rpl/src/instructions_c8.c - diff

Return to instructions_c8.c CVS log

Up to [local] / rpl / src

Diff for /rpl/src/instructions_c8.c between versions 1.8 and 1.41

version 1.8, 2013/04/01 15:29:35	version 1.41, 2025/04/15 10:17:52
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.1.14	RPL/2 (R) version 4.1.36
Copyright (C) 1989-2013 Dr. BERTRAND Joël	Copyright (C) 1989-2025 Dr. BERTRAND Joël

This file is part of RPL/2.	This file is part of RPL/2.

Line 59 instruction_cipher(struct_processus *s_e	Line 59 instruction_cipher(struct_processus *s_e

struct_objet *s_objet_argument_1;	struct_objet *s_objet_argument_1;
struct_objet *s_objet_argument_2;	struct_objet *s_objet_argument_2;
	struct_objet *s_objet_padding;
struct_objet *s_objet_resultat_1;	struct_objet *s_objet_resultat_1;
struct_objet *s_objet_resultat_2;	struct_objet *s_objet_resultat_2;

Line 73 instruction_cipher(struct_processus *s_e	Line 74 instruction_cipher(struct_processus *s_e
unsigned char *iv_binaire;	unsigned char *iv_binaire;
unsigned char *message;	unsigned char *message;
unsigned char *message_chiffre;	unsigned char *message_chiffre;
	unsigned char padding;
unsigned char *tampon;	unsigned char *tampon;

if ((*s_etat_processus).affichage_arguments == 'Y')	if ((*s_etat_processus).affichage_arguments == 'Y')
Line 94 instruction_cipher(struct_processus *s_e	Line 96 instruction_cipher(struct_processus *s_e
printf("-> 1: { \"cipher type\" \"generated key\" \"iv\" }\n\n");	printf("-> 1: { \"cipher type\" \"generated key\" \"iv\" }\n\n");

printf(" 2: \"text\"\n", d_CHN);	printf(" 2: \"text\"\n", d_CHN);
printf(" 1: %s { \"direction\" \"cipher type\" \"key\" \"iv\" }\n",	printf(" 1: { \"direction\" \"cipher type\" \"key\" \"iv\" "
d_LST);	"padding }\n");
printf("-> 2: \"encrypted or decrypted text\"\n", d_CHN);	printf("-> 2: \"encrypted or decrypted text\"\n", d_CHN);
printf(" 1: { \"direction\" \"cipher type\" \"key\" "	printf(" 1: { \"direction\" \"cipher type\" \"key\" "
"\"updated iv\" }\n\n", d_LST);	"\"updated iv\" padding }\n\n", d_LST);

if ((*s_etat_processus).langue == 'F')	if ((*s_etat_processus).langue == 'F')
{	{
Line 243 instruction_cipher(struct_processus *s_e	Line 245 instruction_cipher(struct_processus *s_e
printf(" Digest algorithms:\n\n");	printf(" Digest algorithms:\n\n");
}	}

# ifndef OPENSSL_NO_SHA
printf(" - DSS\n");
printf(" - DSS1\n");
printf(" - ECDSA\n");
# endif
# ifndef OPENSSL_NO_MD2	# ifndef OPENSSL_NO_MD2
printf(" - MD2\n");	printf(" - MD2\n");
# endif	# endif
Line 263 instruction_cipher(struct_processus *s_e	Line 260 instruction_cipher(struct_processus *s_e
# 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 293 instruction_cipher(struct_processus *s_e	Line 283 instruction_cipher(struct_processus *s_e
printf(" \"password\" { \"KEY\" \"DES-EDE-OFB\" \"SHA1\" "	printf(" \"password\" { \"KEY\" \"DES-EDE-OFB\" \"SHA1\" "
"# 0h 3 } CIPHER\n");	"# 0h 3 } CIPHER\n");
printf(" \"text\" { \"ENCRYPT\" \"AES-128-CBC\" \"key\" "	printf(" \"text\" { \"ENCRYPT\" \"AES-128-CBC\" \"key\" "
"\"iv\" } CIPHER\n");	"\"iv\" \"PADDING\" } CIPHER\n");
printf(" \"text\" { \"DECRYPT\" \"AES-128-EBC\" \"key\" "	printf(" \"text\" { \"DECRYPT\" \"AES-128-EBC\" \"key\" "
"\"iv\" } CIPHER\n");	"\"iv\" \"NO PADDING\" } CIPHER\n");
return;	return;
}	}
else if ((*s_etat_processus).test_instruction == 'Y')	else if ((*s_etat_processus).test_instruction == 'Y')
Line 351 instruction_cipher(struct_processus *s_e	Line 341 instruction_cipher(struct_processus *s_e
return;	return;
}	}

if ((instruction = conversion_majuscule((unsigned char *)	if ((instruction = 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 364 instruction_cipher(struct_processus *s_e	Line 355 instruction_cipher(struct_processus *s_e

free(instruction);	free(instruction);

	s_objet_padding = NULL;
l_element_courant = (*l_element_courant).suivant;	l_element_courant = (*l_element_courant).suivant;

if (l_element_courant == NULL)	if (l_element_courant == NULL)
Line 415 instruction_cipher(struct_processus *s_e	Line 407 instruction_cipher(struct_processus *s_e

// Test de la validité de la somme de contrôle.	// Test de la validité de la somme de contrôle.

if ((fonction = conversion_majuscule(controle)) == NULL)	if ((fonction = conversion_majuscule(s_etat_processus, controle))
	== NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 425 instruction_cipher(struct_processus *s_e	Line 418 instruction_cipher(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 694 instruction_cipher(struct_processus *s_e	Line 549 instruction_cipher(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] ==	if (fonction[4] ==
Line 720 instruction_cipher(struct_processus *s_e	Line 568 instruction_cipher(struct_processus *s_e
break;	break;
}	}

# ifndef OPENSSL_NO_SHA256
case '2': // sha2	case '2': // sha2
{	{
switch(fonction[4])	switch(fonction[4])
Line 798 instruction_cipher(struct_processus *s_e	Line 645 instruction_cipher(struct_processus *s_e

break;	break;
}	}
# endif

# ifndef OPENSSL_NO_SHA512
case '3': // sha3	case '3': // sha3
{	{
switch(fonction[4])	switch(fonction[4])
Line 892 instruction_cipher(struct_processus *s_e	Line 737 instruction_cipher(struct_processus *s_e

break;	break;
}	}
# endif

default:	default:
{	{
Line 903 instruction_cipher(struct_processus *s_e	Line 747 instruction_cipher(struct_processus *s_e

break;	break;
}	}
# endif

default:	default:
{	{
Line 1083 instruction_cipher(struct_processus *s_e	Line 926 instruction_cipher(struct_processus *s_e

iv = (unsigned char ) ((*l_element_courant).donnee).objet;	iv = (unsigned char ) ((*l_element_courant).donnee).objet;

	// On attend le drapeau concernant le padding.

	if ((l_element_courant = (*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_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;
	}

	tampon = conversion_majuscule(s_etat_processus,
	(unsigned char ) ((*l_element_courant).donnee).objet);

	if (strcmp(tampon, "PADDING") == 0)
	{
	padding = 'Y';
	}
	else if (strcmp(tampon, "NO PADDING") == 0)
	{
	padding = 'N';
	}
	else
	{
	free(tampon);

	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;
	}

	free(tampon);

	s_objet_padding = copie_objet(s_etat_processus,
	(*l_element_courant).donnee, 'P');

if ((*l_element_courant).suivant != NULL)	if ((*l_element_courant).suivant != NULL)
{	{
liberation(s_etat_processus, s_objet_argument_1);	liberation(s_etat_processus, s_objet_argument_1);
Line 1104 instruction_cipher(struct_processus *s_e	Line 996 instruction_cipher(struct_processus *s_e
return;	return;
}	}

if ((tampon = conversion_majuscule(algorithme_chiffrement)) == NULL)	if ((tampon = conversion_majuscule(s_etat_processus,
	algorithme_chiffrement)) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 1670 instruction_cipher(struct_processus *s_e	Line 1563 instruction_cipher(struct_processus *s_e
return;	return;
}	}

if ((message_chiffre = chiffrement(EVP_chiffrement, encodage, message,	if ((message_chiffre = chiffrement(s_etat_processus,
	EVP_chiffrement, encodage, message,
longueur_message, clef_binaire, longueur_clef_binaire,	longueur_message, clef_binaire, longueur_clef_binaire,
iv_binaire, &longueur_message_chiffre)) == NULL)	iv_binaire, &longueur_message_chiffre, padding)) == NULL)
{	{
free(clef_binaire);	free(clef_binaire);
free(iv_binaire);	free(iv_binaire);
Line 1755 instruction_cipher(struct_processus *s_e	Line 1649 instruction_cipher(struct_processus *s_e
}	}

if ((((l_element_courant).donnee).objet =	if ((((l_element_courant).donnee).objet =
conversion_majuscule(algorithme_chiffrement)) == NULL)	conversion_majuscule(s_etat_processus, algorithme_chiffrement))
	== NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 1798 instruction_cipher(struct_processus *s_e	Line 1693 instruction_cipher(struct_processus *s_e
}	}

l_element_courant = (*l_element_courant).suivant;	l_element_courant = (*l_element_courant).suivant;
(*l_element_courant).suivant = NULL;

if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))	if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
== NULL)	== NULL)
Line 1815 instruction_cipher(struct_processus *s_e	Line 1709 instruction_cipher(struct_processus *s_e

free(iv_binaire);	free(iv_binaire);

	// Padding

	if (((*l_element_courant).suivant = allocation_maillon(
	s_etat_processus)) == NULL)
	{
	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
	return;
	}

	l_element_courant = (*l_element_courant).suivant;
	(*l_element_courant).donnee = s_objet_padding;
	(*l_element_courant).suivant = NULL;

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);

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.8
changed lines
	Added in v.1.41