1: /*
2: ================================================================================
3: RPL/2 (R) version 4.1.12
4: Copyright (C) 1989-2012 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: 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:
342: unsigned long i;
343: unsigned long j;
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
412: = malloc((*((struct_vecteur *) (*s_objet_resultat).objet))
413: .taille * sizeof(integer8))) == NULL)
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
470: = malloc((*((struct_vecteur *) (*s_objet_resultat).objet))
471: .taille * sizeof(real8))) == NULL)
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
528: = malloc((*((struct_vecteur *) (*s_objet_resultat).objet))
529: .taille * sizeof(complex16))) == NULL)
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:
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: {
608: EVP_MD_CTX contexte;
609:
610: const EVP_MD * (*EVP_sum)();
611:
612: logical1 somme_invalide;
613:
614: long i;
615: long longueur_chaine;
616:
617: struct_liste_chainee *l_element_courant;
618:
619: struct_objet *s_objet_argument_1;
620: struct_objet *s_objet_argument_2;
621: struct_objet *s_objet_resultat;
622:
623: unsigned char *chaine;
624: unsigned char *clef;
625: unsigned char *fonction;
626: unsigned char somme[EVP_MAX_MD_SIZE];
627: unsigned char *tampon;
628:
629: unsigned int longueur_bloc;
630: unsigned int longueur_somme;
631: unsigned int longueur_tampon;
632:
633: unsigned long longueur_clef;
634:
635: (*s_etat_processus).erreur_execution = d_ex;
636:
637: if ((*s_etat_processus).affichage_arguments == 'Y')
638: {
639: printf("\n DIGEST ");
640:
641: if ((*s_etat_processus).langue == 'F')
642: {
643: printf("(somme d'authentification)\n\n");
644: }
645: else
646: {
647: printf("(hash algorithm)\n\n");
648: }
649:
650: printf(" 2: %s\n", d_CHN);
651: printf(" 1: %s\n", d_CHN);
652: printf("-> 1: %s\n\n", d_CHN);
653:
654: printf(" 2: %s\n", d_CHN);
655: printf(" 1: %s\n", d_LST);
656: printf("-> 1: %s\n\n", d_CHN);
657:
658: if ((*s_etat_processus).langue == 'F')
659: {
660: printf(" Algorithmes :\n\n");
661: }
662: else
663: {
664: printf(" Algorithms:\n\n");
665: }
666:
667: # ifndef OPENSSL_NO_SHA
668: printf(" - DSS\n");
669: printf(" - DSS1\n");
670: printf(" - ECDSA\n");
671: # endif
672: # ifndef OPENSSL_NO_MD2
673: printf(" - MD2\n");
674: # endif
675: # ifndef OPENSSL_NO_MD4
676: printf(" - MD4\n");
677: # endif
678: # ifndef OPENSSL_NO_MD5
679: printf(" - MD5\n");
680: # endif
681: # ifndef OPENSSL_NO_MDC2
682: printf(" - MDC2\n");
683: # endif
684: # ifndef OPENSSL_NO_RIPEMD
685: printf(" - RIPEMD160\n");
686: # endif
687: # ifndef OPENSSL_NO_SHA
688: printf(" - SHA\n");
689: printf(" - SHA1\n");
690: # endif
691: # ifndef OPENSSL_NO_SHA256
692: printf(" - SHA224\n");
693: printf(" - SHA256\n");
694: # endif
695: # ifndef OPENSSL_NO_SHA512
696: printf(" - SHA384\n");
697: printf(" - SHA512\n");
698: # endif
699: # ifndef OPENSSL_NO_WHIRLPOOL
700: printf(" - WHIRLPOOL\n");
701: # endif
702:
703: printf("\n");
704:
705: if ((*s_etat_processus).langue == 'F')
706: {
707: printf(" Utilisation :\n\n");
708: }
709: else
710: {
711: printf(" Usage:\n\n");
712: }
713:
714: printf(" \"text\" \"MD5\" DIGEST\n");
715: printf(" \"text\" { \"SHA384\" \"key\" } DIGEST\n");
716: printf(" \"text\" { \"AES-CBC\" \"key\" } DIGEST\n");
717: return;
718: }
719: else if ((*s_etat_processus).test_instruction == 'Y')
720: {
721: (*s_etat_processus).nombre_arguments = -1;
722: return;
723: }
724:
725: if (test_cfsf(s_etat_processus, 31) == d_vrai)
726: {
727: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
728: {
729: return;
730: }
731: }
732:
733: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
734: &s_objet_argument_1) == d_erreur)
735: {
736: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
737: return;
738: }
739:
740: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
741: &s_objet_argument_2) == d_erreur)
742: {
743: liberation(s_etat_processus, s_objet_argument_1);
744:
745: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
746: return;
747: }
748:
749: if (((*s_objet_argument_1).type == CHN) &&
750: ((*s_objet_argument_2).type == CHN))
751: {
752: // Liste des sommes disponibles :
753: // - EVP_dss
754: // - EVP_dss1
755: // - EVP_ecdsa
756: // - EVP_md2
757: // - EVP_md4
758: // - EVP_md5
759: // - EVP_mdc2
760: // - EVP_ripemd160
761: // - EVP_sha
762: // - EVP_sha1
763: // - EVP_sha224
764: // - EVP_sha256
765: // - EVP_sha384
766: // - EVP_sha512
767: // - EVP_whirlpool
768:
769: if ((fonction = conversion_majuscule((unsigned char *)
770: (*s_objet_argument_1).objet)) == NULL)
771: {
772: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
773: return;
774: }
775:
776: somme_invalide = d_faux;
777:
778: switch(fonction[0])
779: {
780: case 'D':
781: {
782: switch(fonction[1])
783: {
784: case 'S': // ds
785: {
786: switch(fonction[2])
787: {
788: # ifndef OPENSSL_NO_SHA
789: case 'S': // dss
790: {
791: switch(fonction[3])
792: {
793: case d_code_fin_chaine:
794: {
795: EVP_sum = EVP_dss;
796: break;
797: }
798:
799: case '1': // dss1
800: {
801: if (fonction[4] == d_code_fin_chaine)
802: {
803: EVP_sum = EVP_dss1;
804: }
805: else
806: {
807: somme_invalide = d_vrai;
808: }
809:
810: break;
811: }
812:
813: default:
814: {
815: somme_invalide = d_vrai;
816: break;
817: }
818: }
819:
820: break;
821: }
822: # endif
823:
824: default:
825: {
826: somme_invalide = d_vrai;
827: break;
828: }
829: }
830:
831: break;
832: }
833:
834: default:
835: {
836: somme_invalide = d_vrai;
837: break;
838: }
839: }
840:
841: break;
842: }
843:
844: case 'E':
845: {
846: switch(fonction[1])
847: {
848: case 'C': // ec
849: {
850: switch(fonction[2])
851: {
852: case 'D': // ecd
853: {
854: switch(fonction[3])
855: {
856: case 'S': // ecds
857: {
858: switch(fonction[4])
859: {
860: # ifndef OPENSSL_NO_SHA
861: case 'A': // ecdsa
862: {
863: if (fonction[5] ==
864: d_code_fin_chaine)
865: {
866: EVP_sum = EVP_ecdsa;
867: }
868: else
869: {
870: somme_invalide = d_vrai;
871: }
872:
873: break;
874: }
875: # endif
876:
877: default:
878: {
879: somme_invalide = d_vrai;
880: break;
881: }
882: }
883:
884: break;
885: }
886:
887: default:
888: {
889: somme_invalide = d_vrai;
890: break;
891: }
892: }
893:
894: break;
895: }
896:
897: default:
898: {
899: somme_invalide = d_vrai;
900: break;
901: }
902: }
903:
904: break;
905: }
906:
907: default:
908: {
909: somme_invalide = d_vrai;
910: break;
911: }
912: }
913:
914: break;
915: }
916:
917: case 'M':
918: {
919: switch(fonction[1])
920: {
921: case 'D': // md
922: {
923: switch(fonction[2])
924: {
925: # ifndef OPENSSL_NO_MD2
926: case '2': // md2
927: {
928: if (fonction[3] == d_code_fin_chaine)
929: {
930: EVP_sum = EVP_md2;
931: }
932: else
933: {
934: somme_invalide = d_vrai;
935: }
936:
937: break;
938: }
939: # endif
940:
941: # ifndef OPENSSL_NO_MD4
942: case '4': // md4
943: {
944: if (fonction[3] == d_code_fin_chaine)
945: {
946: EVP_sum = EVP_md4;
947: }
948: else
949: {
950: somme_invalide = d_vrai;
951: }
952:
953: break;
954: }
955: # endif
956:
957: # ifndef OPENSSL_NO_MD5
958: case '5': // md5
959: {
960: if (fonction[3] == d_code_fin_chaine)
961: {
962: EVP_sum = EVP_md5;
963: }
964: else
965: {
966: somme_invalide = d_vrai;
967: }
968:
969: break;
970: }
971: # endif
972:
973: case 'C': // mdc
974: {
975: switch(fonction[3])
976: {
977: # ifndef OPENSSL_NO_MDC2
978: case '2': // mdc2
979: {
980: if (fonction[4] == d_code_fin_chaine)
981: {
982: EVP_sum = EVP_mdc2;
983: }
984: else
985: {
986: somme_invalide = d_vrai;
987: }
988:
989: break;
990: }
991: # endif
992:
993: default:
994: {
995: somme_invalide = d_vrai;
996: break;
997: }
998: }
999:
1000: break;
1001: }
1002:
1003: default:
1004: {
1005: somme_invalide = d_vrai;
1006: break;
1007: }
1008: }
1009:
1010: break;
1011: }
1012:
1013: default:
1014: {
1015: somme_invalide = d_vrai;
1016: break;
1017: }
1018: }
1019:
1020: break;
1021: }
1022:
1023: # ifndef OPENSSL_NO_RIPEMD
1024: case 'R':
1025: {
1026: if (strcmp(fonction, "RIPEMD160") == 0)
1027: {
1028: EVP_sum = EVP_ripemd160;
1029: }
1030: else
1031: {
1032: somme_invalide = d_vrai;
1033: }
1034:
1035: break;
1036: }
1037: # endif
1038:
1039: case 'S':
1040: {
1041: switch(fonction[1])
1042: {
1043: case 'H': // sh
1044: {
1045: switch(fonction[2])
1046: {
1047: # ifndef OPENSSL_NO_SHA
1048: case 'A':
1049: {
1050: switch(fonction[3])
1051: {
1052: case d_code_fin_chaine:
1053: {
1054: EVP_sum = EVP_sha;
1055: break;
1056: }
1057:
1058: case '1': // sha1
1059: {
1060: if (fonction[4] == d_code_fin_chaine)
1061: {
1062: EVP_sum = EVP_sha1;
1063: }
1064: else
1065: {
1066: somme_invalide = d_vrai;
1067: }
1068:
1069: break;
1070: }
1071:
1072: # ifndef OPENSSL_NO_SHA256
1073: case '2': // sha2
1074: {
1075: switch(fonction[4])
1076: {
1077: case '2': // sha22
1078: {
1079: switch(fonction[5])
1080: {
1081: case '4': // sha224
1082: {
1083: if (fonction[6] ==
1084: d_code_fin_chaine)
1085: {
1086: EVP_sum =
1087: EVP_sha224;
1088: }
1089: else
1090: {
1091: somme_invalide =
1092: d_vrai;
1093: }
1094:
1095: break;
1096: }
1097:
1098: default:
1099: {
1100: somme_invalide = d_vrai;
1101: break;
1102: }
1103: }
1104:
1105: break;
1106: }
1107:
1108: case '5':
1109: {
1110: switch(fonction[5])
1111: {
1112: case '6': // sha256
1113: {
1114: if (fonction[6] ==
1115: d_code_fin_chaine)
1116: {
1117: EVP_sum =
1118: EVP_sha256;
1119: }
1120: else
1121: {
1122: somme_invalide =
1123: d_vrai;
1124: }
1125:
1126: break;
1127: }
1128:
1129: default:
1130: {
1131: somme_invalide = d_vrai;
1132: break;
1133: }
1134: }
1135:
1136: break;
1137: }
1138:
1139: default:
1140: {
1141: somme_invalide = d_vrai;
1142: break;
1143: }
1144: }
1145:
1146: break;
1147: }
1148: # endif
1149:
1150: # ifndef OPENSSL_NO_SHA512
1151: case '3': // sha3
1152: {
1153: switch(fonction[4])
1154: {
1155: case '8': // sha38
1156: {
1157: switch(fonction[5])
1158: {
1159: case '4': // sha384
1160: {
1161: if (fonction[6] ==
1162: d_code_fin_chaine)
1163: {
1164: EVP_sum =
1165: EVP_sha384;
1166: }
1167: else
1168: {
1169: somme_invalide =
1170: d_vrai;
1171: }
1172:
1173: break;
1174: }
1175:
1176: default:
1177: {
1178: somme_invalide = d_vrai;
1179: break;
1180: }
1181: }
1182:
1183: break;
1184: }
1185:
1186: default:
1187: {
1188: somme_invalide = d_vrai;
1189: break;
1190: }
1191: }
1192:
1193: break;
1194: }
1195:
1196: case '5': // sha5
1197: {
1198: switch(fonction[4])
1199: {
1200: case '1': // sha51
1201: {
1202: switch(fonction[5])
1203: {
1204: case '2': // sha512
1205: {
1206: if (fonction[6] ==
1207: d_code_fin_chaine)
1208: {
1209: EVP_sum =
1210: EVP_sha512;
1211: }
1212: else
1213: {
1214: somme_invalide =
1215: d_vrai;
1216: }
1217:
1218: break;
1219: }
1220:
1221: default:
1222: {
1223: somme_invalide = d_vrai;
1224: break;
1225: }
1226: }
1227:
1228: break;
1229: }
1230:
1231: default:
1232: {
1233: somme_invalide = d_vrai;
1234: break;
1235: }
1236: }
1237:
1238: break;
1239: }
1240: # endif
1241:
1242: default:
1243: {
1244: somme_invalide = d_vrai;
1245: break;
1246: }
1247: }
1248:
1249: break;
1250: }
1251: # endif
1252:
1253: default:
1254: {
1255: somme_invalide = d_vrai;
1256: break;
1257: }
1258: }
1259:
1260: break;
1261: }
1262:
1263: default:
1264: {
1265: somme_invalide = d_vrai;
1266: break;
1267: }
1268: }
1269:
1270: break;
1271: }
1272:
1273: # ifndef OPENSSL_NO_WHIRLPOOL
1274: case 'W':
1275: {
1276: if (strcmp(fonction, "WHIRLPOOL") == 0)
1277: {
1278: EVP_sum = EVP_whirlpool;
1279: }
1280: else
1281: {
1282: somme_invalide = d_vrai;
1283: }
1284:
1285: break;
1286: }
1287: # endif
1288:
1289: default:
1290: {
1291: somme_invalide = d_vrai;
1292: break;
1293: }
1294: }
1295:
1296: free(fonction);
1297:
1298: if (somme_invalide == d_vrai)
1299: {
1300: liberation(s_etat_processus, s_objet_argument_1);
1301: liberation(s_etat_processus, s_objet_argument_2);
1302:
1303: (*s_etat_processus).erreur_execution =
1304: d_ex_chiffrement_indisponible;
1305: return;
1306: }
1307:
1308: if (EVP_DigestInit(&contexte, EVP_sum()) != 1)
1309: {
1310: EVP_MD_CTX_cleanup(&contexte);
1311:
1312: liberation(s_etat_processus, s_objet_argument_1);
1313: liberation(s_etat_processus, s_objet_argument_2);
1314:
1315: (*s_etat_processus).erreur_execution = d_ex_chiffrement;
1316: return;
1317: }
1318:
1319: if ((chaine = formateur_flux(s_etat_processus, (unsigned char *)
1320: (*s_objet_argument_2).objet, &longueur_chaine)) == NULL)
1321: {
1322: EVP_MD_CTX_cleanup(&contexte);
1323:
1324: liberation(s_etat_processus, s_objet_argument_1);
1325: liberation(s_etat_processus, s_objet_argument_2);
1326:
1327: return;
1328: }
1329:
1330: if (EVP_DigestUpdate(&contexte, chaine, longueur_chaine) != 1)
1331: {
1332: free(chaine);
1333: EVP_MD_CTX_cleanup(&contexte);
1334:
1335: liberation(s_etat_processus, s_objet_argument_1);
1336: liberation(s_etat_processus, s_objet_argument_2);
1337:
1338: (*s_etat_processus).erreur_execution = d_ex_chiffrement;
1339: return;
1340: }
1341:
1342: if (EVP_DigestFinal_ex(&contexte, somme, &longueur_somme) != 1)
1343: {
1344: free(chaine);
1345: EVP_MD_CTX_cleanup(&contexte);
1346:
1347: liberation(s_etat_processus, s_objet_argument_1);
1348: liberation(s_etat_processus, s_objet_argument_2);
1349:
1350: (*s_etat_processus).erreur_execution = d_ex_chiffrement;
1351: return;
1352: }
1353:
1354: free(chaine);
1355: EVP_MD_CTX_cleanup(&contexte);
1356:
1357: if ((s_objet_resultat = allocation(s_etat_processus, CHN)) == NULL)
1358: {
1359: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1360: return;
1361: }
1362:
1363: if (((*s_objet_resultat).objet = analyse_flux(s_etat_processus,
1364: somme, longueur_somme)) == NULL)
1365: {
1366: liberation(s_etat_processus, s_objet_argument_1);
1367: liberation(s_etat_processus, s_objet_argument_2);
1368:
1369: return;
1370: }
1371: }
1372: else if (((*s_objet_argument_1).type == LST) &&
1373: ((*s_objet_argument_2).type == CHN))
1374: {
1375: l_element_courant = (*s_objet_argument_1).objet;
1376:
1377: if ((*(*l_element_courant).donnee).type != CHN)
1378: {
1379: liberation(s_etat_processus, s_objet_argument_1);
1380: liberation(s_etat_processus, s_objet_argument_2);
1381:
1382: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1383: return;
1384: }
1385:
1386: l_element_courant = (*l_element_courant).suivant;
1387:
1388: if (l_element_courant == NULL)
1389: {
1390: liberation(s_etat_processus, s_objet_argument_1);
1391: liberation(s_etat_processus, s_objet_argument_2);
1392:
1393: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
1394: return;
1395: }
1396:
1397: if ((*(*l_element_courant).donnee).type != CHN)
1398: {
1399: liberation(s_etat_processus, s_objet_argument_1);
1400: liberation(s_etat_processus, s_objet_argument_2);
1401:
1402: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
1403: return;
1404: }
1405:
1406: if ((*l_element_courant).suivant != NULL)
1407: {
1408: liberation(s_etat_processus, s_objet_argument_1);
1409: liberation(s_etat_processus, s_objet_argument_2);
1410:
1411: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
1412: return;
1413: }
1414:
1415: // Test du type de somme de contrôle
1416: // - les sommes classiques suivent la RFC 2104
1417: // - les autres sont formées sur des algorithmes de type CBC
1418:
1419: l_element_courant = (*s_objet_argument_1).objet;
1420:
1421: if ((fonction = conversion_majuscule((unsigned char *)
1422: (*(*l_element_courant).donnee).objet)) == NULL)
1423: {
1424: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
1425: return;
1426: }
1427:
1428: somme_invalide = d_faux;
1429:
1430: switch(fonction[0])
1431: {
1432: case 'D':
1433: {
1434: switch(fonction[1])
1435: {
1436: case 'S': // ds
1437: {
1438: switch(fonction[2])
1439: {
1440: # ifndef OPENSSL_NO_SHA
1441: case 'S': // dss
1442: {
1443: switch(fonction[3])
1444: {
1445: case d_code_fin_chaine:
1446: {
1447: EVP_sum = EVP_dss;
1448: longueur_bloc = SHA_CBLOCK;
1449: break;
1450: }
1451:
1452: case '1': // dss1
1453: {
1454: if (fonction[4] == d_code_fin_chaine)
1455: {
1456: EVP_sum = EVP_dss1;
1457: longueur_bloc = SHA_CBLOCK;
1458: }
1459: else
1460: {
1461: somme_invalide = d_vrai;
1462: }
1463:
1464: break;
1465: }
1466:
1467: default:
1468: {
1469: somme_invalide = d_vrai;
1470: break;
1471: }
1472: }
1473:
1474: break;
1475: }
1476: # endif
1477:
1478: default:
1479: {
1480: somme_invalide = d_vrai;
1481: break;
1482: }
1483: }
1484:
1485: break;
1486: }
1487:
1488: default:
1489: {
1490: somme_invalide = d_vrai;
1491: break;
1492: }
1493: }
1494:
1495: break;
1496: }
1497:
1498: case 'E':
1499: {
1500: switch(fonction[1])
1501: {
1502: case 'C': // ec
1503: {
1504: switch(fonction[2])
1505: {
1506: case 'D': // ecd
1507: {
1508: switch(fonction[3])
1509: {
1510: case 'S': // ecds
1511: {
1512: switch(fonction[4])
1513: {
1514: # ifndef OPENSSL_NO_SHA
1515: case 'A': // ecdsa
1516: {
1517: if (fonction[5] ==
1518: d_code_fin_chaine)
1519: {
1520: EVP_sum = EVP_ecdsa;
1521: longueur_bloc = SHA_CBLOCK;
1522: }
1523: else
1524: {
1525: somme_invalide = d_vrai;
1526: }
1527:
1528: break;
1529: }
1530: # endif
1531:
1532: default:
1533: {
1534: somme_invalide = d_vrai;
1535: break;
1536: }
1537: }
1538:
1539: break;
1540: }
1541:
1542: default:
1543: {
1544: somme_invalide = d_vrai;
1545: break;
1546: }
1547: }
1548:
1549: break;
1550: }
1551:
1552: default:
1553: {
1554: somme_invalide = d_vrai;
1555: break;
1556: }
1557: }
1558:
1559: break;
1560: }
1561:
1562: default:
1563: {
1564: somme_invalide = d_vrai;
1565: break;
1566: }
1567: }
1568:
1569: break;
1570: }
1571:
1572: case 'M':
1573: {
1574: switch(fonction[1])
1575: {
1576: case 'D': // md
1577: {
1578: switch(fonction[2])
1579: {
1580: # ifndef OPENSSL_NO_MD2
1581: case '2': // md2
1582: {
1583: if (fonction[3] == d_code_fin_chaine)
1584: {
1585: EVP_sum = EVP_md2;
1586: longueur_bloc = MD2_BLOCK;
1587: }
1588: else
1589: {
1590: somme_invalide = d_vrai;
1591: }
1592:
1593: break;
1594: }
1595: # endif
1596:
1597: # ifndef OPENSSL_NO_MD4
1598: case '4': // md4
1599: {
1600: if (fonction[3] == d_code_fin_chaine)
1601: {
1602: EVP_sum = EVP_md4;
1603: longueur_bloc = MD4_CBLOCK;
1604: }
1605: else
1606: {
1607: somme_invalide = d_vrai;
1608: }
1609:
1610: break;
1611: }
1612: # endif
1613:
1614: # ifndef OPENSSL_NO_MD5
1615: case '5': // md5
1616: {
1617: if (fonction[3] == d_code_fin_chaine)
1618: {
1619: EVP_sum = EVP_md5;
1620: longueur_bloc = MD5_CBLOCK;
1621: }
1622: else
1623: {
1624: somme_invalide = d_vrai;
1625: }
1626:
1627: break;
1628: }
1629: # endif
1630:
1631: case 'C': // mdc
1632: {
1633: switch(fonction[3])
1634: {
1635: # ifndef OPENSSL_NO_MDC2
1636: case '2': // mdc2
1637: {
1638: if (fonction[4] == d_code_fin_chaine)
1639: {
1640: EVP_sum = EVP_mdc2;
1641: longueur_bloc = MDC2_BLOCK;
1642: }
1643: else
1644: {
1645: somme_invalide = d_vrai;
1646: }
1647:
1648: break;
1649: }
1650: # endif
1651:
1652: default:
1653: {
1654: somme_invalide = d_vrai;
1655: break;
1656: }
1657: }
1658:
1659: break;
1660: }
1661:
1662: default:
1663: {
1664: somme_invalide = d_vrai;
1665: break;
1666: }
1667: }
1668:
1669: break;
1670: }
1671:
1672: default:
1673: {
1674: somme_invalide = d_vrai;
1675: break;
1676: }
1677: }
1678:
1679: break;
1680: }
1681:
1682: # ifndef OPENSSL_NO_RIPEMD
1683: case 'R':
1684: {
1685: if (strcmp(fonction, "RIPEMD160") == 0)
1686: {
1687: EVP_sum = EVP_ripemd160;
1688: longueur_bloc = RIPEMD160_CBLOCK;
1689: }
1690: else
1691: {
1692: somme_invalide = d_vrai;
1693: }
1694:
1695: break;
1696: }
1697: # endif
1698:
1699: case 'S':
1700: {
1701: switch(fonction[1])
1702: {
1703: case 'H': // sh
1704: {
1705: switch(fonction[2])
1706: {
1707: # ifndef OPENSSL_NO_SHA
1708: case 'A':
1709: {
1710: switch(fonction[3])
1711: {
1712: case d_code_fin_chaine:
1713: {
1714: EVP_sum = EVP_sha;
1715: longueur_bloc = SHA_CBLOCK;
1716: break;
1717: }
1718:
1719: case '1': // sha1
1720: {
1721: if (fonction[4] == d_code_fin_chaine)
1722: {
1723: EVP_sum = EVP_sha1;
1724: longueur_bloc = SHA_CBLOCK;
1725: }
1726: else
1727: {
1728: somme_invalide = d_vrai;
1729: }
1730:
1731: break;
1732: }
1733:
1734: # ifndef OPENSSL_NO_SHA256
1735: case '2': // sha2
1736: {
1737: switch(fonction[4])
1738: {
1739: case '2': // sha22
1740: {
1741: switch(fonction[5])
1742: {
1743: case '4': // sha224
1744: {
1745: if (fonction[6] ==
1746: d_code_fin_chaine)
1747: {
1748: EVP_sum =
1749: EVP_sha224;
1750: longueur_bloc =
1751: SHA256_CBLOCK;
1752: }
1753: else
1754: {
1755: somme_invalide =
1756: d_vrai;
1757: }
1758:
1759: break;
1760: }
1761:
1762: default:
1763: {
1764: somme_invalide = d_vrai;
1765: break;
1766: }
1767: }
1768:
1769: break;
1770: }
1771:
1772: case '5':
1773: {
1774: switch(fonction[5])
1775: {
1776: case '6': // sha256
1777: {
1778: if (fonction[6] ==
1779: d_code_fin_chaine)
1780: {
1781: EVP_sum =
1782: EVP_sha256;
1783: longueur_bloc =
1784: SHA256_CBLOCK;
1785: }
1786: else
1787: {
1788: somme_invalide =
1789: d_vrai;
1790: }
1791:
1792: break;
1793: }
1794:
1795: default:
1796: {
1797: somme_invalide = d_vrai;
1798: break;
1799: }
1800: }
1801:
1802: break;
1803: }
1804:
1805: default:
1806: {
1807: somme_invalide = d_vrai;
1808: break;
1809: }
1810: }
1811:
1812: break;
1813: }
1814: # endif
1815:
1816: # ifndef OPENSSL_NO_SHA512
1817: case '3': // sha3
1818: {
1819: switch(fonction[4])
1820: {
1821: case '8': // sha38
1822: {
1823: switch(fonction[5])
1824: {
1825: case '4': // sha384
1826: {
1827: if (fonction[6] ==
1828: d_code_fin_chaine)
1829: {
1830: EVP_sum =
1831: EVP_sha384;
1832: longueur_bloc =
1833: SHA512_CBLOCK;
1834: }
1835: else
1836: {
1837: somme_invalide =
1838: d_vrai;
1839: }
1840:
1841: break;
1842: }
1843:
1844: default:
1845: {
1846: somme_invalide = d_vrai;
1847: break;
1848: }
1849: }
1850:
1851: break;
1852: }
1853:
1854: default:
1855: {
1856: somme_invalide = d_vrai;
1857: break;
1858: }
1859: }
1860:
1861: break;
1862: }
1863:
1864: case '5': // sha5
1865: {
1866: switch(fonction[4])
1867: {
1868: case '1': // sha51
1869: {
1870: switch(fonction[5])
1871: {
1872: case '2': // sha512
1873: {
1874: if (fonction[6] ==
1875: d_code_fin_chaine)
1876: {
1877: EVP_sum =
1878: EVP_sha512;
1879: longueur_bloc =
1880: SHA512_CBLOCK;
1881: }
1882: else
1883: {
1884: somme_invalide =
1885: d_vrai;
1886: }
1887:
1888: break;
1889: }
1890:
1891: default:
1892: {
1893: somme_invalide = d_vrai;
1894: break;
1895: }
1896: }
1897:
1898: break;
1899: }
1900:
1901: default:
1902: {
1903: somme_invalide = d_vrai;
1904: break;
1905: }
1906: }
1907:
1908: break;
1909: }
1910: # endif
1911:
1912: default:
1913: {
1914: somme_invalide = d_vrai;
1915: break;
1916: }
1917: }
1918:
1919: break;
1920: }
1921: # endif
1922:
1923: default:
1924: {
1925: somme_invalide = d_vrai;
1926: break;
1927: }
1928: }
1929:
1930: break;
1931: }
1932:
1933: default:
1934: {
1935: somme_invalide = d_vrai;
1936: break;
1937: }
1938: }
1939:
1940: break;
1941: }
1942:
1943: # ifndef OPENSSL_NO_WHIRLPOOL
1944: case 'W':
1945: {
1946: if (strcmp(fonction, "WHIRLPOOL") == 0)
1947: {
1948: EVP_sum = EVP_whirlpool;
1949: longueur_bloc = WHIRLPOOL_BBLOCK / 8;
1950: }
1951: else
1952: {
1953: somme_invalide = d_vrai;
1954: }
1955:
1956: break;
1957: }
1958: # endif
1959:
1960: default:
1961: {
1962: somme_invalide = d_vrai;
1963: break;
1964: }
1965: }
1966:
1967: free(fonction);
1968:
1969: if (somme_invalide == d_vrai)
1970: {
1971: // Le chiffrement est de type CBC-MAC
1972: BUG(1, uprintf("Oops!"));
1973: exit(0);
1974: }
1975: else
1976: {
1977: // Le chiffrement est de type HMAC
1978: // Le second élément de la chaîne contient la clef utilisée pour
1979: // la signature.
1980:
1981: l_element_courant = (*s_objet_argument_1).objet;
1982: l_element_courant = (*l_element_courant).suivant;
1983:
1984: if ((clef = formateur_flux(s_etat_processus, (unsigned char *)
1985: (*(*l_element_courant).donnee).objet, &longueur_clef))
1986: == NULL)
1987: {
1988: liberation(s_etat_processus, s_objet_argument_1);
1989: liberation(s_etat_processus, s_objet_argument_2);
1990: return;
1991: }
1992:
1993: if (longueur_clef < longueur_bloc)
1994: {
1995: longueur_tampon = longueur_clef;
1996: tampon = clef;
1997:
1998: if ((clef = malloc(longueur_bloc * sizeof(unsigned char)))
1999: == NULL)
2000: {
2001: (*s_etat_processus).erreur_systeme =
2002: d_es_allocation_memoire;
2003: return;
2004: }
2005:
2006: memset(clef, 0, longueur_bloc);
2007: memcpy(clef, tampon, longueur_tampon);
2008: longueur_clef = longueur_bloc;
2009: free(tampon);
2010: }
2011: else if (longueur_clef > longueur_bloc)
2012: {
2013: longueur_tampon = longueur_clef;
2014: tampon = clef;
2015:
2016: if ((clef = malloc(longueur_bloc * sizeof(unsigned char)))
2017: == NULL)
2018: {
2019: (*s_etat_processus).erreur_systeme =
2020: d_es_allocation_memoire;
2021: return;
2022: }
2023:
2024: memcpy(clef, tampon, longueur_bloc);
2025: longueur_clef = longueur_bloc;
2026: free(tampon);
2027: }
2028:
2029: for(i = 0; i < longueur_bloc; i++)
2030: {
2031: clef[i] ^= 0x36;
2032: }
2033:
2034: if ((chaine = formateur_flux(s_etat_processus, (unsigned char *)
2035: (*s_objet_argument_2).objet, &longueur_chaine)) == NULL)
2036: {
2037: EVP_MD_CTX_cleanup(&contexte);
2038:
2039: liberation(s_etat_processus, s_objet_argument_1);
2040: liberation(s_etat_processus, s_objet_argument_2);
2041:
2042: return;
2043: }
2044:
2045: if ((tampon = malloc((longueur_bloc + longueur_chaine) *
2046: sizeof(unsigned char))) == NULL)
2047: {
2048: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2049: return;
2050: }
2051:
2052: memcpy(tampon, clef, longueur_bloc);
2053: memcpy(tampon + longueur_bloc, chaine, longueur_chaine);
2054: longueur_tampon = longueur_bloc + longueur_chaine;
2055:
2056: if (EVP_DigestInit(&contexte, EVP_sum()) != 1)
2057: {
2058: free(tampon);
2059: free(clef);
2060: free(chaine);
2061:
2062: EVP_MD_CTX_cleanup(&contexte);
2063:
2064: liberation(s_etat_processus, s_objet_argument_1);
2065: liberation(s_etat_processus, s_objet_argument_2);
2066:
2067: (*s_etat_processus).erreur_execution = d_ex_chiffrement;
2068: return;
2069: }
2070:
2071: if (EVP_DigestUpdate(&contexte, tampon, longueur_tampon) != 1)
2072: {
2073: free(tampon);
2074: free(clef);
2075: free(chaine);
2076:
2077: EVP_MD_CTX_cleanup(&contexte);
2078:
2079: liberation(s_etat_processus, s_objet_argument_1);
2080: liberation(s_etat_processus, s_objet_argument_2);
2081:
2082: (*s_etat_processus).erreur_execution = d_ex_chiffrement;
2083: return;
2084: }
2085:
2086: free(tampon);
2087:
2088: if (EVP_DigestFinal_ex(&contexte, somme, &longueur_somme) != 1)
2089: {
2090: free(chaine);
2091: EVP_MD_CTX_cleanup(&contexte);
2092:
2093: liberation(s_etat_processus, s_objet_argument_1);
2094: liberation(s_etat_processus, s_objet_argument_2);
2095:
2096: (*s_etat_processus).erreur_execution = d_ex_chiffrement;
2097: return;
2098: }
2099:
2100: EVP_MD_CTX_cleanup(&contexte);
2101:
2102: for(i = 0; i < longueur_bloc; i++)
2103: {
2104: clef[i] ^= (0x36 ^ 0x5c);
2105: }
2106:
2107: if ((tampon = malloc((longueur_bloc + longueur_somme) *
2108: sizeof(unsigned char))) == NULL)
2109: {
2110: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2111: return;
2112: }
2113:
2114: memcpy(tampon, clef, longueur_bloc);
2115: memcpy(tampon + longueur_bloc, somme, longueur_somme);
2116: longueur_tampon = longueur_bloc + longueur_somme;
2117:
2118: if (EVP_DigestInit(&contexte, EVP_sum()) != 1)
2119: {
2120: free(tampon);
2121: free(clef);
2122: free(chaine);
2123:
2124: EVP_MD_CTX_cleanup(&contexte);
2125:
2126: liberation(s_etat_processus, s_objet_argument_1);
2127: liberation(s_etat_processus, s_objet_argument_2);
2128:
2129: (*s_etat_processus).erreur_execution = d_ex_chiffrement;
2130: return;
2131: }
2132:
2133: if (EVP_DigestUpdate(&contexte, tampon, longueur_tampon) != 1)
2134: {
2135: free(tampon);
2136: free(clef);
2137: free(chaine);
2138:
2139: EVP_MD_CTX_cleanup(&contexte);
2140:
2141: liberation(s_etat_processus, s_objet_argument_1);
2142: liberation(s_etat_processus, s_objet_argument_2);
2143:
2144: (*s_etat_processus).erreur_execution = d_ex_chiffrement;
2145: return;
2146: }
2147:
2148: free(tampon);
2149:
2150: if (EVP_DigestFinal_ex(&contexte, somme, &longueur_somme) != 1)
2151: {
2152: free(chaine);
2153: EVP_MD_CTX_cleanup(&contexte);
2154:
2155: liberation(s_etat_processus, s_objet_argument_1);
2156: liberation(s_etat_processus, s_objet_argument_2);
2157:
2158: (*s_etat_processus).erreur_execution = d_ex_chiffrement;
2159: return;
2160: }
2161:
2162: EVP_MD_CTX_cleanup(&contexte);
2163:
2164: free(chaine);
2165: free(clef);
2166:
2167: if ((s_objet_resultat = allocation(s_etat_processus, CHN)) == NULL)
2168: {
2169: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
2170: return;
2171: }
2172:
2173: if (((*s_objet_resultat).objet = analyse_flux(s_etat_processus,
2174: somme, longueur_somme)) == NULL)
2175: {
2176: liberation(s_etat_processus, s_objet_argument_1);
2177: liberation(s_etat_processus, s_objet_argument_2);
2178:
2179: return;
2180: }
2181: }
2182: }
2183: else
2184: {
2185: liberation(s_etat_processus, s_objet_argument_1);
2186: liberation(s_etat_processus, s_objet_argument_2);
2187:
2188: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
2189: return;
2190: }
2191:
2192: liberation(s_etat_processus, s_objet_argument_1);
2193: liberation(s_etat_processus, s_objet_argument_2);
2194:
2195: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
2196: s_objet_resultat) == d_erreur)
2197: {
2198: return;
2199: }
2200:
2201: return;
2202: }
2203:
2204: // vim: ts=4
CVSweb interface <joel.bertrand@systella.fr>
![[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