Forum |  HardWare.fr | News | Articles | PC | Prix | S'identifier | S'inscrire | Aide | Shop Recherche
311 connectés 

  FORUM HardWare.fr
  Programmation
  C

  erreur fonction padding dans sha1

 



 Mot :   Pseudo :  
 
Bas de page
Auteur Sujet :

erreur fonction padding dans sha1

n°1930771
solean87
Posté le 09-10-2009 à 20:03:40  profilanswer
 

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 :
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. //#include <iostream>
  5. // rotation gauche x:valeur s:indice
  6. #define ROTL( x, s) ((x)<<(s))^((x)>>((32)-(s)))
  7. // #define Ch( x, y, z) (( (x) & (y))|(~(x) & (z)))
  8. #define Maj( x, y, z) (( (x) & (y))^( (x) & (z))^( (y) & (z)))
  9. //#define Parity(x, y, z) ( (x) ^ (y) ^ (z))
  10. unsigned int Ch (unsigned __int32 x,unsigned __int32 y,unsigned __int32 z)
  11. {
  12. return (( (x) & (y))^((~x) & (z)));
  13. }
  14. unsigned int Parity (unsigned __int32 x,unsigned __int32 y,unsigned __int32 z)
  15. {
  16. return ((x) ^ (y) ^ (z));
  17. }
  18. //fonction de conversion hexdécimal=>entier
  19. int convertir_Hexa_en_Int ( char dizaine, char unite ) {
  20. int resultat=0;
  21. resultat = 0;
  22. switch (unite) {
  23.     case 'a': resultat = 10; break;
  24.     case 'b': resultat = 11; break;
  25.     case 'c': resultat = 12; break;
  26.     case 'd': resultat = 13; break;
  27.     case 'e': resultat = 14; break;
  28.     case 'f': resultat = 15; break;
  29.     case '1': resultat = 1;  break;
  30.     case '2': resultat = 2;  break;
  31.     case '3': resultat = 3;  break;
  32.     case '4': resultat = 4;  break;
  33.     case '5': resultat = 5;  break;
  34.     case '6': resultat = 6;  break;
  35.     case '7': resultat = 7;  break;
  36.     case '8': resultat = 8;  break;
  37.     case '9': resultat = 9;  break;   
  38.     default : resultat = unite - 48;
  39.   
  40.  }
  41.  switch (dizaine) {
  42.     case 'a': resultat += 10*16; break;
  43.     case 'b': resultat += 11*16; break;
  44.     case 'c': resultat += 12*16; break;
  45.     case 'd': resultat += 13*16; break;
  46.     case 'e': resultat += 14*16; break;
  47.     case 'f': resultat += 15*16; break;
  48.     case '1': resultat += 1*16;  break;
  49.     case '2': resultat += 2*16;  break;
  50.     case '3': resultat += 3*16;  break;
  51.     case '4': resultat += 4*16;  break;
  52.     case '5': resultat += 5*16;  break;
  53.     case '6': resultat += 6*16;  break;
  54.     case '7': resultat += 7*16;  break;
  55.     case '8': resultat += 8*16;  break;
  56.     case '9': resultat += 9*16;  break;
  57.  }
  58.  return resultat;
  59. }
  60. //fonction padding
  61. int * padding ( char *message, int *unDejaMis ) {
  62.     char taille_en_Hexa[16];
  63. int i,j,taille_FIN,tailleTotSansLen;
  64. int taille_tmp;
  65. int reste;
  66. int message_format_Int[64] ;
  67. int *message_final;
  68. int lgmessage = 0;// longueur du message M
  69. //unsigned int tailleHex = 0;
  70. i = 0;
  71. j = 0;
  72. taille_FIN = 0;
  73. tailleTotSansLen = 0;
  74. taille_tmp=0;
  75. reste=0;
  76. lgmessage = strlen(message);
  77. tailleHex = lgmessage*8;
  78. for  (i = 0; i < 64 ; i++ ) {
  79.   message_format_Int[i] = 0;
  80.     }
  81. i=0;
  82. printf("\n\n\tL'entr\202e du padding: %s\n",message);
  83. while ( ( message[i] != '\0' ) && (i < 64 )) {
  84.   message_format_Int[i] = message[i];
  85.   i++;
  86. }
  87. taille_tmp = i;
  88. // 56 octets = 448 bits
  89. if ( taille_tmp < 55 )  { 
  90.   tailleTotSansLen = (taille_tmp / 55) + (56);
  91.      taille_FIN = tailleTotSansLen + 8;
  92.      message_final = (int*)malloc(taille_FIN*sizeof(int));
  93.      for ( i = 0; i < taille_tmp ; i++ ) {
  94.     message_final[i] = message_format_Int[i];
  95.   }
  96.   if ( *unDejaMis != 1 ) {// 1000 0000 = 128       
  97.       message_final[taille_tmp] = 128;
  98.       *unDejaMis = 1;
  99.      }
  100.   else
  101.      message_final[taille_tmp] = 0;
  102.    for ( i = taille_tmp+1 ; i < 56 ; i++ ) {
  103.     message_final[i] = 0;
  104.   }
  105.   printf("%d", lgmessage * 8);
  106.   //printf ("\n\ttaille : %X",taille_en_Hexa);
  107.   //sscanf ( taille_en_Hexa, "%016x", lgmessage*8 );
  108.   sprintf ( taille_en_Hexa, "%016x", lgmessage*8 );
  109.   //printf ("\n\ttaille : %016x",taille_en_Hexa);
  110.     message_final[63] = convertir_Hexa_en_Int ( taille_en_Hexa[14], taille_en_Hexa[15] );
  111.     message_final[62] = convertir_Hexa_en_Int ( taille_en_Hexa[12], taille_en_Hexa[13] );
  112.     message_final[61] = convertir_Hexa_en_Int ( taille_en_Hexa[10], taille_en_Hexa[11] );
  113.     message_final[60] = convertir_Hexa_en_Int ( taille_en_Hexa[8], taille_en_Hexa[9]  );
  114.     message_final[59] = convertir_Hexa_en_Int ( taille_en_Hexa[6], taille_en_Hexa[7]  );
  115.     message_final[58] = convertir_Hexa_en_Int ( taille_en_Hexa[4], taille_en_Hexa[5]  );
  116.     message_final[57] = convertir_Hexa_en_Int ( taille_en_Hexa[2], taille_en_Hexa[3]  );
  117.     message_final[56] = convertir_Hexa_en_Int ( taille_en_Hexa[0], taille_en_Hexa[1]  );
  118.   memset(taille_en_Hexa,0,16);
  119.     }
  120.     if ( taille_tmp == 55 ) {
  121.      message_final = (int*)malloc(64*sizeof(int));
  122.      for ( i = 0 ; i < 55 ; i++ ) {
  123.              message_final[i] = message_format_Int[i];
  124.          }
  125.          if ( *unDejaMis == 0 ) { // 1000 0000 = 128  
  126.       message_final[55] = 128;
  127.        *unDejaMis = 1;
  128.    }
  129.  else
  130.     message_final[55] = 0;
  131.   //printf("\n\tTaille :  %i",taille);
  132.     //sprintf ( taille_en_Hexa, "%016x", taille*8 );
  133.    message_final[63] = convertir_Hexa_en_Int ( taille_en_Hexa[14], taille_en_Hexa[15] );
  134.    message_final[62] = convertir_Hexa_en_Int ( taille_en_Hexa[12], taille_en_Hexa[13] );
  135.    message_final[61] = convertir_Hexa_en_Int ( taille_en_Hexa[10], taille_en_Hexa[11] );
  136.    message_final[60] = convertir_Hexa_en_Int ( taille_en_Hexa[8], taille_en_Hexa[9]  );
  137.    message_final[59] = convertir_Hexa_en_Int ( taille_en_Hexa[6], taille_en_Hexa[7]  );
  138.    message_final[58] = convertir_Hexa_en_Int ( taille_en_Hexa[4], taille_en_Hexa[5]  );
  139.    message_final[57] = convertir_Hexa_en_Int ( taille_en_Hexa[2], taille_en_Hexa[3]  );
  140.    message_final[56] = convertir_Hexa_en_Int ( taille_en_Hexa[0], taille_en_Hexa[1]  );
  141.  memset(taille_en_Hexa,0,16);
  142.  
  143.    }
  144.     else if ( taille_tmp >= 56 ) { // taille entre 56 et 64
  145.         message_final = (int*)malloc(64*sizeof(int));
  146.         if ( *unDejaMis ==0 ) {  // 1000 0000 = 128  
  147.            message_final[taille_tmp] = 128;     // // 1000 0000 = 128
  148.            *unDejaMis = 1;
  149.     }
  150.     else
  151.            message_final[taille_tmp] = 0;
  152.       
  153.     for ( i = 0 ; i < taille_tmp ; i++ ) {
  154.              message_final[i] = message_format_Int[i];
  155.          }
  156.          for ( i = taille_tmp +1 ; i < 64 ; i++ ) {
  157.     message_final[i] = 0;
  158.   }
  159.     }
  160.     printf("\n\tLes caracteres convertis en hexadecimal : " );
  161.     for ( i = 0 ; i < 64 ; i++ ) {
  162.  printf("%x ",message_final[i]);
  163. }
  164. printf("\n" );
  165. return message_final;
  166. }
  167. //fonction Creer les blocs M
  168. void CreerLesM ( int *mess, unsigned __int32 *M  ) {
  169.        
  170. int i;
  171. for ( i = 15; i >=0 ; i-- ) {
  172.  M[i] = mess[(i*4)+3] + ROTL(mess[(i*4)],24) + ROTL(mess[(i*4)+1],16)+ROTL(mess[(i*4)+2],8);
  173. }
  174. }
  175. void compress (unsigned int *H, unsigned __int32 *M)
  176. {
  177. // valeur de chainage spécifié au paragraphe 5.3.1
  178. // 16 mots de 32 bits qui est paddez
  179. int t;
  180. unsigned __int32 T;
  181. unsigned __int32 K; // Constante qui change a chaque tour
  182. //unsigned int res = 0;
  183.    unsigned __int32 A, B, C, D, E;
  184. unsigned __int32 F; // Sauv du resultat de la fontion courante
  185. unsigned __int32 w[80];
  186. for (t=0;t < 80; t++)
  187. {
  188.  if (0<=t && t < 16) // on initialise les 19 premier tours
  189.  {
  190.   w[t] = M[t];
  191.  }
  192.  else if (0<=t && t < 80) // on initialise les 19 premier tours
  193.  {
  194.   w[t] = ROTL((w[t-3]^w[t-8]^w[t-14]^w[t-16]),1);
  195.  }
  196. }
  197. A = H[0];
  198. B = H[1];
  199. C = H[2];
  200. D = H[3];
  201. E = H[4];
  202. printf( "t\t\tA        B        C        D        E\n" );
  203. for (t=0;t < 80; t++)
  204. {
  205.  if (0<=t && t < 20) // on initialise les 19 premier tours
  206.  {
  207.   K = 0x5a827999;
  208.   F = Ch(B,C,D);
  209.  }
  210.  else if (20<=t && t < 40) // on initialise les tours de 20 à 39
  211.  {
  212.   K = 0x6ed9eba1;
  213.   F = Parity(B, C, D);
  214.  }
  215.  else if (40<=t && t < 60) // on initialise les tours de 20 à 39
  216.  {
  217.   K = 0x8f1bbcdc;
  218.   F = Maj(B, C, D);
  219.  }
  220.  else if (60<=t && t < 80) // on initialise les tours de 20 à 39
  221.  {
  222.   K = 0xca62c1d6;
  223.   F = Parity(B, C, D);
  224.  }
  225.  T = ROTL(A,5);
  226.  T = T + F + E + K + w[t];
  227.  E = D;
  228.  D = C;
  229.  C = ROTL(B,30);
  230.  B = A;
  231.  A = T;
  232.  printf( "%d\t %08X %08X %08X %08X %08X \n",t ,A , B, C, D, E);
  233. }
  234. H[0] = A + H[0];
  235. H[1] = B + H[1];
  236. H[2] = C + H[2];
  237. H[3] = D + H[3];
  238. H[4] = E + H[4];
  239. printf( "\nResultat Compression : \nH[0]     H[1]     H[2]     H[3]     H[4] \n" );
  240. printf( "%08X %08X %08X %08X %08X\n",H[0], H[1], H[2], H[3], H[4]);
  241. }
  242. int main(int argc, char **argv)
  243. {
  244. // Declaration des variables
  245. int menu; // selection du menu du programme
  246. unsigned __int32 h[5];
  247. unsigned __int32 message_bloc[16]; // Pour tester le premier objectif
  248. char message[1000]; // message de 32 bits
  249. //char message[32] = "abc";
  250. //int lgmessage; // longueur du message M
  251. //unsigned M; // 512 bits
  252. //unsigned pM; // M plus padding
  253. // Initialisation de la valeur du hash
  254. h[0] = 0x67452301;
  255. h[1] = 0xefcdab89;
  256. h[2] = 0x98badcfe;
  257. h[3] = 0x10325476;
  258. h[4] = 0xc3d2e1f0;
  259. // pour tester ROTL printf("%x", ROTL(h[0],3));
  260. /*Afichage du menu*/
  261. menu = 0;
  262. do
  263.  {
  264.  do
  265.  {
  266.   system("cls" );
  267.   printf("******************************************************************* \n" );
  268.   printf("***************** La fonction de hachage SHA-1 ******************** \n" );
  269.   printf("*************************************************  * \n" );
  270.   printf("************************************************* * \n\n\n" );
  271.   printf("Choix 1 : Objectif 1 : Teste de la fonction compression \n\n" );
  272.   printf("Choix 2 : Objectif 2 : Hacher des chaines de caracteres quelconques\n\n" );
  273.   printf("Choix 3 : Objectif 3 : Hacher un fichier de taille quelconque \n\n" );
  274.   printf("Choix 4 : Quitter \n\n" );
  275.   printf("******************************************************************* \n\n" );
  276.   printf("Saisir le choix : " );
  277.   fflush(stdin);
  278.   scanf ("%d",&menu);
  279.   switch (menu)
  280.   {
  281.    case 1 ://saisie des 5 valeurs
  282.     system("cls" ); // netoyer l'affichage
  283.     // message_bloc avec padding abc+1
  284.     message_bloc[0] = 0x61626380;
  285.     message_bloc[1] = 0x00000000;
  286.     message_bloc[2] = 0x00000000;
  287.     message_bloc[3] = 0x00000000;
  288.     message_bloc[4] = 0x00000000;
  289.     message_bloc[5] = 0x00000000;
  290.     message_bloc[6] = 0x00000000;
  291.     message_bloc[7] = 0x00000000;
  292.     message_bloc[8] = 0x00000000;
  293.     message_bloc[9] = 0x00000000;
  294.     message_bloc[10] = 0x00000000;
  295.     message_bloc[11] = 0x00000000;
  296.     message_bloc[12] = 0x00000000;
  297.     message_bloc[13] = 0x00000000;
  298.     message_bloc[14] = 0x00000000;
  299.     message_bloc[15] = 0x00000018;
  300.     compress(h,message_bloc);
  301.     system("pause" );
  302.    break;
  303.    case 2 :
  304.      system("cls" ); // netoyer l'affichage
  305.      printf("saisir un message:" );
  306.      scanf("%s",&message);
  307.      printf("%d",strlen(message));
  308.      //padding(message);
  309.      system("pause" );
  310.    break;
  311.    case 3 :
  312.     //printf("non fonctionnel!\n" );
  313.     FILE *fichier;
  314.     int tailleFichier;
  315.     char *chaine;
  316.     int nbTour;
  317.     unsigned __int32 *M ;
  318.     int *mess, unDejaMis;
  319.     unsigned int taille;
  320.     int n;
  321.     int occurence;
  322.     int reste_actuel;
  323.     int i,j;
  324.     tailleFichier = 0;
  325.     unDejaMis = 0;
  326.     taille = 0;
  327.     n = 0;
  328.     reste_actuel = 0;
  329.     M = (unsigned __int32*)malloc(16*sizeof(unsigned __int32));
  330.     //scanf("Nom du fichier a charger : %s", &nomfichier);
  331.     fichier = fopen("sha1.txt","rb" );
  332.     // Vérification si le fichier existe
  333.     if (fichier == NULL)
  334.     {
  335.      printf ("Le fichier n'existe pas.\n" );
  336.      system("pause" );
  337.      exit(0);
  338.     }
  339.     else
  340.     {
  341.      printf ("Le fichier est charge en memoire\n" );
  342.      while (! feof(fichier))
  343.      {
  344.       chaine = (char*)malloc(64*sizeof(char));
  345.       tailleFichier = tailleFichier + fread(chaine, 1, 64, fichier);
  346.       //printf("\nIl y a %d caractere dans le fichier\n",tailleFichier);
  347.      }
  348.      if ((( tailleFichier + 9) % 64) == 0)
  349.      {
  350.       nbTour = ((tailleFichier + 9) / 64);
  351.      }
  352.      else
  353.      {
  354.       nbTour = (((tailleFichier +9) / 64) +1);
  355.      }
  356.      //printf("%d\n", nbTour);
  357.      reste_actuel = tailleFichier;
  358.       fclose(fichier);
  359.       fichier = fopen("sha1.txt", "rb" );
  360.       occurence = 0;
  361.      while ( occurence < nbTour) 
  362.      { 
  363.                           //printf("\n\tboucle %i\n",occurence);
  364.       chaine = (char*)malloc(64*sizeof(char));
  365.       n=0;
  366.       for ( i = 0 ; i < 64 ; i++ )
  367.        chaine[i] = '\0';
  368.       mess = (int*)malloc(64*sizeof(int));
  369.       if ( reste_actuel > 0 ) 
  370.        n = fread( chaine, 1, 64, fichier );   // le dernier est le 1 à rajouter
  371.          
  372.       reste_actuel -= n;
  373.       chaine[n] = '\0';
  374.       //printf("n %i\n",n);
  375.       //printf("%d",tailleFichier);
  376.       mess = padding(chaine,&unDejaMis);
  377.       ////// test///////////
  378.       printf("\n\tLe mess avant le découpage : " );
  379.       for ( j = 0; j < 80 ; j++) {
  380.       printf("%d ",mess[j]);
  381.       }
  382.       printf("\n\n\n" );
  383.        //A=h0;  
  384.            //B=h1;  
  385.            //C=h2;  
  386.            //D=h3;  
  387.            //E=h4;
  388.    
  389.       CreerLesM(mess,M);
  390.       ////// test///////////
  391.       printf("\n\tLes M : " );
  392.       for ( j = 0; j < 16 ; j++) {
  393.       printf("%08X ",M[j]);
  394.       }
  395.       printf("\n\n\n" );
  396.       compress(h,M);
  397.            /*
  398.            for ( i = 0; i <= 15 ; i++ )  
  399.        {
  400.             W[i] = M[i];
  401.            }
  402.            for ( i = 16; i <= 79; i++ ) {
  403.             W[i] = DecalageCirculaire(W[i-3] ^ W[i-8] ^ W[i-14] ^ W[i-16], 1);
  404.            }
  405.      
  406.            for ( i = 0; i <= 19 ; i++ )  
  407.        {
  408.             F[i] = (B & C) | ((~B) & D );
  409.             temp = DecalageCirculaire(A,5) + F[i] + E + W[i] + 0x5a827999;
  410.             E = D; D = C; C = DecalageCirculaire(B,30); B = A; A = temp;
  411.            }
  412.            for ( i = 20; i <= 39; i++ )  
  413.        {
  414.             F[i] = (B ^ C ^ D);
  415.             temp = DecalageCirculaire(A,5) + F[i] + E + W[i] + 0x6ed9eba1;
  416.             E = D; D = C; C = DecalageCirculaire(B,30); B = A; A = temp;
  417.            }
  418.            for ( i = 40; i <= 59; i++ )  
  419.        {
  420.             F[i] = (B & C) | (B & D) | (C & D);
  421.             temp = DecalageCirculaire(A,5) + F[i] + E + W[i] + 0x8f1bbcdc;
  422.             E = D; D = C; C = DecalageCirculaire(B,30); B = A; A = temp;
  423.            }
  424.            for ( i = 60; i <= 79; i++ )  
  425.        {
  426.             F[i] = (B ^ C ^ D);
  427.             temp = DecalageCirculaire(A,5) + F[i] + E + W[i] + 0xca62c1d6;
  428.             E = D; D = C; C = DecalageCirculaire(B,30); B = A; A = temp;
  429.            }
  430.            h0 = A + h0; h1 = B + h1; h2 = C +h2; h3 = D + h3; h4 = E + h4;
  431.      
  432.        printf("\n\n\tHaSH : %x %x %x %x %x\n",h0,h1,h2,h3,h4);
  433. */
  434.       occurence++; 
  435.    
  436.          }
  437.     printf("\n\n\t" );
  438.        system("PAUSE" );
  439.     printf("\n\n\t" );
  440.         free(chaine);
  441.         free(mess);
  442.     //fclose(fichier);
  443.     //}
  444. //return 0;
  445. //}*/
  446.     fclose(fichier);
  447.     //system("pause" );
  448.    }
  449.    break;
  450.    case 4 :
  451.     menu = 4;
  452.    break;
  453.   }
  454.  } while (menu <4 && menu >1);
  455. } while (menu != 4);
  456. }

mood
Publicité
Posté le 09-10-2009 à 20:03:40  profilanswer
 

n°1930788
tpierron
Posté le 09-10-2009 à 22:30:02  profilanswer
 

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 :
  1. char taille_en_Hexa[16];
  2. /*... */
  3. 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.

n°1930865
solean87
Posté le 10-10-2009 à 16:06:54  profilanswer
 

merci ça fonctionne trés bien

n°1930911
regexp42
Eplucheur de RFC.
Posté le 11-10-2009 à 00:07:26  profilanswer
 

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.


Aller à :
Ajouter une réponse
  FORUM HardWare.fr
  Programmation
  C

  erreur fonction padding dans sha1

 

Sujets relatifs
[C] pb pour passer une matrice en parametre d'un fonctionErreur de la Function Filemtime()
erreur tomcat: java.lang.NoClassDefFoundError[Boost::random] Template comme argument d'une fonction...
La fonction qui tue gccframe + js = erreur acces
[VBA] Pb gestion d'erreurfonction initialisé valeurs formulaires rien ne se passe
erreur actionscriptExporter fonction excel
Plus de sujets relatifs à : erreur fonction padding dans sha1


Copyright © 1997-2018 Hardware.fr SARL (Signaler un contenu illicite) / Groupe LDLC / Shop HFR