def test_manual_convert_rgb(self, input):
message_to_hide = "I love 🍕 and 🍫!"
lsb.hide(
"./tests/sample-files/Lenna-grayscale.png",
message_to_hide,
encoding="UTF-32LE",
)
def stego():
print("hi")
global numBytes, numExfilFiles, numFiles, dT, eD,flg,textAdd,gpath
numF=1
flg=1
downloadImage()
while numF<=numFiles:
print("hey")
textF=open((gpath+"\\"+str(numF)+"combinedExfil.txt"), "r")
numBytestextEx=0
textAdd=""
last=checkLine(gpath+"\\"+str(numF)+"combinedExfil.txt")
for line in textF:
if numBytestextEx+sys.getsizeof(line)<20000:
numBytestextEx+=sys.getsizeof(line)
textAdd+=line
if line==last:
secret = lsb.hide(gpath+"\\diamond_PNG6695.png" , textAdd)
secret.save(gpath+"\\X"+str(numExfilFiles)+"combinedExfil.png")
elif numBytestextEx+sys.getsizeof(line)>=20000:
textAdd=line
secret = lsb.hide(gpath+"\\diamond_PNG6695.png", textAdd)
secret.save(gpath+"\\X"+str(numExfilFiles)+"combinedExfil.png")
print(lsb.reveal(gpath+"\\X"+str(numExfilFiles)+"combinedExfil.png"))
numExfilFiles+=1
if line==last:
secret = lsb.hide(gpath+"\\diamond_PNG6695.png", textAdd)
secret.save(gpath+"\\X"+str(numExfilFiles)+"combinedExfil.png")
numF+=1
def encode():
if secimg.get() == "jpeg":
inimage = fileopen
response = messagebox.askyesno("popup", "do you want to encode")
if response == 1:
aaa.hide(inimage, entrysave.get() + '.jpg', entrysecmes.get())
messagebox.showinfo(
"popup", "successfully encode" + entrysave.get() + ".jpeg")
else:
messagebox.showwarning("popup", "unsuccessful")
if secimg.get() == "png":
inimage = fileopen
response = messagebox.askyesno("popup", "do you want to encode")
if response == 1:
lsb.hide(inimage,
message=entrysecmes.get()).save(entrysave.get() +
'.png')
messagebox.showinfo(
"popup",
"successfully encode to " + entrysave.get() + ".png")
else:
messagebox.showwarning("popup", "unsuccessful")
def encryption():
if request.method == 'POST':
result = request.form
oldpath = request.files['oldpath']
msg = request.form['msg']
newpath = request.form['newpath']
newpath = newpath + '.png'
img_upload_dir = os.path.join(os.path.dirname(app.instance_path), '')
lsb.hide(oldpath,
message=msg).save(os.path.join(img_upload_dir, newpath))
if 'username' in session:
username = session['username']
sql = "INSERT INTO images(username, imagepath) VALUES(%s, %s)"
data = (username, newpath)
conn = mysql.connect()
cursor = conn.cursor()
cursor.execute(sql, data)
conn.commit()
cursor.execute("SELECT imagepath from images where username='******'")
images_data = cursor.fetchall()
images_list = []
for row in images_data:
image = str(row)
image1 = image.replace("\\\\", "\\")
image2 = image1.replace("\\r\\n", "")
image3 = image2.replace(
"C:\\Users\\janvi\\PycharmProjects\\Steganography\\venv\\Lib\\static\\uploads\\",
"")
image4 = image3[2:-3]
images_list.append(image4)
flash('Encrypted Successfully')
return render_template("home_page.html", images_list=images_list)
def test_auto_convert_rgb(self):
message_to_hide = "I love 🍕 and 🍫!"
lsb.hide(
"./tests/sample-files/Lenna-grayscale.png",
message_to_hide,
encoding="UTF-32LE",
auto_convert_rgb=True,
)
def test_refuse_convert_rgb(self, input):
message_to_hide = "I love 🍕 and 🍫!"
with self.assertRaises(Exception):
lsb.hide(
"./tests/sample-files/Lenna-grayscale.png",
message_to_hide,
encoding="UTF-32LE",
)
def ocultar_en_imgs(self, fromdir, firma, extension, usar_metadatos):
todir = fromdir[:fromdir.rfind('_')] + '_images/' # De la ruta del directorio, nos quedamos con el nombre y le añadimos el sufijo '_images'
# Creamos un directorio (si no existe).
if not os.path.exists(todir):
os.mkdir(todir)
else:
for fname in os.listdir(todir):
# Si el directorio existe y tiene contenido, dejamos el directorio y eliminamos el contenido del directorio.
os.remove(os.path.join(todir, fname))
parts = os.listdir(fromdir) # Generamos una lista con los fragmentos que hay en el directorio.
parts.sort()
firma = procesarContenido(self, firma)
for index, part in enumerate(parts):
content = procesarFichero(self, fromdir + part)
part_name = part[:part.rfind('.')]
if usar_metadatos:
img = Image.open(self.lineEdit_3.text())
img.save(todir + part_name + '.' + img.format.lower())
newImage = Image.open(todir + part_name + '.' + img.format.lower())
if 'part_001' in newImage.filename:
Metadatos.ocultar_informacion(self, newImage.filename, 'firma', firma)
Metadatos.ocultar_informacion(self, newImage.filename, 'extension', extension)
Metadatos.ocultar_informacion(self, newImage.filename, 'contenido', content)
else:
img = Image.open(self.lineEdit_3.text())
if img.format == 'JPEG':
img.save(todir + part_name + '.png')
newImage = Image.open(todir + part_name + '.png')
else:
img.save(todir + part_name + '.' + img.format.lower())
newImage = Image.open(todir + part_name + '.' + img.format.lower())
if 'part_001' in newImage.filename:
secret = lsb.hide(newImage.filename, firma + "#####" + extension + "#####" + content)
secret.save(newImage.filename)
else:
secret = lsb.hide(newImage.filename, content)
secret.save(newImage.filename)
os.remove(fromdir + part)
os.rmdir(fromdir)
return todir
def encode_txt_img(self): # Fn to encode our txt to image
sel_image = self.ids.encode_image_path.text # getting the file location
user_text = self.ids.user_text.text # text to be encoded
slash_count = sel_image.count("\\") # getting the file location
img_name = sel_image.split("\\", slash_count)[slash_count].split(
".", 1)[0] # selecting only the file name with no extension
img_type = sel_image.split("\\", slash_count)[slash_count].split(
".", 1)[1] # selecting only the file extension
# Checking if the required folder exists
if os.path.exists(r"C:\Secret TXT"):
pass
else: # if not creating it
os.makedirs(r"C:\Secret TXT")
try:
# checking the type of file first
# for png types
if img_type == "png":
secret_img = f"C:\\Secret TXT\\{img_name} [Encoded].{img_type}" # setting the location to save the encoded images
# lsb is used for png
# hide is used to encode the image
# it's parameters are selected image, the text to be encoded
lsb.hide(sel_image, message=user_text).save(
secret_img
) # save is used to save the image to the required location
self.ids.encode_result.text = "Encoding was successful"
# for jpg/jpeg types
elif img_type == "jpg" or img_type == "jpeg":
secret_img = f"C:\\Secret TXT\\{img_name} [Encoded].{img_type}"
# exifHeader is used for jpg/jpeg
# hide is used to encode the image
# it's parameters are selected image, location to be saved, and the text to be encoded
exifHeader.hide(sel_image,
secret_img,
secret_message=user_text)
self.ids.encode_result.text = "Encoding was successful"
# if type is not supported
else:
self.ids.encode_result.text = "Type not supported"
except:
# fail-safe
self.ids.encode_result.text = "Encoding has failed"
def perform(original_image_path, changed_image_path):
original_image = Image.open(original_image_path)
changed_image = Image.open(changed_image_path)
w, h = original_image.size
tile_size = 64
hash_length = 64
threshold = hash_length * 0.15
column, row = count_tiles_size(w, h, tile_size)
# Slice image to 64x64 blocks
original_tiles = image_slicer.slice(original_image_path,
number_tiles=column * row,
col=column,
row=row,
save=False)
changed_tiles = image_slicer.slice(changed_image_path,
number_tiles=column * row,
col=column,
row=row,
save=False)
# Итеративно проходим по каждому блоку изображения
for original_tile, changed_tile in zip(original_tiles, changed_tiles):
# Получаем хеш блока
original_hash = imagehash.phash_simple(original_tile.image)
changed_hash = imagehash.phash_simple(changed_tile.image)
# Прям хеш методом наименее значащего бита
original_tile.image = lsb.hide(original_tile.image, str(original_hash))
changed_tile.image = lsb.hide(changed_tile.image, str(changed_hash))
# Забираем хеш из изображения
decoded_original_hash = lsb.reveal(original_tile.image.copy())
decoded_changed_hash = lsb.reveal(changed_tile.image.copy())
# Вычисляем расстояние Хемминга и сравниваем его с пороговой границей
if hamming_distance(decoded_original_hash,
decoded_changed_hash) > threshold:
# Закрашиваем измененные области
# The current version supports all possible conversions between “L”, “RGB” and “CMYK.” The matrix argument only supports “L” and “RGB”.
rgb2xyz = (0.412453, 0.357580, 0.180423, 0, 0.212671, 0.215160,
0.072169, 0, 0.019334, 0.919193, 0.950227, 0)
changed_tile.image = changed_tile.image.convert("RGB", rgb2xyz)
result_image = image_slicer.join(changed_tiles, w, h)
file_name = original_image_path.split(".")[-2]
result_image_path = original_image_path.replace(file_name,
file_name + "_result")
result_image.save(result_image_path)
original_image.show()
changed_image.show()
result_image.show()
def add_steg(path, bpp):
'''
Add steg to each image in directory
param:
path - str path to data folder containing .pngs
bpp - float desired bits per pixel
return:
None
'''
filecounter = len([path for path in walk_dir(path)])
gen = DocumentGenerator()
if (args.generators):
lsb_generators = [
getattr(generators, entry) for entry in args.generators
]
count = 0
for filepath in tqdm(walk_dir(path), total=filecounter, unit='files'):
try:
im = Image.open(filepath)
im_size = im.size[0] * im.size[1]
# average sentence length is 60 bytes -> 480 bits
message = '\n'.join(
[gen.sentence() for i in range(int(im_size * bpp / 480))])
# remove non-ascii characters as they mess up steganography
message = message.encode('ascii', 'ignore').decode()
if (args.generators):
# + 1 to add normal lsb
gen_index = int(count % (len(lsb_generators) + 1))
if (gen_index == len(lsb_generators)):
secret = lsb.hide(filepath, message)
secret.save(filepath.replace('.png', '.steg.png'))
else:
lsb_gen = lsb_generators[gen_index]
secret = lsbset.hide(filepath, message, lsb_gen())
secret.save(
filepath.replace('.png',
f".{args.generators[gen_index]}.png"))
else:
secret = lsb.hide(filepath, message)
secret.save(filepath.replace('.png', '.steg.png'))
count += 1
except Exception as e:
print(e)
print(filepath)
def set_signature(input_image: str, output_image: str, signature: str) -> None:
"""Signs the image at the input path with the supplied signature and saves it at the output image path.
The output image must be of png format because lossless compression is required to sign an image.
:param input_image: the input image path
:param output_image: the output image path
:param signature: the signature
:return: None
:raise ImageFormatException: if the output image format is not png
"""
if not output_image or output_image.split('.')[-1] != 'png':
raise ImageFormatException()
lsb.hide(input_image, signature).save(output_image, 'png')
def start_operation(self):
key_box = self.textbox_key.toPlainText()
message = self.textbox_message.toPlainText()
image = self.path_textBox.text()
path_save = self.output_textBox.text()
#Start Encryption
if (key_box != '') and (message != '') and (path_save != '') and (image != ''):
try:
cipher_text_byte = PrpCrypt(key_box).encrypt(message) #Encrypted Message
cipher_text_str = cipher_text_byte.decode() #Covert Byte to String
cipher_image = lsb.hide(image, cipher_text_str)
cipher_image.save(path_save)
time.sleep(1)
QMessageBox.about(self, 'Completed', 'Done!')
#Clear All The Input Boxes.
self.clear_all()
except:
QMessageBox.about(self, 'Error', 'Operation Failed, try again.')
else:
QMessageBox.about(self, 'Error', 'Please enter all the fields to continue..')
def watermark_text(input_image_path, output_image_path, text):
photo = Image.open(input_image_path)
origin_x, origin_y, width, height = photo.getbbox()
xPos = width - 400
yPos = height - 50
# make the image editable
drawing = ImageDraw.Draw(photo)
shadow_color = (0, 0, 0)
text_color = (255, 255, 255)
font = ImageFont.truetype("/Library/Fonts/Futura.ttc", 40)
# draw thin border
drawing.text((xPos - 2, yPos), text, font=font, fill=shadow_color)
drawing.text((xPos + 2, yPos), text, font=font, fill=shadow_color)
drawing.text((xPos, yPos - 2), text, font=font, fill=shadow_color)
drawing.text((xPos, yPos + 2), text, font=font, fill=shadow_color)
# draw true text
drawing.text((xPos, yPos), text, fill=text_color, font=font)
# preview and save image
photo.show()
photo.save(output_image_path)
secret = lsb.hide(output_image_path,
'© ' + time.strftime("%Y") + ' Owen Pierce')
secret.save(output_image_path)
def upload_image():
form = SHA512Form()
if request.method == "POST":
if request.files:
if "filesize" in request.cookies:
if not allowed_image_filesize(request.cookies["filesize"]):
flash("Filesize exceeded maximum limit", 'danger')
return redirect(request.url)
image = request.files["image"]
if image.filename == "":
flash("No file selected", 'danger')
return redirect(request.url)
if allowed_image(image.filename):
filename = secure_filename(image.filename)
image.save(
os.path.join(app.config["IMAGE_UPLOADS"], filename))
secret = lsb.hide(app.config["IMAGE_UPLOADS"] + filename,
form.plaintext.data.encode("utf-8"))
secret.save(
os.path.join(app.config["IMAGE_UPLOADS"],
'secret-' + filename))
return send_file(app.config["IMAGE_UPLOADS"] + 'secret-' +
filename,
as_attachment=True)
flash('Hiding message successful', 'success')
return redirect(request.url)
else:
flash("That file extension is not allowed", 'danger')
return redirect(request.url)
return render_template("upload_new.html", title="Stegano", form=form)
def main():
print HTML_HEADER
print HEAD
data = cgi.FieldStorage()
fileds = data['file']
if fileds.filename.endswith('.jpg') or fileds.filename.endswith(
'.png') or fileds.filename.endswith(
'.jpeg') or fileds.filename.endswith(
'.tiff') and fileds.filename.count('/') == -1:
os.chdir('files')
with open(fileds.filename, 'wb') as fout:
shutil.copyfileobj(fileds.file, fout, 100000)
os.chdir('../')
# do NOT touch above code
if fileds.filename.endswith('.png'):
sec = lsb.hide('files/' + fileds.filename, data['message'].value)
sec.save('files/' + fileds.filename)
if fileds.filename.endswith('.jpg') or fileds.filename.endswith('.jpeg'):
secret = exifHeader.hide('files/' + fileds.filename,
'files/' + fileds.filename,
secret_message=data['message'].value)
print "Successfully generated."
print '<a href="http://jonathanwong.koding.io/bstego/files/' + fileds.filename + '">Link here</a>'
print END
def encrypt():
if request.method == "GET":
return render_template("encrypt.html")
else:
if not (request.form.get("text") or request.form.get("key1")):
return apology("Missing Message/Key")
elif request.form.get("key1").isdigit() == False:
return apology("Enter a secret key between 1 and 26.")
elif (int(request.form.get("key1")) < 1
or int(request.form.get("key1")) > MAX_KEY_SIZE):
return apology("Enter a secret key between 1 and 26.")
else:
f = request.files['pic']
f.save("./static/Input.png")
plaintext1 = request.form.get("text")
key1 = int(request.form.get("key1"))
ciphertext1 = ciphertexter(plaintext1, key1)
secret = lsb.hide(
f, ciphertext1) # or secret = lsb.hide("./Input.png", text)
secret.save("./static/Stego.png")
return render_template("encrypted.html")
def encode_string(input_string, root="./tmp/"):
split_string_list = split_string(input_string)
for i in range(0, len(split_string_list)):
f_name = "{}{}.png".format(root, i)
secret_enc = lsb.hide(f_name, split_string_list[i])
secret_enc.save(f_name)
print("[INFO] frame {} holds {}".format(f_name, split_string_list[i]))
def send_msg():
ch = select_a_friend()
text = input("What do you want to say? ")
secret = lsb.hide("./input.png", text)
output = input('Name of output file: \n (Press enter for default name)')
if len(output) == 0:
secret.save("./secret.png")
print(
bcolors.BOLD +
"Your secret message image is ready! with file name 'secret.png' ")
else:
try:
secret.save(output)
print(bcolors.BOLD +
"Your secret message image is ready! with file name " +
output)
except Exception:
print(bcolors.WARNING + 'Please Enter valid extension')
# Append chat to friend
new_chat = ChatMessage(text, True)
friends[ch].chats.append(new_chat)
start_chat(spy_name, spy_age, spy_rating)
def generate_images(dir_name, word):
print("generating images for " + current_dir + " " + dir_name + "...")
clear_message = ""
current_index = 0
loop_index = 0
print("generating word: " + word)
for count in range(len(word)):
base_dir = current_dir + dir_name + "/"
if not os.path.exists(base_dir):
os.makedirs(base_dir)
current = word[count]
file = base_dir + str(
loop_index) + "-" + file_keys[current_index] + '.png'
height = random.randint(50, 955)
width = random.randint(250, 955)
img = Image.new('RGB', (width, height))
draw = ImageDraw.Draw(img)
fonts_path = "~/Library/Fonts"
font = ImageFont.truetype(os.path.join(fonts_path, 'slkscr.ttf'), 9)
draw.text((0, random.randint(10, height - 20)),
randomString(random.randint(2, 255)),
(random.randint(50, 255), random.randint(
50, 255), random.randint(50, 255)),
font=font)
img.save(file)
secret = lsb.hide(file, current)
secret.save(file)
clear_message += lsb.reveal(file)
current_index = current_index + 1
if current_index > 6:
current_index = 0
loop_index = loop_index + 1
def embed(img, saveas, password, inp, offset, pic_num, tps):
# encrypt & embed a data string into an image
salt = get_random_bytes(32) # generate something salty..
key = PBKDF2(password, salt,
dkLen=32) # encryption key generated from the password
cipher = AES.new(key, AES.MODE_CBC) # let's get encrypting...
data = inp.encode() # encode input to a bytes object
pd = str(":" + str(pic_num) + "," +
str(tps)).encode() # encode sequence position
ct_bytes = cipher.encrypt(pad(
data + pd, AES.block_size)) # cipher text bytes + sequence
iv = b64encode(cipher.iv).decode('utf-8') # base64 encoded IV
ct = b64encode(ct_bytes).decode('utf-8') # base64 encoded Cipher Text
salt_s = b64encode(salt).decode('utf-8') # base64 encoded Salt
enc_string = lukefuscate(salt_s + iv +
ct) # obfuscation/substitution cipher
steg_it = lsb.hide(img,
enc_string,
encoding="UTF-8",
shift=offset,
auto_convert_rgb=True)
steg_it.save(saveas) # save the image
return "SAVED AS: " + str(saveas)
def hide(self, input_filename, output_filename, data):
"""
Encrypt and save the data inside the image.
:param input_filename: Input image file path
:param output_filename: Output image file path
:param data: Information to be encrypted and saved
:return:
"""
# Generate a random initialization vector
iv = Random.new().read(AES.block_size)
encryption_suite = AES.new(self.key, AES.MODE_CBC, iv)
# If it is string convert to byte string before use it
if isinstance(data, str):
data = data.encode()
# Encrypt the random initialization vector concatenated
# with the padded data
cypher_data = encryption_suite.encrypt(iv + pad(data, self.block_size))
# Convert the cypher byte string to a base64 string to avoid
# decode padding error
cypher_data = base64.b64encode(cypher_data).decode()
# Hide the encrypted message in the image with the LSB
# (Least Significant Bit) technique.
secret = lsb.hide(input_filename, cypher_data)
# Save the image file
secret.save(output_filename)
def add_image_steganography(image_file):
#print(image_file)
try:
key = ''
if "tree" in image_file:
key = 'tree'
elif "mountain" in image_file:
key = 'mountain'
elif "sea" in image_file:
key = 'sea'
elif "hotel" in image_file:
key = 'hotel'
#print(lookup[key])
if ".jpg" in image_file.lower():
#print(image_file)
img = Image.open(image_file)
img1 = img.convert("RGB")
secret = lsb.hide(img1, lookup[key])
secret.save("./valid_data/" + key + "/" +
os.path.basename(image_file))
except:
print(" Error in processing the file ")
return True
def final_encryption(path, message):
p = path
m = message
secret_message = lsb.hide(p, m)
secret_message.save("C:/Users/User/Desktop/tour/secret_message.png")
messagebox.showinfo(
"Saved",
"Encryped file stored in C:/Users/User/Desktop/encrypted_images")
def encodePng(self, path, string):
# if ".png" not in path:
# path = path + ".png"
# if "./" not in path:
# path = "./" + path
newImage = lsb.hide(path, string)
newImage.save("./Steganography/steganized/"+os.path.basename(path))
def test_hide_and_reveal_UTF32LE(self):
messages_to_hide = 'I love 🍕 and 🍫!'
secret = lsb.hide("./tests/sample-files/Lenna.png",
messages_to_hide, encoding='UTF-32LE')
secret.save("./image.png")
clear_message = lsb.reveal("./image.png", encoding='UTF-32LE')
self.assertEqual(messages_to_hide, clear_message)
def keygenerate(data, id): #Regenerate the key file on user request
ipath = 'https://source.unsplash.com/random/200x200'
fname = id + '.png'
path = os.path.join(MEDIA_ROOT + '/keys/', fname)
r = requests.get(ipath, allow_redirects=True)
open(path, 'wb').write(r.content)
secret = lsb.hide(path, data) # Stegano library hiding the data
secret.save(path)
def test_hide_and_reveal(self):
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 encode_string(input_string, root):
# for file in os.listdir(root):
# if file.endswith(".jpg"):
split_string_list = split_string(input_string)
for i in range(1, len(split_string_list)):
secret_enc = lsb.hide("{}{}.png".format(root, i), split_string_list[i])
secret_enc.save("{}{}.png".format(root, i))
print("[INFO] frame {} holds {}".format(i, split_string_list[i]))
def test_hide_and_reveal(self):
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 send(msg):
secret = lsb.hide("example.png", msg)
secret.save("example-steg.png")
with open("example-steg.png", "rb") as imagefile:
imagedata = imagefile.read()
id_img = twitter_upload.media.upload(
media=imagedata, media_category="tweet_image")["media_id_string"]
results = twitter.statuses.update(media_ids=id_img)
def encode_message(image, message):
image_with_secret = lsb.hide(image, message)
filename = f"{uuid.uuid4().hex}.png" # giving a random name to the file
image_path = os.path.join(
app.root_path, "static/images",
filename) # to work with stegano, the image will be saved as a png
image_with_secret.save(image_path) # save the processed image
return filename
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 main_function(original_image_filename, deformed_image_filename):
original_image = Image.open(original_image_filename)
deformed_image = Image.open(deformed_image_filename)
# расчет количества блоков
n = 64
width, height = original_image.size
col = math.ceil(width / n)
row = math.ceil(height / n)
# пороговая величина
threshold = n * 0.15
# разбитие изображений на блоки
orig_img_tiles = image_slicer.slice(original_image_filename,
col=col,
row=row,
save=False)
deform_img_tiles = image_slicer.slice(deformed_image_filename,
col=col,
row=row,
save=False)
for orig_block, deform_block in zip(orig_img_tiles, deform_img_tiles):
# getting block hash
orig_hash = myimagehash.phash_simple(orig_block.image)
deform_hash = myimagehash.phash_simple(deform_block.image)
# hide a message(hash) in images with the LSB
orig_block.image = lsb.hide(orig_block.image, str(orig_hash))
deform_block.image = lsb.hide(deform_block.image, str(deform_hash))
# Find a message(hash) in images with the LSB
decoded_orig_hash = lsb.reveal(orig_block.image.copy())
decoded_deform_hash = lsb.reveal(deform_block.image.copy())
if hamming_distance(decoded_orig_hash,
decoded_deform_hash) > threshold:
deform_block.image = deform_block.image.convert("L")
result_image = image_slicer.join(deform_img_tiles, width, height)
result_image.save("./images/result.png")
original_image.show()
deformed_image.show()
result_image.show()
def test_with_text_file(self):
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)
secret.save("./image.png")
clear_message = lsb.reveal("./image.png")
self.assertEqual(message, clear_message)
def test_with_transparent_png(self):
messages_to_hide = ['🍕', 'a', 'foo', 'Hello World!', ':Python:']
for message in messages_to_hide:
secret = lsb.hide("./tests/sample-files/transparent.png",
message, 'UTF-32LE')
secret.save("./image.png")
clear_message = lsb.reveal("./image.png", 'UTF-32LE')
self.assertEqual(message, clear_message)
def test_with_bytes(self):
messages_to_hide = ["a", "foo", "Hello World!", ":Python:"]
for message in messages_to_hide:
message = "Hello World"
outputBytes = io.BytesIO()
bytes_image = lsb.hide(open("./tests/sample-files/20160505T130442.jpg", 'rb'), message)
bytes_image.save(outputBytes, "PNG")
outputBytes.seek(0)
clear_message = lsb.reveal(outputBytes)
self.assertEqual(message, clear_message)
def main():
print HTML_HEADER
print HEAD
data = cgi.FieldStorage()
fileds = data['file']
if fileds.filename.endswith('.jpg') or fileds.filename.endswith('.png') or fileds.filename.endswith('.jpeg') or fileds.filename.endswith('.tiff') and fileds.filename.count('/') == -1:
os.chdir('files')
with open(fileds.filename, 'wb') as fout:
shutil.copyfileobj(fileds.file, fout, 100000)
os.chdir('../')
# do NOT touch above code
if fileds.filename.endswith('.png'):
sec = lsb.hide('files/'+fileds.filename, data['message'].value)
sec.save('files/'+fileds.filename)
if fileds.filename.endswith('.jpg') or fileds.filename.endswith('.jpeg'):
secret = exifHeader.hide('files/'+fileds.filename, 'files/'+fileds.filename, secret_message=data['message'].value)
print "Successfully generated."
print '<a href="http://jonathanwong.koding.io/bstego/files/'+fileds.filename+'">Link here</a>'
print END
def test_with_binary_file(self):
binary_file_to_hide = "./tests/sample-files/free-software-song.ogg"
with open(binary_file_to_hide, "rb") as bin_file:
encoded_string = base64.b64encode(bin_file.read())
message = encoded_string.decode()
secret = lsb.hide("./tests/sample-files/Montenach.png", message)
secret.save("./image.png")
clear_message = lsb.reveal("./image.png")
clear_message += '==='
clear_message = base64.b64decode(clear_message)
with open('file1', 'wb') as f:
f.write(clear_message)
with open('file1', 'rb') as bin_file:
encoded_string = base64.b64encode(bin_file.read())
message1 = encoded_string.decode()
self.assertEqual(message, message1)
try:
os.unlink('./file1')
except:
pass
def POST(self):
input = web.input(file={})
filename = input['file'].filename
fileds = input['file'].value
message = input.message
if filename.endswith('.jpg') or filename.endswith('.png') or filename.endswith('.jpeg') and filename.count('/') == -1:
os.chdir('static/files')
with open(filename, 'wb') as fout:
shutil.copyfileobj(input['file'].file, fout, 100000)
os.chdir('../../')
# do NOT touch above code
if filename.endswith('.png'):
sec = lsb.hide('static/files/' + filename, message)
sec.save('static/files/' + filename)
if filename.endswith('.jpg') or filename.endswith('.jpeg'):
secret = exifHeader.hide('static/files/' + filename, 'static/files/' + filename, secret_message = message)
return '''
<!DOCTYPE html>
<html lang="en">
<head>
<title>
Your image
</title>
<style>
img {
width: 500px;
height: 500px;
}
</style>
</head>
<body>
<h1>
Right click on the image and click <i>Save As</i> to save it.
</h1>
<img src="static/files/'''+filename+'''" />
</body>
</html>
'''
else:
return
def test_refuse_convert_rgb(self, input):
message_to_hide = 'I love 🍕 and 🍫!'
with self.assertRaises(Exception):
secret = lsb.hide("./tests/sample-files/Lenna-grayscale.png",
message_to_hide, 'UTF-32LE')
def test_auto_convert_rgb(self):
message_to_hide = 'I love 🍕 and 🍫!'
secret = lsb.hide("./tests/sample-files/Lenna-grayscale.png",
message_to_hide, 'UTF-32LE', True)
from stegano import lsb
secret = lsb.hide("./test.png", "This is a test This is a testThis is a testThis is a testThis is a testThis is a test"
"This is a testThis is a testThis is a testThis is a testThis is a testThis is a test"
"This is a testThis is a testThis is a testThis is a testThis is a testThis is a test")
secret.save("./Lenna-secret.png")
print(lsb.reveal("./Lenna-secret.png"))
def test_hide_empty_message(self):
"""
Test hiding the empty string.
"""
with self.assertRaises(AssertionError):
secret = lsb.hide("./tests/sample-files/Lenna.png", "")
def png_encode(file_name, message, mfile_name): secret = lsb.hide(file_name, message) secret.save(mfile_name)
def test_with_too_long_message(self):
with open("./tests/sample-files/lorem_ipsum.txt") as f:
message = f.read()
message += message*2
with self.assertRaises(Exception):
lsb.hide("./tests/sample-files/Lenna.png", message)
