Discussion :

[abcdefg]

Bonjour, je suis en train de faire une classe qui va me permettre de crypter les données d’une transaction entre deux clients certifiés.

Pour certifié que j’ai le même client au bout de ma communication j’ai utilisé le principe diffie hellman avec la lib d’OpenSsl.

Seulement comme j’utilise le réseau pour faire passé la clé publique et les autres informations genre ‘p’ et ‘g’ je dois transforme tout en hexadécimal, heureusement il y a des fonctions pour la conversion.

Voici mon problème, quand je fais passer les informations publique de
alice a bob (p, g, pub_key) avec une copy du même type que celle prévue pour accueillir ces même information l’opération réussi et les clé privé sont bien les mêmes.


BN_copy(dhBob->p, dhAlice->p);
BN_copy(dhBob->g, dhAlice->g);

Resultat : Alice et bob on la meme cle privé.

Alice calculated:
A6A480EFF04D1C89
Bob calculated:
A6A480EFF04D1C89


Maintenant comme mes valeurs seront recuperé sous la forme hexadecimal par reseau, j’utilise la function suivant pour remplir mes variable:


//Set the parameters with hexa values (by reseaux)
BN_hex2bn(&dhBob->p,"979BDD86B4AFB637");
BN_hex2bn(&dhBob->g,"05");

Resultat : Echec!

Alice calculated:
D184B0E02CEC3608
Bob calculated:
CDCDCDCDCDCDCDCD

Quand je liste les structures pour vérifié les valeurs, elle s'affiche bien, et quand je check la structure elle est aussi sans erreur.
Merci de me donné un coup de main pour se problème que je n’arrive pas à résoudre.

[Médinoc]

CDCDCD, ça me rappelle ceci:
http://en.wikipedia.org/wiki/Magic_n...c_debug_values

0xCDCDCDCD : Used by Microsoft's C++ debugging runtime library to mark uninitialised heap memory

[abcdefg]

A oui simpa le page sur les magic numbers
Mais ca me dit tout o plus que mon programme n'a jammais ecrit dans cette partie de la memoire.

Lorsque je fait se code: BN_hex2bn(&dhBob->p,"979BDD86B4AFB637");
Pour moi c'est la valeurs hexa du 'p' mais pourquoi est 'il si petit?
Dans un exemple prit sur le net j'ai chopé se bout de code:

char *group1_hex =
"FFFFFFFF" "FFFFFFFF" "C90FDAA2" "2168C234" "C4C6628B" "80DC1CD1"
"29024E08" "8A67CC74" "020BBEA6" "3B139B22" "514A0879" "8E3404DD"
"EF9519B3" "CD3A431B" "302B0A6D" "F25F1437" "4FE1356D" "6D51C245"
"E485B576" "625E7EC6" "F44C42E9" "A637ED6B" "0BFF5CB6" "F406B7ED"
"EE386BFB" "5A899FA5" "AE9F2411" "7C4B1FE6" "49286651" "ECE65381"
"FFFFFFFF" "FFFFFFFF";

char *gen = "2";
dh = DH_new ();
assert (dh != NULL);

/* FIXME: check these return vals */
BN_hex2bn(&dh->p, group1_hex);
BN_hex2bn(&dh->g, gen);

On peut voir que sont 'p' est bcp plus grand que se que moi j'ecrit pour la meme fonction.A la base je pensé que je devais mettre dans 'p' juste se que la fonction BN_bn2hex() me renvoyer pour la valeurs de mon 'p' cad un truc du genre "979BDD86B4AFB637" .
Help me; je ne c'est pas quel format de valeurs imposé a Bob pour la valeurs du 'p'.
Je remarque aussi que pour la valeurs du 'g' j'ai imposé 05 alors que dans un exmple j'ai pu voir: (sans le zero)

char *gen = "2";
BN_hex2bn(&dh->g, gen);

J'aimerais aussi avoir votre avis, merci.

[Tex-Twil]

Salut,
déjà pour le nombre premier dh->p il faut le générer avec le fonction d'openssl:

Code :

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

1
2
3
4
5
6
7
8
9
DH *dh;
int prime_len = 64 // 64 pour faire des tests car c'est plus rapide, sinon il faut 1024 voir plus
int generator = 5;  // ou plutot #define GENERATOR DH_GENERATOR_5

printf("Generating DH params ... this can take a while \n");
dh = DH_generate_parameters(prime_len, generator, NULL, NULL);

// apres faut tester que t'as généré un "bon" nombre premier avec DH_check

Maintenant est ce que tu peux me dire de quelle façon t"écris les paramètres DH dans ta socket. On est bien d'accord, le serveur doit envoyer au client p, g et sa clé publique
De mémoire, j'avais fait un truc du genre:

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

char *prime;
char *s_pub_key;
//Génération de la clé pub par le serveur.
DH_generate_key(dh);

prime = malloc(sizeof(dh->p));	
if(prime == NULL) { perror("malloc"); exit(2); }
prime = BN_bn2hex(dh->p); 

s_pub_key = malloc(sizeof(dh->pub_key));
if(s_pub_key == NULL) { perror("malloc"); exit(2); }		
s_pub_key = BN_bn2hex((dh->pub_key);

...
// écriture dans la socket
// Sending DH params to client
printf("Sending server's prime     : %16s ... ", prime);
// +1 pour écrire également le '\0' de fin de chaine
send(client_sock, prime, strlen(prime)+1, 0);

printf("Sending server's public key: %16s ... ", s_pub_key);
send(client_sock, s_pub_key, strlen(s_pub_key)+1, 0);

sprintf(generator,"%i", GENERATOR);
printf("Sending server's generator : %16s ... ", generator);	
send(client_sock, generator, strlen(generator)+1, 0);
...
// FREE de tout ce que t'as alloué ;)

Regardes si tu reçois bien la même chose du côté client.