![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to instructions_c8.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_c8.c CVS log | Up to [local] / rpl / src |
Ajout de instruction_c8.c.
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 'cipher'
29: ================================================================================
30: Entrées :
31: --------------------------------------------------------------------------------
32: Sorties :
33: --------------------------------------------------------------------------------
34: Effets de bord : néant
35: ================================================================================
36: */
37:
38: void
39: instruction_cipher(struct_processus *s_etat_processus)
40: {
41: const EVP_CIPHER *EVP_chiffrement;
42: const EVP_MD *EVP_sum;
43:
44: integer8 nombre_cycles;
45:
46: logical1 somme_invalide;
47: logical1 generation_clef;
48:
49: logical8 sel;
50:
51: struct_liste_chainee *l_element_courant;
52:
53: struct_objet *s_objet_argument_1;
54: struct_objet *s_objet_argument_2;
55: struct_objet *s_objet_resultat_1;
56: struct_objet *s_objet_resultat_2;
57:
58: unsigned char *chiffrement;
59: unsigned char *clef;
60: unsigned char *controle;
61: unsigned char *direction;
62: unsigned char *fonction;
63: unsigned char *instruction;
64: unsigned char *iv;
65: unsigned char *tampon;
66:
67: if ((*s_etat_processus).affichage_arguments == 'Y')
68: {
69: printf("\n CIPHER ");
70:
71: if ((*s_etat_processus).langue == 'F')
72: {
73: printf("(opérations de chiffrement)\n\n");
74: }
75: else
76: {
77: printf("(cryptographic operations)\n\n");
78: }
79:
80: printf(" 2: %s \"password\"\n", d_CHN);
81: printf(" 1: %s { \"KEY\" \"cipher type\" \"digest type\" "
82: "salt nround }\n", d_LST);
83: printf("-> 1: %s { \"generated key\" \"iv\" }\n\n", d_LST);
84:
85: printf(" 2: %s \"text\"\n", d_CHN);
86: printf(" 1: %s { \"cipher type\" \"direction\" \"key\" \"iv\" }\n",
87: d_LST);
88: printf("-> 2: %s \"encrypted or decrypted text\"\n", d_CHN);
89: printf(" 1: %s { \"cipher type\" \"direction\" \"key\" "
90: "\"updated iv\" }\n\n", d_LST);
91:
92: if ((*s_etat_processus).langue == 'F')
93: {
94: printf(" Algorithmes de signature :\n\n");
95: }
96: else
97: {
98: printf(" Digest algorithms:\n\n");
99: }
100:
101: # ifndef OPENSSL_NO_SHA
102: printf(" - DSS\n");
103: printf(" - DSS1\n");
104: printf(" - ECDSA\n");
105: # endif
106: # ifndef OPENSSL_NO_MD2
107: printf(" - MD2\n");
108: # endif
109: # ifndef OPENSSL_NO_MD4
110: printf(" - MD4\n");
111: # endif
112: # ifndef OPENSSL_NO_MD5
113: printf(" - MD5\n");
114: # endif
115: # ifndef OPENSSL_NO_MDC2
116: printf(" - MDC2\n");
117: # endif
118: # ifndef OPENSSL_NO_RIPEMD
119: printf(" - RIPEMD160\n");
120: # endif
121: # ifndef OPENSSL_NO_SHA
122: printf(" - SHA\n");
123: printf(" - SHA1\n");
124: # endif
125: # ifndef OPENSSL_NO_SHA256
126: printf(" - SHA224\n");
127: printf(" - SHA256\n");
128: # endif
129: # ifndef OPENSSL_NO_SHA512
130: printf(" - SHA384\n");
131: printf(" - SHA512\n");
132: # endif
133: # ifndef OPENSSL_NO_WHIRLPOOL
134: printf(" - WHIRLPOOL\n");
135: # endif
136:
137: printf("\n");
138:
139: if ((*s_etat_processus).langue == 'F')
140: {
141: printf(" Utilisation :\n\n");
142: }
143: else
144: {
145: printf(" Usage:\n\n");
146: }
147:
148: printf(" \"password\" { \"key\" \"SHA1\" # 0h 3 } CIPHER\n");
149: printf(" \"text\" { \"AES-128-CBC\" \"DECRYPT\" \"key\" "
150: "\"iv\" } CIPHER\n");
151: printf(" \"text\" { \"AES-128-EBC\" \"ENCRYPT\" \"key\" "
152: "\"iv\" } CIPHER\n");
153: return;
154: }
155: else if ((*s_etat_processus).test_instruction == 'Y')
156: {
157: (*s_etat_processus).nombre_arguments = -1;
158: return;
159: }
160:
161: if (test_cfsf(s_etat_processus, 31) == d_vrai)
162: {
163: if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
164: {
165: return;
166: }
167: }
168:
169: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
170: &s_objet_argument_1) == d_erreur)
171: {
172: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
173: return;
174: }
175:
176: if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
177: &s_objet_argument_2) == d_erreur)
178: {
179: liberation(s_etat_processus, s_objet_argument_1);
180:
181: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
182: return;
183: }
184:
185: if (((*s_objet_argument_1).type == LST) &&
186: ((*s_objet_argument_2).type == CHN))
187: {
188: l_element_courant = (*s_objet_argument_1).objet;
189:
190: if (l_element_courant == NULL)
191: {
192: liberation(s_etat_processus, s_objet_argument_1);
193: liberation(s_etat_processus, s_objet_argument_2);
194:
195: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
196: return;
197: }
198:
199: if ((*(*l_element_courant).donnee).type != CHN)
200: {
201: liberation(s_etat_processus, s_objet_argument_1);
202: liberation(s_etat_processus, s_objet_argument_2);
203:
204: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
205: return;
206: }
207:
208: if ((instruction = conversion_majuscule((unsigned char *)
209: (*(*l_element_courant).donnee).objet)) == NULL)
210: {
211: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
212: return;
213: }
214:
215: if (strcmp(instruction, "KEY") == 0)
216: {
217: // Dérivation d'une clef
218:
219: free(instruction);
220:
221: l_element_courant = (*l_element_courant).suivant;
222:
223: if (l_element_courant == NULL)
224: {
225: liberation(s_etat_processus, s_objet_argument_1);
226: liberation(s_etat_processus, s_objet_argument_2);
227:
228: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
229: return;
230: }
231:
232: // On attend l'algorithme de chiffrement.
233:
234: if ((*(*l_element_courant).donnee).type != CHN)
235: {
236: liberation(s_etat_processus, s_objet_argument_1);
237: liberation(s_etat_processus, s_objet_argument_2);
238:
239: (*s_etat_processus).erreur_execution =
240: d_ex_erreur_type_argument;
241: return;
242: }
243:
244: chiffrement = (unsigned char *) (*(*l_element_courant)
245: .donnee).objet;
246:
247: if ((l_element_courant = (*l_element_courant).suivant) == NULL)
248: {
249: liberation(s_etat_processus, s_objet_argument_1);
250: liberation(s_etat_processus, s_objet_argument_2);
251:
252: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
253: return;
254: }
255:
256: // On attend la somme de contrôle.
257:
258: if ((*(*l_element_courant).donnee).type != CHN)
259: {
260: liberation(s_etat_processus, s_objet_argument_1);
261: liberation(s_etat_processus, s_objet_argument_2);
262:
263: (*s_etat_processus).erreur_execution =
264: d_ex_erreur_type_argument;
265: return;
266: }
267:
268: controle = (unsigned char *) (*(*l_element_courant).donnee).objet;
269:
270: if ((l_element_courant = (*l_element_courant).suivant) == NULL)
271: {
272: liberation(s_etat_processus, s_objet_argument_1);
273: liberation(s_etat_processus, s_objet_argument_2);
274:
275: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
276: return;
277: }
278:
279:
280: // On attend le sel, donc un entier binaire de 64 bits.
281:
282: if ((*(*l_element_courant).donnee).type != BIN)
283: {
284: liberation(s_etat_processus, s_objet_argument_1);
285: liberation(s_etat_processus, s_objet_argument_2);
286:
287: (*s_etat_processus).erreur_execution =
288: d_ex_erreur_type_argument;
289: return;
290: }
291:
292: sel = (*((logical8 *) (*(*l_element_courant).donnee).objet));
293:
294: if ((l_element_courant = (*l_element_courant).suivant) == NULL)
295: {
296: liberation(s_etat_processus, s_objet_argument_1);
297: liberation(s_etat_processus, s_objet_argument_2);
298:
299: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
300: return;
301: }
302:
303: // On attend le nombre de cycles.
304:
305: if ((*(*l_element_courant).donnee).type != INT)
306: {
307: liberation(s_etat_processus, s_objet_argument_1);
308: liberation(s_etat_processus, s_objet_argument_2);
309:
310: (*s_etat_processus).erreur_execution =
311: d_ex_erreur_type_argument;
312: return;
313: }
314:
315: nombre_cycles = (*((integer8 *) (*(*l_element_courant)
316: .donnee).objet));
317:
318: // On a dû atteindre la fin de la liste.
319:
320: if ((*l_element_courant).suivant != NULL)
321: {
322: liberation(s_etat_processus, s_objet_argument_1);
323: liberation(s_etat_processus, s_objet_argument_2);
324:
325: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
326: return;
327: }
328:
329: // Test de la validité de la somme de contrôle.
330:
331: if ((fonction = conversion_majuscule(controle)) == NULL)
332: {
333: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
334: return;
335: }
336:
337: somme_invalide = d_faux;
338:
339: switch(fonction[0])
340: {
341: case 'D':
342: {
343: switch(fonction[1])
344: {
345: case 'S': // ds
346: {
347: switch(fonction[2])
348: {
349: # ifndef OPENSSL_NO_SHA
350: case 'S': // dss
351: {
352: switch(fonction[3])
353: {
354: case d_code_fin_chaine:
355: {
356: EVP_sum = EVP_dss();
357: break;
358: }
359:
360: case '1': // dss1
361: {
362: if (fonction[4] ==
363: d_code_fin_chaine)
364: {
365: EVP_sum = EVP_dss1();
366: }
367: else
368: {
369: somme_invalide = d_vrai;
370: }
371:
372: break;
373: }
374:
375: default:
376: {
377: somme_invalide = d_vrai;
378: break;
379: }
380: }
381:
382: break;
383: }
384: # endif
385:
386: default:
387: {
388: somme_invalide = d_vrai;
389: break;
390: }
391: }
392:
393: break;
394: }
395:
396: default:
397: {
398: somme_invalide = d_vrai;
399: break;
400: }
401: }
402:
403: break;
404: }
405:
406: case 'E':
407: {
408: switch(fonction[1])
409: {
410: case 'C': // ec
411: {
412: switch(fonction[2])
413: {
414: case 'D': // ecd
415: {
416: switch(fonction[3])
417: {
418: case 'S': // ecds
419: {
420: switch(fonction[4])
421: {
422: # ifndef OPENSSL_NO_SHA
423: case 'A': // ecdsa
424: {
425: if (fonction[5] ==
426: d_code_fin_chaine)
427: {
428: EVP_sum = EVP_ecdsa();
429: }
430: else
431: {
432: somme_invalide = d_vrai;
433: }
434:
435: break;
436: }
437: # endif
438:
439: default:
440: {
441: somme_invalide = d_vrai;
442: break;
443: }
444: }
445:
446: break;
447: }
448:
449: default:
450: {
451: somme_invalide = d_vrai;
452: break;
453: }
454: }
455:
456: break;
457: }
458:
459: default:
460: {
461: somme_invalide = d_vrai;
462: break;
463: }
464: }
465:
466: break;
467: }
468:
469: default:
470: {
471: somme_invalide = d_vrai;
472: break;
473: }
474: }
475:
476: break;
477: }
478:
479: case 'M':
480: {
481: switch(fonction[1])
482: {
483: case 'D': // md
484: {
485: switch(fonction[2])
486: {
487: # ifndef OPENSSL_NO_MD2
488: case '2': // md2
489: {
490: if (fonction[3] == d_code_fin_chaine)
491: {
492: EVP_sum = EVP_md2();
493: }
494: else
495: {
496: somme_invalide = d_vrai;
497: }
498:
499: break;
500: }
501: # endif
502:
503: # ifndef OPENSSL_NO_MD4
504: case '4': // md4
505: {
506: if (fonction[3] == d_code_fin_chaine)
507: {
508: EVP_sum = EVP_md4();
509: }
510: else
511: {
512: somme_invalide = d_vrai;
513: }
514:
515: break;
516: }
517: # endif
518:
519: # ifndef OPENSSL_NO_MD5
520: case '5': // md5
521: {
522: if (fonction[3] == d_code_fin_chaine)
523: {
524: EVP_sum = EVP_md5();
525: }
526: else
527: {
528: somme_invalide = d_vrai;
529: }
530:
531: break;
532: }
533: # endif
534:
535: case 'C': // mdc
536: {
537: switch(fonction[3])
538: {
539: # ifndef OPENSSL_NO_MDC2
540: case '2': // mdc2
541: {
542: if (fonction[4] ==
543: d_code_fin_chaine)
544: {
545: EVP_sum = EVP_mdc2();
546: }
547: else
548: {
549: somme_invalide = d_vrai;
550: }
551:
552: break;
553: }
554: # endif
555:
556: default:
557: {
558: somme_invalide = d_vrai;
559: break;
560: }
561: }
562:
563: break;
564: }
565:
566: default:
567: {
568: somme_invalide = d_vrai;
569: break;
570: }
571: }
572:
573: break;
574: }
575:
576: default:
577: {
578: somme_invalide = d_vrai;
579: break;
580: }
581: }
582:
583: break;
584: }
585:
586: # ifndef OPENSSL_NO_RIPEMD
587: case 'R':
588: {
589: if (strcmp(fonction, "RIPEMD160") == 0)
590: {
591: EVP_sum = EVP_ripemd160();
592: }
593: else
594: {
595: somme_invalide = d_vrai;
596: }
597:
598: break;
599: }
600: # endif
601:
602: case 'S':
603: {
604: switch(fonction[1])
605: {
606: case 'H': // sh
607: {
608: switch(fonction[2])
609: {
610: # ifndef OPENSSL_NO_SHA
611: case 'A':
612: {
613: switch(fonction[3])
614: {
615: case d_code_fin_chaine:
616: {
617: EVP_sum = EVP_sha();
618: break;
619: }
620:
621: case '1': // sha1
622: {
623: if (fonction[4] ==
624: d_code_fin_chaine)
625: {
626: EVP_sum = EVP_sha1();
627: }
628: else
629: {
630: somme_invalide = d_vrai;
631: }
632:
633: break;
634: }
635:
636: # ifndef OPENSSL_NO_SHA256
637: case '2': // sha2
638: {
639: switch(fonction[4])
640: {
641: case '2': // sha22
642: {
643: switch(fonction[5])
644: {
645: case '4': // sha224
646: {
647: if (fonction[6] ==
648: d_code_fin_chaine)
649: {
650: EVP_sum =
651: EVP_sha224();
652: }
653: else
654: {
655: somme_invalide =
656: d_vrai;
657: }
658:
659: break;
660: }
661:
662: default:
663: {
664: somme_invalide =
665: d_vrai;
666: break;
667: }
668: }
669:
670: break;
671: }
672:
673: case '5':
674: {
675: switch(fonction[5])
676: {
677: case '6': // sha256
678: {
679: if (fonction[6] ==
680: d_code_fin_chaine)
681: {
682: EVP_sum =
683: EVP_sha256();
684: }
685: else
686: {
687: somme_invalide =
688: d_vrai;
689: }
690:
691: break;
692: }
693:
694: default:
695: {
696: somme_invalide =
697: d_vrai;
698: break;
699: }
700: }
701:
702: break;
703: }
704:
705: default:
706: {
707: somme_invalide = d_vrai;
708: break;
709: }
710: }
711:
712: break;
713: }
714: # endif
715:
716: # ifndef OPENSSL_NO_SHA512
717: case '3': // sha3
718: {
719: switch(fonction[4])
720: {
721: case '8': // sha38
722: {
723: switch(fonction[5])
724: {
725: case '4': // sha384
726: {
727: if (fonction[6] ==
728: d_code_fin_chaine)
729: {
730: EVP_sum =
731: EVP_sha384();
732: }
733: else
734: {
735: somme_invalide =
736: d_vrai;
737: }
738:
739: break;
740: }
741:
742: default:
743: {
744: somme_invalide =
745: d_vrai;
746: break;
747: }
748: }
749:
750: break;
751: }
752:
753: default:
754: {
755: somme_invalide = d_vrai;
756: break;
757: }
758: }
759:
760: break;
761: }
762:
763: case '5': // sha5
764: {
765: switch(fonction[4])
766: {
767: case '1': // sha51
768: {
769: switch(fonction[5])
770: {
771: case '2': // sha512
772: {
773: if (fonction[6] ==
774: d_code_fin_chaine)
775: {
776: EVP_sum =
777: EVP_sha512();
778: }
779: else
780: {
781: somme_invalide =
782: d_vrai;
783: }
784:
785: break;
786: }
787:
788: default:
789: {
790: somme_invalide =
791: d_vrai;
792: break;
793: }
794: }
795:
796: break;
797: }
798:
799: default:
800: {
801: somme_invalide = d_vrai;
802: break;
803: }
804: }
805:
806: break;
807: }
808: # endif
809:
810: default:
811: {
812: somme_invalide = d_vrai;
813: break;
814: }
815: }
816:
817: break;
818: }
819: # endif
820:
821: default:
822: {
823: somme_invalide = d_vrai;
824: break;
825: }
826: }
827:
828: break;
829: }
830:
831: default:
832: {
833: somme_invalide = d_vrai;
834: break;
835: }
836: }
837:
838: break;
839: }
840:
841: # ifndef OPENSSL_NO_WHIRLPOOL
842: case 'W':
843: {
844: if (strcmp(fonction, "WHIRLPOOL") == 0)
845: {
846: EVP_sum = EVP_whirlpool();
847: }
848: else
849: {
850: somme_invalide = d_vrai;
851: }
852:
853: break;
854: }
855: # endif
856:
857: default:
858: {
859: somme_invalide = d_vrai;
860: break;
861: }
862: }
863:
864: free(fonction);
865:
866: if (somme_invalide == d_vrai)
867: {
868: liberation(s_etat_processus, s_objet_argument_1);
869: liberation(s_etat_processus, s_objet_argument_2);
870:
871: (*s_etat_processus).erreur_execution =
872: d_ex_chiffrement_indisponible;
873: return;
874: }
875:
876: generation_clef = d_vrai;
877: }
878: else
879: {
880: // Chiffrement ou déchiffrement d'un message
881:
882: chiffrement = fonction;
883:
884: l_element_courant = (*l_element_courant).suivant;
885:
886: if (l_element_courant == NULL)
887: {
888: liberation(s_etat_processus, s_objet_argument_1);
889: liberation(s_etat_processus, s_objet_argument_2);
890:
891: (*s_etat_processus).erreur_execution = d_ex_manque_argument;
892: return;
893: }
894:
895: // On attend la direction.
896:
897: if ((*(*l_element_courant).donnee).type != CHN)
898: {
899: liberation(s_etat_processus, s_objet_argument_1);
900: liberation(s_etat_processus, s_objet_argument_2);
901:
902: (*s_etat_processus).erreur_execution =
903: d_ex_erreur_type_argument;
904: return;
905: }
906:
907: direction = (unsigned char *) (*(*l_element_courant)
908: .donnee).objet;
909:
910: // On attend la clef.
911:
912: if ((l_element_courant = (*l_element_courant).suivant) == NULL)
913: {
914: liberation(s_etat_processus, s_objet_argument_1);
915: liberation(s_etat_processus, s_objet_argument_2);
916:
917: (*s_etat_processus).erreur_execution =
918: d_ex_manque_argument;
919: return;
920: }
921:
922: clef = (unsigned char *) (*(*l_element_courant).donnee).objet;
923:
924: // On attend le vecteur d'initialisation.
925:
926: if ((l_element_courant = (*l_element_courant).suivant) == NULL)
927: {
928: liberation(s_etat_processus, s_objet_argument_1);
929: liberation(s_etat_processus, s_objet_argument_2);
930:
931: (*s_etat_processus).erreur_execution =
932: d_ex_manque_argument;
933: return;
934: }
935:
936: iv = (unsigned char *) (*(*l_element_courant).donnee).objet;
937:
938: if ((*l_element_courant).suivant != NULL)
939: {
940: liberation(s_etat_processus, s_objet_argument_1);
941: liberation(s_etat_processus, s_objet_argument_2);
942:
943: (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
944: return;
945: }
946: }
947: }
948: else
949: {
950: liberation(s_etat_processus, s_objet_argument_1);
951: liberation(s_etat_processus, s_objet_argument_2);
952:
953: (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
954: return;
955: }
956:
957: if ((tampon = conversion_majuscule(chiffrement)) == NULL)
958: {
959: (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
960: return;
961: }
962:
963: if (strncmp(tampon, "AES", 3) == 0)
964: {
965: }
966:
967: free(tampon);
968:
969: if (generation_clef == d_vrai)
970: {
971: }
972: else
973: {
974: }
975:
976: liberation(s_etat_processus, s_objet_argument_1);
977: liberation(s_etat_processus, s_objet_argument_2);
978: return;
979: }
980:
981: // vim: ts=4