--- rpl/src/instructions_d6.c 2013/02/23 18:31:16 1.39 +++ rpl/src/instructions_d6.c 2013/02/25 19:14:01 1.42 @@ -607,21 +607,33 @@ instruction_digest(struct_processus *s_e { EVP_MD_CTX contexte; - const EVP_MD * (*EVP_sum)(); + const EVP_MD *EVP_sum; + const EVP_CIPHER *EVP_chiffrement; logical1 somme_invalide; + long i; long longueur_chaine; + 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; + unsigned int longueur_bloc; unsigned int longueur_somme; + unsigned int longueur_tampon; + + unsigned long longueur_clef; + unsigned long longueur_clef_attendue; (*s_etat_processus).erreur_execution = d_ex; @@ -655,6 +667,11 @@ instruction_digest(struct_processus *s_e 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_SHA printf(" - DSS\n"); printf(" - DSS1\n"); @@ -669,11 +686,42 @@ instruction_digest(struct_processus *s_e # ifndef OPENSSL_NO_MD5 printf(" - MD5\n"); # endif +# ifndef OPENSSL_NO_MDC2 + printf(" - MDC2\n"); +# endif +# ifndef OPENSSL_NO_RIPEMD + printf(" - RIPEMD160\n"); +# endif # ifndef OPENSSL_NO_SHA printf(" - SHA\n"); printf(" - SHA1\n"); # endif +# ifndef OPENSSL_NO_SHA256 + printf(" - SHA224\n"); + printf(" - SHA256\n"); +# endif +# ifndef OPENSSL_NO_SHA512 + printf(" - SHA384\n"); + printf(" - SHA512\n"); +# endif +# 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') @@ -752,7 +800,7 @@ instruction_digest(struct_processus *s_e { case d_code_fin_chaine: { - EVP_sum = EVP_dss; + EVP_sum = EVP_dss(); break; } @@ -760,7 +808,7 @@ instruction_digest(struct_processus *s_e { if (fonction[4] == d_code_fin_chaine) { - EVP_sum = EVP_dss1; + EVP_sum = EVP_dss1(); } else { @@ -823,7 +871,7 @@ instruction_digest(struct_processus *s_e if (fonction[5] == d_code_fin_chaine) { - EVP_sum = EVP_ecdsa; + EVP_sum = EVP_ecdsa(); } else { @@ -887,7 +935,7 @@ instruction_digest(struct_processus *s_e { if (fonction[3] == d_code_fin_chaine) { - EVP_sum = EVP_md2; + EVP_sum = EVP_md2(); } else { @@ -903,7 +951,7 @@ instruction_digest(struct_processus *s_e { if (fonction[3] == d_code_fin_chaine) { - EVP_sum = EVP_md4; + EVP_sum = EVP_md4(); } else { @@ -914,12 +962,12 @@ instruction_digest(struct_processus *s_e } # endif -# ifndef OPENSSL_NO_MD4 +# ifndef OPENSSL_NO_MD5 case '5': // md5 { if (fonction[3] == d_code_fin_chaine) { - EVP_sum = EVP_md5; + EVP_sum = EVP_md5(); } else { @@ -939,7 +987,7 @@ instruction_digest(struct_processus *s_e { if (fonction[4] == d_code_fin_chaine) { - EVP_sum = EVP_mdc2; + EVP_sum = EVP_mdc2(); } else { @@ -985,7 +1033,7 @@ instruction_digest(struct_processus *s_e { if (strcmp(fonction, "RIPEMD160") == 0) { - EVP_sum = EVP_ripemd160; + EVP_sum = EVP_ripemd160(); } else { @@ -1011,7 +1059,7 @@ instruction_digest(struct_processus *s_e { case d_code_fin_chaine: { - EVP_sum = EVP_sha; + EVP_sum = EVP_sha(); break; } @@ -1019,7 +1067,7 @@ instruction_digest(struct_processus *s_e { if (fonction[4] == d_code_fin_chaine) { - EVP_sum = EVP_sha1; + EVP_sum = EVP_sha1(); } else { @@ -1044,12 +1092,12 @@ instruction_digest(struct_processus *s_e d_code_fin_chaine) { EVP_sum = - EVP_sha224; + EVP_sha224(); } else { somme_invalide = - d_vrai; + d_vrai; } break; @@ -1075,12 +1123,12 @@ instruction_digest(struct_processus *s_e d_code_fin_chaine) { EVP_sum = - EVP_sha256; + EVP_sha256(); } else { somme_invalide = - d_vrai; + d_vrai; } break; @@ -1122,12 +1170,12 @@ instruction_digest(struct_processus *s_e d_code_fin_chaine) { EVP_sum = - EVP_sha384; + EVP_sha384(); } else { somme_invalide = - d_vrai; + d_vrai; } break; @@ -1167,12 +1215,12 @@ instruction_digest(struct_processus *s_e d_code_fin_chaine) { EVP_sum = - EVP_sha512; + EVP_sha512(); } else { somme_invalide = - d_vrai; + d_vrai; } break; @@ -1235,7 +1283,7 @@ instruction_digest(struct_processus *s_e { if (strcmp(fonction, "WHIRLPOOL") == 0) { - EVP_sum = EVP_whirlpool; + EVP_sum = EVP_whirlpool(); } else { @@ -1265,7 +1313,7 @@ instruction_digest(struct_processus *s_e return; } - if (EVP_DigestInit(&contexte, EVP_sum()) != 1) + if (EVP_DigestInit(&contexte, EVP_sum) != 1) { EVP_MD_CTX_cleanup(&contexte); @@ -1329,11 +1377,987 @@ instruction_digest(struct_processus *s_e return; } } - else if (((*s_objet_argument_1).type == CHN) && - ((*s_objet_argument_2).type == LST)) + else if (((*s_objet_argument_1).type == LST) && + ((*s_objet_argument_2).type == CHN)) { - BUG(1, uprintf("Oops\n")); - s_objet_resultat = NULL; + 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((unsigned char *) + (*(*l_element_courant).donnee).objet)) == NULL) + { + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } + + somme_invalide = d_faux; + + switch(fonction[0]) + { + case 'D': + { + switch(fonction[1]) + { + case 'S': // ds + { + switch(fonction[2]) + { +# ifndef OPENSSL_NO_SHA + case 'S': // dss + { + switch(fonction[3]) + { + case d_code_fin_chaine: + { + EVP_sum = EVP_dss(); + longueur_bloc = SHA_CBLOCK; + break; + } + + case '1': // dss1 + { + if (fonction[4] == d_code_fin_chaine) + { + EVP_sum = EVP_dss1(); + longueur_bloc = SHA_CBLOCK; + } + else + { + somme_invalide = d_vrai; + } + + break; + } + + default: + { + somme_invalide = d_vrai; + break; + } + } + + break; + } +# endif + + default: + { + somme_invalide = d_vrai; + break; + } + } + + break; + } + + default: + { + somme_invalide = d_vrai; + break; + } + } + + break; + } + + case 'E': + { + switch(fonction[1]) + { + case 'C': // ec + { + switch(fonction[2]) + { + case 'D': // ecd + { + switch(fonction[3]) + { + case 'S': // ecds + { + switch(fonction[4]) + { +# ifndef OPENSSL_NO_SHA + case 'A': // ecdsa + { + if (fonction[5] == + d_code_fin_chaine) + { + EVP_sum = EVP_ecdsa(); + longueur_bloc = SHA_CBLOCK; + } + else + { + somme_invalide = d_vrai; + } + + break; + } +# endif + + default: + { + somme_invalide = d_vrai; + break; + } + } + + break; + } + + default: + { + somme_invalide = d_vrai; + break; + } + } + + break; + } + + default: + { + somme_invalide = d_vrai; + break; + } + } + + break; + } + + default: + { + somme_invalide = d_vrai; + break; + } + } + + break; + } + + case 'M': + { + switch(fonction[1]) + { + case 'D': // md + { + switch(fonction[2]) + { +# ifndef OPENSSL_NO_MD2 + case '2': // md2 + { + if (fonction[3] == d_code_fin_chaine) + { + EVP_sum = EVP_md2(); + longueur_bloc = MD2_BLOCK; + } + else + { + somme_invalide = d_vrai; + } + + break; + } +# endif + +# ifndef OPENSSL_NO_MD4 + case '4': // md4 + { + if (fonction[3] == d_code_fin_chaine) + { + EVP_sum = EVP_md4(); + longueur_bloc = MD4_CBLOCK; + } + else + { + somme_invalide = d_vrai; + } + + break; + } +# endif + +# ifndef OPENSSL_NO_MD5 + case '5': // md5 + { + if (fonction[3] == d_code_fin_chaine) + { + EVP_sum = EVP_md5(); + longueur_bloc = MD5_CBLOCK; + } + else + { + somme_invalide = d_vrai; + } + + break; + } +# endif + + case 'C': // mdc + { + switch(fonction[3]) + { +# ifndef OPENSSL_NO_MDC2 + case '2': // mdc2 + { + if (fonction[4] == d_code_fin_chaine) + { + EVP_sum = EVP_mdc2(); + longueur_bloc = MDC2_BLOCK; + } + else + { + somme_invalide = d_vrai; + } + + break; + } +# endif + + default: + { + somme_invalide = d_vrai; + break; + } + } + + break; + } + + default: + { + somme_invalide = d_vrai; + break; + } + } + + break; + } + + default: + { + somme_invalide = d_vrai; + break; + } + } + + break; + } + +# ifndef OPENSSL_NO_RIPEMD + case 'R': + { + if (strcmp(fonction, "RIPEMD160") == 0) + { + EVP_sum = EVP_ripemd160(); + longueur_bloc = RIPEMD160_CBLOCK; + } + else + { + somme_invalide = d_vrai; + } + + break; + } +# endif + + case 'S': + { + switch(fonction[1]) + { + case 'H': // sh + { + switch(fonction[2]) + { +# ifndef OPENSSL_NO_SHA + case 'A': + { + switch(fonction[3]) + { + case d_code_fin_chaine: + { + EVP_sum = EVP_sha(); + longueur_bloc = SHA_CBLOCK; + break; + } + + case '1': // sha1 + { + if (fonction[4] == d_code_fin_chaine) + { + EVP_sum = EVP_sha1(); + longueur_bloc = SHA_CBLOCK; + } + else + { + somme_invalide = d_vrai; + } + + break; + } + +# ifndef OPENSSL_NO_SHA256 + case '2': // sha2 + { + switch(fonction[4]) + { + case '2': // sha22 + { + switch(fonction[5]) + { + case '4': // sha224 + { + if (fonction[6] == + d_code_fin_chaine) + { + EVP_sum = + EVP_sha224(); + longueur_bloc = + SHA256_CBLOCK; + } + else + { + somme_invalide = + d_vrai; + } + + break; + } + + default: + { + somme_invalide = d_vrai; + break; + } + } + + break; + } + + case '5': + { + switch(fonction[5]) + { + case '6': // sha256 + { + if (fonction[6] == + d_code_fin_chaine) + { + EVP_sum = + EVP_sha256(); + longueur_bloc = + SHA256_CBLOCK; + } + else + { + somme_invalide = + d_vrai; + } + + break; + } + + default: + { + somme_invalide = d_vrai; + break; + } + } + + break; + } + + default: + { + somme_invalide = d_vrai; + break; + } + } + + break; + } +# endif + +# ifndef OPENSSL_NO_SHA512 + case '3': // sha3 + { + switch(fonction[4]) + { + case '8': // sha38 + { + switch(fonction[5]) + { + case '4': // sha384 + { + if (fonction[6] == + d_code_fin_chaine) + { + EVP_sum = + EVP_sha384(); + longueur_bloc = + SHA512_CBLOCK; + } + else + { + somme_invalide = + d_vrai; + } + + break; + } + + default: + { + somme_invalide = d_vrai; + break; + } + } + + break; + } + + default: + { + somme_invalide = d_vrai; + break; + } + } + + break; + } + + case '5': // sha5 + { + switch(fonction[4]) + { + case '1': // sha51 + { + switch(fonction[5]) + { + case '2': // sha512 + { + if (fonction[6] == + d_code_fin_chaine) + { + EVP_sum = + EVP_sha512(); + longueur_bloc = + SHA512_CBLOCK; + } + else + { + somme_invalide = + d_vrai; + } + + break; + } + + default: + { + somme_invalide = d_vrai; + break; + } + } + + break; + } + + default: + { + somme_invalide = d_vrai; + break; + } + } + + break; + } +# endif + + default: + { + somme_invalide = d_vrai; + break; + } + } + + break; + } +# endif + + default: + { + somme_invalide = d_vrai; + break; + } + } + + break; + } + + default: + { + somme_invalide = d_vrai; + break; + } + } + + break; + } + +# ifndef OPENSSL_NO_WHIRLPOOL + case 'W': + { + if (strcmp(fonction, "WHIRLPOOL") == 0) + { + EVP_sum = EVP_whirlpool(); + longueur_bloc = WHIRLPOOL_BBLOCK / 8; + } + else + { + somme_invalide = d_vrai; + } + + break; + } +# endif + + default: + { + somme_invalide = d_vrai; + break; + } + } + + if (somme_invalide == d_vrai) + { + // Le chiffrement est de type CBC-MAC + + /* + * const EVP_CIPHER *EVP_des_cbc(void); + * const EVP_CIPHER *EVP_des_ede_cbc(void); + * const EVP_CIPHER *EVP_des_ede3_cbc(void); + * const EVP_CIPHER *EVP_desx_cbc(void); + * const EVP_CIPHER *EVP_dev_crypto_des_ede3_cbc(void); + * const EVP_CIPHER *EVP_idea_cbc(void); + * const EVP_CIPHER *EVP_rc2_cbc(void); + * const EVP_CIPHER *EVP_rc2_40_cbc(void); + * const EVP_CIPHER *EVP_rc2_64_cbc(void); + * const EVP_CIPHER *EVP_bf_cbc(void); + * const EVP_CIPHER *EVP_cast5_cbc(void); + * const EVP_CIPHER *EVP_rc5_32_12_16_cbc(void); + * const EVP_CIPHER *EVP_aes_128_cbc(void); + * const EVP_CIPHER *EVP_aes_192_cbc(void); + * const EVP_CIPHER *EVP_aes_256_cbc(void); + * const EVP_CIPHER *EVP_aes_128_cbc_hmac_sha1(void); + * const EVP_CIPHER *EVP_aes_256_cbc_hmac_sha1(void); + * const EVP_CIPHER *EVP_camellia_128_cbc(void); + * const EVP_CIPHER *EVP_camellia_192_cbc(void); + * const EVP_CIPHER *EVP_camellia_256_cbc(void); + * const EVP_CIPHER *EVP_seed_cbc(void); + */ + + 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; +# else + + if (strcmp(fonction, "AES-128-CBC") == 0) + { + EVP_chiffrement = EVP_aes_128_cbc(); + longueur_clef_attendue = 16; + longueur_somme = AES_BLOCK_SIZE; + } + else if (strcmp(fonction, "AES-192-CBC") == 0) + { + EVP_chiffrement = EVP_aes_192_cbc(); + longueur_clef_attendue = 24; + longueur_somme = AES_BLOCK_SIZE; + } + else if (strcmp(fonction, "AES-256-CBC") == 0) + { + EVP_chiffrement = EVP_aes_256_cbc(); + longueur_clef_attendue = 32; + longueur_somme = AES_BLOCK_SIZE; + } + 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 != 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; + } + + if ((vecteur_initialisation = malloc(longueur_clef * + sizeof(unsigned char))) == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + memset(vecteur_initialisation, 0, longueur_clef); + + if ((tampon = chiffrement(EVP_chiffrement, d_vrai, + chaine, longueur_chaine, clef, longueur_clef, + vecteur_initialisation, longueur_clef, + longueur_somme, &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); + +# 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; + } + + 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; + + if ((clef = formateur_flux(s_etat_processus, (unsigned char *) + (*(*l_element_courant).donnee).objet, &longueur_clef)) + == NULL) + { + liberation(s_etat_processus, s_objet_argument_1); + liberation(s_etat_processus, s_objet_argument_2); + return; + } + + if (longueur_clef < longueur_bloc) + { + longueur_tampon = longueur_clef; + tampon = clef; + + if ((clef = malloc(longueur_bloc * sizeof(unsigned char))) + == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + memset(clef, 0, longueur_bloc); + memcpy(clef, tampon, longueur_tampon); + longueur_clef = longueur_bloc; + free(tampon); + } + else if (longueur_clef > longueur_bloc) + { + longueur_tampon = longueur_clef; + tampon = clef; + + if ((clef = malloc(longueur_bloc * sizeof(unsigned char))) + == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + memcpy(clef, tampon, longueur_bloc); + longueur_clef = longueur_bloc; + free(tampon); + } + + for(i = 0; i < longueur_bloc; i++) + { + clef[i] ^= 0x36; + } + + if ((chaine = formateur_flux(s_etat_processus, (unsigned char *) + (*s_objet_argument_2).objet, &longueur_chaine)) == NULL) + { + EVP_MD_CTX_cleanup(&contexte); + + liberation(s_etat_processus, s_objet_argument_1); + liberation(s_etat_processus, s_objet_argument_2); + + return; + } + + if ((tampon = malloc((longueur_bloc + longueur_chaine) * + sizeof(unsigned char))) == NULL) + { + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } + + memcpy(tampon, clef, longueur_bloc); + memcpy(tampon + longueur_bloc, chaine, longueur_chaine); + longueur_tampon = longueur_bloc + longueur_chaine; + + if (EVP_DigestInit(&contexte, EVP_sum) != 1) + { + free(tampon); + free(clef); + free(chaine); + + EVP_MD_CTX_cleanup(&contexte); + + liberation(s_etat_processus, s_objet_argument_1); + liberation(s_etat_processus, s_objet_argument_2); + + (*s_etat_processus).erreur_execution = d_ex_chiffrement; + return; + } + + if (EVP_DigestUpdate(&contexte, tampon, longueur_tampon) != 1) + { + free(tampon); + free(clef); + free(chaine); + + EVP_MD_CTX_cleanup(&contexte); + + liberation(s_etat_processus, s_objet_argument_1); + liberation(s_etat_processus, s_objet_argument_2); + + (*s_etat_processus).erreur_execution = d_ex_chiffrement; + return; + } + + free(tampon); + + if (EVP_DigestFinal_ex(&contexte, somme, &longueur_somme) != 1) + { + free(chaine); + EVP_MD_CTX_cleanup(&contexte); + + liberation(s_etat_processus, s_objet_argument_1); + liberation(s_etat_processus, s_objet_argument_2); + + (*s_etat_processus).erreur_execution = d_ex_chiffrement; + return; + } + + EVP_MD_CTX_cleanup(&contexte); + + for(i = 0; i < longueur_bloc; i++) + { + clef[i] ^= (0x36 ^ 0x5c); + } + + if ((tampon = malloc((longueur_bloc + longueur_somme) * + sizeof(unsigned char))) == NULL) + { + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } + + memcpy(tampon, clef, longueur_bloc); + memcpy(tampon + longueur_bloc, somme, longueur_somme); + longueur_tampon = longueur_bloc + longueur_somme; + + if (EVP_DigestInit(&contexte, EVP_sum) != 1) + { + free(tampon); + free(clef); + free(chaine); + + EVP_MD_CTX_cleanup(&contexte); + + liberation(s_etat_processus, s_objet_argument_1); + liberation(s_etat_processus, s_objet_argument_2); + + (*s_etat_processus).erreur_execution = d_ex_chiffrement; + return; + } + + if (EVP_DigestUpdate(&contexte, tampon, longueur_tampon) != 1) + { + free(tampon); + free(clef); + free(chaine); + + EVP_MD_CTX_cleanup(&contexte); + + liberation(s_etat_processus, s_objet_argument_1); + liberation(s_etat_processus, s_objet_argument_2); + + (*s_etat_processus).erreur_execution = d_ex_chiffrement; + return; + } + + free(tampon); + + if (EVP_DigestFinal_ex(&contexte, somme, &longueur_somme) != 1) + { + free(chaine); + EVP_MD_CTX_cleanup(&contexte); + + liberation(s_etat_processus, s_objet_argument_1); + liberation(s_etat_processus, s_objet_argument_2); + + (*s_etat_processus).erreur_execution = d_ex_chiffrement; + return; + } + + EVP_MD_CTX_cleanup(&contexte); + + free(chaine); + free(clef); + + if ((s_objet_resultat = allocation(s_etat_processus, CHN)) == NULL) + { + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } + + if (((*s_objet_resultat).objet = analyse_flux(s_etat_processus, + somme, longueur_somme)) == NULL) + { + liberation(s_etat_processus, s_objet_argument_1); + liberation(s_etat_processus, s_objet_argument_2); + + return; + } + } } else {