* sign.c (update_keysig_packet): Policies and notations should be stripped
[gnupg.git] / g10 / tlv.c
1 /* tlv.c - Tag-Length-Value Utilities
2  *      Copyright (C) 2003, 2004 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG 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
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21 #include <config.h>
22
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <assert.h>
27
28 #include "errors.h"
29 #include "util.h"
30 #include "packet.h"
31 #include "tlv.h"
32
33 static const unsigned char *
34 do_find_tlv (const unsigned char *buffer, size_t length,
35              int tag, size_t *nbytes, int nestlevel)
36 {
37   const unsigned char *s = buffer;
38   size_t n = length;
39   size_t len;
40   int this_tag;
41   int composite;
42     
43   for (;;)
44     {
45       buffer = s;
46       if (n < 2)
47         return NULL; /* Buffer definitely too short for tag and length. */
48       if (!*s || *s == 0xff)
49         { /* Skip optional filler between TLV objects. */
50           s++;
51           n--;
52           continue;
53         }
54       composite = !!(*s & 0x20);
55       if ((*s & 0x1f) == 0x1f)
56         { /* more tag bytes to follow */
57           s++;
58           n--;
59           if (n < 2)
60             return NULL; /* buffer definitely too short for tag and length. */
61           if ((*s & 0x1f) == 0x1f)
62             return NULL; /* We support only up to 2 bytes. */
63           this_tag = (s[-1] << 8) | (s[0] & 0x7f);
64         }
65       else
66         this_tag = s[0];
67       len = s[1];
68       s += 2; n -= 2;
69       if (len < 0x80)
70         ;
71       else if (len == 0x81)
72         { /* One byte length follows. */
73           if (!n)
74             return NULL; /* we expected 1 more bytes with the length. */
75           len = s[0];
76           s++; n--;
77         }
78       else if (len == 0x82)
79         { /* Two byte length follows. */
80           if (n < 2)
81             return NULL; /* We expected 2 more bytes with the length. */
82           len = (s[0] << 8) | s[1];
83           s += 2; n -= 2;
84         }
85       else
86         return NULL; /* APDU limit is 65535, thus it does not make
87                         sense to assume longer length fields. */
88
89       if (composite && nestlevel < 100)
90         { /* Dive into this composite DO after checking for a too deep
91              nesting. */
92           const unsigned char *tmp_s;
93           size_t tmp_len;
94           
95           tmp_s = do_find_tlv (s, len, tag, &tmp_len, nestlevel+1);
96           if (tmp_s)
97             {
98               *nbytes = tmp_len;
99               return tmp_s;
100             }
101         }
102
103       if (this_tag == tag)
104         {
105           *nbytes = len;
106           return s;
107         }
108       if (len > n)
109         return NULL; /* Buffer too short to skip to the next tag. */
110       s += len; n -= len;
111     }
112 }
113
114
115 /* Locate a TLV encoded data object in BUFFER of LENGTH and
116    return a pointer to value as well as its length in NBYTES.  Return
117    NULL if it was not found.  Note, that the function does not check
118    whether the value fits into the provided buffer. */
119 const unsigned char *
120 find_tlv (const unsigned char *buffer, size_t length,
121           int tag, size_t *nbytes)
122 {
123   return do_find_tlv (buffer, length, tag, nbytes, 0);
124 }
125
126
127
128
129 /* ASN.1 BER parser: Parse BUFFER of length SIZE and return the tag
130    and the length part from the TLV triplet.  Update BUFFER and SIZE
131    on success. */
132 gpg_error_t
133 parse_ber_header (unsigned char const **buffer, size_t *size,
134                   int *r_class, int *r_tag, 
135                   int *r_constructed, int *r_ndef,
136                   size_t *r_length, size_t *r_nhdr)
137 {
138   int c;
139   unsigned long tag;
140   const unsigned char *buf = *buffer;
141   size_t length = *size;
142
143   *r_ndef = 0;
144   *r_length = 0;
145   *r_nhdr = 0;
146
147   /* Get the tag. */
148   if (!length)
149     return gpg_error (GPG_ERR_EOF);
150   c = *buf++; length--; ++*r_nhdr;
151
152   *r_class = (c & 0xc0) >> 6;
153   *r_constructed = !!(c & 0x20);
154   tag = c & 0x1f;
155
156   if (tag == 0x1f)
157     {
158       tag = 0;
159       do
160         {
161           tag <<= 7;
162           if (!length)
163             return gpg_error (GPG_ERR_EOF);
164           c = *buf++; length--; ++*r_nhdr;
165           tag |= c & 0x7f;
166
167         }
168       while (c & 0x80);
169     }
170   *r_tag = tag;
171
172   /* Get the length. */
173   if (!length)
174     return gpg_error (GPG_ERR_EOF);
175   c = *buf++; length--; ++*r_nhdr;
176
177   if ( !(c & 0x80) )
178     *r_length = c;
179   else if (c == 0x80)
180     *r_ndef = 1;
181   else if (c == 0xff)
182     return gpg_error (GPG_ERR_BAD_BER);
183   else
184     {
185       unsigned long len = 0;
186       int count = c & 0x7f;
187
188       if (count > sizeof (len) || count > sizeof (size_t))
189         return gpg_error (GPG_ERR_BAD_BER);
190
191       for (; count; count--)
192         {
193           len <<= 8;
194           if (!length)
195             return gpg_error (GPG_ERR_EOF);
196           c = *buf++; length--; ++*r_nhdr;
197           len |= c & 0xff;
198         }
199       *r_length = len;
200     }
201   
202   /* Without this kludge some example certs can't be parsed. */
203   if (*r_class == CLASS_UNIVERSAL && !*r_tag)
204     *r_length = 0;
205   
206   *buffer = buf;
207   *size = length;
208   return 0;
209 }