adding comments and readme

Author: Nibba2018

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

@@ -3,12 +3,13 @@
 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 ])
@@ -20,63 +21,83 @@ def message_to_binary(message):
         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

@@ -1 +1 @@
-UJRsXUb0QISvEQwbyl4M0FVhl-Xt1X_mWyjQClbT3KE=
+hrnyzqoF3aOwaOO4n9vnunH9KUD-nh-Ee5fjQcuLU9k=

Python/Image-Steganography/images/retrieving.png

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

Python/Image-Steganography/sample.png renamed to Python/Image-Steganography/images/sample.png

@@ -3,11 +3,14 @@
 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 ])
@@ -19,39 +22,52 @@ def message_to_binary(message):
         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
 
-    message = decrypt_message(decoded_data[:-5].encode(), key)
+    # Decrypt the encryption.
+    message = decrypt_message(decoded_data[:-5].encode(), key).decode()
 
-    return message.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)}")