diff --git a/jpegObj/__init__.pyc b/jpegObj/__init__.pyc index e6e4406..9df081c 100644 Binary files a/jpegObj/__init__.pyc and b/jpegObj/__init__.pyc differ diff --git a/msteg/StegBase.py b/msteg/StegBase.py index 6c7de39..7afde90 100644 --- a/msteg/StegBase.py +++ b/msteg/StegBase.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): diff --git a/msteg/StegBase.pyc b/msteg/StegBase.pyc index c1170d1..02fbd8d 100644 Binary files a/msteg/StegBase.pyc and b/msteg/StegBase.pyc differ diff --git a/msteg/steganography/F3.pyc b/msteg/steganography/F3.pyc index b3f2d1b..adcd95d 100644 Binary files a/msteg/steganography/F3.pyc and b/msteg/steganography/F3.pyc differ diff --git a/msteg/steganography/F4-simple.py b/msteg/steganography/F4-simple.py new file mode 100644 index 0000000..544932c --- /dev/null +++ b/msteg/steganography/F4-simple.py @@ -0,0 +1,101 @@ +__author__ = 'chunk' + +""" +

This module implements a slight variant of the F4 steganography algorithm +invented by Andreas Westfeld. It embeds a secret message in JPEG +DCT coefficients.

+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: embed_raw_data to embed data + with the F3 algorithm and extract_raw_data 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'" diff --git a/msteg/steganography/F4.py b/msteg/steganography/F4.py index 92aac00..a6e47dc 100644 --- a/msteg/steganography/F4.py +++ b/msteg/steganography/F4.py @@ -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: diff --git a/msteg/steganography/F4.pyc b/msteg/steganography/F4.pyc index 22a4453..5c67fc5 100644 Binary files a/msteg/steganography/F4.pyc and b/msteg/steganography/F4.pyc differ diff --git a/msteg/steganography/F5.py b/msteg/steganography/F5.py index 3a317fa..f45853a 100644 --- a/msteg/steganography/F5.py +++ b/msteg/steganography/F5.py @@ -1,3 +1,5 @@ +__author__ = 'chunk' + """

This module implements the rather sophisticated F5 algorithm which was invented by Andreas Westfeld.

@@ -35,118 +37,134 @@ class F5(StegBase): with the F5 algorithm and extract_raw_data 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): - """

This method embeds arbitrary data into a cover image. - The cover image must be a JPEG.

- -

Parameters: -

    - 
  1. src_cover
    - A valid pathname to an image file which serves as cover image - (the image which the secret image is embedded into).
    2. - - 
  2. src_hidden
    - A valid pathname to an arbitrary file that is supposed to be - embedded into the cover image.
    3. - - 
  3. 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.
    4. - - 
  4. seed
    - A seed for the random number generator that is responsible scattering - the secret data within the cover image.
    5. - - 
  5. param embed_fun
    + 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.
    6. -
-

+ 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): - """

This method extracts secret data from a stego image. It is - (obviously) the inverse operation of embed_raw_data.

+ cov_data, bits_cnt = self._raw_embed(cov_data, hid_data) -

Parameters: -

    - 
  1. src_stego
    - A valid pathname to an image file which serves as stego image.
    2. + 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)) - 
  2. tgt_hidden
    - A pathname denoting where the extracted data should be saved to.
    3. + self.cov_jpeg.setsignal(cov_data, channel='Y') + self.cov_jpeg.Jwrite(tgt_stego) - 
  3. param seed
    - A seed for the random number generator that is responsible scattering - the secret data within the cover image.
    4. + # size_cov = os.path.getsize(tgt_stego) + size_cov = np.size(cov_data) / 8 + size_embedded = np.size(hid_data) - 
  4. 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.
    5. -
- """ + 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' diff --git a/msteg/steganography/F5.pyc b/msteg/steganography/F5.pyc index 0be458d..bc47764 100644 Binary files a/msteg/steganography/F5.pyc and b/msteg/steganography/F5.pyc differ diff --git a/msteg/steganography/LSB.pyc b/msteg/steganography/LSB.pyc index 7cdbd23..70a29cb 100644 Binary files a/msteg/steganography/LSB.pyc and b/msteg/steganography/LSB.pyc differ diff --git a/res/steged.jpg b/res/steged.jpg index f3f6c05..a18b1df 100644 Binary files a/res/steged.jpg and b/res/steged.jpg differ diff --git a/test_jpeg.py b/test_jpeg.py index d18f7b3..b200f24 100644 --- a/test_jpeg.py +++ b/test_jpeg.py @@ -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__ == '__main__': # 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() diff --git a/test_steg.py b/test_steg.py index f5bdcf6..9beb4a5 100644 --- a/test_steg.py +++ b/test_steg.py @@ -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 -- libgit2 0.21.2