Return to controle.c CVS log

Up to [local] / rpl / src

Mise à jour du copyright.

    1: /*
    2: ================================================================================
    3:   RPL/2 (R) version 4.1.36
    4:   Copyright (C) 1989-2025 Dr. BERTRAND Joël
    5: 
    6:   This file is part of RPL/2.
    7: 
    8:   RPL/2 is free software; you can redistribute it and/or modify it
    9:   under the terms of the CeCILL V2 License as published by the french
   10:   CEA, CNRS and INRIA.
   11:  
   12:   RPL/2 is distributed in the hope that it will be useful, but WITHOUT
   13:   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   14:   FITNESS FOR A PARTICULAR PURPOSE.  See the CeCILL V2 License
   15:   for more details.
   16:  
   17:   You should have received a copy of the CeCILL License
   18:   along with RPL/2. If not, write to info@cecill.info.
   19: ================================================================================
   20: */
   21: 
   22: 
   23: #include "rpl-conv.h"
   24: 
   25: 
   26: /*
   27: ================================================================================
   28:   Calcul des sommes de contrôle avant le lancement d'un exécutable
   29:   de la famille RPL/2 (rpliconv, rplconvert, rplfile et rplpp).
   30: ================================================================================
   31:   Entrée :
   32:     - chaîne de caractères sur le fichier à contrôler
   33:     - chaîne de caractères contenant la somme à contrôler
   34:     - type de somme de contrôle
   35: --------------------------------------------------------------------------------
   36:   Sortie : drapeau
   37: --------------------------------------------------------------------------------
   38:   Effets de bord : néant
   39: ================================================================================
   40: */
   41: 
   42: logical1
   43: controle(struct_processus *s_etat_processus, unsigned char *fichier,
   44:         unsigned char *type, unsigned char *somme_candidate)
   45: {
   46:     EVP_MD_CTX          *contexte;
   47: 
   48:     int                 in_fd;
   49: 
   50:     logical1            drapeau;
   51: 
   52:     off_t               taille_fichier;
   53: 
   54:     ssize_t             octets_lus;
   55: 
   56:     struct stat         stat_buf;
   57: 
   58:     unsigned char       *chaine;
   59:     unsigned char       *registre;
   60:     unsigned char       somme[EVP_MAX_MD_SIZE];
   61:     unsigned char       somme_hexadecimale[2 * EVP_MAX_MD_SIZE];
   62: 
   63:     unsigned int        i;
   64:     unsigned int        longueur_somme;
   65: 
   66:     registre = fichier;
   67: 
   68: #   ifdef OS2
   69:     unsigned char       *tampon;
   70: 
   71:     if ((tampon = malloc((strlen(fichier) + 5) * sizeof(unsigned char)))
   72:             == NULL)
   73:     {
   74:         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
   75:         return(d_faux);
   76:     }
   77: 
   78:     sprintf(tampon, "%s.exe", fichier);
   79:     fichier = tampon;
   80: #   endif
   81: 
   82:     if (stat(fichier, &stat_buf) != 0)
   83:     {
   84: #       ifdef OS2
   85:         free(fichier);
   86: #       endif
   87: 
   88:         (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
   89:         return(d_faux);
   90:     }
   91: 
   92:     taille_fichier = stat_buf.st_size;
   93: 
   94:     if ((chaine = malloc((size_t) taille_fichier)) == NULL)
   95:     {
   96: #       ifdef OS2
   97:         free(fichier);
   98: #       endif
   99: 
  100:         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
  101:         return(d_faux);
  102:     }
  103: 
  104:     if ((in_fd = open(fichier, 0, O_RDONLY)) < 0)
  105:     {
  106: #       ifdef OS2
  107:         free(fichier);
  108: #       endif
  109: 
  110:         free(chaine);
  111: 
  112:         (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  113:         return(d_faux);
  114:     }
  115: 
  116: #   ifdef OS2
  117:     free(fichier);
  118: #   endif
  119: 
  120:     if ((octets_lus = read(in_fd, chaine, (size_t) taille_fichier))
  121:             != (ssize_t) taille_fichier)
  122:     {
  123: #       ifndef OS2
  124:         close(in_fd);
  125:         free(chaine);
  126: 
  127:         (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  128:         return(d_faux);
  129: #       endif
  130:     }
  131: 
  132:     close(in_fd);
  133: 
  134:     if ((contexte = EVP_MD_CTX_new()) == NULL)
  135:     {
  136:         close(in_fd);
  137:         return(d_faux);
  138:     }
  139: 
  140:     if (strcmp(type, "md5") == 0)
  141:     {
  142:         if (EVP_DigestInit(contexte, EVP_md5()) != 1)
  143:         {
  144:             EVP_MD_CTX_free(contexte);
  145:             close(in_fd);
  146:             free(chaine);
  147: 
  148:             (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  149:             return(d_faux);
  150:         }
  151: 
  152:         if (EVP_DigestUpdate(contexte, chaine, (size_t) taille_fichier) != 1)
  153:         {
  154:             EVP_MD_CTX_free(contexte);
  155:             close(in_fd);
  156:             free(chaine);
  157: 
  158:             (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  159:             return(d_faux);
  160:         }
  161: 
  162:         if (EVP_DigestFinal_ex(contexte, somme, &longueur_somme) != 1)
  163:         {
  164:             EVP_MD_CTX_free(contexte);
  165:             close(in_fd);
  166:             free(chaine);
  167: 
  168:             (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  169:             return(d_faux);
  170:         }
  171:     }
  172:     else if (strcmp(type, "sha1") == 0)
  173:     {
  174:         if (EVP_DigestInit(contexte, EVP_sha1()) != 1)
  175:         {
  176:             EVP_MD_CTX_free(contexte);
  177:             close(in_fd);
  178:             free(chaine);
  179: 
  180:             (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  181:             return(d_faux);
  182:         }
  183: 
  184:         if (EVP_DigestUpdate(contexte, chaine, (size_t) taille_fichier) != 1)
  185:         {
  186:             EVP_MD_CTX_free(contexte);
  187:             close(in_fd);
  188:             free(chaine);
  189: 
  190:             (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  191:             return(d_faux);
  192:         }
  193: 
  194:         if (EVP_DigestFinal_ex(contexte, somme, &longueur_somme) != 1)
  195:         {
  196:             EVP_MD_CTX_free(contexte);
  197:             close(in_fd);
  198:             free(chaine);
  199: 
  200:             (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
  201:             return(d_faux);
  202:         }
  203:     }
  204:     else
  205:     {
  206:         return(d_faux);
  207:     }
  208: 
  209:     EVP_MD_CTX_free(contexte);
  210:     free(chaine);
  211: 
  212:     for(i = 0; i < longueur_somme; i++)
  213:     {
  214:         sprintf(&(somme_hexadecimale[2 * i]), "%02x", somme[i]);
  215:     }
  216: 
  217:     if (strcmp(somme_candidate, somme_hexadecimale) == 0)
  218:     {
  219:         drapeau = d_vrai;
  220:     }
  221:     else
  222:     {
  223:         if ((*s_etat_processus).langue == 'F')
  224:         {
  225:             printf("+++Fatal : Somme de contrôle invalide\n");
  226:             printf("Fonction %s(%s)\n", type, registre);
  227:             printf("Résultat obtenu  : %s\n", somme_hexadecimale);
  228:             printf("Résultat attendu : %s\n", somme_candidate);
  229:         }
  230:         else
  231:         {
  232:             printf("+++Fatal : Hash code mismatch\n");
  233:             printf("Function %s(%s)\n", type, registre);
  234:             printf("Computed hash code : %s\n", somme_hexadecimale);
  235:             printf("Expected hash code : %s\n", somme_candidate);
  236:         }
  237: 
  238:         drapeau = d_faux;
  239:     }
  240: 
  241:     return(drapeau);
  242: }
  243: 
  244: // vim: ts=4