Extraire les bits d'un fichier quelconque, lire et réécrire un fichier

**wilfryjules** · 12/02/2012, 17h43

Bonsoir,

voici mon but: Récupérer un fichier quelconque contenant une information, et le mettre dans une image (stéganographie).
Mais je ne vous demande que de m'aider sur la manipulation de fichiers en c++.

En effet j'ai déjà réussi à stéganographier un message binaire (image binaire) dans une autre image couleur, en mélangeant les pixels suivant une séquence bien précise obtenue grâce à un générateur de nombres et un mot de passe ... bref !
Maintenant, j'aimerais stéganographier un fichier quelconque, en récupérant les bytes de ce dernier!!

J'ai déjà commencer ça, j'arrive à récupérer le fichier, mais j'ai un problème pour capturer les différents bytes du fichier !!!

Votre aide me serait fort utile !!

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
 
 
 
 
string demandeLeChemin(void)
{
	string chemin;
 
	cout << "Entrez le chemin d'accès au fichier\n";
	cin >> chemin;
 
	return chemin;
 
}
 
ifstream message;  // message object 
int entier; 
double decimal; 
char caractere;
 
 
int main( int argc, char** argv )
{
 
     int n=0,i=0;
 
     char c[50];
     int flag_byte=0;
     unsigned char bit[200000];
 
 
     if (argc == 1) 
     {
		 do 
                 { 
                       message.open(demandeLeChemin());  
                 } 
		 while (!message);
 
 
 
		 //cout << message.get() << "\n";
		 //cout << message.peek() << "\n";
		 cout << message.get(c,0) << "\n";
 
 
		 while (c[i] != EOF)
		 {
			//cette fonction prend en paramètre un fichier ou flux, et renvoi un caractère
            //la premiere fois qu'elle est apelé elle revoi le 1er caractère, la deuxième fois elle revoit le deuxième, ect...,
			//Ensuite sur chaque octet, tu peut aisément lire la suite des 8 bits en utilisant des masques binaires. 
			c[i] =message.get();  
 
			cout << endl << "On se trouve au " << message.tellg() << " ieme octet." << endl;
 
 
 
			if (c[i] & 0x01 == 0x01)
			{
				cout << 1;
				bit[flag_byte] = 1;
			}
			else  
			{
				cout << 0;
				bit[flag_byte] = 0;
			}
 
			if (c[i] & 0x02 == 0x02)
			{
				cout << 1;
				bit[flag_byte+1] = 1;
			}
			else
			{
				cout << 0;
				bit[flag_byte+1] = 0;
			}
 
		        if (c[i] & 0x04 == 0x04)
			{
				cout << 1;
				bit[flag_byte+2] = 1;
			}
			else
			{
				cout << 0;
				bit[flag_byte+2] = 0;
			}
 
		        if (c[i] & 0x08 == 0x08)
			{
				cout << 1;
				bit[flag_byte+3] = 1;
			}
			else
			{
				cout << 0;
				bit[flag_byte+3] = 0;
			}
 
		        if (c[i] & 0x10 == 0x10)
			{
				cout << 1;
				bit[flag_byte+4] = 1;
			}
			else
			{
				cout << 0;
				bit[flag_byte+4] = 0;
			}
 
		        if (c[i] & 0x20 == 0x20)
			{
				cout << 1;
				bit[flag_byte+5] = 1;
			}
			else
			{
				cout << 0;
				bit[flag_byte+5] = 0;
			}
 
		        if (c[i] & 0x40 == 0x40)
			{
				cout << 1;
				bit[flag_byte+6] = 1;
			}
			else
			{
				cout << 0;
				bit[flag_byte+6] = 0;
			}
 
		        if (c[i] & 0x80 == 0x80)
			{
				cout << 1;
				bit[flag_byte+7] = 1;
			}
			else
			{
				cout << 0;
				bit[flag_byte+7] = 0;
			}
 
 
 
			flag_byte += 8;
 
			if (c[i] == 'e') 
			{
				n++;
			}
 
			i++;
 
			message.peek();
 
		 }
 
		  cout << "Il y a "<< n <<" fois le caractère 'e' dans ton message.\n";
		  message.close();
 
 
 
		  //00000001b = 0x01 = 1
		  //00000010b = 0x02 = 2
		  //00000100b = 0x04 = 4
		  //00001000b = 0x08 = 8
		  //00010000b = 0x10 = 16
		  //00100000b = 0x20 = 32
		  //01000000b = 0x40 = 64
		  //10000000b = 0x80 = 128
 
 
 
		 return 0;
 
	 }
	 else
	 {
		   // not OK : main returns -1
		   return -1;
	 }
 
 
}

Une fois que j'aurai tous les bits de mon fichier dans mon tableau bit[], je pourrai les mettre dans mon image, ça je sais faire !!!
merci pour votre aide!!

**aslo92** · 13/02/2012, 12h07

Bonjour,

voici la solution que je te propose:
Plutôt que de de lire ton fichier caractère par caractère, je te propose de recopier son contenu en mémoire. La lecture sera plus rapide et tu auras facilement accès à tous les bits que tu veux.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#include <iostream>
#include <fstream>
using namespace std;
 
int main () {
  int length;
  char * buffer;
 
  ifstream is;
  is.open(demandeLeChemin(), ios::binary );
 
  // Obtenir la taille du fichier
  is.seekg(0, ios::end);
  length = is.tellg();
  is.seekg(0, ios::beg);
 
  // Allouer de la mémoire pour le fichier
  buffer = new char [length];
 
  // Ecrire les données en mémoire
  is.read (buffer,length);
  is.close();
 
  // Utiliser les données ici
 
  // Libérer la mémoire une fois le traitement terminé
  delete[] buffer;
  return 0;
}

Je te propose ensuite de modifier ton code ainsi:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
		 for (int i=0, i<length; i++)
		 {
			char c = buffer[i];  
			cout << endl << "On se trouve au " << i << " ieme octet." << endl;
 
			if (c & 0x01 == 0x01)

Attention à ton buffer bit, car sa taille est fixe et il y a un risque de débordement. Il serait plus judicieux de l'allouer dynamiquement comme pour buffer avec une taille égale à length * 8.

J'imagine que ce buffer sert ensuite à modifier le bit de poid faible de ton image. Pour optimiser, je chargerai l'image et le message en mémoire et je ferai directement le traitement à partir de deux buffers. Ca économisera le traitement du buffer intermédiaire: bit et ça sera plus rapide.

**wilfryjules** · 13/02/2012, 17h21

Ok, merci pour cette réponse, je vais voir ça de près !!

En effet, il faut ensuite que je vérifie que mon fichier contient moins de bit que la taille de mon image, c'est à dire pixels_ligne * pixel_col * 3

car il y a 3 channels de couleurs dans mes images.

ça fait donc en octets: pixels_ligne * pixel_col * 3 * 1/8

**therwald** · 13/02/2012, 18h10

Juste une question: la séquence d'accès aux bits est-elle prédictible à un moment donné (c'est une question "naïve, car je ne m'y connais pas en stéganographie)? Parce que le point faible de ce chargement intégral c'est la consommation mémoire, qui rendra très coûteux d'encrypter des fichiers volumineux (gros fichier = bcp de données à charger + nécessité d'utiliser une image haute résolution donc volumineuse pour avoir assez de pixels). Une méthode de transposition permettant de traiter les données en streaming (par petits blocs et non en globalité) permettrait de plafonner cette consommation.

**wilfryjules** · 13/02/2012, 18h43

Pour te répondre Therwald, je ne sais pas... je me contente juste de faire mon devoir !

Je réfléchirai à tout ça un autre jour !!

Mais sinon j'ai une 2eme question:

Est ce normal que, pour chaque octet, j'obtienne soit-
- que des zéro : 00000000
- soit que des 1: 11111111

J'obtiens ça à chaque fois !!!!

Pourquoi n'ai-je jamais 01000100 par exemple ?

Code:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
 
 
 
#include <stdlib.h>
#include <stdio.h>
#include <cv.h>   		// open cv general include file
#include <highgui.h>	// open cv GUI include file
#include <fstream>		// standard C++ I/O
 
/*
- la classe ofstream (output file stream) permet d'insérer (put) des données dans le fichier
associé à la variable ou, en d'autres termes, d'écrire dans le fichier ;
- la classe ifstream (input file stream) permet d'extraire (get) des données du fichier associé à
la variable ou, en d'autres termes, de lire le fichier ;
*/
 
using namespace cv; // OpenCV API is in the C++ "cv" namespace
using namespace std;
 
 
 
unsigned char getBitN(unsigned char testvalue, int bit) 
{
     unsigned char b;
     b = 1 & (testvalue >> bit); // décalage à droite de "bit"
     return b;
}
 
 
 
string demandeLeChemin(void)
{
	string chemin;
 
	cout << "Entrez le chemin d'accès au fichier\n";
	cin >> chemin;
 
	return chemin;
 
}
 
 
 
 
int main( int argc, char** argv )
{
 
     int length;
     char * buffer;
     char s[50000];
     ifstream message;  // message object 
 
 
     if (argc == 1) 
    {
 
	        do 
                { 
                    message.open(demandeLeChemin(), ios::binary);  
                } 
	         while (!message);
 
		 // we get the length of the file
                 message.seekg(0, ios::end);
		 length = message.tellg();
	         message.seekg(0, ios::beg);
 
		 // We allocate memory for the file
                 buffer = new char [length];
 
		 // We write data in the memory
                 message.read (buffer,length);
 
		 // Utiliser les données ici
 
 
 
		 // Libérer la mémoire une fois le traitement terminé
		 delete[] buffer;
 
		 int n=0;
 
		 for (int i=0; i<length; i++)
		 {
 
				char c = buffer[i];  
 
				cout << endl << "On se trouve au " << i << " ieme octet." << endl;
 
				if (c & 0x01 == 0x01)
				{
					cout << 1;
				}
				else  
				{
					cout << 0;
				}
 
				if (c & 0x02 == 0x02)
				{
					cout << 1;
				}
				else  
				{
					cout << 0;
				}
 
				if (c & 0x04 == 0x04)
				{
					cout << 1;
				}
				else  
				{
					cout << 0;
				}
 
				if (c & 0x08 == 0x08)
				{
					cout << 1;
				}
				else  
				{
					cout << 0;
				}
 
				if (c & 0x10 == 0x10)
				{
					cout << 1;
				}
				else  
				{
					cout << 0;
				}
 
				if (c & 0x20 == 0x20)
				{
					cout << 1;
				}
				else  
				{
					cout << 0;
				}
 
				if (c & 0x40 == 0x40)
				{
					cout << 1;
				}
				else  
				{
					cout << 0;
				}
 
				if (c & 0x80 == 0x80)
				{
					cout << 1;
				}
				else  
				{
					cout << 0;
				}
 
 
				cout << "\n";
 
 
 
		 } // for
 
 
		 message.close();
 
 
		//00000001b = 0x01 = 1
		//00000010b = 0x02 = 2
		//00000100b = 0x04 = 4
		//00001000b = 0x08 = 8
		//00010000b = 0x10 = 16
		//00100000b = 0x20 = 32
		//01000000b = 0x40 = 64
		//10000000b = 0x80 = 128
 
		return 0;
 
	 }
	 else
	 {
		 return -1;
	 }
 
 
}

**aslo92** · 14/02/2012, 11h46

Si tu essayais de déplacer la ligne 79 vers la ligne 171 ...

**therwald** · 14/02/2012, 11h59

Note que l'utilisation d'un std::vector<char> te délivrerais de la gestion du delete et de la longueur, si c'est autorisé par ton exo...

**wilfryjules** · 14/02/2012, 12h27

Voilà, j'ai déplacé le delete[] buffer;

mais rien n'y change, j'obtiens toujours une liste d'octets soit tout à 0:
-00000000
soit tout à 1:
-11111111

Est-ce normal?

Voici mon fichier texte que je charge:
"hey !! tu ne rentres pas à la maison?"

un message tout simple quoi...

Sinon, je préfère utiliser un buffer, car il faudra ensuite que je vérifie que la taille de mon fichier est bien inférieure à celle de mon image, afin de pouvoir stéganographier les bits;

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
 
 
 
int main( int argc, char** argv )
{
 
	 int length;
     char * buffer;
     char s[50000];
     ifstream message;  // message object 
 
 
     if (argc == 1) 
	 {
 
		 do 
         { 
              message.open(demandeLeChemin(), ios::binary);  
         } 
		 while (!message);
 
		 // we get the length of the message file 
         message.seekg(0, ios::end);
		 length = message.tellg();
	     message.seekg(0, ios::beg);
 
		 // We allocate memory for the file
         buffer = new char [length];
 
		 // We write data in the memory
         message.read (buffer,length);
 
		 // Utiliser les données ici
 
 
		 int n=0;
 
		 for (int i=0; i<length; i++)
		 {
 
				char c = buffer[i];  
 
				cout << endl << "On se trouve au " << i << " ieme octet." << endl;
 
				if (c & 0x01 == 0x01)
				{
					cout << 1;
				}
				else  
				{
					cout << 0;
				}
 
				if (c & 0x02 == 0x02)
				{
					cout << 1;
				}
				else  
				{
					cout << 0;
				}
 
				if (c & 0x04 == 0x04)
				{
					cout << 1;
				}
				else  
				{
					cout << 0;
				}
 
				if (c & 0x08 == 0x08)
				{
					cout << 1;
				}
				else  
				{
					cout << 0;
				}
 
				if (c & 0x10 == 0x10)
				{
					cout << 1;
				}
				else  
				{
					cout << 0;
				}
 
				if (c & 0x20 == 0x20)
				{
					cout << 1;
				}
				else  
				{
					cout << 0;
				}
 
				if (c & 0x40 == 0x40)
				{
					cout << 1;
				}
				else  
				{
					cout << 0;
				}
 
				if (c & 0x80 == 0x80)
				{
					cout << 1;
				}
				else  
				{
					cout << 0;
				}
 
 
 
				cout << "\n";
 
 
		 } // for
 
		 // Libérer la mémoire une fois le traitement terminé
		 delete[] buffer;
		 message.close();
 
 
		//00000001b = 0x01 = 1
		//00000010b = 0x02 = 2
		//00000100b = 0x04 = 4
		//00001000b = 0x08 = 8
		//00010000b = 0x10 = 16
		//00100000b = 0x20 = 32
		//01000000b = 0x40 = 64
		//10000000b = 0x80 = 128
 
		return 0;
 
	 }
	 else
	 {
		 return -1;
	 }
 
 
}

**therwald** · 14/02/2012, 12h31

Envoyé par wilfryjules

Sinon, je préfère utiliser un buffer, car il faudra ensuite que je vérifie que la taille de mon fichier est bien inférieure à celle de mon image, afin de pouvoir stéganographier les bits;

Je ne comprends pas le rapport...un std::vector te donnera la taille aussi bien qu'un buffer...
Sinon, au hasard, je dirais que c'est un problème de priorité (0xbb==0xbb serait fait avant c & ... Ajoute des parenthèses pour en avoir le coeur net...

**wilfryjules** · 14/02/2012, 13h13

Merci Therwald !! C'était ça !! ça marche !!

Sinon, j'aimerais bien suivre ton conseil pour le vector<char>, mais j'ai du mal à ajouter les données de file au vecteur,

avec un truc comme ça?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
 
vector<char> buffer;
 
while(!message.eof())
{
buffer.puchback(message.get()); //? ne marche pas... je sais plus trop comment faire,,
}

**therwald** · 14/02/2012, 13h15

Qu'entends tu par "ne marche pas"?

ne compile pas
plante
?

**wilfryjules** · 14/02/2012, 13h25

Oui ça plante, mais ça compile, bref je ne sais tout simplement pas manier ces vecteurs..

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
 
 while (!message.eof())
		 {
			buffer.push_back(message.peek());
 
		 }
 
 int n=0;
 
		 for (int i=0; i<length; i++)
		 {
 
				char c = buffer[i];  
 
				cout << endl << "On se trouve au " << i << " ieme octet." << endl;
 
				if ((c & 0x01) == 0x01)
				{
					cout << 1;

**aslo92** · 14/02/2012, 14h18

J'ai modifié un peu ton code pour que ça marche :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
 
#include <iostream>
#include <stdlib.h>
#include <stdio.h>
//#include <cv.h>   		// open cv general include file
//#include <highgui.h>	// open cv GUI include file
#include <fstream>		// standard C++ I/O
 
/*
- la classe ofstream (output file stream) permet d'insérer (put) des données 
dans le fichier
associé à la variable ou, en d'autres termes, d'écrire dans le fichier ;
- la classe ifstream (input file stream) permet d'extraire (get) des données 
du fichier associé à
la variable ou, en d'autres termes, de lire le fichier ;
*/
 
//using namespace cv; // OpenCV API is in the C++ "cv" namespace
using namespace std;
 
unsigned char getBitN(unsigned char testvalue, int bit) 
{
     unsigned char b;
     b = 1 & (testvalue >> bit); // décalage à droite de "bit"
     return b;
}
 
string demandeLeChemin(void)
{
    string chemin;
 
    cout << "Entrez le chemin d'accès au fichier\n";
    cin >> chemin;
 
    return chemin;
}
 
int main( int argc, char** argv )
{
    int length;
    char* buffer;
    char s[50000];
    ifstream message;  // message object 
 
    if (argc == 1) 
    {
        do 
        { 
            string filename = demandeLeChemin();
            message.open(filename.c_str(), ios::binary);  
        } 
        while (!message);
 
        // we get the length of the file
        message.seekg(0, ios::end);
        length = message.tellg();
        message.seekg(0, ios::beg);
 
        // We allocate memory for the file
        buffer = new char [length];
 
        // We write data in the memory
        message.read (buffer,length);
        message.close();
 
        int n=0;
 
        for (int i=0; i<length; i++)
        {
            unsigned char c = (unsigned char)buffer[i];  
 
            cout << endl << "On se trouve au " << i << " ieme octet." << endl;
 
            unsigned char mask = 1;  
 
            for (int j=0; j<8; j++)
            {
                if (c & mask)
                {
                    cout << 1;
                }
                else  
                {
                    cout << 0;
                }
                mask <<= 1;
            }
 
            cout << endl;
        } // for
 
        // Libérer la mémoire une fois le traitement terminé
        delete[] buffer;
 
		//00000001b = 0x01 = 1
		//00000010b = 0x02 = 2
		//00000100b = 0x04 = 4
		//00001000b = 0x08 = 8
		//00010000b = 0x10 = 16
		//00100000b = 0x20 = 32
		//01000000b = 0x40 = 64
		//10000000b = 0x80 = 128
 
        system("PAUSE");
		return 0;
    }
    else
    {
        return -1;
    }
}

Et voici la trace que j'obtiens :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
 
On se trouve au 0 ieme octet.
00010110
 
On se trouve au 1 ieme octet.
10100110
 
On se trouve au 2 ieme octet.
10011110
 
On se trouve au 3 ieme octet.
00000100
 
On se trouve au 4 ieme octet.
10000100
 
On se trouve au 5 ieme octet.
10000100
 
On se trouve au 6 ieme octet.
00000100
 
On se trouve au 7 ieme octet.
00101110
 
On se trouve au 8 ieme octet.
10101110
 
On se trouve au 9 ieme octet.
00000100
 
On se trouve au 10 ieme octet.
01110110
 
On se trouve au 11 ieme octet.
10100110
 
On se trouve au 12 ieme octet.
00000100
 
On se trouve au 13 ieme octet.
01001110
 
On se trouve au 14 ieme octet.
10100110
 
On se trouve au 15 ieme octet.
01110110
 
On se trouve au 16 ieme octet.
00101110
 
On se trouve au 17 ieme octet.
01001110
 
On se trouve au 18 ieme octet.
10100110
 
On se trouve au 19 ieme octet.
11001110
 
On se trouve au 20 ieme octet.
00000100
 
On se trouve au 21 ieme octet.
00001110
 
On se trouve au 22 ieme octet.
10000110
 
On se trouve au 23 ieme octet.
11001110
 
On se trouve au 24 ieme octet.
00000100
 
On se trouve au 25 ieme octet.
00000111
 
On se trouve au 26 ieme octet.
00000100
 
On se trouve au 27 ieme octet.
00110110
 
On se trouve au 28 ieme octet.
10000110
 
On se trouve au 29 ieme octet.
00000100
 
On se trouve au 30 ieme octet.
10110110
 
On se trouve au 31 ieme octet.
10000110
 
On se trouve au 32 ieme octet.
10010110
 
On se trouve au 33 ieme octet.
11001110
 
On se trouve au 34 ieme octet.
11110110
 
On se trouve au 35 ieme octet.
01110110
 
On se trouve au 36 ieme octet.
11111100
 
On se trouve au 37 ieme octet.
10110000
 
On se trouve au 38 ieme octet.
01010000

Remarque: Comme tu lis du bit de poids faible vers le bits de poids fort, la valeur binaire affichée correspond à la valeur binaire inversée de ton caractère.

Ainsi c = 'h' vaut 01101000 et la trace donne 00010110.

Si tu veux la même chose, if suffit de modifier le code ainsi:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
            unsigned char mask = 128;  
 
            for (int j=0; j<8; j++)
            {
                if (c & mask)
                {
                    cout << 1;
                }
                else  
                {
                    cout << 0;
                }
                mask >>= 1;
            }

J'espère que ça va marcher aussi avec ton compilateur ?

**wilfryjules** · 14/02/2012, 16h25

Oui, merci !!

ça marchait déjà avec mon ancien code, mais ta méthode avec la boucle for de 0 à 8 et le petit décalage est bien plus noble !! Respect!!

**wilfryjules** · 14/02/2012, 23h34

Bon.... j'ai réussi ma stéganographie....

J'en suis maintenant à la déstéganographie....

et vosu devinerez mon problème.... j'ai récupérer dans un tableau tous les bits de mon fichier message:

tab_bit[] = {1, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0 .....}

comment écrire un fichier, le plus facilement possible, avec tout ça?

Je sais déjà qu'il faut repasser en octets..

Je dois donc de ce fait recréer un tableau de bytes:

bye tab_byte[];

donc une première question se pose: comment créer un octet à partir de bits ? enfin je sais qu'un octet = 8 bits, mais comment les réunir en code?

Est-ce correct?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
 
int q=0;
 
			for(int i=0; i<col*row; i++)
			{
				if( (i+1)%8 == 0)
				{
 
					tab_bytes[q]=tab_bits[i-7]*0x80
							     +tab_bits[i-6]*0x40
							     +tab_bits[i-5]*0x20
							     +tab_bits[i-4]*0x10
							     +tab_bits[i-3]*0x08
							     +tab_bits[i-2]*0x04
							     +tab_bits[i-1]*0x02
							     +tab_bits[i]   *0x01;
				}
				q++;
			}

**aslo92** · 15/02/2012, 11h38

Bonjour wilfryjules,

pour terminer le décodage, voici le code qui transforme tes bits en octets

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
        for (int i=0; i<length; i++)
        {
            pbits = tab_bits + i * 8;
            tab_bytes[i] = 0;
 
            for (int j=7; j>0; j--)
            {
                tab_bytes[i] = (tab_bytes[i] | pbits[j]) << 1;
            }
 
            tab_bytes[i] |= pbits[0];
        }

Remarque: Tu peux éviter de construire un buffer de bits en utilisant directement les octets de ton image puisqu'il suffit de faire image[x] & 1 pour récupérer le bit.

Bonne journée

**wilfryjules** · 15/02/2012, 15h09

<Salut!! merci pour cette réponse! mais... je suis vraiment désolé....je n'ai absolument rien compris à ce code, trop abstrait pour moi !!

NB: chaque pixels de mon image binaire finale de décodage correspond à un bit: 0 (0) ou 1 (255).

La taille de mon fichier devant être inférieure à celle du nombre de pixels de mon image, c'est à dire col * row, j'ai décidé de mettre à 0 tous les bits restant.

ainsi, lorsque je récupère les bits, j'obtiens un

tab_bits[] = {1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ...}

en gras, le fichier à récupérer.

Bref, pour l'instant, je cherchais à mettre tout ça sous forme d'octets (byte), mais je n'ai absolument pas compris ton code !! trop noble pour moi!!

Sinon, est-ce que le code suivant est correct?

Et comment enregistrer mon fichier sur mon ordi?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
 
 
vector<int> tab_bits;
 
vector<byte> tab_bytes;
vector<byte> tab_bytes_final;
 
 
int q=0;
 // ici je transforme en octets (bytes) les bits de mon tableau tab_bits[col*row] et j'obtiens donc un tab_byte[col*row*1/8]
			for(int i=0; i<col*row; i++)
			{
				if( (i+1)%8 == 0)
				{
 
					tab_bytes[q]=tab_bits[i-7]*0x80
							     +tab_bits[i-6]*0x40
							     +tab_bits[i-5]*0x20
							     +tab_bits[i-4]*0x10
							     +tab_bits[i-3]*0x08
							     +tab_bits[i-2]*0x04
							     +tab_bits[i-1]*0x02
							     +tab_bits[i]  *0x01;
				}
				q++;
			}
 
 
			// ici je récupère seulement les octets du fichier et j'obtiens mon tab_byte_final[length] de longueur du fichier.
 
			int flag_end_file = 0;
			int f=0;
 
			while (flag_end_file == 0)
			{
				if(tab_bytes[f] != 0x00)
				{
					f++;
					tab_bytes_final[f] = tab_bytes[f];
				}
				else
				{
					flag_end_file = 1;
				}
			}
 
                        // on écrit dans le fichier
                        for (int i=0; i<f; i++)
			{
				message << tab_bytes_final[i];
			}
                        // on écrit le caractère de fin dans le fichier
			message << EOF; 
 
			message.close();

Thanks ! Si vous pouviez corriger mon code,

**aslo92** · 15/02/2012, 16h41

Ton code ne marche pas car q++ doit être à l'intérieur du test :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

if( (i+1)%8 == 0)

D'ailleurs ce test ne sert pas à grand chose car tu peux simplifier en faisant i+=8 dans ta boucle

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
        int q=0;
        // ici je transforme en octets (bytes) les bits de mon tableau tab_bits[col*row] et j'obtiens donc un tab_byte[col*row*1/8]
		for(int i=0; i<col*row; i+=8)
		{
				tab_bytes[q]=tab_bits[i]
						     + tab_bits[i+1] * 0x02
						     + tab_bits[i+2] * 0x04
						     + tab_bits[i+3] * 0x08
						     + tab_bits[i+4] * 0x10
						     + tab_bits[i+5] * 0x20
						     + tab_bits[i+6] * 0x40
						     + tab_bits[i+7] * 0x80;
        		q++;
		}

J'ai inversé l'ordre des bits pour que ça fonctionne avec le code que je t'avais envoyé précédemment. Je ne sait pas ce qu'il en est dans ton implémentation?

Le code de mon post précédent fait la même chose que toi à part que length = col*row/8.
Je boucle sur des octets au lieu des bits.
Après au lieu de multiplier par des multiples de 2, je fais des décalages ce qui est équivalent.
Je rempli mon octet en ajoutant un bit à droite (bit de poids le plus faible) et je décale le résultat d'un bit vers la gauche pour pouvoir insérer le bit suivant.

Ex:

bits = 1 1 0 1 0 0 0 1

j = 0, octet = 00000000 + 1 = 00000001 puis décalage ==> octet = 00000010
j = 1, octet = 00000010 + 1 = 00000011 puis décalage ==> octet = 00000110
j = 2, octet = 00000110 + 0 = 00000110 puis décalage ==> octet = 00001100
j = 3, octet = 00001100 + 1 = 00001101 puis décalage ==> octet = 00011010
j = 4, octet = 00011010 + 0 = 00011010 puis décalage ==> octet = 00110100
j = 5, octet = 00110100 + 0 = 00110100 puis décalage ==> octet = 01101000
j = 6, octet = 01101000 + 0 = 01101000 puis décalage ==> octet = 11010000
j = 7, octet = 11010000 + 1 = 11010001

J'espère que maintenant mon code devient plus lisible ?

**wilfryjules** · 15/02/2012, 17h46

Oui, parfaitement clair !! merci,

par contre, avec mon code corrigé, j'ai une erreur de dépassement de vecteur out of range... sûrement sur tab_bytes

**wilfryjules** · 16/02/2012, 19h50

OK !!!!

Alors concernant les problèmes de vecteurs out of range, 2 solutions:
soit on initialise le vecteur comme ça:

- vector<byte> tab_bytes(col*row); et dans ce cas on doit accéder aux variables de la même manière qu'avec un tableau, c'est à dire tab_bytes[i] pour accéder à la variable i. En effet, lors ce cette initialisation, toutes les valeurs sont mises à zéro par défaut.

- soit vector<byte> tab_bytes; et alors on fait tab_bytes.push_back(i) ;

RESOLU !!!!

Extraire les bits d'un fichier quelconque, lire et réécrire un fichier

C++

Discussions similaires

Partager

Partager