[BACK]Return to instructions_d6.c CVS log [TXT] [DIR] Up to [local] / rpl / src

Diff for /rpl/src/instructions_d6.c between versions 1.40 and 1.41

version 1.40, 2013/02/23 18:51:43 version 1.41, 2013/02/25 11:24:02
Line 611  instruction_digest(struct_processus *s_e Line 611  instruction_digest(struct_processus *s_e
   
     logical1                    somme_invalide;      logical1                    somme_invalide;
   
       long                        i;
     long                        longueur_chaine;      long                        longueur_chaine;
   
       struct_liste_chainee        *l_element_courant;
   
     struct_objet                *s_objet_argument_1;      struct_objet                *s_objet_argument_1;
     struct_objet                *s_objet_argument_2;      struct_objet                *s_objet_argument_2;
     struct_objet                *s_objet_resultat;      struct_objet                *s_objet_resultat;
   
     unsigned char               *chaine;      unsigned char               *chaine;
       unsigned char               *clef;
     unsigned char               *fonction;      unsigned char               *fonction;
     unsigned char               somme[EVP_MAX_MD_SIZE];      unsigned char               somme[EVP_MAX_MD_SIZE];
       unsigned char               *tampon;
   
       unsigned int                longueur_bloc;
     unsigned int                longueur_somme;      unsigned int                longueur_somme;
       unsigned int                longueur_tampon;
   
       unsigned long               longueur_clef;
   
     (*s_etat_processus).erreur_execution = d_ex;      (*s_etat_processus).erreur_execution = d_ex;
   
Line 691  instruction_digest(struct_processus *s_e Line 700  instruction_digest(struct_processus *s_e
         printf("    - WHIRLPOOL\n");          printf("    - WHIRLPOOL\n");
 #       endif  #       endif
   
           printf("\n");
   
           if ((*s_etat_processus).langue == 'F')
           {
               printf("  Utilisation :\n\n");
           }
           else
           {
               printf("  Usage:\n\n");
           }
   
           printf("    \"text\" \"MD5\" DIGEST\n");
           printf("    \"text\" { \"SHA384\" \"key\" } DIGEST\n");
           printf("    \"text\" { \"AES-CBC\" \"key\" } DIGEST\n");
         return;          return;
     }      }
     else if ((*s_etat_processus).test_instruction == 'Y')      else if ((*s_etat_processus).test_instruction == 'Y')
Line 931  instruction_digest(struct_processus *s_e Line 954  instruction_digest(struct_processus *s_e
                             }                              }
 #                           endif  #                           endif
   
 #                           ifndef OPENSSL_NO_MD4  #                           ifndef OPENSSL_NO_MD5
                             case '5': // md5                              case '5': // md5
                             {                              {
                                 if (fonction[3] == d_code_fin_chaine)                                  if (fonction[3] == d_code_fin_chaine)
Line 1346  instruction_digest(struct_processus *s_e Line 1369  instruction_digest(struct_processus *s_e
             return;              return;
         }          }
     }      }
     else if (((*s_objet_argument_1).type == CHN) &&      else if (((*s_objet_argument_1).type == LST) &&
             ((*s_objet_argument_2).type == LST))              ((*s_objet_argument_2).type == CHN))
     {      {
         BUG(1, uprintf("Oops\n"));          l_element_courant = (*s_objet_argument_1).objet;
         s_objet_resultat = NULL;  
           if ((*(*l_element_courant).donnee).type != CHN)
           {
               liberation(s_etat_processus, s_objet_argument_1);
               liberation(s_etat_processus, s_objet_argument_2);
   
               (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
               return;
           }
   
           l_element_courant = (*l_element_courant).suivant;
   
           if (l_element_courant == NULL)
           {
               liberation(s_etat_processus, s_objet_argument_1);
               liberation(s_etat_processus, s_objet_argument_2);
   
               (*s_etat_processus).erreur_execution = d_ex_manque_argument;
               return;
           }
   
           if ((*(*l_element_courant).donnee).type != CHN)
           {
               liberation(s_etat_processus, s_objet_argument_1);
               liberation(s_etat_processus, s_objet_argument_2);
   
               (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
               return;
           }
   
           if ((*l_element_courant).suivant != NULL)
           {
               liberation(s_etat_processus, s_objet_argument_1);
               liberation(s_etat_processus, s_objet_argument_2);
   
               (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
               return;
           }
   
           // Test du type de somme de contrôle
           // - les sommes classiques suivent la RFC 2104
           // - les autres sont formées sur des algorithmes de type CBC
   
           l_element_courant = (*s_objet_argument_1).objet;
   
           if ((fonction = conversion_majuscule((unsigned char *)
                   (*(*l_element_courant).donnee).objet)) == NULL)
           {
               (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
               return;
           }
   
           somme_invalide = d_faux;
   
           switch(fonction[0])
           {
               case 'D':
               {
                   switch(fonction[1])
                   {
                       case 'S': // ds
                       {
                           switch(fonction[2])
                           {
   #                           ifndef OPENSSL_NO_SHA
                               case 'S': // dss
                               {
                                   switch(fonction[3])
                                   {
                                       case d_code_fin_chaine:
                                       {
                                           EVP_sum = EVP_dss;
                                           longueur_bloc = SHA_CBLOCK;
                                           break;
                                       }
   
                                       case '1': // dss1
                                       {
                                           if (fonction[4] == d_code_fin_chaine)
                                           {
                                               EVP_sum = EVP_dss1;
                                               longueur_bloc = SHA_CBLOCK;
                                           }
                                           else
                                           {
                                               somme_invalide = d_vrai;
                                           }
   
                                           break;
                                       }
   
                                       default:
                                       {
                                           somme_invalide = d_vrai;
                                           break;
                                       }
                                   }
   
                                   break;
                               }
   #                           endif
   
                               default:
                               {
                                   somme_invalide = d_vrai;
                                   break;
                               }
                           }
   
                           break;
                       }
   
                       default:
                       {
                           somme_invalide = d_vrai;
                           break;
                       }
                   }
   
                   break;
               }
   
               case 'E':
               {
                   switch(fonction[1])
                   {
                       case 'C': // ec
                       {
                           switch(fonction[2])
                           {
                               case 'D': // ecd
                               {
                                   switch(fonction[3])
                                   {
                                       case 'S': // ecds
                                       {
                                           switch(fonction[4])
                                           {
   #                                           ifndef OPENSSL_NO_SHA
                                               case 'A': // ecdsa
                                               {
                                                   if (fonction[5] ==
                                                           d_code_fin_chaine)
                                                   {
                                                       EVP_sum = EVP_ecdsa;
                                                       longueur_bloc = SHA_CBLOCK;
                                                   }
                                                   else
                                                   {
                                                       somme_invalide = d_vrai;
                                                   }
   
                                                   break;
                                               }
   #                                           endif
   
                                               default:
                                               {
                                                   somme_invalide = d_vrai;
                                                   break;
                                               }
                                           }
   
                                           break;
                                       }
   
                                       default:
                                       {
                                           somme_invalide = d_vrai;
                                           break;
                                       }
                                   }
   
                                   break;
                               }
   
                               default:
                               {
                                   somme_invalide = d_vrai;
                                   break;
                               }
                           }
   
                           break;
                       }
   
                       default:
                       {
                           somme_invalide = d_vrai;
                           break;
                       }
                   }
   
                   break;
               }
   
               case 'M':
               {
                   switch(fonction[1])
                   {
                       case 'D': // md
                       {
                           switch(fonction[2])
                           {
   #                           ifndef OPENSSL_NO_MD2
                               case '2': // md2
                               {
                                   if (fonction[3] == d_code_fin_chaine)
                                   {
                                       EVP_sum = EVP_md2;
                                       longueur_bloc = MD2_BLOCK;
                                   }
                                   else
                                   {
                                       somme_invalide = d_vrai;
                                   }
   
                                   break;
                               }
   #                           endif
   
   #                           ifndef OPENSSL_NO_MD4
                               case '4': // md4
                               {
                                   if (fonction[3] == d_code_fin_chaine)
                                   {
                                       EVP_sum = EVP_md4;
                                       longueur_bloc = MD4_CBLOCK;
                                   }
                                   else
                                   {
                                       somme_invalide = d_vrai;
                                   }
   
                                   break;
                               }
   #                           endif
   
   #                           ifndef OPENSSL_NO_MD5
                               case '5': // md5
                               {
                                   if (fonction[3] == d_code_fin_chaine)
                                   {
                                       EVP_sum = EVP_md5;
                                       longueur_bloc = MD5_CBLOCK;
                                   }
                                   else
                                   {
                                       somme_invalide = d_vrai;
                                   }
   
                                   break;
                               }
   #                           endif
   
                               case 'C': // mdc
                               {
                                   switch(fonction[3])
                                   {
   #                                   ifndef OPENSSL_NO_MDC2
                                       case '2': // mdc2
                                       {
                                           if (fonction[4] == d_code_fin_chaine)
                                           {
                                               EVP_sum = EVP_mdc2;
                                               longueur_bloc = MDC2_BLOCK;
                                           }
                                           else
                                           {
                                               somme_invalide = d_vrai;
                                           }
   
                                           break;
                                       }
   #                                   endif
   
                                       default:
                                       {
                                           somme_invalide = d_vrai;
                                           break;
                                       }
                                   }
   
                                   break;
                               }
   
                               default:
                               {
                                   somme_invalide = d_vrai;
                                   break;
                               }
                           }
   
                           break;
                       }
   
                       default:
                       {
                           somme_invalide = d_vrai;
                           break;
                       }
                   }
   
                   break;
               }
   
   #           ifndef OPENSSL_NO_RIPEMD
               case 'R':
               {
                   if (strcmp(fonction, "RIPEMD160") == 0)
                   {
                       EVP_sum = EVP_ripemd160;
                       longueur_bloc = RIPEMD160_CBLOCK;
                   }
                   else
                   {
                       somme_invalide = d_vrai;
                   }
   
                   break;
               }
   #           endif
   
               case 'S':
               {
                   switch(fonction[1])
                   {
                       case 'H': // sh
                       {
                           switch(fonction[2])
                           {
   #                           ifndef OPENSSL_NO_SHA
                               case 'A':
                               {
                                   switch(fonction[3])
                                   {
                                       case d_code_fin_chaine:
                                       {
                                           EVP_sum = EVP_sha;
                                           longueur_bloc = SHA_CBLOCK;
                                           break;
                                       }
   
                                       case '1': // sha1
                                       {
                                           if (fonction[4] == d_code_fin_chaine)
                                           {
                                               EVP_sum = EVP_sha1;
                                               longueur_bloc = SHA_CBLOCK;
                                           }
                                           else
                                           {
                                               somme_invalide = d_vrai;
                                           }
   
                                           break;
                                       }
   
   #                                   ifndef OPENSSL_NO_SHA256
                                       case '2': // sha2
                                       {
                                           switch(fonction[4])
                                           {
                                               case '2': // sha22
                                               {
                                                   switch(fonction[5])
                                                   {
                                                       case '4': // sha224
                                                       {
                                                           if (fonction[6] ==
                                                               d_code_fin_chaine)
                                                           {
                                                               EVP_sum =
                                                                   EVP_sha224;
                                                               longueur_bloc =
                                                                   SHA256_CBLOCK;
                                                           }
                                                           else
                                                           {
                                                               somme_invalide =
                                                                       d_vrai;
                                                           }
   
                                                           break;
                                                       }
   
                                                       default:
                                                       {
                                                           somme_invalide = d_vrai;
                                                           break;
                                                       }
                                                   }
   
                                                   break;
                                               }
   
                                               case '5':
                                               {
                                                   switch(fonction[5])
                                                   {
                                                       case '6': // sha256
                                                       {
                                                           if (fonction[6] ==
                                                               d_code_fin_chaine)
                                                           {
                                                               EVP_sum =
                                                                   EVP_sha256;
                                                               longueur_bloc =
                                                                   SHA256_CBLOCK;
                                                           }
                                                           else
                                                           {
                                                               somme_invalide =
                                                                       d_vrai;
                                                           }
   
                                                           break;
                                                       }
   
                                                       default:
                                                       {
                                                           somme_invalide = d_vrai;
                                                           break;
                                                       }
                                                   }
   
                                                   break;
                                               }
   
                                               default:
                                               {
                                                   somme_invalide = d_vrai;
                                                   break;
                                               }
                                           }
   
                                           break;
                                       }
   #                                   endif
   
   #                                   ifndef OPENSSL_NO_SHA512
                                       case '3': // sha3
                                       {
                                           switch(fonction[4])
                                           {
                                               case '8': // sha38
                                               {
                                                   switch(fonction[5])
                                                   {
                                                       case '4': // sha384
                                                       {
                                                           if (fonction[6] ==
                                                               d_code_fin_chaine)
                                                           {
                                                               EVP_sum =
                                                                   EVP_sha384;
                                                               longueur_bloc =
                                                                   SHA512_CBLOCK;
                                                           }
                                                           else
                                                           {
                                                               somme_invalide =
                                                                       d_vrai;
                                                           }
   
                                                           break;
                                                       }
   
                                                       default:
                                                       {
                                                           somme_invalide = d_vrai;
                                                           break;
                                                       }
                                                   }
   
                                                   break;
                                               }
   
                                               default:
                                               {
                                                   somme_invalide = d_vrai;
                                                   break;
                                               }
                                           }
   
                                           break;
                                       }
   
                                       case '5': // sha5
                                       {
                                           switch(fonction[4])
                                           {
                                               case '1': // sha51
                                               {
                                                   switch(fonction[5])
                                                   {
                                                       case '2': // sha512
                                                       {
                                                           if (fonction[6] ==
                                                               d_code_fin_chaine)
                                                           {
                                                               EVP_sum =
                                                                   EVP_sha512;
                                                               longueur_bloc =
                                                                   SHA512_CBLOCK;
                                                           }
                                                           else
                                                           {
                                                               somme_invalide =
                                                                       d_vrai;
                                                           }
   
                                                           break;
                                                       }
   
                                                       default:
                                                       {
                                                           somme_invalide = d_vrai;
                                                           break;
                                                       }
                                                   }
   
                                                   break;
                                               }
   
                                               default:
                                               {
                                                   somme_invalide = d_vrai;
                                                   break;
                                               }
                                           }
   
                                           break;
                                       }
   #                                   endif
   
                                       default:
                                       {
                                           somme_invalide = d_vrai;
                                           break;
                                       }
                                   }
   
                                   break;
                               }
   #                           endif
   
                               default:
                               {
                                   somme_invalide = d_vrai;
                                   break;
                               }
                           }
   
                           break;
                       }
   
                       default:
                       {
                           somme_invalide = d_vrai;
                           break;
                       }
                   }
   
                   break;
               }
   
   #           ifndef OPENSSL_NO_WHIRLPOOL
               case 'W':
               {
                   if (strcmp(fonction, "WHIRLPOOL") == 0)
                   {
                       EVP_sum = EVP_whirlpool;
                       longueur_bloc = WHIRLPOOL_BBLOCK / 8;
                   }
                   else
                   {
                       somme_invalide = d_vrai;
                   }
   
                   break;
               }
   #           endif
   
               default:
               {
                   somme_invalide = d_vrai;
                   break;
               }
           }
   
           free(fonction);
   
           if (somme_invalide == d_vrai)
           {
               // Le chiffrement est de type CBC-MAC
               BUG(1, uprintf("Oops!"));
               exit(0);
           }
           else
           {
               // Le chiffrement est de type HMAC
               // Le second élément de la chaîne contient la clef utilisée pour
               // la signature.
   
               l_element_courant = (*s_objet_argument_1).objet;
               l_element_courant = (*l_element_courant).suivant;
   
               if ((clef = formateur_flux(s_etat_processus, (unsigned char *)
                       (*(*l_element_courant).donnee).objet, &longueur_clef))
                       == NULL)
               {
                   liberation(s_etat_processus, s_objet_argument_1);
                   liberation(s_etat_processus, s_objet_argument_2);
                   return;
               }
   
               if (longueur_clef < longueur_bloc)
               {
                   longueur_tampon = longueur_clef;
                   tampon = clef;
   
                   if ((clef = malloc(longueur_bloc * sizeof(unsigned char)))
                           == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   memset(clef, 0, longueur_bloc);
                   memcpy(clef, tampon, longueur_tampon);
                   longueur_clef = longueur_bloc;
                   free(tampon);
               }
               else if (longueur_clef > longueur_bloc)
               {
                   longueur_tampon = longueur_clef;
                   tampon = clef;
   
                   if ((clef = malloc(longueur_bloc * sizeof(unsigned char)))
                           == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   memcpy(clef, tampon, longueur_bloc);
                   longueur_clef = longueur_bloc;
                   free(tampon);
               }
   
               for(i = 0; i < longueur_bloc; i++)
               {
                   clef[i] ^= 0x36;
               }
   
               if ((chaine = formateur_flux(s_etat_processus, (unsigned char *)
                       (*s_objet_argument_2).objet, &longueur_chaine)) == NULL)
               {
                   EVP_MD_CTX_cleanup(&contexte);
   
                   liberation(s_etat_processus, s_objet_argument_1);
                   liberation(s_etat_processus, s_objet_argument_2);
   
                   return;
               }
   
               if ((tampon = malloc((longueur_bloc + longueur_chaine) *
                       sizeof(unsigned char))) == NULL)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
               memcpy(tampon, clef, longueur_bloc);
               memcpy(tampon + longueur_bloc, chaine, longueur_chaine);
               longueur_tampon = longueur_bloc + longueur_chaine;
   
               if (EVP_DigestInit(&contexte, EVP_sum()) != 1)
               {
                   free(tampon);
                   free(clef);
                   free(chaine);
   
                   EVP_MD_CTX_cleanup(&contexte);
   
                   liberation(s_etat_processus, s_objet_argument_1);
                   liberation(s_etat_processus, s_objet_argument_2);
   
                   (*s_etat_processus).erreur_execution = d_ex_chiffrement;
                   return;
               }
   
               if (EVP_DigestUpdate(&contexte, tampon, longueur_tampon) != 1)
               {
                   free(tampon);
                   free(clef);
                   free(chaine);
   
                   EVP_MD_CTX_cleanup(&contexte);
   
                   liberation(s_etat_processus, s_objet_argument_1);
                   liberation(s_etat_processus, s_objet_argument_2);
   
                   (*s_etat_processus).erreur_execution = d_ex_chiffrement;
                   return;
               }
   
               free(tampon);
   
               if (EVP_DigestFinal_ex(&contexte, somme, &longueur_somme) != 1)
               {
                   free(chaine);
                   EVP_MD_CTX_cleanup(&contexte);
   
                   liberation(s_etat_processus, s_objet_argument_1);
                   liberation(s_etat_processus, s_objet_argument_2);
   
                   (*s_etat_processus).erreur_execution = d_ex_chiffrement;
                   return;
               }
   
               EVP_MD_CTX_cleanup(&contexte);
   
               for(i = 0; i < longueur_bloc; i++)
               {
                   clef[i] ^= (0x36 ^ 0x5c);
               }
   
               if ((tampon = malloc((longueur_bloc + longueur_somme) *
                       sizeof(unsigned char))) == NULL)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
               memcpy(tampon, clef, longueur_bloc);
               memcpy(tampon + longueur_bloc, somme, longueur_somme);
               longueur_tampon = longueur_bloc + longueur_somme;
   
               if (EVP_DigestInit(&contexte, EVP_sum()) != 1)
               {
                   free(tampon);
                   free(clef);
                   free(chaine);
   
                   EVP_MD_CTX_cleanup(&contexte);
   
                   liberation(s_etat_processus, s_objet_argument_1);
                   liberation(s_etat_processus, s_objet_argument_2);
   
                   (*s_etat_processus).erreur_execution = d_ex_chiffrement;
                   return;
               }
   
               if (EVP_DigestUpdate(&contexte, tampon, longueur_tampon) != 1)
               {
                   free(tampon);
                   free(clef);
                   free(chaine);
   
                   EVP_MD_CTX_cleanup(&contexte);
   
                   liberation(s_etat_processus, s_objet_argument_1);
                   liberation(s_etat_processus, s_objet_argument_2);
   
                   (*s_etat_processus).erreur_execution = d_ex_chiffrement;
                   return;
               }
   
               free(tampon);
   
               if (EVP_DigestFinal_ex(&contexte, somme, &longueur_somme) != 1)
               {
                   free(chaine);
                   EVP_MD_CTX_cleanup(&contexte);
   
                   liberation(s_etat_processus, s_objet_argument_1);
                   liberation(s_etat_processus, s_objet_argument_2);
   
                   (*s_etat_processus).erreur_execution = d_ex_chiffrement;
                   return;
               }
   
               EVP_MD_CTX_cleanup(&contexte);
   
               free(chaine);
               free(clef);
   
               if ((s_objet_resultat = allocation(s_etat_processus, CHN)) == NULL)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
               if (((*s_objet_resultat).objet = analyse_flux(s_etat_processus,
                       somme, longueur_somme)) == NULL)
               {
                   liberation(s_etat_processus, s_objet_argument_1);
                   liberation(s_etat_processus, s_objet_argument_2);
   
                   return;
               }
           }
     }      }
     else      else
     {      {
Removed from v.1.40  
changed lines
  Added in v.1.41

CVSweb interface <joel.bertrand@systella.fr>