erreur fonction padding dans sha1

Marsh Posté le 09-10-2009 à 20:03:40

bonjour,

je doit développer la fonction de hashage sha1 pour un cours de cripto a rendre lundi j'ais un souci dans ma fonction padding en effet mon programme est mis en échec sur sprintf

si vous pouvez me permettre de m'en sortir ça serai super car la je blocque totalement.

merci d'avance

Le code en C:

Code :

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//#include <iostream>
// rotation gauche x:valeur s:indice
#define ROTL( x, s) ((x)<<(s))^((x)>>((32)-(s)))
// #define Ch( x, y, z) (( (x) & (y))|(~(x) & (z)))
#define Maj( x, y, z) (( (x) & (y))^( (x) & (z))^( (y) & (z)))
//#define Parity(x, y, z) ( (x) ^ (y) ^ (z))
unsigned int Ch (unsigned __int32 x,unsigned __int32 y,unsigned __int32 z)
{
return (( (x) & (y))^((~x) & (z)));
}
unsigned int Parity (unsigned __int32 x,unsigned __int32 y,unsigned __int32 z)
{
return ((x) ^ (y) ^ (z));
}
//fonction de conversion hexdécimal=>entier
int convertir_Hexa_en_Int ( char dizaine, char unite ) {
int resultat=0;
resultat = 0;
switch (unite) {
case 'a': resultat = 10; break;
case 'b': resultat = 11; break;
case 'c': resultat = 12; break;
case 'd': resultat = 13; break;
case 'e': resultat = 14; break;
case 'f': resultat = 15; break;
case '1': resultat = 1; break;
case '2': resultat = 2; break;
case '3': resultat = 3; break;
case '4': resultat = 4; break;
case '5': resultat = 5; break;
case '6': resultat = 6; break;
case '7': resultat = 7; break;
case '8': resultat = 8; break;
case '9': resultat = 9; break;
default : resultat = unite - 48;
}
switch (dizaine) {
case 'a': resultat += 10*16; break;
case 'b': resultat += 11*16; break;
case 'c': resultat += 12*16; break;
case 'd': resultat += 13*16; break;
case 'e': resultat += 14*16; break;
case 'f': resultat += 15*16; break;
case '1': resultat += 1*16; break;
case '2': resultat += 2*16; break;
case '3': resultat += 3*16; break;
case '4': resultat += 4*16; break;
case '5': resultat += 5*16; break;
case '6': resultat += 6*16; break;
case '7': resultat += 7*16; break;
case '8': resultat += 8*16; break;
case '9': resultat += 9*16; break;
}
return resultat;
}
//fonction padding
int * padding ( char *message, int *unDejaMis ) {
char taille_en_Hexa[16];
int i,j,taille_FIN,tailleTotSansLen;
int taille_tmp;
int reste;
int message_format_Int[64] ;
int *message_final;
int lgmessage = 0;// longueur du message M
//unsigned int tailleHex = 0;
i = 0;
j = 0;
taille_FIN = 0;
tailleTotSansLen = 0;
taille_tmp=0;
reste=0;
lgmessage = strlen(message);
tailleHex = lgmessage*8;
for (i = 0; i < 64 ; i++ ) {
message_format_Int[i] = 0;
}
i=0;
printf("\n\n\tL'entr\202e du padding: %s\n",message);
while ( ( message[i] != '\0' ) && (i < 64 )) {
message_format_Int[i] = message[i];
i++;
}
taille_tmp = i;
// 56 octets = 448 bits
if ( taille_tmp < 55 ) {
tailleTotSansLen = (taille_tmp / 55) + (56);
taille_FIN = tailleTotSansLen + 8;
message_final = (int*)malloc(taille_FIN*sizeof(int));
for ( i = 0; i < taille_tmp ; i++ ) {
message_final[i] = message_format_Int[i];
}
if ( *unDejaMis != 1 ) {// 1000 0000 = 128
message_final[taille_tmp] = 128;
*unDejaMis = 1;
}
else
message_final[taille_tmp] = 0;
for ( i = taille_tmp+1 ; i < 56 ; i++ ) {
message_final[i] = 0;
}
printf("%d", lgmessage * 8);
//printf ("\n\ttaille : %X",taille_en_Hexa);
//sscanf ( taille_en_Hexa, "%016x", lgmessage*8 );
sprintf ( taille_en_Hexa, "%016x", lgmessage*8 );
//printf ("\n\ttaille : %016x",taille_en_Hexa);
message_final[63] = convertir_Hexa_en_Int ( taille_en_Hexa[14], taille_en_Hexa[15] );
message_final[62] = convertir_Hexa_en_Int ( taille_en_Hexa[12], taille_en_Hexa[13] );
message_final[61] = convertir_Hexa_en_Int ( taille_en_Hexa[10], taille_en_Hexa[11] );
message_final[60] = convertir_Hexa_en_Int ( taille_en_Hexa[8], taille_en_Hexa[9] );
message_final[59] = convertir_Hexa_en_Int ( taille_en_Hexa[6], taille_en_Hexa[7] );
message_final[58] = convertir_Hexa_en_Int ( taille_en_Hexa[4], taille_en_Hexa[5] );
message_final[57] = convertir_Hexa_en_Int ( taille_en_Hexa[2], taille_en_Hexa[3] );
message_final[56] = convertir_Hexa_en_Int ( taille_en_Hexa[0], taille_en_Hexa[1] );
memset(taille_en_Hexa,0,16);
}
if ( taille_tmp == 55 ) {
message_final = (int*)malloc(64*sizeof(int));
for ( i = 0 ; i < 55 ; i++ ) {
message_final[i] = message_format_Int[i];
}
if ( *unDejaMis == 0 ) { // 1000 0000 = 128
message_final[55] = 128;
*unDejaMis = 1;
}
else
message_final[55] = 0;
//printf("\n\tTaille : %i",taille);
//sprintf ( taille_en_Hexa, "%016x", taille*8 );
message_final[63] = convertir_Hexa_en_Int ( taille_en_Hexa[14], taille_en_Hexa[15] );
message_final[62] = convertir_Hexa_en_Int ( taille_en_Hexa[12], taille_en_Hexa[13] );
message_final[61] = convertir_Hexa_en_Int ( taille_en_Hexa[10], taille_en_Hexa[11] );
message_final[60] = convertir_Hexa_en_Int ( taille_en_Hexa[8], taille_en_Hexa[9] );
message_final[59] = convertir_Hexa_en_Int ( taille_en_Hexa[6], taille_en_Hexa[7] );
message_final[58] = convertir_Hexa_en_Int ( taille_en_Hexa[4], taille_en_Hexa[5] );
message_final[57] = convertir_Hexa_en_Int ( taille_en_Hexa[2], taille_en_Hexa[3] );
message_final[56] = convertir_Hexa_en_Int ( taille_en_Hexa[0], taille_en_Hexa[1] );
memset(taille_en_Hexa,0,16);
}
else if ( taille_tmp >= 56 ) { // taille entre 56 et 64
message_final = (int*)malloc(64*sizeof(int));
if ( *unDejaMis ==0 ) { // 1000 0000 = 128
message_final[taille_tmp] = 128; // // 1000 0000 = 128
*unDejaMis = 1;
}
else
message_final[taille_tmp] = 0;
for ( i = 0 ; i < taille_tmp ; i++ ) {
message_final[i] = message_format_Int[i];
}
for ( i = taille_tmp +1 ; i < 64 ; i++ ) {
message_final[i] = 0;
}
}
printf("\n\tLes caracteres convertis en hexadecimal : " );
for ( i = 0 ; i < 64 ; i++ ) {
printf("%x ",message_final[i]);
}
printf("\n" );
return message_final;
}
//fonction Creer les blocs M
void CreerLesM ( int *mess, unsigned __int32 *M ) {
int i;
for ( i = 15; i >=0 ; i-- ) {
M[i] = mess[(i*4)+3] + ROTL(mess[(i*4)],24) + ROTL(mess[(i*4)+1],16)+ROTL(mess[(i*4)+2],8);
}
}
void compress (unsigned int *H, unsigned __int32 *M)
{
// valeur de chainage spécifié au paragraphe 5.3.1
// 16 mots de 32 bits qui est paddez
int t;
unsigned __int32 T;
unsigned __int32 K; // Constante qui change a chaque tour
//unsigned int res = 0;
unsigned __int32 A, B, C, D, E;
unsigned __int32 F; // Sauv du resultat de la fontion courante
unsigned __int32 w[80];
for (t=0;t < 80; t++)
{
if (0<=t && t < 16) // on initialise les 19 premier tours
{
w[t] = M[t];
}
else if (0<=t && t < 80) // on initialise les 19 premier tours
{
w[t] = ROTL((w[t-3]^w[t-8]^w[t-14]^w[t-16]),1);
}
}
A = H[0];
B = H[1];
C = H[2];
D = H[3];
E = H[4];
printf( "t\t\tA B C D E\n" );
for (t=0;t < 80; t++)
{
if (0<=t && t < 20) // on initialise les 19 premier tours
{
K = 0x5a827999;
F = Ch(B,C,D);
}
else if (20<=t && t < 40) // on initialise les tours de 20 à 39
{
K = 0x6ed9eba1;
F = Parity(B, C, D);
}
else if (40<=t && t < 60) // on initialise les tours de 20 à 39
{
K = 0x8f1bbcdc;
F = Maj(B, C, D);
}
else if (60<=t && t < 80) // on initialise les tours de 20 à 39
{
K = 0xca62c1d6;
F = Parity(B, C, D);
}
T = ROTL(A,5);
T = T + F + E + K + w[t];
E = D;
D = C;
C = ROTL(B,30);
B = A;
A = T;
printf( "%d\t %08X %08X %08X %08X %08X \n",t ,A , B, C, D, E);
}
H[0] = A + H[0];
H[1] = B + H[1];
H[2] = C + H[2];
H[3] = D + H[3];
H[4] = E + H[4];
printf( "\nResultat Compression : \nH[0] H[1] H[2] H[3] H[4] \n" );
printf( "%08X %08X %08X %08X %08X\n",H[0], H[1], H[2], H[3], H[4]);
}
int main(int argc, char **argv)
{
// Declaration des variables
int menu; // selection du menu du programme
unsigned __int32 h[5];
unsigned __int32 message_bloc[16]; // Pour tester le premier objectif
char message[1000]; // message de 32 bits
//char message[32] = "abc";
//int lgmessage; // longueur du message M
//unsigned M; // 512 bits
//unsigned pM; // M plus padding
// Initialisation de la valeur du hash
h[0] = 0x67452301;
h[1] = 0xefcdab89;
h[2] = 0x98badcfe;
h[3] = 0x10325476;
h[4] = 0xc3d2e1f0;
// pour tester ROTL printf("%x", ROTL(h[0],3));
/*Afichage du menu*/
menu = 0;
do
{
do
{
system("cls" );
printf("******************************************************************* \n" );
printf("***************** La fonction de hachage SHA-1 ******************** \n" );
printf("************************************************* * \n" );
printf("************************************************* * \n\n\n" );
printf("Choix 1 : Objectif 1 : Teste de la fonction compression \n\n" );
printf("Choix 2 : Objectif 2 : Hacher des chaines de caracteres quelconques\n\n" );
printf("Choix 3 : Objectif 3 : Hacher un fichier de taille quelconque \n\n" );
printf("Choix 4 : Quitter \n\n" );
printf("******************************************************************* \n\n" );
printf("Saisir le choix : " );
fflush(stdin);
scanf ("%d",&menu);
switch (menu)
{
case 1 ://saisie des 5 valeurs
system("cls" ); // netoyer l'affichage
// message_bloc avec padding abc+1
message_bloc[0] = 0x61626380;
message_bloc[1] = 0x00000000;
message_bloc[2] = 0x00000000;
message_bloc[3] = 0x00000000;
message_bloc[4] = 0x00000000;
message_bloc[5] = 0x00000000;
message_bloc[6] = 0x00000000;
message_bloc[7] = 0x00000000;
message_bloc[8] = 0x00000000;
message_bloc[9] = 0x00000000;
message_bloc[10] = 0x00000000;
message_bloc[11] = 0x00000000;
message_bloc[12] = 0x00000000;
message_bloc[13] = 0x00000000;
message_bloc[14] = 0x00000000;
message_bloc[15] = 0x00000018;
compress(h,message_bloc);
system("pause" );
break;
case 2 :
system("cls" ); // netoyer l'affichage
printf("saisir un message:" );
scanf("%s",&message);
printf("%d",strlen(message));
//padding(message);
system("pause" );
break;
case 3 :
//printf("non fonctionnel!\n" );
FILE *fichier;
int tailleFichier;
char *chaine;
int nbTour;
unsigned __int32 *M ;
int *mess, unDejaMis;
unsigned int taille;
int n;
int occurence;
int reste_actuel;
int i,j;
tailleFichier = 0;
unDejaMis = 0;
taille = 0;
n = 0;
reste_actuel = 0;
M = (unsigned __int32*)malloc(16*sizeof(unsigned __int32));
//scanf("Nom du fichier a charger : %s", &nomfichier);
fichier = fopen("sha1.txt","rb" );
// Vérification si le fichier existe
if (fichier == NULL)
{
printf ("Le fichier n'existe pas.\n" );
system("pause" );
exit(0);
}
else
{
printf ("Le fichier est charge en memoire\n" );
while (! feof(fichier))
{
chaine = (char*)malloc(64*sizeof(char));
tailleFichier = tailleFichier + fread(chaine, 1, 64, fichier);
//printf("\nIl y a %d caractere dans le fichier\n",tailleFichier);
}
if ((( tailleFichier + 9) % 64) == 0)
{
nbTour = ((tailleFichier + 9) / 64);
}
else
{
nbTour = (((tailleFichier +9) / 64) +1);
}
//printf("%d\n", nbTour);
reste_actuel = tailleFichier;
fclose(fichier);
fichier = fopen("sha1.txt", "rb" );
occurence = 0;
while ( occurence < nbTour)
{
//printf("\n\tboucle %i\n",occurence);
chaine = (char*)malloc(64*sizeof(char));
n=0;
for ( i = 0 ; i < 64 ; i++ )
chaine[i] = '\0';
mess = (int*)malloc(64*sizeof(int));
if ( reste_actuel > 0 )
n = fread( chaine, 1, 64, fichier ); // le dernier est le 1 à rajouter
reste_actuel -= n;
chaine[n] = '\0';
//printf("n %i\n",n);
//printf("%d",tailleFichier);
mess = padding(chaine,&unDejaMis);
////// test///////////
printf("\n\tLe mess avant le découpage : " );
for ( j = 0; j < 80 ; j++) {
printf("%d ",mess[j]);
}
printf("\n\n\n" );
//A=h0;
//B=h1;
//C=h2;
//D=h3;
//E=h4;
CreerLesM(mess,M);
////// test///////////
printf("\n\tLes M : " );
for ( j = 0; j < 16 ; j++) {
printf("%08X ",M[j]);
}
printf("\n\n\n" );
compress(h,M);
/*
for ( i = 0; i <= 15 ; i++ )
{
W[i] = M[i];
}
for ( i = 16; i <= 79; i++ ) {
W[i] = DecalageCirculaire(W[i-3] ^ W[i-8] ^ W[i-14] ^ W[i-16], 1);
}
for ( i = 0; i <= 19 ; i++ )
{
F[i] = (B & C) | ((~B) & D );
temp = DecalageCirculaire(A,5) + F[i] + E + W[i] + 0x5a827999;
E = D; D = C; C = DecalageCirculaire(B,30); B = A; A = temp;
}
for ( i = 20; i <= 39; i++ )
{
F[i] = (B ^ C ^ D);
temp = DecalageCirculaire(A,5) + F[i] + E + W[i] + 0x6ed9eba1;
E = D; D = C; C = DecalageCirculaire(B,30); B = A; A = temp;
}
for ( i = 40; i <= 59; i++ )
{
F[i] = (B & C) | (B & D) | (C & D);
temp = DecalageCirculaire(A,5) + F[i] + E + W[i] + 0x8f1bbcdc;
E = D; D = C; C = DecalageCirculaire(B,30); B = A; A = temp;
}
for ( i = 60; i <= 79; i++ )
{
F[i] = (B ^ C ^ D);
temp = DecalageCirculaire(A,5) + F[i] + E + W[i] + 0xca62c1d6;
E = D; D = C; C = DecalageCirculaire(B,30); B = A; A = temp;
}
h0 = A + h0; h1 = B + h1; h2 = C +h2; h3 = D + h3; h4 = E + h4;
printf("\n\n\tHaSH : %x %x %x %x %x\n",h0,h1,h2,h3,h4);
*/
occurence++;
}
printf("\n\n\t" );
system("PAUSE" );
printf("\n\n\t" );
free(chaine);
free(mess);
//fclose(fichier);
//}
//return 0;
//}*/
fclose(fichier);
//system("pause" );
}
break;
case 4 :
menu = 4;
break;
}
} while (menu <4 && menu >1);
} while (menu != 4);
}

Marsh Posté le 09-10-2009 à 20:03:40

Marsh Posté le 09-10-2009 à 22:30:02

Bon, je n'ai pas regardé tout le détail du code, mais déjà avec ça, tu vas obtenir un buffer overflow, donc crash potentiel :

Code :

char taille_en_Hexa[16];
/*... */
sprintf ( taille_en_Hexa, "%016x", lgmessage*8 );

%016x va te générer une chaine de 17 caractères (et oui, le 0 final) alors que ton tableau n'en a que 16.

Marsh Posté le 10-10-2009 à 16:06:54

merci ça fonctionne trés bien

Message cité 1 fois

Marsh Posté le 11-10-2009 à 00:07:26

solean87 a écrit :

merci ça fonctionne trés bien

Prends l'habitude d'utiliser snprintf() plutôt que sprintf(), ça t'éviteras ce genre de soucis.

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed

Name *

Email *

URL

Message *