--- rpl/src/instructions_d6.c 2011/01/03 12:08:05 1.15 +++ rpl/src/instructions_d6.c 2016/09/27 10:43:23 1.64 @@ -1,7 +1,7 @@ /* ================================================================================ - RPL/2 (R) version 4.0.20 - Copyright (C) 1989-2011 Dr. BERTRAND Joël + RPL/2 (R) version 4.1.25 + Copyright (C) 1989-2016 Dr. BERTRAND Joël This file is part of RPL/2. @@ -339,8 +339,8 @@ instruction_diag_fleche(struct_processus struct_objet *s_objet_argument; struct_objet *s_objet_resultat; - unsigned long i; - unsigned long j; + integer8 i; + integer8 j; (*s_etat_processus).erreur_execution = d_ex; @@ -409,8 +409,8 @@ instruction_diag_fleche(struct_processus (*((struct_matrice *) (*s_objet_argument).objet)).nombre_lignes; if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau - = malloc((*((struct_vecteur *) (*s_objet_resultat).objet)) - .taille * sizeof(integer8))) == NULL) + = malloc(((size_t) (*((struct_vecteur *) (*s_objet_resultat) + .objet)).taille) * sizeof(integer8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; @@ -467,8 +467,8 @@ instruction_diag_fleche(struct_processus (*((struct_matrice *) (*s_objet_argument).objet)).nombre_lignes; if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau - = malloc((*((struct_vecteur *) (*s_objet_resultat).objet)) - .taille * sizeof(real8))) == NULL) + = malloc(((size_t) (*((struct_vecteur *) (*s_objet_resultat) + .objet)).taille) * sizeof(real8))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; @@ -525,8 +525,8 @@ instruction_diag_fleche(struct_processus (*((struct_matrice *) (*s_objet_argument).objet)).nombre_lignes; if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau - = malloc((*((struct_vecteur *) (*s_objet_resultat).objet)) - .taille * sizeof(complex16))) == NULL) + = malloc(((size_t) (*((struct_vecteur *) (*s_objet_resultat) + .objet)).taille) * sizeof(complex16))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; @@ -582,6 +582,1673 @@ instruction_diag_fleche(struct_processus if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), 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; }