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.4 and 1.36

version 1.4, 2013/02/27 15:44:15	version 1.36, 2022/09/07 13:40:34
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.1.12	RPL/2 (R) version 4.1.34
Copyright (C) 1989-2013 Dr. BERTRAND Joël	Copyright (C) 1989-2021 Dr. BERTRAND Joël

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

Line 43 instruction_cipher(struct_processus *s_e	Line 43 instruction_cipher(struct_processus *s_e

int longueur_clef;	int longueur_clef;

	integer8 longueur_clef_binaire;
	integer8 longueur_iv_binaire;
	integer8 longueur_message;
	integer8 longueur_message_chiffre;
integer8 nombre_cycles;	integer8 nombre_cycles;

logical1 encodage;	logical1 encodage;
Line 51 instruction_cipher(struct_processus *s_e	Line 55 instruction_cipher(struct_processus *s_e

logical8 sel;	logical8 sel;

long longueur_clef_binaire;
long longueur_iv_binaire;
long longueur_message;

struct_liste_chainee *l_element_courant;	struct_liste_chainee *l_element_courant;

struct_objet *s_objet_argument_1;	struct_objet *s_objet_argument_1;
Line 75 instruction_cipher(struct_processus *s_e	Line 75 instruction_cipher(struct_processus *s_e
unsigned char *message_chiffre;	unsigned char *message_chiffre;
unsigned char *tampon;	unsigned char *tampon;

unsigned int longueur_message_chiffre;

if ((*s_etat_processus).affichage_arguments == 'Y')	if ((*s_etat_processus).affichage_arguments == 'Y')
{	{
printf("\n CIPHER ");	printf("\n CIPHER ");
Line 96 instruction_cipher(struct_processus *s_e	Line 94 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\" }\n");
d_LST);
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\" }\n\n", d_LST);
Line 245 instruction_cipher(struct_processus *s_e	Line 242 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 265 instruction_cipher(struct_processus *s_e	Line 257 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 353 instruction_cipher(struct_processus *s_e	Line 338 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 417 instruction_cipher(struct_processus *s_e	Line 403 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 427 instruction_cipher(struct_processus *s_e	Line 414 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 696 instruction_cipher(struct_processus *s_e	Line 545 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 722 instruction_cipher(struct_processus *s_e	Line 564 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 800 instruction_cipher(struct_processus *s_e	Line 641 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 894 instruction_cipher(struct_processus *s_e	Line 733 instruction_cipher(struct_processus *s_e

break;	break;
}	}
# endif

default:	default:
{	{
Line 905 instruction_cipher(struct_processus *s_e	Line 743 instruction_cipher(struct_processus *s_e

break;	break;
}	}
# endif

default:	default:
{	{
Line 1106 instruction_cipher(struct_processus *s_e	Line 943 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 1474 instruction_cipher(struct_processus *s_e	Line 1312 instruction_cipher(struct_processus *s_e

if (generation_clef == d_vrai)	if (generation_clef == d_vrai)
{	{
if ((iv = malloc(EVP_CIPHER_iv_length(EVP_chiffrement)	if ((iv = malloc(((size_t) EVP_CIPHER_iv_length(EVP_chiffrement))
* 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;
}	}

if ((clef = malloc(EVP_CIPHER_key_length(EVP_chiffrement)	if ((clef = malloc(((size_t) EVP_CIPHER_key_length(EVP_chiffrement))
* 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;
Line 1490 instruction_cipher(struct_processus *s_e	Line 1328 instruction_cipher(struct_processus *s_e

longueur_clef = EVP_BytesToKey(EVP_chiffrement, EVP_sum,	longueur_clef = EVP_BytesToKey(EVP_chiffrement, EVP_sum,
(unsigned char ) &sel, (unsigned char )	(unsigned char ) &sel, (unsigned char )
(*s_objet_argument_2).objet, longueur_chaine(s_etat_processus,	(*s_objet_argument_2).objet,
	(int) longueur_chaine(s_etat_processus,
(unsigned char ) (s_objet_argument_2).objet),	(unsigned char ) (s_objet_argument_2).objet),
nombre_cycles, clef, iv);	(int) nombre_cycles, clef, iv);

if (longueur_clef != EVP_CIPHER_key_length(EVP_chiffrement))	if (longueur_clef != EVP_CIPHER_key_length(EVP_chiffrement))
{	{
Line 1671 instruction_cipher(struct_processus *s_e	Line 1510 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)) == NULL)
{	{
Line 1755 instruction_cipher(struct_processus *s_e	Line 1595 instruction_cipher(struct_processus *s_e
return;	return;
}	}

if ((((l_element_courant).donnee).objet = malloc(	if ((((l_element_courant).donnee).objet =
(strlen(algorithme_chiffrement) + 1) * sizeof(unsigned char)))	conversion_majuscule(s_etat_processus, algorithme_chiffrement))
== NULL)	== NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
}	}

strcpy(((l_element_courant).donnee).objet, algorithme_chiffrement);

// Clef	// Clef

if (((*l_element_courant).suivant = allocation_maillon(	if (((*l_element_courant).suivant = allocation_maillon(

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.4
changed lines
	Added in v.1.36