[BACK]Return to instructions_c8.c CVS log [TXT] [DIR] Up to [local] / rpl / src

Diff for /rpl/src/instructions_c8.c between versions 1.4 and 1.19

version 1.4, 2013/02/27 15:44:15 version 1.19, 2015/02/19 11:01:22
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.12    RPL/2 (R) version 4.1.21
   Copyright (C) 1989-2013 Dr. BERTRAND Joël    Copyright (C) 1989-2015 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 353  instruction_cipher(struct_processus *s_e Line 350  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 415  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 1106  instruction_cipher(struct_processus *s_e Line 1105  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 1474  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 1490  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 1672  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 1757  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(
Removed from v.1.4  
changed lines
  Added in v.1.19

CVSweb interface <joel.bertrand@systella.fr>