[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.24 and 1.76

version 1.24, 2011/06/27 09:04:57 version 1.76, 2022/09/07 13:40:34
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.0    RPL/2 (R) version 4.1.34
   Copyright (C) 1989-2011 Dr. BERTRAND Joël    Copyright (C) 1989-2021 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 339  instruction_diag_fleche(struct_processus Line 339  instruction_diag_fleche(struct_processus
     struct_objet                *s_objet_argument;      struct_objet                *s_objet_argument;
     struct_objet                *s_objet_resultat;      struct_objet                *s_objet_resultat;
   
     unsigned long               i;      integer8                    i;
     unsigned long               j;      integer8                    j;
   
     (*s_etat_processus).erreur_execution = d_ex;      (*s_etat_processus).erreur_execution = d_ex;
   
Line 409  instruction_diag_fleche(struct_processus Line 409  instruction_diag_fleche(struct_processus
                 (*((struct_matrice *) (*s_objet_argument).objet)).nombre_lignes;                  (*((struct_matrice *) (*s_objet_argument).objet)).nombre_lignes;
   
         if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau          if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau
                 = malloc((*((struct_vecteur *) (*s_objet_resultat).objet))                  = malloc(((size_t) (*((struct_vecteur *) (*s_objet_resultat)
                 .taille * sizeof(integer8))) == NULL)                  .objet)).taille) * sizeof(integer8))) == NULL)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             return;              return;
Line 467  instruction_diag_fleche(struct_processus Line 467  instruction_diag_fleche(struct_processus
                 (*((struct_matrice *) (*s_objet_argument).objet)).nombre_lignes;                  (*((struct_matrice *) (*s_objet_argument).objet)).nombre_lignes;
   
         if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau          if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau
                 = malloc((*((struct_vecteur *) (*s_objet_resultat).objet))                  = malloc(((size_t) (*((struct_vecteur *) (*s_objet_resultat)
                 .taille * sizeof(real8))) == NULL)                  .objet)).taille) * sizeof(real8))) == NULL)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             return;              return;
Line 525  instruction_diag_fleche(struct_processus Line 525  instruction_diag_fleche(struct_processus
                 (*((struct_matrice *) (*s_objet_argument).objet)).nombre_lignes;                  (*((struct_matrice *) (*s_objet_argument).objet)).nombre_lignes;
   
         if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau          if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau
                 = malloc((*((struct_vecteur *) (*s_objet_resultat).objet))                  = malloc(((size_t) (*((struct_vecteur *) (*s_objet_resultat)
                 .taille * sizeof(complex16))) == NULL)                  .objet)).taille) * sizeof(complex16))) == NULL)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             return;              return;
Line 582  instruction_diag_fleche(struct_processus Line 582  instruction_diag_fleche(struct_processus
   
     if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),      if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
             s_objet_resultat) == d_erreur)              s_objet_resultat) == d_erreur)
       {
           return;
       }
   
       return;
   }
   
   
   /*
   ================================================================================
     Fonction 'digest'
   ================================================================================
     Entrées : pointeur sur une structure struct_processus
   --------------------------------------------------------------------------------
     Sorties :
   --------------------------------------------------------------------------------
     Effets de bord : néant
   ================================================================================
   */
   
   void
   instruction_digest(struct_processus *s_etat_processus)
   {
       EVP_MD_CTX                  *contexte;
   
       const EVP_MD                *EVP_sum;
       const EVP_CIPHER            *EVP_chiffrement;
   
       int                         i;
       int                         longueur_bloc;
       int                         longueur_somme;
   
       integer8                    longueur_chaine;
       integer8                    longueur_clef;
       integer8                    longueur_clef_attendue;
       integer8                    longueur_clef_max;
       integer8                    longueur_clef_min;
       integer8                    longueur_tampon;
   
       logical1                    somme_invalide;
   
       struct_liste_chainee        *l_element_courant;
   
       struct_objet                *s_objet_argument_1;
       struct_objet                *s_objet_argument_2;
       struct_objet                *s_objet_resultat;
   
       unsigned char               *chaine;
       unsigned char               *clef;
       unsigned char               *fonction;
       unsigned char               somme[EVP_MAX_MD_SIZE];
       unsigned char               *tampon;
       unsigned char               *vecteur_initialisation;
   
       (*s_etat_processus).erreur_execution = d_ex;
   
       if ((*s_etat_processus).affichage_arguments == 'Y')
       {
           printf("\n  DIGEST ");
   
           if ((*s_etat_processus).langue == 'F')
           {
               printf("(somme d'authentification)\n\n");
           }
           else
           {
               printf("(hash algorithm)\n\n");
           }
   
           printf("    2: %s\n", d_CHN);
           printf("    1: %s\n", d_CHN);
           printf("->  1: %s\n\n", d_CHN);
   
           printf("    2: %s\n", d_CHN);
           printf("    1: %s\n", d_LST);
           printf("->  1: %s\n\n", d_CHN);
   
           if ((*s_etat_processus).langue == 'F')
           {
               printf("  Algorithmes :\n\n");
           }
           else
           {
               printf("  Algorithms:\n\n");
           }
   
   #       ifndef OPENSSL_NO_AES
           printf("    - AES-128-CBC\n");
           printf("    - AES-192-CBC\n");
           printf("    - AES-256-CBC\n");
   #       endif
   #       ifndef OPENSSL_NO_CAMELLIA
           printf("    - CAMELLIA-128-CBC\n");
           printf("    - CAMELLIA-192-CBC\n");
           printf("    - CAMELLIA-256-CBC\n");
   #       endif
   #       ifndef OPENSSL_NO_DES
           printf("    - DES-CBC\n");
           printf("    - DES-EDE-CBC\n");
           printf("    - DES-EDE3-CB\n");
           printf("    - DESX-CBC\n");
   #       endif
   #       ifndef OPENSSL_NO_IDEA
           printf("    - IDEA-CBC\n");
   #       endif
   #       ifndef OPENSSL_NO_MD2
           printf("    - MD2\n");
   #       endif
   #       ifndef OPENSSL_NO_MD4
           printf("    - MD4\n");
   #       endif
   #       ifndef OPENSSL_NO_MD5
           printf("    - MD5\n");
   #       endif
   #       ifndef OPENSSL_NO_MDC2
           printf("    - MDC2\n");
   #       endif
   #       ifndef OPENSSL_NO_RC2
           printf("    - RC2-CBC\n");
           printf("    - RC2-40-CBC\n");
           printf("    - RC2-64-CBC\n");
   #       endif
   #       ifndef OPENSSL_NO_RIPEMD
           printf("    - RIPEMD160\n");
   #       endif
           printf("    - SHA1\n");
           printf("    - SHA224\n");
           printf("    - SHA256\n");
           printf("    - SHA384\n");
           printf("    - SHA512\n");
   #       ifndef OPENSSL_NO_WHIRLPOOL
           printf("    - WHIRLPOOL\n");
   #       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-128-CBC\" \"key\" } DIGEST\n");
           return;
       }
       else if ((*s_etat_processus).test_instruction == 'Y')
       {
           (*s_etat_processus).nombre_arguments = -1;
           return;
       }
   
       if (test_cfsf(s_etat_processus, 31) == d_vrai)
       {
           if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
           {
               return;
           }
       }
   
       if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
               &s_objet_argument_1) == d_erreur)
       {
           (*s_etat_processus).erreur_execution = d_ex_manque_argument;
           return;
       }
   
       if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
               &s_objet_argument_2) == d_erreur)
       {
           liberation(s_etat_processus, s_objet_argument_1);
   
           (*s_etat_processus).erreur_execution = d_ex_manque_argument;
           return;
       }
   
       if (((*s_objet_argument_1).type == CHN) &&
               ((*s_objet_argument_2).type == CHN))
       {
           // Liste des sommes disponibles :
           // - EVP_md2
           // - EVP_md4
           // - EVP_md5
           // - EVP_mdc2
           // - EVP_ripemd160
           // - EVP_sha1
           // - EVP_sha224
           // - EVP_sha256
           // - EVP_sha384
           // - EVP_sha512
           // - EVP_whirlpool
   
           if ((fonction = conversion_majuscule(s_etat_processus,
                   (unsigned char *) (*s_objet_argument_1).objet)) == NULL)
           {
               (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
               return;
           }
   
           somme_invalide = d_faux;
   
           switch(fonction[0])
           {
               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();
                                   }
                                   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();
                                   }
                                   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();
                                   }
                                   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();
                                           }
                                           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();
                   }
                   else
                   {
                       somme_invalide = d_vrai;
                   }
   
                   break;
               }
   #           endif
   
               case 'S':
               {
                   switch(fonction[1])
                   {
                       case 'H': // sh
                       {
                           switch(fonction[2])
                           {
                               case 'A':
                               {
                                   switch(fonction[3])
                                   {
                                       case '1': // sha1
                                       {
                                           if (fonction[4] == d_code_fin_chaine)
                                           {
                                               EVP_sum = EVP_sha1();
                                           }
                                           else
                                           {
                                               somme_invalide = d_vrai;
                                           }
   
                                           break;
                                       }
   
                                       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();
                                                           }
                                                           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();
                                                           }
                                                           else
                                                           {
                                                               somme_invalide =
                                                                   d_vrai;
                                                           }
   
                                                           break;
                                                       }
   
                                                       default:
                                                       {
                                                           somme_invalide = d_vrai;
                                                           break;
                                                       }
                                                   }
   
                                                   break;
                                               }
   
                                               default:
                                               {
                                                   somme_invalide = d_vrai;
                                                   break;
                                               }
                                           }
   
                                           break;
                                       }
   
                                       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();
                                                           }
                                                           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();
                                                           }
                                                           else
                                                           {
                                                               somme_invalide =
                                                                   d_vrai;
                                                           }
   
                                                           break;
                                                       }
   
                                                       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;
                       }
   
                       default:
                       {
                           somme_invalide = d_vrai;
                           break;
                       }
                   }
   
                   break;
               }
   
   #           ifndef OPENSSL_NO_WHIRLPOOL
               case 'W':
               {
                   if (strcmp(fonction, "WHIRLPOOL") == 0)
                   {
                       EVP_sum = EVP_whirlpool();
                   }
                   else
                   {
                       somme_invalide = d_vrai;
                   }
   
                   break;
               }
   #           endif
   
               default:
               {
                   somme_invalide = d_vrai;
                   break;
               }
           }
   
           free(fonction);
   
           if (somme_invalide == d_vrai)
           {
               liberation(s_etat_processus, s_objet_argument_1);
               liberation(s_etat_processus, s_objet_argument_2);
   
               (*s_etat_processus).erreur_execution =
                       d_ex_chiffrement_indisponible;
               return;
           }
   
           if ((contexte = EVP_MD_CTX_new()) == NULL)
           {
               liberation(s_etat_processus, s_objet_argument_1);
               liberation(s_etat_processus, s_objet_argument_2);
   
               (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
               return;
           }
   
           if (EVP_DigestInit(contexte, EVP_sum) != 1)
           {
               EVP_MD_CTX_free(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 ((chaine = formateur_flux(s_etat_processus, (unsigned char *)
                   (*s_objet_argument_2).objet, &longueur_chaine)) == NULL)
           {
               EVP_MD_CTX_free(contexte);
   
               liberation(s_etat_processus, s_objet_argument_1);
               liberation(s_etat_processus, s_objet_argument_2);
   
               return;
           }
   
           if (EVP_DigestUpdate(contexte, chaine, (size_t) longueur_chaine) != 1)
           {
               free(chaine);
               EVP_MD_CTX_free(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_DigestFinal_ex(contexte, somme, &longueur_somme) != 1)
           {
               free(chaine);
               EVP_MD_CTX_free(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(chaine);
           EVP_MD_CTX_free(contexte);
   
           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 if (((*s_objet_argument_1).type == LST) &&
               ((*s_objet_argument_2).type == CHN))
       {
           l_element_courant = (*s_objet_argument_1).objet;
   
           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(s_etat_processus,
                   (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 '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();
                                   }
                                   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();
                                   }
                                   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();
                                   }
                                   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();
                                           }
                                           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();
                   }
                   else
                   {
                       somme_invalide = d_vrai;
                   }
   
                   break;
               }
   #           endif
   
               case 'S':
               {
                   switch(fonction[1])
                   {
                       case 'H': // sh
                       {
                           switch(fonction[2])
                           {
                               case 'A':
                               {
                                   switch(fonction[3])
                                   {
                                       case '1': // sha1
                                       {
                                           if (fonction[4] == d_code_fin_chaine)
                                           {
                                               EVP_sum = EVP_sha1();
                                           }
                                           else
                                           {
                                               somme_invalide = d_vrai;
                                           }
   
                                           break;
                                       }
   
                                       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();
                                                           }
                                                           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();
                                                           }
                                                           else
                                                           {
                                                               somme_invalide =
                                                                       d_vrai;
                                                           }
   
                                                           break;
                                                       }
   
                                                       default:
                                                       {
                                                           somme_invalide = d_vrai;
                                                           break;
                                                       }
                                                   }
   
                                                   break;
                                               }
   
                                               default:
                                               {
                                                   somme_invalide = d_vrai;
                                                   break;
                                               }
                                           }
   
                                           break;
                                       }
   
                                       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();
                                                           }
                                                           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();
                                                           }
                                                           else
                                                           {
                                                               somme_invalide =
                                                                       d_vrai;
                                                           }
   
                                                           break;
                                                       }
   
                                                       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;
                       }
   
                       default:
                       {
                           somme_invalide = d_vrai;
                           break;
                       }
                   }
   
                   break;
               }
   
   #           ifndef OPENSSL_NO_WHIRLPOOL
               case 'W':
               {
                   if (strcmp(fonction, "WHIRLPOOL") == 0)
                   {
                       EVP_sum = EVP_whirlpool();
                   }
                   else
                   {
                       somme_invalide = d_vrai;
                   }
   
                   break;
               }
   #           endif
   
               default:
               {
                   somme_invalide = d_vrai;
                   break;
               }
           }
   
           if (somme_invalide == d_vrai)
           {
               // Le chiffrement est de type CBC-MAC
   
               if (strncmp(fonction, "AES", 3) == 0)
               {
   #               ifdef OPENSSL_NO_AES
   
                   free(fonction);
   
                   liberation(s_etat_processus, s_objet_argument_1);
                   liberation(s_etat_processus, s_objet_argument_2);
   
                   (*s_etat_processus).erreur_execution =
                           d_ex_chiffrement_indisponible;
                   return;
   
   #               else
   
                   if (strcmp(fonction, "AES-128-CBC") == 0)
                   {
                       EVP_chiffrement = EVP_aes_128_cbc();
                   }
                   else if (strcmp(fonction, "AES-192-CBC") == 0)
                   {
                       EVP_chiffrement = EVP_aes_192_cbc();
                   }
                   else if (strcmp(fonction, "AES-256-CBC") == 0)
                   {
                       EVP_chiffrement = EVP_aes_256_cbc();
                   }
                   else
                   {
                       free(fonction);
   
                       liberation(s_etat_processus, s_objet_argument_1);
                       liberation(s_etat_processus, s_objet_argument_2);
   
                       (*s_etat_processus).erreur_execution =
                               d_ex_chiffrement_indisponible;
                       return;
                   }
   
                   longueur_clef_attendue = EVP_CIPHER_key_length(EVP_chiffrement);
                   longueur_somme = EVP_CIPHER_block_size(EVP_chiffrement);
   
   #               endif
               }
               else if (strncmp(fonction, "DES", 3) == 0)
               {
   #               ifdef OPENSSL_NO_DES
   
                   free(fonction);
   
                   liberation(s_etat_processus, s_objet_argument_1);
                   liberation(s_etat_processus, s_objet_argument_2);
   
                   (*s_etat_processus).erreur_execution =
                           d_ex_chiffrement_indisponible;
                   return;
   
   #               else
   
                   if (strcmp(fonction, "DES-CBC") == 0)
                   {
                       EVP_chiffrement = EVP_des_cbc();
                   }
                   else if (strcmp(fonction, "DES-EDE-CBC") == 0)
                   {
                       EVP_chiffrement = EVP_des_ede_cbc();
                   }
                   else if (strcmp(fonction, "DES-EDE3-CBC") == 0)
                   {
                       EVP_chiffrement = EVP_des_ede3_cbc();
                   }
                   else if (strcmp(fonction, "DESX-CBC") == 0)
                   {
                       EVP_chiffrement = EVP_desx_cbc();
                   }
                   else
                   {
                       free(fonction);
   
                       liberation(s_etat_processus, s_objet_argument_1);
                       liberation(s_etat_processus, s_objet_argument_2);
   
                       (*s_etat_processus).erreur_execution =
                               d_ex_chiffrement_indisponible;
                       return;
                   }
   
                   longueur_clef_attendue = EVP_CIPHER_key_length(EVP_chiffrement);
                   longueur_somme = EVP_CIPHER_block_size(EVP_chiffrement);
   
   #               endif
               }
               else if (strncmp(fonction, "CAMELLIA", 8) == 0)
               {
   #               ifdef OPENSSL_NO_CAMELLIA
   
                   free(fonction);
   
                   liberation(s_etat_processus, s_objet_argument_1);
                   liberation(s_etat_processus, s_objet_argument_2);
   
                   (*s_etat_processus).erreur_execution =
                           d_ex_chiffrement_indisponible;
                   return;
   
   #               else
   
                   if (strcmp(fonction, "CAMELLIA-128-CBC") == 0)
                   {
                       EVP_chiffrement = EVP_camellia_128_cbc();
                   }
                   else if (strcmp(fonction, "CAMELLIA-192-CBC") == 0)
                   {
                       EVP_chiffrement = EVP_camellia_192_cbc();
                   }
                   else if (strcmp(fonction, "CAMELLIA-256-CBC") == 0)
                   {
                       EVP_chiffrement = EVP_camellia_256_cbc();
                   }
                   else
                   {
                       free(fonction);
   
                       liberation(s_etat_processus, s_objet_argument_1);
                       liberation(s_etat_processus, s_objet_argument_2);
   
                       (*s_etat_processus).erreur_execution =
                               d_ex_chiffrement_indisponible;
                       return;
                   }
   
                   longueur_clef_attendue = EVP_CIPHER_key_length(EVP_chiffrement);
                   longueur_somme = EVP_CIPHER_block_size(EVP_chiffrement);
   
   #               endif
               }
               else if (strncmp(fonction, "RC2", 3) == 0)
               {
   #               ifdef OPENSSL_NO_RC2
   
                   free(fonction);
   
                   liberation(s_etat_processus, s_objet_argument_1);
                   liberation(s_etat_processus, s_objet_argument_2);
   
                   (*s_etat_processus).erreur_execution =
                           d_ex_chiffrement_indisponible;
                   return;
   
   #               else
   
                   if (strcmp(fonction, "RC2-CBC") == 0)
                   {
                       EVP_chiffrement = EVP_rc2_cbc();
                   }
                   else if (strcmp(fonction, "RC2-40-CBC") == 0)
                   {
                       EVP_chiffrement = EVP_rc2_40_cbc();
                   }
                   else if (strcmp(fonction, "RC2-64-CBC") == 0)
                   {
                       EVP_chiffrement = EVP_rc2_64_cbc();
                   }
                   else
                   {
                       free(fonction);
   
                       liberation(s_etat_processus, s_objet_argument_1);
                       liberation(s_etat_processus, s_objet_argument_2);
   
                       (*s_etat_processus).erreur_execution =
                               d_ex_chiffrement_indisponible;
                       return;
                   }
   
                   longueur_clef_attendue = 0;
                   longueur_clef_min = 1;
                   longueur_clef_max = 16;
                   longueur_somme = EVP_CIPHER_block_size(EVP_chiffrement);
   
   #               endif
               }
               else if (strncmp(fonction, "IDEA", 4) == 0)
               {
   #               ifdef OPENSSL_NO_IDEA
   
                   free(fonction);
   
                   liberation(s_etat_processus, s_objet_argument_1);
                   liberation(s_etat_processus, s_objet_argument_2);
   
                   (*s_etat_processus).erreur_execution =
                           d_ex_chiffrement_indisponible;
                   return;
   
   #               else
   
                   if (strcmp(fonction, "IDEA-CBC") == 0)
                   {
                       EVP_chiffrement = EVP_idea_cbc();
                   }
                   else
                   {
                       free(fonction);
   
                       liberation(s_etat_processus, s_objet_argument_1);
                       liberation(s_etat_processus, s_objet_argument_2);
   
                       (*s_etat_processus).erreur_execution =
                               d_ex_chiffrement_indisponible;
                       return;
                   }
   
                   longueur_clef_attendue = EVP_CIPHER_key_length(EVP_chiffrement);
                   longueur_somme = EVP_CIPHER_block_size(EVP_chiffrement);
   
   #               endif
               }
               else
               {
                   free(fonction);
   
                   liberation(s_etat_processus, s_objet_argument_1);
                   liberation(s_etat_processus, s_objet_argument_2);
   
                   (*s_etat_processus).erreur_execution =
                           d_ex_chiffrement_indisponible;
                   return;
               }
   
               if ((chaine = formateur_flux(s_etat_processus, (unsigned char *)
                       (*s_objet_argument_2).objet, &longueur_chaine)) == NULL)
               {
                   free(fonction);
   
                   liberation(s_etat_processus, s_objet_argument_1);
                   liberation(s_etat_processus, s_objet_argument_2);
   
                   return;
               }
   
               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)
               {
                   free(fonction);
                   free(chaine);
   
                   liberation(s_etat_processus, s_objet_argument_1);
                   liberation(s_etat_processus, s_objet_argument_2);
                   return;
               }
   
               if (longueur_clef_attendue != 0)
               {
                   if (longueur_clef != longueur_clef_attendue)
                   {
                       free(fonction);
                       free(chaine);
                       free(clef);
   
                       liberation(s_etat_processus, s_objet_argument_1);
                       liberation(s_etat_processus, s_objet_argument_2);
   
                       (*s_etat_processus).erreur_execution =
                               d_ex_longueur_clef_chiffrement;
                       return;
                   }
               }
               else
               {
                   if ((longueur_clef < longueur_clef_min) &&
                           (longueur_clef > longueur_clef_max))
                   {
                       free(fonction);
                       free(chaine);
                       free(clef);
   
                       liberation(s_etat_processus, s_objet_argument_1);
                       liberation(s_etat_processus, s_objet_argument_2);
   
                       (*s_etat_processus).erreur_execution =
                               d_ex_longueur_clef_chiffrement;
                       return;
                   }
               }
   
               if ((vecteur_initialisation = malloc(((size_t) longueur_clef) *
                       sizeof(unsigned char))) == NULL)
               {
                   (*s_etat_processus).erreur_systeme =
                           d_es_allocation_memoire;
                   return;
               }
   
               memset(vecteur_initialisation, 0, (size_t) longueur_clef);
   
               if ((tampon = chiffrement(s_etat_processus, EVP_chiffrement, d_vrai,
                       chaine, longueur_chaine, clef, longueur_clef,
                       vecteur_initialisation, &longueur_tampon)) == NULL)
               {
                   free(fonction);
                   free(vecteur_initialisation);
                   free(chaine);
                   free(clef);
   
                   (*s_etat_processus).erreur_execution =
                           d_ex_chiffrement;
                   return;
               }
   
               free(vecteur_initialisation);
               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,
                       &(tampon[longueur_tampon - longueur_somme]),
                       longueur_somme)) == NULL)
               {
                   free(tampon);
                   free(fonction);
   
                   liberation(s_etat_processus, s_objet_argument_1);
                   liberation(s_etat_processus, s_objet_argument_2);
                   return;
               }
   
               free(tampon);
               free(fonction);
           }
           else
           {
               // Le chiffrement est de type HMAC
               // Le second élément de la chaîne contient la clef utilisée pour
               // la signature.
   
               free(fonction);
   
               l_element_courant = (*s_objet_argument_1).objet;
               l_element_courant = (*l_element_courant).suivant;
   
               longueur_bloc = EVP_MD_block_size(EVP_sum);
   
               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(((size_t) longueur_bloc) *
                           sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   memset(clef, 0, (size_t) longueur_bloc);
                   memcpy(clef, tampon, (size_t) longueur_tampon);
                   longueur_clef = longueur_bloc;
                   free(tampon);
               }
               else if (longueur_clef > longueur_bloc)
               {
                   longueur_tampon = longueur_clef;
                   tampon = clef;
   
                   if ((clef = malloc(((size_t) longueur_bloc) *
                           sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   memcpy(clef, tampon, (size_t) longueur_bloc);
                   longueur_clef = longueur_bloc;
                   free(tampon);
               }
   
               for(i = 0; i < longueur_bloc; i++)
               {
                   clef[i] ^= (unsigned char) 0x36;
               }
   
               if ((chaine = formateur_flux(s_etat_processus, (unsigned char *)
                       (*s_objet_argument_2).objet, &longueur_chaine)) == NULL)
               {
                   liberation(s_etat_processus, s_objet_argument_1);
                   liberation(s_etat_processus, s_objet_argument_2);
   
                   return;
               }
   
               if ((tampon = malloc(((size_t) (longueur_bloc + longueur_chaine)) *
                       sizeof(unsigned char))) == NULL)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
               memcpy(tampon, clef, (size_t) longueur_bloc);
               memcpy(tampon + longueur_bloc, chaine, (size_t) longueur_chaine);
               longueur_tampon = longueur_bloc + longueur_chaine;
   
               if ((contexte = EVP_MD_CTX_new()) == NULL)
               {
                   liberation(s_etat_processus, s_objet_argument_1);
                   liberation(s_etat_processus, s_objet_argument_2);
   
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
               if (EVP_DigestInit(contexte, EVP_sum) != 1)
               {
                   free(tampon);
                   free(clef);
                   free(chaine);
   
                   EVP_MD_CTX_free(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, (size_t) longueur_tampon)
                       != 1)
               {
                   free(tampon);
                   free(clef);
                   free(chaine);
   
                   EVP_MD_CTX_free(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_free(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_reset(contexte);
   
               for(i = 0; i < longueur_bloc; i++)
               {
                   clef[i] ^= (0x36 ^ 0x5c);
               }
   
               if ((tampon = malloc(((size_t) (longueur_bloc + longueur_somme)) *
                       sizeof(unsigned char))) == NULL)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
               memcpy(tampon, clef, (size_t) longueur_bloc);
               memcpy(tampon + longueur_bloc, somme, (size_t) longueur_somme);
               longueur_tampon = longueur_bloc + longueur_somme;
   
               if (EVP_DigestInit(contexte, EVP_sum) != 1)
               {
                   free(tampon);
                   free(clef);
                   free(chaine);
   
                   EVP_MD_CTX_free(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, (size_t) longueur_tampon)
                       != 1)
               {
                   free(tampon);
                   free(clef);
                   free(chaine);
   
                   EVP_MD_CTX_free(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_free(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_free(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
       {
           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;
       }
   
       liberation(s_etat_processus, s_objet_argument_1);
       liberation(s_etat_processus, s_objet_argument_2);
   
       if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
               s_objet_resultat) == d_erreur)
     {      {
         return;          return;
     }      }
Removed from v.1.24  
changed lines
  Added in v.1.76

CVSweb interface <joel.bertrand@systella.fr>