![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_d6.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src|
Return to instructions_d6.c CVS log | Up to [local] / rpl / src |
1.1 bertrand 1: /*
2: ================================================================================
1.65 bertrand 3: RPL/2 (R) version 4.1.26
1.66 ! bertrand 4: Copyright (C) 1989-2017 Dr. BERTRAND Joël
1.1 bertrand 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:
1.11 bertrand 23: #include "rpl-conv.h"
1.1 bertrand 24:
25:
26: /*
27: ================================================================================
28: Fonction 'dupcntxt'
29: ================================================================================
30: Entrées : pointeur sur une structure struct_processus
31: --------------------------------------------------------------------------------
32: Sorties :
33: --------------------------------------------------------------------------------
34: Effets de bord : néant
35: ================================================================================
36: */
37:
38: void
39: instruction_dupcntxt(struct_processus *s_etat_processus)
40: {
41: struct_objet *s_objet;
42: struct_objet *s_pile;
43:
44: (*s_etat_processus).erreur_execution = d_ex;
45:
46: if ((*s_etat_processus).affichage_arguments == 'Y')
47: {
48: printf("\n DUPCNTXT ");
49:
50: if ((*s_etat_processus).langue == 'F')
51: {
52: printf("(duplication du contexte)\n\n");
53: printf(" Aucun argument\n");
54: }
55: else
56: {
57: printf("(context duplication)\n\n");
58: printf(" No argument\n");
59: }
60:
61: return;
62: }
63: else if ((*s_etat_processus).test_instruction == 'Y')
64: {
65: (*s_etat_processus).nombre_arguments = -1;
66: return;
67: }
68:
69: if (test_cfsf(s_etat_processus, 31) == d_vrai)
70: {
71: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
72: {
73: return;
74: }
75: }
76:
77: if ((s_objet = allocation(s_etat_processus, LST)) == NULL)
78: {
79: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
80: return;
81: }
82:
83: (*s_objet).objet = (*s_etat_processus).l_base_pile;
84:
85: if ((s_pile = copie_objet(s_etat_processus, s_objet, 'N')) == NULL)
86: {
87: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
88: return;
89: }
90:
91: if (empilement(s_etat_processus, &((*s_etat_processus).
92: l_base_pile_contextes), s_objet) == d_erreur)
93: {
94: return;
95: }
96:
97: if ((s_objet = allocation(s_etat_processus, INT)) == NULL)
98: {
99: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
100: return;
101: }
102:
103: (*((integer8 *) (*s_objet).objet)) = (*s_etat_processus)
104: .hauteur_pile_operationnelle;
105:
106: if (empilement(s_etat_processus, &((*s_etat_processus)
107: .l_base_pile_taille_contextes), s_objet) == d_erreur)
108: {
109: return;
110: }
111:
112: /*
113: * Copie de la pile opérationnelle
114: */
115:
116: (*s_etat_processus).l_base_pile = (*s_pile).objet;
117:
118: (*s_pile).objet = NULL;
119: liberation(s_etat_processus, s_pile);
120:
121: return;
122: }
123:
124:
125: /*
126: ================================================================================
127: Fonction 'dropcntxt'
128: ================================================================================
129: Entrées : pointeur sur une structure struct_processus
130: --------------------------------------------------------------------------------
131: Sorties :
132: --------------------------------------------------------------------------------
133: Effets de bord : néant
134: ================================================================================
135: */
136:
137: void
138: instruction_dropcntxt(struct_processus *s_etat_processus)
139: {
140: struct_objet *s_objet;
141:
142: (*s_etat_processus).erreur_execution = d_ex;
143:
144: if ((*s_etat_processus).affichage_arguments == 'Y')
145: {
146: printf("\n DROPCNTXT ");
147:
148: if ((*s_etat_processus).langue == 'F')
149: {
150: printf("(effacement d'un contexte)\n\n");
151: printf(" Aucun argument\n");
152: }
153: else
154: {
155: printf("(drops context)\n\n");
156: printf(" No argument\n");
157: }
158:
159: return;
160: }
161: else if ((*s_etat_processus).test_instruction == 'Y')
162: {
163: (*s_etat_processus).nombre_arguments = -1;
164: return;
165: }
166:
167: if (test_cfsf(s_etat_processus, 31) == d_vrai)
168: {
169: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
170: {
171: return;
172: }
173: }
174:
175: if (((*s_etat_processus).l_base_pile_contextes == NULL) ||
176: ((*s_etat_processus).l_base_pile_taille_contextes == NULL))
177: {
178: (*s_etat_processus).erreur_execution = d_ex_contexte;
179: return;
180: }
181:
182: if (depilement(s_etat_processus, &((*s_etat_processus)
183: .l_base_pile_contextes), &s_objet) == d_erreur)
184: {
185: return;
186: }
187:
188: liberation(s_etat_processus, s_objet);
189:
190: if (depilement(s_etat_processus, &((*s_etat_processus)
191: .l_base_pile_taille_contextes), &s_objet) == d_erreur)
192: {
193: return;
194: }
195:
196: liberation(s_etat_processus, s_objet);
197:
198: return;
199: }
200:
201:
202: /*
203: ================================================================================
204: Fonction 'dgtiz'
205: ================================================================================
206: Entrées : pointeur sur une structure struct_processus
207: --------------------------------------------------------------------------------
208: Sorties :
209: --------------------------------------------------------------------------------
210: Effets de bord : néant
211: ================================================================================
212: */
213:
214: void
215: instruction_dgtiz(struct_processus *s_etat_processus)
216: {
217: (*s_etat_processus).erreur_execution = d_ex;
218:
219: if ((*s_etat_processus).affichage_arguments == 'Y')
220: {
221: printf("\n DGTIZ ");
222:
223: if ((*s_etat_processus).langue == 'F')
224: {
225: printf("(mouse support in plot functions)\n\n");
226: printf(" Aucun argument\n");
227: }
228: else
229: {
230: printf("(support de la souris dans les fonctions graphiques)\n\n");
231: printf(" No argument\n");
232: }
233:
234: return;
235: }
236: else if ((*s_etat_processus).test_instruction == 'Y')
237: {
238: (*s_etat_processus).nombre_arguments = -1;
239: return;
240: }
241:
242: if (test_cfsf(s_etat_processus, 31) == d_vrai)
243: {
244: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
245: {
246: return;
247: }
248: }
249:
250: if ((*s_etat_processus).fichiers_graphiques != NULL)
251: {
252: (*s_etat_processus).souris_active = d_vrai;
253: appel_gnuplot(s_etat_processus, 'N');
254: (*s_etat_processus).souris_active = d_faux;
255: }
256:
257: return;
258: }
259:
260:
261: /*
262: ================================================================================
263: Fonction 'daemonize'
264: ================================================================================
265: Entrées : pointeur sur une structure struct_processus
266: --------------------------------------------------------------------------------
267: Sorties :
268: --------------------------------------------------------------------------------
269: Effets de bord : néant
270: ================================================================================
271: */
272:
273: void
274: instruction_daemonize(struct_processus *s_etat_processus)
275: {
276: (*s_etat_processus).erreur_execution = d_ex;
277:
278: if ((*s_etat_processus).affichage_arguments == 'Y')
279: {
280: printf("\n DAEMONIZE ");
281:
282: if ((*s_etat_processus).langue == 'F')
283: {
284: printf("(basculement en mode daemon)\n\n");
285: printf(" Aucun argument\n");
286: }
287: else
288: {
289: printf("(convert to daemon)\n\n");
290: printf(" No argument\n");
291: }
292:
293: return;
294: }
295: else if ((*s_etat_processus).test_instruction == 'Y')
296: {
297: (*s_etat_processus).nombre_arguments = -1;
298: return;
299: }
300:
301: if (test_cfsf(s_etat_processus, 31) == d_vrai)
302: {
303: if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
304: {
305: return;
306: }
307: }
308:
309: if (((*s_etat_processus).var_volatile_processus_pere == -1) &&
310: ((*s_etat_processus).l_base_pile_processus == NULL))
311: {
312: lancement_daemon(s_etat_processus);
313: }
314: else
315: {
316: (*s_etat_processus).erreur_execution = d_ex_daemon;
317: return;
318: }
319:
320: return;
321: }
322:
323:
324: /*
325: ================================================================================
326: Fonction 'diag->'
327: ================================================================================
328: Entrées : pointeur sur une structure struct_processus
329: --------------------------------------------------------------------------------
330: Sorties :
331: --------------------------------------------------------------------------------
332: Effets de bord : néant
333: ================================================================================
334: */
335:
336: void
337: instruction_diag_fleche(struct_processus *s_etat_processus)
338: {
339: struct_objet *s_objet_argument;
340: struct_objet *s_objet_resultat;
341:
1.48 bertrand 342: integer8 i;
343: integer8 j;
1.1 bertrand 344:
345: (*s_etat_processus).erreur_execution = d_ex;
346:
347: if ((*s_etat_processus).affichage_arguments == 'Y')
348: {
349: printf("\n DIAG-> ");
350:
351: if ((*s_etat_processus).langue == 'F')
352: {
353: printf("(conversion d'une matrice diagonale en vecteur)\n\n");
354: }
355: else
356: {
357: printf("(diagonal matrix to vector conversion)\n\n");
358: }
359:
360: printf(" 1: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
361: printf("-> 1: %s, %s, %s\n", d_VIN, d_VRL, d_VCX);
362:
363: return;
364: }
365: else if ((*s_etat_processus).test_instruction == 'Y')
366: {
367: (*s_etat_processus).nombre_arguments = -1;
368: return;
369: }
370:
371: if (test_cfsf(s_etat_processus, 31) == d_vrai)
372: {
373: if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
374: {
375: return;
376: }
377: }
378:
379: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
380: &s_objet_argument) == d_erreur)
381: {
382: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
383: return;
384: }
385:
386: /*
387: * Conversion d'une matrice
388: */
389:
390: if ((*s_objet_argument).type == MIN)
391: {
392: if ((*((struct_matrice *) (*s_objet_argument).objet)).nombre_lignes !=
393: (*((struct_matrice *) (*s_objet_argument).objet))
394: .nombre_colonnes)
395: {
396: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
397:
398: liberation(s_etat_processus, s_objet_argument);
399: return;
400: }
401:
402: if ((s_objet_resultat = allocation(s_etat_processus, VIN)) == NULL)
403: {
404: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
405: return;
406: }
407:
408: (*((struct_vecteur *) (*s_objet_resultat).objet)).taille =
409: (*((struct_matrice *) (*s_objet_argument).objet)).nombre_lignes;
410:
411: if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau
1.48 bertrand 412: = malloc(((size_t) (*((struct_vecteur *) (*s_objet_resultat)
413: .objet)).taille) * sizeof(integer8))) == NULL)
1.1 bertrand 414: {
415: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
416: return;
417: }
418:
419: for(i = 0; i < (*((struct_matrice *) (*s_objet_argument).objet))
420: .nombre_lignes; i++)
421: {
422: for(j = 0; j < (*((struct_matrice *) (*s_objet_argument).objet))
423: .nombre_colonnes; j++)
424: {
425: if (i != j)
426: {
427: if (((integer8 **) (*((struct_matrice *) (*s_objet_argument)
428: .objet)).tableau)[i][j] != 0)
429: {
430: liberation(s_etat_processus, s_objet_argument);
431: liberation(s_etat_processus, s_objet_resultat);
432:
433: (*s_etat_processus).erreur_execution =
434: d_ex_matrice_non_diagonale;
435: return;
436: }
437: }
438: else
439: {
440: ((integer8 *) (*((struct_vecteur *) (*s_objet_resultat)
441: .objet)).tableau)[i] = ((integer8 **)
442: (*((struct_matrice *) (*s_objet_argument)
443: .objet)).tableau)[i][j];
444: }
445: }
446: }
447: }
448: else if ((*s_objet_argument).type == MRL)
449: {
450: if ((*((struct_matrice *) (*s_objet_argument).objet)).nombre_lignes !=
451: (*((struct_matrice *) (*s_objet_argument).objet))
452: .nombre_colonnes)
453: {
454: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
455:
456: liberation(s_etat_processus, s_objet_argument);
457: return;
458: }
459:
460: if ((s_objet_resultat = allocation(s_etat_processus, VRL)) == NULL)
461: {
462: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
463: return;
464: }
465:
466: (*((struct_vecteur *) (*s_objet_resultat).objet)).taille =
467: (*((struct_matrice *) (*s_objet_argument).objet)).nombre_lignes;
468:
469: if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau
1.48 bertrand 470: = malloc(((size_t) (*((struct_vecteur *) (*s_objet_resultat)
471: .objet)).taille) * sizeof(real8))) == NULL)
1.1 bertrand 472: {
473: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
474: return;
475: }
476:
477: for(i = 0; i < (*((struct_matrice *) (*s_objet_argument).objet))
478: .nombre_lignes; i++)
479: {
480: for(j = 0; j < (*((struct_matrice *) (*s_objet_argument).objet))
481: .nombre_colonnes; j++)
482: {
483: if (i != j)
484: {
485: if (((real8 **) (*((struct_matrice *) (*s_objet_argument)
486: .objet)).tableau)[i][j] != 0)
487: {
488: liberation(s_etat_processus, s_objet_argument);
489: liberation(s_etat_processus, s_objet_resultat);
490:
491: (*s_etat_processus).erreur_execution =
492: d_ex_matrice_non_diagonale;
493: return;
494: }
495: }
496: else
497: {
498: ((real8 *) (*((struct_vecteur *) (*s_objet_resultat)
499: .objet)).tableau)[i] = ((real8 **)
500: (*((struct_matrice *) (*s_objet_argument)
501: .objet)).tableau)[i][j];
502: }
503: }
504: }
505: }
506: else if ((*s_objet_argument).type == MCX)
507: {
508: if ((*((struct_matrice *) (*s_objet_argument).objet)).nombre_lignes !=
509: (*((struct_matrice *) (*s_objet_argument).objet))
510: .nombre_colonnes)
511: {
512: (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
513:
514: liberation(s_etat_processus, s_objet_argument);
515: return;
516: }
517:
518: if ((s_objet_resultat = allocation(s_etat_processus, VCX)) == NULL)
519: {
520: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
521: return;
522: }
523:
524: (*((struct_vecteur *) (*s_objet_resultat).objet)).taille =
525: (*((struct_matrice *) (*s_objet_argument).objet)).nombre_lignes;
526:
527: if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau
1.48 bertrand 528: = malloc(((size_t) (*((struct_vecteur *) (*s_objet_resultat)
529: .objet)).taille) * sizeof(complex16))) == NULL)
1.1 bertrand 530: {
531: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
532: return;
533: }
534:
535: for(i = 0; i < (*((struct_matrice *) (*s_objet_argument).objet))
536: .nombre_lignes; i++)
537: {
538: for(j = 0; j < (*((struct_matrice *) (*s_objet_argument).objet))
539: .nombre_colonnes; j++)
540: {
541: if (i != j)
542: {
543: if ((((complex16 **) (*((struct_matrice *)
544: (*s_objet_argument).objet)).tableau)[i][j]
545: .partie_reelle != 0) ||
546: (((complex16 **) (*((struct_matrice *)
547: (*s_objet_argument).objet)).tableau)[i][j]
548: .partie_imaginaire != 0))
549: {
550: liberation(s_etat_processus, s_objet_argument);
551: liberation(s_etat_processus, s_objet_resultat);
552:
553: (*s_etat_processus).erreur_execution =
554: d_ex_matrice_non_diagonale;
555: return;
556: }
557: }
558: else
559: {
560: ((complex16 *) (*((struct_vecteur *) (*s_objet_resultat)
561: .objet)).tableau)[i] = ((complex16 **)
562: (*((struct_matrice *) (*s_objet_argument)
563: .objet)).tableau)[i][j];
564: }
565: }
566: }
567: }
568:
569: /*
570: * Conversion impossible impossible
571: */
572:
573: else
574: {
575: liberation(s_etat_processus, s_objet_argument);
576:
577: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
578: return;
579: }
580:
581: liberation(s_etat_processus, s_objet_argument);
582:
583: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
584: s_objet_resultat) == d_erreur)
585: {
586: return;
587: }
588:
589: return;
590: }
591:
1.39 bertrand 592:
593: /*
594: ================================================================================
595: Fonction 'digest'
596: ================================================================================
597: Entrées : pointeur sur une structure struct_processus
598: --------------------------------------------------------------------------------
599: Sorties :
600: --------------------------------------------------------------------------------
601: Effets de bord : néant
602: ================================================================================
603: */
604:
605: void
606: instruction_digest(struct_processus *s_etat_processus)
607: {
1.64 bertrand 608: EVP_MD_CTX *contexte;
1.39 bertrand 609:
1.42 bertrand 610: const EVP_MD *EVP_sum;
611: const EVP_CIPHER *EVP_chiffrement;
1.39 bertrand 612:
1.48 bertrand 613: int i;
614: int longueur_bloc;
615: int longueur_somme;
616:
617: integer8 longueur_chaine;
618: integer8 longueur_clef;
619: integer8 longueur_clef_attendue;
620: integer8 longueur_clef_max;
621: integer8 longueur_clef_min;
622: integer8 longueur_tampon;
623:
1.39 bertrand 624: logical1 somme_invalide;
625:
1.41 bertrand 626: struct_liste_chainee *l_element_courant;
627:
1.39 bertrand 628: struct_objet *s_objet_argument_1;
629: struct_objet *s_objet_argument_2;
630: struct_objet *s_objet_resultat;
631:
632: unsigned char *chaine;
1.41 bertrand 633: unsigned char *clef;
1.39 bertrand 634: unsigned char *fonction;
635: unsigned char somme[EVP_MAX_MD_SIZE];
1.41 bertrand 636: unsigned char *tampon;
1.42 bertrand 637: unsigned char *vecteur_initialisation;
1.39 bertrand 638:
639: (*s_etat_processus).erreur_execution = d_ex;
640:
641: if ((*s_etat_processus).affichage_arguments == 'Y')
642: {
643: printf("\n DIGEST ");
644:
645: if ((*s_etat_processus).langue == 'F')
646: {
647: printf("(somme d'authentification)\n\n");
648: }
649: else
650: {
651: printf("(hash algorithm)\n\n");
652: }
653:
654: printf(" 2: %s\n", d_CHN);
655: printf(" 1: %s\n", d_CHN);
656: printf("-> 1: %s\n\n", d_CHN);
657:
658: printf(" 2: %s\n", d_CHN);
659: printf(" 1: %s\n", d_LST);
660: printf("-> 1: %s\n\n", d_CHN);
661:
662: if ((*s_etat_processus).langue == 'F')
663: {
664: printf(" Algorithmes :\n\n");
665: }
666: else
667: {
668: printf(" Algorithms:\n\n");
669: }
670:
1.42 bertrand 671: # ifndef OPENSSL_NO_AES
672: printf(" - AES-128-CBC\n");
673: printf(" - AES-192-CBC\n");
674: printf(" - AES-256-CBC\n");
675: # endif
1.43 bertrand 676: # ifndef OPENSSL_NO_CAMELLIA
677: printf(" - CAMELLIA-128-CBC\n");
678: printf(" - CAMELLIA-192-CBC\n");
679: printf(" - CAMELLIA-256-CBC\n");
680: # endif
681: # ifndef OPENSSL_NO_DES
682: printf(" - DES-CBC\n");
683: printf(" - DES-EDE-CBC\n");
684: printf(" - DES-EDE3-CB\n");
685: printf(" - DESX-CBC\n");
686: # endif
687: # ifndef OPENSSL_NO_IDEA
688: printf(" - IDEA-CBC\n");
689: # endif
1.39 bertrand 690: # ifndef OPENSSL_NO_MD2
691: printf(" - MD2\n");
692: # endif
693: # ifndef OPENSSL_NO_MD4
694: printf(" - MD4\n");
695: # endif
696: # ifndef OPENSSL_NO_MD5
697: printf(" - MD5\n");
698: # endif
1.40 bertrand 699: # ifndef OPENSSL_NO_MDC2
700: printf(" - MDC2\n");
701: # endif
1.43 bertrand 702: # ifndef OPENSSL_NO_RC2
703: printf(" - RC2-CBC\n");
704: printf(" - RC2-40-CBC\n");
705: printf(" - RC2-64-CBC\n");
706: # endif
1.40 bertrand 707: # ifndef OPENSSL_NO_RIPEMD
708: printf(" - RIPEMD160\n");
709: # endif
1.39 bertrand 710: printf(" - SHA1\n");
1.40 bertrand 711: printf(" - SHA224\n");
712: printf(" - SHA256\n");
713: printf(" - SHA384\n");
714: printf(" - SHA512\n");
715: # ifndef OPENSSL_NO_WHIRLPOOL
716: printf(" - WHIRLPOOL\n");
717: # endif
1.39 bertrand 718:
1.41 bertrand 719: printf("\n");
720:
721: if ((*s_etat_processus).langue == 'F')
722: {
723: printf(" Utilisation :\n\n");
724: }
725: else
726: {
727: printf(" Usage:\n\n");
728: }
729:
730: printf(" \"text\" \"MD5\" DIGEST\n");
731: printf(" \"text\" { \"SHA384\" \"key\" } DIGEST\n");
1.42 bertrand 732: printf(" \"text\" { \"AES-128-CBC\" \"key\" } DIGEST\n");
1.39 bertrand 733: return;
734: }
735: else if ((*s_etat_processus).test_instruction == 'Y')
736: {
737: (*s_etat_processus).nombre_arguments = -1;
738: return;
739: }
740:
741: if (test_cfsf(s_etat_processus, 31) == d_vrai)
742: {
743: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
744: {
745: return;
746: }
747: }
748:
749: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
750: &s_objet_argument_1) == d_erreur)
751: {
752: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
753: return;
754: }
755:
756: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
757: &s_objet_argument_2) == d_erreur)
758: {
759: liberation(s_etat_processus, s_objet_argument_1);
760:
761: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
762: return;
763: }
764:
765: if (((*s_objet_argument_1).type == CHN) &&
766: ((*s_objet_argument_2).type == CHN))
767: {
768: // Liste des sommes disponibles :
769: // - EVP_md2
770: // - EVP_md4
771: // - EVP_md5
772: // - EVP_mdc2
773: // - EVP_ripemd160
774: // - EVP_sha1
775: // - EVP_sha224
776: // - EVP_sha256
777: // - EVP_sha384
778: // - EVP_sha512
779: // - EVP_whirlpool
780:
1.58 bertrand 781: if ((fonction = conversion_majuscule(s_etat_processus,
782: (unsigned char *) (*s_objet_argument_1).objet)) == NULL)
1.39 bertrand 783: {
784: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
785: return;
786: }
787:
788: somme_invalide = d_faux;
789:
790: switch(fonction[0])
791: {
792: case 'M':
793: {
794: switch(fonction[1])
795: {
796: case 'D': // md
797: {
798: switch(fonction[2])
799: {
800: # ifndef OPENSSL_NO_MD2
801: case '2': // md2
802: {
803: if (fonction[3] == d_code_fin_chaine)
804: {
1.42 bertrand 805: EVP_sum = EVP_md2();
1.39 bertrand 806: }
807: else
808: {
809: somme_invalide = d_vrai;
810: }
811:
812: break;
813: }
814: # endif
815:
816: # ifndef OPENSSL_NO_MD4
817: case '4': // md4
818: {
819: if (fonction[3] == d_code_fin_chaine)
820: {
1.42 bertrand 821: EVP_sum = EVP_md4();
1.39 bertrand 822: }
823: else
824: {
825: somme_invalide = d_vrai;
826: }
827:
828: break;
829: }
830: # endif
831:
1.41 bertrand 832: # ifndef OPENSSL_NO_MD5
1.39 bertrand 833: case '5': // md5
834: {
835: if (fonction[3] == d_code_fin_chaine)
836: {
1.42 bertrand 837: EVP_sum = EVP_md5();
1.39 bertrand 838: }
839: else
840: {
841: somme_invalide = d_vrai;
842: }
843:
844: break;
845: }
846: # endif
847:
848: case 'C': // mdc
849: {
850: switch(fonction[3])
851: {
852: # ifndef OPENSSL_NO_MDC2
853: case '2': // mdc2
854: {
855: if (fonction[4] == d_code_fin_chaine)
856: {
1.42 bertrand 857: EVP_sum = EVP_mdc2();
1.39 bertrand 858: }
859: else
860: {
861: somme_invalide = d_vrai;
862: }
863:
864: break;
865: }
866: # endif
867:
868: default:
869: {
870: somme_invalide = d_vrai;
871: break;
872: }
873: }
874:
875: break;
876: }
877:
878: default:
879: {
880: somme_invalide = d_vrai;
881: break;
882: }
883: }
884:
885: break;
886: }
887:
888: default:
889: {
890: somme_invalide = d_vrai;
891: break;
892: }
893: }
894:
895: break;
896: }
897:
898: # ifndef OPENSSL_NO_RIPEMD
899: case 'R':
900: {
901: if (strcmp(fonction, "RIPEMD160") == 0)
902: {
1.42 bertrand 903: EVP_sum = EVP_ripemd160();
1.39 bertrand 904: }
905: else
906: {
907: somme_invalide = d_vrai;
908: }
909:
910: break;
911: }
912: # endif
913:
914: case 'S':
915: {
916: switch(fonction[1])
917: {
918: case 'H': // sh
919: {
920: switch(fonction[2])
921: {
922: case 'A':
923: {
924: switch(fonction[3])
925: {
926: case '1': // sha1
927: {
928: if (fonction[4] == d_code_fin_chaine)
929: {
1.42 bertrand 930: EVP_sum = EVP_sha1();
1.39 bertrand 931: }
932: else
933: {
934: somme_invalide = d_vrai;
935: }
936:
937: break;
938: }
939:
940: case '2': // sha2
941: {
942: switch(fonction[4])
943: {
944: case '2': // sha22
945: {
946: switch(fonction[5])
947: {
948: case '4': // sha224
949: {
950: if (fonction[6] ==
951: d_code_fin_chaine)
952: {
953: EVP_sum =
1.42 bertrand 954: EVP_sha224();
1.39 bertrand 955: }
956: else
957: {
958: somme_invalide =
1.42 bertrand 959: d_vrai;
1.39 bertrand 960: }
961:
962: break;
963: }
964:
965: default:
966: {
967: somme_invalide = d_vrai;
968: break;
969: }
970: }
971:
972: break;
973: }
974:
975: case '5':
976: {
977: switch(fonction[5])
978: {
979: case '6': // sha256
980: {
981: if (fonction[6] ==
982: d_code_fin_chaine)
983: {
984: EVP_sum =
1.42 bertrand 985: EVP_sha256();
1.39 bertrand 986: }
987: else
988: {
989: somme_invalide =
1.42 bertrand 990: d_vrai;
1.39 bertrand 991: }
992:
993: break;
994: }
995:
996: default:
997: {
998: somme_invalide = d_vrai;
999: break;
1000: }
1001: }
1002:
1003: break;
1004: }
1005:
1006: default:
1007: {
1008: somme_invalide = d_vrai;
1009: break;
1010: }
1011: }
1012:
1013: break;
1014: }
1015:
1016: case '3': // sha3
1017: {
1018: switch(fonction[4])
1019: {
1020: case '8': // sha38
1021: {
1022: switch(fonction[5])
1023: {
1024: case '4': // sha384
1025: {
1026: if (fonction[6] ==
1027: d_code_fin_chaine)
1028: {
1029: EVP_sum =
1.42 bertrand 1030: EVP_sha384();
1.39 bertrand 1031: }
1032: else
1033: {
1034: somme_invalide =
1.42 bertrand 1035: d_vrai;
1.39 bertrand 1036: }
1037:
1038: break;
1039: }
1040:
1041: default:
1042: {
1043: somme_invalide = d_vrai;
1044: break;
1045: }
1046: }
1047:
1048: break;
1049: }
1050:
1051: default:
1052: {
1053: somme_invalide = d_vrai;
1054: break;
1055: }
1056: }
1057:
1058: break;
1059: }
1060:
1061: case '5': // sha5
1062: {
1063: switch(fonction[4])
1064: {
1065: case '1': // sha51
1066: {
1067: switch(fonction[5])
1068: {
1069: case '2': // sha512
1070: {
1071: if (fonction[6] ==
1072: d_code_fin_chaine)
1073: {
1074: EVP_sum =
1.42 bertrand 1075: EVP_sha512();
1.39 bertrand 1076: }
1077: else
1078: {
1079: somme_invalide =
1.42 bertrand 1080: d_vrai;
1.39 bertrand 1081: }
1082:
1083: break;
1084: }
1085:
1086: default:
1087: {
1088: somme_invalide = d_vrai;
1089: break;
1090: }
1091: }
1092:
1093: break;
1094: }
1095:
1096: default:
1097: {
1098: somme_invalide = d_vrai;
1099: break;
1100: }
1101: }
1102:
1103: break;
1104: }
1105:
1106: default:
1107: {
1108: somme_invalide = d_vrai;
1109: break;
1110: }
1111: }
1112:
1113: break;
1114: }
1115:
1116: default:
1117: {
1118: somme_invalide = d_vrai;
1119: break;
1120: }
1121: }
1122:
1123: break;
1124: }
1125:
1126: default:
1127: {
1128: somme_invalide = d_vrai;
1129: break;
1130: }
1131: }
1132:
1133: break;
1134: }
1135:
1136: # ifndef OPENSSL_NO_WHIRLPOOL
1137: case 'W':
1138: {
1139: if (strcmp(fonction, "WHIRLPOOL") == 0)
1140: {
1.42 bertrand 1141: EVP_sum = EVP_whirlpool();
1.39 bertrand 1142: }
1143: else
1144: {
1145: somme_invalide = d_vrai;
1146: }
1147:
1148: break;
1149: }
1150: # endif
1151:
1152: default:
1153: {
1154: somme_invalide = d_vrai;
1155: break;
1156: }
1157: }
1158:
1159: free(fonction);
1160:
1161: if (somme_invalide == d_vrai)
1162: {
1163: liberation(s_etat_processus, s_objet_argument_1);
1164: liberation(s_etat_processus, s_objet_argument_2);
1165:
1166: (*s_etat_processus).erreur_execution =
1167: d_ex_chiffrement_indisponible;
1168: return;
1169: }
1170:
1.64 bertrand 1171: if ((contexte = EVP_MD_CTX_new()) == NULL)
1.39 bertrand 1172: {
1.64 bertrand 1173: liberation(s_etat_processus, s_objet_argument_1);
1174: liberation(s_etat_processus, s_objet_argument_2);
1175:
1176: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1177: return;
1178: }
1179:
1180: if (EVP_DigestInit(contexte, EVP_sum) != 1)
1181: {
1182: EVP_MD_CTX_free(contexte);
1.39 bertrand 1183:
1184: liberation(s_etat_processus, s_objet_argument_1);
1185: liberation(s_etat_processus, s_objet_argument_2);
1186:
1187: (*s_etat_processus).erreur_execution = d_ex_chiffrement;
1188: return;
1189: }
1190:
1191: if ((chaine = formateur_flux(s_etat_processus, (unsigned char *)
1192: (*s_objet_argument_2).objet, &longueur_chaine)) == NULL)
1193: {
1.64 bertrand 1194: EVP_MD_CTX_free(contexte);
1.39 bertrand 1195:
1196: liberation(s_etat_processus, s_objet_argument_1);
1197: liberation(s_etat_processus, s_objet_argument_2);
1198:
1199: return;
1200: }
1201:
1.64 bertrand 1202: if (EVP_DigestUpdate(contexte, chaine, (size_t) longueur_chaine) != 1)
1.39 bertrand 1203: {
1204: free(chaine);
1.64 bertrand 1205: EVP_MD_CTX_free(contexte);
1.39 bertrand 1206:
1207: liberation(s_etat_processus, s_objet_argument_1);
1208: liberation(s_etat_processus, s_objet_argument_2);
1209:
1210: (*s_etat_processus).erreur_execution = d_ex_chiffrement;
1211: return;
1212: }
1213:
1.64 bertrand 1214: if (EVP_DigestFinal_ex(contexte, somme, &longueur_somme) != 1)
1.39 bertrand 1215: {
1216: free(chaine);
1.64 bertrand 1217: EVP_MD_CTX_free(contexte);
1.39 bertrand 1218:
1219: liberation(s_etat_processus, s_objet_argument_1);
1220: liberation(s_etat_processus, s_objet_argument_2);
1221:
1222: (*s_etat_processus).erreur_execution = d_ex_chiffrement;
1223: return;
1224: }
1225:
1226: free(chaine);
1.64 bertrand 1227: EVP_MD_CTX_free(contexte);
1.39 bertrand 1228:
1229: if ((s_objet_resultat = allocation(s_etat_processus, CHN)) == NULL)
1230: {
1231: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1232: return;
1233: }
1234:
1235: if (((*s_objet_resultat).objet = analyse_flux(s_etat_processus,
1236: somme, longueur_somme)) == NULL)
1237: {
1238: liberation(s_etat_processus, s_objet_argument_1);
1239: liberation(s_etat_processus, s_objet_argument_2);
1240:
1241: return;
1242: }
1243: }
1.41 bertrand 1244: else if (((*s_objet_argument_1).type == LST) &&
1245: ((*s_objet_argument_2).type == CHN))
1.39 bertrand 1246: {
1.41 bertrand 1247: l_element_courant = (*s_objet_argument_1).objet;
1248:
1249: if ((*(*l_element_courant).donnee).type != CHN)
1250: {
1251: liberation(s_etat_processus, s_objet_argument_1);
1252: liberation(s_etat_processus, s_objet_argument_2);
1253:
1254: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1255: return;
1256: }
1257:
1258: l_element_courant = (*l_element_courant).suivant;
1259:
1260: if (l_element_courant == NULL)
1261: {
1262: liberation(s_etat_processus, s_objet_argument_1);
1263: liberation(s_etat_processus, s_objet_argument_2);
1264:
1265: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1266: return;
1267: }
1268:
1269: if ((*(*l_element_courant).donnee).type != CHN)
1270: {
1271: liberation(s_etat_processus, s_objet_argument_1);
1272: liberation(s_etat_processus, s_objet_argument_2);
1273:
1274: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1275: return;
1276: }
1277:
1278: if ((*l_element_courant).suivant != NULL)
1279: {
1280: liberation(s_etat_processus, s_objet_argument_1);
1281: liberation(s_etat_processus, s_objet_argument_2);
1282:
1283: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
1284: return;
1285: }
1286:
1287: // Test du type de somme de contrôle
1288: // - les sommes classiques suivent la RFC 2104
1289: // - les autres sont formées sur des algorithmes de type CBC
1290:
1291: l_element_courant = (*s_objet_argument_1).objet;
1292:
1.58 bertrand 1293: if ((fonction = conversion_majuscule(s_etat_processus,
1294: (unsigned char *) (*(*l_element_courant).donnee).objet))
1295: == NULL)
1.41 bertrand 1296: {
1297: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1298: return;
1299: }
1300:
1301: somme_invalide = d_faux;
1302:
1303: switch(fonction[0])
1304: {
1305: case 'M':
1306: {
1307: switch(fonction[1])
1308: {
1309: case 'D': // md
1310: {
1311: switch(fonction[2])
1312: {
1313: # ifndef OPENSSL_NO_MD2
1314: case '2': // md2
1315: {
1316: if (fonction[3] == d_code_fin_chaine)
1317: {
1.42 bertrand 1318: EVP_sum = EVP_md2();
1.41 bertrand 1319: }
1320: else
1321: {
1322: somme_invalide = d_vrai;
1323: }
1324:
1325: break;
1326: }
1327: # endif
1328:
1329: # ifndef OPENSSL_NO_MD4
1330: case '4': // md4
1331: {
1332: if (fonction[3] == d_code_fin_chaine)
1333: {
1.42 bertrand 1334: EVP_sum = EVP_md4();
1.41 bertrand 1335: }
1336: else
1337: {
1338: somme_invalide = d_vrai;
1339: }
1340:
1341: break;
1342: }
1343: # endif
1344:
1345: # ifndef OPENSSL_NO_MD5
1346: case '5': // md5
1347: {
1348: if (fonction[3] == d_code_fin_chaine)
1349: {
1.42 bertrand 1350: EVP_sum = EVP_md5();
1.41 bertrand 1351: }
1352: else
1353: {
1354: somme_invalide = d_vrai;
1355: }
1356:
1357: break;
1358: }
1359: # endif
1360:
1361: case 'C': // mdc
1362: {
1363: switch(fonction[3])
1364: {
1365: # ifndef OPENSSL_NO_MDC2
1366: case '2': // mdc2
1367: {
1368: if (fonction[4] == d_code_fin_chaine)
1369: {
1.42 bertrand 1370: EVP_sum = EVP_mdc2();
1.41 bertrand 1371: }
1372: else
1373: {
1374: somme_invalide = d_vrai;
1375: }
1376:
1377: break;
1378: }
1379: # endif
1380:
1381: default:
1382: {
1383: somme_invalide = d_vrai;
1384: break;
1385: }
1386: }
1387:
1388: break;
1389: }
1390:
1391: default:
1392: {
1393: somme_invalide = d_vrai;
1394: break;
1395: }
1396: }
1397:
1398: break;
1399: }
1400:
1401: default:
1402: {
1403: somme_invalide = d_vrai;
1404: break;
1405: }
1406: }
1407:
1408: break;
1409: }
1410:
1411: # ifndef OPENSSL_NO_RIPEMD
1412: case 'R':
1413: {
1414: if (strcmp(fonction, "RIPEMD160") == 0)
1415: {
1.42 bertrand 1416: EVP_sum = EVP_ripemd160();
1.41 bertrand 1417: }
1418: else
1419: {
1420: somme_invalide = d_vrai;
1421: }
1422:
1423: break;
1424: }
1425: # endif
1426:
1427: case 'S':
1428: {
1429: switch(fonction[1])
1430: {
1431: case 'H': // sh
1432: {
1433: switch(fonction[2])
1434: {
1435: case 'A':
1436: {
1437: switch(fonction[3])
1438: {
1439: case '1': // sha1
1440: {
1441: if (fonction[4] == d_code_fin_chaine)
1442: {
1.42 bertrand 1443: EVP_sum = EVP_sha1();
1.41 bertrand 1444: }
1445: else
1446: {
1447: somme_invalide = d_vrai;
1448: }
1449:
1450: break;
1451: }
1452:
1453: case '2': // sha2
1454: {
1455: switch(fonction[4])
1456: {
1457: case '2': // sha22
1458: {
1459: switch(fonction[5])
1460: {
1461: case '4': // sha224
1462: {
1463: if (fonction[6] ==
1464: d_code_fin_chaine)
1465: {
1466: EVP_sum =
1.42 bertrand 1467: EVP_sha224();
1.41 bertrand 1468: }
1469: else
1470: {
1471: somme_invalide =
1472: d_vrai;
1473: }
1474:
1475: break;
1476: }
1477:
1478: default:
1479: {
1480: somme_invalide = d_vrai;
1481: break;
1482: }
1483: }
1484:
1485: break;
1486: }
1487:
1488: case '5':
1489: {
1490: switch(fonction[5])
1491: {
1492: case '6': // sha256
1493: {
1494: if (fonction[6] ==
1495: d_code_fin_chaine)
1496: {
1497: EVP_sum =
1.42 bertrand 1498: EVP_sha256();
1.41 bertrand 1499: }
1500: else
1501: {
1502: somme_invalide =
1503: d_vrai;
1504: }
1505:
1506: break;
1507: }
1508:
1509: default:
1510: {
1511: somme_invalide = d_vrai;
1512: break;
1513: }
1514: }
1515:
1516: break;
1517: }
1518:
1519: default:
1520: {
1521: somme_invalide = d_vrai;
1522: break;
1523: }
1524: }
1525:
1526: break;
1527: }
1528:
1529: case '3': // sha3
1530: {
1531: switch(fonction[4])
1532: {
1533: case '8': // sha38
1534: {
1535: switch(fonction[5])
1536: {
1537: case '4': // sha384
1538: {
1539: if (fonction[6] ==
1540: d_code_fin_chaine)
1541: {
1542: EVP_sum =
1.42 bertrand 1543: EVP_sha384();
1.41 bertrand 1544: }
1545: else
1546: {
1547: somme_invalide =
1548: d_vrai;
1549: }
1550:
1551: break;
1552: }
1553:
1554: default:
1555: {
1556: somme_invalide = d_vrai;
1557: break;
1558: }
1559: }
1560:
1561: break;
1562: }
1563:
1564: default:
1565: {
1566: somme_invalide = d_vrai;
1567: break;
1568: }
1569: }
1570:
1571: break;
1572: }
1573:
1574: case '5': // sha5
1575: {
1576: switch(fonction[4])
1577: {
1578: case '1': // sha51
1579: {
1580: switch(fonction[5])
1581: {
1582: case '2': // sha512
1583: {
1584: if (fonction[6] ==
1585: d_code_fin_chaine)
1586: {
1587: EVP_sum =
1.42 bertrand 1588: EVP_sha512();
1.41 bertrand 1589: }
1590: else
1591: {
1592: somme_invalide =
1593: d_vrai;
1594: }
1595:
1596: break;
1597: }
1598:
1599: default:
1600: {
1601: somme_invalide = d_vrai;
1602: break;
1603: }
1604: }
1605:
1606: break;
1607: }
1608:
1609: default:
1610: {
1611: somme_invalide = d_vrai;
1612: break;
1613: }
1614: }
1615:
1616: break;
1617: }
1618:
1619: default:
1620: {
1621: somme_invalide = d_vrai;
1622: break;
1623: }
1624: }
1625:
1626: break;
1627: }
1628:
1629: default:
1630: {
1631: somme_invalide = d_vrai;
1632: break;
1633: }
1634: }
1635:
1636: break;
1637: }
1638:
1639: default:
1640: {
1641: somme_invalide = d_vrai;
1642: break;
1643: }
1644: }
1645:
1646: break;
1647: }
1648:
1649: # ifndef OPENSSL_NO_WHIRLPOOL
1650: case 'W':
1651: {
1652: if (strcmp(fonction, "WHIRLPOOL") == 0)
1653: {
1.42 bertrand 1654: EVP_sum = EVP_whirlpool();
1.41 bertrand 1655: }
1656: else
1657: {
1658: somme_invalide = d_vrai;
1659: }
1660:
1661: break;
1662: }
1663: # endif
1664:
1665: default:
1666: {
1667: somme_invalide = d_vrai;
1668: break;
1669: }
1670: }
1671:
1672: if (somme_invalide == d_vrai)
1673: {
1674: // Le chiffrement est de type CBC-MAC
1.42 bertrand 1675:
1676: if (strncmp(fonction, "AES", 3) == 0)
1677: {
1678: # ifdef OPENSSL_NO_AES
1.43 bertrand 1679:
1.42 bertrand 1680: free(fonction);
1681:
1682: liberation(s_etat_processus, s_objet_argument_1);
1683: liberation(s_etat_processus, s_objet_argument_2);
1684:
1685: (*s_etat_processus).erreur_execution =
1686: d_ex_chiffrement_indisponible;
1.43 bertrand 1687: return;
1688:
1.42 bertrand 1689: # else
1690:
1691: if (strcmp(fonction, "AES-128-CBC") == 0)
1692: {
1693: EVP_chiffrement = EVP_aes_128_cbc();
1694: }
1695: else if (strcmp(fonction, "AES-192-CBC") == 0)
1696: {
1697: EVP_chiffrement = EVP_aes_192_cbc();
1698: }
1699: else if (strcmp(fonction, "AES-256-CBC") == 0)
1700: {
1701: EVP_chiffrement = EVP_aes_256_cbc();
1702: }
1703: else
1704: {
1705: free(fonction);
1706:
1707: liberation(s_etat_processus, s_objet_argument_1);
1708: liberation(s_etat_processus, s_objet_argument_2);
1709:
1710: (*s_etat_processus).erreur_execution =
1711: d_ex_chiffrement_indisponible;
1712: return;
1713: }
1714:
1.45 bertrand 1715: longueur_clef_attendue = EVP_CIPHER_key_length(EVP_chiffrement);
1716: longueur_somme = EVP_CIPHER_block_size(EVP_chiffrement);
1717:
1.43 bertrand 1718: # endif
1719: }
1720: else if (strncmp(fonction, "DES", 3) == 0)
1721: {
1722: # ifdef OPENSSL_NO_DES
1723:
1724: free(fonction);
1725:
1726: liberation(s_etat_processus, s_objet_argument_1);
1727: liberation(s_etat_processus, s_objet_argument_2);
1728:
1729: (*s_etat_processus).erreur_execution =
1730: d_ex_chiffrement_indisponible;
1731: return;
1732:
1733: # else
1734:
1735: if (strcmp(fonction, "DES-CBC") == 0)
1736: {
1737: EVP_chiffrement = EVP_des_cbc();
1738: }
1739: else if (strcmp(fonction, "DES-EDE-CBC") == 0)
1740: {
1741: EVP_chiffrement = EVP_des_ede_cbc();
1742: }
1743: else if (strcmp(fonction, "DES-EDE3-CBC") == 0)
1744: {
1745: EVP_chiffrement = EVP_des_ede3_cbc();
1746: }
1747: else if (strcmp(fonction, "DESX-CBC") == 0)
1748: {
1749: EVP_chiffrement = EVP_desx_cbc();
1750: }
1751: else
1.42 bertrand 1752: {
1753: free(fonction);
1754:
1755: liberation(s_etat_processus, s_objet_argument_1);
1756: liberation(s_etat_processus, s_objet_argument_2);
1757:
1.43 bertrand 1758: (*s_etat_processus).erreur_execution =
1759: d_ex_chiffrement_indisponible;
1.42 bertrand 1760: return;
1761: }
1.45 bertrand 1762:
1763: longueur_clef_attendue = EVP_CIPHER_key_length(EVP_chiffrement);
1764: longueur_somme = EVP_CIPHER_block_size(EVP_chiffrement);
1765:
1.43 bertrand 1766: # endif
1767: }
1768: else if (strncmp(fonction, "CAMELLIA", 8) == 0)
1769: {
1770: # ifdef OPENSSL_NO_CAMELLIA
1771:
1772: free(fonction);
1.42 bertrand 1773:
1.43 bertrand 1774: liberation(s_etat_processus, s_objet_argument_1);
1775: liberation(s_etat_processus, s_objet_argument_2);
1.42 bertrand 1776:
1.43 bertrand 1777: (*s_etat_processus).erreur_execution =
1778: d_ex_chiffrement_indisponible;
1779: return;
1780:
1781: # else
1782:
1783: if (strcmp(fonction, "CAMELLIA-128-CBC") == 0)
1784: {
1785: EVP_chiffrement = EVP_camellia_128_cbc();
1786: }
1787: else if (strcmp(fonction, "CAMELLIA-192-CBC") == 0)
1788: {
1789: EVP_chiffrement = EVP_camellia_192_cbc();
1790: }
1791: else if (strcmp(fonction, "CAMELLIA-256-CBC") == 0)
1792: {
1793: EVP_chiffrement = EVP_camellia_256_cbc();
1794: }
1795: else
1.42 bertrand 1796: {
1797: free(fonction);
1798:
1799: liberation(s_etat_processus, s_objet_argument_1);
1800: liberation(s_etat_processus, s_objet_argument_2);
1.43 bertrand 1801:
1802: (*s_etat_processus).erreur_execution =
1803: d_ex_chiffrement_indisponible;
1.42 bertrand 1804: return;
1805: }
1.45 bertrand 1806:
1807: longueur_clef_attendue = EVP_CIPHER_key_length(EVP_chiffrement);
1808: longueur_somme = EVP_CIPHER_block_size(EVP_chiffrement);
1809:
1.43 bertrand 1810: # endif
1811: }
1812: else if (strncmp(fonction, "RC2", 3) == 0)
1813: {
1814: # ifdef OPENSSL_NO_RC2
1.42 bertrand 1815:
1.43 bertrand 1816: free(fonction);
1817:
1818: liberation(s_etat_processus, s_objet_argument_1);
1819: liberation(s_etat_processus, s_objet_argument_2);
1820:
1821: (*s_etat_processus).erreur_execution =
1822: d_ex_chiffrement_indisponible;
1823: return;
1824:
1825: # else
1826:
1827: if (strcmp(fonction, "RC2-CBC") == 0)
1828: {
1829: EVP_chiffrement = EVP_rc2_cbc();
1830: }
1831: else if (strcmp(fonction, "RC2-40-CBC") == 0)
1832: {
1833: EVP_chiffrement = EVP_rc2_40_cbc();
1834: }
1835: else if (strcmp(fonction, "RC2-64-CBC") == 0)
1836: {
1837: EVP_chiffrement = EVP_rc2_64_cbc();
1838: }
1839: else
1.42 bertrand 1840: {
1841: free(fonction);
1842:
1843: liberation(s_etat_processus, s_objet_argument_1);
1844: liberation(s_etat_processus, s_objet_argument_2);
1845:
1846: (*s_etat_processus).erreur_execution =
1.43 bertrand 1847: d_ex_chiffrement_indisponible;
1.42 bertrand 1848: return;
1849: }
1.45 bertrand 1850:
1851: longueur_clef_attendue = 0;
1852: longueur_clef_min = 1;
1853: longueur_clef_max = 16;
1854: longueur_somme = EVP_CIPHER_block_size(EVP_chiffrement);
1855:
1.43 bertrand 1856: # endif
1857: }
1858: else if (strncmp(fonction, "IDEA", 4) == 0)
1859: {
1860: # ifdef OPENSSL_NO_IDEA
1861:
1862: free(fonction);
1.42 bertrand 1863:
1.43 bertrand 1864: liberation(s_etat_processus, s_objet_argument_1);
1865: liberation(s_etat_processus, s_objet_argument_2);
1866:
1867: (*s_etat_processus).erreur_execution =
1868: d_ex_chiffrement_indisponible;
1869: return;
1870:
1871: # else
1872:
1873: if (strcmp(fonction, "IDEA-CBC") == 0)
1.42 bertrand 1874: {
1.43 bertrand 1875: EVP_chiffrement = EVP_idea_cbc();
1.42 bertrand 1876: }
1.43 bertrand 1877: else
1.42 bertrand 1878: {
1879: free(fonction);
1.43 bertrand 1880:
1881: liberation(s_etat_processus, s_objet_argument_1);
1882: liberation(s_etat_processus, s_objet_argument_2);
1.42 bertrand 1883:
1884: (*s_etat_processus).erreur_execution =
1.43 bertrand 1885: d_ex_chiffrement_indisponible;
1.42 bertrand 1886: return;
1887: }
1.45 bertrand 1888:
1889: longueur_clef_attendue = EVP_CIPHER_key_length(EVP_chiffrement);
1890: longueur_somme = EVP_CIPHER_block_size(EVP_chiffrement);
1891:
1.43 bertrand 1892: # endif
1893: }
1894: else
1895: {
1896: free(fonction);
1897:
1898: liberation(s_etat_processus, s_objet_argument_1);
1899: liberation(s_etat_processus, s_objet_argument_2);
1900:
1901: (*s_etat_processus).erreur_execution =
1902: d_ex_chiffrement_indisponible;
1903: return;
1904: }
1905:
1906: if ((chaine = formateur_flux(s_etat_processus, (unsigned char *)
1907: (*s_objet_argument_2).objet, &longueur_chaine)) == NULL)
1908: {
1909: free(fonction);
1.42 bertrand 1910:
1.43 bertrand 1911: liberation(s_etat_processus, s_objet_argument_1);
1912: liberation(s_etat_processus, s_objet_argument_2);
1913:
1914: return;
1915: }
1916:
1917: l_element_courant = (*s_objet_argument_1).objet;
1918: l_element_courant = (*l_element_courant).suivant;
1919:
1920: if ((clef = formateur_flux(s_etat_processus, (unsigned char *)
1921: (*(*l_element_courant).donnee).objet, &longueur_clef))
1922: == NULL)
1923: {
1924: free(fonction);
1.42 bertrand 1925: free(chaine);
1926:
1.43 bertrand 1927: liberation(s_etat_processus, s_objet_argument_1);
1928: liberation(s_etat_processus, s_objet_argument_2);
1929: return;
1930: }
1931:
1932: if (longueur_clef_attendue != 0)
1933: {
1934: if (longueur_clef != longueur_clef_attendue)
1.42 bertrand 1935: {
1.43 bertrand 1936: free(fonction);
1937: free(chaine);
1938: free(clef);
1939:
1940: liberation(s_etat_processus, s_objet_argument_1);
1941: liberation(s_etat_processus, s_objet_argument_2);
1942:
1943: (*s_etat_processus).erreur_execution =
1944: d_ex_longueur_clef_chiffrement;
1.42 bertrand 1945: return;
1946: }
1.43 bertrand 1947: }
1948: else
1949: {
1950: if ((longueur_clef < longueur_clef_min) &&
1951: (longueur_clef > longueur_clef_max))
1.42 bertrand 1952: {
1953: free(fonction);
1.43 bertrand 1954: free(chaine);
1955: free(clef);
1.42 bertrand 1956:
1957: liberation(s_etat_processus, s_objet_argument_1);
1958: liberation(s_etat_processus, s_objet_argument_2);
1.43 bertrand 1959:
1960: (*s_etat_processus).erreur_execution =
1961: d_ex_longueur_clef_chiffrement;
1.42 bertrand 1962: return;
1963: }
1.43 bertrand 1964: }
1965:
1.48 bertrand 1966: if ((vecteur_initialisation = malloc(((size_t) longueur_clef) *
1.43 bertrand 1967: sizeof(unsigned char))) == NULL)
1968: {
1969: (*s_etat_processus).erreur_systeme =
1970: d_es_allocation_memoire;
1971: return;
1972: }
1973:
1.48 bertrand 1974: memset(vecteur_initialisation, 0, (size_t) longueur_clef);
1.42 bertrand 1975:
1.58 bertrand 1976: if ((tampon = chiffrement(s_etat_processus, EVP_chiffrement, d_vrai,
1.43 bertrand 1977: chaine, longueur_chaine, clef, longueur_clef,
1.45 bertrand 1978: vecteur_initialisation, &longueur_tampon)) == NULL)
1.43 bertrand 1979: {
1980: free(fonction);
1981: free(vecteur_initialisation);
1982: free(chaine);
1983: free(clef);
1984:
1985: (*s_etat_processus).erreur_execution =
1986: d_ex_chiffrement;
1987: return;
1988: }
1989:
1990: free(vecteur_initialisation);
1991: free(chaine);
1992: free(clef);
1.42 bertrand 1993:
1.43 bertrand 1994: if ((s_objet_resultat = allocation(s_etat_processus, CHN))
1995: == NULL)
1996: {
1997: (*s_etat_processus).erreur_systeme =
1998: d_es_allocation_memoire;
1999: return;
1.42 bertrand 2000: }
1.43 bertrand 2001:
2002: if (((*s_objet_resultat).objet = analyse_flux(s_etat_processus,
2003: &(tampon[longueur_tampon - longueur_somme]),
2004: longueur_somme)) == NULL)
1.42 bertrand 2005: {
1.43 bertrand 2006: free(tampon);
1.42 bertrand 2007: free(fonction);
2008:
2009: liberation(s_etat_processus, s_objet_argument_1);
2010: liberation(s_etat_processus, s_objet_argument_2);
2011: return;
2012: }
2013:
1.43 bertrand 2014: free(tampon);
1.42 bertrand 2015: free(fonction);
1.41 bertrand 2016: }
2017: else
2018: {
2019: // Le chiffrement est de type HMAC
2020: // Le second élément de la chaîne contient la clef utilisée pour
2021: // la signature.
2022:
1.42 bertrand 2023: free(fonction);
2024:
1.41 bertrand 2025: l_element_courant = (*s_objet_argument_1).objet;
2026: l_element_courant = (*l_element_courant).suivant;
2027:
1.45 bertrand 2028: longueur_bloc = EVP_MD_block_size(EVP_sum);
2029:
1.41 bertrand 2030: if ((clef = formateur_flux(s_etat_processus, (unsigned char *)
2031: (*(*l_element_courant).donnee).objet, &longueur_clef))
2032: == NULL)
2033: {
2034: liberation(s_etat_processus, s_objet_argument_1);
2035: liberation(s_etat_processus, s_objet_argument_2);
2036: return;
2037: }
2038:
2039: if (longueur_clef < longueur_bloc)
2040: {
2041: longueur_tampon = longueur_clef;
2042: tampon = clef;
2043:
1.48 bertrand 2044: if ((clef = malloc(((size_t) longueur_bloc) *
2045: sizeof(unsigned char))) == NULL)
1.41 bertrand 2046: {
2047: (*s_etat_processus).erreur_systeme =
2048: d_es_allocation_memoire;
2049: return;
2050: }
2051:
1.48 bertrand 2052: memset(clef, 0, (size_t) longueur_bloc);
2053: memcpy(clef, tampon, (size_t) longueur_tampon);
1.41 bertrand 2054: longueur_clef = longueur_bloc;
2055: free(tampon);
2056: }
2057: else if (longueur_clef > longueur_bloc)
2058: {
2059: longueur_tampon = longueur_clef;
2060: tampon = clef;
2061:
1.48 bertrand 2062: if ((clef = malloc(((size_t) longueur_bloc) *
2063: sizeof(unsigned char))) == NULL)
1.41 bertrand 2064: {
2065: (*s_etat_processus).erreur_systeme =
2066: d_es_allocation_memoire;
2067: return;
2068: }
2069:
1.48 bertrand 2070: memcpy(clef, tampon, (size_t) longueur_bloc);
1.41 bertrand 2071: longueur_clef = longueur_bloc;
2072: free(tampon);
2073: }
2074:
2075: for(i = 0; i < longueur_bloc; i++)
2076: {
1.48 bertrand 2077: clef[i] ^= (unsigned char) 0x36;
1.41 bertrand 2078: }
2079:
2080: if ((chaine = formateur_flux(s_etat_processus, (unsigned char *)
2081: (*s_objet_argument_2).objet, &longueur_chaine)) == NULL)
2082: {
2083: liberation(s_etat_processus, s_objet_argument_1);
2084: liberation(s_etat_processus, s_objet_argument_2);
2085:
2086: return;
2087: }
2088:
1.48 bertrand 2089: if ((tampon = malloc(((size_t) (longueur_bloc + longueur_chaine)) *
1.41 bertrand 2090: sizeof(unsigned char))) == NULL)
2091: {
2092: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2093: return;
2094: }
2095:
1.48 bertrand 2096: memcpy(tampon, clef, (size_t) longueur_bloc);
2097: memcpy(tampon + longueur_bloc, chaine, (size_t) longueur_chaine);
1.41 bertrand 2098: longueur_tampon = longueur_bloc + longueur_chaine;
2099:
1.64 bertrand 2100: if ((contexte = EVP_MD_CTX_new()) == NULL)
2101: {
2102: liberation(s_etat_processus, s_objet_argument_1);
2103: liberation(s_etat_processus, s_objet_argument_2);
2104:
2105: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2106: return;
2107: }
2108:
2109: if (EVP_DigestInit(contexte, EVP_sum) != 1)
1.41 bertrand 2110: {
2111: free(tampon);
2112: free(clef);
2113: free(chaine);
2114:
1.64 bertrand 2115: EVP_MD_CTX_free(contexte);
1.41 bertrand 2116:
2117: liberation(s_etat_processus, s_objet_argument_1);
2118: liberation(s_etat_processus, s_objet_argument_2);
2119:
2120: (*s_etat_processus).erreur_execution = d_ex_chiffrement;
2121: return;
2122: }
2123:
1.64 bertrand 2124: if (EVP_DigestUpdate(contexte, tampon, (size_t) longueur_tampon)
1.48 bertrand 2125: != 1)
1.41 bertrand 2126: {
2127: free(tampon);
2128: free(clef);
2129: free(chaine);
2130:
1.64 bertrand 2131: EVP_MD_CTX_free(contexte);
1.41 bertrand 2132:
2133: liberation(s_etat_processus, s_objet_argument_1);
2134: liberation(s_etat_processus, s_objet_argument_2);
2135:
2136: (*s_etat_processus).erreur_execution = d_ex_chiffrement;
2137: return;
2138: }
2139:
2140: free(tampon);
2141:
1.64 bertrand 2142: if (EVP_DigestFinal_ex(contexte, somme, &longueur_somme) != 1)
1.41 bertrand 2143: {
2144: free(chaine);
1.64 bertrand 2145: EVP_MD_CTX_free(contexte);
1.41 bertrand 2146:
2147: liberation(s_etat_processus, s_objet_argument_1);
2148: liberation(s_etat_processus, s_objet_argument_2);
2149:
2150: (*s_etat_processus).erreur_execution = d_ex_chiffrement;
2151: return;
2152: }
2153:
1.64 bertrand 2154: EVP_MD_CTX_reset(contexte);
1.41 bertrand 2155:
2156: for(i = 0; i < longueur_bloc; i++)
2157: {
2158: clef[i] ^= (0x36 ^ 0x5c);
2159: }
2160:
1.48 bertrand 2161: if ((tampon = malloc(((size_t) (longueur_bloc + longueur_somme)) *
1.41 bertrand 2162: sizeof(unsigned char))) == NULL)
2163: {
2164: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2165: return;
2166: }
2167:
1.48 bertrand 2168: memcpy(tampon, clef, (size_t) longueur_bloc);
2169: memcpy(tampon + longueur_bloc, somme, (size_t) longueur_somme);
1.41 bertrand 2170: longueur_tampon = longueur_bloc + longueur_somme;
2171:
1.64 bertrand 2172: if (EVP_DigestInit(contexte, EVP_sum) != 1)
1.41 bertrand 2173: {
2174: free(tampon);
2175: free(clef);
2176: free(chaine);
2177:
1.64 bertrand 2178: EVP_MD_CTX_free(contexte);
1.41 bertrand 2179:
2180: liberation(s_etat_processus, s_objet_argument_1);
2181: liberation(s_etat_processus, s_objet_argument_2);
2182:
2183: (*s_etat_processus).erreur_execution = d_ex_chiffrement;
2184: return;
2185: }
2186:
1.64 bertrand 2187: if (EVP_DigestUpdate(contexte, tampon, (size_t) longueur_tampon)
1.48 bertrand 2188: != 1)
1.41 bertrand 2189: {
2190: free(tampon);
2191: free(clef);
2192: free(chaine);
2193:
1.64 bertrand 2194: EVP_MD_CTX_free(contexte);
1.41 bertrand 2195:
2196: liberation(s_etat_processus, s_objet_argument_1);
2197: liberation(s_etat_processus, s_objet_argument_2);
2198:
2199: (*s_etat_processus).erreur_execution = d_ex_chiffrement;
2200: return;
2201: }
2202:
2203: free(tampon);
2204:
1.64 bertrand 2205: if (EVP_DigestFinal_ex(contexte, somme, &longueur_somme) != 1)
1.41 bertrand 2206: {
2207: free(chaine);
1.64 bertrand 2208: EVP_MD_CTX_free(contexte);
1.41 bertrand 2209:
2210: liberation(s_etat_processus, s_objet_argument_1);
2211: liberation(s_etat_processus, s_objet_argument_2);
2212:
2213: (*s_etat_processus).erreur_execution = d_ex_chiffrement;
2214: return;
2215: }
2216:
1.64 bertrand 2217: EVP_MD_CTX_free(contexte);
1.41 bertrand 2218:
2219: free(chaine);
2220: free(clef);
2221:
2222: if ((s_objet_resultat = allocation(s_etat_processus, CHN)) == NULL)
2223: {
2224: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2225: return;
2226: }
2227:
2228: if (((*s_objet_resultat).objet = analyse_flux(s_etat_processus,
2229: somme, longueur_somme)) == NULL)
2230: {
2231: liberation(s_etat_processus, s_objet_argument_1);
2232: liberation(s_etat_processus, s_objet_argument_2);
2233:
2234: return;
2235: }
2236: }
1.39 bertrand 2237: }
2238: else
2239: {
2240: liberation(s_etat_processus, s_objet_argument_1);
2241: liberation(s_etat_processus, s_objet_argument_2);
2242:
2243: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
2244: return;
2245: }
2246:
2247: liberation(s_etat_processus, s_objet_argument_1);
2248: liberation(s_etat_processus, s_objet_argument_2);
2249:
2250: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
2251: s_objet_resultat) == d_erreur)
2252: {
2253: return;
2254: }
2255:
2256: return;
2257: }
2258:
1.1 bertrand 2259: // vim: ts=4