Spaces:
Sleeping
Sleeping
| #!/usr/bin/env python3 | |
| """ | |
| 2PAC: Picture Analyzer & Corruption Killer - Gradio Web Interface | |
| Steganography, image corruption detection, and security analysis | |
| """ | |
| import os | |
| import tempfile | |
| import gradio as gr | |
| from PIL import Image | |
| import matplotlib.pyplot as plt | |
| import io | |
| import base64 | |
| # Import 2PAC modules | |
| from steg_embedder import StegEmbedder | |
| import rat_finder | |
| import find_bad_images | |
| # Initialize embedder | |
| embedder = StegEmbedder() | |
| def hide_data_in_image(image, secret_text, password, bits_per_channel): | |
| """ | |
| Tab 1: Hide data in an image using LSB steganography | |
| """ | |
| if image is None: | |
| return None, "⚠️ Please upload an image first" | |
| if not secret_text or len(secret_text.strip()) == 0: | |
| return None, "⚠️ Please enter text to hide" | |
| try: | |
| # Save uploaded image to temp file | |
| with tempfile.NamedTemporaryFile(delete=False, suffix='.png') as tmp_input: | |
| img = Image.fromarray(image) | |
| img.save(tmp_input.name, 'PNG') | |
| input_path = tmp_input.name | |
| # Create output file | |
| with tempfile.NamedTemporaryFile(delete=False, suffix='.png') as tmp_output: | |
| output_path = tmp_output.name | |
| # Calculate capacity first | |
| img = Image.open(input_path) | |
| capacity = embedder.calculate_capacity(img, bits_per_channel) | |
| # Check if data fits | |
| data_size = len(secret_text.encode('utf-8')) | |
| if data_size > capacity: | |
| os.unlink(input_path) | |
| return None, f"❌ **Error:** Data too large!\n\n" \ | |
| f"- **Data size:** {data_size:,} bytes\n" \ | |
| f"- **Maximum capacity:** {capacity:,} bytes\n" \ | |
| f"- **Overflow:** {data_size - capacity:,} bytes\n\n" \ | |
| f"💡 Try: Shorter text, larger image, or more bits per channel" | |
| # Embed data | |
| pwd = password if password and len(password) > 0 else None | |
| success, message, stats = embedder.embed_data( | |
| input_path, | |
| secret_text, | |
| output_path, | |
| password=pwd, | |
| bits_per_channel=bits_per_channel | |
| ) | |
| # Clean up input | |
| os.unlink(input_path) | |
| if not success: | |
| if os.path.exists(output_path): | |
| os.unlink(output_path) | |
| return None, f"❌ **Error:** {message}" | |
| # Load result image | |
| result_img = Image.open(output_path) | |
| # Format success message | |
| result_message = f""" | |
| ✅ **Successfully Hidden!** | |
| 📊 **Statistics:** | |
| - **Data hidden:** {stats['data_size']:,} bytes ({len(secret_text):,} characters) | |
| - **Image capacity:** {stats['capacity']:,} bytes | |
| - **Utilization:** {stats['utilization']} | |
| - **Encryption:** {"🔒 Yes" if stats['encrypted'] else "🔓 No"} | |
| - **LSB depth:** {stats['bits_per_channel']} bit(s) per channel | |
| - **Image dimensions:** {stats['image_size']} | |
| 💾 **Download the image below** - your data is invisible to the naked eye! | |
| ⚠️ **Important:** | |
| - Save as PNG (not JPEG - will destroy hidden data) | |
| - Keep your password safe if you used encryption | |
| """ | |
| return result_img, result_message | |
| except Exception as e: | |
| if 'input_path' in locals() and os.path.exists(input_path): | |
| os.unlink(input_path) | |
| if 'output_path' in locals() and os.path.exists(output_path): | |
| os.unlink(output_path) | |
| return None, f"❌ **Error:** {str(e)}" | |
| def detect_hidden_data(image, sensitivity): | |
| """ | |
| Tab 2: Detect steganography using RAT Finder analysis | |
| """ | |
| if image is None: | |
| return None, "⚠️ Please upload an image to analyze" | |
| try: | |
| # Save uploaded image to temp file | |
| with tempfile.NamedTemporaryFile(delete=False, suffix='.png') as tmp: | |
| img = Image.fromarray(image) | |
| img.save(tmp.name, 'PNG') | |
| image_path = tmp.name | |
| # Map slider to sensitivity | |
| sens_map = {1: 'low', 2: 'low', 3: 'low', 4: 'medium', 5: 'medium', | |
| 6: 'medium', 7: 'high', 8: 'high', 9: 'high', 10: 'high'} | |
| sensitivity_str = sens_map.get(sensitivity, 'medium') | |
| # Perform analysis | |
| confidence, details = rat_finder.analyze_image(image_path, sensitivity=sensitivity_str) | |
| # Generate ELA visualization | |
| ela_result = rat_finder.perform_ela_analysis(image_path) | |
| # Clean up | |
| os.unlink(image_path) | |
| # Create confidence indicator | |
| if confidence >= 70: | |
| confidence_emoji = "🚨" | |
| confidence_label = "HIGH SUSPICION" | |
| elif confidence >= 40: | |
| confidence_emoji = "⚠️" | |
| confidence_label = "MODERATE SUSPICION" | |
| else: | |
| confidence_emoji = "✅" | |
| confidence_label = "LOW SUSPICION" | |
| # Format results | |
| result_text = f""" | |
| {confidence_emoji} **{confidence_label}** | |
| 📊 **Confidence Score:** {confidence:.1f}% | |
| 🔍 **Analysis Details:** | |
| """ | |
| for detail in details: | |
| result_text += f"\n• {detail}" | |
| result_text += f""" | |
| --- | |
| **What does this mean?** | |
| - **ELA (Error Level Analysis):** Highlights areas with different compression levels | |
| - Bright areas = potential manipulation or hidden data | |
| - Uniform appearance = likely unmodified | |
| - **LSB Analysis:** Checks randomness in least significant bits | |
| - **Histogram Analysis:** Looks for statistical anomalies | |
| - **Metadata:** Examines EXIF data for suspicious tools | |
| - **File Structure:** Checks for trailing data | |
| 💡 **High confidence doesn't mean data is hidden** - just that anomalies exist. | |
| Use the "Extract Data" tab if you suspect LSB steganography! | |
| """ | |
| # Return ELA plot if available | |
| if ela_result['success'] and ela_result['ela_image']: | |
| return ela_result['ela_image'], result_text | |
| return None, result_text | |
| except Exception as e: | |
| if 'image_path' in locals() and os.path.exists(image_path): | |
| os.unlink(image_path) | |
| return None, f"❌ **Error:** {str(e)}" | |
| def extract_hidden_data(image, password, bits_per_channel): | |
| """ | |
| Tab 2b: Extract data hidden with LSB steganography | |
| """ | |
| if image is None: | |
| return "⚠️ Please upload an image" | |
| try: | |
| # Save uploaded image to temp file | |
| with tempfile.NamedTemporaryFile(delete=False, suffix='.png') as tmp: | |
| img = Image.fromarray(image) | |
| img.save(tmp.name, 'PNG') | |
| image_path = tmp.name | |
| # Attempt extraction | |
| pwd = password if password and len(password) > 0 else None | |
| success, message, extracted_data = embedder.extract_data( | |
| image_path, | |
| password=pwd, | |
| bits_per_channel=bits_per_channel | |
| ) | |
| # Clean up | |
| os.unlink(image_path) | |
| if not success: | |
| return f"❌ **{message}**\n\nPossible reasons:\n" \ | |
| f"• No data hidden in this image\n" \ | |
| f"• Wrong password (if encrypted)\n" \ | |
| f"• Wrong bits-per-channel setting\n" \ | |
| f"• Image was modified/re-saved" | |
| result = f""" | |
| ✅ **Data Successfully Extracted!** | |
| 📝 **Hidden Message:** | |
| --- | |
| {extracted_data} | |
| --- | |
| 📊 **Extraction Info:** | |
| - **Data size:** {len(extracted_data)} characters | |
| - **Decryption:** {"🔒 Used" if pwd else "🔓 Not needed"} | |
| - **LSB depth:** {bits_per_channel} bit(s) per channel | |
| 💡 Copy the message above - it has been successfully recovered from the image! | |
| """ | |
| return result | |
| except Exception as e: | |
| if 'image_path' in locals() and os.path.exists(image_path): | |
| os.unlink(image_path) | |
| return f"❌ **Error:** {str(e)}" | |
| def check_image_corruption(image, sensitivity, check_visual): | |
| """ | |
| Tab 3: Check for image corruption and validate integrity | |
| """ | |
| if image is None: | |
| return "⚠️ Please upload an image to check" | |
| try: | |
| # Save uploaded image to temp file | |
| with tempfile.NamedTemporaryFile(delete=False, suffix='.png') as tmp: | |
| img = Image.fromarray(image) | |
| img.save(tmp.name, 'PNG') | |
| image_path = tmp.name | |
| # Map slider to sensitivity | |
| sens_map = {1: 'low', 2: 'low', 3: 'low', 4: 'medium', 5: 'medium', | |
| 6: 'medium', 7: 'high', 8: 'high', 9: 'high', 10: 'high'} | |
| sensitivity_str = sens_map.get(sensitivity, 'medium') | |
| # Validate image | |
| is_valid = find_bad_images.is_valid_image( | |
| image_path, | |
| thorough=True, | |
| sensitivity=sensitivity_str, | |
| check_visual=check_visual | |
| ) | |
| # Get diagnostic details | |
| issues = find_bad_images.diagnose_image_issue(image_path) | |
| # Clean up | |
| os.unlink(image_path) | |
| # Format results | |
| if is_valid: | |
| result = f""" | |
| ✅ **IMAGE IS VALID** | |
| The image passed all validation checks: | |
| - ✅ File structure is intact | |
| - ✅ Headers are valid | |
| - ✅ No truncation detected | |
| - ✅ Metadata is consistent | |
| """ | |
| if check_visual: | |
| result += "- ✅ No visual corruption detected\n" | |
| result += "\n💚 **This image is safe to use!**" | |
| else: | |
| result = f""" | |
| ⚠️ **ISSUES DETECTED** | |
| The image has validation problems: | |
| """ | |
| if issues: | |
| for issue_type, issue_desc in issues.items(): | |
| result += f"**{issue_type}:**\n{issue_desc}\n\n" | |
| else: | |
| result += "❌ Image failed validation but no specific issues identified.\n\n" | |
| result += """ | |
| --- | |
| **What to do:** | |
| - Image may be corrupted or incomplete | |
| - Try re-downloading the original file | |
| - Check if the file was properly transferred | |
| - Use image repair tools if needed | |
| """ | |
| return result | |
| except Exception as e: | |
| if 'image_path' in locals() and os.path.exists(image_path): | |
| os.unlink(image_path) | |
| return f"❌ **Error:** {str(e)}" | |
| # Create Gradio interface | |
| with gr.Blocks( | |
| title="2PAC: Picture Analyzer & Corruption Killer", | |
| theme=gr.themes.Soft( | |
| primary_hue="violet", | |
| secondary_hue="blue", | |
| ) | |
| ) as demo: | |
| gr.Markdown(""" | |
| # 🔫 2PAC: Picture Analyzer & Corruption Killer | |
| **Advanced image security and steganography toolkit** | |
| Hide secret messages in images, detect hidden data, and validate image integrity. | |
| """) | |
| with gr.Tabs(): | |
| # TAB 1: Hide Data | |
| with gr.Tab("🔒 Hide Secret Data"): | |
| gr.Markdown(""" | |
| ## Hide Data in Image (LSB Steganography) | |
| Invisibly hide text inside an image using Least Significant Bit encoding. | |
| The image will look identical to the naked eye, but contains your secret message! | |
| """) | |
| with gr.Row(): | |
| with gr.Column(scale=1): | |
| hide_input_image = gr.Image( | |
| label="Upload Image", | |
| type="numpy", | |
| height=300 | |
| ) | |
| hide_secret_text = gr.Textbox( | |
| label="Secret Text to Hide", | |
| placeholder="Enter your secret message here...", | |
| lines=5, | |
| max_lines=10 | |
| ) | |
| with gr.Row(): | |
| hide_password = gr.Textbox( | |
| label="Password (Optional - for encryption)", | |
| placeholder="Leave empty for no encryption", | |
| type="password" | |
| ) | |
| hide_bits = gr.Slider( | |
| minimum=1, | |
| maximum=4, | |
| value=1, | |
| step=1, | |
| label="LSB Depth (higher = more capacity, less subtle)", | |
| info="1=subtle, 4=maximum capacity" | |
| ) | |
| hide_button = gr.Button("🔒 Hide Data in Image", variant="primary", size="lg") | |
| with gr.Column(scale=1): | |
| hide_output_image = gr.Image(label="Result Image (Download This!)", height=300) | |
| hide_output_text = gr.Markdown(label="Status") | |
| hide_button.click( | |
| fn=hide_data_in_image, | |
| inputs=[hide_input_image, hide_secret_text, hide_password, hide_bits], | |
| outputs=[hide_output_image, hide_output_text] | |
| ) | |
| gr.Markdown(""" | |
| --- | |
| **💡 Tips:** | |
| - Use PNG images for best results (JPEG will destroy hidden data!) | |
| - Larger images can hold more data | |
| - Password encryption adds extra security layer | |
| - LSB depth: 1-2 bits is undetectable, 3-4 bits provides more capacity | |
| """) | |
| # TAB 2: Detect & Extract | |
| with gr.Tab("🔍 Detect & Extract Hidden Data"): | |
| gr.Markdown(""" | |
| ## Detect Steganography & Extract Hidden Data | |
| Use advanced analysis techniques to detect hidden data in images, or extract data hidden with this tool. | |
| """) | |
| with gr.Tabs(): | |
| # Sub-tab: Detection | |
| with gr.Tab("🔎 Detect (Analysis)"): | |
| gr.Markdown(""" | |
| ### Steganography Detection (RAT Finder) | |
| Analyzes images for signs of hidden data using multiple techniques: | |
| ELA, LSB analysis, histogram analysis, metadata inspection, and more. | |
| """) | |
| with gr.Row(): | |
| with gr.Column(scale=1): | |
| detect_input_image = gr.Image( | |
| label="Upload Image to Analyze", | |
| type="numpy", | |
| height=300 | |
| ) | |
| detect_sensitivity = gr.Slider( | |
| minimum=1, | |
| maximum=10, | |
| value=5, | |
| step=1, | |
| label="Detection Sensitivity", | |
| info="Higher = more thorough but more false positives" | |
| ) | |
| detect_button = gr.Button("🔍 Analyze for Hidden Data", variant="primary", size="lg") | |
| with gr.Column(scale=1): | |
| detect_output_image = gr.Image(label="ELA Visualization", height=300) | |
| detect_output_text = gr.Markdown(label="Analysis Results") | |
| detect_button.click( | |
| fn=detect_hidden_data, | |
| inputs=[detect_input_image, detect_sensitivity], | |
| outputs=[detect_output_image, detect_output_text] | |
| ) | |
| # Sub-tab: Extraction | |
| with gr.Tab("📤 Extract Data"): | |
| gr.Markdown(""" | |
| ### Extract Hidden Data (LSB Extraction) | |
| If you have an image created with the "Hide Data" tool, extract the hidden message here. | |
| """) | |
| with gr.Row(): | |
| with gr.Column(scale=1): | |
| extract_input_image = gr.Image( | |
| label="Upload Image with Hidden Data", | |
| type="numpy", | |
| height=300 | |
| ) | |
| with gr.Row(): | |
| extract_password = gr.Textbox( | |
| label="Password (if encrypted)", | |
| placeholder="Leave empty if not encrypted", | |
| type="password" | |
| ) | |
| extract_bits = gr.Slider( | |
| minimum=1, | |
| maximum=4, | |
| value=1, | |
| step=1, | |
| label="LSB Depth (must match encoding)", | |
| info="Use same value as when hiding" | |
| ) | |
| extract_button = gr.Button("📤 Extract Hidden Data", variant="primary", size="lg") | |
| with gr.Column(scale=1): | |
| extract_output_text = gr.Markdown(label="Extracted Data") | |
| extract_button.click( | |
| fn=extract_hidden_data, | |
| inputs=[extract_input_image, extract_password, extract_bits], | |
| outputs=[extract_output_text] | |
| ) | |
| # TAB 3: Check Corruption | |
| with gr.Tab("🛡️ Check Image Integrity"): | |
| gr.Markdown(""" | |
| ## Image Corruption & Validation | |
| Thoroughly validate image files for corruption, truncation, and structural issues. | |
| Detects damaged headers, incomplete data, and visual artifacts. | |
| """) | |
| with gr.Row(): | |
| with gr.Column(scale=1): | |
| check_input_image = gr.Image( | |
| label="Upload Image to Validate", | |
| type="numpy", | |
| height=300 | |
| ) | |
| with gr.Row(): | |
| check_sensitivity = gr.Slider( | |
| minimum=1, | |
| maximum=10, | |
| value=5, | |
| step=1, | |
| label="Validation Sensitivity", | |
| info="Higher = more strict validation" | |
| ) | |
| check_visual = gr.Checkbox( | |
| label="Check for Visual Corruption", | |
| value=True, | |
| info="Slower but detects visual artifacts" | |
| ) | |
| check_button = gr.Button("🛡️ Validate Image", variant="primary", size="lg") | |
| with gr.Column(scale=1): | |
| check_output_text = gr.Markdown(label="Validation Results") | |
| check_button.click( | |
| fn=check_image_corruption, | |
| inputs=[check_input_image, check_sensitivity, check_visual], | |
| outputs=[check_output_text] | |
| ) | |
| gr.Markdown(""" | |
| --- | |
| **🔍 Checks Performed:** | |
| - ✅ File format validation (JPEG, PNG, GIF, etc.) | |
| - ✅ Header integrity | |
| - ✅ Data completeness | |
| - ✅ Metadata consistency | |
| - ✅ Visual corruption detection (black/gray regions) | |
| - ✅ Structure validation | |
| """) | |
| gr.Markdown(""" | |
| --- | |
| ## About 2PAC | |
| **2PAC** (Picture Analyzer & Corruption Killer) is a comprehensive image security toolkit combining: | |
| - **LSB Steganography**: Hide and extract secret messages in images | |
| - **RAT Finder**: Advanced steganography detection using 7+ analysis techniques | |
| - **Image Validation**: Detect corruption and structural issues | |
| 🔗 **GitHub:** [github.com/ricyoung/2pac](https://github.com/ricyoung/2pac) | |
| 🌐 **More Tools:** [demo.deepneuro.ai](https://demo.deepneuro.ai) | |
| --- | |
| *Built with ❤️ by DeepNeuro.AI | Powered by Gradio & Hugging Face Spaces* | |
| """) | |
| if __name__ == "__main__": | |
| demo.launch() | |