Upload 5 files

app.py

@@ -0,0 +1,27 @@
+import streamlit as st
+from picchange import img_cryptography
+from stegnography import steganography_function
+from detection import steganography_detection
+
+# Sidebar Title
+st.sidebar.title("IMAGENIAS")
+st.sidebar.write("Choose a feature to proceed:")
+
+# Add buttons in rows within the sidebar
+crypto_button = st.sidebar.button("Crypto")
+stego_button = st.sidebar.button("Steganography")
+detect_button = st.sidebar.button("Detection")
+
+# Main App Title
+st.title("IMAGNIAS: Image Processing Toolkit")
+
+# Trigger the corresponding function based on the clicked button
+if crypto_button:
+    st.write("### Crypto Functionality")
+    img_cryptography()
+elif stego_button:
+    st.write("### Steganography Functionality")
+    steganography_function()
+else:
+    steganography_detection()
+

detection.py

@@ -0,0 +1,75 @@
+import streamlit as st
+from PIL import Image
+import numpy as np
+
+def steganography_detection():
+    def lsb_analysis(image):
+        """
+        Analyzes the Least Significant Bits (LSB) of the image pixels
+        and checks for irregularities that might indicate hidden data.
+        """
+        img = Image.open(image)
+        img = img.convert('RGB')  # Ensure RGB mode
+        pixels = np.array(img)  # Convert image to numpy array
+
+        if len(pixels.shape) != 3 or pixels.shape[2] != 3:
+            raise ValueError("Unsupported image format. Please use RGB images.")
+
+        height, width, _ = pixels.shape
+
+        lsb_count = [0, 0]  # Count of 0s and 1s in the LSB
+        lsb_distribution = []
+
+        # Loop through each pixel and channel
+        for y in range(height):
+            for x in range(width):
+                pixel = pixels[y, x]
+                for channel in range(3):  # Process R, G, B channels
+                    lsb = pixel[channel] & 1
+                    lsb_count[lsb] += 1
+                    lsb_distribution.append(lsb)
+
+        total_lsb = sum(lsb_count)
+        if total_lsb == 0:
+            return None, None
+
+        # Compute percentage distribution
+        lsb_percentage = [count / total_lsb * 100 for count in lsb_count]
+        return lsb_percentage, lsb_distribution
+
+    st.title("Steganography Detection Tool")
+    st.subheader("Analyze images for hidden messages based on LSB irregularities")
+
+    uploaded_image = st.file_uploader("Upload an image to analyze", type=["png", "jpg", "jpeg"])
+    analyze_button = st.button("Analyze Image")
+
+    if analyze_button:
+        if uploaded_image:
+            try:
+                st.image(uploaded_image, caption="Uploaded Image", use_column_width=True)
+                lsb_percentage, lsb_distribution = lsb_analysis(uploaded_image)
+
+                if lsb_percentage is None:
+                    st.error("Unable to analyze the image.")
+                else:
+                    st.write("### LSB Distribution Analysis")
+                    st.write(f"**Percentage of LSBs:**\n- 0s: {lsb_percentage[0]:.2f}%\n- 1s: {lsb_percentage[1]:.2f}%")
+
+                    # Visualization
+                    st.write("### Visualization of LSB Distribution")
+                    st.bar_chart({
+                        "LSB Values": ["0s", "1s"],
+                        "Percentage": lsb_percentage
+                    })
+
+                    # Detection threshold
+                    threshold = 50  # Typically, natural images have an approximately equal distribution of 0s and 1s
+                    if abs(lsb_percentage[0] - lsb_percentage[1]) > 5:
+                        st.warning("The image shows irregular LSB distribution, suggesting possible steganographic modification.")
+                    else:
+                        st.success("The LSB distribution appears normal, with no clear indication of hidden data.")
+
+            except Exception as e:
+                st.error(f"An error occurred while analyzing the image: {e}")
+        else:
+            st.error("Please upload an image for analysis.")

picchange.py

@@ -0,0 +1,163 @@
+import streamlit as st
+from PIL import Image
+import numpy as np
+from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
+from cryptography.hazmat.backends import default_backend
+from cryptography.hazmat.primitives import padding
+from io import BytesIO
+def img_cryptography():
+
+    # Function to add padding to the image bytes
+    def pad_data(data):
+        try:
+            padder = padding.PKCS7(128).padder()  # AES block size is 128 bits (16 bytes)
+            padded_data = padder.update(data) + padder.finalize()
+            return padded_data
+        except Exception as e:
+            raise ValueError(f"Padding Error: {e}")
+
+    # Function to remove padding after decryption
+    def unpad_data(data):
+        try:
+            unpadder = padding.PKCS7(128).unpadder()
+            unpadded_data = unpadder.update(data) + unpadder.finalize()
+            return unpadded_data
+        except Exception as e:
+            raise ValueError(f"Unpadding Error: {e}")
+
+    # Function to encrypt image using AES with a user-provided key
+    def encrypt_image(image_bytes, key):
+        try:
+            cipher = Cipher(algorithms.AES(key), modes.ECB(), backend=default_backend())
+            encryptor = cipher.encryptor()
+
+            # Pad the image bytes before encryption
+            padded_bytes = pad_data(image_bytes)
+            encrypted_bytes = encryptor.update(padded_bytes) + encryptor.finalize()
+            return encrypted_bytes
+        except Exception as e:
+            raise ValueError(f"Encryption Error: {e}")
+
+    # Function to decrypt image using AES with a user-provided key
+    def decrypt_image(encrypted_bytes, key):
+        try:
+            cipher = Cipher(algorithms.AES(key), modes.ECB(), backend=default_backend())
+            decryptor = cipher.decryptor()
+            decrypted_bytes = decryptor.update(encrypted_bytes) + decryptor.finalize()
+
+            # Remove padding after decryption
+            unpadded_bytes = unpad_data(decrypted_bytes)
+            return unpadded_bytes
+        except ValueError as e:
+            raise ValueError(f"Decryption Error: Invalid padding or incorrect key - {e}")
+        except Exception as e:
+            raise ValueError(f"Decryption Error: {e}")
+
+    # Streamlit user interface
+    st.title("Image Encryption and Decryption using AES")
+
+    # Option for selecting key length
+    key_length = st.selectbox("Choose AES key length:", [16, 24, 32])
+
+    # Function to generate the AES key based on user input
+    def generate_key(key_input, length):
+        try:
+            key = key_input.encode('utf-8')
+            if len(key) < length:
+                # Pad the key with null bytes if it's shorter than the selected length
+                key = key.ljust(length, b'\0')
+            elif len(key) > length:
+                # Truncate the key if it's longer than the selected length
+                key = key[:length]
+            return key
+        except Exception as e:
+            raise ValueError(f"Key Generation Error: {e}")
+
+    # Input for AES Key
+    key_input = st.text_input(f"Enter AES encryption key (up to {key_length} characters):", type="password")
+
+    # Ensure the key is of the correct length after processing
+    if key_input and key_length:
+        key = generate_key(key_input, key_length)
+    else:
+        st.warning(f"Please enter a key of length {key_length} characters for encryption and decryption.")
+        key = None
+
+    # Create two columns for encryption and decryption sections
+    col1, col2 = st.tabs(["Encryption","Decryption"])
+
+    # ENCRYPTION SECTION (Left Column)
+    with col1:
+        st.header("Encryption")
+
+        # Option to upload image for encryption
+        uploaded_file = st.file_uploader("Choose an image to encrypt...", type=["jpg", "jpeg", "png"])
+
+        if uploaded_file is not None and key:
+            # Display the original image
+            image = Image.open(uploaded_file)
+            st.image(image, caption="Original Image", use_column_width=True)
+
+            if st.button("Encrypt"):
+                # Convert image to bytes for encryption
+                image_bytes = BytesIO()
+                image.save(image_bytes, format="PNG")
+                image_bytes = image_bytes.getvalue()
+
+                # Encrypt the image bytes
+                encrypted_bytes = encrypt_image(image_bytes, key)
+
+                # Save the encrypted bytes as a .bin file
+                encrypted_bin_file = "encrypted_image.bin"
+                with open(encrypted_bin_file, "wb") as f:
+                    f.write(encrypted_bytes)
+
+                # To visualize encrypted data, truncate or pad it to match the original size
+                # Use numpy to create a grayscale view of the encrypted data
+                encrypted_array = np.frombuffer(encrypted_bytes, dtype=np.uint8)
+                padded_array = np.zeros(image.size[0] * image.size[1], dtype=np.uint8)
+                padded_array[:len(encrypted_array)] = encrypted_array[:len(padded_array)]
+
+                # Reshape to match image dimensions and visualize as a grayscale image
+                encrypted_image_array = padded_array.reshape(image.size[1], image.size[0])
+                encrypted_image = Image.fromarray(encrypted_image_array, mode="L")
+                encrypted_image_file = "encrypted_image.png"
+                encrypted_image.save(encrypted_image_file, format="PNG")
+
+                # Success message and download buttons
+                st.success("Image Encrypted Successfully!")
+                st.download_button(label="Download Encrypted BIN File", data=encrypted_bytes, file_name="encrypted_image.bin")
+                st.download_button(label="Download Encrypted PNG File", data=open(encrypted_image_file, "rb").read(), file_name="encrypted_image.png")
+                st.image(encrypted_image, caption="Encrypted Image (PNG)", use_column_width=True)
+
+
+    # DECRYPTION SECTION (Right Column)
+    with col2:
+        st.header("Decryption")
+
+        # Option to upload encrypted file for decryption (.bin only)
+        encrypted_file = st.file_uploader("Upload an encrypted file to decrypt (.bin only)...", type=["bin"])
+
+        if encrypted_file is not None and key:
+            try:
+                # Read encrypted binary data
+                encrypted_bytes = encrypted_file.read()
+
+                # Decrypt the image
+                decrypted_bytes = decrypt_image(encrypted_bytes, key)
+
+                # Convert decrypted bytes back to image
+                decrypted_image = Image.open(BytesIO(decrypted_bytes))
+                st.image(decrypted_image, caption="Decrypted Image", use_column_width=True)
+
+                # Save decrypted image as JPG
+                decrypted_image_file = "decrypted_image.jpg"
+                decrypted_image.save(decrypted_image_file, format="JPEG")
+
+                st.success("Image Decrypted Successfully!")
+                st.download_button(label="Download Decrypted Image (JPG)", data=open(decrypted_image_file, "rb").read(), file_name="decrypted_image.jpg")
+
+            except ValueError as e:
+                st.error(f"Error in decryption: {e}. This may indicate mismatched padding or incorrect decryption keys.")
+            except Exception as e:
+                st.error(f"Unexpected error: {e}")

stegnography.py

@@ -0,0 +1,104 @@
+import streamlit as st
+from PIL import Image
+import io
+def steganography_function():
+    # Steganography functions
+    def encode_image(input_image, secret_message):
+        """Encodes a secret message into an image."""
+        img = Image.open(input_image)
+        encoded = img.copy()
+        width, height = img.size
+        pixels = encoded.load()
+
+        # Convert the message into binary and add a delimiter
+        binary_message = ''.join(format(ord(char), '08b') for char in secret_message) + '1111111111111110'
+        data_index = 0
+
+        for y in range(height):
+            for x in range(width):
+                if data_index < len(binary_message):
+                    pixel = list(pixels[x, y])
+                    # Modify the LSB of each RGB value
+                    for i in range(3):  # Process R, G, B channels
+                        if data_index < len(binary_message):
+                            pixel[i] = (pixel[i] & ~1) | int(binary_message[data_index])
+                            data_index += 1
+                    pixels[x, y] = tuple(pixel)
+
+        output = io.BytesIO()
+        encoded.save(output, format='PNG')
+        output.seek(0)
+        return output
+
+    def decode_image(encoded_image):
+        """Decodes a secret message from an image."""
+        img = Image.open(encoded_image)
+        width, height = img.size
+        pixels = img.load()
+
+        binary_message = ""
+        for y in range(height):
+            for x in range(width):
+                pixel = pixels[x, y]
+                for i in range(3):  # Process R, G, B channels
+                    binary_message += str(pixel[i] & 1)
+
+        # Split binary string into 8-bit chunks
+        message = ""
+        for i in range(0, len(binary_message), 8):
+            byte = binary_message[i:i+8]
+            if byte == '11111110':  # Stop at the delimiter
+                break
+            message += chr(int(byte, 2))
+
+        return message
+
+    # Streamlit App
+    st.title("Steganography Tool")
+    st.subheader("Hide and retrieve secret messages in images")
+
+    # Tabs for Encode and Decode
+    tab1, tab2 = st.tabs(["🔒 Encode Message", "🔓 Decode Message"])
+
+    with tab1:
+        st.header("Encode a Secret Message")
+        uploaded_image = st.file_uploader("Upload an image to encode", type=["png", "jpg", "jpeg"])
+        if uploaded_image:
+            st.image(uploaded_image, caption="Selected Image for Encoding", use_column_width=True)
+        secret_message = st.text_area("Enter the secret message to hide")
+        encode_button = st.button("Apply Encoding")
+
+        if encode_button:
+            if uploaded_image and secret_message:
+                try:
+                    encoded_image = encode_image(uploaded_image, secret_message)
+                    st.success("Message encoded successfully!")
+                    st.image(encoded_image, caption="Encoded Image", use_column_width=True)
+                    st.download_button(
+                        label="Download Encoded Image",
+                        data=encoded_image,
+                        file_name="encoded_image.png",
+                        mime="image/png"
+                    )
+                except Exception as e:
+                    st.error(f"An error occurred: {e}")
+            else:
+                st.error("Please upload an image and enter a secret message.")
+
+    with tab2:
+        st.header("Decode a Secret Message")
+        encoded_image = st.file_uploader("Upload an image to decode", type=["png", "jpg", "jpeg"], key="decode")
+        if encoded_image:
+            st.image(encoded_image, caption="Selected Image for Decoding", use_column_width=True)
+        decode_button = st.button("Apply Decoding")
+
+        if decode_button:
+            if encoded_image:
+                try:
+                    decoded_message = decode_image(encoded_image)
+                    st.success("Message decoded successfully!")
+                    st.text_area("Decoded Message", decoded_message, height=100)
+                except Exception as e:
+                    st.error(f"An error occurred: {e}")
+            else:
+                st.error("Please upload an image to decode.")

watermark.py

@@ -0,0 +1,112 @@
+import streamlit as st
+from PIL import Image, ImageDraw, ImageFont
+import io
+import numpy as np
+def watermark_():
+# Function to create a visible watermark on an image
+    def add_visible_watermark(image, watermark_text, size, opacity):
+        width, height = image.size
+        font_size = int(size)
+        try:
+            font = ImageFont.truetype("arial.ttf", font_size)
+        except IOError:
+            font = ImageFont.load_default()
+
+        # Create watermark layer
+    # Create watermark layer
+        watermark_layer = Image.new("RGBA", image.size, (255, 255, 255, 0))
+        watermark_draw = ImageDraw.Draw(watermark_layer)
+
+        # Calculate center position
+        text_width, text_height = watermark_draw.textbbox((0, 0), watermark_text, font=font)[2:]
+        x = (width - text_width) / 2
+        y = (height - text_height) / 2
+
+        # Add shadow
+        shadow_color = (0, 0, 0, int(opacity * 0.3))
+        watermark_draw.text((x + 3, y + 3), watermark_text, font=font, fill=shadow_color)
+
+        # Add main watermark in a slant line
+        watermark_color = (255, 255, 255, int(opacity))
+        for i in range(-width, width, text_width + 20):
+            watermark_draw.text((x + i, y + i), watermark_text, font=font, fill=watermark_color)
+
+
+        # Combine the watermark layer with the original image
+        combined_image = Image.alpha_composite(image.convert("RGBA"), watermark_layer).convert("RGB")
+        return combined_image
+
+    # Function to embed an invisible watermark in an image
+    def add_invisible_watermark(image, watermark_text):
+        binary_watermark = ''.join(format(ord(char), '08b') for char in watermark_text)
+        img_array = np.array(image)
+        flat_image = img_array.flatten()
+
+        for i in range(len(binary_watermark)):
+            flat_image[i] = flat_image[i] & ~1 | int(binary_watermark[i])
+
+        watermarked_image = flat_image.reshape(img_array.shape)
+        return Image.fromarray(watermarked_image.astype(np.uint8))
+
+    # Function to detect an invisible watermark in an image
+    def detect_invisible_watermark(image, watermark_length):
+        img_array = np.array(image)
+        flat_image = img_array.flatten()
+        binary_watermark = ''.join(str(flat_image[i] & 1) for i in range(watermark_length * 8))
+        watermark = ''.join(chr(int(binary_watermark[i:i + 8], 2)) for i in range(0, len(binary_watermark), 8))
+        return watermark
+
+    # Streamlit UI
+    def main():
+        st.title("Visible and Invisible Watermarking Tool")
+
+        col1, col2 = st.tabs(["Visible","Invisible"])
+
+        with col1:
+            st.header("Visible Watermark")
+            watermark_text = st.text_input("Enter Watermark Text", key="visible_text")
+
+            uploaded_file = st.file_uploader("Upload an Image", type=["png", "jpg", "jpeg"], key="visible_upload")
+
+            if uploaded_file and (watermark_text):
+                image = Image.open(uploaded_file).convert("RGB")
+
+                size = st.slider("Select Font Size", 10, 200, 50, key="font_size")
+                opacity = st.slider("Select Opacity", 0, 255, 128, key="opacity")
+                
+
+                watermarked_image = add_visible_watermark(
+                    image, watermark_text, size, opacity
+                )
+
+                st.image(watermarked_image, caption="Watermarked Image")
+                buffer = io.BytesIO()
+                watermarked_image.save(buffer, format="PNG")
+                st.download_button("Download Watermarked Image", buffer.getvalue(), "visible_watermarked_image.png")
+
+        with col2:
+            st.header("Invisible Watermark")
+
+            watermark_text = st.text_input("Enter Invisible Watermark Text", key="invisible_text")
+            uploaded_file = st.file_uploader("Upload an Image", type=["png", "jpg", "jpeg"], key="invisible_upload")
+
+            if uploaded_file and watermark_text:
+                image = Image.open(uploaded_file).convert("RGB")
+                watermarked_image = add_invisible_watermark(image, watermark_text)
+
+                st.image(watermarked_image, caption="Image with Invisible Watermark")
+                buffer = io.BytesIO()
+                watermarked_image.save(buffer, format="PNG")
+                st.download_button("Download Image with Invisible Watermark", buffer.getvalue(), "invisible_watermarked_image.png")
+
+            if st.checkbox("Check Invisible Watermark"):
+                uploaded_file = st.file_uploader("Upload an Image to Check Watermark", type=["png", "jpg", "jpeg"], key="check_upload")
+                watermark_length = st.number_input("Enter Watermark Length", min_value=1, step=1, key="watermark_length")
+
+                if uploaded_file and watermark_length:
+                    image = Image.open(uploaded_file).convert("RGB")
+                    extracted_watermark = detect_invisible_watermark(image, watermark_length)
+                    st.write("Extracted Watermark:", extracted_watermark)
+
+    if __name__ == "__main__":
+        main()