Stéganographie facile en python

[invite5eadf00c]

Bonsoir à tous,

Je dois réaliser un projet sur la stéganographie.
Ma problématique se tourne plutôt vers les méthodes d'insertion et d'extraction pour le moment.

J'ai très peu de connaissances en informatique et je viens de débuter le python il y a quelques mois.

Pour continuer mon projet, j'ai avant tout besoin d'un programme simple (impérativement en python) qui me permettrais d'insérer un fichier texte dans une image (non compressée type jpeg).

J'ai trouvé quelques programmes tout faits sur internet, mais je ne sais pas comment les mettre en marche à partir de mon ordinateur.

Pourriez-vous me donner des pistes, voire me suggérer quelques programmes qui pourraient être intéressants et me donner des indications quant à leur usage ?


Je pense avoir besoin d'être beaucoup éclairée sur ce sujet,

Merci d'avance et bonne soirée!
-----

[henryallen]

Bonsoir

Bon, quand j'ai lu ce message, cela m'a rappelé ce que j'avais déjà lu sur la stéganographie, et puisqu'entre temps j'avais appris un peu de python, je me suis dit: pourquoi pas ? J'ai donc moi-même effectué des recherches, et je vais expliquer juste après ce que j'ai compris. Ici, je détaille comment cacher une image dans une image, mais j'explique également très brièvement comment cacher du texte dans une image, il faudra juste adapter la méthode. Il est fort possible que j'aie mal compris certaines notions, ou que j'aie commis des fautes dans ce que j'ai écrit. Je m'en excuse par avance.

Donc voilà:

Rappels sur l’écriture binaire :

Lorsqu’on écrit des nombres, on utilise généralement la base décimale, ou base 10, c’est-à-dire qu’on utilise 10 chiffres : 0, 1, 2, 3, 4, 5, 6, 7, 8 et 9. Mais il est possible d’en utiliser un nombre différent : 16 dans le cas du système hexadécimal, ou juste 2 pour le système binaire (en l’occurrence le 0 et le 1). Comment comprendre par exemple 1001 en binaire ? Tout d’abord, il faut regarder en décimal : si l’on considère par exemple 1234, on peut le décomposer ainsi : 1000 + 2*100 + 3*10 + 4*1 soit, avec des puissances de 10, 10³+2*10²+3*10¹+4*10⁰. Finalement, on a ceci :
1 2 3 4
10³ 10² 10¹ 10⁰

Chaque chiffre, selon la place qu’il occupe dans le nombre, est associé à une certaine puissance de 10. Et en multipliant chaque chiffre par la puissance de 10 correspondante, et en sommant le tout, on retrouve 1234.
Prenons un exemple plus concret en base 2 : 101101. Combien ce nombre vaut-il en base décimale ? Reprenons le tableau, mais en utilisant ici les puissances de 2 (puisqu’on est en base 2).
1 0 1 1 0 1
2⁵ 2⁴ 2³ 2² 2¹ 2⁰

On multiplie chaque chiffre par la puissance de 2 correspondante, et on somme :
1*2⁵+0*2⁴+1*2³+1*2²+0*2¹+1*2⁰=32+8+4+1=45.
Donc 101101₂=45₁₀.
Voilà, comprendre le binaire sera utile par la suite.
Pour terminer ces rappels, quelques notions :
-un bit correspond à un chiffre dans un nombre en binaire : 101 comporte 3 bits, et 11111 5 bits par exemple ;
-un octet est composé de 8 bits, comme par exemple 11011001 ;
-on peut remarquer, d’après ce qu’on a vu précédemment, que les différents bits n’ont pas le même « poids » : si l’on prend 1001, le 1 de gauche a une valeur supérieure à celui de droite, on parle respectivement de bit de poids lourd et de bit de poids faible, ce qui sera utile plus tard.

Images et pixels :

Bon, et la stéganographie alors ? Patience … Avant de se lancer dans le sujet lui-même, il faut comprendre comment une image est définie. Il est connu qu’une image est composée de pixels, des sous-unités colorées. Or les ordinateurs aiment bien avoir tout de quantifié, donc comment attribuer aux couleurs un nombre ?
Tout d’abord, il faut parler de synthèse additive. Si l’on prend une lumière rouge et une lumière verte, la combinaison des deux formera une lumière jaune. C’est cela, la synthèse additive. Et les trois couleurs primaires de cette synthèse (opposée à la synthèse soustractive, comme avec la peinture) sont le rouge, le bleu et le vert. Ainsi, avec ces trois couleurs nuancées, on peut recréer n’importe quelle autre couleur. Aucune couleur et ce sera du noir, toutes de même intensité et on aura du blanc par exemple.
Donc pour quantifier la couleur d’un pixel, on peut quantifier l’intensité de chacune des trois couleurs primaires. Soit, mais comment ? En réalité, un nombre compris entre 0 et 255 permet de disposer de suffisamment de nuances. Ainsi, un pixel comporte trois nombres entre 0 et 255, correspondant à l’intensité de rouge, de bleu et de vert. Et en binaire alors ? Eh bien, on peut le calculer : un octet est équivalent, en base 10, à un nombre compris entre 0 et 255. Ainsi 00000000₂=0₁₀ et 11111111₂=255₁₀. Donc finalement, un pixel est défini par trois octets (pour sa couleur).


Stéganographie :

Et alors, comment utiliser tout ça pour cacher une image dans une autre ? A mon avis, le plus simple est de commencer par un exemple. Prenons donc un pixel A défini, pour les couleurs, par le tuple suivant : (157, 236, 27), et le pixel B : (12, 121, 69). En convertissant en binaire, on a : A : (10011101, 11101100, 00011011) et B 00001100, 01111001, 01000101). Comment « cacher » le pixel A dans le pixel B ? Il faut en revenir à la notion de bits de poids lourd et faible. Ainsi, le premier octet de A, 10011101, a comme trois grands bits forts 1, 0, 0. En utilisant uniquement ces trois bits auxquels on rajoute à la suite 5 zéros (10000000), et en négligeant les autres, on obtient une approximation raisonnable du premier octet de A (157 en réalité contre 128 avec la version modifiée). Ces bits représentent donc une bonne partie du premier octet. Nous voulons donc les insérer dans le premier octet de B, sans trop modifier celui-ci. Il faut donc les mettre … à la place des trois bits de poids faible : 00001100. On effectue donc la modification : 00001100, et on prend cet octet comme le premier de C, l’image où A est caché dans B. On fait de même avec les autres, et on obtient ainsi successivement : 01111111 et 01000000. Et donc on obtient ici un pixel, qui est C: (00001100, 01111111, 01000000). L’avantage de ce pixel est qu’il est très proche de B, et contient l’essentiel de l’information de A. En effectuant cette opération pour tous les pixels, on obtient donc une image cachée dans une autre.

Et pour retrouver l’image d’origine alors ?

Prenons l’exemple du pixel C, et supposons qu’on veuille retrouver A. On prend, pour chaque octet de C, les 3 derniers bits : (100, 111, 000). Or on veut des octets, donc on complète par des 0 : (10000000, 11100000, 00000000). Et voilà, on a le pixel A … plus ou moins. On ré effectue cette opération pour chaque pixel, et on retrouve une image semblable à l’image qu’on a cachée.
Remarquons que j’ai pris les 3 bits lourds/légers, mais on peut l’effectuer avec moins ou plus. Et de plus, j’ai implicitement supposé que les deux images que je « fusionnais » avaient la même taille, ce qui n’est pas forcément le cas. On peut ainsi très bien prendre l’image leurre (celle dans laquelle on cache l’autre) plus grande, et par exemple, pour chaque octet de l’autre image (à cacher), on met un bit dans un octet de l’image leurre. Ainsi l’image leurre sera beaucoup plus grande que l’image à cacher, mais la modification sera beaucoup moins visible et l’image cachée sera identique du début à la fin.
Bon, OK, et pour mettre un texte dans une image alors ? Je n’ai pas vraiment fait sur ça pour le moment, mais il faut utiliser un principe similaire : convertir le texte en binaire, et le cacher dans les bits de l’image. Comment effectuer cette conversion ? Il faut se pencher sur la table ASCII, qui à chaque caractère associe un nombre décimal, qu’on peut transformer en binaire. Après, reste à trouver une taille pour l’image qui serait bonne.

Donc, là, on a fait de la théorie. C’est bien, mais nous, on veut un programme Python ! Donc, comment faire ? J’ai pour ma part utilisé le module Pillow (PIL), qui doit être téléchargé en plus du pack d’installation (le mieux est de regarder une vidéo sur Internet). Je vais donner quelques indications :
-Déjà, il faut au début faire : from PIL import Image ;
-Pour ouvrir une image : image=Image.open(« image.bmp ») ;
-Pour obtenir les nombres RVB : image=image.convert(‘RGB’) ;
-Et pour obtenir une liste à partir de là : liste=list(image.getdata()) ;
-Et pour créer une image par la suite, on fait ceci : image2=Image.new(image.mode, image.size) (ici, image correspond à l’image de même taille que celle que l’on souhaite, l’image leurre comme je l’ai appelée plus tôt) ;
-Pour associer à cette image une liste RVB (en nombres décimaux) : image2.putdata(liste2) où liste 2 correspond à la liste des tuples (RVB) ;
-Enfin, pour enregistrer : image2.save(« nom.bmp »).
Pour faire clair, si j’ai une image (image1) que je souhaite copier dans image2, je fais ceci :

from PIL import Image
image1=Image.open(« image1.bmp »)
image1=image1.convert(‘RGB’)
liste1=list(image1.getdata())
liste2=list(liste1)
image2=Image.new(image1.mode, image1.size)
image2.putdata(liste2)
image2.save(« image2.bmp »)

Note: la fonction bin, qui en argument prend un nombre en base décimale, renvoie une chaîne de caractères de la forme "0b*", où * est l'écriture binaire du nombre entré.

Je n'ai pas mis directement de programme puisque je suppose qu'il est toujours mieux d'essayer soi même. Et puis bon ... Mon programme n'est pas super !

D'autres personnes pourront éventuellement me corriger et/ou me compléter.

Bonne soirée, à bientôt peut-être

[invite23cdddab]

Petite remarque en passant : le jpeg est un format compressé et avec pertes, faire de la stéganographie sur du jpeg est donc plus compliqué, car la méthode proposée par henryallen n'est plus utilisable telle qu'elle.

Si le format est sans pertes mais juste compressé (par exemple un png) on peut appliquer cette méthode à l'image au format RGB, la convertir au format png, et à l'autre bout de la chaine, la reconvertir en format RGB et récupérer les infos (comme il n'y a pas de pertes, on est assuré de retrouver toute l'information intacte : ça n'est pas le cas avec du jpeg)