/*
================================================================================
  RPL/2 (R) version 4.1.12
  Copyright (C) 1989-2013 Dr. BERTRAND Joël

  This file is part of RPL/2.

  RPL/2 is free software; you can redistribute it and/or modify it
  under the terms of the CeCILL V2 License as published by the french
  CEA, CNRS and INRIA.
 
  RPL/2 is distributed in the hope that it will be useful, but WITHOUT
  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  FITNESS FOR A PARTICULAR PURPOSE.  See the CeCILL V2 License
  for more details.
 
  You should have received a copy of the CeCILL License
  along with RPL/2. If not, write to info@cecill.info.
================================================================================
*/


#include "rpl-conv.h"


/*
================================================================================
  Fonction 'cipher'
================================================================================
  Entrées :
--------------------------------------------------------------------------------
  Sorties :
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

void
instruction_cipher(struct_processus *s_etat_processus)
{
	const EVP_CIPHER				*EVP_chiffrement;
	const EVP_MD					*EVP_sum;

	integer8						nombre_cycles;

	logical1						somme_invalide;
	logical1						generation_clef;

	logical8						sel;

	struct_liste_chainee			*l_element_courant;

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

	unsigned char					*chiffrement;
	unsigned char					*clef;
	unsigned char					*controle;
	unsigned char					*direction;
	unsigned char					*fonction;
	unsigned char					*instruction;
	unsigned char					*iv;
	unsigned char					*tampon;

	if ((*s_etat_processus).affichage_arguments == 'Y')
	{
		printf("\n  CIPHER ");

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(opérations de chiffrement)\n\n");
		}
		else
		{
			printf("(cryptographic operations)\n\n");
		}

		printf("    2: %s \"password\"\n", d_CHN);
		printf("    1: %s { \"KEY\" \"cipher type\" \"digest type\" "
				"salt nround }\n", d_LST);
		printf("->  1: %s { \"generated key\" \"iv\" }\n\n", d_LST);

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("  Algorithmes de signature :\n\n");
		}
		else
		{
			printf("  Digest algorithms:\n\n");
		}

#		ifndef OPENSSL_NO_SHA
		printf("    - DSS\n");
		printf("    - DSS1\n");
		printf("    - ECDSA\n");
#		endif
#		ifndef OPENSSL_NO_MD2
		printf("    - MD2\n");
#		endif
#		ifndef OPENSSL_NO_MD4
		printf("    - MD4\n");
#		endif
#		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("    \"password\" { \"key\" \"SHA1\" # 0h 3 } CIPHER\n");
		printf("    \"text\" { \"AES-128-CBC\" \"DECRYPT\" \"key\" "
				"\"iv\" } CIPHER\n");
		printf("    \"text\" { \"AES-128-EBC\" \"ENCRYPT\" \"key\" "
				"\"iv\" } CIPHER\n");
		return;
	}
	else if ((*s_etat_processus).test_instruction == 'Y')
	{
		(*s_etat_processus).nombre_arguments = -1;
		return;
	}

	if (test_cfsf(s_etat_processus, 31) == d_vrai)
	{
		if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
		{
			return;
		}
	}

	if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
			&s_objet_argument_1) == d_erreur)
	{
		(*s_etat_processus).erreur_execution = d_ex_manque_argument;
		return;
	}

	if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
			&s_objet_argument_2) == d_erreur)
	{
		liberation(s_etat_processus, s_objet_argument_1);

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

	if (((*s_objet_argument_1).type == LST) &&
			((*s_objet_argument_2).type == CHN))
	{
		l_element_courant = (*s_objet_argument_1).objet;

		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_argument_invalide; 
			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 ((instruction = conversion_majuscule((unsigned char *)
				(*(*l_element_courant).donnee).objet)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if (strcmp(instruction, "KEY") == 0)
		{
			// Dérivation d'une clef

			free(instruction);

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

			// On attend l'algorithme de chiffrement.

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

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

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

			// On attend la somme de contrôle.

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

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

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


			// On attend le sel, donc un entier binaire de 64 bits.

			if ((*(*l_element_courant).donnee).type != BIN)
			{
				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;
			}

			sel = (*((logical8 *) (*(*l_element_courant).donnee).objet));

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

			// On attend le nombre de cycles.

			if ((*(*l_element_courant).donnee).type != INT)
			{
				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;
			}

			nombre_cycles = (*((integer8 *) (*(*l_element_courant)
					.donnee).objet));

			// On a dû atteindre la fin de la liste.

			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 de la validité de la somme de contrôle.

			if ((fonction = conversion_majuscule(controle)) == 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();
											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':
				{
					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();
									}
									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();
									}
									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();
									}
									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();
											}
											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();
					}
					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();
											break;
										}

										case '1': // sha1
										{
											if (fonction[4] ==
													d_code_fin_chaine)
											{
												EVP_sum = EVP_sha1();
											}
											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();
															}
															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();
															}
															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();
															}
															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();
															}
															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();
					}
					else
					{
						somme_invalide = d_vrai;
					}

					break;
				}
#				endif

				default:
				{
					somme_invalide = d_vrai;
					break;
				}
			}

			free(fonction);

			if (somme_invalide == d_vrai)
			{
				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;
			}

			generation_clef = d_vrai;
		}
		else
		{
			// Chiffrement ou déchiffrement d'un message

			chiffrement = fonction;

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

			// On attend la direction.

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

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

			// On attend la clef.

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

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

			// On attend le vecteur d'initialisation.

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

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

			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;
			}
		}
	}
	else
	{
		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 ((tampon = conversion_majuscule(chiffrement)) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	if (strncmp(tampon, "AES", 3) == 0)
	{
	}

	free(tampon);

	if (generation_clef == d_vrai)
	{
	}
	else
	{
	}

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

// vim: ts=4