ragibson/steganographyStéganographie par bit de poids faible pour les images bitmap (.bmp et .png), les fichiers audio WAV et les séquences d'octets. Simple stéganalyse LSB (extraction LSB) pour les images bitmap.
Si vous n'êtes pas familier avec les techniques de stéganographie, j'ai également écrit un aperçu de base du domaine dans Steganography: Hiding Data Inside Data.
Ce projet est sur PyPI et peut être installé avec
pip install stego-lsb
Alternativement, vous pouvez l'installer directement depuis ce dépôt :
git clone https://github.com/ragibson/Steganography
cd Steganography
python3 setup.py install
Après l'installation, utilisez la commande stegolsb dans le terminal ou importez les fonctions depuis stego_lsb dans votre code.
bit_manipulation offre la possibilité d'entrelacer (rapidement) les octets d'une charge utile directement dans les bits de poids faible d'une séquence d'octets porteuse.
Plus précisément, il contient quatre fonctions principales :
# Interleave the bytes of payload into the num_lsb LSBs of carrier.
lsb_interleave_bytes(carrier, payload, num_lsb, truncate=False)
# Deinterleave num_bits bits from the num_lsb LSBs of carrier.
lsb_deinterleave_bytes(carrier, num_bits, num_lsb)
# Runs lsb_interleave_bytes with a List[uint8] carrier.
lsb_interleave_list(carrier, payload, num_lsb)
# Runs lsb_deinterleave_bytes with a List[uint8] carrier.
lsb_deinterleave_list(carrier, num_bits, num_lsb)
Exécuter bit_manipulation.py, appeler sa fonction test() directement, ou exécuter stegolsb test devrait produire une sortie similaire à
Testing 1.0 MB payload -> 10.0 MB carrier...
Progress: [################################]
----------------------------------------
| # LSBs | Taux d'encodage | Taux de décodage |
| 1 | 60.6 MB/s | 95.9 MB/s |
| 2 | 56.6 MB/s | 52.7 MB/s |
| 3 | 82.5 MB/s | 77.4 MB/s |
| 4 | 112.4 MB/s | 105.9 MB/s |
| 5 | 135.9 MB/s | 129.8 MB/s |
| 6 | 159.9 MB/s | 152.4 MB/s |
| 7 | 181.7 MB/s | 174.6 MB/s |
| 8 | 372.8 MB/s | 1121.8 MB/s |
----------------------------------------
WavSteg utilise la stéganographie par bits de poids faible pour cacher un fichier dans les échantillons d'un fichier .wav.
Pour chaque échantillon du fichier audio, nous écrasons les bits de poids faible avec les données de notre fichier.
WavSteg nécessite Python 3
Exécutez WavSteg avec les arguments de ligne de commande suivants :
Command Line Arguments:
-h, --hide To hide data in a sound file
-r, --recover To recover data from a sound file
-i, --input TEXT Path to a .wav file
-s, --secret TEXT Path to a file to hide in the sound file
-o, --output TEXT Path to an output file
-n, --lsb-count INTEGER How many LSBs to use [default: 2]
-b, --bytes INTEGER How many bytes to recover from the sound file
--help Show this message and exit.
Exemple :
$ stegolsb wavsteg -h -i sound.wav -s file.txt -o sound_steg.wav -n 1
# OR
$ stegolsb wavsteg -r -i sound_steg.wav -o output.txt -n 1 -b 1000
Cacher des données utilise les arguments -h, -i, -s, -o et -n.
La commande suivante cacherait le contenu de file.txt dans sound.wav et enregistrerait le résultat sous sound_steg.wav. La commande affiche également combien d'octets ont été utilisés sur un maximum théorique.
Exemple :
$ stegolsb wavsteg -h -i sound.wav -s file.txt -o sound_steg.wav -n 2
Using 2 LSBs, we can hide 6551441 bytes
Files read in 0.01s
5589889 bytes hidden in 0.24s
Output wav written in 0.03s
Si vous tentez de cacher trop de données, WavSteg affichera le nombre minimum de LSB nécessaire pour cacher vos données.
Récupérer des données utilise les arguments -r, -i, -o, -n et -b
La commande suivante récupérerait les données cachées de sound_steg.wav et les enregistrerait sous output.txt. Cela nécessite que la taille en octets des données cachées soit exacte, sinon le résultat pourrait être trop court ou contenir des données superflues.
Exemple :
$ stegolsb wavsteg -r -i sound_steg.wav -o output.txt -n 2 -b 5589889
Files read in 0.02s
Recovered 5589889 bytes in 0.18s
Written output file in 0.00s
LSBSteg utilise la stéganographie par bits de poids faible pour cacher un fichier dans les informations de couleur d'une image RVB (.bmp ou .png).
Pour chaque canal de couleur (par exemple, R, V et B) dans chaque pixel de l'image, nous écrasons les bits de poids faible de la valeur de couleur avec les données de notre fichier. Afin de faciliter la récupération de ces données, nous cachons également la taille du fichier d'entrée dans les premiers canaux de couleur de l'image.
Vous avez besoin de Python 3 et de Pillow, un fork de la Python Imaging Library (PIL).
Exécutez LSBSteg avec les arguments de ligne de commande suivants :
Command Line Arguments:
-h, --hide To hide data in an image file
-r, --recover To recover data from an image file
-a, --analyze Print how much data can be hidden within an image [default: False]
-i, --input TEXT Path to an bitmap (.bmp or .png) image
-s, --secret TEXT Path to a file to hide in the image
-o, --output TEXT Path to an output file
-n, --lsb-count INTEGER How many LSBs to use [default: 2]
-c, --compression INTEGER RANGE
1 (best speed) to 9 (smallest file size) [default: 1]
--help Show this message and exit.
Exemple :
$ stegolsb steglsb -a -i input_image.png -s input_file.zip -n 2
# OR
$ stegolsb steglsb -h -i input_image.png -s input_file.zip -o steg.png -n 2 -c 1
# OR
$ stegolsb steglsb -r -i steg.png -o output_file.zip -n 2
Avant de cacher des données dans une image, il peut être utile de voir combien de données peuvent être cachées. La commande suivante permet de le faire, produisant une sortie similaire à
$ stegolsb steglsb -a -i input_image.png -s input_file.zip -n 2
Image resolution: (2000, 1100, 3)
Using 2 LSBs, we can hide: 1650000 B
Size of input file: 1566763 B
File size tag: 3 B
La commande suivante cachera des données dans l'image d'entrée et écrira le résultat dans l'image stéganographiée, produisant une sortie similaire à
$ stegolsb steglsb -h -i input_image.png -s input_file.zip -o steg.png -n 2 -c 1
Files read in 0.26s
1566763 bytes hidden in 0.31s
Image overwritten in 0.27s
La commande suivante récupérera les données de l'image stéganographiée et écrira le résultat dans le fichier de sortie, produisant une sortie similaire à
$ stegolsb steglsb -r -i steg.png -o output_file.zip -n 2
Files read in 0.30s
1566763 bytes recovered in 0.28s
Output file written in 0.00s
StegDetect fournit une méthode pour détecter la stéganographie simple dans les images.
Vous avez besoin de Python 3 et de Pillow, un fork de la Python Imaging Library (PIL).
Exécutez StegDetect avec les arguments de ligne de commande suivants :
Command Line Arguments:
-i, --input TEXT Path to an image
-n, --lsb-count INTEGER How many LSBs to display [default: 2]
--help Show this message and exit.
Nous additionnons les n bits de poids faible des canaux de couleur RVB pour chaque pixel et normalisons le résultat dans la plage 0-255. Cette valeur est ensuite appliquée à chaque canal de couleur pour le pixel. Où n est le nombre de bits de poids faible à afficher, la commande suivante enregistrera l'image résultante, en ajoutant "_nLSBs" au nom du fichier, et produira une sortie similaire à la suivante :
$ stegolsb stegdetect -i input_image.png -n 2
Runtime: 0.63s