![[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.37 bertrand 3: RPL/2 (R) version 4.1.12
1.30 bertrand 4: Copyright (C) 1989-2012 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:
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:
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: {
! 608: EVP_MD_CTX contexte;
! 609:
! 610: const EVP_MD * (*EVP_sum)();
! 611:
! 612: logical1 somme_invalide;
! 613:
! 614: long longueur_chaine;
! 615:
! 616: struct_objet *s_objet_argument_1;
! 617: struct_objet *s_objet_argument_2;
! 618: struct_objet *s_objet_resultat;
! 619:
! 620: unsigned char *chaine;
! 621: unsigned char *fonction;
! 622: unsigned char somme[EVP_MAX_MD_SIZE];
! 623:
! 624: unsigned int longueur_somme;
! 625:
! 626: (*s_etat_processus).erreur_execution = d_ex;
! 627:
! 628: if ((*s_etat_processus).affichage_arguments == 'Y')
! 629: {
! 630: printf("\n DIGEST ");
! 631:
! 632: if ((*s_etat_processus).langue == 'F')
! 633: {
! 634: printf("(somme d'authentification)\n\n");
! 635: }
! 636: else
! 637: {
! 638: printf("(hash algorithm)\n\n");
! 639: }
! 640:
! 641: printf(" 2: %s\n", d_CHN);
! 642: printf(" 1: %s\n", d_CHN);
! 643: printf("-> 1: %s\n\n", d_CHN);
! 644:
! 645: printf(" 2: %s\n", d_CHN);
! 646: printf(" 1: %s\n", d_LST);
! 647: printf("-> 1: %s\n\n", d_CHN);
! 648:
! 649: if ((*s_etat_processus).langue == 'F')
! 650: {
! 651: printf(" Algorithmes :\n\n");
! 652: }
! 653: else
! 654: {
! 655: printf(" Algorithms:\n\n");
! 656: }
! 657:
! 658: # ifndef OPENSSL_NO_SHA
! 659: printf(" - DSS\n");
! 660: printf(" - DSS1\n");
! 661: printf(" - ECDSA\n");
! 662: # endif
! 663: # ifndef OPENSSL_NO_MD2
! 664: printf(" - MD2\n");
! 665: # endif
! 666: # ifndef OPENSSL_NO_MD4
! 667: printf(" - MD4\n");
! 668: # endif
! 669: # ifndef OPENSSL_NO_MD5
! 670: printf(" - MD5\n");
! 671: # endif
! 672: # ifndef OPENSSL_NO_SHA
! 673: printf(" - SHA\n");
! 674: printf(" - SHA1\n");
! 675: # endif
! 676:
! 677: return;
! 678: }
! 679: else if ((*s_etat_processus).test_instruction == 'Y')
! 680: {
! 681: (*s_etat_processus).nombre_arguments = -1;
! 682: return;
! 683: }
! 684:
! 685: if (test_cfsf(s_etat_processus, 31) == d_vrai)
! 686: {
! 687: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
! 688: {
! 689: return;
! 690: }
! 691: }
! 692:
! 693: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 694: &s_objet_argument_1) == d_erreur)
! 695: {
! 696: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 697: return;
! 698: }
! 699:
! 700: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 701: &s_objet_argument_2) == d_erreur)
! 702: {
! 703: liberation(s_etat_processus, s_objet_argument_1);
! 704:
! 705: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
! 706: return;
! 707: }
! 708:
! 709: if (((*s_objet_argument_1).type == CHN) &&
! 710: ((*s_objet_argument_2).type == CHN))
! 711: {
! 712: // Liste des sommes disponibles :
! 713: // - EVP_dss
! 714: // - EVP_dss1
! 715: // - EVP_ecdsa
! 716: // - EVP_md2
! 717: // - EVP_md4
! 718: // - EVP_md5
! 719: // - EVP_mdc2
! 720: // - EVP_ripemd160
! 721: // - EVP_sha
! 722: // - EVP_sha1
! 723: // - EVP_sha224
! 724: // - EVP_sha256
! 725: // - EVP_sha384
! 726: // - EVP_sha512
! 727: // - EVP_whirlpool
! 728:
! 729: if ((fonction = conversion_majuscule((unsigned char *)
! 730: (*s_objet_argument_1).objet)) == NULL)
! 731: {
! 732: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 733: return;
! 734: }
! 735:
! 736: somme_invalide = d_faux;
! 737:
! 738: switch(fonction[0])
! 739: {
! 740: case 'D':
! 741: {
! 742: switch(fonction[1])
! 743: {
! 744: case 'S': // ds
! 745: {
! 746: switch(fonction[2])
! 747: {
! 748: # ifndef OPENSSL_NO_SHA
! 749: case 'S': // dss
! 750: {
! 751: switch(fonction[3])
! 752: {
! 753: case d_code_fin_chaine:
! 754: {
! 755: EVP_sum = EVP_dss;
! 756: break;
! 757: }
! 758:
! 759: case '1': // dss1
! 760: {
! 761: if (fonction[4] == d_code_fin_chaine)
! 762: {
! 763: EVP_sum = EVP_dss1;
! 764: }
! 765: else
! 766: {
! 767: somme_invalide = d_vrai;
! 768: }
! 769:
! 770: break;
! 771: }
! 772:
! 773: default:
! 774: {
! 775: somme_invalide = d_vrai;
! 776: break;
! 777: }
! 778: }
! 779:
! 780: break;
! 781: }
! 782: # endif
! 783:
! 784: default:
! 785: {
! 786: somme_invalide = d_vrai;
! 787: break;
! 788: }
! 789: }
! 790:
! 791: break;
! 792: }
! 793:
! 794: default:
! 795: {
! 796: somme_invalide = d_vrai;
! 797: break;
! 798: }
! 799: }
! 800:
! 801: break;
! 802: }
! 803:
! 804: case 'E':
! 805: {
! 806: switch(fonction[1])
! 807: {
! 808: case 'C': // ec
! 809: {
! 810: switch(fonction[2])
! 811: {
! 812: case 'D': // ecd
! 813: {
! 814: switch(fonction[3])
! 815: {
! 816: case 'S': // ecds
! 817: {
! 818: switch(fonction[4])
! 819: {
! 820: # ifndef OPENSSL_NO_SHA
! 821: case 'A': // ecdsa
! 822: {
! 823: if (fonction[5] ==
! 824: d_code_fin_chaine)
! 825: {
! 826: EVP_sum = EVP_ecdsa;
! 827: }
! 828: else
! 829: {
! 830: somme_invalide = d_vrai;
! 831: }
! 832:
! 833: break;
! 834: }
! 835: # endif
! 836:
! 837: default:
! 838: {
! 839: somme_invalide = d_vrai;
! 840: break;
! 841: }
! 842: }
! 843:
! 844: break;
! 845: }
! 846:
! 847: default:
! 848: {
! 849: somme_invalide = d_vrai;
! 850: break;
! 851: }
! 852: }
! 853:
! 854: break;
! 855: }
! 856:
! 857: default:
! 858: {
! 859: somme_invalide = d_vrai;
! 860: break;
! 861: }
! 862: }
! 863:
! 864: break;
! 865: }
! 866:
! 867: default:
! 868: {
! 869: somme_invalide = d_vrai;
! 870: break;
! 871: }
! 872: }
! 873:
! 874: break;
! 875: }
! 876:
! 877: case 'M':
! 878: {
! 879: switch(fonction[1])
! 880: {
! 881: case 'D': // md
! 882: {
! 883: switch(fonction[2])
! 884: {
! 885: # ifndef OPENSSL_NO_MD2
! 886: case '2': // md2
! 887: {
! 888: if (fonction[3] == d_code_fin_chaine)
! 889: {
! 890: EVP_sum = EVP_md2;
! 891: }
! 892: else
! 893: {
! 894: somme_invalide = d_vrai;
! 895: }
! 896:
! 897: break;
! 898: }
! 899: # endif
! 900:
! 901: # ifndef OPENSSL_NO_MD4
! 902: case '4': // md4
! 903: {
! 904: if (fonction[3] == d_code_fin_chaine)
! 905: {
! 906: EVP_sum = EVP_md4;
! 907: }
! 908: else
! 909: {
! 910: somme_invalide = d_vrai;
! 911: }
! 912:
! 913: break;
! 914: }
! 915: # endif
! 916:
! 917: # ifndef OPENSSL_NO_MD4
! 918: case '5': // md5
! 919: {
! 920: if (fonction[3] == d_code_fin_chaine)
! 921: {
! 922: EVP_sum = EVP_md5;
! 923: }
! 924: else
! 925: {
! 926: somme_invalide = d_vrai;
! 927: }
! 928:
! 929: break;
! 930: }
! 931: # endif
! 932:
! 933: case 'C': // mdc
! 934: {
! 935: switch(fonction[3])
! 936: {
! 937: # ifndef OPENSSL_NO_MDC2
! 938: case '2': // mdc2
! 939: {
! 940: if (fonction[4] == d_code_fin_chaine)
! 941: {
! 942: EVP_sum = EVP_mdc2;
! 943: }
! 944: else
! 945: {
! 946: somme_invalide = d_vrai;
! 947: }
! 948:
! 949: break;
! 950: }
! 951: # endif
! 952:
! 953: default:
! 954: {
! 955: somme_invalide = d_vrai;
! 956: break;
! 957: }
! 958: }
! 959:
! 960: break;
! 961: }
! 962:
! 963: default:
! 964: {
! 965: somme_invalide = d_vrai;
! 966: break;
! 967: }
! 968: }
! 969:
! 970: break;
! 971: }
! 972:
! 973: default:
! 974: {
! 975: somme_invalide = d_vrai;
! 976: break;
! 977: }
! 978: }
! 979:
! 980: break;
! 981: }
! 982:
! 983: # ifndef OPENSSL_NO_RIPEMD
! 984: case 'R':
! 985: {
! 986: if (strcmp(fonction, "RIPEMD160") == 0)
! 987: {
! 988: EVP_sum = EVP_ripemd160;
! 989: }
! 990: else
! 991: {
! 992: somme_invalide = d_vrai;
! 993: }
! 994:
! 995: break;
! 996: }
! 997: # endif
! 998:
! 999: case 'S':
! 1000: {
! 1001: switch(fonction[1])
! 1002: {
! 1003: case 'H': // sh
! 1004: {
! 1005: switch(fonction[2])
! 1006: {
! 1007: # ifndef OPENSSL_NO_SHA
! 1008: case 'A':
! 1009: {
! 1010: switch(fonction[3])
! 1011: {
! 1012: case d_code_fin_chaine:
! 1013: {
! 1014: EVP_sum = EVP_sha;
! 1015: break;
! 1016: }
! 1017:
! 1018: case '1': // sha1
! 1019: {
! 1020: if (fonction[4] == d_code_fin_chaine)
! 1021: {
! 1022: EVP_sum = EVP_sha1;
! 1023: }
! 1024: else
! 1025: {
! 1026: somme_invalide = d_vrai;
! 1027: }
! 1028:
! 1029: break;
! 1030: }
! 1031:
! 1032: # ifndef OPENSSL_NO_SHA256
! 1033: case '2': // sha2
! 1034: {
! 1035: switch(fonction[4])
! 1036: {
! 1037: case '2': // sha22
! 1038: {
! 1039: switch(fonction[5])
! 1040: {
! 1041: case '4': // sha224
! 1042: {
! 1043: if (fonction[6] ==
! 1044: d_code_fin_chaine)
! 1045: {
! 1046: EVP_sum =
! 1047: EVP_sha224;
! 1048: }
! 1049: else
! 1050: {
! 1051: somme_invalide =
! 1052: d_vrai;
! 1053: }
! 1054:
! 1055: break;
! 1056: }
! 1057:
! 1058: default:
! 1059: {
! 1060: somme_invalide = d_vrai;
! 1061: break;
! 1062: }
! 1063: }
! 1064:
! 1065: break;
! 1066: }
! 1067:
! 1068: case '5':
! 1069: {
! 1070: switch(fonction[5])
! 1071: {
! 1072: case '6': // sha256
! 1073: {
! 1074: if (fonction[6] ==
! 1075: d_code_fin_chaine)
! 1076: {
! 1077: EVP_sum =
! 1078: EVP_sha256;
! 1079: }
! 1080: else
! 1081: {
! 1082: somme_invalide =
! 1083: d_vrai;
! 1084: }
! 1085:
! 1086: break;
! 1087: }
! 1088:
! 1089: default:
! 1090: {
! 1091: somme_invalide = d_vrai;
! 1092: break;
! 1093: }
! 1094: }
! 1095:
! 1096: break;
! 1097: }
! 1098:
! 1099: default:
! 1100: {
! 1101: somme_invalide = d_vrai;
! 1102: break;
! 1103: }
! 1104: }
! 1105:
! 1106: break;
! 1107: }
! 1108: # endif
! 1109:
! 1110: # ifndef OPENSSL_NO_SHA512
! 1111: case '3': // sha3
! 1112: {
! 1113: switch(fonction[4])
! 1114: {
! 1115: case '8': // sha38
! 1116: {
! 1117: switch(fonction[5])
! 1118: {
! 1119: case '4': // sha384
! 1120: {
! 1121: if (fonction[6] ==
! 1122: d_code_fin_chaine)
! 1123: {
! 1124: EVP_sum =
! 1125: EVP_sha384;
! 1126: }
! 1127: else
! 1128: {
! 1129: somme_invalide =
! 1130: d_vrai;
! 1131: }
! 1132:
! 1133: break;
! 1134: }
! 1135:
! 1136: default:
! 1137: {
! 1138: somme_invalide = d_vrai;
! 1139: break;
! 1140: }
! 1141: }
! 1142:
! 1143: break;
! 1144: }
! 1145:
! 1146: default:
! 1147: {
! 1148: somme_invalide = d_vrai;
! 1149: break;
! 1150: }
! 1151: }
! 1152:
! 1153: break;
! 1154: }
! 1155:
! 1156: case '5': // sha5
! 1157: {
! 1158: switch(fonction[4])
! 1159: {
! 1160: case '1': // sha51
! 1161: {
! 1162: switch(fonction[5])
! 1163: {
! 1164: case '2': // sha512
! 1165: {
! 1166: if (fonction[6] ==
! 1167: d_code_fin_chaine)
! 1168: {
! 1169: EVP_sum =
! 1170: EVP_sha512;
! 1171: }
! 1172: else
! 1173: {
! 1174: somme_invalide =
! 1175: d_vrai;
! 1176: }
! 1177:
! 1178: break;
! 1179: }
! 1180:
! 1181: default:
! 1182: {
! 1183: somme_invalide = d_vrai;
! 1184: break;
! 1185: }
! 1186: }
! 1187:
! 1188: break;
! 1189: }
! 1190:
! 1191: default:
! 1192: {
! 1193: somme_invalide = d_vrai;
! 1194: break;
! 1195: }
! 1196: }
! 1197:
! 1198: break;
! 1199: }
! 1200: # endif
! 1201:
! 1202: default:
! 1203: {
! 1204: somme_invalide = d_vrai;
! 1205: break;
! 1206: }
! 1207: }
! 1208:
! 1209: break;
! 1210: }
! 1211: # endif
! 1212:
! 1213: default:
! 1214: {
! 1215: somme_invalide = d_vrai;
! 1216: break;
! 1217: }
! 1218: }
! 1219:
! 1220: break;
! 1221: }
! 1222:
! 1223: default:
! 1224: {
! 1225: somme_invalide = d_vrai;
! 1226: break;
! 1227: }
! 1228: }
! 1229:
! 1230: break;
! 1231: }
! 1232:
! 1233: # ifndef OPENSSL_NO_WHIRLPOOL
! 1234: case 'W':
! 1235: {
! 1236: if (strcmp(fonction, "WHIRLPOOL") == 0)
! 1237: {
! 1238: EVP_sum = EVP_whirlpool;
! 1239: }
! 1240: else
! 1241: {
! 1242: somme_invalide = d_vrai;
! 1243: }
! 1244:
! 1245: break;
! 1246: }
! 1247: # endif
! 1248:
! 1249: default:
! 1250: {
! 1251: somme_invalide = d_vrai;
! 1252: break;
! 1253: }
! 1254: }
! 1255:
! 1256: free(fonction);
! 1257:
! 1258: if (somme_invalide == d_vrai)
! 1259: {
! 1260: liberation(s_etat_processus, s_objet_argument_1);
! 1261: liberation(s_etat_processus, s_objet_argument_2);
! 1262:
! 1263: (*s_etat_processus).erreur_execution =
! 1264: d_ex_chiffrement_indisponible;
! 1265: return;
! 1266: }
! 1267:
! 1268: if (EVP_DigestInit(&contexte, EVP_sum()) != 1)
! 1269: {
! 1270: EVP_MD_CTX_cleanup(&contexte);
! 1271:
! 1272: liberation(s_etat_processus, s_objet_argument_1);
! 1273: liberation(s_etat_processus, s_objet_argument_2);
! 1274:
! 1275: (*s_etat_processus).erreur_execution = d_ex_chiffrement;
! 1276: return;
! 1277: }
! 1278:
! 1279: if ((chaine = formateur_flux(s_etat_processus, (unsigned char *)
! 1280: (*s_objet_argument_2).objet, &longueur_chaine)) == NULL)
! 1281: {
! 1282: EVP_MD_CTX_cleanup(&contexte);
! 1283:
! 1284: liberation(s_etat_processus, s_objet_argument_1);
! 1285: liberation(s_etat_processus, s_objet_argument_2);
! 1286:
! 1287: return;
! 1288: }
! 1289:
! 1290: if (EVP_DigestUpdate(&contexte, chaine, longueur_chaine) != 1)
! 1291: {
! 1292: free(chaine);
! 1293: EVP_MD_CTX_cleanup(&contexte);
! 1294:
! 1295: liberation(s_etat_processus, s_objet_argument_1);
! 1296: liberation(s_etat_processus, s_objet_argument_2);
! 1297:
! 1298: (*s_etat_processus).erreur_execution = d_ex_chiffrement;
! 1299: return;
! 1300: }
! 1301:
! 1302: if (EVP_DigestFinal_ex(&contexte, somme, &longueur_somme) != 1)
! 1303: {
! 1304: free(chaine);
! 1305: EVP_MD_CTX_cleanup(&contexte);
! 1306:
! 1307: liberation(s_etat_processus, s_objet_argument_1);
! 1308: liberation(s_etat_processus, s_objet_argument_2);
! 1309:
! 1310: (*s_etat_processus).erreur_execution = d_ex_chiffrement;
! 1311: return;
! 1312: }
! 1313:
! 1314: free(chaine);
! 1315: EVP_MD_CTX_cleanup(&contexte);
! 1316:
! 1317: if ((s_objet_resultat = allocation(s_etat_processus, CHN)) == NULL)
! 1318: {
! 1319: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
! 1320: return;
! 1321: }
! 1322:
! 1323: if (((*s_objet_resultat).objet = analyse_flux(s_etat_processus,
! 1324: somme, longueur_somme)) == NULL)
! 1325: {
! 1326: liberation(s_etat_processus, s_objet_argument_1);
! 1327: liberation(s_etat_processus, s_objet_argument_2);
! 1328:
! 1329: return;
! 1330: }
! 1331: }
! 1332: else if (((*s_objet_argument_1).type == CHN) &&
! 1333: ((*s_objet_argument_2).type == LST))
! 1334: {
! 1335: BUG(1, uprintf("Oops\n"));
! 1336: s_objet_resultat = NULL;
! 1337: }
! 1338: else
! 1339: {
! 1340: liberation(s_etat_processus, s_objet_argument_1);
! 1341: liberation(s_etat_processus, s_objet_argument_2);
! 1342:
! 1343: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
! 1344: return;
! 1345: }
! 1346:
! 1347: liberation(s_etat_processus, s_objet_argument_1);
! 1348: liberation(s_etat_processus, s_objet_argument_2);
! 1349:
! 1350: if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
! 1351: s_objet_resultat) == d_erreur)
! 1352: {
! 1353: return;
! 1354: }
! 1355:
! 1356: return;
! 1357: }
! 1358:
1.1 bertrand 1359: // vim: ts=4