fz0x1/Stegano
1
0
Fork 0
mirror of https://github.com/cedricbonhomme/Stegano.git synced 2025-05-12 17:18:30 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge branch 'unicode'

Browse source
This commit is contained in:
Cédric Bonhomme 2017-05-04 13:08:33 +02:00
commit 13f0fb8086
7 changed files with 89 additions and 39 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
setup.py
View file

@ -36,7 +36,7 @@ with open('CHANGELOG.rst', 'r') as f:
setup(
name='Stegano',
version='0.6.9',
version='0.6.10',
author='Cédric Bonhomme',
author_email='cedric@cedricbonhomme.org',
packages=packages,

16
stegano/lsb/lsb.py
View file

@ -20,8 +20,9 @@
# along with this program. If not, see <http://www.gnu.org/licenses/>
__author__ = "Cedric Bonhomme"
__version__ = "$Revision: 0.2.2 $"
__version__ = "$Revision: 0.3 $"
__date__ = "$Date: 2016/08/04 $"
__revision__ = "$Date: 2017/05/04 $"
__license__ = "GPLv3"
import sys
@ -30,7 +31,10 @@ from PIL import Image
from stegano import tools
def hide(input_image_file: str, message, auto_convert_rgb: bool = False):
def hide(input_image_file: str,
message,
encoding='UTF-8',
auto_convert_rgb: bool = False):
"""Hide a message (string) in an image with the
LSB (Least Significant Bit) technique.
"""
@ -53,7 +57,7 @@ def hide(input_image_file: str, message, auto_convert_rgb: bool = False):
index = 0
message = str(message_length) + ":" + str(message)
message_bits = "".join(tools.a2bits_list(message))
message_bits = "".join(tools.a2bits_list(message, encoding))
message_bits += '0' * ((3 - (len(message_bits) % 3)) % 3)
npixels = width * height
@ -90,7 +94,7 @@ def hide(input_image_file: str, message, auto_convert_rgb: bool = False):
return encoded
def reveal(input_image_file):
def reveal(input_image_file, encoding='UTF-8'):
"""Find a message in an image (with the LSB technique).
"""
img = Image.open(input_image_file)
@ -106,9 +110,9 @@ def reveal(input_image_file):
if img.mode == 'RGBA':
pixel = pixel[:3] # ignore the alpha
for color in pixel:
buff += (color&1)<<(7-count)
buff += (color&1)<<(tools.ENCODINGS[encoding]-1 - count)
count += 1
if count == 8:
if count == tools.ENCODINGS[encoding]:
bitab.append(chr(buff))
buff, count = 0, 0
if bitab[-1] == ":" and limit == None:

18
stegano/lsbset/lsbset.py
View file

@ -20,9 +20,9 @@
# along with this program. If not, see <http://www.gnu.org/licenses/>
__author__ = "Cedric Bonhomme"
__version__ = "$Revision: 0.4.2 $"
__version__ = "$Revision: 0.5 $"
__date__ = "$Date: 2016/03/13 $"
__revision__ = "$Date: 2016/05/22 $"
__revision__ = "$Date: 2017/05/04 $"
__license__ = "GPLv3"
import sys
@ -32,7 +32,11 @@ from PIL import Image
from stegano import tools
from . import generators
def hide(input_image_file, message, generator, auto_convert_rgb=False):
def hide(input_image_file,
message,
generator,
encoding='UTF-8',
auto_convert_rgb=False):
"""Hide a message (string) in an image with the
LSB (Least Significant Bit) technique.
"""
@ -55,7 +59,7 @@ def hide(input_image_file, message, generator, auto_convert_rgb=False):
index = 0
message = str(message_length) + ":" + str(message)
message_bits = "".join(tools.a2bits_list(message))
message_bits = "".join(tools.a2bits_list(message, encoding))
message_bits += '0' * ((3 - (len(message_bits) % 3)) % 3)
npixels = width * height
@ -90,7 +94,7 @@ def hide(input_image_file, message, generator, auto_convert_rgb=False):
return encoded
def reveal(input_image_file, generator):
def reveal(input_image_file, generator, encoding='UTF-8'):
"""Find a message in an image (with the LSB technique).
"""
img = Image.open(input_image_file)
@ -104,9 +108,9 @@ def reveal(input_image_file, generator):
generated_number = next(generator)
# color = [r, g, b]
for color in img_list[generated_number]:
buff += (color&1)<<(7-count)
buff += (color&1)<<(tools.ENCODINGS[encoding]-1 - count)
count += 1
if count == 8:
if count == tools.ENCODINGS[encoding]:
bitab.append(chr(buff))
buff, count = 0, 0
if bitab[-1] == ":" and limit == None:

13
stegano/tools.py
View file

@ -20,9 +20,9 @@
# along with this program. If not, see <http://www.gnu.org/licenses/>
__author__ = "Cedric Bonhomme"
__version__ = "$Revision: 0.2 $"
__version__ = "$Revision: 0.3 $"
__date__ = "$Date: 2010/10/01 $"
__revision__ = "$Date: 2016/08/03 $"
__revision__ = "$Date: 2017/05/04 $"
__license__ = "GPLv3"
import base64
@ -30,6 +30,11 @@ import itertools
from typing import List, Iterator, Tuple, Union
from functools import reduce
ENCODINGS = {
'UTF-8': 8,
'UTF-32LE': 32
}
def a2bits(chars: str) -> str:
"""Converts a string to its bits representation as a string of 0's and 1's.
@ -38,7 +43,7 @@ def a2bits(chars: str) -> str:
"""
return bin(reduce(lambda x, y : (x<<8)+y, (ord(c) for c in chars), 1))[3:]
def a2bits_list(chars: str) -> List[str]:
def a2bits_list(chars: str, encoding: str ='UTF-8') -> List[str]:
"""Convert a string to its bits representation as a list of 0's and 1's.
>>> a2bits_list("Hello World!")
@ -57,7 +62,7 @@ def a2bits_list(chars: str) -> List[str]:
>>> "".join(a2bits_list("Hello World!"))
'010010000110010101101100011011000110111100100000010101110110111101110010011011000110010000100001'
"""
return [bin(ord(x))[2:].rjust(8,"0") for x in chars]
return [bin(ord(x))[2:].rjust(ENCODINGS[encoding],"0") for x in chars]
def bs(s: int) -> str:
"""Converts an int to its bits representation as a string of 0's and 1's.

37
tests/test_lsb.py
View file

@ -20,9 +20,9 @@
# along with this program. If not, see <http://www.gnu.org/licenses/>
__author__ = "Cedric Bonhomme"
__version__ = "$Revision: 0.2 $"
__version__ = "$Revision: 0.3 $"
__date__ = "$Date: 2016/04/12 $"
__revision__ = "$Date: 2017/02/22 $"
__revision__ = "$Date: 2017/05/04 $"
__license__ = "GPLv3"
import io
@ -43,45 +43,54 @@ class TestLSB(unittest.TestCase):
secret = lsb.hide("./tests/sample-files/Lenna.png", "")
def test_hide_and_reveal(self):
messages_to_hide = ["a", "foo", "Hello World!", ":Python:"]
messages_to_hide = ['a', 'foo', 'Hello World!', ':Python:']
for message in messages_to_hide:
secret = lsb.hide("./tests/sample-files/Lenna.png", message)
secret.save("./image.png")
clear_message = lsb.reveal("./image.png")
self.assertEqual(message, clear_message)
def test_hide_and_reveal_UTF32LE(self):
messages_to_hide = 'I love 🍕 and 🍫!'
secret = lsb.hide("./tests/sample-files/Lenna.png",
messages_to_hide, 'UTF-32LE')
secret.save("./image.png")
clear_message = lsb.reveal("./image.png", 'UTF-32LE')
self.assertEqual(messages_to_hide, clear_message)
def test_with_transparent_png(self):
messages_to_hide = ["a", "foo", "Hello World!", ":Python:"]
messages_to_hide = ['🍕', 'a', 'foo', 'Hello World!', ':Python:']
for message in messages_to_hide:
secret = lsb.hide("./tests/sample-files/transparent.png", message)
secret = lsb.hide("./tests/sample-files/transparent.png",
message, 'UTF-32LE')
secret.save("./image.png")
clear_message = lsb.reveal("./image.png")
clear_message = lsb.reveal("./image.png", 'UTF-32LE')
self.assertEqual(message, clear_message)
@patch('builtins.input', return_value='y')
def test_manual_convert_rgb(self, input):
message_to_hide = "I love 🍕 and 🍫!"
message_to_hide = 'I love 🍕 and 🍫!'
secret = lsb.hide("./tests/sample-files/Lenna-grayscale.png",
message_to_hide)
message_to_hide, 'UTF-32LE')
@patch('builtins.input', return_value='n')
def test_refuse_convert_rgb(self, input):
message_to_hide = "I love 🍕 and 🍫!"
message_to_hide = 'I love 🍕 and 🍫!'
with self.assertRaises(Exception):
secret = lsb.hide("./tests/sample-files/Lenna-grayscale.png",
message_to_hide)
message_to_hide, 'UTF-32LE')
def test_auto_convert_rgb(self):
message_to_hide = "I love 🍕 and 🍫!"
message_to_hide = 'I love 🍕 and 🍫!'
secret = lsb.hide("./tests/sample-files/Lenna-grayscale.png",
message_to_hide, True)
message_to_hide, 'UTF-32LE', True)
def test_with_text_file(self):
text_file_to_hide = "./tests/sample-files/lorem_ipsum.txt"
text_file_to_hide = './tests/sample-files/lorem_ipsum.txt'
with open(text_file_to_hide) as f:
message = f.read()
secret = lsb.hide("./tests/sample-files/Lenna.png", message)

25
tests/test_lsbset.py
View file

@ -20,9 +20,9 @@
# along with this program. If not, see <http://www.gnu.org/licenses/>
__author__ = "Cedric Bonhomme"
__version__ = "$Revision: 0.3 $"
__version__ = "$Revision: 0.4 $"
__date__ = "$Date: 2016/04/13 $"
__revision__ = "$Date: 2017/02/22 $"
__revision__ = "$Date: 2017/05/04 $"
__license__ = "GPLv3"
import os
@ -54,6 +54,18 @@ class TestLSBSet(unittest.TestCase):
self.assertEqual(message, clear_message)
def test_hide_and_reveal_UTF32LE(self):
messages_to_hide = 'I love 🍕 and 🍫!'
secret = lsbset.hide("./tests/sample-files/Lenna.png",
messages_to_hide,
generators.eratosthenes(),
'UTF-32LE')
secret.save("./image.png")
clear_message = lsbset.reveal("./image.png", generators.eratosthenes(),
'UTF-32LE')
self.assertEqual(messages_to_hide, clear_message)
def test_with_transparent_png(self):
messages_to_hide = ["a", "foo", "Hello World!", ":Python:"]
for message in messages_to_hide:
@ -68,21 +80,22 @@ class TestLSBSet(unittest.TestCase):
@patch('builtins.input', return_value='y')
def test_manual_convert_rgb(self, input):
message_to_hide = "I love 🍕 and 🍫!"
message_to_hide = "Hello World!"
secret = lsbset.hide("./tests/sample-files/Lenna-grayscale.png",
message_to_hide, generators.eratosthenes())
@patch('builtins.input', return_value='n')
def test_refuse_convert_rgb(self, input):
message_to_hide = "I love 🍕 and 🍫!"
message_to_hide = "Hello World!"
with self.assertRaises(Exception):
secret = lsbset.hide("./tests/sample-files/Lenna-grayscale.png",
message_to_hide, generators.eratosthenes())
def test_auto_convert_rgb(self):
message_to_hide = "I love 🍕 and 🍫!"
message_to_hide = "Hello World!"
secret = lsbset.hide("./tests/sample-files/Lenna-grayscale.png",
message_to_hide, generators.eratosthenes(), True)
message_to_hide, generators.eratosthenes(),
auto_convert_rgb=True)
def test_with_too_long_message(self):
with open("./tests/sample-files/lorem_ipsum.txt") as f:

17
tests/test_tools.py
View file

@ -37,7 +37,7 @@ class TestTools(unittest.TestCase):
bits = tools.a2bits("Hello World!")
self.assertEqual(bits, '010010000110010101101100011011000110111100100000010101110110111101110010011011000110010000100001')
def test_a2bits_list(self):
def test_a2bits_list_UTF8(self):
list_of_bits = tools.a2bits_list("Hello World!")
self.assertEqual(list_of_bits, ['01001000',
'01100101',
@ -52,6 +52,21 @@ class TestTools(unittest.TestCase):
'01100100',
'00100001'])
def test_a2bits_list_UTF32LE(self):
list_of_bits = tools.a2bits_list("Hello World!", 'UTF-32LE')
self.assertEqual(list_of_bits, ['00000000000000000000000001001000',
'00000000000000000000000001100101',
'00000000000000000000000001101100',
'00000000000000000000000001101100',
'00000000000000000000000001101111',
'00000000000000000000000000100000',
'00000000000000000000000001010111',
'00000000000000000000000001101111',
'00000000000000000000000001110010',
'00000000000000000000000001101100',
'00000000000000000000000001100100',
'00000000000000000000000000100001'])
def test_n_at_a_time(self):
result = tools.n_at_a_time([1, 2, 3, 4, 5], 2, 'X')
self.assertEqual(list(result), [(1, 2), (3, 4), (5, 'X')])