Merge pull request #212 from Nibba2018/image_stegano

Image Steganography along with Encryption

Author: tejan-singh

Python/Image-Steganography/README.md

@@ -0,0 +1,59 @@
+# Image Steganography
+Steganography is the art and science of embedding secret messages in a cover message or file in such a way that no one, apart from the sender and the intended recipient, suspects the existence of the message. In case of Image Steganography, secret messages are embedded in images.
+
+![flowchart](https://d1jnx9ba8s6j9r.cloudfront.net/blog/wp-content/uploads/2019/01/SteganogarphyModel-528x259.png)
+
+One of the algorithms to do so is known as **Least Significant Bit Insertion**. In this script the following operations are done:
+
+**While Hiding:**
+1. Image and message is read from a text file.
+2. The message is encrypted with a key.
+3. The encrypted message is then embedded with the image.
+
+**While Retrieving:**
+1. Encrypted message is extracted from the image.
+2. Exncrypted message is then decrypted using the previous key.
+
+## Executing the script:
+* First install dependencies using: `pip install -r requirements.txt`
+* To hide run: `python hide.py <image_path> <message_file_path>`
+* for e.g: `python hide.py sample.png info.txt`
+* To retrieve run: `python retrieve.py <image_path> <key_path>`
+* for e.g: `python retrieve.py sample_secret.png key`
+
+> Note: Avoid using JPEG or JPG files as they ruin the integrity of the message due to compression.
+
+
+## Output:
+
+**sample.png:**
+
+![sample source](images/sample.png)
+
+**info.txt:**
+
+```txt
+Hello, this file's content will be hidden.
+```
+
+**Hiding:**
+
+![hiding](images/hiding.png)
+
+
+**sample_secret.png**
+
+![sample secret](images/sample_secret.png)
+
+The image with the hidden message.
+
+
+**key:**
+
+`hrnyzqoF3aOwaOO4n9vnunH9KUD-nh-Ee5fjQcuLU9k=`
+
+**Retrieving:**
+
+![retrieving](images/retrieving.png)
+
+Thank You!

Python/Image-Steganography/hide.py

@@ -0,0 +1,103 @@
+import cv2
+import numpy as np
+import sys
+from cryptography.fernet import Fernet
+
+# Check if the user has entered commandline arguments correctly or not.
+if len(sys.argv) < 3:
+    print("Provide appropriate commandline arguments.")
+    sys.exit()
+
+
+# Method to convert various data to binary.
+def message_to_binary(message):
+    if type(message) == str:
+        return ''.join([ format(ord(i), "08b") for i in message ])
+    elif type(message) == bytes or type(message) == np.ndarray:
+        return [ format(i, "08b") for i in message ]
+    elif type(message) == int or type(message) == np.uint8:
+        return format(message, "08b")
+    else:
+        raise TypeError("Input type not supported")
+
+
+# Method to generate key and encrypt secrect message.
+def encrypt_message(message):
+    key = Fernet.generate_key()
+    encrypted_message = Fernet(key).encrypt(message.encode())
+
+    return encrypted_message, key
+
+
+# Method to embed encrypted message within the image.
+def hide_info(image, message):
+
+    # Encrypt the message.
+    enc_message, key = encrypt_message(message)
+    enc_message = enc_message.decode()
+
+    # Get the maximum amount of byte data that can be embeded within the image.
+    max_bytes = image.shape[0] * image.shape[1] * 3//8
+
+    # Check if the data is within limits.
+    if len(enc_message) > max_bytes:
+        raise ValueError("Insufficient bytes, provide bigger image or shorter message.")
+
+    # Add salt delimiter.
+    enc_message += "#####"
+
+    data_index = 0
+    bin_enc_message = message_to_binary(enc_message)
+
+    data_len = len(bin_enc_message)
+
+    # Initiate embedding process.
+    for values in image:
+        for pixel in values:
+            # Convert pixel data to binary.
+            r, g, b = message_to_binary(pixel)
+
+            # modify the least significant bit remaining data is available.
+            if data_index < data_len:
+                # Hide data into LSB of red pixel
+                pixel[0] = int(r[:-1] + bin_enc_message[data_index], 2)
+                data_index += 1
+
+            if data_index < data_len:
+                # Hide data into LSB of green pixel
+                pixel[1] = int(g[:-1] + bin_enc_message[data_index], 2)
+                data_index += 1
+
+            if data_index < data_len:
+                # Hide data into LSB of blue pixel
+                pixel[2] = int(b[:-1] + bin_enc_message[data_index], 2)
+                data_index += 1
+
+            # Break out of the loop if there isn't any data left to embed.
+            if data_index >= data_len:
+                break
+
+    # Save the encryption key in a file.
+    with open("key", "wb") as f:
+        f.write(key)
+
+    return image
+
+
+# Extract image and message path.
+image_path = sys.argv[1]
+message_path = sys.argv[2]
+
+
+# Load image and message to memory.
+source_image = cv2.imread(image_path)
+with open(message_path, "r") as f:
+    message = f.read()
+
+
+# Perform the embeded operation and save the resultant image.
+secret_image = hide_info(source_image, message)
+secret_image_path = image_path.split(".")
+secret_image_path = secret_image_path[-2]+"_secret."+secret_image_path[-1]
+cv2.imwrite(secret_image_path, secret_image)
+print("Message successfully hidden.")

Python/Image-Steganography/images/hiding.png

@@ -0,0 +1 @@
+Hello, this file's content will be hidden.

Python/Image-Steganography/images/retrieving.png

@@ -0,0 +1 @@
+hrnyzqoF3aOwaOO4n9vnunH9KUD-nh-Ee5fjQcuLU9k=

Python/Image-Steganography/images/sample.png

@@ -0,0 +1,2 @@
+opencv-python
+cryptography

Python/Image-Steganography/images/sample_secret.png

@@ -0,0 +1,73 @@
+from cryptography.fernet import Fernet
+import cv2
+import numpy as np
+import sys
+
+
+# Check if user has provided commandline arguments or not.
+if len(sys.argv) < 3:
+    print("Provide appropriate commandline arguments.")
+    sys.exit()
+
+
+# Convert various data to binary.
+def message_to_binary(message):
+    if type(message) == str:
+        return ''.join([ format(ord(i), "08b") for i in message ])
+    elif type(message) == bytes or type(message) == np.ndarray:
+        return [ format(i, "08b") for i in message ]
+    elif type(message) == int or type(message) == np.uint8:
+        return format(message, "08b")
+    else:
+        raise TypeError("Input type not supported")
+
+
+# Decrypt an encrypted message.
+def decrypt_message(enc_message, key):
+    dec_message = Fernet(key).decrypt(enc_message)
+    return dec_message
+
+
+# Retrive the message from an image.
+def retrieve_info(image, key):
+
+    binary_data = ""
+
+    for values in image:
+        for pixel in values:
+            # Convert pixel to binary.
+            r, g, b = message_to_binary(pixel)
+
+            # Extracting data from the LSB of all the channels.
+            binary_data += r[-1]
+            binary_data += g[-1]
+            binary_data += b[-1]
+
+    # split by 8 bits.
+    all_bytes = [binary_data[i: i+8] for i in range(0, len(binary_data), 8)]
+
+    # Convert to ASCII values.
+    decoded_data = ""
+    for byte in all_bytes:
+        decoded_data += chr(int(byte, 2))
+        if decoded_data[-5:] == "#####":
+            break
+
+    # Decrypt the encryption.
+    message = decrypt_message(decoded_data[:-5].encode(), key).decode()
+
+    return message
+
+
+# Extract the image and key path.
+image_path = sys.argv[1]
+key_path = sys.argv[2]
+
+
+# Read the image and key.
+steg_image = cv2.imread(image_path)
+with open(key_path, "rb") as f:
+    key = f.read()
+
+# Display the secrect message.
+print(f"Secret Message:{retrieve_info(steg_image, key)}")