shadowbits 1.0.0__py3-none-any.whl

shadowbits/cli.py

@@ -0,0 +1,74 @@
+import argparse
+from emb_img import embed_file  
+from ext_img import extract_file
+from emb_aud import embed_audio
+from ext_aud import extract_audio
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Steganography tool for hiding files in images')
+    subparsers = parser.add_subparsers(dest='command', help='Available commands')
+
+
+    # Embed command for image
+    img_parser = subparsers.add_parser('img', help='Image operations')
+    img_subparser = img_parser.add_subparsers(dest='action' , help='Image actions')
+    embed_cmd = img_subparser.add_parser('embed', help='Hide a file in an image')
+    embed_cmd.add_argument('--in', dest='input', required=True, help='File to hide')    
+    embed_cmd.add_argument('--cover', dest='image', required=True, help='Cover image')
+    embed_cmd.add_argument('--key', required=True, help='Secret key for randomization')
+
+    # Extract command for image
+    extract_cmd = img_subparser.add_parser('extract', help='Extract hidden file from image')
+    extract_cmd.add_argument('--stego', required=True, help='Image with hidden file')
+    extract_cmd.add_argument('--key', required=True, help='Secret key used for hiding')
+
+    # Embed command for audio
+    aud_parser = subparsers.add_parser('aud', help='Audio operation')
+    aud_subparser = aud_parser.add_subparsers(dest='action', help='Audio actions')
+    embed_audio_cmd = aud_subparser.add_parser('embed', help='Hide a file in an audio file')
+    embed_audio_cmd.add_argument('--in', dest='input', required=True, help='File to hide')
+    embed_audio_cmd.add_argument('--cover', dest='song', required=True, help='Cover audio')
+    embed_audio_cmd.add_argument('--key', required=True, help='Secret key to randomize bits')
+
+    # Extract command for audio
+    extract_audio_cmd = aud_subparser.add_parser('extract', help='Extract hidden file from audio')
+    extract_audio_cmd.add_argument('--stego', required=True, help='Audio with hidden file')
+    extract_audio_cmd.add_argument('--key', required=True, help='Secret key used for hiding')
+
+
+    args = parser.parse_args()
+
+    if not args.command:
+        parser.print_help()
+        exit(1)
+
+    try:
+        if args.command == 'img':
+            if args.action == 'embed':
+                embed_file(args.image, args.input, args.key)
+                print(f"Successfully embedded {args.input} in {args.image}.")
+            elif args.action == 'extract':
+                extract_file(args.stego, args.key)
+                print(f"Successfully extracted hidden file from {args.stego}.")
+            else:
+                img_parser.print_help()
+                raise SystemExit(1)
+        
+        elif args.command == 'aud':
+            if args.action == 'embed':
+                embed_audio(args.song, args.input, args.key)
+                print(f"Successfully embedded {args.input} in {args.song}.")
+            elif args.action == 'extract':
+                extract_audio(args.stego, args.key)
+                print(f"Successfully extracted hidden file from {args.stego}.")
+            else:
+                aud_parser.print_help()
+                raise SystemExit(1)
+
+    except Exception as e:
+        print(f"Error: {e}")
+        exit(1)
+
+if __name__ == '__main__':
+    main()

shadowbits/crypto/aes.py

@@ -0,0 +1,28 @@
+import hashlib
+from Crypto.Cipher import AES
+
+def derive_key(password):
+    return hashlib.sha256(password.encode()).digest()
+
+def to_seed(password: str) -> int:
+    digest = hashlib.sha256(password.encode()).digest()
+    return int.from_bytes(digest, 'big')
+
+def encryption(payload, key):
+    cipher = AES.new(derive_key(key), AES.MODE_EAX)
+    ciphertext, tag = cipher.encrypt_and_digest(payload)
+    payload = cipher.nonce + tag + ciphertext
+    return payload
+
+def decryption(payload, key):
+    if len(payload) < 32:
+        raise ValueError("Encrypted payload too short")
+    nonce = payload[:16]
+    tag = payload[16:32]
+    ciphertext = payload[32:]
+    cipher = AES.new(derive_key(key), AES.MODE_EAX, nonce=nonce)
+    try:
+        payload = cipher.decrypt_and_verify(ciphertext, tag)
+        return payload
+    except ValueError as e:
+        raise ValueError("Decryption failed - wrong key or corrupted data")

shadowbits/emb_aud.py

@@ -0,0 +1,99 @@
+import wave
+import random
+from crypto.aes import *
+import os
+import time
+
+def valid_wav(cover_path):
+    try:
+        with wave.open(cover_path, 'rb') as wave_file:
+            channels = wave_file.getnchannels()
+            sample_width = wave_file.getsampwidth()
+            framerate = wave_file.getframerate()
+            frames = wave_file.getnframes()
+            
+            if not (1 <= channels <= 8): 
+                return False
+            if sample_width not in [1, 2, 3, 4]:
+                return False
+            if not (8000 <= framerate <= 192000):
+                return False
+            if frames <= 0:
+                return False
+            
+            wave_file.readframes(min(1024, frames))
+            
+            return True
+            
+    except (wave.Error, EOFError, FileNotFoundError, PermissionError):
+        return False
+    except Exception:
+        return False
+
+
+def embed_audio(cover_path, payload_path, key):
+    start = time.time()
+    try:
+        if not os.path.exists(cover_path):
+            raise FileNotFoundError(f"Cover file path {cover_path} not found.")
+        if not os.path.exists(payload_path):
+            raise FileNotFoundError(f"Secret file path {payload_path} not found.")
+        if not valid_wav(cover_path):
+            raise ValueError(f"{cover_path} is not a valid WAV file")
+        
+        print("Loading cover file...")
+        with wave.open(cover_path, mode='rb') as song:
+            frame_bytes = bytearray(song.readframes(song.getnframes()))
+            params = song.getparams()
+
+        print("Loading payload file...")
+        with open(payload_path, 'rb') as f:
+            payload = f.read()
+
+        print("Encrypting the payload's byte...")
+        payload = encryption(payload, key)
+
+        print("Attaching the markers on payload's bytes...")
+        starting = b'###START###'
+        ending = b'###END###'
+        full_payload = starting + payload + ending
+
+        print("Converting the payload's byte into bits...")
+        payload_bits = []
+        for byte in full_payload:
+            bits = format(byte, '08b')
+            payload_bits.extend([int(b) for b in bits])
+
+        print("Checking cover file capacity...")
+        max_payload_bits = len(frame_bytes)
+        if len(payload_bits) > max_payload_bits:
+            raise ValueError(f"Payload too large! Need {len(payload_bits)} bits but only have {max_payload_bits} available")
+
+        seed = to_seed(key)
+        shifu = random.Random(seed)
+        indexes = list(range(len(frame_bytes)))
+        shifu.shuffle(indexes)
+
+        print("Embedding the payload bits into cover file bytes...")
+        for bit_idx, bit in enumerate(payload_bits):
+            i = indexes[bit_idx]
+            frame_bytes[i] = (frame_bytes[i] & 0xFE) | bit
+
+        output_path = "encoded.wav"
+        if os.path.exists(output_path):
+            counter = 1
+            while os.path.exists(f"encoded({counter}).wav"):
+                counter += 1
+            output_path = f"encoded({counter}).wav"
+
+        print("Saving stego file...")
+        with wave.open(output_path, 'wb') as fd:
+            fd.setparams(params)
+            fd.writeframes(bytes(frame_bytes))
+        end = time.time() - start
+        print(f"Time taken: {int(end)} seconds.")
+        return output_path
+    
+    except Exception as e:
+        print(f"Error in embed_audio: {e}")
+        raise

shadowbits/emb_img.py

@@ -0,0 +1,103 @@
+from PIL import Image
+import random
+from crypto.aes import *
+import os
+import time
+
+### To varify if the image is valid
+def valid_img(cover_path):
+    try:
+        with Image.open(cover_path) as img:
+            # Check format first
+            if img.format and img.format.upper() == "PNG":
+                img.verify()  # Only verify if it claims to be PNG
+                return True
+            return False
+    except Exception:
+        return False
+
+
+def embed_file(cover_path, payload_path, key):
+    start = time.time()
+    try:
+        if not os.path.exists(cover_path):
+            raise FileNotFoundError(f"Cover image {cover_path} not found.")
+        if not os.path.exists(payload_path):
+            raise FileNotFoundError(f"Payload file {payload_path} not found.")
+        if not valid_img(cover_path):
+            raise ValueError(f"{cover_path} is not a valid PNG image file.")
+
+        print("Loading cover file...")
+        img = Image.open(cover_path)
+        mode = img.mode
+
+        if mode != 'RGB':
+            print(f"Converting the {mode} mode to RGB mode...")
+            img = img.convert('RGB')
+
+        pixels = list(img.getdata())
+
+        print("Loading payload file in bytes...")
+        with open(payload_path, 'rb') as f:
+            payload = f.read()
+
+        print("Encrypting the payload bytes...")
+        payload = encryption(payload, key)
+
+        print("Attaching the markers on payload bytes...")
+        starting = b'###START###'
+        ending = b'###END###'
+
+        length = len(payload).to_bytes(4, 'big')
+        data = starting + length + payload + ending
+
+        print("Convertng payload bytes into bits...")
+        bits = ''.join(f'{byte:08b}' for byte in data)
+
+        max_bits = len(pixels) * 3 ### 3 color channels per pixel
+        print("Checking cover file capacity...")
+        if len(bits) > max_bits:
+            raise ValueError('Payload is too large to embed in cover file.')
+
+        seed = to_seed(key)
+        prng = random.Random(seed)
+        indexes = list(range(len(pixels)))
+        prng.shuffle(indexes)
+
+        print("Embedding data into image...")
+        new_pixels = [None] * len(pixels)  
+        bit_idx = 0
+        
+        for i in range(len(indexes)):
+            pixel_idx = indexes[i]  
+            r, g, b = pixels[pixel_idx]
+        
+            if bit_idx < len(bits):
+                r = (r & ~1) | int(bits[bit_idx])
+                bit_idx += 1
+            if bit_idx < len(bits):
+                g = (g & ~1) | int(bits[bit_idx])
+                bit_idx += 1
+            if bit_idx < len(bits):
+                b = (b & ~1) | int(bits[bit_idx])
+                bit_idx += 1
+
+            new_pixels[pixel_idx] = (r, g, b)
+
+        img.putdata(new_pixels)
+
+        output_path = "stego_file.png"
+        if os.path.exists(output_path):
+            counter = 1
+            while os.path.exists(f"stego_file({counter}).png"):
+                counter += 1
+            output_path = f"stego_file({counter}).png"
+            
+        print("Saving the stego file...")
+        file = img.save(output_path)
+        end = time.time() - start
+        print(f"Time taken: {int(end)} seconds.")
+        return file
+    except Exception as e:
+        print(f"Error in embedding : {e}")
+        raise

shadowbits/ext_aud.py

@@ -0,0 +1,74 @@
+import wave
+from emb_aud import valid_wav
+from crypto.aes import *
+import os
+import random
+from validator import detect_file_type
+import time
+
+def extract_audio(stego_path, key):
+    start = time.time()
+    try:
+        if not valid_wav(stego_path):
+            raise ValueError(f"{stego_path} is not a valid wav file")
+        
+        print("Loading stego file...")
+        with wave.open(stego_path, 'rb') as song:
+            frame_bytes = song.readframes(song.getnframes())
+
+        seed = to_seed(key)
+        shifu = random.Random(seed)
+        indexes = list(range(len(frame_bytes)))
+        shifu.shuffle(indexes)
+
+        print("Extracting the bits from stego file...")
+        extracted_bits = []
+        for i in indexes:
+            extracted_bits.append(frame_bytes[i] & 1)
+
+        print("Converting extracted bits into bytes...")
+        extracted_bytes = bytearray()
+        for i in range(0, len(extracted_bits), 8):
+            if i + 7 < len(extracted_bits):
+                byte_bits = extracted_bits[i:i+8]
+                byte_value = 0
+                for j, bit in enumerate(byte_bits):
+                    byte_value |= bit << (7-j)
+                extracted_bytes.append(byte_value)
+
+        starting = b'###START###'
+        ending = b'###END###'
+        print("Locating markers in bytes...")
+        try:
+            start_byte = extracted_bytes.find(starting)
+            if start_byte == -1:
+                raise ValueError("Starting point not found - file may not contain embedded data or key is incorrect")
+            
+            search = start_byte + len(starting)
+            end_byte = extracted_bytes.find(ending, search)
+            if end_byte == -1:
+                raise ValueError("Ending point not found - embedded data maybe corrupted")
+            
+            print("Extracting payload's bytes from bytes....")
+            payload = bytes(extracted_bytes[search:end_byte])
+
+        except Exception as e:
+            print(f"Error finding payload data : {e}")
+            return None
+        
+        print("Decrypting the payload's bytes...")
+        payload = decryption(payload, key)
+            
+        extension, mime_type = detect_file_type(payload)
+        output_path = f"hidden_file.{extension}"
+
+        print("Saving the extracted file...")
+        with open(output_path, 'wb') as fd:
+            fd.write(payload)
+        end = time.time() - start
+        print(f"Time taken: {int(end)} seconds.")
+        return payload
+    
+    except Exception as e:
+        print(f"Error in extracting data from file: {e}")
+        return None

shadowbits/ext_img.py

@@ -0,0 +1,91 @@
+from PIL import Image
+import random
+from crypto.aes import *
+import os
+from emb_img import valid_img
+from validator import detect_file_type
+import time
+
+def extract_file(stego_path, key):
+    start = time.time()
+    try:
+        if not os.path.exists(stego_path):
+            raise FileNotFoundError(f"stego image {stego_path} not found.")
+        if not valid_img(stego_path):
+            raise ValueError(f"Image is not a valid PNG file.")
+        
+        print("Loading stego file...")
+        img = Image.open(stego_path)
+        pixels = list(img.getdata())
+        
+        seed = to_seed(key)
+        prng = random.Random(seed)
+        indexes = list(range(len(pixels)))
+        prng.shuffle(indexes)
+
+        print("Extracting the bits from stego file...")
+        bits = ''
+        for i in range(len(pixels)):
+            pixel_idx = indexes[i]  
+            r, g, b = pixels[pixel_idx]
+            bits += str(r & 1)
+            bits += str(g & 1)
+            bits += str(b & 1)
+
+    
+        if len(bits) % 8 != 0:
+            bits = bits[:-(len(bits) % 8)]  # Remove incomplete byte
+        
+        print("Converting bits into bytes...")
+        bytes_list = bytes([int(bits[i:i+8], 2) for i in range(0, len(bits), 8)])
+        
+        starting = b'###START###'
+        ending = b'###END###'
+
+        print("Locating markers in bytes...")
+        start_point = bytes_list.find(starting)
+        if start_point == -1:
+            raise ValueError("Starting marker of the payload not found in image or key is incorrect")
+        
+        data_start = start_point + len(starting)
+
+        if len(bytes_list) < data_start + 4:
+            raise ValueError("Not enough data to extract length")
+        
+        length = int.from_bytes(bytes_list[data_start:data_start + 4], 'big')
+
+        payload_start = data_start + 4
+        payload_end = payload_start + length    
+    
+        if len(bytes_list) < payload_end:
+            raise ValueError(f"Not enough data to extract payload of length {length}")
+        
+        print("Extracting payload's bytes from bytes...")
+        payload = bytes_list[payload_start:payload_end]
+
+        print("Verifying the end marker in bytes...") 
+        end_start = payload_end
+        end_end = end_start + len(ending)
+
+        if len(bytes_list) < end_end:
+            raise ValueError(f"Not enough data to verify the end marker.")
+        
+        extract_end = bytes_list[end_start:end_end]
+        if extract_end != ending:
+            raise ValueError(f"End marker not found or corrupted")
+        
+        print("Decrypting the payload bytes...")
+        payload = decryption(payload, key)
+            
+        extension, mime_type = detect_file_type(payload)
+        out_path = f"extracted_file.{extension}"
+
+        print("Saving the extracted file...")
+        with open(out_path, 'wb') as f:
+            f.write(payload)
+        end = time.time() - start
+        print(f"Time taken: {int(end)} seconds.")
+        return out_path
+    except Exception as e:
+        print(f"Error in extracion : {e}")
+        raise

shadowbits/validator.py

@@ -0,0 +1,87 @@
+def detect_file_type(data):
+    """
+    Detect file type based on magic bytes (file signatures)
+    Returns tuple: (extension, mime_type)
+    """
+    if not data or len(data) < 4:
+        return 'bin', 'application/octet-stream'
+    
+    # Common file signatures
+    signatures = {
+        # Images
+        b'\xFF\xD8\xFF': ('jpg', 'image/jpeg'),
+        b'\x89PNG\r\n\x1a\n': ('png', 'image/png'),
+        b'GIF87a': ('gif', 'image/gif'),
+        b'GIF89a': ('gif', 'image/gif'),
+        b'BM': ('bmp', 'image/bmp'),
+        b'RIFF': ('webp', 'image/webp'),
+        b'\x00\x00\x01\x00': ('ico', 'image/x-icon'),
+        
+        # Documents
+        b'%PDF': ('pdf', 'application/pdf'),
+        b'\xD0\xCF\x11\xE0\xA1\xB1\x1A\xE1': ('doc', 'application/msword'),
+        b'PK\x03\x04': ('zip', 'application/zip'),  # Also docx, xlsx, etc.
+        
+        # Audio
+        b'ID3': ('mp3', 'audio/mpeg'),
+        b'\xFF\xFB': ('mp3', 'audio/mpeg'),
+        b'\xFF\xF3': ('mp3', 'audio/mpeg'),
+        b'\xFF\xF2': ('mp3', 'audio/mpeg'),
+        b'OggS': ('ogg', 'audio/ogg'),
+        b'fLaC': ('flac', 'audio/flac'),
+        
+        # Video
+        b'\x00\x00\x00\x18ftypmp4': ('mp4', 'video/mp4'),
+        b'\x00\x00\x00\x20ftypM4V': ('m4v', 'video/x-m4v'),
+        b'RIFF....AVI ': ('avi', 'video/x-msvideo'),
+        
+        # Archives
+        b'\x50\x4B\x05\x06': ('zip', 'application/zip'),
+        b'\x50\x4B\x07\x08': ('zip', 'application/zip'),
+        b'\x1F\x8B\x08': ('gz', 'application/gzip'),
+        b'Rar!\x1A\x07\x00': ('rar', 'application/x-rar-compressed'),
+        b'7z\xBC\xAF\x27\x1C': ('7z', 'application/x-7z-compressed'),
+        
+        # Text/Code
+        b'#!/bin/bash': ('sh', 'text/x-shellscript'),
+        b'#!/bin/sh': ('sh', 'text/x-shellscript'),
+        b'<?xml': ('xml', 'text/xml'),
+        b'<html': ('html', 'text/html'),
+        b'<!DOCTYPE html': ('html', 'text/html'),
+    }
+    
+    for sig, (ext, mime) in signatures.items():
+        if data.startswith(sig):
+            # Special handling for RIFF files
+            if sig == b'RIFF' and len(data) >= 12:
+                if data[8:12] == b'WAVE':
+                    return 'wav', 'audio/wav'
+                elif data[8:12] == b'WEBP':
+                    return 'webp', 'image/webp'
+                elif data[8:12] == b'AVI ':
+                    return 'avi', 'video/x-msvideo'
+            return ext, mime
+    
+    # Check for text files
+    try:
+        text = data[:min(512, len(data))].decode('utf-8', errors='strict')
+        if all(ord(c) < 127 and (c.isprintable() or c.isspace()) for c in text):
+            # Further classify text files
+            text_lower = text.lower()
+            if any(keyword in text_lower for keyword in ['<html', '<!doctype', '<head', '<body']):
+                return 'html', 'text/html'
+            elif text.strip().startswith('<?xml'):
+                return 'xml', 'text/xml'
+            elif any(keyword in text_lower for keyword in ['import ', 'def ', 'class ', 'if __name__']):
+                return 'py', 'text/x-python'
+            elif any(keyword in text_lower for keyword in ['#include', 'int main', 'void ']):
+                return 'c', 'text/x-c'
+            elif any(keyword in text_lower for keyword in ['function', 'var ', 'let ', 'const ']):
+                return 'js', 'text/javascript'
+            else:
+                return 'txt', 'text/plain'
+    except UnicodeDecodeError:
+        pass
+    
+    # If no signature matches, return binary
+    return 'bin', 'application/octet-stream'

shadowbits-1.0.0.dist-info/METADATA

@@ -0,0 +1,207 @@
+Metadata-Version: 2.4
+Name: shadowbits
+Version: 1.0.0
+Summary: Powerful steganography tool for hiding files in images and audio using LSB techniques
+Author-email: kaizoku73 <ultimate0134@gmail.com>
+Maintainer-email: kaizoku73 <ultimate0134@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/kaizoku73/ShadowBits
+Project-URL: Repository, https://github.com/kaizoku73/ShadowBits
+Project-URL: Bug Reports, https://github.com/kaizoku73/ShadowBits/issues
+Project-URL: Documentation, https://kaizoku.gitbook.io/steganography
+Project-URL: LSB Image Docs, https://kaizoku.gitbook.io/steganography/lsb-for-image
+Project-URL: LSB Audio Docs, https://kaizoku.gitbook.io/steganography/lsb-for-audio
+Keywords: steganography,lsb,least-significant-bit,image-steganography,audio-steganography,cryptography,security,png,wav,file-hiding,aes-encryption,bits-manipulation
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Topic :: Security :: Cryptography
+Classifier: Topic :: Multimedia :: Graphics
+Classifier: Topic :: Multimedia :: Sound/Audio
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: future>=0.18.0
+Requires-Dist: Pillow>=8.0.0
+Requires-Dist: pycryptodome>=3.15.0
+Dynamic: license-file
+
+# ShadowBits 🔒
+
+A powerful steganography tool that allows you to hide files within images and audio files using LSB (Least Significant Bit) techniques. ShadowBits supports both embedding and extraction operations with optional AES encryption for enhanced security.
+
+## Features
+
+- **Image Steganography**: Hide files within PNG images using LSB manipulation
+- **Audio Steganography**: Embed files in WAV audio files 
+- **AES Encryption**: Optional encryption layer for embedded data
+- **Key-based Randomization**: Uses secret keys to randomize bit placement for enhanced security
+- **Automatic File Type Detection**: Detects and preserves original file types during extraction
+- **Format Validation**: Validates PNG images and WAV audio files before processing
+- **Collision Prevention**: Automatically handles filename conflicts during output
+- **Comprehensive Error Handling**: Robust error handling for various failure scenarios
+
+## Quick Start
+
+### Prerequisites
+
+```bash
+pip install -r requirements.txt
+```
+### Installation
+
+```bash
+pip install shadowbits
+```
+
+### One-Line Installation
+
+```bash
+# System-wide (with sudo)
+curl -sSL https://raw.githubusercontent.com/kaizoku73/ShadowBits/main/install.sh | sudo bash
+
+# User installation (no sudo)
+curl -sSL https://raw.githubusercontent.com/kaizoku73/ShadowBits/main/install.sh | bash
+```
+
+### Uninstallation
+
+```bash
+# To uninstall Resono (no sudo):
+curl -sSL https://raw.githubusercontent.com/kaizoku73/ShadowBits/main/uninstall.sh | bash
+
+# To uninstall Resono (With sudo):
+curl -sSL https://raw.githubusercontent.com/kaizoku73/ShadowBits/main/uninstall.sh | sudo bash
+
+```
+
+## Usage
+
+ShadowBits provides a command-line interface with four main operations:
+
+### Image Operations
+
+#### Embed a file in an image
+```bash
+shadowbits img embed --in secret.txt --cover image.png --key mysecretkey
+```
+
+#### Extract from image
+```bash
+shadowbits img extract --stego stego_image.png --key mysecretkey
+```
+
+
+### Audio Operations
+
+#### Embed a file in audio
+```bash
+shadowbits aud embed --in secret.pdf --cover music.wav --key myaudiokey
+```
+
+#### Extract from audio
+```bash
+shadowbits aud extract --stego stego_audio.wav --key myaudiokey
+```
+
+## How It Works
+
+### LSB Steganography
+ShadowBits uses the Least Significant Bit (LSB) method to hide data:
+
+- **Images**: Modifies the least significant bit of RGB color channels in a randomized order
+- **Audio**: Modifies the least significant bit of audio sample data in a randomized pattern
+
+## What is LSB and how does it work?
+For a detailed explanation on LSB steganography and how it works, check out this article: https://kaizoku.gitbook.io/steganography
+
+### Security Features
+
+1. **Key-based Randomization**: Uses PRNG seeded with your secret key to randomize bit placement
+2. **Automatic AES Encryption**: All data is encrypted using AES-EAX mode with SHA-256 key derivation
+3. **Data Integrity Markers**: Uses start/end markers to ensure data completeness
+4. **Format Validation**: Verifies PNG/WAV file formats before processing
+5. **File Type Detection**: Automatically detects original file type using magic bytes for proper restoration
+
+## Hidden Files
+The tool can hide any file type and will automatically detect and restore the original format using magic byte signatures, including:
+- Images: JPG, PNG, GIF, BMP, WebP, ICO
+- Documents: PDF, DOC, ZIP archives
+- Audio: MP3, OGG, FLAC, WAV
+- Video: MP4, M4V, AVI
+- Archives: ZIP, GZ, RAR, 7Z
+- Text/Code: HTML, XML, Python, C, JavaScript, plain text
+- Binary files: Any other format as .bin
+
+
+## Limitations
+
+- **Image capacity**: Limited by image size (3 bits per pixel for RGB images)
+- **Audio capacity**: Limited by audio file length (1 bit per sample)
+- **File size**: To hide larger files, you need larger cover media file
+
+## Examples
+
+### Hide a document in a photo
+```bash
+shadowbits img embed --in document.pdf --cover vacation.jpg --key family2023
+```
+
+### Extract the hidden document
+```bash
+shadowbits img extract --stego stego_file.png --key family2023
+```
+
+### Hide source code in music
+```bash
+shadowbits aud embed --in source_code.zip --cover favorite_song.mp3 --key coding123
+```
+
+## Security Considerations
+
+- **Key Management**: Use strong, unique keys for each operation
+- **Key Security**: The same key is used for both encryption and randomization
+- **Cover Selection**: Choose cover files with sufficient capacity for your payload
+- **File Format**: Ensure cover images are PNG and audio files are WAV
+- **Key Reuse**: Avoid reusing keys across different files
+
+## Error Handling
+
+ShadowBits includes comprehensive error handling for:
+- Invalid file formats
+- Insufficient cover media capacity  
+- Corrupted embedded data or invalid markers
+- AES Decryption failures (wrong key or corrupted data)
+- Missing files or permissions
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit issues, feature requests, or pull requests.
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Disclaimer
+
+This tool is for educational and legitimate purposes only. Users are responsible for ensuring compliance with applicable laws and regulations when using steganography techniques.
+
+## Support
+
+If you encounter any issues or have questions, please open an issue on GitHub.
+
+---
+
+**ShadowBits** - Where your secrets hide in plain sight 👁️‍🗨️
+
+**Made by kaizoku**

shadowbits-1.0.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+shadowbits/cli.py,sha256=I9yQkazd9epOsbbPNjG8RWCVYzZCtWTErRX2PPP0xiQ,3315
+shadowbits/emb_aud.py,sha256=5kGFYC-r59pWMrgnW3ktDc2h6-Ix_vfyrqGMC7-Dju0,3403
+shadowbits/emb_img.py,sha256=XGZG9GA4za5Upu0oPgRpfh4k4cPBdgRjs6AvlDg4x0k,3382
+shadowbits/ext_aud.py,sha256=SzXs97EedBu3v6iO25ZCLBRAV7tkYRa4XSP3shCx5eE,2592
+shadowbits/ext_img.py,sha256=tgNOlnMVYUEOk3rTXFbekrGdk_emIuDw5ysD82eOlHw,3161
+shadowbits/validator.py,sha256=uauRuxAY4KMfQJpxew-VKuMEx6DYu3wXfsHr0C5TlsY,3544
+shadowbits/crypto/aes.py,sha256=J55J5PN89zqakhOxmAk-Zc6uQwCFifEXTAexxLAF5Q8,945
+shadowbits-1.0.0.dist-info/licenses/LICENSE,sha256=iEyXbm1ZX-a9ro7ubAKtd4A7JsYWHqC6WTC5rWukeNs,1065
+shadowbits-1.0.0.dist-info/METADATA,sha256=m0o93hk-rcKVw76nYlg3Aszvsbwi22PadODkOP89Q08,7306
+shadowbits-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+shadowbits-1.0.0.dist-info/entry_points.txt,sha256=oXTWczfc9Y5-Fa7svu9DdEDj4qzEPNhmymENMRS1C5w,51
+shadowbits-1.0.0.dist-info/top_level.txt,sha256=Di2Wya3HFPV4vkFBc8SAkbeWVPvRglnG_yE7ZaQOHzM,11
+shadowbits-1.0.0.dist-info/RECORD,,

shadowbits-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

shadowbits-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+shadowbits = shadowbits.cli:main

shadowbits-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 kaizoku73
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

shadowbits-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+shadowbits