"ssn_range" needs to be a copy of "global_ssn_range", so that it's not
[obnox/wireshark/wip.git] / asn1.c
1 /* asn1.c
2  * Routines for ASN.1 BER dissection
3  *
4  * $Id$
5  *
6  * Ethereal - Network traffic analyzer
7  * By Gerald Combs <gerald@ethereal.com>
8  *
9  * Based on "g_asn1.c" from:
10  *
11  * GXSNMP -- An snmp mangament application
12  * Copyright (C) 1998 Gregory McLean & Jochen Friedrich
13  * Beholder RMON ethernet network monitor, Copyright (C) 1993 DNPAP group
14  *
15  * This program is free software; you can redistribute it and/or modify
16  * it under the terms of the GNU General Public License as published by
17  * the Free Software Foundation; either version 2 of the License, or
18  * (at your option) any later version.
19  *
20  * This program is distributed in the hope that it will be useful,
21  * but WITHOUT ANY WARRANTY; without even the implied warranty of
22  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
23  * GNU General Public License for more details.
24  *
25  * You should have received a copy of the GNU General Public License
26  * along with this program; if not, write to the Free Software
27  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
28  */
29
30 /*
31  * MODULE INFORMATION
32  * ------------------
33  *     FILE     NAME:       g_asn1.c
34  *     SYSTEM   NAME:       ASN1 Basic Encoding
35  *     ORIGINAL AUTHOR(S):  Dirk Wisse
36  *     VERSION  NUMBER:     1
37  *     CREATION DATE:       1990/11/22
38  *
39  * DESCRIPTION: ASN1 Basic Encoding Rules.
40  *
41  *              To decode this we must do:
42  *
43  *              asn1_open (asn1, tvb, offset);
44  *              asn1_header_decode (asn1, &end_of_seq, cls, con, tag, def, len);
45  *              asn1_header_decode (asn1, &end_of_octs, cls, con, tag, def, len);
46  *              asn1_octets_decode (asn1, end_of_octs, str, len);
47  *              asn1_header_decode (asn1, &end_of_int, cls, con, tag);
48  *              asn1_int_decode (asn1, end_of_int, &integer);
49  *              asn1_eoc_decode (asn1, end_of_seq);
50  *              asn1_close (asn1, &offset);
51  *
52  *              For indefinite encoding end_of_seq and &end_of_seq in the
53  *              example above should be replaced by NULL.
54  *              For indefinite decoding nothing has to be changed.
55  *              This can be very useful if you want to decode both
56  *              definite and indefinite encodings.
57  */
58
59 #ifdef HAVE_CONFIG_H
60 # include "config.h"
61 #endif
62
63 #include <stdio.h>
64
65 #include <limits.h>
66
67 #include <glib.h>
68
69 #ifdef NEED_SNPRINTF_H
70 # include "snprintf.h"
71 #endif
72
73 #include <epan/tvbuff.h>
74 #include "asn1.h"
75
76 /*
77  * NAME:        asn1_open                                   [API]
78  * SYNOPSIS:    void asn1_open
79  *                  (
80  *                      ASN1_SCK *asn1,
81  *                      tvbuff_t *tvb,
82  *                      int       offset
83  *                  )
84  * DESCRIPTION: Opens an ASN1 socket.
85  *              Parameters:
86  *              asn1:   pointer to ASN1 socket.
87  *              tvb:    Tvbuff for encoding.
88  *              offset: Current offset in tvbuff.
89  *              Encoding starts at the end of the buffer, and
90  *              proceeds to the beginning.
91  * RETURNS:     void
92  */
93
94 void
95 asn1_open(ASN1_SCK *asn1, tvbuff_t *tvb, int offset)
96 {
97     asn1->tvb = tvb;
98     asn1->offset = offset;
99 }
100
101 /*
102  * NAME:        asn1_close                                  [API]
103  * SYNOPSIS:    void asn1_close
104  *                  (
105  *                      ASN1_SCK   *asn1,
106  *                      int        *offset
107  *                  )
108  * DESCRIPTION: Closes an ASN1 socket.
109  *              Parameters:
110  *              asn1:   pointer to ASN1 socket.
111  *              offset: pointer to variable into which current offset is
112  *              to be put.
113  * RETURNS:     void
114  */
115
116 void
117 asn1_close(ASN1_SCK *asn1, int *offset)
118 {
119     *offset = asn1->offset;
120 }
121
122 /*
123  * NAME:        asn1_octet_decode
124  * SYNOPSIS:    int asn1_octet_decode
125  *                  (
126  *                      ASN1_SCK *asn1,
127  *                      guchar   *ch
128  *                  )
129  * DESCRIPTION: Decodes an octet.
130  * RETURNS:     ASN1_ERR value (ASN1_ERR_NOERROR on success)
131  */
132 int
133 asn1_octet_decode(ASN1_SCK *asn1, guchar *ch)
134 {
135     *ch = tvb_get_guint8(asn1->tvb, asn1->offset);
136     asn1->offset++;
137     return ASN1_ERR_NOERROR;
138 }
139
140 /*
141  * NAME:        asn1_tag_get
142  * SYNOPSIS:    int asn1_tag_get
143  *                  (
144  *                      ASN1_SCK *asn1,
145  *                      guint    *tag
146  *                  )
147  * DESCRIPTION: Decodes a tag number, combining it with existing tag bits.
148  * RETURNS:     ASN1_ERR value (ASN1_ERR_NOERROR on success)
149  */
150 static int
151 asn1_tag_get(ASN1_SCK *asn1, guint *tag)
152 {
153     int    ret;
154     guchar ch;
155
156     do {
157         ret = asn1_octet_decode (asn1, &ch);
158         if (ret != ASN1_ERR_NOERROR)
159             return ret;
160         *tag <<= 7;
161         *tag |= ch & 0x7F;
162     } while ((ch & 0x80) == 0x80);
163     return ASN1_ERR_NOERROR;
164 }
165
166 /*
167  * NAME:        asn1_tag_decode
168  * SYNOPSIS:    int asn1_tag_decode
169  *                  (
170  *                      ASN1_SCK *asn1,
171  *                      guint    *tag
172  *                  )
173  * DESCRIPTION: Decodes a tag number.
174  * RETURNS:     ASN1_ERR value (ASN1_ERR_NOERROR on success)
175  */
176 int
177 asn1_tag_decode(ASN1_SCK *asn1, guint *tag)
178 {
179     *tag = 0;
180     return asn1_tag_get(asn1, tag);
181 }
182
183 /*
184  * NAME:        asn1_id_decode
185  * SYNOPSIS:    int asn1_id_decode
186  *                  (
187  *                      ASN1_SCK *asn1,
188  *                      guint    *cls,
189  *                      guint    *con,
190  *                      guint    *tag
191  *                  )
192  * DESCRIPTION: Decodes an identifier.
193  * RETURNS:     ASN1_ERR value (ASN1_ERR_NOERROR on success)
194  */
195 int
196 asn1_id_decode(ASN1_SCK *asn1, guint *cls, guint *con, guint *tag)
197 {
198     int    ret;
199     guchar ch;
200
201     *tag = 0;
202     ret = asn1_octet_decode (asn1, &ch);
203     if (ret != ASN1_ERR_NOERROR)
204         return ret;
205     *cls = (ch & 0xC0) >> 6;
206     *con = (ch & 0x20) >> 5;
207     *tag = (ch & 0x1F);
208     if (*tag == 0x1F) {
209         ret = asn1_tag_decode (asn1, tag);
210         if (ret != ASN1_ERR_NOERROR)
211             return ret;
212     }
213     return ASN1_ERR_NOERROR;
214 }
215
216 /*
217  * NAME:        asn1_id_decode1
218  * SYNOPSIS:    int asn1_id_decode1
219  *                  (
220  *                      ASN1_SCK *asn1,
221  *                      guint    *tag
222  *                  )
223  * DESCRIPTION: Decodes an identifier.
224  *              Like asn1_id_decode() except that the Class and Constructor
225  *              bits are returned in the tag.
226  * RETURNS:     ASN1_ERR value (ASN1_ERR_NOERROR on success)
227  */
228 int
229 asn1_id_decode1(ASN1_SCK *asn1, guint *tag)
230 {
231     int    ret;
232     guchar ch;
233
234     *tag = 0;
235     ret = asn1_octet_decode (asn1, &ch);
236     if (ret != ASN1_ERR_NOERROR)
237         return ret;
238
239     *tag = ch;
240     if ((*tag & 0x1F) == 0x1F) { /* high-tag-number format */
241         *tag = ch >> 5; /* leave just the Class and Constructor bits */
242         ret = asn1_tag_get (asn1, tag);
243         if (ret != ASN1_ERR_NOERROR)
244             return ret;
245     }
246     return ASN1_ERR_NOERROR;
247 }
248
249 /*
250  * NAME:        asn1_length_decode
251  * SYNOPSIS:    int asn1_length_decode
252  *                  (
253  *                      ASN1_SCK *asn1,
254  *                      gboolean *def,
255  *                      guint    *len
256  *                  )
257  * DESCRIPTION: Decodes an ASN1 length.
258  *              Parameters:
259  *              asn1: pointer to ASN1 socket.
260  *              def: Boolean - TRUE if length definite, FALSE if not
261  *              len: length, if length is definite
262  * DESCRIPTION: Decodes a definite or indefinite length.
263  * RETURNS:     ASN1_ERR value (ASN1_ERR_NOERROR on success)
264  */
265 int
266 asn1_length_decode(ASN1_SCK *asn1, gboolean *def, guint *len)
267 {
268     int    ret;
269     guchar ch, cnt;
270
271     ret = asn1_octet_decode (asn1, &ch);
272     if (ret != ASN1_ERR_NOERROR)
273         return ret;
274     if (ch == 0x80)
275         *def = FALSE;           /* indefinite length */
276     else {
277         *def = TRUE;            /* definite length */
278         if (ch < 0x80)
279             *len = ch;
280         else {
281             cnt = (guchar) (ch & 0x7F);
282             *len = 0;
283             while (cnt > 0) {
284                 ret = asn1_octet_decode (asn1, &ch);
285                 if (ret != ASN1_ERR_NOERROR)
286                     return ret;
287                 *len <<= 8;
288                 *len |= ch;
289                 cnt--;
290             }
291         }
292     }
293     return ASN1_ERR_NOERROR;
294 }
295
296 /*
297  * NAME:        asn1_header_decode                                [API]
298  * SYNOPSIS:    int asn1_header_decode
299  *                  (
300  *                      ASN1_SCK *asn1,
301  *                      guint    *cls,
302  *                      guint    *con,
303  *                      guint    *tag
304  *                      gboolean *defp,
305  *                      guint    *lenp
306  *                  )
307  * DESCRIPTION: Decodes an ASN1 header.
308  *              Parameters:
309  *              asn1: pointer to ASN1 socket.
310  *              cls:  Class (see asn1.h)
311  *              con:  Primitive, Constructed (ASN1_PRI, ASN1_CON)
312  *              tag:  Tag (see asn1.h)
313  *              defp: Boolean - TRUE if length definite, FALSE if not
314  *              lenp: length, if length is definite
315  * RETURNS:     ASN1_ERR value (ASN1_ERR_NOERROR on success)
316  */
317 int
318 asn1_header_decode(ASN1_SCK *asn1, guint *cls, guint *con, guint *tag,
319                         gboolean *defp, guint *lenp)
320 {
321     int   ret;
322     guint def, len;
323
324     ret = asn1_id_decode (asn1, cls, con, tag);
325     if (ret != ASN1_ERR_NOERROR)
326         return ret;
327     ret = asn1_length_decode (asn1, &def, &len);
328     if (ret != ASN1_ERR_NOERROR)
329         return ret;
330     *defp = def;
331     *lenp = len;
332     return ASN1_ERR_NOERROR;
333 }
334
335
336 /*
337  * NAME:        asn1_eoc                                   [API]
338  * SYNOPSIS:    gboolean asn1_eoc
339  *                  (
340  *                      ASN1_SCK *asn1,
341  *                      int       eoc
342  *                  )
343  * DESCRIPTION: Checks if decoding is at End Of Contents.
344  *              Parameters:
345  *              asn1: pointer to ASN1 socket.
346  *              eoc: offset of end of encoding, or -1 if indefinite.
347  * RETURNS:     gboolean success
348  */
349 gboolean
350 asn1_eoc ( ASN1_SCK *asn1, int eoc)
351 {
352     if (eoc == -1)
353         return (tvb_get_guint8(asn1->tvb, asn1->offset) == 0x00
354                 && tvb_get_guint8(asn1->tvb, asn1->offset + 1) == 0x00);
355     else
356         return (asn1->offset >= eoc);
357 }
358
359 /*
360  * NAME:        asn1_eoc_decode                                [API]
361  * SYNOPSIS:    int asn1_eoc_decode
362  *                  (
363  *                      ASN1_SCK  *asn1,
364  *                      int       eoc
365  *                  )
366  * DESCRIPTION: Decodes End Of Contents.
367  *              Parameters:
368  *              asn1: pointer to ASN1 socket.
369  *              eoc: offset of end of encoding, or -1 if indefinite.
370  *              If eoc is -1 it decodes an ASN1 End Of
371  *              Contents (0x00 0x00), so it has to be an
372  *              indefinite length encoding. If eoc is a non-negative
373  *              integer, it probably was filled by asn1_header_decode,
374  *              and should refer to the octet after the last of the encoding.
375  *              It is checked if this offset refers to the octet to be
376  *              decoded. This only takes place in decoding a
377  *              definite length encoding.
378  * RETURNS:     ASN1_ERR value (ASN1_ERR_NOERROR on success)
379  */
380 int
381 asn1_eoc_decode (ASN1_SCK *asn1, int eoc)
382 {
383     int    ret;
384     guchar ch;
385
386     if (eoc == -1) {
387         ret = asn1_octet_decode (asn1, &ch);
388         if (ret != ASN1_ERR_NOERROR)
389             return ret;
390       if (ch != 0x00)
391         return ASN1_ERR_EOC_MISMATCH;
392       ret = asn1_octet_decode (asn1, &ch);
393       if (ret != ASN1_ERR_NOERROR)
394         return ret;
395       if (ch != 0x00)
396         return ASN1_ERR_EOC_MISMATCH;
397       return ASN1_ERR_NOERROR;
398   } else {
399       if (asn1->offset != eoc)
400         return ASN1_ERR_LENGTH_MISMATCH;
401       return ASN1_ERR_NOERROR;
402     }
403 }
404
405 /*
406  * NAME:        asn1_null_decode                                [API]
407  * SYNOPSIS:    int asn1_null_decode
408  *                  (
409  *                      ASN1_SCK *asn1,
410  *                      int      enc_len
411  *                  )
412  * DESCRIPTION: Decodes Null.
413  *              Parameters:
414  *              asn1:    pointer to ASN1 socket.
415  *              enc_len: length of encoding of value.
416  * RETURNS:     ASN1_ERR value (ASN1_ERR_NOERROR on success)
417  */
418 int
419 asn1_null_decode ( ASN1_SCK *asn1, int enc_len)
420 {
421     asn1->offset += enc_len;
422     return ASN1_ERR_NOERROR;
423 }
424
425 /*
426  * NAME:        asn1_bool_decode                                [API]
427  * SYNOPSIS:    int asn1_bool_decode
428  *                  (
429  *                      ASN1_SCK *asn1,
430  *                      int      enc_len,
431  *                      gboolean *boolean
432  *                  )
433  * DESCRIPTION: Decodes Boolean.
434  *              Parameters:
435  *              asn1:    pointer to ASN1 socket.
436  *              enc_len: length of encoding of value.
437  *              bool:    False, True (0, !0).
438  * RETURNS:     ASN1_ERR value (ASN1_ERR_NOERROR on success)
439  */
440 int
441 asn1_bool_decode ( ASN1_SCK *asn1, int enc_len, gboolean *boolean)
442 {
443     int    ret;
444     guchar ch;
445
446     if (enc_len != 1)
447       return ASN1_ERR_LENGTH_MISMATCH;
448     ret = asn1_octet_decode (asn1, &ch);
449     if (ret != ASN1_ERR_NOERROR)
450         return ret;
451     *boolean = ch ? TRUE : FALSE;
452     return ASN1_ERR_NOERROR;
453 }
454
455 /*
456  * NAME:        asn1_int32_value_decode                                [API]
457  * SYNOPSIS:    int asn1_int32_value_decode
458  *                  (
459  *                      ASN1_SCK *asn1,
460  *                      int      enc_len,
461  *                      gint32   *integer
462  *                  )
463  * DESCRIPTION: Decodes value portion of Integer (which must be no more
464  *              than 32 bits).
465  *              Parameters:
466  *              asn1:    pointer to ASN1 socket.
467  *              enc_len: length of encoding of value.
468  *              integer: Integer.
469  * RETURNS:     ASN1_ERR value (ASN1_ERR_NOERROR on success)
470  */
471 int
472 asn1_int32_value_decode ( ASN1_SCK *asn1, int enc_len, gint32 *integer)
473 {
474     int          ret;
475     int          eoc;
476     guchar       ch;
477     guint        len;
478
479     eoc = asn1->offset + enc_len;
480     ret = asn1_octet_decode (asn1, &ch);
481     if (ret != ASN1_ERR_NOERROR)
482         return ret;
483     *integer = (gint) ch;
484     len = 1;
485     while (asn1->offset < eoc) {
486         if (++len > sizeof (gint32))
487             return ASN1_ERR_WRONG_LENGTH_FOR_TYPE;
488         ret = asn1_octet_decode (asn1, &ch);
489         if (ret != ASN1_ERR_NOERROR)
490             return ret;
491         *integer <<= 8;
492         *integer |= ch;
493     }
494     return ASN1_ERR_NOERROR;
495 }
496
497 /*
498  * NAME:        asn1_int32_decode                                [API]
499  * SYNOPSIS:    int asn1_int32_decode
500  *                  (
501  *                      ASN1_SCK *asn1,
502  *                      gint32   *integer,
503  *                      guint    *nbytes,
504  *                  )
505  * DESCRIPTION: Decodes Integer (which must be no more than 32 bits).
506  *              Parameters:
507  *              asn1:    pointer to ASN1 socket.
508  *              integer: Integer.
509  *              nbytes:  number of bytes used to encode it.
510  * RETURNS:     ASN1_ERR value (ASN1_ERR_NOERROR on success)
511  */
512 int
513 asn1_int32_decode ( ASN1_SCK *asn1, gint32 *integer, guint *nbytes)
514 {
515     int          ret;
516     int          start;
517     guint        cls;
518     guint        con;
519     guint        tag;
520     gboolean     def;
521     guint        enc_len;
522
523     start = asn1->offset;
524     ret = asn1_header_decode (asn1, &cls, &con, &tag, &def, &enc_len);
525     if (ret != ASN1_ERR_NOERROR)
526         goto done;
527     if (cls != ASN1_UNI || con != ASN1_PRI || tag != ASN1_INT) {
528         ret = ASN1_ERR_WRONG_TYPE;
529         goto done;
530     }
531     if (!def) {
532         ret = ASN1_ERR_LENGTH_NOT_DEFINITE;
533         goto done;
534     }
535     ret = asn1_int32_value_decode (asn1, enc_len, integer);
536
537 done:
538     *nbytes = asn1->offset - start;
539     return ret;
540 }
541
542 /*
543  * NAME:        asn1_uint32_value_decode                             [API]
544  * SYNOPSIS:    int asn1_uint32_value_decode
545  *                  (
546  *                      ASN1_SCK *asn1,
547  *                      int      enc_len,
548  *                      guint32  *integer
549  *                  )
550  * DESCRIPTION: Decodes value part of Unsigned Integer (which must be no
551  *              more than 32 bits).
552  *              Parameters:
553  *              asn1:    pointer to ASN1 socket.
554  *              enc_len: length of encoding of value.
555  *              integer: Integer.
556  * RETURNS:     ASN1_ERR value (ASN1_ERR_NOERROR on success)
557  */
558 int
559 asn1_uint32_value_decode ( ASN1_SCK *asn1, int enc_len, guint32 *integer)
560 {
561     int          ret;
562     int          eoc;
563     guchar       ch;
564     guint        len;
565
566     eoc = asn1->offset + enc_len;
567     ret = asn1_octet_decode (asn1, &ch);
568     if (ret != ASN1_ERR_NOERROR)
569         return ret;
570     *integer = ch;
571     if (ch == 0)
572         len = 0;
573     else
574         len = 1;
575     while (asn1->offset < eoc) {
576         if (++len > sizeof (guint32))
577             return ASN1_ERR_WRONG_LENGTH_FOR_TYPE;
578         ret = asn1_octet_decode (asn1, &ch);
579         if (ret != ASN1_ERR_NOERROR)
580             return ret;
581         *integer <<= 8;
582         *integer |= ch;
583     }
584     return ASN1_ERR_NOERROR;
585 }
586
587 /*
588  * NAME:        asn1_uint32_decode                             [API]
589  * SYNOPSIS:    int asn1_uint32_decode
590  *                  (
591  *                      ASN1_SCK *asn1,
592  *                      guint32  *integer,
593  *                      guint    *nbytes,
594  *                  )
595  * DESCRIPTION: Decodes Unsigned Integer (which must be no more than 32 bits).
596  *              Parameters:
597  *              asn1:    pointer to ASN1 socket.
598  *              integer: Integer.
599  *              nbytes:  number of bytes used to encode it.
600  * RETURNS:     ASN1_ERR value (ASN1_ERR_NOERROR on success)
601  */
602 int
603 asn1_uint32_decode ( ASN1_SCK *asn1, guint32 *integer, guint *nbytes)
604 {
605     int          ret;
606     int          start;
607     guint        cls;
608     guint        con;
609     guint        tag;
610     gboolean     def;
611     guint        enc_len;
612
613     start = asn1->offset;
614     ret = asn1_header_decode (asn1, &cls, &con, &tag, &def, &enc_len);
615     if (ret != ASN1_ERR_NOERROR)
616         goto done;
617     if (cls != ASN1_UNI || con != ASN1_PRI || tag != ASN1_INT) {
618         ret = ASN1_ERR_WRONG_TYPE;
619         goto done;
620     }
621     if (!def) {
622         ret = ASN1_ERR_LENGTH_NOT_DEFINITE;
623         goto done;
624     }
625     ret = asn1_uint32_value_decode (asn1, enc_len, integer);
626
627 done:
628     *nbytes = asn1->offset - start;
629     return ret;
630 }
631
632 /*
633  * NAME:        asn1_bits_decode                                [API]
634  * SYNOPSIS:    int asn1_bits_decode
635  *                  (
636  *                      ASN1_SCK  *asn1,
637  *                      int        eoc,
638  *                      guchar    *bits,
639  *                      guint      size,
640  *                      guint      len,
641  *                      guchar     unused
642  *                  )
643  * DESCRIPTION: Decodes Bit String.
644  *              Parameters:
645  *              asn1:    pointer to ASN1 socket.
646  *              enc_len: length of value.
647  *              bits:    pointer to variable we set to point to strring
648  *              len:     Size of Bit String in characters.
649  *              unused:  Number of unused bits in last character.
650  * RETURNS:     ASN1_ERR value (ASN1_ERR_NOERROR on success)
651  */
652 int
653 asn1_bits_decode ( ASN1_SCK *asn1, int enc_len, guchar **bits,
654                      guint *len, guchar *unused)
655 {
656     int ret;
657     int eoc;
658     guchar *ptr;
659
660     eoc = asn1->offset + enc_len;
661     *bits = NULL;
662     ret = asn1_octet_decode (asn1, unused);
663     if (ret != ASN1_ERR_NOERROR)
664         return ret;
665     *len = 0;
666
667     /*
668      * First, make sure the entire string is in the tvbuff, and throw
669      * an exception if it isn't.  If the length is bogus, this should
670      * keep us from trying to allocate an immensely large buffer.
671      * (It won't help if the length is *valid* but immensely large,
672      * but that's another matter; in any case, that would happen only
673      * if we had an immensely large tvbuff....)
674      */
675     if (enc_len != 0) {
676         tvb_ensure_bytes_exist(asn1->tvb, asn1->offset, enc_len);
677         *bits = g_malloc (enc_len);
678     } else {
679         /*
680          * If the length is 0, we allocate a 1-byte buffer, as
681          * "g_malloc()" returns NULL if passed 0 as an argument,
682          * and our caller expects us to return a pointer to a
683          * buffer.
684          */
685         *bits = g_malloc (1);
686     }
687
688     ptr = *bits;
689     while (asn1->offset < eoc) {
690         ret = asn1_octet_decode (asn1, (guchar *)ptr++);
691         if (ret != ASN1_ERR_NOERROR) {
692             g_free(*bits);
693             *bits = NULL;
694             return ret;
695         }
696     }
697     *len = ptr - *bits;
698     return ASN1_ERR_NOERROR;
699 }
700
701 /*
702  * NAME:        asn1_string_value_decode                       [API]
703  * SYNOPSIS:    int asn1_string_value_decode
704  *                  (
705  *                      ASN1_SCK *asn1,
706  *                      int      enc_len,
707  *                      guchar   **octets
708  *                  )
709  * DESCRIPTION: Decodes value portion of string (Octet String, various
710  *              character string types)
711  *              Parameters:
712  *              asn1:    pointer to ASN1 socket.
713  *              enc_len: length of encoding of value.
714  *              octets:  pointer to variable we set to point to string,
715  *                       which is '\0' terminated for ease of use as C-string
716  * RETURNS:     ASN1_ERR value (ASN1_ERR_NOERROR on success)
717  */
718 int
719 asn1_string_value_decode ( ASN1_SCK *asn1, int enc_len, guchar **octets)
720 {
721     int          ret;
722     int          eoc;
723     guchar       *ptr;
724
725     /*
726      * First, make sure the entire string is in the tvbuff, and throw
727      * an exception if it isn't.  If the length is bogus, this should
728      * keep us from trying to allocate an immensely large buffer.
729      * (It won't help if the length is *valid* but immensely large,
730      * but that's another matter; in any case, that would happen only
731      * if we had an immensely large tvbuff....)
732      */
733     if (enc_len != 0)
734         tvb_ensure_bytes_exist(asn1->tvb, asn1->offset, enc_len);
735     *octets = g_malloc (enc_len+1);
736
737     eoc = asn1->offset + enc_len;
738     ptr = *octets;
739     while (asn1->offset < eoc) {
740         ret = asn1_octet_decode (asn1, (guchar *)ptr++);
741         if (ret != ASN1_ERR_NOERROR) {
742             g_free(*octets);
743             *octets = NULL;
744             return ret;
745         }
746     }
747     *(guchar *)ptr = '\0';
748     return ASN1_ERR_NOERROR;
749 }
750
751 /*
752  * NAME:        asn1_string_decode                             [API]
753  * SYNOPSIS:    int asn1_string_decode
754  *                  (
755  *                      ASN1_SCK  *asn1,
756  *                      guchar    **octets,
757  *                      guint     *str_len,
758  *                      guint     *nbytes,
759  *                      guint     expected_tag
760  *                  )
761  * DESCRIPTION: Decodes string (Octet String, various character string
762  *              types)
763  *              Parameters:
764  *              asn1:         pointer to ASN1 socket.
765  *              octets:       pointer to variable we set to point to string.
766  *              str_len:      length of octet_string.
767  *              nbytes:       number of bytes used to encode.
768  *              expected_tag: tag expected for this type of string.
769  * RETURNS:     ASN1_ERR value (ASN1_ERR_NOERROR on success)
770  */
771 int
772 asn1_string_decode ( ASN1_SCK *asn1, guchar **octets, guint *str_len,
773                         guint *nbytes, guint expected_tag)
774 {
775     int          ret;
776     int          start;
777     int          enc_len;
778     guint        cls;
779     guint        con;
780     guint        tag;
781     gboolean     def;
782
783     start = asn1->offset;
784     ret = asn1_header_decode (asn1, &cls, &con, &tag, &def, &enc_len);
785     if (ret != ASN1_ERR_NOERROR)
786         goto done;
787     if (cls != ASN1_UNI || con != ASN1_PRI || tag != expected_tag) {
788         /* XXX - handle the constructed encoding? */
789         ret = ASN1_ERR_WRONG_TYPE;
790         goto done;
791     }
792     if (!def) {
793         ret = ASN1_ERR_LENGTH_NOT_DEFINITE;
794         goto done;
795     }
796
797     ret = asn1_string_value_decode (asn1, enc_len, octets);
798     *str_len = enc_len;
799
800 done:
801     *nbytes = asn1->offset - start;
802     return ret;
803 }
804
805 /*
806  * NAME:        asn1_octet_string_decode                             [API]
807  * SYNOPSIS:    int asn1_octet_string_decode
808  *                  (
809  *                      ASN1_SCK  *asn1,
810  *                      guchar    **octets,
811  *                      guint     *str_len,
812  *                      guint     *nbytes,
813  *                  )
814  * DESCRIPTION: Decodes Octet String.
815  *              Parameters:
816  *              asn1:    pointer to ASN1 socket.
817  *              octets:  pointer to variable we set to point to string.
818  *              str_len: length of octet_string.
819  *              nbytes:  number of bytes used to encode.
820  * RETURNS:     ASN1_ERR value (ASN1_ERR_NOERROR on success)
821  */
822 int
823 asn1_octet_string_decode ( ASN1_SCK *asn1, guchar **octets, guint *str_len,
824                         guint *nbytes)
825 {
826     return asn1_string_decode(asn1, octets, str_len, nbytes, ASN1_OTS);
827 }
828
829 /*
830  * NAME:        asn1_subid_decode
831  * SYNOPSIS:    int asn1_subid_decode
832  *                  (
833  *                      ASN1_SCK *asn1,
834  *                      subid_t  *subid
835  *                  )
836  * DESCRIPTION: Decodes Sub Identifier.
837  *              Parameters:
838  *              asn1:  pointer to ASN1 socket.
839  *              subid: Sub Identifier.
840  * RETURNS:     ASN1_ERR value (ASN1_ERR_NOERROR on success)
841  */
842 int
843 asn1_subid_decode ( ASN1_SCK *asn1, subid_t *subid)
844 {
845     int    ret;
846     guchar ch;
847
848     *subid = 0;
849     do {
850         ret = asn1_octet_decode(asn1, &ch);
851         if (ret != ASN1_ERR_NOERROR)
852             return ret;
853         *subid <<= 7;
854         *subid |= ch & 0x7F;
855     } while ((ch & 0x80) == 0x80);
856     return ASN1_ERR_NOERROR;
857 }
858
859 /*
860  * NAME:        asn1_oid_value_decode                                [API]
861  * SYNOPSIS:    int asn1_oid_value_decode
862  *                  (
863  *                      ASN1_SCK *asn1,
864  *                      int      enc_len,
865  *                      subid_t  **oid,
866  *                      guint    *len
867  *                  )
868  * DESCRIPTION: Decodes value portion of Object Identifier.
869  *              Parameters:
870  *              asn1:    pointer to ASN1 socket.
871  *              enc_len: length of encoding of value.
872  *              oid:     pointer to variable we set to Object Identifier.
873  *              len:     Length of Object Identifier in gulongs.
874  * RETURNS:     ASN1_ERR value (ASN1_ERR_NOERROR on success)
875  */
876 int
877 asn1_oid_value_decode ( ASN1_SCK *asn1, int enc_len, subid_t **oid, guint *len)
878 {
879     int          ret;
880     int          eoc;
881     subid_t      subid;
882     guint        size;
883     subid_t      *optr;
884
885     /*
886      * First, make sure the entire string is in the tvbuff, and throw
887      * an exception if it isn't.  If the length is bogus, this should
888      * keep us from trying to allocate an immensely large buffer.
889      * (It won't help if the length is *valid* but immensely large,
890      * but that's another matter; in any case, that would happen only
891      * if we had an immensely large tvbuff....)
892      */
893     if (enc_len != 0)
894         tvb_ensure_bytes_exist(asn1->tvb, asn1->offset, enc_len);
895
896     eoc = asn1->offset + enc_len;
897
898     size = enc_len + 1;
899     *oid = g_malloc(size * sizeof(gulong));
900     optr = *oid;
901
902     ret = asn1_subid_decode (asn1, &subid);
903     if (ret != ASN1_ERR_NOERROR) {
904         g_free(*oid);
905         *oid = NULL;
906         return ret;
907     }
908     if (subid < 40) {
909         optr[0] = 0;
910         optr[1] = subid;
911     } else if (subid < 80) {
912         optr[0] = 1;
913         optr[1] = subid - 40;
914     } else {
915         optr[0] = 2;
916         optr[1] = subid - 80;
917     }
918     *len = 2;
919     optr += 2;
920     while (asn1->offset < eoc) {
921         if (++(*len) > size) {
922             g_free(*oid);
923             *oid = NULL;
924             return ASN1_ERR_WRONG_LENGTH_FOR_TYPE;
925         }
926         ret = asn1_subid_decode (asn1, optr++);
927         if (ret != ASN1_ERR_NOERROR) {
928             g_free(*oid);
929             *oid = NULL;
930             return ret;
931         }
932     }
933     return ASN1_ERR_NOERROR;
934 }
935
936 /*
937  * NAME:        asn1_oid_decode                                [API]
938  * SYNOPSIS:    int asn1_oid_decode
939  *                  (
940  *                      ASN1_SCK *asn1,
941  *                      subid_t  **oid,
942  *                      guint    *len,
943  *                      guint    *nbytes
944  *                  )
945  * DESCRIPTION: Decodes Object Identifier.
946  *              Parameters:
947  *              asn1:   pointer to ASN1 socket.
948  *              oid:    pointer to variable we set to Object Identifier.
949  *              len:    Length of Object Identifier in gulongs.
950  *              nbytes: number of bytes used to encode.
951  * RETURNS:     ASN1_ERR value (ASN1_ERR_NOERROR on success)
952  */
953 int
954 asn1_oid_decode ( ASN1_SCK *asn1, subid_t **oid, guint *len, guint *nbytes)
955 {
956     int          ret;
957     int          start;
958     guint        cls;
959     guint        con;
960     guint        tag;
961     gboolean     def;
962     guint        enc_len;
963
964     start = asn1->offset;
965     ret = asn1_header_decode (asn1, &cls, &con, &tag, &def, &enc_len);
966     if (ret != ASN1_ERR_NOERROR)
967         goto done;
968     if (cls != ASN1_UNI || con != ASN1_PRI || tag != ASN1_OJI) {
969         ret = ASN1_ERR_WRONG_TYPE;
970         goto done;
971     }
972     if (!def) {
973         ret = ASN1_ERR_LENGTH_NOT_DEFINITE;
974         goto done;
975     }
976
977     ret = asn1_oid_value_decode (asn1, enc_len, oid, len);
978
979 done:
980     *nbytes = asn1->offset - start;
981     return ret;
982 }
983
984 /*
985  * NAME:        asn1_sequence_decode                             [API]
986  * SYNOPSIS:    int asn1_sequence_decode
987  *                  (
988  *                      ASN1_SCK  *asn1,
989  *                      guint     *seq_len,
990  *                      guint     *nbytes
991  *                  )
992  * DESCRIPTION: Decodes header for SEQUENCE.
993  *              Parameters:
994  *              asn1:    pointer to ASN1 socket.
995  *              seq_len: length of sequence.
996  *              nbytes:  number of bytes used to encode header.
997  * RETURNS:     ASN1_ERR value (ASN1_ERR_NOERROR on success)
998  */
999 int
1000 asn1_sequence_decode ( ASN1_SCK *asn1, guint *seq_len, guint *nbytes)
1001 {
1002     int          ret;
1003     int          start;
1004     guint        cls;
1005     guint        con;
1006     guint        tag;
1007     gboolean     def;
1008
1009     start = asn1->offset;
1010     ret = asn1_header_decode(asn1, &cls, &con, &tag,
1011             &def, seq_len);
1012     if (ret != ASN1_ERR_NOERROR)
1013         goto done;
1014     if (cls != ASN1_UNI || con != ASN1_CON || tag != ASN1_SEQ) {
1015         ret = ASN1_ERR_WRONG_TYPE;
1016         goto done;
1017     }
1018     if (!def) {
1019         /* XXX - might some sequences have an indefinite length? */
1020         ret = ASN1_ERR_LENGTH_NOT_DEFINITE;
1021         goto done;
1022     }
1023     ret = ASN1_ERR_NOERROR;
1024
1025 done:
1026     *nbytes = asn1->offset - start;
1027     return ret;
1028 }
1029
1030 /*
1031  * NAME:        asn1_err_to_str                             [API]
1032  * SYNOPSIS:    char *asn1_err_to_str
1033  *                  (
1034  *                      int     err
1035  *                  )
1036  * DESCRIPTION: Returns the string corresponding to an ASN.1 library error.
1037  *              Parameters:
1038  *              err: the error code
1039  * RETURNS:     string for the error
1040  */
1041 char *
1042 asn1_err_to_str(int err)
1043 {
1044     char         *errstr;
1045     char         errstrbuf[14+1+1+11+1+1];      /* "Unknown error (%d)\0" */
1046
1047     switch (err) {
1048
1049     case ASN1_ERR_EOC_MISMATCH:
1050         errstr = "EOC mismatch";
1051         break;
1052
1053     case ASN1_ERR_WRONG_TYPE:
1054         errstr = "Wrong type for that item";
1055         break;
1056
1057     case ASN1_ERR_LENGTH_NOT_DEFINITE:
1058         errstr = "Length was indefinite";
1059         break;
1060
1061     case ASN1_ERR_LENGTH_MISMATCH:
1062         errstr = "Length mismatch";
1063         break;
1064
1065     case ASN1_ERR_WRONG_LENGTH_FOR_TYPE:
1066         errstr = "Wrong length for that item's type";
1067         break;
1068
1069     default:
1070         snprintf(errstrbuf, sizeof errstrbuf, "Unknown error (%d)", err);
1071         errstr = errstrbuf;
1072         break;
1073     }
1074     return errstr;
1075 }