problème avec const char * et #define macro

Version imprimable

Bonjour à tous,

dans mon programme j'ai 2 fonctions

Code:

1
2
3
4
 
void file_utils_lion_encrypt(char *in, char *out, size_t blklen, const char *key) 
//et
void file_utils_lion_decrypt(char *in, char *out, size_t blklen, const char *key)

ces 2 fonctions servent à chiffrer/déchiffrer les données, in contient les données à chiffrer/déchiffrer , out recoit le resultat après chiffrement/déchiffrement, blklen est la taille du bloc à chiffrer/déchiffrer et key est la clé de chiffrement c'est cette même clé qui me cause un problème.

quand j'utilise une constante chaine de caractères comme ceci

Code:

1
2
3
4
5
 
const char *macle = "chiffrement";
file_utils_lion_encrypt(plaintext, ciphertext,block_size, macle);
//et puis
file_utils_lion_decrypt( ciphertext,plaintext,block_size, macle);

après les données ne sont plus les même.
mais quand je passe à ces deux fonctions une constante macro( #define) comme ca

Code:

1
2
3
4
#define macroCle "chiffrement" 
file_utils_lion_encrypt(plaintext, ciphertext,block_size, macroCle);
//et puis
file_utils_lion_decrypt( ciphertext,plaintext,block_size, macroCle);

je retrouve mes données comme avant le dechiffrement;

quelqu'un comprend pour quoi ? car moi je suis largué.
merci.
pour plus d'info voici l'implèmentation de ces fonctions

Code:

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
 
 
#define HASH_SZ   20
#define NUM_WORDS (HASH_SZ / sizeof(int))
 
 
void file_utils_lion_encrypt(char *in, char *out, size_t blklen, const char *key) 
{
	int     i, tmp[NUM_WORDS];
  	RC4_KEY k;
 
  	/* Round 1: R = R ^ RC4(L ^ K1) */
  	for (i = 0;  i < NUM_WORDS;  i++)
    	tmp[i] = ((int *)in)[i] ^ ((int *)key)[i];
 
	RC4_set_key(&k, HASH_SZ, (char *)tmp);
  	RC4(&k, blklen - HASH_SZ, in + HASH_SZ, out + HASH_SZ);
 
  	/* Round 2: L = L ^ SHA1(R) */
  	SHA1(out + HASH_SZ, blklen - HASH_SZ, out);
  	for (i = 0;  i < NUM_WORDS; i++)
    	((int *)out)[i] ^= ((int *)in)[i];
 
  	/* Round 3: R = R ^ RC4(L ^ K2) */
  	for (i = 0;  i < NUM_WORDS;  i++)
    	tmp[i] = ((int *)out)[i] ^ ((int *)key)[i + NUM_WORDS];
  	RC4_set_key(&k, HASH_SZ, (char *)tmp);
  	RC4(&k, blklen - HASH_SZ, out + HASH_SZ, out + HASH_SZ);
}
 
void file_utils_lion_decrypt(char *in, char *out, size_t blklen, const char *key)
{
  	int     i, tmp[NUM_WORDS];
  	RC4_KEY k;
 
  	for (i = 0;  i < NUM_WORDS;  i++)
    	tmp[i] = ((int *)in)[i] ^ ((int *)key)[i + NUM_WORDS];
  	RC4_set_key(&k, HASH_SZ, (char *)tmp);
  	RC4(&k, blklen - HASH_SZ, in + HASH_SZ, out + HASH_SZ);
 
  	SHA1(out + HASH_SZ, blklen - HASH_SZ, out);
  	for (i = 0;  i < NUM_WORDS;  i++) 
	{
    	((int *)out)[i] ^= ((int *)in)[i];
    	tmp[i] = ((int *)out)[i] ^ ((int *)key)[i];
  	}
  	RC4_set_key(&k, HASH_SZ, (char *)tmp);
  	RC4(&k, blklen - HASH_SZ, out + HASH_SZ, out + HASH_SZ);
}

16/09/2006, 14h42
D[r]eadLock

Salut,
Je ne peux pas essayer de compiler car il n'y a pas les #includes .
À mon avis, ton const char *key est modifié (malgrès le const), parce que tu le cast en int * (alors que tu devrais le caster en const int *) ! Pas certain ?: affiche la valeur de macle juste après le cryptage, je te parie un mars qu'il est modifé ;)

Merci pour ton aide D[r]eadLock mais ça ne marche pas comme avant
j'ai fait un cast en (const int *) key et j'ai fais un printf de key à la fin de chaque fonction key ne change pas et le resultat est comme avant
voici le code des fonctions y compris les includes
pour plus d'infos je suis sous debian et la version de mon compilateur est
gcc version 4.1.2 20060814 (prerelease) (Debian 4.1.1-11)
pour que ça compile il faut mettre l'option -lssl
Merci

Code:

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
 
#include <stdio.h>
#include <openssl/rc4.h>
#include <openssl/sha.h>
#include <stdlib.h>
#include <fcntl.h>
 
 
#define HASH_SZ   20
#define NUM_WORDS (HASH_SZ / sizeof(int))
 
void file_utils_lion_encrypt(char *in, char *out, size_t blklen, const char *key) 
{
	int     i, tmp[NUM_WORDS];
  	RC4_KEY k;
 
  	/* Round 1: R = R ^ RC4(L ^ K1) */
  	for (i = 0;  i < NUM_WORDS;  i++)
    	tmp[i] = ((int *)in)[i] ^ ((const int *)key)[i];
 
	RC4_set_key(&k, HASH_SZ, (char *)tmp);
  	RC4(&k, blklen - HASH_SZ, in + HASH_SZ, out + HASH_SZ);
 
  	/* Round 2: L = L ^ SHA1(R) */
  	SHA1(out + HASH_SZ, blklen - HASH_SZ, out);
  	for (i = 0;  i < NUM_WORDS; i++)
    	((int *)out)[i] ^= ((int *)in)[i];
 
  	/* Round 3: R = R ^ RC4(L ^ K2) */
  	for (i = 0;  i < NUM_WORDS;  i++)
    	tmp[i] = ((int *)out)[i] ^ ((const int *)key)[i + NUM_WORDS];
  	RC4_set_key(&k, HASH_SZ, (char *)tmp);
  	RC4(&k, blklen - HASH_SZ, out + HASH_SZ, out + HASH_SZ);
	printf("dans encypt key = %s\n",key);
 
}
 
void file_utils_lion_decrypt(char *in, char *out, size_t blklen, const char *key)
{
  	int     i, tmp[NUM_WORDS];
  	RC4_KEY k;
 
  	for (i = 0;  i < NUM_WORDS;  i++)
    	tmp[i] = ((int *)in)[i] ^ ((const int *)key)[i + NUM_WORDS];
  	RC4_set_key(&k, HASH_SZ, (char *)tmp);
  	RC4(&k, blklen - HASH_SZ, in + HASH_SZ, out + HASH_SZ);
 
  	SHA1(out + HASH_SZ, blklen - HASH_SZ, out);
  	for (i = 0;  i < NUM_WORDS;  i++) 
	{
    	((int *)out)[i] ^= ((int *)in)[i];
    	tmp[i] = ((int *)out)[i] ^ ((const int *)key)[i];
  	}
  	RC4_set_key(&k, HASH_SZ, (char *)tmp);
  	RC4(&k, blklen - HASH_SZ, out + HASH_SZ, out + HASH_SZ);
	printf("dans decypt key = %s\n",key);
}

17/09/2006, 11h32
D[r]eadLock

Hum, y'a pas mal de trucs bizarre dans ton code:
- si strlen(key) < HASH_SZ alors tu accède à de la mémoire "indéfinie" (i.e. après ta chaine de caractère !) lors de tes boucles avec tmp. À mon avis il te faut un modulo, genre ((const int *)key) [i % (strlen(key)/sizeof(int))] et pareil avec to i+NUM_WORDS
- pourquoi re-définir HASH_SZ alors que ca doit valoir SHA_DIGEST_LENGTH ? (au pire, tu fais #define HASH_SZ SHA2_DIGEST_LENGTH)
- que se passe-t-il si blklen < HASH_SZ ? (euh, chez moi ca dump), mais tu me diras que generallement la clé est plus petite que le texte

Rq: pour moi, j'ai le même comportement avec la macro ou le const char *, mais ca doit venir de ce qui suit ton const char * en memoire (voir item 1): si tu as un tableau qui lui varie entre le cryptage et le décryptage, ça doit être pour ça que ca foire.
Pour info, montre ton code complet (i.e. avec les définitions de macle et de plaintext....)

Rq2: ok, j'ai perdu un mars (ça m'apprendra à lire trop vite le code), mais je suis pret pour le quitte-ou-double :wink:
18/09/2006, 17h12
Ti-R

Citation:

quand j'utilise une constante chaine de caractères comme ceci

Code:
const char *macle = "chiffrement";
file_utils_lion_encrypt(plaintext, ciphertext,block_size, macle);
//et puis
file_utils_lion_decrypt( ciphertext,plaintext,block_size, macle);
après les données ne sont plus les même.
mais quand je passe à ces deux fonctions une constante macro( #define) comme ca

Code:
#define macroCle "chiffrement"
file_utils_lion_encrypt(plaintext, ciphertext,block_size, macroCle);
//et puis
file_utils_lion_decrypt( ciphertext,plaintext,block_size, macroCle);

C'est à dire que si tu fais
printf de macroCle tu as bien "chiffrement" ?
Et si tu fais printf de macle, tu n'as plus "chiffrement" ?

Et bien je t'annonce que c'est "presque" normal.

Car dans un cas macroCle, ta chaîne est copiée 3 fois dans file_utils_lion_encrypt et dans file_utils_lion_decrypt, ainsi que dans ton printf... donc tu ne visualises pas les mêmes données, les chaînes ont toutes un espace mémoire dédié.

Avec

Code:

const char *macle = "chiffrement";

macle tiens le même espace mémoire partout.
Donc le problème est que les 2 fonctions, encode et décode mais ne fonctionne pas ensemble... la première encode quelque chose que le seconde ne décode pas correctement.
20/09/2006, 21h25
David.Schris

Citation:

Envoyé par Ti-R

[...] Car dans un cas macroCle, ta chaîne est copiée 3 fois dans file_utils_lion_encrypt et dans file_utils_lion_decrypt, ainsi que dans ton printf... donc tu ne visualises pas les mêmes données, les chaînes ont toutes un espace mémoire dédié. [...]

En supposant que tu aies raison : je n'ai pas compris.