hg clone https://bitbucket.org/cedricbonhomme/stegano/
cd stegano/stegano
wget https://lh6.googleusercontent.com/-Sntb2St4xUQ/T5HgDH90JTI/AAAAAAAADwA/IQq_7mFeUhM/s0/sanga.png
python ./slsbset.py --reveal -i ./sanga.png -b OFD --generator XXX
cvlc -L OFD

Il faut remplacer XXX par le bon générateur (énorme indice). Ça fonctionnerai aussi avec une image de taille inférieure, mais je préfère donner une belle photo de Sanga.

J’espère pour vous que cette nouvelle année sera un bon cru. De bonnes nouvelles et un maximum d’épanouissement. Pour ma part 2012 et 2013 vont être je pense assez importantes dans ma vie.

$ slsb-set --hide -i examples/pictures/Montenach.png -o ~/enc-OEIS_A000217.png --generator OEIS_A000217 -m 'Happy new year!'
$ slsb-set --reveal -i ~/enc-OEIS_A000217.png --generator OEIS_A000217
Happy new year!

$ slsb-set --reveal -i ~/enc-OEIS_A000217.png --generator fermat
Impossible to detect message.

Rien de bien compliqué ici. Il s’agit juste de montrer comme il est simple d’ajouter des générateurs.
J’ai aussi ajouté de nouveaux exemples plutôt intéressants, comme celui-ci.

Merci aussi à Vincent qui a répondu à l’appel à l’aide du billet précédent.

Ce post n’est pas assez important pour mériter une photo de Sarah. Mais ne vous inquiétez pas, elle va y passer.

Pourquoi ne pas ajouter la fonction identité ( avec son implémentation en générateur) à la liste des générateurs permettant d’engendrer les ensembles?
On pourrait ensuite vérifier si on peut retrouver le message avec l’outil slsb classique. Faisons le test:

# On cache avec l'outil slsb-set (LSB + fonction identité)
$ slsb-set --hide -i ~/Jessica_Alba.png -o ~/Jessica_Alba-enc-gen.png --generator identity -m 'Je préfère Cédric à Michael Weatherly.'

# On tente de retrouver le message avec l'outils slsb (juste LSB)
$ slsb --reveal  -i ~/Jessica_Alba-enc-gen.png
Je préfère Cédric à Michael Weatherly.

Et ça fonctionne! Ça peut sembler logique, mais pour moi c’était un peu la surprise. La surprise qui veut dire que ce n’est quand même pas codé n’importe comment

Heureusement d’autres générateurs d’ensembles sont disponibles. Voici la liste des générateurs déjà implémenté.

Appel à l’aide. Si vous avez une implémentation un peu voir beaucoup plus performante que la mienne pour Syracuse, elle serait la bienvenue! Mais j’en doute… Syracuse:

Post lié: Stéganalyse de la méthode LSB (avec un ensemble de nombres décrit par crible d’Eratosthenes) avec Jennifer Morrison

Aujourd’hui nous allons en plus caché le message avec la nouvelle technique. Qui consiste à utiliser un ensemble de nombres pour sélectionner les pixels où seront cachés les données. Pour cette exemple nous allons utiliser le crible d’Eratosthenes.

J’avais promis qu’après Elisha Cuthbert nous passerions à Jennifer Morrison.

Ensuite il suffit d’exécuter les commandes:

# Cache le contenu de secret.txt dans Jennifer_Morrison-original.png en utilisant l'ensemble des nombres décrit par le crible d'Eratosthenes
$ slsb-set --hide -i ./Jennifer_Morrison-original.png -o ./Jennifer_Morrison-enc-gen.png --generator eratosthenes -f ./secret.txt
# Stéganalyse du fichier résultant
$ steganalysis-parity -i ./Jennifer_Morrison-enc-gen.png -o ./Jennifer_Morrison-en-gen-steg.png

# Cache le contenu de secret.txt dans Jennifer_Morrison-original.png via la méthode LSB classique
$ slsb --hide -i ./Jennifer_Morrison-original.png -o ./Jennifer_Morrison-enc.png  -f ./secret.txt
# Stéganalyse du fichier résultant
$ steganalysis-parity -i ./Jennifer_Morrison-enc.png -o ./Jennifer_Morrison-en-steg.png 

# Stéganalyse du fichier original
$ steganalysis-parity -i ./Jennifer_Morrison-original.png -o ./Jennifer_Morrison-steg.png

Vous obtiendrez en résultat ces fichiers (survollez avec la souris les images afin de comprendre de quoi il s’agit):

Les 3 sublimes images de la première colonne paraissent identiques.
On peut observer une étrange régularité au début du fichier résultant de la stéganlyse de l’image dans laquelle un texte a été caché via la méthode LSB classique.
Par contre il est plus difficile de détecter une anomalie similaire sur le fichier résultant de la stéganalyse de l’image dans laquelle un texte a été caché via la méthode LSB tout en utilisant un ensemble de points (ici obtenu avec le crible d’Eratosthenes).

Si vous ne me faites pas confiance:

$ wget http://blog.cedricbonhomme.org/wp-content/uploads/2011/12/Jennifer_Morrison-enc.png
$ wget http://blog.cedricbonhomme.org/wp-content/uploads/2011/12/Jennifer_Morrison-enc-gen.png

$ slsb-set --reveal --generator eratosthenes -i ./Jennifer_Morrison-enc-gen.png  -b text-dec-gen.txt
$ slsb --reveal  -i ./Jennifer_Morrison-enc.png  -b text-dec.txt
$ cmp text-dec.txt text-dec-gen.txt
$ cat text-dec.txt
The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.

$ slsb-set --reveal --generator fermat -i ./Jennifer_Morrison-enc-gen.png  -b text-dec-gen.txt
Impossible to detect message.

La conclusion évidente est donc qu’il est préférable de ne pas utiliser des pixels se suivants mais un ensemble de pixels bien réparti que l’on pourra retrouver afin de récupérer le message caché. Ici l’idée était donc de générer des ensembles via des générateurs de nombres entiers. La qualité de la répartition va donc dépendre de la suite choisie. On aurait très bien pu utiliser la suite de Fibonacci par exemple.

Vous trouverez plus de détails ainsi qu’un meilleur exemple à cette page.

La prochaine fois on se fait Jessica Alba ou Sarah Michelle Gellar.

Vous pouvez tester le nouveau module de Stéganô en recopiant le script ci-dessous dans un fichier test-slsb-gen.sh puis en l’excécutant.

hg clone https://bitbucket.org/cedricbonhomme/stegano/
cd stegano/
sudo python setup.py install
echo "We're going to test a little Stéganô..."

echo "Hide the message with the Sieve of Eratosthenes..."
slsb-set --hide -i ./examples/pictures/Montenach.png -o ./surprise.png --generator eratosthenes -m 'Joyeux Noël!'
echo ""

echo "Try to reveal with Mersenne numbers..."
slsb-set --reveal --generator mersenne -i ./surprise.png
echo ""

echo "Try to reveal with fermat numbers..."
slsb-set --reveal --generator fermat -i ./surprise.png
echo ""

echo "Try to reveal with carmichael numbers..."
slsb-set --reveal --generator carmichael -i ./surprise.png
echo ""

echo "Try to reveal with Sieve of Eratosthenes..."
slsb-set --reveal --generator eratosthenes -i ./surprise.png

Vous obtiendrez le résultat suivant:

cedric@montenach:~$ ./test-slsb-gen.sh
destination directory: stegano
requesting all changes
adding changesets
adding manifests
adding file changes
added 53 changesets with 115 changes to 43 files
updating to branch default
23 files updated, 0 files merged, 0 files removed, 0 files unresolved
...
We're going to test a little Stéganô...

Hide the message with the Sieve of Eratosthenes...

Try to reveal with Mersenne numbers...
Impossible to detect message.

Try to reveal with fermat numbers...
Impossible to detect message.

Try to reveal with carmichael numbers...
Impossible to detect message.

Try to reveal with Sieve of Eratosthenes...
Joyeux Noël!

Et voilà le message est bien découvert avec le crible d’Eratosthenes. Il s’agit d’une première version et il y a des améliorations à effectuer. Cependant il est possible de déjà faire quelques tests. Pour le moment il est possible de générer des ensembles avec la suite de Fibonacci, le crible d’Eratosthenes, les nombres de Fermat et Carmichael. Il y a quelques problèmes avec Carmichael et Ackermann. Je ne comprends pas, j’ai pourtant un i7 . Je précise que dans cette implémentation la suite de fermat commence par 1,2,3,… En commençant par les premières valeurs on a des problèmes…

$ hg clone https://bitbucket.org/cedricbonhomme/stegano
$ cd stegano/stegano
$ wget https://lh4.googleusercontent.com/-JsrmdDNU3yQ/TuvK72nZZLI/AAAAAAAADSE/f3yPdaKBLvg/s0/merry-christmas.png
$ python slsb.py --reveal -i merry-christmas.png -b surprise.txt
$ cat surprise.txt

Pour vous rafraîchir la mémoire vous pouvez d’abord lire l’article sur Lena. Nous passons maintenant à Elisha.

Comme d’habitude grâce à notre Python, nous allons découvrir le petit secret que nous cache cette coquine. Voici comment procéder:

$ hg clone https://bitbucket.org/cedricbonhomme/stegano
$ cd stegano/
$ wget http://blog.cedricbonhomme.org/wp-content/uploads/2011/03/Elisha-Cuthbert_enc.jpg
$ chmod u+x *.py
$ ./exif-header.py --reveal -i ./Elisha-Cuthbert_enc.jpg

Comme vous le constatez maintenant il s’agit d’une image JPEG. Le message est en fait simplement passé en base 64, compressé puis caché dans la partie description de l’image. L’avantage est qu’on ne perd pas le secret en la modifiant (compression, rognage, etc.) Cependant, contrairement à la méthode LSB, le fichier gagne quelques octets.
Stéganô comprend maintenant 3 techniques de stéganographies appliquées aux images. Pour plus de détails vous pouvez lire le tutoriel de Stéganô ou cette page en construction.

Pour le prochain exemple nous prendrons Jennifer Morrison.

J’ai reçu il y a quelques jours de Vincent le mail ci-dessous.

----------  Message transmis  ----------
Sujet : Simple Art of Steganography
Date : jeudi 21 octobre 2010
De : ***
À : ***

(1) Download and open "hug me.jpg" , it is a simple jpg picture, representing
my Teddy bear hugging ...;  rename the extension of this file to MP3, so you'll
have "hug me.mp3" , you used to think that it wont work if you simply change
the extension of a file? well you were wrong ! try it, open it [ i used
WINAMP].

can u hear it? can you hear the picture file?!  again change the file extension
to JPG and it is still a pictre file .

(2) Download and open "veronamania.jpg",  change the file extension to RAR, so
you will have "veronamania.rar",  use WinRAR [or other RAR handlers]  to
extract this file and see the other JPG file inside !

well it is called "steganography", refere to link below for complete
definition:

http://www.garykessler.net/library/steganography.html

http://en.wikipedia.org/wiki/Steganography

-------------------------------------------------------

Je vais donc lui (par la même occasion, vous) répondre. Donc je pense qu’il n’y a rien de bien compliqué. Il s’agit de la technique qui consiste à concaténer un fichier (image, musique, etc.) à une archive. Test:

$ zip test.zip test.txt
$ cat Stop_And_Stare.ogg test.zip > Stop_And_Stare-1.ogg

Vous pourrez toujours écouter votre musique. En renommant l’extension vous retrouverez le fichier texte. En gros, c’est du au fait que votre logiciel se contente d’interpréter les données qu’il attend (tar/zip décodent les données compressées). Je préfère de loin les méthodes évoquées précédemment sur ce blog. Elles sont plus marrantes et n’agrandissent pas la taille du fichier.

Tout autre chose, les archives de pyAggr3g470r présentent maintenant mieux les articles. Évidemment on peut toujours exporter en fichier brut.

hg clone http://bitbucket.org/cedricbonhomme/stegano/
cd stegano
wget http://www.gnu.org/music/free-software-song.ogg
./lsb-s.py --hide -i ./pictures/Montenach.png -o ./pictures/Montenach_enc.png -f ./free-software-song.ogg
rm free-software-song.ogg
./lsb-s.py --reveal -i ./pictures/Montenach_enc.png -b ./cool-song.ogg

Ceci seulement pour annoncer qu’une ligne de commande est disponible (avec d’autres améliorations). Plus d’informations sur le Wiki. Et n’hésitez pas à cacher cette fabuleuse chanson dans toutes vos images.

Stéganalyse de l'image originale

Maintenant une stéganalyse du cadeau d’hier:

Stéganalyse de l'image contenant un message

On constate deux choses:

• il reste beaucoup de place. L’algorithme de stéganographie LSB utilise le dernier bit de chaque couleur des pixels. De nombreuses implémentations utilisent les deux derniers. Ce qui signifie que j’aurai pu utiliser une photo de seulement 5Mo pour faire la même chose.
• des données encodées en base 64 sont facilement détectables par stéganalyse. Il faudrait ajouter du bruit et ne pas les insérer à la suite.

La fonction reveal est aussi beaucoup plus rapide grâce à Christophe qui préfère les bits aux strings.

import urllib
import base64
from PIL import Image

def bs(s):
    """
    Converts an int to its bits representation as a string of 0's and 1's.
    """
    return str(s) if s<=1 else bs(s>>1) + str(s&1)

def reveal(img):
    """
    Find a message in an image
    (with the LSB technique).
    """
    width, height = img.size
    bits = ""
    for row in range(height):
        for col in range(width):
            r, g, b = img.getpixel((col, row))
            bits += bs(r)[-1] + bs(g)[-1] + bs(b)[-1]
            if int(bits[-8:], 2) == 126:
                list_of_string_bits = ["".join(list(bits[i:(i+8)])) for i in range(0, len(bits)-8, 8)]
                list_of_character = [chr(int(elem, 2)) for elem in list_of_string_bits]
                return "".join(list_of_character)
    return ""

if __name__ == '__main__':
    # Point of entry in execution mode
    urllib.urlretrieve("http://cedric.bonhomme.free.fr/images/surprise.png", "./surprise.png")
    img = Image.open("./surprise.png")
    surprise = reveal(img)
    data = base64.b64decode(surprise)
    with open("./surprise", "w") as f:
        f.write(data)

Le décodage pourra prendre deux ou trois minutes. Une fois le script terminé, faites un petit file ./surprise. Et vous saurez déjà quoi en faire.

Tout ce que je peux vous dire. 15 Mo is enough! Largement!

Mmm oui, le fichier téléchargé est une photo sous licence Creative Commons. Nous dirons donc que ce fichier peut être partagé.

Voyons ce que cela nous donne avec l’image originale.

Image originale

Stéganalyse de l'image originale

On voit que la répartition n’est localement pas très uniforme (cliquez sur les images pour voir plus près).

Maintenant nous utilisons l’algorithme LSB afin de cacher un message. Ensuite nous réalisons une stéganalyse sur l’image modifiée.

Image avec un texte caché

Stéganalyse de l'image avec un texte caché

Ici on s’aperçoit nettement que la zone où se trouve dissimulé le message est plus uniforme (une des raisons de chiffrer le texte avant de le cacher). En introduisant un message dans l’image nous avons modifié le bit de poids faible (donc la parité) des composantes des pixels. Il faut aussi savoir que dans le système RGB un pixel par exemple blanc sera toujours codé (255, 255, 255) avec les appareils saturants les couleurs (les valeus sont quasi exactes).

J’ai une autre petite idée derrière la tête. Donc avec de la chance nous verrons bientôt une autre méthode utilisant l’entropie pour détecter un message caché dans une image, peut être même le trouver. Si mes résultats seront concluents… Nous pourrons aussi comparer les deux techniques de stéganalyse.

La technique de stéganographie utilisée précédemment pour cacher un message dans une photo est très loin d’être parfaite, comme Christophe la justement fait remarquer. Elle consistait simplement à remplacer la composante rouge (un octet) de chaque pixel par la valeur ASCII d’un caractère du message à cacher. Ceci en partant du début du fichier. La transformation est la suivante:

(R, G, B)
devient:
(ord(ascii_character), G, B)

Le rouge est totalement modifié. On altére considérablement autant de pixels que le message comporte de caractères. D’où la trace noire en haut à gauche de la photo.

Vous vous en doutez, il existe de meilleures façons de dissimuler un message dans une image. Par exemple la méthode bien connue LSB (Least Significant Bit). Les données sont insérées à la place des bits les moins importants. Pour chaque composante RGB on a 256 valeurs possibles et nous faisons varier uniquement le bit de poids faible. La transformation est la suivante:

(R, G, B) = (00000000, 00000001, 00000000)
devient:
(R, G, B) = (00000001, 00000000, 00000001)

Maintenant les composantes sont faiblement détériorées. Évidemment cette méthode encore très simple est attaquable. Mais la belle Lena mérite cet effort.

Voici le code pour voir le message caché dans la photo de ce billet:

import urllib
from PIL import Image

def bs(s):
    """
    Convert an int to its bits representation as a string of 0's and 1's.
    """
    return str(s) if s<=1 else bs(s>>1) + str(s&1)

def decode_image(img):
    """
    Find a message in an encoded image (with the
    LSB technic).
    """
    width, height = img.size
    bits, index = "", 0
    for row in range(height):
        for col in range(width):
            r, g, b = img.getpixel((col, row))
            bits += bs(r)[-1] + bs(g)[-1] + bs(b)[-1]

            if len(bits) >= 8:
                if int(bits[-8:], 2) == 126:
                    list_of_string_bits = ["".join(list(bits[i*8:(i*8)+8])) for i in range(0, len(bits)/8)]

                    list_of_character = [chr(int(elem, 2)) for elem in list_of_string_bits]
                    return "".join(list_of_character)[:-2]
    return ""

urllib.urlretrieve("http://cedric.bonhomme.free.fr/images/Lenna_LSB.png", "Lenna_LSB.png")
img = Image.open("Lenna_LSB.png")
print decode_image(img)

Le code complet (cacher et retrouver un message). Il s’agit d’une première implémentation. J’ai encore quelques améliorations à effectuer, mais le script fonctionne plutôt correctement.

Je pense que je vais bientôt créer un dépôt Mercurial avec des algorithmes de stéganographie

Découvre le message que la petite coquine Lenna te cache en utilisant ton serpent.

Besoin d’un indice?

import urllib
from PIL import Image

def decode_image(img):
    width, height = img.size
    msg = ""
    index = 0
    for row in range(height):
        for col in range(width):
            r, g, b = img.getpixel((col, row))
            if row == 0 and col == 0:
                msg_length = r
            elif index <= msg_length:
                msg += chr(r)
            index += 1
    return msg

urllib.urlretrieve("http://cedric.bonhomme.free.fr/images/Lenna_Simple_Method.png", "Lenna.png")
img = Image.open("Lenna.png")
print decode_image(img)