[c++] & sfml cryptographie

Soyez le premier à donner votre avis sur cette source.

Snippet vu 5 560 fois - Téléchargée 19 fois

Contenu du snippet

Petit code qui "brouille un texte" dans une image...
Oui, qui brouille, au départ j'ai tenté de caché totalement le texte dans l'image en l'éparpillant, mais je cherche

encore un moyen de mélanger les pixels correctement.
Dans ce programme, j'ai juste fait des inversion 2 par 2 de lignes et de colones de pixels.

Voila le principe :

On écrit dans paint un texte sur un fond vert (la couleur de fond doit donc être 0,255,0 dans Couleurs/Modifier les

couleurs... dans paint). Cette image doit être nommée texte.bmp.

Ensuite on prend une autre image, n'importe quel format.

On met les deux à coté de l'executable.

On ouvre le programme, là il demande le nom de l'image (la derniere évoquée),
puis le nom d'enregistrement (n'importe quoi).

On valide, puis on se met sur la fenetre graphique.
On peut voir l'image de départ. On appuie sur une touche, et les pixels sont mélangés, et le texte qui est extrait

de l'image texte.bmp se colle sur ce mélange.
On rappuie est on peut voir l'image remise en place, et le texte brouillé.
En quittant cette image est enregistrée sous le nom précédement rentré.

Pour "débrouiller" le texte, on réouvre le programme, on choisit "décrypter", est les étapes sont quasi-similaire.

Le programme, les dlls et un exemple sont disponibles à cette adresse : http://dl.free.fr/getfile.pl?file=/EyfTgLKj

Source / Exemple :


/// RY-CRYPTEUR
// disponible sur http://dl.free.fr/getfile.pl?file=/EyfTgLKj

#include <SFML/Graphics.hpp>
#include <iostream>
#include <fstream>

int main()
{

    std::cout << " Bienvenue\n\n";
    std::cout << "Cryptage (1)\nDecryptage (2)\n\nVotre choix : ";
    int choix;
    std::cin >> choix;

    std::string chemin;
    std::cout << "\n\n\nNom de l'image : \n";
    std::cin >> chemin;
    std::string NomFin;
    if (choix != 1 && choix != 2)
    {
        EXIT_FAILURE;
    }

    std::cout << "\n\nNom d'enregistrement : \n";
    std::cin >> NomFin;

    system ("PAUSE");

    sf::RenderWindow App(sf::VideoMode(1024, 768), "SFML Views");

    sf::Image Image;
    if (!Image.LoadFromFile(chemin))
        return EXIT_FAILURE;
    sf::Sprite Background(Image);

    Background.Resize(1024, 768);

    App.Clear (sf::Color (255,255,255));
    App.Draw(Background);
    App.Display();

//////////////////// VARIABLES //////////////////////

    /*int mtaillex = Image.GetWidth();
    int mtailley = Image.GetHeight();
    int TAILLEX = (mtaillex / 400) - 1;
    int TAILLEY = (mtailley / 400) - 1 ;*/
    int TAILLEX = 1;
    int TAILLEY = 1;

    std::cout << "\n Taille x: " << TAILLEX << "\n\n";
    std::cout << "\n Taille y: " << TAILLEY << "\n\n";

    sf::Color map [TAILLEX] [TAILLEY];
    sf::Color temp [TAILLEX] [TAILLEY];

    bool next = false;

///////////////////// ATTENTE /////////////////////////

    std::cout << "\n\nVeuillez appuyez sur une touche pour continuer.\n\n";

    next = false;
    while (!next)
    {

        sf::Event Event;
        while (App.GetEvent(Event))
        {

            if ((Event.Type == sf::Event::KeyPressed))
                next = true;
            if (Event.Type == sf::Event::Closed)
                App.Close();

            if ((Event.Type == sf::Event::KeyPressed) && (Event.Key.Code == sf::Key::Escape))
                App.Close();
        }

        App.Clear();
        App.Draw(Background);
        App.Display();
    }

/////////////////// TRAITEMENT //////////////////////

/// En x

    for (int j = 0; j < Image.GetHeight(); j+= (TAILLEY))
    {
        if ((j + TAILLEY) < Image.GetHeight())
        {
            for (int i = 0; i < Image.GetWidth(); i+= (TAILLEX*2))
            {
                if ((i + 2* TAILLEX) < Image.GetWidth())
                {
                    for (int y = 0; y < TAILLEY; y++)
                    {
                        for (int x = 0; x < TAILLEX; x++)
                        {
                            map [x] [y] = Image.GetPixel((i+x),(j+y));
                            temp [x][y] = Image.GetPixel ((i+TAILLEX+x), (j+y));
                        }
                    }
                    for (int y = 0; y < TAILLEY; y++)
                    {
                        for (int x = 0; x < TAILLEX; x++)
                        {
                            Image.SetPixel ((i+x), (j+y), temp [x] [y]);
                            Image.SetPixel ((i+x+TAILLEX),(j+y), map [x][y]);
                        }
                    }

                }
            }
        }
    }

/// En y
    for (int i = 0; i < Image.GetWidth(); i+= (TAILLEX))
    {
        if ((i + 2* TAILLEX) < Image.GetWidth())
        {
            for (int j = 0; j < Image.GetHeight(); j+= (TAILLEY * 2))
            {
                if ((j + TAILLEY) < Image.GetHeight())
                {

                    for (int y = 0; y < TAILLEY; y++)
                    {
                        for (int x = 0; x < TAILLEX; x++)
                        {
                            map [x] [y] = Image.GetPixel((i+x),(j+y));
                            temp [x][y] = Image.GetPixel ((i+x), (TAILLEY+j+y));
                        }
                    }
                    for (int y = 0; y < TAILLEY; y++)
                    {
                        for (int x = 0; x < TAILLEX; x++)
                        {
                            Image.SetPixel ((i+x), (j+y), temp [x] [y]);
                            Image.SetPixel ((i+x),(TAILLEY +j+y), map [x][y]);
                        }
                    }

                }
            }
        }
    }

//////// MISE EN PLACE DE L'OBJET
    if (choix == 1)
    {

        sf::Image imgTexte;

        if (!imgTexte.LoadFromFile("texte.bmp"))
            return EXIT_FAILURE;

        for (int i = 0; i < imgTexte.GetWidth(); i++)
        {
            for (int j = 0; j < imgTexte.GetHeight(); j++)
            {
                if (imgTexte.GetPixel(i,j) != sf::Color (0,255,0))
                {
                    Image.SetPixel (i, j, imgTexte.GetPixel(i,j));
                }
            }
        }

    }

///////////////////// ATTENTE /////////////////////////

    std::cout << "\n\nVeuillez appuyez sur une touche pour continuer.\n\n";

    next = false;
    while (!next)
    {

        sf::Event Event;
        while (App.GetEvent(Event))
        {

            if ((Event.Type == sf::Event::KeyPressed))
                next = true;
            if (Event.Type == sf::Event::Closed)
                App.Close();

            if ((Event.Type == sf::Event::KeyPressed) && (Event.Key.Code == sf::Key::Escape))
                App.Close();
        }

        App.Clear();
        App.Draw(Background);
        App.Display();
    }

////////////////////// Enregistrement //////////////////

    if (choix == 2)
    {
        Image.SaveToFile (NomFin);
        system ("cls");
        std::cout << "Vous pouvez fermer la fenetre.\n\n";
    }

/////////////////// REMISE EN PLACE //////////////////////

/// En y
    for (int i = 0; i < Image.GetWidth(); i+= (TAILLEX))
    {
        if ((i + 2* TAILLEX) < Image.GetWidth())
        {
            for (int j = 0; j < Image.GetHeight(); j+= (TAILLEY * 2))
            {
                if ((j + TAILLEY) < Image.GetHeight())
                {

                    for (int y = 0; y < TAILLEY; y++)
                    {
                        for (int x = 0; x < TAILLEX; x++)
                        {
                            map [x] [y] = Image.GetPixel((i+x),(j+y));
                            temp [x][y] = Image.GetPixel ((i+x), (TAILLEY +j+y));
                        }
                    }
                    for (int y = 0; y < TAILLEY; y++)
                    {
                        for (int x = 0; x < TAILLEX; x++)
                        {
                            Image.SetPixel ((i+x), (j+y), temp [x] [y]);
                            Image.SetPixel ((i+x),(TAILLEY + j+y), map [x][y]);
                        }
                    }

                }
            }
        }
    }

/// En x

    for (int j = 0; j < Image.GetHeight(); j+= (TAILLEY))
    {
        if ((j + TAILLEY) < Image.GetHeight())
        {
            for (int i = 0; i < Image.GetWidth(); i+= (TAILLEX*2))
            {
                if ((i + 2* TAILLEX) < Image.GetWidth())
                {
                    for (int y = 0; y < TAILLEY; y++)
                    {
                        for (int x = 0; x < TAILLEX; x++)
                        {
                            map [x] [y] = Image.GetPixel((i+x),(j+y));
                            temp [x][y] = Image.GetPixel ((i+TAILLEX+x), (j+y));
                        }
                    }
                    for (int y = 0; y < TAILLEY; y++)
                    {
                        for (int x = 0; x < TAILLEX; x++)
                        {
                            Image.SetPixel ((i+x), (j+y), temp [x] [y]);
                            Image.SetPixel ((i+x+TAILLEX),(j+y), map [x][y]);
                        }
                    }

                }
            }
        }
    }

////////////////////// Enregistrement //////////////////

    if (choix == 1)
    {
        Image.SaveToFile (NomFin);
        system ("cls");
        std::cout << "Vous pouvez fermer la fenetre.\n\n";
    }

///////////////////// ATTENTE /////////////////////////

    App.Clear (sf::Color (255,255,255));
    App.Draw(Background);
    App.Display();

    while (App.IsOpened())
    {

        sf::Event Event;
        while (App.GetEvent(Event))
        {

            if (Event.Type == sf::Event::Closed)
                App.Close();

            if ((Event.Type == sf::Event::KeyPressed) && (Event.Key.Code == sf::Key::Escape))
                App.Close();
        }

        App.Clear();
        App.Draw(Background);
        App.Display();
    }

    return EXIT_SUCCESS;
}

Conclusion :


Bon, j'avoue que le code à beau être en C++, il n'est pas très orienté objet.
Mais bon, c'était un petit défi que je m'étais lancé.

Je sais que ce programme est loin (très loin) d'être parfait, et je ne rejetterais pas vos commentaires ainsi vos idées :)

D'ailleurs si quelqu'un connait une façon de vraiment mélanger les pixels de façon mathématique...

M'enfin voila, http://dl.free.fr/getfile.pl?file=/EyfTgLKj

A voir également

Ajouter un commentaire Commentaires
Messages postés
181
Date d'inscription
mardi 6 avril 2010
Statut
Membre
Dernière intervention
7 janvier 2012
9
Merci beaucoup !
Messages postés
285
Date d'inscription
mardi 28 décembre 2004
Statut
Membre
Dernière intervention
20 janvier 2013

Bonjour,
Je n'ai pas regardé le code pour le moment mais je peux déjà donner une piste à ta question.
Ce que tu cherche à faire s'appelle la "Stéganographie". Il en existe des dizaines de formes selon ce qui doit être caché et dans quoi (cf. article de wikipédia http://fr.wikipedia.org/wiki/St%C3%A9ganographie).

Voici une méthode simple pour masquer une donnée dans une image 24 bpp (24 bits par pixel) :
Chaque pixel est composé de 3 octets, un pour le rouge, un pour le vert et un pour le bleu. Ça fait énormément de couleur, bien plus que nos yeux peuvent en distinguer. L'astuce consiste donc a prendre le bit de poids faible de chaque octet pour y stocker un bit de la donnée qu'on souhaite cacher. Ainsi, on dégrade l'image d'origine, mais c'est imperceptible a nos yeux. Attention toute fois, tous les formats ne sont pas compatibles avec cette méthode, par exemple le jpeg ne fonctionne pas car sa compression risque de faire perdre ce bit de données, en revanche, le bmp fonctionne très bien, tout comme le png, qui sont des formats sans pertes.

On remarque que l'inconvénient de la méthode est qu'on ne peut utilisé qu'1/8 du poids de l'image d'origine pour stocker la donnée (puisqu'on utilise un seul bit par pixel). Cependant, rien n'empêche de compresser la données avant de la cacher (même si ca ne fait que repousser le problème).

Il existe évidemment bien d'autres méthodes, je te laisse les chercher si le coeur t'en dit.

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.