?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix typo.
[shishi.git] / asn1 / decoding.c
blob3e3e9d85f2dbb99467f959450a613876d2f4d10b
1 /*
2 * Copyright (C) 2002 Fabio Fiorina
3 *
4 * This file is part of LIBASN1.
5 *
6 * The LIBTASN1 library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 */
20
21
22 /*****************************************************/
23 /* File: decoding.c */
24 /* Description: Functions to manage DER decoding */
25 /*****************************************************/
26
27 #include <int.h>
28 #include <errors.h>
29 #include "der.h"
30 #include "parser_aux.h"
31 #include <gstr.h>
32 #include "structure.h"
33 #include "element.h"
34
35
36 void
37 _asn1_error_description_tag_error(node_asn *node,char *ErrorDescription)
38 {
39
40 Estrcpy(ErrorDescription,":: tag error near element '");
41 _asn1_hierarchical_name(node,ErrorDescription+strlen(ErrorDescription),
42 MAX_ERROR_DESCRIPTION_SIZE-40);
43 Estrcat(ErrorDescription,"'");
44
45 }
46
47
48 signed long
49 _asn1_get_length_der(const unsigned char *der,int *len)
50 {
51 unsigned long ans;
52 int k,punt;
53
54 if(!(der[0]&128)){
55 /* short form */
56 *len=1;
57 return der[0];
58 }
59 else{
60 /* Long form */
61 k=der[0]&0x7F;
62 punt=1;
63 if(k){ /* definite length method */
64 ans=0;
65 while(punt<=k) ans=ans*256+der[punt++];
66 }
67 else{ /* indefinite lenght method */
68 ans=-1;
69 }
70
71 *len=punt;
72 return ans;
73 }
74 }
75
76
77
78
79 unsigned int
80 _asn1_get_tag_der(const unsigned char *der,unsigned char *class,int *len)
81 {
82 int punt,ris;
83
84 if (der==NULL || len == NULL) return ASN1_DER_ERROR;
85 *class=der[0]&0xE0;
86 if((der[0]&0x1F)!=0x1F){
87 /* short form */
88 *len=1;
89 ris=der[0]&0x1F;
90 }
91 else{
92 /* Long form */
93 punt=1;
94 ris=0;
95 while(der[punt]&128) ris=ris*128+(der[punt++]&0x7F);
96 ris=ris*128+(der[punt++]&0x7F);
97 *len=punt;
98 }
99 return ris;
100 }
101
102
103
104
105 int
106 _asn1_get_octet_der(const unsigned char *der,int *der_len,unsigned char *str,int str_size, int *str_len)
107 {
108 int len_len;
109
110 /* if(str==NULL) return ASN1_SUCCESS; */
111 *str_len=_asn1_get_length_der(der,&len_len);
112
113 *der_len=*str_len+len_len;
114 if ( str_size >= *str_len)
115 memcpy(str,der+len_len,*str_len);
116 else {
117 return ASN1_MEM_ERROR;
118 }
119
120 return ASN1_SUCCESS;
121 }
122
123
124
125
126 void
127 _asn1_get_time_der(const unsigned char *der,int *der_len,unsigned char *str)
128 {
129 int len_len,str_len;
130
131 if(str==NULL) return;
132 str_len=_asn1_get_length_der(der,&len_len);
133 memcpy(str,der+len_len,str_len);
134 str[str_len]=0;
135 *der_len=str_len+len_len;
136 }
137
138
139
140 void
141 _asn1_get_objectid_der(const unsigned char *der,int *der_len,unsigned char *str, int str_size)
142 {
143 int len_len,len,k;
144 char temp[20];
145 unsigned long val,val1;
146
147 if(str==NULL) return;
148 len=_asn1_get_length_der(der,&len_len);
149
150 val1=der[len_len]/40;
151 val=der[len_len]-val1*40;
152
153 _asn1_str_cpy(str, str_size, _asn1_ltostr(val1,temp));
154 _asn1_str_cat(str, str_size, ".");
155 _asn1_str_cat(str, str_size, _asn1_ltostr(val,temp));
156
157 val=0;
158 for(k=1;k<len;k++){
159 val=val<<7;
160 val|=der[len_len+k]&0x7F;
161 if(!(der[len_len+k]&0x80)){
162 _asn1_str_cat(str, str_size,".");
163 _asn1_str_cat(str, str_size,_asn1_ltostr(val,temp));
164 val=0;
165 }
166 }
167 *der_len=len+len_len;
168 }
169
170
171
172
173 int
174 _asn1_get_bit_der(const unsigned char *der,int *der_len,unsigned char *str, int str_size, int *bit_len)
175 {
176 int len_len,len_byte;
177
178 len_byte=_asn1_get_length_der(der,&len_len)-1;
179
180 *der_len=len_byte+len_len+1;
181 *bit_len=len_byte*8-der[len_len];
182
183 if (str_size >= len_byte)
184 memcpy(str,der+len_len+1,len_byte);
185 else {
186 return ASN1_MEM_ERROR;
187 }
188
189 return ASN1_SUCCESS;
190 }
191
192
193
194
195 int
196 _asn1_extract_tag_der(node_asn *node,const unsigned char *der,int *der_len)
197 {
198 node_asn *p;
199 int counter,len2,len3,is_tag_implicit;
200 unsigned long tag,tag_implicit=0;
201 unsigned char class,class2,class_implicit=0;
202
203
204 counter=is_tag_implicit=0;
205
206 if(node->type&CONST_TAG){
207 p=node->down;
208 while(p){
209 if(type_field(p->type)==TYPE_TAG){
210 if(p->type&CONST_APPLICATION) class2=APPLICATION;
211 else if(p->type&CONST_UNIVERSAL) class2=UNIVERSAL;
212 else if(p->type&CONST_PRIVATE) class2=PRIVATE;
213 else class2=CONTEXT_SPECIFIC;
214
215 if(p->type&CONST_EXPLICIT){
216 tag=_asn1_get_tag_der(der+counter,&class,&len2);
217 counter+=len2;
218 len3=_asn1_get_length_der(der+counter,&len2);
219 counter+=len2;
220 if(!is_tag_implicit){
221 if((class!=(class2|STRUCTURED)) || (tag!=strtoul(p->value,NULL,10)))
222 return ASN1_TAG_ERROR;
223 }
224 else{ /* TAG_IMPLICIT */
225 if((class!=class_implicit) || (tag!=tag_implicit))
226 return ASN1_TAG_ERROR;
227 }
228
229 is_tag_implicit=0;
230 }
231 else{ /* TAG_IMPLICIT */
232 if(!is_tag_implicit){
233 if((type_field(node->type)==TYPE_SEQUENCE) ||
234 (type_field(node->type)==TYPE_SEQUENCE_OF) ||
235 (type_field(node->type)==TYPE_SET) ||
236 (type_field(node->type)==TYPE_SET_OF)) class2|=STRUCTURED;
237 class_implicit=class2;
238 tag_implicit=strtoul(p->value,NULL,10);
239 is_tag_implicit=1;
240 }
241 }
242 }
243 p=p->right;
244 }
245 }
246
247 if(is_tag_implicit){
248 tag=_asn1_get_tag_der(der+counter,&class,&len2);
249 if((class!=class_implicit) || (tag!=tag_implicit)){
250 if(type_field(node->type)==TYPE_OCTET_STRING){
251 class_implicit |= STRUCTURED;
252 if((class!=class_implicit) || (tag!=tag_implicit))
253 return ASN1_TAG_ERROR;
254 }
255 else
256 return ASN1_TAG_ERROR;
257 }
258 }
259 else{
260 if(type_field(node->type)==TYPE_TAG){
261 counter=0;
262 *der_len=counter;
263 return ASN1_SUCCESS;
264 }
265
266 tag=_asn1_get_tag_der(der+counter,&class,&len2);
267 switch(type_field(node->type)){
268 case TYPE_NULL:
269 if((class!=UNIVERSAL) || (tag!=TAG_NULL)) return ASN1_DER_ERROR;
270 break;
271 case TYPE_BOOLEAN:
272 if((class!=UNIVERSAL) || (tag!=TAG_BOOLEAN)) return ASN1_DER_ERROR;
273 break;
274 case TYPE_INTEGER:
275 if((class!=UNIVERSAL) || (tag!=TAG_INTEGER)) return ASN1_DER_ERROR;
276 break;
277 case TYPE_ENUMERATED:
278 if((class!=UNIVERSAL) || (tag!=TAG_ENUMERATED)) return ASN1_DER_ERROR;
279 break;
280 case TYPE_OBJECT_ID:
281 if((class!=UNIVERSAL) || (tag!=TAG_OBJECT_ID)) return ASN1_DER_ERROR;
282 break;
283 case TYPE_TIME:
284 if(node->type&CONST_UTC){
285 if((class!=UNIVERSAL) || (tag!=TAG_UTCTime)) return ASN1_DER_ERROR;
286 }
287 else{
288 if((class!=UNIVERSAL) || (tag!=TAG_GENERALIZEDTime))
289 return ASN1_DER_ERROR;
290 }
291 break;
292 case TYPE_OCTET_STRING:
293 if(((class!=UNIVERSAL) && (class!=(UNIVERSAL|STRUCTURED)))
294 || (tag!=TAG_OCTET_STRING)) return ASN1_DER_ERROR;
295 break;
296 case TYPE_GENERALSTRING:
297 if((class!=UNIVERSAL) || (tag!=TAG_GENERALSTRING)) return ASN1_DER_ERROR;
298 break;
299 case TYPE_BIT_STRING:
300 if((class!=UNIVERSAL) || (tag!=TAG_BIT_STRING)) return ASN1_DER_ERROR;
301 break;
302 case TYPE_SEQUENCE: case TYPE_SEQUENCE_OF:
303 if((class!=(UNIVERSAL|STRUCTURED)) || (tag!=TAG_SEQUENCE))
304 return ASN1_DER_ERROR;
305 break;
306 case TYPE_SET: case TYPE_SET_OF:
307 if((class!=(UNIVERSAL|STRUCTURED)) || (tag!=TAG_SET))
308 return ASN1_DER_ERROR;
309 break;
310 case TYPE_ANY:
311 counter-=len2;
312 break;
313 default:
314 return ASN1_DER_ERROR;
315 break;
316 }
317 }
318
319 counter+=len2;
320 *der_len=counter;
321 return ASN1_SUCCESS;
322 }
323
324
325 int
326 _asn1_delete_not_used(node_asn *node)
327 {
328 node_asn *p,*p2;
329
330 if(node==NULL) return ASN1_ELEMENT_NOT_FOUND;
331
332 p=node;
333 while(p){
334 if(p->type&CONST_NOT_USED){
335 p2=NULL;
336 if(p!=node){
337 p2=_asn1_find_left(p);
338 if(!p2) p2=_asn1_find_up(p);
339 }
340 asn1_delete_structure(&p);
341 p=p2;
342 }
343
344 if(!p) break; /* reach node */
345
346 if(p->down){
347 p=p->down;
348 }
349 else{
350 if(p==node) p=NULL;
351 else if(p->right) p=p->right;
352 else{
353 while(1){
354 p=_asn1_find_up(p);
355 if(p==node){
356 p=NULL;
357 break;
358 }
359 if(p->right){
360 p=p->right;
361 break;
362 }
363 }
364 }
365 }
366 }
367 return ASN1_SUCCESS;
368 }
369
370
371 asn1_retCode
372 _asn1_get_octet_string(const unsigned char* der,node_asn *node,int* len)
373 {
374 int len2,len3,counter,counter2,counter_end,tot_len,indefinite;
375 char *temp,*temp2;
376
377 counter=0;
378
379 if(*(der-1) & STRUCTURED){
380 tot_len=0;
381 indefinite=_asn1_get_length_der(der,&len3);
382
383 counter+=len3;
384 if(indefinite>=0) indefinite+=len3;
385
386 while(1){
387 if(counter>(*len)) return ASN1_DER_ERROR;
388
389 if(indefinite==-1){
390 if((der[counter]==0) && (der[counter+1]==0)){
391 counter+=2;
392 break;
393 }
394 }
395 else if(counter>=indefinite) break;
396
397 if(der[counter] != TAG_OCTET_STRING) return ASN1_DER_ERROR;
398
399 counter++;
400
401 len2=_asn1_get_length_der(der+counter,&len3);
402 if(len2 <= 0) return ASN1_DER_ERROR;
403
404 counter+=len3+len2;
405 tot_len+=len2;
406 }
407
408 /* copy */
409 if(node){
410 _asn1_length_der(tot_len,NULL,&len2);
411 temp=(unsigned char *)_asn1_alloca(len2+tot_len);
412 if (temp==NULL){
413 return ASN1_MEM_ALLOC_ERROR;
414 }
415
416 _asn1_length_der(tot_len,temp,&len2);
417 tot_len+=len2;
418 temp2=temp+len2;
419 len2=_asn1_get_length_der(der,&len3);
420 counter2=len3+1;
421
422 if(indefinite==-1) counter_end=counter-2;
423 else counter_end=counter;
424
425 while(counter2<counter_end){
426 len2=_asn1_get_length_der(der+counter2,&len3);
427 memcpy(temp2,der+counter2+len3,len2);
428 temp2+=len2;
429 counter2+=len2+len3+1;
430 }
431 _asn1_set_value(node,temp,tot_len);
432 _asn1_afree(temp);
433 }
434 }
435 else{ /* NOT STRUCTURED */
436 len2=_asn1_get_length_der(der,&len3);
437 if(node)
438 _asn1_set_value(node,der,len3+len2);
439 counter=len3+len2;
440 }
441
442 *len=counter;
443 return ASN1_SUCCESS;
444
445 }
446
447
448 asn1_retCode
449 _asn1_get_indefinite_length_string(const unsigned char* der,int* len)
450 {
451 int len2,len3,counter,indefinite;
452 unsigned int tag;
453 unsigned char class;
454
455 counter=indefinite=0;
456
457 while(1){
458 if((*len)<counter) return ASN1_DER_ERROR;
459
460 if((der[counter]==0) && (der[counter+1]==0)){
461 counter+=2;
462 indefinite--;
463 if(indefinite<=0) break;
464 else continue;
465 }
466
467 tag=_asn1_get_tag_der(der+counter,&class,&len2);
468 counter+=len2;
469 len2=_asn1_get_length_der(der+counter,&len3);
470 if(len2 == -1){
471 indefinite++;
472 counter+=1;
473 }
474 else{
475 counter+=len2+len3;
476 }
477 }
478
479 *len=counter;
480 return ASN1_SUCCESS;
481
482 }
483
484
485 /**
486 * asn1_der_decoding - Fill the structure *ELEMENT with values of a DER encoding string.
487 * @element: pointer to an ASN1 structure
488 * @der: vector that contains the DER encoding.
489 * @len: number of bytes of *der: der[0]..der[len-1]
490 * Description:
491 *
492 * Fill the structure *ELEMENT with values of a DER encoding string. The sructure must just be
493 * created with function 'create_stucture'.
494 * If an error accurs during de decoding procedure, the *ELEMENT is deleted
495 * and set equal to ASN1_TYPE_EMPTY.
496 *
497 * Returns:
498 *
499 * ASN1_SUCCESS\: DER encoding OK
500 *
501 * ASN1_ELEMENT_NOT_FOUND\: ELEMENT is ASN1_TYPE_EMPTY.
502 *
503 * ASN1_TAG_ERROR,ASN1_DER_ERROR\: the der encoding doesn't match the structure NAME. *ELEMENT deleted.
504 **/
505
506 asn1_retCode
507 asn1_der_decoding(ASN1_TYPE *element,const unsigned char *der,int len,
508 char *errorDescription)
509 {
510 node_asn *node,*p,*p2,*p3;
511 char temp[128];
512 int counter,len2,len3,len4,move,ris;
513 unsigned char class,*temp2;
514 unsigned int tag;
515 int indefinite;
516
517 node=*element;
518
519 if(node==ASN1_TYPE_EMPTY) return ASN1_ELEMENT_NOT_FOUND;
520
521 if(node->type&CONST_OPTION){
522 asn1_delete_structure(element);
523 return ASN1_GENERIC_ERROR;
524 }
525
526 counter=0;
527 move=DOWN;
528 p=node;
529 while(1){
530 ris=ASN1_SUCCESS;
531 if(move!=UP){
532 if(p->type&CONST_SET){
533 p2=_asn1_find_up(p);
534 len2=strtol(p2->value,NULL,10);
535 if(len2==-1){
536 if(!der[counter] && !der[counter+1]){
537 p=p2;
538 move=UP;
539 counter+=2;
540 continue;
541 }
542 }
543 else if(counter==len2){
544 p=p2;
545 move=UP;
546 continue;
547 }
548 else if(counter>len2){
549 asn1_delete_structure(element);
550 return ASN1_DER_ERROR;
551 }
552 p2=p2->down;
553 while(p2){
554 if((p2->type&CONST_SET) && (p2->type&CONST_NOT_USED)){
555 if(type_field(p2->type)!=TYPE_CHOICE)
556 ris=_asn1_extract_tag_der(p2,der+counter,&len2);
557 else{
558 p3=p2->down;
559 while(p3){
560 ris=_asn1_extract_tag_der(p3,der+counter,&len2);
561 if(ris==ASN1_SUCCESS) break;
562 p3=p3->right;
563 }
564 }
565 if(ris==ASN1_SUCCESS){
566 p2->type&=~CONST_NOT_USED;
567 p=p2;
568 break;
569 }
570 }
571 p2=p2->right;
572 }
573 if(p2==NULL){
574 asn1_delete_structure(element);
575 return ASN1_DER_ERROR;
576 }
577 }
578
579 if((p->type&CONST_OPTION) || (p->type&CONST_DEFAULT)){
580 p2=_asn1_find_up(p);
581 len2=strtol(p2->value,NULL,10);
582 if(counter==len2){
583 if(p->right){
584 p2=p->right;
585 move=RIGHT;
586 }
587 else move=UP;
588
589 if(p->type&CONST_OPTION) asn1_delete_structure(&p);
590
591 p=p2;
592 continue;
593 }
594 }
595
596 if(type_field(p->type)==TYPE_CHOICE){
597 while(p->down){
598 if(counter<len)
599 ris=_asn1_extract_tag_der(p->down,der+counter,&len2);
600 else
601 ris=ASN1_DER_ERROR;
602 if(ris==ASN1_SUCCESS){
603 while(p->down->right){
604 p2=p->down->right;
605 asn1_delete_structure(&p2);
606 }
607 break;
608 }
609 else if(ris==ASN1_ERROR_TYPE_ANY){
610 asn1_delete_structure(element);
611 return ASN1_ERROR_TYPE_ANY;
612 }
613 else{
614 p2=p->down;
615 asn1_delete_structure(&p2);
616 }
617 }
618
619 if(p->down==NULL){
620 if(!(p->type&CONST_OPTION)){
621 asn1_delete_structure(element);
622 return ASN1_DER_ERROR;
623 }
624 }
625 else
626 p=p->down;
627 }
628
629 if((p->type&CONST_OPTION) || (p->type&CONST_DEFAULT)){
630 p2=_asn1_find_up(p);
631 len2=strtol(p2->value,NULL,10);
632 if((len2!=-1) && (counter>len2)) ris=ASN1_TAG_ERROR;
633 }
634
635 if(ris==ASN1_SUCCESS) ris=_asn1_extract_tag_der(p,der+counter,&len2);
636 if(ris!=ASN1_SUCCESS){
637 if(p->type&CONST_OPTION){
638 p->type|=CONST_NOT_USED;
639 move=RIGHT;
640 }
641 else if(p->type&CONST_DEFAULT) {
642 _asn1_set_value(p,NULL,0);
643 move=RIGHT;
644 }
645 else {
646 if (errorDescription!=NULL)
647 _asn1_error_description_tag_error(p,errorDescription);
648
649 asn1_delete_structure(element);
650 return ASN1_TAG_ERROR;
651 }
652 }
653 else counter+=len2;
654 }
655
656 if(ris==ASN1_SUCCESS){
657 switch(type_field(p->type)){
658 case TYPE_NULL:
659 if(der[counter]){
660 asn1_delete_structure(element);
661 return ASN1_DER_ERROR;
662 }
663 counter++;
664 move=RIGHT;
665 break;
666 case TYPE_BOOLEAN:
667 if(der[counter++]!=1){
668 asn1_delete_structure(element);
669 return ASN1_DER_ERROR;
670 }
671 if(der[counter++]==0) _asn1_set_value(p,"F",1);
672 else _asn1_set_value(p,"T",1);
673 move=RIGHT;
674 break;
675 case TYPE_INTEGER: case TYPE_ENUMERATED:
676 len2=_asn1_get_length_der(der+counter,&len3);
677 _asn1_set_value(p,der+counter,len3+len2);
678 counter+=len3+len2;
679 move=RIGHT;
680 break;
681 case TYPE_OBJECT_ID:
682 _asn1_get_objectid_der(der+counter,&len2, temp, sizeof(temp));
683 _asn1_set_value(p,temp,strlen(temp)+1);
684 counter+=len2;
685 move=RIGHT;
686 break;
687 case TYPE_TIME:
688 _asn1_get_time_der(der+counter,&len2,temp);
689 _asn1_set_value(p,temp,strlen(temp)+1);
690 counter+=len2;
691 move=RIGHT;
692 break;
693 case TYPE_OCTET_STRING:
694 len3=len-counter;
695 ris=_asn1_get_octet_string(der+counter,p,&len3);
696 if(ris != ASN1_SUCCESS) return ris;
697 counter+=len3;
698 move=RIGHT;
699 break;
700 case TYPE_GENERALSTRING:
701 len2=_asn1_get_length_der(der+counter,&len3);
702 _asn1_set_value(p,der+counter,len3+len2);
703 counter+=len3+len2;
704 move=RIGHT;
705 break;
706 case TYPE_BIT_STRING:
707 len2=_asn1_get_length_der(der+counter,&len3);
708 _asn1_set_value(p,der+counter,len3+len2);
709 counter+=len3+len2;
710 move=RIGHT;
711 break;
712 case TYPE_SEQUENCE: case TYPE_SET:;
713 if(move==UP){
714 len2=strtol(p->value,NULL,10);
715 _asn1_set_value(p,NULL,0);
716 if(len2==-1){ /* indefinite length method */
717 if((der[counter]) || der[counter+1]){
718 asn1_delete_structure(element);
719 return ASN1_DER_ERROR;
720 }
721 counter+=2;
722 }
723 else{ /* definite length method */
724 if(len2!=counter){
725 asn1_delete_structure(element);
726 return ASN1_DER_ERROR;
727 }
728 }
729 move=RIGHT;
730 }
731 else{ /* move==DOWN || move==RIGHT */
732 len3=_asn1_get_length_der(der+counter,&len2);
733 counter+=len2;
734 if(len3>0){
735 _asn1_ltostr(counter+len3,temp);
736 _asn1_set_value(p,temp,strlen(temp)+1);
737 move=DOWN;
738 }
739 else if(len3==0){
740 p2=p->down;
741 while(p2){
742 if(type_field(p2->type)!=TYPE_TAG){
743 p3=p2->right;
744 asn1_delete_structure(&p2);
745 p2=p3;
746 }
747 else
748 p2=p2->right;
749 }
750 move=RIGHT;
751 }
752 else{ /* indefinite length method */
753 _asn1_set_value(p,"-1",3);
754 move=DOWN;
755 }
756 }
757 break;
758 case TYPE_SEQUENCE_OF: case TYPE_SET_OF:
759 if(move==UP){
760 len2=strtol(p->value,NULL,10);
761 if(len2==-1){ /* indefinite length method */
762 if((counter+2)>len) return ASN1_DER_ERROR;
763 if((der[counter]) || der[counter+1]){
764 _asn1_append_sequence_set(p);
765 p=p->down;
766 while(p->right) p=p->right;
767 move=RIGHT;
768 continue;
769 }
770 _asn1_set_value(p,NULL,0);
771 counter+=2;
772 }
773 else{ /* definite length method */
774 if(len2>counter){
775 _asn1_append_sequence_set(p);
776 p=p->down;
777 while(p->right) p=p->right;
778 move=RIGHT;
779 continue;
780 }
781 _asn1_set_value(p,NULL,0);
782 if(len2!=counter){
783 asn1_delete_structure(element);
784 return ASN1_DER_ERROR;
785 }
786 }
787 }
788 else{ /* move==DOWN || move==RIGHT */
789 len3=_asn1_get_length_der(der+counter,&len2);
790 counter+=len2;
791 if(len3){
792 if(len3>0){ /* definite length method */
793 _asn1_ltostr(counter+len3,temp);
794 _asn1_set_value(p,temp,strlen(temp)+1);
795 }
796 else { /* indefinite length method */
797 _asn1_set_value(p,"-1",3);
798 }
799 p2=p->down;
800 while((type_field(p2->type)==TYPE_TAG) || (type_field(p2->type)==TYPE_SIZE)) p2=p2->right;
801 if(p2->right==NULL) _asn1_append_sequence_set(p);
802 p=p2;
803 }
804 }
805 move=RIGHT;
806 break;
807 case TYPE_ANY:
808 /* Check indefinite lenth method in a EXPLICIT TAG */
809 if((p->type&CONST_TAG) && (der[counter-1]==0x80))
810 indefinite=1;
811 else
812 indefinite=0;
813
814 tag=_asn1_get_tag_der(der+counter,&class,&len2);
815 len4=_asn1_get_length_der(der+counter+len2,&len3);
816
817 if(len4 != -1){
818 len2+=len4;
819 _asn1_length_der(len2+len3,NULL,&len4);
820 temp2=(unsigned char *)_asn1_alloca(len2+len3+len4);
821 if (temp2==NULL){
822 asn1_delete_structure(element);
823 return ASN1_MEM_ALLOC_ERROR;
824 }
825
826 _asn1_octet_der(der+counter,len2+len3,temp2,&len4);
827 _asn1_set_value(p,temp2,len4);
828 _asn1_afree(temp2);
829 counter+=len2+len3;
830 }
831 else{ /* indefinite length */
832 len2=len-counter;
833 ris=_asn1_get_indefinite_length_string(der+counter,&len2);
834 if(ris != ASN1_SUCCESS){
835 asn1_delete_structure(element);
836 return ris;
837 }
838 _asn1_length_der(len2,NULL,&len4);
839 temp2=(unsigned char *)_asn1_alloca(len2+len4);
840 if (temp2==NULL){
841 asn1_delete_structure(element);
842 return ASN1_MEM_ALLOC_ERROR;
843 }
844
845 _asn1_octet_der(der+counter,len2,temp2,&len4);
846 _asn1_set_value(p,temp2,len4);
847 _asn1_afree(temp2);
848 counter+=len2;
849 }
850
851 /* Check if a couple of 0x00 are present due to an EXPLICIT TAG with
852 a indefinite length method. */
853 if(indefinite){
854 if(!der[counter] && !der[counter+1]){
855 counter+=2;
856 }
857 else{
858 asn1_delete_structure(element);
859 return ASN1_DER_ERROR;
860 }
861 }
862 move=RIGHT;
863 break;
864 default:
865 move=(move==UP)?RIGHT:DOWN;
866 break;
867 }
868 }
869
870 if(p==node && move!=DOWN) break;
871
872 if(move==DOWN){
873 if(p->down) p=p->down;
874 else move=RIGHT;
875 }
876 if((move==RIGHT) && !(p->type&CONST_SET)){
877 if(p->right) p=p->right;
878 else move=UP;
879 }
880 if(move==UP) p=_asn1_find_up(p);
881 }
882
883 _asn1_delete_not_used(*element);
884
885 if(counter != len){
886 asn1_delete_structure(element);
887 return ASN1_DER_ERROR;
888 }
889
890 return ASN1_SUCCESS;
891 }
892
893
894 #define FOUND 1
895 #define SAME_BRANCH 2
896 #define OTHER_BRANCH 3
897 #define EXIT 4
898
899 /**
900 * asn1_der_decoding_element - Fill the element named ELEMENTNAME of the structure STRUCTURE with values of a DER encoding string.
901 * @structure: pointer to an ASN1 structure
902 * @elementName: name of the element to fill
903 * @der: vector that contains the DER encoding of the whole structure.
904 * @len: number of bytes of *der: der[0]..der[len-1]
905 * @errorDescription: null-terminated string contains details when an arror accured.
906 *
907 * Description:
908 *
909 * Fill the element named ELEMENTNAME with values of a DER encoding string.
910 * The sructure must just be created with function 'create_stucture'.
911 * The DER vector must contain the encoding string of the whole STRUCTURE.
912 * If an error accurs during the decoding procedure, the *STRUCTURE is deleted
913 * and set equal to ASN1_TYPE_EMPTY.
914 *
915 * Returns:
916 *
917 * ASN1_SUCCESS\: DER encoding OK
918 *
919 * ASN1_ELEMENT_NOT_FOUND\: ELEMENT is ASN1_TYPE_EMPTY or elementName == NULL.
920 *
921 * ASN1_TAG_ERROR,ASN1_DER_ERROR\: the der encoding doesn't match the structure STRUCTURE. *ELEMENT deleted.
922 *
923 **/
924 asn1_retCode
925 asn1_der_decoding_element(ASN1_TYPE *structure,const char *elementName,
926 const unsigned char *der,int len,char *errorDescription)
927 {
928 node_asn *node,*p,*p2,*p3,*nodeFound=ASN1_TYPE_EMPTY;
929 char temp[128],currentName[MAX_NAME_SIZE*10],*dot_p,*char_p;
930 int nameLen=MAX_NAME_SIZE*10-1,state;
931 int counter,len2,len3,len4,move,ris;
932 unsigned char class,*temp2;
933 unsigned int tag;
934 int indefinite;
935
936 node=*structure;
937
938 if(node==ASN1_TYPE_EMPTY) return ASN1_ELEMENT_NOT_FOUND;
939
940 if(elementName == NULL){
941 asn1_delete_structure(structure);
942 return ASN1_ELEMENT_NOT_FOUND;
943 }
944
945 if(node->type&CONST_OPTION){
946 asn1_delete_structure(structure);
947 return ASN1_GENERIC_ERROR;
948 }
949
950 if((*structure)->name){ /* Has *structure a name? */
951 nameLen-=strlen((*structure)->name);
952 if(nameLen>0) strcpy(currentName,(*structure)->name);
953 else{
954 asn1_delete_structure(structure);
955 return ASN1_MEM_ERROR;
956 }
957 if(!(strcmp(currentName,elementName))){
958 state=FOUND;
959 nodeFound=*structure;
960 }
961 else if(!memcmp(currentName,elementName,strlen(currentName)))
962 state=SAME_BRANCH;
963 else
964 state=OTHER_BRANCH;
965 }
966 else{ /* *structure doesn't have a name? */
967 currentName[0]=0;
968 if(elementName[0]==0){
969 state=FOUND;
970 nodeFound=*structure;
971 }
972 else{
973 state=SAME_BRANCH;
974 }
975 }
976
977 counter=0;
978 move=DOWN;
979 p=node;
980 while(1){
981
982 ris=ASN1_SUCCESS;
983
984 if(move!=UP){
985 if(p->type&CONST_SET){
986 p2=_asn1_find_up(p);
987 len2=strtol(p2->value,NULL,10);
988 if(counter==len2){
989 p=p2;
990 move=UP;
991 continue;
992 }
993 else if(counter>len2){
994 asn1_delete_structure(structure);
995 return ASN1_DER_ERROR;
996 }
997 p2=p2->down;
998 while(p2){
999 if((p2->type&CONST_SET) && (p2->type&CONST_NOT_USED)){
1000 if(type_field(p2->type)!=TYPE_CHOICE)
1001 ris=_asn1_extract_tag_der(p2,der+counter,&len2);
1002 else{
1003 p3=p2->down;
1004 while(p3){
1005 ris=_asn1_extract_tag_der(p3,der+counter,&len2);
1006 if(ris==ASN1_SUCCESS) break;
1007 p3=p3->right;
1008 }
1009 }
1010 if(ris==ASN1_SUCCESS){
1011 p2->type&=~CONST_NOT_USED;
1012 p=p2;
1013 break;
1014 }
1015 }
1016 p2=p2->right;
1017 }
1018 if(p2==NULL){
1019 asn1_delete_structure(structure);
1020 return ASN1_DER_ERROR;
1021 }
1022 }
1023
1024 if((p->type&CONST_OPTION) || (p->type&CONST_DEFAULT)){
1025 p2=_asn1_find_up(p);
1026 len2=strtol(p2->value,NULL,10);
1027 if(counter==len2){
1028 if(p->right){
1029 p2=p->right;
1030 move=RIGHT;
1031 }
1032 else move=UP;
1033
1034 if(p->type&CONST_OPTION) asn1_delete_structure(&p);
1035
1036 p=p2;
1037 continue;
1038 }
1039 }
1040
1041 if(type_field(p->type)==TYPE_CHOICE){
1042 while(p->down){
1043 if(counter<len)
1044 ris=_asn1_extract_tag_der(p->down,der+counter,&len2);
1045 else
1046 ris=ASN1_DER_ERROR;
1047 if(ris==ASN1_SUCCESS){
1048 while(p->down->right){
1049 p2=p->down->right;
1050 asn1_delete_structure(&p2);
1051 }
1052 break;
1053 }
1054 else if(ris==ASN1_ERROR_TYPE_ANY){
1055 asn1_delete_structure(structure);
1056 return ASN1_ERROR_TYPE_ANY;
1057 }
1058 else{
1059 p2=p->down;
1060 asn1_delete_structure(&p2);
1061 }
1062 }
1063
1064 if(p->down==NULL){
1065 if(!(p->type&CONST_OPTION)){
1066 asn1_delete_structure(structure);
1067 return ASN1_DER_ERROR;
1068 }
1069 }
1070 else
1071 p=p->down;
1072 }
1073
1074 if((p->type&CONST_OPTION) || (p->type&CONST_DEFAULT)){
1075 p2=_asn1_find_up(p);
1076 len2=strtol(p2->value,NULL,10);
1077 if(counter>len2) ris=ASN1_TAG_ERROR;
1078 }
1079
1080 if(ris==ASN1_SUCCESS) ris=_asn1_extract_tag_der(p,der+counter,&len2);
1081 if(ris!=ASN1_SUCCESS){
1082 if(p->type&CONST_OPTION){
1083 p->type|=CONST_NOT_USED;
1084 move=RIGHT;
1085 }
1086 else if(p->type&CONST_DEFAULT) {
1087 _asn1_set_value(p,NULL,0);
1088 move=RIGHT;
1089 }
1090 else {
1091 if (errorDescription!=NULL)
1092 _asn1_error_description_tag_error(p,errorDescription);
1093
1094 asn1_delete_structure(structure);
1095 return ASN1_TAG_ERROR;
1096 }
1097 }
1098 else counter+=len2;
1099 }
1100
1101 if(ris==ASN1_SUCCESS){
1102 switch(type_field(p->type)){
1103 case TYPE_NULL:
1104 if(der[counter]){
1105 asn1_delete_structure(structure);
1106 return ASN1_DER_ERROR;
1107 }
1108
1109 if(p==nodeFound) state=EXIT;
1110
1111 counter++;
1112 move=RIGHT;
1113 break;
1114 case TYPE_BOOLEAN:
1115 if(der[counter++]!=1){
1116 asn1_delete_structure(structure);
1117 return ASN1_DER_ERROR;
1118 }
1119
1120 if(state==FOUND){
1121 if(der[counter++]==0) _asn1_set_value(p,"F",1);
1122 else _asn1_set_value(p,"T",1);
1123
1124 if(p==nodeFound) state=EXIT;
1125
1126 }
1127 else
1128 counter++;
1129
1130 move=RIGHT;
1131 break;
1132 case TYPE_INTEGER: case TYPE_ENUMERATED:
1133 len2=_asn1_get_length_der(der+counter,&len3);
1134 if(state==FOUND){
1135 _asn1_set_value(p,der+counter,len3+len2);
1136
1137 if(p==nodeFound) state=EXIT;
1138 }
1139 counter+=len3+len2;
1140 move=RIGHT;
1141 break;
1142 case TYPE_OBJECT_ID:
1143 if(state==FOUND){
1144 _asn1_get_objectid_der(der+counter,&len2, temp, sizeof(temp));
1145 _asn1_set_value(p,temp,strlen(temp)+1);
1146
1147 if(p==nodeFound) state=EXIT;
1148 }
1149 else{
1150 len2=_asn1_get_length_der(der+counter,&len3);
1151 len2+=len3;
1152 }
1153
1154 counter+=len2;
1155 move=RIGHT;
1156 break;
1157 case TYPE_TIME:
1158 if(state==FOUND){
1159 _asn1_get_time_der(der+counter,&len2,temp);
1160 _asn1_set_value(p,temp,strlen(temp)+1);
1161
1162 if(p==nodeFound) state=EXIT;
1163 }
1164 else{
1165 len2=_asn1_get_length_der(der+counter,&len3);
1166 len2+=len3;
1167 }
1168
1169 counter+=len2;
1170 move=RIGHT;
1171 break;
1172 case TYPE_OCTET_STRING:
1173 len3=len-counter;
1174 if(state==FOUND){
1175 ris=_asn1_get_octet_string(der+counter,p,&len3);
1176 if(p==nodeFound) state=EXIT;
1177 }
1178 else
1179 ris=_asn1_get_octet_string(der+counter,NULL,&len3);
1180
1181 if(ris != ASN1_SUCCESS) return ris;
1182 counter+=len3;
1183 move=RIGHT;
1184 break;
1185 case TYPE_GENERALSTRING:
1186 len2=_asn1_get_length_der(der+counter,&len3);
1187 if(state==FOUND){
1188 _asn1_set_value(p,der+counter,len3+len2);
1189
1190 if(p==nodeFound) state=EXIT;
1191 }
1192 counter+=len3+len2;
1193 move=RIGHT;
1194 break;
1195 case TYPE_BIT_STRING:
1196 len2=_asn1_get_length_der(der+counter,&len3);
1197 if(state==FOUND){
1198 _asn1_set_value(p,der+counter,len3+len2);
1199
1200 if(p==nodeFound) state=EXIT;
1201 }
1202 counter+=len3+len2;
1203 move=RIGHT;
1204 break;
1205 case TYPE_SEQUENCE: case TYPE_SET:
1206 if(move==UP){
1207 len2=strtol(p->value,NULL,10);
1208 _asn1_set_value(p,NULL,0);
1209 if(len2==-1){ /* indefinite length method */
1210 if((der[counter]) || der[counter+1]){
1211 asn1_delete_structure(structure);
1212 return ASN1_DER_ERROR;
1213 }
1214 counter+=2;
1215 }
1216 else{ /* definite length method */
1217 if(len2!=counter){
1218 asn1_delete_structure(structure);
1219 return ASN1_DER_ERROR;
1220 }
1221 }
1222 if(p==nodeFound) state=EXIT;
1223 move=RIGHT;
1224 }
1225 else{ /* move==DOWN || move==RIGHT */
1226 if(state==OTHER_BRANCH){
1227 len3=_asn1_get_length_der(der+counter,&len2);
1228 counter+=len2+len3;
1229 move=RIGHT;
1230 }
1231 else { /* state==SAME_BRANCH or state==FOUND */
1232 len3=_asn1_get_length_der(der+counter,&len2);
1233 counter+=len2;
1234 if(len3>0){
1235 _asn1_ltostr(counter+len3,temp);
1236 _asn1_set_value(p,temp,strlen(temp)+1);
1237 move=DOWN;
1238 }
1239 else if(len3==0){
1240 p2=p->down;
1241 while(p2){
1242 if(type_field(p2->type)!=TYPE_TAG){
1243 p3=p2->right;
1244 asn1_delete_structure(&p2);
1245 p2=p3;
1246 }
1247 else
1248 p2=p2->right;
1249 }
1250 move=RIGHT;
1251 }
1252 else{ /* indefinite length method */
1253 _asn1_set_value(p,"-1",3);
1254 move=DOWN;
1255 }
1256 }
1257 }
1258 break;
1259 case TYPE_SEQUENCE_OF: case TYPE_SET_OF:
1260 if(move==UP){
1261 len2=strtol(p->value,NULL,10);
1262 if(len2>counter){
1263 _asn1_append_sequence_set(p);
1264 p=p->down;
1265 while(p->right) p=p->right;
1266 move=RIGHT;
1267 continue;
1268 }
1269 _asn1_set_value(p,NULL,0);
1270 if(len2!=counter){
1271 asn1_delete_structure(structure);
1272 return ASN1_DER_ERROR;
1273 }
1274
1275 if(p==nodeFound) state=EXIT;
1276 }
1277 else{ /* move==DOWN || move==RIGHT */
1278 if(state==OTHER_BRANCH){
1279 len3=_asn1_get_length_der(der+counter,&len2);
1280 counter+=len2+len3;
1281 move=RIGHT;
1282 }
1283 else{ /* state==FOUND or state==SAME_BRANCH */
1284 len3=_asn1_get_length_der(der+counter,&len2);
1285 counter+=len2;
1286 if(len3){
1287 _asn1_ltostr(counter+len3,temp);
1288 _asn1_set_value(p,temp,strlen(temp)+1);
1289 p2=p->down;
1290 while((type_field(p2->type)==TYPE_TAG) || (type_field(p2->type)==TYPE_SIZE)) p2=p2->right;
1291 if(p2->right==NULL) _asn1_append_sequence_set(p);
1292 p=p2;
1293 state=FOUND;
1294 }
1295 }
1296 }
1297
1298 break;
1299 case TYPE_ANY:
1300 /* Check indefinite lenth method in a EXPLICIT TAG */
1301 if((p->type&CONST_TAG) && (der[counter-1]==0x80))
1302 indefinite=1;
1303 else
1304 indefinite=0;
1305
1306 tag=_asn1_get_tag_der(der+counter,&class,&len2);
1307 len4=_asn1_get_length_der(der+counter+len2,&len3);
1308
1309 if(len4 != -1){
1310 len2+=len4;
1311 if(state==FOUND){
1312 _asn1_length_der(len2+len3,NULL,&len4);
1313 temp2=(unsigned char *)_asn1_alloca(len2+len3+len4);
1314 if (temp2==NULL){
1315 asn1_delete_structure(structure);
1316 return ASN1_MEM_ALLOC_ERROR;
1317 }
1318
1319 _asn1_octet_der(der+counter,len2+len3,temp2,&len4);
1320 _asn1_set_value(p,temp2,len4);
1321 _asn1_afree(temp2);
1322
1323 if(p==nodeFound) state=EXIT;
1324 }
1325 counter+=len2+len3;
1326 }
1327 else{ /* indefinite length */
1328 len2=len-counter;
1329 ris=_asn1_get_indefinite_length_string(der+counter,&len2);
1330 if(ris != ASN1_SUCCESS){
1331 asn1_delete_structure(structure);
1332 return ris;
1333 }
1334
1335 if(state==FOUND){
1336 _asn1_length_der(len2,NULL,&len4);
1337 temp2=(unsigned char *)_asn1_alloca(len2+len4);
1338 if (temp2==NULL){
1339 asn1_delete_structure(structure);
1340 return ASN1_MEM_ALLOC_ERROR;
1341 }
1342
1343 _asn1_octet_der(der+counter,len2,temp2,&len4);
1344 _asn1_set_value(p,temp2,len4);
1345 _asn1_afree(temp2);
1346
1347 if(p==nodeFound) state=EXIT;
1348 }
1349
1350 counter+=len2;
1351 }
1352
1353 /* Check if a couple of 0x00 are present due to an EXPLICIT TAG with
1354 a indefinite length method. */
1355 if(indefinite){
1356 if(!der[counter] && !der[counter+1]){
1357 counter+=2;
1358 }
1359 else{
1360 asn1_delete_structure(structure);
1361 return ASN1_DER_ERROR;
1362 }
1363 }
1364 move=RIGHT;
1365 break;
1366
1367 default:
1368 move=(move==UP)?RIGHT:DOWN;
1369 break;
1370 }
1371 }
1372
1373 if((p==node && move!=DOWN) || (state==EXIT)) break;
1374
1375 if(move==DOWN){
1376 if(p->down){
1377 p=p->down;
1378
1379 if(state != FOUND){
1380 nameLen-=strlen(p->name)+1;
1381 if(nameLen>0){
1382 if(currentName[0]) strcat(currentName,".");
1383 strcat(currentName,p->name);
1384 }
1385 else{
1386 asn1_delete_structure(structure);
1387 return ASN1_MEM_ERROR;
1388 }
1389 if(!(strcmp(currentName,elementName))){
1390 state=FOUND;
1391 nodeFound=p;
1392 }
1393 else if(!memcmp(currentName,elementName,strlen(currentName)))
1394 state=SAME_BRANCH;
1395 else
1396 state=OTHER_BRANCH;
1397 }
1398 }
1399 else move=RIGHT;
1400 }
1401
1402 if((move==RIGHT) && !(p->type&CONST_SET)){
1403 if(p->right){
1404 p=p->right;
1405
1406 if(state != FOUND){
1407 dot_p=char_p=currentName;
1408 while((char_p=strchr(char_p,'.'))){
1409 dot_p=char_p++;
1410 dot_p++;
1411 }
1412
1413 nameLen+=strlen(currentName)-(dot_p-currentName);
1414 *dot_p=0;
1415
1416 nameLen-=strlen(p->name);
1417 if(nameLen>0) strcat(currentName,p->name);
1418 else{
1419 asn1_delete_structure(structure);
1420 return ASN1_MEM_ERROR;
1421 }
1422
1423 if(!(strcmp(currentName,elementName))){
1424 state=FOUND;
1425 nodeFound=p;
1426 }
1427 else if(!memcmp(currentName,elementName,strlen(currentName)))
1428 state=SAME_BRANCH;
1429 else
1430 state=OTHER_BRANCH;
1431 }
1432 }
1433 else move=UP;
1434 }
1435
1436 if(move==UP){
1437 p=_asn1_find_up(p);
1438
1439 if(state != FOUND){
1440 dot_p=char_p=currentName;
1441 while((char_p=strchr(char_p,'.'))){
1442 dot_p=char_p++;
1443 dot_p++;
1444 }
1445
1446 nameLen+=strlen(currentName)-(dot_p-currentName);
1447 *dot_p=0;
1448
1449 if(!(strcmp(currentName,elementName))){
1450 state=FOUND;
1451 nodeFound=p;
1452 }
1453 else if(!memcmp(currentName,elementName,strlen(currentName)))
1454 state=SAME_BRANCH;
1455 else
1456 state=OTHER_BRANCH;
1457 }
1458 }
1459 }
1460
1461 _asn1_delete_not_used(*structure);
1462
1463 if(counter > len){
1464 asn1_delete_structure(structure);
1465 return ASN1_DER_ERROR;
1466 }
1467
1468 return ASN1_SUCCESS;
1469 }
1470
1471
1472
1473 /**
1474 * asn1_der_decoding_startEnd - Find the start and end point of an element in a DER encoding string.
1475 * @element: pointer to an ASN1 element
1476 * @der: vector that contains the DER encoding.
1477 * @len: number of bytes of *der: der[0]..der[len-1]
1478 * @name_element: an element of NAME structure.
1479 * @start: the position of the first byte of NAME_ELEMENT decoding (der[*start])
1480 * @end: the position of the last byte of NAME_ELEMENT decoding (der[*end])
1481 * Description:
1482 *
1483 * Find the start and end point of an element in a DER encoding string. I mean that if you
1484 * have a der encoding and you have already used the function "asn1_der_decoding" to fill a structure, it may
1485 * happen that you want to find the piece of string concerning an element of the structure.
1486 *
1487 * Example: the sequence "tbsCertificate" inside an X509 certificate.
1488 *
1489 * Returns:
1490 *
1491 * ASN1_SUCCESS\: DER encoding OK
1492 *
1493 * ASN1_ELEMENT_NOT_FOUND\: ELEMENT is ASN1_TYPE EMPTY or NAME_ELEMENT is not a valid element.
1494 *
1495 * ASN1_TAG_ERROR,ASN1_DER_ERROR\: the der encoding doesn't match the structure ELEMENT.
1496 *
1497 **/
1498 asn1_retCode
1499 asn1_der_decoding_startEnd(ASN1_TYPE element,const unsigned char *der,int len,
1500 const char *name_element,int *start, int *end)
1501 {
1502 node_asn *node,*node_to_find,*p,*p2,*p3;
1503 int counter,len2,len3,len4,move,ris;
1504 unsigned char class;
1505 unsigned int tag;
1506 int indefinite;
1507
1508 node=element;
1509
1510 if(node==ASN1_TYPE_EMPTY) return ASN1_ELEMENT_NOT_FOUND;
1511
1512 node_to_find=_asn1_find_node(node,name_element);
1513
1514 if(node_to_find==NULL) return ASN1_ELEMENT_NOT_FOUND;
1515
1516 if(node_to_find==node){
1517 *start=0;
1518 *end=len-1;
1519 return ASN1_SUCCESS;
1520 }
1521
1522 if(node->type&CONST_OPTION) return ASN1_GENERIC_ERROR;
1523
1524 counter=0;
1525 move=DOWN;
1526 p=node;
1527 while(1){
1528 ris=ASN1_SUCCESS;
1529
1530 if(move!=UP){
1531 if(p->type&CONST_SET){
1532 p2=_asn1_find_up(p);
1533 len2=strtol(p2->value,NULL,10);
1534 if(len2==-1){
1535 if(!der[counter] && !der[counter+1]){
1536 p=p2;
1537 move=UP;
1538 counter+=2;
1539 continue;
1540 }
1541 }
1542 else if(counter==len2){
1543 p=p2;
1544 move=UP;
1545 continue;
1546 }
1547 else if(counter>len2) return ASN1_DER_ERROR;
1548 p2=p2->down;
1549 while(p2){
1550 if((p2->type&CONST_SET) && (p2->type&CONST_NOT_USED)){ /* CONTROLLARE */
1551 if(type_field(p2->type)!=TYPE_CHOICE)
1552 ris=_asn1_extract_tag_der(p2,der+counter,&len2);
1553 else{
1554 p3=p2->down;
1555 ris=_asn1_extract_tag_der(p3,der+counter,&len2);
1556 }
1557 if(ris==ASN1_SUCCESS){
1558 p2->type&=~CONST_NOT_USED;
1559 p=p2;
1560 break;
1561 }
1562 }
1563 p2=p2->right;
1564 }
1565 if(p2==NULL) return ASN1_DER_ERROR;
1566 }
1567
1568 if(p==node_to_find) *start=counter;
1569
1570 if(type_field(p->type)==TYPE_CHOICE){
1571 p=p->down;
1572 ris=_asn1_extract_tag_der(p,der+counter,&len2);
1573 if(p==node_to_find) *start=counter;
1574 }
1575
1576 if(ris==ASN1_SUCCESS) ris=_asn1_extract_tag_der(p,der+counter,&len2);
1577 if(ris!=ASN1_SUCCESS){
1578 if(p->type&CONST_OPTION){
1579 p->type|=CONST_NOT_USED;
1580 move=RIGHT;
1581 }
1582 else if(p->type&CONST_DEFAULT) {
1583 move=RIGHT;
1584 }
1585 else {
1586 return ASN1_TAG_ERROR;
1587 }
1588 }
1589 else counter+=len2;
1590 }
1591
1592 if(ris==ASN1_SUCCESS){
1593 switch(type_field(p->type)){
1594 case TYPE_NULL:
1595 if(der[counter]) return ASN1_DER_ERROR;
1596 counter++;
1597 move=RIGHT;
1598 break;
1599 case TYPE_BOOLEAN:
1600 if(der[counter++]!=1) return ASN1_DER_ERROR;
1601 counter++;
1602 move=RIGHT;
1603 break;
1604 case TYPE_INTEGER: case TYPE_ENUMERATED:
1605 len2=_asn1_get_length_der(der+counter,&len3);
1606 counter+=len3+len2;
1607 move=RIGHT;
1608 break;
1609 case TYPE_OBJECT_ID:
1610 len2=_asn1_get_length_der(der+counter,&len3);
1611 counter+=len2+len3;
1612 move=RIGHT;
1613 break;
1614 case TYPE_TIME:
1615 len2=_asn1_get_length_der(der+counter,&len3);
1616 counter+=len2+len3;
1617 move=RIGHT;
1618 break;
1619 case TYPE_OCTET_STRING:
1620 len3=len-counter;
1621 ris=_asn1_get_octet_string(der+counter,NULL,&len3);
1622 if(ris != ASN1_SUCCESS) return ris;
1623 counter+=len3;
1624 move=RIGHT;
1625 break;
1626 case TYPE_GENERALSTRING:
1627 len2=_asn1_get_length_der(der+counter,&len3);
1628 counter+=len3+len2;
1629 move=RIGHT;
1630 break;
1631 case TYPE_BIT_STRING:
1632 len2=_asn1_get_length_der(der+counter,&len3);
1633 counter+=len3+len2;
1634 move=RIGHT;
1635 break;
1636 case TYPE_SEQUENCE: case TYPE_SET:
1637 if(move!=UP){
1638 len3=_asn1_get_length_der(der+counter,&len2);
1639 counter+=len2;
1640 if(len3==0) move=RIGHT;
1641 else move=DOWN;
1642 }
1643 else{
1644 if(!der[counter] && !der[counter+1]) /* indefinite length method */
1645 counter+=2;
1646 move=RIGHT;
1647 }
1648 break;
1649 case TYPE_SEQUENCE_OF: case TYPE_SET_OF:
1650 if(move!=UP){
1651 len3=_asn1_get_length_der(der+counter,&len2);
1652 counter+=len2;
1653 if((len3==-1) && !der[counter] && !der[counter+1])
1654 counter+=2;
1655 else if(len3){
1656 p2=p->down;
1657 while((type_field(p2->type)==TYPE_TAG) ||
1658 (type_field(p2->type)==TYPE_SIZE)) p2=p2->right;
1659 p=p2;
1660 }
1661 }
1662 else{
1663 if(!der[counter] && !der[counter+1]) /* indefinite length method */
1664 counter+=2;
1665 }
1666 move=RIGHT;
1667 break;
1668 case TYPE_ANY:
1669 /* Check indefinite lenth method in a EXPLICIT TAG */
1670 if((p->type&CONST_TAG) && (der[counter-1]==0x80))
1671 indefinite=1;
1672 else
1673 indefinite=0;
1674
1675 tag=_asn1_get_tag_der(der+counter,&class,&len2);
1676 len4=_asn1_get_length_der(der+counter+len2,&len3);
1677
1678 if(len4 != -1){
1679 counter+=len2+len4+len3;
1680 }
1681 else{ /* indefinite length */
1682 len2=len-counter;
1683 ris=_asn1_get_indefinite_length_string(der+counter,&len2);
1684 if(ris != ASN1_SUCCESS)
1685 return ris;
1686 counter+=len2;
1687 }
1688
1689 /* Check if a couple of 0x00 are present due to an EXPLICIT TAG with
1690 a indefinite length method. */
1691 if(indefinite){
1692 if(!der[counter] && !der[counter+1])
1693 counter+=2;
1694 else
1695 return ASN1_DER_ERROR;
1696 }
1697 move=RIGHT;
1698 break;
1699 default:
1700 move=(move==UP)?RIGHT:DOWN;
1701 break;
1702 }
1703 }
1704
1705 if((p==node_to_find) && (move==RIGHT)){
1706 *end=counter-1;
1707 return ASN1_SUCCESS;
1708 }
1709
1710 if(p==node && move!=DOWN) break;
1711
1712 if(move==DOWN){
1713 if(p->down) p=p->down;
1714 else move=RIGHT;
1715 }
1716 if((move==RIGHT) && !(p->type&CONST_SET)){
1717 if(p->right) p=p->right;
1718 else move=UP;
1719 }
1720 if(move==UP) p=_asn1_find_up(p);
1721 }
1722
1723 return ASN1_ELEMENT_NOT_FOUND;
1724 }
1725
1726
1727 /**
1728 * asn1_expand_any_defined_by - Expand every "ANY DEFINED BY" fields of
1729 * structure *ELEMENT with the corresponding type.
1730 * @definitions: ASN1 definitions
1731 * @element: pointer to an ASN1 structure
1732 * Description:
1733 *
1734 * Expands every "ANY DEFINED BY" element of a structure created from
1735 * a DER decoding process (asn1_der_decoding function). The element ANY
1736 * must be defined by an OBJECT IDENTIFIER. The type used to expand
1737 * the element ANY is the first one following the definition of
1738 * the actual value of the OBJECT IDENTIFIER.
1739 *
1740 *
1741 * Returns:
1742 *
1743 * ASN1_SUCCESS\: substitution OK
1744 *
1745 * ASN1_ERROR_TYPE_ANY\: some "ANY DEFINED BY" element couldn't be expanded
1746 * due to a problem in OBJECT_ID -> TYPE association.
1747 * other errors\: result of der decoding process.
1748 **/
1749
1750 asn1_retCode
1751 asn1_expand_any_defined_by(ASN1_TYPE definitions,ASN1_TYPE *element)
1752 {
1753 char definitionsName[MAX_NAME_SIZE],name[2*MAX_NAME_SIZE+1],value[MAX_NAME_SIZE];
1754 asn1_retCode retCode=ASN1_SUCCESS,result;
1755 int len,len2,len3;
1756 ASN1_TYPE p,p2,p3,aux=ASN1_TYPE_EMPTY;
1757 char errorDescription[MAX_ERROR_DESCRIPTION_SIZE];
1758
1759 if((definitions==ASN1_TYPE_EMPTY) || (*element==ASN1_TYPE_EMPTY))
1760 return ASN1_ELEMENT_NOT_FOUND;
1761
1762 strcpy(definitionsName,definitions->name);
1763 strcat(definitionsName,".");
1764
1765 p=*element;
1766 while(p){
1767
1768 switch(type_field(p->type)){
1769 case TYPE_ANY:
1770 if((p->type&CONST_DEFINED_BY) && (p->value)){
1771 /* search the "DEF_BY" element */
1772 p2=p->down;
1773 while((p2) && (type_field(p2->type)!=TYPE_CONSTANT))
1774 p2=p2->right;
1775
1776 if(!p2){
1777 retCode=ASN1_ERROR_TYPE_ANY;
1778 break;
1779 }
1780
1781 p3=_asn1_find_up(p);
1782
1783 if(!p3){
1784 retCode=ASN1_ERROR_TYPE_ANY;
1785 break;
1786 }
1787
1788 p3=p3->down;
1789 while(p3){
1790 if((p3->name) && !(strcmp(p3->name,p2->name))) break;
1791 p3=p3->right;
1792 }
1793
1794 if((!p3) || (type_field(p3->type)!=TYPE_OBJECT_ID) ||
1795 (p3->value==NULL)){
1796
1797 p3=_asn1_find_up(p);
1798 p3=_asn1_find_up(p3);
1799
1800 if(!p3){
1801 retCode=ASN1_ERROR_TYPE_ANY;
1802 break;
1803 }
1804
1805 p3=p3->down;
1806
1807 while(p3){
1808 if((p3->name) && !(strcmp(p3->name,p2->name))) break;
1809 p3=p3->right;
1810 }
1811
1812 if((!p3) || (type_field(p3->type)!=TYPE_OBJECT_ID) ||
1813 (p3->value==NULL)){
1814 retCode=ASN1_ERROR_TYPE_ANY;
1815 break;
1816 }
1817 }
1818
1819 /* search the OBJECT_ID into definitions */
1820 p2=definitions->down;
1821 while(p2){
1822 if((type_field(p2->type)==TYPE_OBJECT_ID) &&
1823 (p2->type & CONST_ASSIGN)){
1824 strcpy(name,definitionsName);
1825 strcat(name,p2->name);
1826
1827 len=MAX_NAME_SIZE;
1828 result=asn1_read_value(definitions,name,value,&len);
1829
1830 if((result == ASN1_SUCCESS) && (!strcmp(p3->value,value))){
1831 p2=p2->right; /* pointer to the structure to
1832 use for expansion */
1833 while((p2) && (p2->type & CONST_ASSIGN))
1834 p2=p2->right;
1835
1836 if(p2){
1837 strcpy(name,definitionsName);
1838 strcat(name,p2->name);
1839
1840 result=asn1_create_element(definitions,name,&aux);
1841 if(result == ASN1_SUCCESS){
1842 _asn1_set_name(aux,p->name);
1843 len2=_asn1_get_length_der(p->value,&len3);
1844
1845 result=asn1_der_decoding(&aux,p->value+len3,len2,
1846 errorDescription);
1847 if(result == ASN1_SUCCESS){
1848
1849 _asn1_set_right(aux,p->right);
1850 _asn1_set_right(p,aux);
1851
1852 result=asn1_delete_structure(&p);
1853 if(result == ASN1_SUCCESS){
1854 p=aux;
1855 aux=ASN1_TYPE_EMPTY;
1856 break;
1857 }
1858 else{ /* error with asn1_delete_structure */
1859 asn1_delete_structure(&aux);
1860 retCode=result;
1861 break;
1862 }
1863 }
1864 else{/* error with asn1_der_decoding */
1865 retCode=result;
1866 break;
1867 }
1868 }
1869 else{/* error with asn1_create_element */
1870 retCode=result;
1871 break;
1872 }
1873 }
1874 else{/* error with the pointer to the structure to exapand */
1875 retCode=ASN1_ERROR_TYPE_ANY;
1876 break;
1877 }
1878 }
1879 }
1880 p2=p2->right;
1881 } /* end while */
1882
1883 if(!p2){
1884 retCode=ASN1_ERROR_TYPE_ANY;
1885 break;
1886 }
1887
1888 }
1889 break;
1890 default:
1891 break;
1892 }
1893
1894
1895 if(p->down){
1896 p=p->down;
1897 }
1898 else if(p==*element){
1899 p=NULL;
1900 break;
1901 }
1902 else if(p->right) p=p->right;
1903 else{
1904 while(1){
1905 p=_asn1_find_up(p);
1906 if(p==*element){
1907 p=NULL;
1908 break;
1909 }
1910 if(p->right){
1911 p=p->right;
1912 break;
1913 }
1914 }
1915 }
1916 }
1917
1918 return retCode;
1919 }
1920
1921
1922
1923 /**
1924 * asn1_expand_octet_string - Expand an "OCTET STRING" fields of
1925 * structure *ELEMENT with the corresponding type.
1926 * @definitions: ASN1 definitions
1927 * @element: pointer to an ASN1 structure
1928 * @octetName: name of the OCTECT STRING field to expand.
1929 * @objectName: name of the OBJECT IDENTIFIER field to use to define
1930 * the type for expansion.
1931 *
1932 * Description:
1933 *
1934 * Expands an "OCTET STRING" element of a structure created from
1935 * a DER decoding process (asn1_der_decoding function). The type used
1936 * for expansion is the first one following the definition of
1937 * the actual value of the OBJECT IDENTIFIER indicated by OBJECTNAME.
1938 *
1939 * Returns:
1940 *
1941 * ASN1_SUCCESS\: substitution OK
1942 *
1943 * ASN1_ELEMENT_NOT_FOUND\: OBJECTNAME or OCTETNAME are not correct.
1944 *
1945 * ASN1_VALUE_NOT_VALID\: wasn't possible to find the type to use
1946 * for expansion.
1947 *
1948 * other errors\: result of der decoding process.
1949 **/
1950 asn1_retCode
1951 asn1_expand_octet_string(ASN1_TYPE definitions,ASN1_TYPE *element,
1952 const char *octetName,const char *objectName)
1953 {
1954 char name[2*MAX_NAME_SIZE+1],value[MAX_NAME_SIZE];
1955 asn1_retCode retCode=ASN1_SUCCESS,result;
1956 int len,len2,len3;
1957 ASN1_TYPE p2,aux=ASN1_TYPE_EMPTY;
1958 ASN1_TYPE octetNode=ASN1_TYPE_EMPTY,objectNode=ASN1_TYPE_EMPTY;
1959 char errorDescription[MAX_ERROR_DESCRIPTION_SIZE];
1960
1961 if((definitions==ASN1_TYPE_EMPTY) || (*element==ASN1_TYPE_EMPTY))
1962 return ASN1_ELEMENT_NOT_FOUND;
1963
1964 octetNode=_asn1_find_node(*element,octetName);
1965 if(octetNode==ASN1_TYPE_EMPTY)
1966 return ASN1_ELEMENT_NOT_FOUND;
1967 if(type_field(octetNode->type)!=TYPE_OCTET_STRING)
1968 return ASN1_ELEMENT_NOT_FOUND;
1969 if(octetNode->value==NULL)
1970 return ASN1_VALUE_NOT_FOUND;
1971
1972 objectNode=_asn1_find_node(*element,objectName);
1973 if(objectNode==ASN1_TYPE_EMPTY)
1974 return ASN1_ELEMENT_NOT_FOUND;
1975
1976 if(type_field(objectNode->type)!=TYPE_OBJECT_ID)
1977 return ASN1_ELEMENT_NOT_FOUND;
1978
1979 if(objectNode->value==NULL)
1980 return ASN1_VALUE_NOT_FOUND;
1981
1982
1983 /* search the OBJECT_ID into definitions */
1984 p2=definitions->down;
1985 while(p2){
1986 if((type_field(p2->type)==TYPE_OBJECT_ID) &&
1987 (p2->type & CONST_ASSIGN)){
1988 strcpy(name,definitions->name);
1989 strcat(name,".");
1990 strcat(name,p2->name);
1991
1992 len = sizeof(value);
1993 result=asn1_read_value(definitions,name,value,&len);
1994
1995 if((result == ASN1_SUCCESS) && (!strcmp(objectNode->value,value))){
1996
1997 p2=p2->right; /* pointer to the structure to
1998 use for expansion */
1999 while((p2) && (p2->type & CONST_ASSIGN))
2000 p2=p2->right;
2001
2002 if(p2){
2003 strcpy(name,definitions->name);
2004 strcat(name,".");
2005 strcat(name,p2->name);
2006
2007 result=asn1_create_element(definitions,name,&aux);
2008 if(result == ASN1_SUCCESS){
2009 _asn1_set_name(aux,octetNode->name);
2010 len2=_asn1_get_length_der(octetNode->value,&len3);
2011
2012 result=asn1_der_decoding(&aux,octetNode->value+len3,len2,
2013 errorDescription);
2014 if(result == ASN1_SUCCESS){
2015
2016 _asn1_set_right(aux,octetNode->right);
2017 _asn1_set_right(octetNode,aux);
2018
2019 result=asn1_delete_structure(&octetNode);
2020 if(result == ASN1_SUCCESS){
2021 aux=ASN1_TYPE_EMPTY;
2022 break;
2023 }
2024 else{ /* error with asn1_delete_structure */
2025 asn1_delete_structure(&aux);
2026 retCode=result;
2027 break;
2028 }
2029 }
2030 else{/* error with asn1_der_decoding */
2031 retCode=result;
2032 break;
2033 }
2034 }
2035 else{/* error with asn1_create_element */
2036 retCode=result;
2037 break;
2038 }
2039 }
2040 else{/* error with the pointer to the structure to exapand */
2041 retCode=ASN1_VALUE_NOT_VALID;
2042 break;
2043 }
2044 }
2045 }
2046
2047 p2=p2->right;
2048
2049 }
2050
2051 if(!p2) retCode=ASN1_VALUE_NOT_VALID;
2052
2053 return retCode;
2054 }
2055
2056
2057
2058
2059
2060
2061
Free Kerberos V5 implementation