--- rpl/src/instructions_d6.c	2013/02/25 19:14:01	1.42
+++ rpl/src/instructions_d6.c	2013/02/26 10:25:21	1.43
@@ -634,6 +634,8 @@ instruction_digest(struct_processus *s_e
 
 	unsigned long				longueur_clef;
 	unsigned long				longueur_clef_attendue;
+	unsigned long				longueur_clef_max;
+	unsigned long				longueur_clef_min;
 
 	(*s_etat_processus).erreur_execution = d_ex;
 
@@ -672,11 +674,25 @@ instruction_digest(struct_processus *s_e
 		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_SHA
 		printf("    - DSS\n");
 		printf("    - DSS1\n");
 		printf("    - ECDSA\n");
 #		endif
+#		ifndef OPENSSL_NO_IDEA
+		printf("    - IDEA-CBC\n");
+#		endif
 #		ifndef OPENSSL_NO_MD2
 		printf("    - MD2\n");
 #		endif
@@ -689,6 +705,11 @@ instruction_digest(struct_processus *s_e
 #		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
@@ -1976,33 +1997,10 @@ instruction_digest(struct_processus *s_e
 		{
 			// 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);
@@ -2010,6 +2008,8 @@ instruction_digest(struct_processus *s_e
 
 				(*s_etat_processus).erreur_execution =
 						d_ex_chiffrement_indisponible;
+				return;
+
 #				else
 
 				if (strcmp(fonction, "AES-128-CBC") == 0)
@@ -2042,111 +2042,314 @@ instruction_digest(struct_processus *s_e
 					return;
 				}
 
-				if ((chaine = formateur_flux(s_etat_processus, (unsigned char *)
-						(*s_objet_argument_2).objet, &longueur_chaine)) == NULL)
+#				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();
+					longueur_clef_attendue = 7;
+					longueur_somme = 8;
+				}
+				else if (strcmp(fonction, "DES-EDE-CBC") == 0)
+				{
+					EVP_chiffrement = EVP_des_ede_cbc();
+					longueur_clef_attendue = 7;
+					longueur_somme = 8;
+				}
+				else if (strcmp(fonction, "DES-EDE3-CBC") == 0)
+				{
+					EVP_chiffrement = EVP_des_ede3_cbc();
+					longueur_clef_attendue = 7;
+					longueur_somme = 8;
+				}
+				else if (strcmp(fonction, "DESX-CBC") == 0)
+				{
+					EVP_chiffrement = EVP_desx_cbc();
+					longueur_clef_attendue = 7;
+					longueur_somme = 8;
+				}
+				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;
 				}
+#				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);
 
-				l_element_courant = (*s_objet_argument_1).objet;
-				l_element_courant = (*l_element_courant).suivant;
+				(*s_etat_processus).erreur_execution =
+						d_ex_chiffrement_indisponible;
+				return;
+
+#				else
 
-				if ((clef = formateur_flux(s_etat_processus, (unsigned char *)
-						(*(*l_element_courant).donnee).objet, &longueur_clef))
-						== NULL)
+				if (strcmp(fonction, "CAMELLIA-128-CBC") == 0)
+				{
+					EVP_chiffrement = EVP_camellia_128_cbc();
+					longueur_clef_attendue = 16;
+					longueur_somme = CAMELLIA_BLOCK_SIZE;
+				}
+				else if (strcmp(fonction, "CAMELLIA-192-CBC") == 0)
+				{
+					EVP_chiffrement = EVP_camellia_192_cbc();
+					longueur_clef_attendue = 24;
+					longueur_somme = CAMELLIA_BLOCK_SIZE;
+				}
+				else if (strcmp(fonction, "CAMELLIA-256-CBC") == 0)
+				{
+					EVP_chiffrement = EVP_camellia_256_cbc();
+					longueur_clef_attendue = 32;
+					longueur_somme = CAMELLIA_BLOCK_SIZE;
+				}
+				else
 				{
 					free(fonction);
-					free(chaine);
 
 					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;
 				}
+#				endif
+			}
+			else if (strncmp(fonction, "RC2", 3) == 0)
+			{
+#				ifdef OPENSSL_NO_RC2
 
-				if (longueur_clef != longueur_clef_attendue)
+				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();
+					longueur_clef_attendue = 0;
+					longueur_clef_min = 1;
+					longueur_clef_max = 16;
+					longueur_somme = RC2_BLOCK;
+				}
+				else if (strcmp(fonction, "RC2-40-CBC") == 0)
+				{
+					EVP_chiffrement = EVP_rc2_40_cbc();
+					longueur_clef_attendue = 0;
+					longueur_clef_min = 1;
+					longueur_clef_max = 16;
+					longueur_somme = RC2_BLOCK;
+				}
+				else if (strcmp(fonction, "RC2-64-CBC") == 0)
+				{
+					EVP_chiffrement = EVP_rc2_64_cbc();
+					longueur_clef_attendue = 0;
+					longueur_clef_min = 1;
+					longueur_clef_max = 16;
+					longueur_somme = RC2_BLOCK;
+				}
+				else
 				{
 					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;
+							d_ex_chiffrement_indisponible;
 					return;
 				}
+#				endif
+			}
+			else if (strncmp(fonction, "IDEA", 4) == 0)
+			{
+#				ifdef OPENSSL_NO_IDEA
 
-				if ((vecteur_initialisation = malloc(longueur_clef *
-						sizeof(unsigned char))) == NULL)
-				{
-					(*s_etat_processus).erreur_systeme =
-							d_es_allocation_memoire;
-					return;
-				}
+				free(fonction);
 
-				memset(vecteur_initialisation, 0, longueur_clef);
+				liberation(s_etat_processus, s_objet_argument_1);
+				liberation(s_etat_processus, s_objet_argument_2);
 
-				if ((tampon = chiffrement(EVP_chiffrement, d_vrai,
-						chaine, longueur_chaine, clef, longueur_clef,
-						vecteur_initialisation, longueur_clef,
-						longueur_somme, &longueur_tampon)) == NULL)
+				(*s_etat_processus).erreur_execution =
+						d_ex_chiffrement_indisponible;
+				return;
+
+#				else
+
+				if (strcmp(fonction, "IDEA-CBC") == 0)
+				{
+					EVP_chiffrement = EVP_idea_cbc();
+					longueur_clef_attendue = 16;
+					longueur_somme = IDEA_BLOCK;
+				}
+				else
 				{
 					free(fonction);
-					free(vecteur_initialisation);
-					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_chiffrement;
+							d_ex_chiffrement_indisponible;
 					return;
 				}
+#				endif
+			}
+			else
+			{
+				free(fonction);
 
-				free(vecteur_initialisation);
+				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);
-				free(clef);
 
-				if ((s_objet_resultat = allocation(s_etat_processus, CHN))
-						== NULL)
+				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)
 				{
-					(*s_etat_processus).erreur_systeme =
-							d_es_allocation_memoire;
+					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 (((*s_objet_resultat).objet = analyse_flux(s_etat_processus,
-						&(tampon[longueur_tampon - longueur_somme]),
-						longueur_somme)) == NULL)
+			}
+			else
+			{
+				if ((longueur_clef < longueur_clef_min) &&
+						(longueur_clef > longueur_clef_max))
 				{
-					free(tampon);
 					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;
 				}
+			}
 
-				free(tampon);
+			if ((vecteur_initialisation = malloc(longueur_clef *
+					sizeof(unsigned char))) == NULL)
+			{
+				(*s_etat_processus).erreur_systeme =
+						d_es_allocation_memoire;
+				return;
+			}
 
-#				endif
+			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;
 			}
-			else
+
+			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);
-
-				(*s_etat_processus).erreur_execution =
-						d_ex_chiffrement_indisponible;
 				return;
 			}
 
+			free(tampon);
 			free(fonction);
 		}
 		else