Discussion :

[St-42-FCM-57]

Oui, mais c'est ce que picodev a donné au début :

pour coder :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
char *xorify(size_t size, const char *string, int xor_key)
{
  char *res=malloc(size+1);
  if (res!=NULL) {
    for(size_t i=0; i<size; ++i)
      res[i] = string[i] ^ xor_key;
    res[size]=0;
  }
  return res;
}

pour afficher le message codé en décimal :

Code :

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

1
2
3
4
5
6
7
 
void decimal_display(size_t size, const char *string)
{
  for(size_t i=0; i<size; ++i)
    printf(" %03hhu", (unsigned char)string[i]); 
  putchar('\n');
}

le programme principal :

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
 
int main(void)
{
  int key=199;
  const char message[]="o";
  size_t size=strlen(message);
 
  char *encrypted=xorify(size, message,key); //ici on crypte message[]
  char *decrypted=xorify(size, encrypted,key); // Ici on décrypte la ligne du dessus pour avoir le message initial non codé
 
  puts(message);//affichage du texte initial
 
 
  decimal_display(size, encrypted);//affichage du texte codé
 
  puts(decrypted); // affichage du texte décodé, donc message initial
 
  free(decrypted);
  free(encrypted);
 
  return 0;
}

[Médinoc]

En fait, le mieux pour afficher des données brutes ou inconnues, c'est le dump hexadécimal + ascii.

Pour te donner un aperçu de ce que ça donne, j'ai retrouvé un vieux code de dump HexAscii à moi, que j'ai nettoyé:

Code C :

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
/*
HexAscii Dump.h:
Declares the DumpMemory function and its enum.
*/
#pragma once
#include <stdio.h>
 
#ifndef EXTERN_C 
#define EXTERN_C extern
#endif
 
typedef enum eDumpAddressMode
{
	DumpNoAddress,
	DumpAddress,
	DumpAddressAligned,
} DumpAddressMode;
 
EXTERN_C void DumpMemory(
 FILE* pfOut,                /*[in/modif] Output stream. */
 unsigned int nCols,         /*[in] Number of columns of display. Must be at least 14 on 32-bit machines. */
 void const * pcMem,         /*[in] Memory block to dump. */
 size_t cbMem,               /*[in] Size to dump, in bytes. */
 DumpAddressMode addressMode /*[in] Whether to display the address, and if so, whether to align on line size.*/
 );

Code C :

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
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
/*
HexAscii Dump.c:
Implements an hexadecimal+ASCII dump to console.
*/
#include "HexAscii Dump.h"
#include <stdlib.h>
#include <assert.h>
 
/* Helper macros
   ------------- */
#ifndef ARRAYSIZE
#define ARRAYSIZE(x) (sizeof x / sizeof x[0])
#endif
 
typedef enum BOOL { FALSE, TRUE} BOOL;
 
struct dumpParams
{
	unsigned int nBytesPerLine;
	unsigned int nSpaces1;
	unsigned int nSpaces2;
	unsigned int realAddressLength;
 
	BOOL displayAddress;
	unsigned char const * pcByMem;
	unsigned char const * pcStart;
	unsigned char const * pcEnd; /* pcEnd is the address IMMEDIATELY AFTER the last valid one, rounded up on line length. */
};
 
/* Helper function for number of bytes to display
   ---------------------------------------------- */
static unsigned int LowerPowerOfTwo(unsigned int in)
{
	/*Search the first 'set' bit, from msb to lsb.*/
	unsigned int bit = 0x80000000u;
	if(in==0)
		return 0;
 
	while((in & bit)==0)
	{
		/*Bit is too high: shift it and retry.*/
		bit >>= 1;
	}
	return bit;
}
 
/* Helper function for calculating the dump parameters
   --------------------------------------------------- */
static BOOL ProcessParams(
 struct dumpParams *pParams,    /*[out] */ 
 unsigned int nCols,            /*[in] */
 unsigned char const * pcByMem, /*[in] pcMem, implicitely cast as a char pointer. */
 size_t cbMem,                  /*[in] */
 DumpAddressMode addressMode    /*[in] */
 )
{
 
	assert(pParams != NULL);
 
	/*Calculate real address length*/
	if(addressMode != DumpNoAddress)
	{
		void* p=NULL;
		#ifdef _MSC_VER
		int length = _scprintf("%p", p);
		#else
		int length = snprintf(NULL, "%p", p);
		#endif
		if(length < 0)
			return FALSE;
		pParams->realAddressLength = length;
		pParams->displayAddress = TRUE;
	}
	else
	{
		pParams->realAddressLength = 0;
		pParams->displayAddress = FALSE;
	}
 
	/*Calculate number of bytes per line, and spacing*/
	{
		int nSpaces = 0;
		unsigned int nBytesPerLine = 0;
		unsigned int spacedAddressLength = pParams->realAddressLength + (pParams->displayAddress ? 1 : 0);
		unsigned int const nColsBytes = nCols - spacedAddressLength - 1; /*subtract Address-in-hex (with space), End-of-line, .*/
 
		/*If not enough for four bytes, fail.*/
		if(nCols <= spacedAddressLength+1 || nColsBytes < 4)
			return FALSE;
 
		nBytesPerLine = LowerPowerOfTwo(nColsBytes/4);
		assert(nBytesPerLine > 0); /*shall be OK, since tested before.*/
 
		/*Additional spacing*/
		nSpaces = (nColsBytes-(nBytesPerLine*4));
		assert(nSpaces >= 0);
		if(pParams->displayAddress)
			pParams->nSpaces2 = nSpaces/2;
		else
			pParams->nSpaces2 = nSpaces;
		pParams->nSpaces1 = nSpaces - pParams->nSpaces2;
		pParams->nBytesPerLine = nBytesPerLine;
	}
	assert(pParams->nBytesPerLine > 0);
 
	/*Start&End pointers, with alignment.*/
	{
		unsigned int const nBytesPerLine = pParams->nBytesPerLine;
 
		unsigned char const * pcStart = pcByMem;
		unsigned char const * pcEnd = pcByMem+cbMem; /*pcEnd is the address IMMEDIATELY AFTER the last valid one here.*/
 
		/*If aligning, round pcStart down.*/
		if(addressMode == DumpAddressAligned)
		{
			pcStart -= (intptr_t)pcStart%nBytesPerLine;
			assert((intptr_t)pcStart%nBytesPerLine == 0);
		}
 
		/*Always align pcEnd with pcStart*/
		{
			size_t unalEnd = (pcEnd-pcStart)%nBytesPerLine;
			if(unalEnd!=0)
			{
				pcEnd += (nBytesPerLine-unalEnd);
			}
			assert((pcStart-pcEnd)%nBytesPerLine == 0);
		}
 
		/*Set pointers in the parameter structure.*/
		pParams->pcByMem = pcByMem;
		pParams->pcStart = pcStart;
		pParams->pcEnd = pcEnd;
	}
	return TRUE;
}
 
/* Helper function for writing a string of identical chars
   ------------------------------------------------------- */
static void WriteChars(FILE* pfOut, char c, unsigned int n)
{
	unsigned int i;
	for(i=0 ; i<n ; i++)
		putc(c, pfOut);
}
 
/*Function for hiding bytes that can't be printed for some reason or other*/
static BOOL IsPrintableByte(unsigned char by)
{
	return by!=127 //DEL
	 && by >= 32   //C0 control characters
#ifdef _WIN32
	 && by!=0x81 && by!=0x8D && by!=0x8F //Five characters in the C1 block still non-printable in Windows-1252
	 && by!=0x90 && by!=0x9D             //Five characters in the C1 block still non-printable in Windows-1252
	 && by!=0x95 //Bullet, non-printable when dumped on Console
#else
	 && !(by >= 0x80 && by <= 0x9F) //Assume all C1 characters are non-printable on non-Windows OSes
#endif
	// && by!=0x98 //Tilde, because textbox treats it as combining.
	// && by!=0xAD; //SHY (Soft Hyphen) character, which disappears on textbox.
	 ;
}
 
/*---------------------------------------------------------------------------*/
 
/* Memory dump function
   -------------------- */
EXTERN_C void DumpMemory(
 FILE* pfOut,                /*[in/modif] Output stream. */
 unsigned int nCols,         /*[in] Number of columns of display. Must be at least 14 on 32-bit machines. */
 void const * pcMem,         /*[in] Memory block to dump. */
 size_t cbMem,               /*[in] Size to dump, in bytes. */
 DumpAddressMode addressMode /*[in] Whether to display the address, and if so, whether to align on line size.*/
 )
{
	struct dumpParams params = {0};
 
	/*Analyze the parameters to set variables such as the real start and end of the dump,
	  the number of bytes in one line, etc.*/
	if(!ProcessParams(&params, nCols, pcMem, cbMem, addressMode))
	{
		fputs("Error processing parameters.\n", stderr);
		return;
	}
 
	/*Dump the memory according to the processed parameters.*/
	{
		unsigned char const * pcCurrent = NULL;
		size_t iByteLine = 0;
		/*Buffer for individual characters, written at the end of each line*/
		char stackBuf[40]="", *heapBuf=NULL, *buf=NULL;
		size_t bufSize = params.nBytesPerLine+1;
 
		buf = bufSize > ARRAYSIZE(buf) ? (heapBuf=malloc(bufSize)) : stackBuf;
		if(buf != NULL)
			buf[params.nBytesPerLine] = '\0';
 
		for(pcCurrent = params.pcStart ; pcCurrent<params.pcEnd ; pcCurrent++)
		{
			/*If at start of line, display address and the spaces that follow it*/
			if(iByteLine==0 && params.displayAddress)
			{
				fprintf(pfOut, "%p", (void const*)pcCurrent);
				/*Write spaces*/
				WriteChars(pfOut, ' ', params.nSpaces1+1);
			}
 
			/*If before the start or after the end, display spaces instead of the data.
			  If in the right zone, display the byte data (The pointer is dereferenced only here).*/
			if(pcCurrent < params.pcByMem || pcCurrent >= params.pcByMem+cbMem)
			{
				/*Write two spaces instead of the byte.*/
				WriteChars(pfOut, ' ', 2);
				/*Add a space to the buffer instead of the character.*/
				if(buf != NULL)
					buf[iByteLine] = ' ';
			}
			else
			{
				/*Write the byte*/
				unsigned char const by = *pcCurrent;
				fprintf(pfOut, "%02X", by);
				/*Add the character to the buffer*/
				if(buf != NULL)
					buf[iByteLine] = (IsPrintableByte(by) ? by : '.');
			}
 
			/*Increment iByteLine now, allowing correct position of the "minus" char.*/
			iByteLine++;
 
			/*Write the space between bytes.*/
			{
				if(iByteLine==params.nBytesPerLine/2 && iByteLine!=0)
					putc('-', pfOut);
				else
					putc(' ', pfOut);
			}
 
			/*If at end of line, display the character representation of the bytes.*/
			if(iByteLine ==params.nBytesPerLine)
			{
				/*Write spaces (no +1 here, because written above)*/
				WriteChars(pfOut, ' ', params.nSpaces2);
				/*Write the caracs*/
				if(buf != NULL)
					fprintf(pfOut, "%s", buf);
				else
					WriteChars(pfOut, '-', params.nBytesPerLine);
 
				/*Next line.*/
				iByteLine = 0;
					putc('\n', pfOut);
			}
		}/*for*/
 
		/*Debug: The NUL terminator must not have been overwritten*/
		if(buf != NULL)
			assert( buf[params.nBytesPerLine] == '\0' );
		buf=NULL;
		free(heapBuf), heapBuf=NULL;
	}/*local variables*/
}

Avec ça, tu auras à la fois le o et le 0x6F (111) son code ASCII.
Note: Si tu es en 64 bits et sur 80 colonnes, tu constatera que si tu mets autre chose que DumpNoAddress en dernier paramètre, tu n'auras plus 16 octets par ligne: Il n'y a plus la place.

---

J'ai fait un petit code d'exemple pour le fonctionnement de la fonction de dump:

Code C :

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
#include "HexAscii Dump.h"
#include <stdio.h>
#include <stdlib.h>
//#include <wchar.h>
 
void TestDump3(void)
{
	//wchar_t const* chaineADumper = L"Ceci est un long, long texte à dumper, écrit par Médinoc il y a bien longtemps et nettoyé le 1er octobre 2016.";
	//size_t cchLongueur = wcslen(chaineADumper);
	char const* chaineADumper = "Ceci est un long, long texte à dumper, écrit par Médinoc il y a bien longtemps et nettoyé le 1er octobre 2016.";
	size_t cchLongueur = strlen(chaineADumper);
 
	size_t cbTaille = (cchLongueur+1) * sizeof(*chaineADumper);
 
	puts("Unaligned:");
	DumpMemory(stdout, 80, chaineADumper, cbTaille, DumpAddress);
	puts("Aligned:");
	DumpMemory(stdout, 80, chaineADumper, cbTaille, DumpAddressAligned);
	puts("Without address:");
	DumpMemory(stdout, 80, chaineADumper, cbTaille, DumpNoAddress);
}

En 64 bits, sous Windows ça donne ceci:

Code X :

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
Unaligned:
000000014003C0E0                43 65 63 69-20 65 73 74                Ceci est
000000014003C0E8                20 75 6E 20-6C 6F 6E 67                 un long
000000014003C0F0                2C 20 6C 6F-6E 67 20 74                , long t
000000014003C0F8                65 78 74 65-20 E0 20 64                exte Ó d
000000014003C100                75 6D 70 65-72 2C 20 E9                umper, Ú
000000014003C108                63 72 69 74-20 70 61 72                crit par
000000014003C110                20 4D E9 64-69 6E 6F 63                 MÚdinoc
000000014003C118                20 69 6C 20-79 20 61 20                 il y a
000000014003C120                62 69 65 6E-20 6C 6F 6E                bien lon
000000014003C128                67 74 65 6D-70 73 20 65                gtemps e
000000014003C130                74 20 6E 65-74 74 6F 79                t nettoy
000000014003C138                E9 20 6C 65-20 31 65 72                Ú le 1er
000000014003C140                20 6F 63 74-6F 62 72 65                 octobre
000000014003C148                20 32 30 31-36 2E 00                    2016..
Aligned:
000000014003C0E0                43 65 63 69-20 65 73 74                Ceci est
000000014003C0E8                20 75 6E 20-6C 6F 6E 67                 un long
000000014003C0F0                2C 20 6C 6F-6E 67 20 74                , long t
000000014003C0F8                65 78 74 65-20 E0 20 64                exte Ó d
000000014003C100                75 6D 70 65-72 2C 20 E9                umper, Ú
000000014003C108                63 72 69 74-20 70 61 72                crit par
000000014003C110                20 4D E9 64-69 6E 6F 63                 MÚdinoc
000000014003C118                20 69 6C 20-79 20 61 20                 il y a
000000014003C120                62 69 65 6E-20 6C 6F 6E                bien lon
000000014003C128                67 74 65 6D-70 73 20 65                gtemps e
000000014003C130                74 20 6E 65-74 74 6F 79                t nettoy
000000014003C138                E9 20 6C 65-20 31 65 72                Ú le 1er
000000014003C140                20 6F 63 74-6F 62 72 65                 octobre
000000014003C148                20 32 30 31-36 2E 00                    2016..
Without address:
43 65 63 69 20 65 73 74-20 75 6E 20 6C 6F 6E 67                Ceci est un long
2C 20 6C 6F 6E 67 20 74-65 78 74 65 20 E0 20 64                , long texte Ó d
75 6D 70 65 72 2C 20 E9-63 72 69 74 20 70 61 72                umper, Úcrit par
20 4D E9 64 69 6E 6F 63-20 69 6C 20 79 20 61 20                 MÚdinoc il y a
62 69 65 6E 20 6C 6F 6E-67 74 65 6D 70 73 20 65                bien longtemps e
74 20 6E 65 74 74 6F 79-E9 20 6C 65 20 31 65 72                t nettoyÚ le 1er
20 6F 63 74 6F 62 72 65-20 32 30 31 36 2E 00                    octobre 2016..

(tu constateras les remplacements de caractères dûs à la Console de Windows).

En 32 bits, on a ça:

Code X :

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
Unaligned:
0044F0A8    43 65 63 69 20 65 73 74-20 75 6E 20 6C 6F 6E 67    Ceci est un long
0044F0B8    2C 20 6C 6F 6E 67 20 74-65 78 74 65 20 E0 20 64    , long texte Ó d
0044F0C8    75 6D 70 65 72 2C 20 E9-63 72 69 74 20 70 61 72    umper, Úcrit par
0044F0D8    20 4D E9 64 69 6E 6F 63-20 69 6C 20 79 20 61 20     MÚdinoc il y a
0044F0E8    62 69 65 6E 20 6C 6F 6E-67 74 65 6D 70 73 20 65    bien longtemps e
0044F0F8    74 20 6E 65 74 74 6F 79-E9 20 6C 65 20 31 65 72    t nettoyÚ le 1er
0044F108    20 6F 63 74 6F 62 72 65-20 32 30 31 36 2E 00        octobre 2016..
Aligned:
0044F0A0                           -43 65 63 69 20 65 73 74            Ceci est
0044F0B0    20 75 6E 20 6C 6F 6E 67-2C 20 6C 6F 6E 67 20 74     un long, long t
0044F0C0    65 78 74 65 20 E0 20 64-75 6D 70 65 72 2C 20 E9    exte Ó dumper, Ú
0044F0D0    63 72 69 74 20 70 61 72-20 4D E9 64 69 6E 6F 63    crit par MÚdinoc
0044F0E0    20 69 6C 20 79 20 61 20-62 69 65 6E 20 6C 6F 6E     il y a bien lon
0044F0F0    67 74 65 6D 70 73 20 65-74 20 6E 65 74 74 6F 79    gtemps et nettoy
0044F100    E9 20 6C 65 20 31 65 72-20 6F 63 74 6F 62 72 65    Ú le 1er octobre
0044F110    20 32 30 31 36 2E 00   -                            2016..
Without address:
43 65 63 69 20 65 73 74-20 75 6E 20 6C 6F 6E 67                Ceci est un long
2C 20 6C 6F 6E 67 20 74-65 78 74 65 20 E0 20 64                , long texte Ó d
75 6D 70 65 72 2C 20 E9-63 72 69 74 20 70 61 72                umper, Úcrit par
20 4D E9 64 69 6E 6F 63-20 69 6C 20 79 20 61 20                 MÚdinoc il y a
62 69 65 6E 20 6C 6F 6E-67 74 65 6D 70 73 20 65                bien longtemps e
74 20 6E 65 74 74 6F 79-E9 20 6C 65 20 31 65 72                t nettoyÚ le 1er
20 6F 63 74 6F 62 72 65-20 32 30 31 36 2E 00                    octobre 2016..

Avec ces exemples, tu ne devrais pas avoir de difficultés à visualiser les résultat de ton cryptage, aux étapes que tu veux.

[St-42-FCM-57]

Bonjour,

Je te remercie pour ton aide extrêmement complète. Aujourd'hui je n'ai pas le temps, mais je vais regarder ça de près dès demain, et, si je rencontre des problèmes, je te dirai ce qui ne va pas.
Encore merci pour tout !