rpl/src/instructions_d6.c - diff

Return to instructions_d6.c CVS log

Up to [local] / rpl / src

Diff for /rpl/src/instructions_d6.c between versions 1.42 and 1.72

version 1.42, 2013/02/25 19:14:01	version 1.72, 2019/02/03 14:40:38
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.1.12	RPL/2 (R) version 4.1.31
Copyright (C) 1989-2012 Dr. BERTRAND Joël	Copyright (C) 1989-2019 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 605 instruction_diag_fleche(struct_processus	Line 605 instruction_diag_fleche(struct_processus
void	void
instruction_digest(struct_processus *s_etat_processus)	instruction_digest(struct_processus *s_etat_processus)
{	{
EVP_MD_CTX contexte;	EVP_MD_CTX *contexte;

const EVP_MD *EVP_sum;	const EVP_MD *EVP_sum;
const EVP_CIPHER *EVP_chiffrement;	const EVP_CIPHER *EVP_chiffrement;

logical1 somme_invalide;	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;

long i;	logical1 somme_invalide;
long longueur_chaine;

struct_liste_chainee *l_element_courant;	struct_liste_chainee *l_element_courant;

Line 628 instruction_digest(struct_processus *s_e	Line 636 instruction_digest(struct_processus *s_e
unsigned char *tampon;	unsigned char *tampon;
unsigned char *vecteur_initialisation;	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;	(*s_etat_processus).erreur_execution = d_ex;

if ((*s_etat_processus).affichage_arguments == 'Y')	if ((*s_etat_processus).affichage_arguments == 'Y')
Line 672 instruction_digest(struct_processus *s_e	Line 673 instruction_digest(struct_processus *s_e
printf(" - AES-192-CBC\n");	printf(" - AES-192-CBC\n");
printf(" - AES-256-CBC\n");	printf(" - AES-256-CBC\n");
# endif	# endif
# ifndef OPENSSL_NO_SHA	# ifndef OPENSSL_NO_CAMELLIA
printf(" - DSS\n");	printf(" - CAMELLIA-128-CBC\n");
printf(" - DSS1\n");	printf(" - CAMELLIA-192-CBC\n");
printf(" - ECDSA\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	# endif
# ifndef OPENSSL_NO_MD2	# ifndef OPENSSL_NO_MD2
printf(" - MD2\n");	printf(" - MD2\n");
Line 689 instruction_digest(struct_processus *s_e	Line 699 instruction_digest(struct_processus *s_e
# ifndef OPENSSL_NO_MDC2	# ifndef OPENSSL_NO_MDC2
printf(" - MDC2\n");	printf(" - MDC2\n");
# endif	# endif
	# ifndef OPENSSL_NO_RC2
	printf(" - RC2-CBC\n");
	printf(" - RC2-40-CBC\n");
	printf(" - RC2-64-CBC\n");
	# endif
# ifndef OPENSSL_NO_RIPEMD	# ifndef OPENSSL_NO_RIPEMD
printf(" - RIPEMD160\n");	printf(" - RIPEMD160\n");
# endif	# endif
# ifndef OPENSSL_NO_SHA
printf(" - SHA\n");
printf(" - SHA1\n");	printf(" - SHA1\n");
# endif
# ifndef OPENSSL_NO_SHA256
printf(" - SHA224\n");	printf(" - SHA224\n");
printf(" - SHA256\n");	printf(" - SHA256\n");
# endif
# ifndef OPENSSL_NO_SHA512
printf(" - SHA384\n");	printf(" - SHA384\n");
printf(" - SHA512\n");	printf(" - SHA512\n");
# endif
# ifndef OPENSSL_NO_WHIRLPOOL	# ifndef OPENSSL_NO_WHIRLPOOL
printf(" - WHIRLPOOL\n");	printf(" - WHIRLPOOL\n");
# endif	# endif
Line 758 instruction_digest(struct_processus *s_e	Line 766 instruction_digest(struct_processus *s_e
((*s_objet_argument_2).type == CHN))	((*s_objet_argument_2).type == CHN))
{	{
// Liste des sommes disponibles :	// Liste des sommes disponibles :
// - EVP_dss
// - EVP_dss1
// - EVP_ecdsa
// - EVP_md2	// - EVP_md2
// - EVP_md4	// - EVP_md4
// - EVP_md5	// - EVP_md5
// - EVP_mdc2	// - EVP_mdc2
// - EVP_ripemd160	// - EVP_ripemd160
// - EVP_sha
// - EVP_sha1	// - EVP_sha1
// - EVP_sha224	// - EVP_sha224
// - EVP_sha256	// - EVP_sha256
Line 774 instruction_digest(struct_processus *s_e	Line 778 instruction_digest(struct_processus *s_e
// - EVP_sha512	// - EVP_sha512
// - EVP_whirlpool	// - EVP_whirlpool

if ((fonction = conversion_majuscule((unsigned char *)	if ((fonction = conversion_majuscule(s_etat_processus,
(*s_objet_argument_1).objet)) == NULL)	(unsigned char ) (s_objet_argument_1).objet)) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 785 instruction_digest(struct_processus *s_e	Line 789 instruction_digest(struct_processus *s_e

switch(fonction[0])	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();
break;
}

case '1': // dss1
{
if (fonction[4] == d_code_fin_chaine)
{
EVP_sum = EVP_dss1();
}
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();
}
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':	case 'M':
{	{
switch(fonction[1])	switch(fonction[1])
Line 1052 instruction_digest(struct_processus *s_e	Line 919 instruction_digest(struct_processus *s_e
{	{
switch(fonction[2])	switch(fonction[2])
{	{
# ifndef OPENSSL_NO_SHA
case 'A':	case 'A':
{	{
switch(fonction[3])	switch(fonction[3])
{	{
case d_code_fin_chaine:
{
EVP_sum = EVP_sha();
break;
}

case '1': // sha1	case '1': // sha1
{	{
if (fonction[4] == d_code_fin_chaine)	if (fonction[4] == d_code_fin_chaine)
Line 1077 instruction_digest(struct_processus *s_e	Line 937 instruction_digest(struct_processus *s_e
break;	break;
}	}

# ifndef OPENSSL_NO_SHA256
case '2': // sha2	case '2': // sha2
{	{
switch(fonction[4])	switch(fonction[4])
Line 1153 instruction_digest(struct_processus *s_e	Line 1012 instruction_digest(struct_processus *s_e

break;	break;
}	}
# endif

# ifndef OPENSSL_NO_SHA512
case '3': // sha3	case '3': // sha3
{	{
switch(fonction[4])	switch(fonction[4])
Line 1245 instruction_digest(struct_processus *s_e	Line 1102 instruction_digest(struct_processus *s_e

break;	break;
}	}
# endif

default:	default:
{	{
Line 1256 instruction_digest(struct_processus *s_e	Line 1112 instruction_digest(struct_processus *s_e

break;	break;
}	}
# endif

default:	default:
{	{
Line 1313 instruction_digest(struct_processus *s_e	Line 1168 instruction_digest(struct_processus *s_e
return;	return;
}	}

if (EVP_DigestInit(&contexte, EVP_sum) != 1)	if ((contexte = EVP_MD_CTX_new()) == NULL)
{	{
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_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_1);
liberation(s_etat_processus, s_objet_argument_2);	liberation(s_etat_processus, s_objet_argument_2);
Line 1327 instruction_digest(struct_processus *s_e	Line 1191 instruction_digest(struct_processus *s_e
if ((chaine = formateur_flux(s_etat_processus, (unsigned char *)	if ((chaine = formateur_flux(s_etat_processus, (unsigned char *)
(*s_objet_argument_2).objet, &longueur_chaine)) == NULL)	(*s_objet_argument_2).objet, &longueur_chaine)) == NULL)
{	{
EVP_MD_CTX_cleanup(&contexte);	EVP_MD_CTX_free(contexte);

liberation(s_etat_processus, s_objet_argument_1);	liberation(s_etat_processus, s_objet_argument_1);
liberation(s_etat_processus, s_objet_argument_2);	liberation(s_etat_processus, s_objet_argument_2);
Line 1335 instruction_digest(struct_processus *s_e	Line 1199 instruction_digest(struct_processus *s_e
return;	return;
}	}

if (EVP_DigestUpdate(&contexte, chaine, longueur_chaine) != 1)	if (EVP_DigestUpdate(contexte, chaine, (size_t) longueur_chaine) != 1)
{	{
free(chaine);	free(chaine);
EVP_MD_CTX_cleanup(&contexte);	EVP_MD_CTX_free(contexte);

liberation(s_etat_processus, s_objet_argument_1);	liberation(s_etat_processus, s_objet_argument_1);
liberation(s_etat_processus, s_objet_argument_2);	liberation(s_etat_processus, s_objet_argument_2);
Line 1347 instruction_digest(struct_processus *s_e	Line 1211 instruction_digest(struct_processus *s_e
return;	return;
}	}

if (EVP_DigestFinal_ex(&contexte, somme, &longueur_somme) != 1)	if (EVP_DigestFinal_ex(contexte, somme, &longueur_somme) != 1)
{	{
free(chaine);	free(chaine);
EVP_MD_CTX_cleanup(&contexte);	EVP_MD_CTX_free(contexte);

liberation(s_etat_processus, s_objet_argument_1);	liberation(s_etat_processus, s_objet_argument_1);
liberation(s_etat_processus, s_objet_argument_2);	liberation(s_etat_processus, s_objet_argument_2);
Line 1360 instruction_digest(struct_processus *s_e	Line 1224 instruction_digest(struct_processus *s_e
}	}

free(chaine);	free(chaine);
EVP_MD_CTX_cleanup(&contexte);	EVP_MD_CTX_free(contexte);

if ((s_objet_resultat = allocation(s_etat_processus, CHN)) == NULL)	if ((s_objet_resultat = allocation(s_etat_processus, CHN)) == NULL)
{	{
Line 1426 instruction_digest(struct_processus *s_e	Line 1290 instruction_digest(struct_processus *s_e

l_element_courant = (*s_objet_argument_1).objet;	l_element_courant = (*s_objet_argument_1).objet;

if ((fonction = conversion_majuscule((unsigned char *)	if ((fonction = conversion_majuscule(s_etat_processus,
((l_element_courant).donnee).objet)) == NULL)	(unsigned char ) ((*l_element_courant).donnee).objet))
	== NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 1437 instruction_digest(struct_processus *s_e	Line 1302 instruction_digest(struct_processus *s_e

switch(fonction[0])	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':	case 'M':
{	{
switch(fonction[1])	switch(fonction[1])
Line 1591 instruction_digest(struct_processus *s_e	Line 1316 instruction_digest(struct_processus *s_e
if (fonction[3] == d_code_fin_chaine)	if (fonction[3] == d_code_fin_chaine)
{	{
EVP_sum = EVP_md2();	EVP_sum = EVP_md2();
longueur_bloc = MD2_BLOCK;
}	}
else	else
{	{
Line 1608 instruction_digest(struct_processus *s_e	Line 1332 instruction_digest(struct_processus *s_e
if (fonction[3] == d_code_fin_chaine)	if (fonction[3] == d_code_fin_chaine)
{	{
EVP_sum = EVP_md4();	EVP_sum = EVP_md4();
longueur_bloc = MD4_CBLOCK;
}	}
else	else
{	{
Line 1625 instruction_digest(struct_processus *s_e	Line 1348 instruction_digest(struct_processus *s_e
if (fonction[3] == d_code_fin_chaine)	if (fonction[3] == d_code_fin_chaine)
{	{
EVP_sum = EVP_md5();	EVP_sum = EVP_md5();
longueur_bloc = MD5_CBLOCK;
}	}
else	else
{	{
Line 1646 instruction_digest(struct_processus *s_e	Line 1368 instruction_digest(struct_processus *s_e
if (fonction[4] == d_code_fin_chaine)	if (fonction[4] == d_code_fin_chaine)
{	{
EVP_sum = EVP_mdc2();	EVP_sum = EVP_mdc2();
longueur_bloc = MDC2_BLOCK;
}	}
else	else
{	{
Line 1693 instruction_digest(struct_processus *s_e	Line 1414 instruction_digest(struct_processus *s_e
if (strcmp(fonction, "RIPEMD160") == 0)	if (strcmp(fonction, "RIPEMD160") == 0)
{	{
EVP_sum = EVP_ripemd160();	EVP_sum = EVP_ripemd160();
longueur_bloc = RIPEMD160_CBLOCK;
}	}
else	else
{	{
Line 1712 instruction_digest(struct_processus *s_e	Line 1432 instruction_digest(struct_processus *s_e
{	{
switch(fonction[2])	switch(fonction[2])
{	{
# ifndef OPENSSL_NO_SHA
case 'A':	case 'A':
{	{
switch(fonction[3])	switch(fonction[3])
{	{
case d_code_fin_chaine:
{
EVP_sum = EVP_sha();
longueur_bloc = SHA_CBLOCK;
break;
}

case '1': // sha1	case '1': // sha1
{	{
if (fonction[4] == d_code_fin_chaine)	if (fonction[4] == d_code_fin_chaine)
{	{
EVP_sum = EVP_sha1();	EVP_sum = EVP_sha1();
longueur_bloc = SHA_CBLOCK;
}	}
else	else
{	{
Line 1739 instruction_digest(struct_processus *s_e	Line 1450 instruction_digest(struct_processus *s_e
break;	break;
}	}

# ifndef OPENSSL_NO_SHA256
case '2': // sha2	case '2': // sha2
{	{
switch(fonction[4])	switch(fonction[4])
Line 1755 instruction_digest(struct_processus *s_e	Line 1465 instruction_digest(struct_processus *s_e
{	{
EVP_sum =	EVP_sum =
EVP_sha224();	EVP_sha224();
longueur_bloc =
SHA256_CBLOCK;
}	}
else	else
{	{
Line 1788 instruction_digest(struct_processus *s_e	Line 1496 instruction_digest(struct_processus *s_e
{	{
EVP_sum =	EVP_sum =
EVP_sha256();	EVP_sha256();
longueur_bloc =
SHA256_CBLOCK;
}	}
else	else
{	{
Line 1819 instruction_digest(struct_processus *s_e	Line 1525 instruction_digest(struct_processus *s_e

break;	break;
}	}
# endif

# ifndef OPENSSL_NO_SHA512
case '3': // sha3	case '3': // sha3
{	{
switch(fonction[4])	switch(fonction[4])
Line 1837 instruction_digest(struct_processus *s_e	Line 1541 instruction_digest(struct_processus *s_e
{	{
EVP_sum =	EVP_sum =
EVP_sha384();	EVP_sha384();
longueur_bloc =
SHA512_CBLOCK;
}	}
else	else
{	{
Line 1884 instruction_digest(struct_processus *s_e	Line 1586 instruction_digest(struct_processus *s_e
{	{
EVP_sum =	EVP_sum =
EVP_sha512();	EVP_sha512();
longueur_bloc =
SHA512_CBLOCK;
}	}
else	else
{	{
Line 1915 instruction_digest(struct_processus *s_e	Line 1615 instruction_digest(struct_processus *s_e

break;	break;
}	}
# endif

default:	default:
{	{
Line 1926 instruction_digest(struct_processus *s_e	Line 1625 instruction_digest(struct_processus *s_e

break;	break;
}	}
# endif

default:	default:
{	{
Line 1954 instruction_digest(struct_processus *s_e	Line 1652 instruction_digest(struct_processus *s_e
if (strcmp(fonction, "WHIRLPOOL") == 0)	if (strcmp(fonction, "WHIRLPOOL") == 0)
{	{
EVP_sum = EVP_whirlpool();	EVP_sum = EVP_whirlpool();
longueur_bloc = WHIRLPOOL_BBLOCK / 8;
}	}
else	else
{	{
Line 1976 instruction_digest(struct_processus *s_e	Line 1673 instruction_digest(struct_processus *s_e
{	{
// Le chiffrement est de type CBC-MAC	// 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)	if (strncmp(fonction, "AES", 3) == 0)
{	{
# ifdef OPENSSL_NO_AES	# ifdef OPENSSL_NO_AES

free(fonction);	free(fonction);

liberation(s_etat_processus, s_objet_argument_1);	liberation(s_etat_processus, s_objet_argument_1);
Line 2010 instruction_digest(struct_processus *s_e	Line 1684 instruction_digest(struct_processus *s_e

(*s_etat_processus).erreur_execution =	(*s_etat_processus).erreur_execution =
d_ex_chiffrement_indisponible;	d_ex_chiffrement_indisponible;
	return;

# else	# else

if (strcmp(fonction, "AES-128-CBC") == 0)	if (strcmp(fonction, "AES-128-CBC") == 0)
{	{
EVP_chiffrement = EVP_aes_128_cbc();	EVP_chiffrement = EVP_aes_128_cbc();
longueur_clef_attendue = 16;
longueur_somme = AES_BLOCK_SIZE;
}	}
else if (strcmp(fonction, "AES-192-CBC") == 0)	else if (strcmp(fonction, "AES-192-CBC") == 0)
{	{
EVP_chiffrement = EVP_aes_192_cbc();	EVP_chiffrement = EVP_aes_192_cbc();
longueur_clef_attendue = 24;
longueur_somme = AES_BLOCK_SIZE;
}	}
else if (strcmp(fonction, "AES-256-CBC") == 0)	else if (strcmp(fonction, "AES-256-CBC") == 0)
{	{
EVP_chiffrement = EVP_aes_256_cbc();	EVP_chiffrement = EVP_aes_256_cbc();
longueur_clef_attendue = 32;
longueur_somme = AES_BLOCK_SIZE;
}	}
else	else
{	{
Line 2042 instruction_digest(struct_processus *s_e	Line 1712 instruction_digest(struct_processus *s_e
return;	return;
}	}

if ((chaine = formateur_flux(s_etat_processus, (unsigned char *)	longueur_clef_attendue = EVP_CIPHER_key_length(EVP_chiffrement);
(*s_objet_argument_2).objet, &longueur_chaine)) == NULL)	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);	free(fonction);

liberation(s_etat_processus, s_objet_argument_1);	liberation(s_etat_processus, s_objet_argument_1);
liberation(s_etat_processus, s_objet_argument_2);	liberation(s_etat_processus, s_objet_argument_2);

	(*s_etat_processus).erreur_execution =
	d_ex_chiffrement_indisponible;
return;	return;
}	}

l_element_courant = (*s_objet_argument_1).objet;	longueur_clef_attendue = EVP_CIPHER_key_length(EVP_chiffrement);
l_element_courant = (*l_element_courant).suivant;	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 ((clef = formateur_flux(s_etat_processus, (unsigned char *)	if (strcmp(fonction, "CAMELLIA-128-CBC") == 0)
((l_element_courant).donnee).objet, &longueur_clef))	{
== NULL)	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);	free(fonction);
free(chaine);

liberation(s_etat_processus, s_objet_argument_1);	liberation(s_etat_processus, s_objet_argument_1);
liberation(s_etat_processus, s_objet_argument_2);	liberation(s_etat_processus, s_objet_argument_2);

	(*s_etat_processus).erreur_execution =
	d_ex_chiffrement_indisponible;
return;	return;
}	}

if (longueur_clef != longueur_clef_attendue)	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);	free(fonction);
free(chaine);
free(clef);

liberation(s_etat_processus, s_objet_argument_1);	liberation(s_etat_processus, s_objet_argument_1);
liberation(s_etat_processus, s_objet_argument_2);	liberation(s_etat_processus, s_objet_argument_2);

(*s_etat_processus).erreur_execution =	(*s_etat_processus).erreur_execution =
d_ex_longueur_clef_chiffrement;	d_ex_chiffrement_indisponible;
return;	return;
}	}

if ((vecteur_initialisation = malloc(longueur_clef *	longueur_clef_attendue = 0;
sizeof(unsigned char))) == NULL)	longueur_clef_min = 1;
{	longueur_clef_max = 16;
(*s_etat_processus).erreur_systeme =	longueur_somme = EVP_CIPHER_block_size(EVP_chiffrement);
d_es_allocation_memoire;
return;
}

memset(vecteur_initialisation, 0, longueur_clef);	# 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);

if ((tampon = chiffrement(EVP_chiffrement, d_vrai,	(*s_etat_processus).erreur_execution =
chaine, longueur_chaine, clef, longueur_clef,	d_ex_chiffrement_indisponible;
vecteur_initialisation, longueur_clef,	return;
longueur_somme, &longueur_tampon)) == NULL)
	# else

	if (strcmp(fonction, "IDEA-CBC") == 0)
	{
	EVP_chiffrement = EVP_idea_cbc();
	}
	else
{	{
free(fonction);	free(fonction);
free(vecteur_initialisation);
free(chaine);	liberation(s_etat_processus, s_objet_argument_1);
free(clef);	liberation(s_etat_processus, s_objet_argument_2);

(*s_etat_processus).erreur_execution =	(*s_etat_processus).erreur_execution =
d_ex_chiffrement;	d_ex_chiffrement_indisponible;
return;	return;
}	}

free(vecteur_initialisation);	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);	free(chaine);
free(clef);

if ((s_objet_resultat = allocation(s_etat_processus, CHN))	liberation(s_etat_processus, s_objet_argument_1);
== NULL)	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 =	free(fonction);
d_es_allocation_memoire;	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;	return;
}	}
	}
if (((*s_objet_resultat).objet = analyse_flux(s_etat_processus,	else
&(tampon[longueur_tampon - longueur_somme]),	{
longueur_somme)) == NULL)	if ((longueur_clef < longueur_clef_min) &&
	(longueur_clef > longueur_clef_max))
{	{
free(tampon);
free(fonction);	free(fonction);
	free(chaine);
	free(clef);

liberation(s_etat_processus, s_objet_argument_1);	liberation(s_etat_processus, s_objet_argument_1);
liberation(s_etat_processus, s_objet_argument_2);	liberation(s_etat_processus, s_objet_argument_2);

	(*s_etat_processus).erreur_execution =
	d_ex_longueur_clef_chiffrement;
return;	return;
}	}
	}

free(tampon);	if ((vecteur_initialisation = malloc(((size_t) longueur_clef) *
	sizeof(unsigned char))) == NULL)
	{
	(*s_etat_processus).erreur_systeme =
	d_es_allocation_memoire;
	return;
	}

# endif	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;
}	}
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);	free(fonction);

liberation(s_etat_processus, s_objet_argument_1);	liberation(s_etat_processus, s_objet_argument_1);
liberation(s_etat_processus, s_objet_argument_2);	liberation(s_etat_processus, s_objet_argument_2);

(*s_etat_processus).erreur_execution =
d_ex_chiffrement_indisponible;
return;	return;
}	}

	free(tampon);
free(fonction);	free(fonction);
}	}
else	else
Line 2160 instruction_digest(struct_processus *s_e	Line 2025 instruction_digest(struct_processus *s_e
l_element_courant = (*s_objet_argument_1).objet;	l_element_courant = (*s_objet_argument_1).objet;
l_element_courant = (*l_element_courant).suivant;	l_element_courant = (*l_element_courant).suivant;

	longueur_bloc = EVP_MD_block_size(EVP_sum);

if ((clef = formateur_flux(s_etat_processus, (unsigned char *)	if ((clef = formateur_flux(s_etat_processus, (unsigned char *)
((l_element_courant).donnee).objet, &longueur_clef))	((l_element_courant).donnee).objet, &longueur_clef))
== NULL)	== NULL)
Line 2174 instruction_digest(struct_processus *s_e	Line 2041 instruction_digest(struct_processus *s_e
longueur_tampon = longueur_clef;	longueur_tampon = longueur_clef;
tampon = clef;	tampon = clef;

if ((clef = malloc(longueur_bloc * sizeof(unsigned char)))	if ((clef = malloc(((size_t) longueur_bloc) *
== NULL)	sizeof(unsigned char))) == NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_allocation_memoire;	d_es_allocation_memoire;
return;	return;
}	}

memset(clef, 0, longueur_bloc);	memset(clef, 0, (size_t) longueur_bloc);
memcpy(clef, tampon, longueur_tampon);	memcpy(clef, tampon, (size_t) longueur_tampon);
longueur_clef = longueur_bloc;	longueur_clef = longueur_bloc;
free(tampon);	free(tampon);
}	}
Line 2192 instruction_digest(struct_processus *s_e	Line 2059 instruction_digest(struct_processus *s_e
longueur_tampon = longueur_clef;	longueur_tampon = longueur_clef;
tampon = clef;	tampon = clef;

if ((clef = malloc(longueur_bloc * sizeof(unsigned char)))	if ((clef = malloc(((size_t) longueur_bloc) *
== NULL)	sizeof(unsigned char))) == NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_allocation_memoire;	d_es_allocation_memoire;
return;	return;
}	}

memcpy(clef, tampon, longueur_bloc);	memcpy(clef, tampon, (size_t) longueur_bloc);
longueur_clef = longueur_bloc;	longueur_clef = longueur_bloc;
free(tampon);	free(tampon);
}	}

for(i = 0; i < longueur_bloc; i++)	for(i = 0; i < longueur_bloc; i++)
{	{
clef[i] ^= 0x36;	clef[i] ^= (unsigned char) 0x36;
}	}

if ((chaine = formateur_flux(s_etat_processus, (unsigned char *)	if ((chaine = formateur_flux(s_etat_processus, (unsigned char *)
(*s_objet_argument_2).objet, &longueur_chaine)) == NULL)	(*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_1);
liberation(s_etat_processus, s_objet_argument_2);	liberation(s_etat_processus, s_objet_argument_2);

return;	return;
}	}

if ((tampon = malloc((longueur_bloc + longueur_chaine) *	if ((tampon = malloc(((size_t) (longueur_bloc + longueur_chaine)) *
sizeof(unsigned char))) == NULL)	sizeof(unsigned char))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
}	}

memcpy(tampon, clef, longueur_bloc);	memcpy(tampon, clef, (size_t) longueur_bloc);
memcpy(tampon + longueur_bloc, chaine, longueur_chaine);	memcpy(tampon + longueur_bloc, chaine, (size_t) longueur_chaine);
longueur_tampon = longueur_bloc + longueur_chaine;	longueur_tampon = longueur_bloc + longueur_chaine;

if (EVP_DigestInit(&contexte, EVP_sum) != 1)	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(tampon);
free(clef);	free(clef);
free(chaine);	free(chaine);

EVP_MD_CTX_cleanup(&contexte);	EVP_MD_CTX_free(contexte);

liberation(s_etat_processus, s_objet_argument_1);	liberation(s_etat_processus, s_objet_argument_1);
liberation(s_etat_processus, s_objet_argument_2);	liberation(s_etat_processus, s_objet_argument_2);
Line 2247 instruction_digest(struct_processus *s_e	Line 2121 instruction_digest(struct_processus *s_e
return;	return;
}	}

if (EVP_DigestUpdate(&contexte, tampon, longueur_tampon) != 1)	if (EVP_DigestUpdate(contexte, tampon, (size_t) longueur_tampon)
	!= 1)
{	{
free(tampon);	free(tampon);
free(clef);	free(clef);
free(chaine);	free(chaine);

EVP_MD_CTX_cleanup(&contexte);	EVP_MD_CTX_free(contexte);

liberation(s_etat_processus, s_objet_argument_1);	liberation(s_etat_processus, s_objet_argument_1);
liberation(s_etat_processus, s_objet_argument_2);	liberation(s_etat_processus, s_objet_argument_2);
Line 2264 instruction_digest(struct_processus *s_e	Line 2139 instruction_digest(struct_processus *s_e

free(tampon);	free(tampon);

if (EVP_DigestFinal_ex(&contexte, somme, &longueur_somme) != 1)	if (EVP_DigestFinal_ex(contexte, somme, &longueur_somme) != 1)
{	{
free(chaine);	free(chaine);
EVP_MD_CTX_cleanup(&contexte);	EVP_MD_CTX_free(contexte);

liberation(s_etat_processus, s_objet_argument_1);	liberation(s_etat_processus, s_objet_argument_1);
liberation(s_etat_processus, s_objet_argument_2);	liberation(s_etat_processus, s_objet_argument_2);
Line 2276 instruction_digest(struct_processus *s_e	Line 2151 instruction_digest(struct_processus *s_e
return;	return;
}	}

EVP_MD_CTX_cleanup(&contexte);	EVP_MD_CTX_reset(contexte);

for(i = 0; i < longueur_bloc; i++)	for(i = 0; i < longueur_bloc; i++)
{	{
clef[i] ^= (0x36 ^ 0x5c);	clef[i] ^= (0x36 ^ 0x5c);
}	}

if ((tampon = malloc((longueur_bloc + longueur_somme) *	if ((tampon = malloc(((size_t) (longueur_bloc + longueur_somme)) *
sizeof(unsigned char))) == NULL)	sizeof(unsigned char))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
}	}

memcpy(tampon, clef, longueur_bloc);	memcpy(tampon, clef, (size_t) longueur_bloc);
memcpy(tampon + longueur_bloc, somme, longueur_somme);	memcpy(tampon + longueur_bloc, somme, (size_t) longueur_somme);
longueur_tampon = longueur_bloc + longueur_somme;	longueur_tampon = longueur_bloc + longueur_somme;

if (EVP_DigestInit(&contexte, EVP_sum) != 1)	if (EVP_DigestInit(contexte, EVP_sum) != 1)
{	{
free(tampon);	free(tampon);
free(clef);	free(clef);
free(chaine);	free(chaine);

EVP_MD_CTX_cleanup(&contexte);	EVP_MD_CTX_free(contexte);

liberation(s_etat_processus, s_objet_argument_1);	liberation(s_etat_processus, s_objet_argument_1);
liberation(s_etat_processus, s_objet_argument_2);	liberation(s_etat_processus, s_objet_argument_2);
Line 2309 instruction_digest(struct_processus *s_e	Line 2184 instruction_digest(struct_processus *s_e
return;	return;
}	}

if (EVP_DigestUpdate(&contexte, tampon, longueur_tampon) != 1)	if (EVP_DigestUpdate(contexte, tampon, (size_t) longueur_tampon)
	!= 1)
{	{
free(tampon);	free(tampon);
free(clef);	free(clef);
free(chaine);	free(chaine);

EVP_MD_CTX_cleanup(&contexte);	EVP_MD_CTX_free(contexte);

liberation(s_etat_processus, s_objet_argument_1);	liberation(s_etat_processus, s_objet_argument_1);
liberation(s_etat_processus, s_objet_argument_2);	liberation(s_etat_processus, s_objet_argument_2);
Line 2326 instruction_digest(struct_processus *s_e	Line 2202 instruction_digest(struct_processus *s_e

free(tampon);	free(tampon);

if (EVP_DigestFinal_ex(&contexte, somme, &longueur_somme) != 1)	if (EVP_DigestFinal_ex(contexte, somme, &longueur_somme) != 1)
{	{
free(chaine);	free(chaine);
EVP_MD_CTX_cleanup(&contexte);	EVP_MD_CTX_free(contexte);

liberation(s_etat_processus, s_objet_argument_1);	liberation(s_etat_processus, s_objet_argument_1);
liberation(s_etat_processus, s_objet_argument_2);	liberation(s_etat_processus, s_objet_argument_2);
Line 2338 instruction_digest(struct_processus *s_e	Line 2214 instruction_digest(struct_processus *s_e
return;	return;
}	}

EVP_MD_CTX_cleanup(&contexte);	EVP_MD_CTX_free(contexte);

free(chaine);	free(chaine);
free(clef);	free(clef);

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.42
changed lines
	Added in v.1.72