F5 half-finished.

Chunk
1 parent 033d3b0d
Showing 13 changed files with 278 additions and 203 deletions Show diff stats
jpegObj/__init__.pyc
msteg/StegBase.py
msteg/StegBase.pyc
msteg/steganography/F3.pyc
msteg/steganography/F4-simple.py
msteg/steganography/F4.py
msteg/steganography/F4.pyc
msteg/steganography/F5.py
msteg/steganography/F5.pyc
msteg/steganography/LSB.pyc
res/steged.jpg
test_jpeg.py
test_steg.py
@@ -102,6 +102,10 @@ class StegBase(object):
             # recovering file size
             header_size = 4 * 8
             size_data, bits_cnt = self._raw_extract(steg_data, header_size)
+            if bits_cnt < header_size:
+                raise Exception("Expected embedded size is %db but actually %db." % (
+                    header_size, bits_cnt))
+
             size_data = bits2bytes(size_data)
             size_hd = 0
             for i in xrange(4):
@@ -0,0 +1,101 @@
+__author__ = 'chunk'
+
+"""
+<p>This module implements a slight variant of the F4 steganography algorithm
+invented by Andreas Westfeld. It embeds a secret message in JPEG
+DCT coefficients.</p>
+It differs from F3 in that even negative and odd positive DCT
+coefficients represent a 1 and odd negative and even positive
+DCT coefficients represent a 0. It also supports permutative strattling
+which is not included in the original description of F4.
+"""
+import time
+import numpy as np
+from msteg.StegBase import StegBase
+from common import *
+
+
+class F4(StegBase):
+    """ This module has two methods: <i>embed_raw_data</i> to embed data
+    with the F3 algorithm and <i>extract_raw_data</i> to extract data
+    which was embedded previously. """
+
+    def __init__(self):
+        """
+        Constructor of the F3 class.
+        """
+        StegBase.__init__(self)
+
+    def embed_raw_data(self, src_cover, src_hidden, tgt_stego):
+        """ This method embeds arbitrary data into a cover image.
+        The cover image must be a JPEG.
+
+        src_cover - A valid pathname to an image file which serves as cover image
+        (the image which the secret image is embedded into).
+
+        src_hidden - A valid pathname to an arbitrary file that is supposed to be
+        embedded into the cover image.
+
+        tgt_stego - Target pathname of the resulting stego image. You should save to a
+        PNG or another lossless format, because many LSBs don't survive
+        lossy compression.
+        """
+        self.t0 = time.time()
+        StegBase._post_embed_actions(self, src_cover, src_hidden, tgt_stego)
+
+    def extract_raw_data(self, src_steg, tgt_hidden):
+        """ This method extracts secret data from a stego image. It is
+        (obviously) the inverse operation of embed_raw_data.
+
+        src_stego - A valid pathname to an image file which serves as stego image.
+
+        tgt_hidden - A pathname denoting where the extracted data should be saved to.
+        """
+        self.t0 = time.time()
+        StegBase._post_extract_actions(self, src_steg, tgt_hidden)
+
+    def _raw_embed(self, cov_data, hid_data, status_begin=0):
+        """
+        cov_data - 4-D numpy.int32 array
+        hid_data - 1-D numpy.uint8 array
+        """
+        hid_data = bytes2bits(hid_data)
+        i = 0
+        cnt = -1
+        for x in np.nditer(cov_data, op_flags=['readwrite']):
+            cnt = cnt + 1
+            if x == 0 or cnt % 64 == 0: continue
+
+            m = (hid_data[i] & 1)
+            if x > 0 and x & 1 != m:
+                x[...] -= 1
+            elif x < 0 and x & 1 == m:
+                x[...] += 1
+            if x == 0: continue
+            i += 1
+            if i == hid_data.size: break
+
+        return cov_data
+
+    def _raw_extract(self, steg_data, num_bits):
+        """
+        Just a small helper function to extract hidden data.
+        """
+        hid_data = np.zeros(num_bits, np.uint8)
+        j = 0
+        cnt = -1
+        for x in np.nditer(steg_data):
+            cnt = cnt + 1
+            if x == 0 or cnt % 64 == 0: continue
+            if j >= num_bits: break
+            if x > 0:
+                hid_data[j] = x & 1
+            else:
+                hid_data[j] = (x & 1) ^ 1
+
+            j = j + 1
+
+        return hid_data
+
+    def __str__(self):
+        return "F4'"
@@ -74,6 +74,10 @@ class F4(StegBase):
             # recovering file size
             header_size = 4 * 8
             size_data, bits_cnt = self._raw_extract(steg_data, header_size)
+            if bits_cnt < header_size:
+                raise Exception("Expected embedded size is %db but actually %db." % (
+                    header_size, bits_cnt))
+
             size_data = bits2bytes(size_data)
             size_hd = 0
@@ -120,6 +124,7 @@ class F4(StegBase):
             if x == 0: continue
             i += 1
             if i == hid_data.size: break
+
         return cov_data, i
     def _raw_extract(self, steg_data, num_bits):
@@ -127,6 +132,7 @@ class F4(StegBase):
         Just a small helper function to extract hidden data.
         steg_data - 1-D numpy.int16 array (permunated)
         """
+
         hid_data = np.zeros(num_bits, np.uint8)
         j = 0
         for x in steg_data:
+__author__ = 'chunk'
+
 """
 <p>This module implements the rather sophisticated F5 algorithm which was
 invented by Andreas Westfeld.</p>
@@ -35,118 +37,134 @@ class F5(StegBase):
     with the F5 algorithm and <i>extract_raw_data</i> to extract data
     which was embedded previously. """
-    def __init__(self, key=sample_key):
+    def __init__(self, key=sample_key, k=None):
         """
         Constructor of the F5 class.
         """
         StegBase.__init__(self, key)
         self._embed_fun = None
         self.default_embedding = True
-        self.steg_ind = -1
-        self.excess_bits = None
+
         # needed because k is embedded separately
-        self.cov_ind = -1
-        self.k_coeff = -1
-
-    @describe_annotate_convert((None, None, ident),
-                               ("cover image", ImagePath, str),
-                               ("hidden data", FilePath, str),
-                               ("stego image", NewFilePath, str),
-                               ("seed", int, int),
-                               ("embedding behavior",
-                                ['Default', 'F3', 'JSteg'], str))
-    def embed_raw_data(self, src_cover, src_hidden, tgt_stego, seed,
-                       embed_fun):
-        """<p>This method embeds arbitrary data into a cover image.
-        The cover image must be a JPEG.</p>
-
-        <p>Parameters:
-        <ol>
-        <li><pre>src_cover</pre>
-        A valid pathname to an image file which serves as cover image
-        (the image which the secret image is embedded into).</li>
-
-        <li><pre>src_hidden</pre>
-        A valid pathname to an arbitrary file that is supposed to be
-        embedded into the cover image.</li>
-
-        <li><pre>tgt_stego</pre>
-        Target pathname of the resulting stego image. You should save to
-        a PNG or another lossless format, because many LSBs don't survive
-        lossy compression.</li>
-
-        <li><pre>seed</pre>
-        A seed for the random number generator that is responsible scattering
-        the secret data within the cover image.</li>
-
-        <li><pre>param embed_fun</pre>
+        self.k_coeff = k
+
+
+    def _get_cov_data(self, img_path):
+        """
+        Returns DCT coefficients of the cover image.
+        """
+        self.cov_jpeg = jpegObj.Jpeg(img_path, key=self.key)
+
+        cov_data = self.cov_jpeg.getsignal(channel='Y')
+        self.cov_data = np.array(cov_data, dtype=np.int16)
+        return self.cov_data
+
+    def embed_raw_data(self, src_cover, src_hidden, tgt_stego, embed_fun='Default'):
+        """This method embeds arbitrary data into a cover image.
+        The cover image must be a JPEG.
+
+        @param embed_fun:
         Specifies which embedding function should be used. Must be one of
         'Default', 'F3', 'Jsteg'. If 'Default' is selected, the algorithm uses
         the same behavior as Westfeld's implementation, i.e. decrementing
         absolute values for n > 1 (F3) and using F4 in the special case n = 1.
-        Selecting F3 or JSteg results in using that scheme for all n.</li>
-        </ol>
-        </p>
+        Selecting F3 or JSteg results in using that scheme for all n.
         """
         self.t0 = time.time()
-        self.seed = seed
+
         if embed_fun == 'F3':
             self._embed_fun = self._f3_embed
             self.default_embedding = False
-        elif embed_fun == 'JSteg':
+        elif embed_fun == 'JSteg' or embed_fun == 'LSB':
             self._embed_fun = self._jsteg_embed
             self.default_embedding = False
-        elif embed_fun == 'Default':
+        else:
             self._embed_fun = self._f3_embed
             self.default_embedding = True
-        self.cov_ind = -1
-        JPEGSteg._post_embed_actions(self, src_cover, src_hidden, tgt_stego)
+        try:
+            cov_data = self._get_cov_data(src_cover)
+            hid_data = self._get_hid_data(src_hidden)
+            # print hid_data.dtype,type(hid_data),hid_data.tolist()
-    @describe_annotate_convert((None, None, ident),
-                               ("stego image", ImagePath, str),
-                               ("hidden data", NewFilePath, str),
-                               ("seed", int, int),
-                               ("embedding behavior", ['Default', 'F3/JSteg'],
-                                str))
-    def extract_raw_data(self, src_steg, tgt_hidden, seed, embed_fun):
-        """<p>This method extracts secret data from a stego image. It is
-        (obviously) the inverse operation of embed_raw_data.</p>
+            cov_data, bits_cnt = self._raw_embed(cov_data, hid_data)
-        <p>Parameters:
-        <ol>
-        <li><pre>src_stego</pre>
-        A valid pathname to an image file which serves as stego image.</li>
+            if bits_cnt < np.size(hid_data) * 8:
+                raise Exception("Expected embedded size is %db but actually %db." % (
+                    np.size(hid_data) * 8, bits_cnt))
-        <li><pre>tgt_hidden</pre>
-        A pathname denoting where the extracted data should be saved to.</li>
+            self.cov_jpeg.setsignal(cov_data, channel='Y')
+            self.cov_jpeg.Jwrite(tgt_stego)
-        <li><pre>param seed</pre>
-        A seed for the random number generator that is responsible scattering
-        the secret data within the cover image.</li>
+            # size_cov = os.path.getsize(tgt_stego)
+            size_cov = np.size(cov_data) / 8
+            size_embedded = np.size(hid_data)
-        <li><pre>param embed_fun</pre>
-        Specifies which embedding function should be used. Must be one of
-        'Default', 'F3', 'JSteg'. If 'Default' is selected, the algorithm uses
-        the same behavior as  Westfeld's implementation, i.e. decrementing
-        absolute values for n > 1 (F3) and using F4 in the special case n = 1.
-        Selecting F3 or JSteg results in using that scheme for all n.</li>
-        </ol></pre>
-        """
+            self._display_stats("embedded", size_cov, size_embedded,
+                                time.time() - self.t0)
+        except TypeError as e:
+            raise e
+        except Exception as expt:
+            print "Exception when embedding!"
+            raise
+
+
+    def extract_raw_data(self, src_steg, tgt_hidden, embed_fun='Default'):
         self.t0 = time.time()
-        self.seed = seed
-        self.steg_ind = -1
-        if embed_fun == 'F3/JSteg':
+
+        if embed_fun == 'F3':
+            self._embed_fun = self._f3_embed
+            self.default_embedding = False
+        elif embed_fun == 'JSteg' or embed_fun == 'LSB':
+            self._embed_fun = self._jsteg_embed
             self.default_embedding = False
-        elif embed_fun == 'Default':
+        else:
+            self._embed_fun = self._f3_embed
             self.default_embedding = True
-        # excess bits occur when the size of extracted data is not a multiple
-        # of k. if excess bits are available, they are prepended to hidden data
-        self.excess_bits = None
+        try:
+            steg_data = self._get_cov_data(src_steg)
+            # emb_size = os.path.getsize(src_steg)
+            emb_size = np.size(steg_data) / 8
+
+            # recovering file size
+            header_size = 4 * 8
+            size_data, bits_cnt = self._raw_extract(steg_data, header_size)
+
+            if bits_cnt < header_size:
+                raise Exception("Expected embedded size is %db but actually %db." % (
+                    header_size, bits_cnt))
+
+            size_data = bits2bytes(size_data[:header_size])
+            print size_data
+
+            size_hd = 0
+            for i in xrange(4):
+                size_hd += size_data[i] * 256 ** i
+
+            raw_size = size_hd * 8
+
+            if raw_size > np.size(steg_data):
+                raise Exception("Supposed secret data too large for stego image.")
+
+            hid_data, bits_cnt = self._raw_extract(steg_data, raw_size)
+
+            if bits_cnt < raw_size:
+                raise Exception("Expected embedded size is %db but actually %db." % (
+                    raw_size, bits_cnt))
+
+            hid_data = bits2bytes(hid_data)
+            # print hid_data.dtype,type(hid_data),hid_data.tolist()
+            hid_data[4:].tofile(tgt_hidden)
+
+            self._display_stats("extracted", emb_size,
+                                np.size(hid_data),
+                                time.time() - self.t0)
+        except Exception as expt:
+            print "Exception when extracting!"
+            raise
-        JPEGSteg._post_extract_actions(self, src_steg, tgt_hidden)
     def _embed_k(self, cov_data, hid_data):
         np.random.seed(self.seed)
@@ -218,153 +236,89 @@ class F5(StegBase):
     def _jsteg_embed(self, cov_data, ind):
         m = 1 ^ (cov_data[ind] & 1)
-        cov_data[ind] = (cov_data[ind] & 0xffffe) | m
+        cov_data[ind] = (cov_data[ind] & 0xfffffffe) | m
-    def _raw_embed(self, cov_data, hid_data, status_begin=0):
+    def _raw_embed(self, cov_data, hid_data):
         k = self.k_coeff
         n = (1 << k) - 1
+
         if n == 1 and self.default_embedding:
-            # in case k = n = 1, Westfeld's implementation uses F4 for
-            # embedding. Therefore, if 'default' embedding has been selected
-            # we will do the same
-            f4 = F4(self.ui, self.core)
-            f4.seed = self.seed
-            f4.dct_p = self.dct_p
-            f4.cov_ind = self.cov_ind
-            cov_data = f4._raw_embed(cov_data, hid_data, 30)
-            return cov_data
-
-        cov_ind = self.cov_ind  # preventing RSI by writing 'self' less often
-        hid_ind = 0
-        remaining_bits = hid_data.size
-        hid_size = float(hid_data.size)
-        dct_p = self.dct_p
-
-        update_cnt = int(hid_size / (70.0 * k))
-        while remaining_bits > 0:
-            if update_cnt == 0:
-                self._set_progress(30 + int(((
-                                                 hid_size - remaining_bits) / hid_size) * 70))
-                update_cnt = int(hid_size / (70.0 * k))
-            update_cnt -= 1
-            msg_chunk_size = min(remaining_bits, k)
-            msg_chunk = np.zeros(k, np.int8)
-            cov_chunk = np.zeros(n, np.int32)
-            msg_chunk[0:msg_chunk_size] = hid_data[hid_ind:hid_ind +
-                                                           msg_chunk_size]
-            hid_ind += k
-
-            # get n DCT coefficients
-            for i in xrange(n):
-                cov_ind += 1
-                while cov_data[dct_p[cov_ind]] == 0 \
-                        or dct_p[cov_ind] % 64 == 0:
-                    cov_ind += 1
-                cov_chunk[i] = dct_p[cov_ind]
+            # in case k = n = 1, Westfeld's implementation uses F4 for embedding.
+            f4 = F4(key=self.key)
+            return f4._raw_embed(cov_data, hid_data)
+
+        hid_data = bytes2bits(hid_data)
+        if len(hid_data) % k != 0:
+            hid_data = list(hid_data) + [0 for x in range(k - len(hid_data) % k)]
+
+        ind_nonzero = np.nonzero(cov_data)[0]
+
+        if np.size(ind_nonzero) * k < len(hid_data) * n:
+            raise Exception("Supposed secret data too large for stego image.")
+
+        ind_cov = 0
+        for ind_hid in range(0, len(hid_data), k):
+            msg_chunk = hid_data[ind_hid:ind_hid + k]
+            cov_chunk = ind_nonzero[ind_cov:ind_cov + n]
+            ind_cov += n
             success = False
-            while not success:  # loop necessary because of shrinkage
+            while not success:
                 h = 0
                 for i in xrange(n):
                     h ^= ((cov_data[cov_chunk[i]] & 1) * (i + 1))
                 scalar_x = 0
                 for i in xrange(k):
-                    scalar_x = (scalar_x << 1) + msg_chunk[i]
+                    scalar_x = (scalar_x << 1) + msg_chunk[
+                        i]  # N.B. hid_data[0]:high (that is x2), hid_data[1]:low (that is x1)
                 s = scalar_x ^ h
                 if s != 0:
                     self._embed_fun(cov_data, cov_chunk[s - 1])
                 else:
                     break
-                if cov_data[cov_chunk[s - 1]] == 0:  # test for shrinkage
-                    cov_chunk[s - 1:-1] = cov_chunk[s:]  # adjusting
-                    cov_ind += 1
-                    while cov_data[dct_p[cov_ind]] == 0 or \
-                                            dct_p[cov_ind] % 64 == 0:
-                        cov_ind += 1
-                    cov_chunk[n - 1] = dct_p[cov_ind]
+                if cov_data[cov_chunk[s - 1]] == 0:  # shrinkage
+                    cov_chunk[s - 1:-1] = cov_chunk[s:]
+                    cov_chunk[-1] = ind_nonzero[ind_cov]
+                    ind_cov += 1
                 else:
                     success = True
-            remaining_bits -= k
-
-        self.k_coeff = -1  # prevent k being read from this instance
-        return cov_data
+        return cov_data, ind_hid + k
-    def _raw_extract(self, num_bits):
+    def _raw_extract(self, steg_data, num_bits):
         k = self.k_coeff
         n = (1 << k) - 1
-        if self.is_header == None:
-            self.is_header = True
-        if n == 1 and self.default_embedding:
-            f4 = F4(self.ui, self.core)
-            f4.seed = self.seed
-            f4.dct_p = self.dct_p
-            f4.steg_data = self.steg_data
-            f4.is_header = self.is_header
-            f4.steg_ind = self.steg_ind
-            hid_data = f4._raw_extract(num_bits)
-            self.steg_ind = f4.steg_ind
-            self.is_header = False
-            return hid_data
-        remaining_bits = num_bits
-        hid_data = np.zeros(num_bits, np.uint8)
-        hid_ind = 0
-
-        dct_p = self.dct_p
-
-        is_header = False  # signals whether or not extracting header
-
-        if self.excess_bits != None:
-            hid_data[hid_ind:hid_ind + self.excess_bits.size] = \
-                self.excess_bits
-            hid_ind += self.excess_bits.size
-            remaining_bits -= self.excess_bits.size
-
-        curr_chunk = np.zeros(k, np.uint8)
-
-        update_cnt = int(num_bits / (100.0 * k))
-
-        while remaining_bits > 0:
-            if update_cnt == 0 and not is_header:
-                self._set_progress(int(((float(num_bits) \
-                                         - remaining_bits) / num_bits) * 100))
-                update_cnt = int(num_bits / (100.0 * k))
+        if n == 1 and self.default_embedding:
+            f4 = F4(key=self.key)
+            return f4._raw_extract(steg_data, num_bits)
-            update_cnt -= 1
+        num_bits_ceil = num_bits
+        if num_bits % k != 0:
+            num_bits_ceil = k * (num_bits / k + 1)
-            steg_chunk = [0 for i in xrange(n)]
-            for i in xrange(n):
-                self.steg_ind += 1
-                while self.steg_data[dct_p[self.steg_ind]] == 0 or \
-                                        dct_p[self.steg_ind] % 64 == 0:
-                    self.steg_ind += 1
-                steg_chunk[i] = self.steg_data[dct_p[self.steg_ind]]
+        hid_data = np.zeros(num_bits_ceil, np.uint8)
+        curr_chunk = np.zeros(k, np.uint8)
+        steg_data = steg_data[np.nonzero(steg_data)]
+        ind_hid = 0
+        for ind_cov in range(0, len(steg_data), n):
+            steg_chunk = steg_data[ind_cov:ind_cov + n]
             h = 0  # hash value
             for i in xrange(n):
                 h ^= ((steg_chunk[i] & 1) * (i + 1))
             for i in xrange(k):
-                curr_chunk[k - i - 1] = h % 2
-                h /= 2
-
-            l = min(k, remaining_bits)
-            for i in xrange(l):
-                hid_data[hid_ind] = curr_chunk[i]
-                hid_ind += 1
+                curr_chunk[k - i - 1] = h & 1  # N.B. hid_data[0]:high (that is x2), hid_data[1]:low (that is x1)
+                h >>= 1
-            # save excess bits (for later calls)
-            if k > remaining_bits:
-                self.excess_bits = curr_chunk[remaining_bits:]
-            else:
-                self.excess_bits = None
+            hid_data[ind_hid:ind_hid + k] = curr_chunk[0:k]
+            ind_hid += k
-            remaining_bits -= k
+            if ind_hid >= num_bits_ceil: break
-        self.is_header = False
-        return hid_data
+        return hid_data, num_bits_ceil
     def __str__(self):
         return 'F5'
@@ -17,7 +17,9 @@ sample = [[7, 12, 14, -12, 1, 0, -1, 0],
           [0, 0, 0, 0, 0, 0, 0, 0],
           [0, 0, 0, 0, 0, 0, 0, 0]]
-sample_key = [46812L, 20559L, 31360L, 16681L, 27536L, 39553L, 5427L, 63029L, 56572L, 36476L, 25695L, 61908L, 63014L, 5908L, 59816L, 56765L]
+sample_key = [46812L, 20559L, 31360L, 16681L, 27536L, 39553L, 5427L, 63029L, 56572L, 36476L, 25695L, 61908L, 63014L,
+              5908L, 59816L, 56765L]
+
 def diffblock(c1, c2):
     diff = False
@@ -32,6 +34,7 @@ def diffblock(c1, c2):
 def diffblocks(a, b):
     diff = False
+    cnt = 0
     for comp in range(a.image_components):
         xmax, ymax = a.Jgetcompdim(comp)
         for y in range(ymax):
@@ -39,7 +42,8 @@ def diffblocks(a, b):
                 if a.Jgetblock(x, y, comp) != b.Jgetblock(x, y, comp):
                     print("blocks({},{}) in component {} not match".format(y, x, comp))
                     diff = True
-    return diff
+                    cnt += 1
+    return diff, cnt
 def test_setblocks():
@@ -131,17 +135,18 @@ def test_rawfile():
         raw[i] = raw_size % 256
         raw_size /= 256
     raw = np.array(raw)
-    print raw.shape,raw
+    print raw.shape, raw
     # print raw.size
     # print bytes2bits(raw)
+
 def test_bitbyte():
     timer.mark()
     raw = np.fromfile("res/test4.jpg", np.uint8)
     timer.report()
     print raw
-    bitsraw =  bytes2bits(raw)
+    bitsraw = bytes2bits(raw)
     # bitsraw = bitsraw[:24]
     timer.report()
     print bitsraw
@@ -150,6 +155,7 @@ def test_bitbyte():
     timer.report()
     print bytesraw
+
 def test_iter():
     imb = jpegObj.Jpeg("res/test4.jpg")
     blocks = imb.getCoefBlocks(channel='Y')
@@ -186,12 +192,12 @@ if __name__ == &#39;__main__&#39;:
     # test_bitbyte()
-    ima = jpegObj.Jpeg("res/test3.jpg",key=sample_key)
+    ima = jpegObj.Jpeg("res/test3.jpg", key=sample_key)
     # imb = jpegObj.Jpeg("res/new.jpg",key=sample_key)
-    imc = jpegObj.Jpeg("res/steged.jpg",key=sample_key)
+    imc = jpegObj.Jpeg("res/steged.jpg", key=sample_key)
     print ima.Jgetcompdim(0)
-    print ima.getkey(),imc.getkey()
-    diffblocks(ima, imc)
+    print ima.getkey(), imc.getkey()
+    print diffblocks(ima, imc)
     # c1 = ima.getCoefBlocks()
     # c2 =  imb.getCoefBlocks()
@@ -7,7 +7,7 @@ import pylab as plt
 import mjpeg
 import mjsteg
 import jpegObj
-from  msteg.steganography import F3, F4, LSB
+from  msteg.steganography import LSB, F3, F4, F5
 from common import *
@@ -22,13 +22,17 @@ sample = [[7, 12, 14, -12, 1, 0, -1, 0],
           [0, 0, 0, 0, 0, 0, 0, 0],
           [0, 0, 0, 0, 0, 0, 0, 0]]
-sample_key = [46812L, 20559L, 31360L, 16681L, 27536L, 39553L, 5427L, 63029L, 56572L, 36476L, 25695L, 61908L, 63014L, 5908L, 59816L, 56765L]
+sample_key = [46812L, 20559L, 31360L, 16681L, 27536L, 39553L, 5427L, 63029L, 56572L, 36476L, 25695L, 61908L, 63014L,
+              5908L, 59816L, 56765L]
 txtsample = [116, 104, 105, 115, 32, 105, 115, 32, 116, 111, 32, 98, 101, 32, 101, 109, 98, 101, 100, 101, 100, 46, 10]
 if __name__ == '__main__':
-    f3test = F4.F4()
+    # f3test = F4.F4(sample_key)
+    f3test = F5.F5(sample_key, 3)
     f3test.embed_raw_data("res/test3.jpg", "res/embeded", "res/steged.jpg")
+
+    # f3test2 = F4.F4(sample_key)
     f3test.extract_raw_data("res/steged.jpg", "res/extracted")
     print f3test.get_key()
     pass
@@ -0,0 +1,101 @@		@@ -0,0 +1,101 @@
	1	+__author__ = 'chunk'
	2	+
	3	+"""
	4	+<p>This module implements a slight variant of the F4 steganography algorithm
	5	+invented by Andreas Westfeld. It embeds a secret message in JPEG
	6	+DCT coefficients.</p>
	7	+It differs from F3 in that even negative and odd positive DCT
	8	+coefficients represent a 1 and odd negative and even positive
	9	+DCT coefficients represent a 0. It also supports permutative strattling
	10	+which is not included in the original description of F4.
	11	+"""
	12	+import time
	13	+import numpy as np
	14	+from msteg.StegBase import StegBase
	15	+from common import *
	16	+
	17	+
	18	+class F4(StegBase):
	19	+ """ This module has two methods: <i>embed_raw_data</i> to embed data
	20	+ with the F3 algorithm and <i>extract_raw_data</i> to extract data
	21	+ which was embedded previously. """
	22	+
	23	+ def __init__(self):
	24	+ """
	25	+ Constructor of the F3 class.
	26	+ """
	27	+ StegBase.__init__(self)
	28	+
	29	+ def embed_raw_data(self, src_cover, src_hidden, tgt_stego):
	30	+ """ This method embeds arbitrary data into a cover image.
	31	+ The cover image must be a JPEG.
	32	+
	33	+ src_cover - A valid pathname to an image file which serves as cover image
	34	+ (the image which the secret image is embedded into).
	35	+
	36	+ src_hidden - A valid pathname to an arbitrary file that is supposed to be
	37	+ embedded into the cover image.
	38	+
	39	+ tgt_stego - Target pathname of the resulting stego image. You should save to a
	40	+ PNG or another lossless format, because many LSBs don't survive
	41	+ lossy compression.
	42	+ """
	43	+ self.t0 = time.time()
	44	+ StegBase._post_embed_actions(self, src_cover, src_hidden, tgt_stego)
	45	+
	46	+ def extract_raw_data(self, src_steg, tgt_hidden):
	47	+ """ This method extracts secret data from a stego image. It is
	48	+ (obviously) the inverse operation of embed_raw_data.
	49	+
	50	+ src_stego - A valid pathname to an image file which serves as stego image.
	51	+
	52	+ tgt_hidden - A pathname denoting where the extracted data should be saved to.
	53	+ """
	54	+ self.t0 = time.time()
	55	+ StegBase._post_extract_actions(self, src_steg, tgt_hidden)
	56	+
	57	+ def _raw_embed(self, cov_data, hid_data, status_begin=0):
	58	+ """
	59	+ cov_data - 4-D numpy.int32 array
	60	+ hid_data - 1-D numpy.uint8 array
	61	+ """
	62	+ hid_data = bytes2bits(hid_data)
	63	+ i = 0
	64	+ cnt = -1
	65	+ for x in np.nditer(cov_data, op_flags=['readwrite']):
	66	+ cnt = cnt + 1
	67	+ if x == 0 or cnt % 64 == 0: continue
	68	+
	69	+ m = (hid_data[i] & 1)
	70	+ if x > 0 and x & 1 != m:
	71	+ x[...] -= 1
	72	+ elif x < 0 and x & 1 == m:
	73	+ x[...] += 1
	74	+ if x == 0: continue
	75	+ i += 1
	76	+ if i == hid_data.size: break
	77	+
	78	+ return cov_data
	79	+
	80	+ def _raw_extract(self, steg_data, num_bits):
	81	+ """
	82	+ Just a small helper function to extract hidden data.
	83	+ """
	84	+ hid_data = np.zeros(num_bits, np.uint8)
	85	+ j = 0
	86	+ cnt = -1
	87	+ for x in np.nditer(steg_data):
	88	+ cnt = cnt + 1
	89	+ if x == 0 or cnt % 64 == 0: continue
	90	+ if j >= num_bits: break
	91	+ if x > 0:
	92	+ hid_data[j] = x & 1
	93	+ else:
	94	+ hid_data[j] = (x & 1) ^ 1
	95	+
	96	+ j = j + 1
	97	+
	98	+ return hid_data
	99	+
	100	+ def __str__(self):
	101	+ return "F4'"