82db75f5e163638d9ac69e9ec998269ce10866f3
[openssl.git] / crypto / asn1 / a_int.c
1 /* crypto/asn1/a_int.c */
2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
3  * All rights reserved.
4  *
5  * This package is an SSL implementation written
6  * by Eric Young (eay@cryptsoft.com).
7  * The implementation was written so as to conform with Netscapes SSL.
8  * 
9  * This library is free for commercial and non-commercial use as long as
10  * the following conditions are aheared to.  The following conditions
11  * apply to all code found in this distribution, be it the RC4, RSA,
12  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
13  * included with this distribution is covered by the same copyright terms
14  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
15  * 
16  * Copyright remains Eric Young's, and as such any Copyright notices in
17  * the code are not to be removed.
18  * If this package is used in a product, Eric Young should be given attribution
19  * as the author of the parts of the library used.
20  * This can be in the form of a textual message at program startup or
21  * in documentation (online or textual) provided with the package.
22  * 
23  * Redistribution and use in source and binary forms, with or without
24  * modification, are permitted provided that the following conditions
25  * are met:
26  * 1. Redistributions of source code must retain the copyright
27  *    notice, this list of conditions and the following disclaimer.
28  * 2. Redistributions in binary form must reproduce the above copyright
29  *    notice, this list of conditions and the following disclaimer in the
30  *    documentation and/or other materials provided with the distribution.
31  * 3. All advertising materials mentioning features or use of this software
32  *    must display the following acknowledgement:
33  *    "This product includes cryptographic software written by
34  *     Eric Young (eay@cryptsoft.com)"
35  *    The word 'cryptographic' can be left out if the rouines from the library
36  *    being used are not cryptographic related :-).
37  * 4. If you include any Windows specific code (or a derivative thereof) from 
38  *    the apps directory (application code) you must include an acknowledgement:
39  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
40  * 
41  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
42  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
44  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
45  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
46  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
47  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
49  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
50  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
51  * SUCH DAMAGE.
52  * 
53  * The licence and distribution terms for any publically available version or
54  * derivative of this code cannot be changed.  i.e. this code cannot simply be
55  * copied and put under another distribution licence
56  * [including the GNU Public Licence.]
57  */
58
59 #include <stdio.h>
60 #include "cryptlib.h"
61 #include <openssl/asn1.h>
62
63 ASN1_INTEGER *ASN1_INTEGER_new(void)
64 { return M_ASN1_INTEGER_new();}
65
66 void ASN1_INTEGER_free(ASN1_INTEGER *x)
67 { M_ASN1_INTEGER_free(x);}
68
69 ASN1_INTEGER *ASN1_INTEGER_dup(ASN1_INTEGER *x)
70 { return M_ASN1_INTEGER_dup(x);}
71
72 int ASN1_INTEGER_cmp(ASN1_INTEGER *x, ASN1_INTEGER *y)
73 { return M_ASN1_INTEGER_cmp(x,y);}
74
75 /* 
76  * This converts an ASN1 INTEGER into its DER encoding.
77  * The internal representation is an ASN1_STRING whose data is a big endian
78  * representation of the value, ignoring the sign. The sign is determined by
79  * the type: V_ASN1_INTEGER for positive and V_ASN1_NEG_INTEGER for negative. 
80  *
81  * Positive integers are no problem: they are almost the same as the DER
82  * encoding, except if the first byte is >= 0x80 we need to add a zero pad.
83  *
84  * Negative integers are a bit trickier...
85  * The DER representation of negative integers is in 2s complement form.
86  * The internal form is converted by complementing each octet and finally 
87  * adding one to the result. This can be done less messily with a little trick.
88  * If the internal form has trailing zeroes then they will become FF by the
89  * complement and 0 by the add one (due to carry) so just copy as many trailing 
90  * zeros to the destination as there are in the source. The carry will add one
91  * to the last none zero octet: so complement this octet and add one and finally
92  * complement any left over until you get to the start of the string.
93  *
94  * Padding is a little trickier too. If the first bytes is > 0x80 then we pad
95  * with 0xff. However if the first byte is 0x80 and one of the following bytes
96  * is non-zero we pad with 0xff. The reason for this distinction is that 0x80
97  * followed by optional zeros isn't padded.
98  */
99
100 int i2d_ASN1_INTEGER(ASN1_INTEGER *a, unsigned char **pp)
101         {
102         int pad=0,ret,r,i,t;
103         unsigned char *p,*n,pb=0;
104
105         if ((a == NULL) || (a->data == NULL)) return(0);
106         t=a->type;
107         if (a->length == 0)
108                 ret=1;
109         else
110                 {
111                 ret=a->length;
112                 i=a->data[0];
113                 if ((t == V_ASN1_INTEGER) && (i > 127)) {
114                         pad=1;
115                         pb=0;
116                 } else if(t == V_ASN1_NEG_INTEGER) {
117                         if(i>128) {
118                                 pad=1;
119                                 pb=0xFF;
120                         } else if(i == 128) {
121                         /*
122                          * Special case: if any other bytes non zero we pad:
123                          * otherwise we don't.
124                          */
125                                 for(i = 1; i < a->length; i++) if(a->data[i]) {
126                                                 pad=1;
127                                                 pb=0xFF;
128                                                 break;
129                                 }
130                         }
131                 }
132                 ret+=pad;
133                 }
134         r=ASN1_object_size(0,ret,V_ASN1_INTEGER);
135         if (pp == NULL) return(r);
136         p= *pp;
137
138         ASN1_put_object(&p,0,ret,V_ASN1_INTEGER,V_ASN1_UNIVERSAL);
139         if (pad) *(p++)=pb;
140         if (a->length == 0) *(p++)=0;
141         else if (t == V_ASN1_INTEGER) memcpy(p,a->data,(unsigned int)a->length);
142         else {
143                 /* Begin at the end of the encoding */
144                 n=a->data + a->length - 1;
145                 p += a->length - 1;
146                 i = a->length;
147                 /* Copy zeros to destination as long as source is zero */
148                 while(!*n) {
149                         *(p--) = 0;
150                         n--;
151                         i--;
152                 }
153                 /* Complement and increment next octet */
154                 *(p--) = ((*(n--)) ^ 0xff) + 1;
155                 i--;
156                 /* Complement any octets left */
157                 for(;i > 0; i--) *(p--) = *(n--) ^ 0xff;
158         }
159
160         *pp+=r;
161         return(r);
162         }
163
164 ASN1_INTEGER *d2i_ASN1_INTEGER(ASN1_INTEGER **a, unsigned char **pp,
165              long length)
166         {
167         ASN1_INTEGER *ret=NULL;
168         unsigned char *p,*to,*s, *pend;
169         long len;
170         int inf,tag,xclass;
171         int i;
172
173         if ((a == NULL) || ((*a) == NULL))
174                 {
175                 if ((ret=M_ASN1_INTEGER_new()) == NULL) return(NULL);
176                 ret->type=V_ASN1_INTEGER;
177                 }
178         else
179                 ret=(*a);
180
181         p= *pp;
182         inf=ASN1_get_object(&p,&len,&tag,&xclass,length);
183         pend = p + len;
184         if (inf & 0x80)
185                 {
186                 i=ASN1_R_BAD_OBJECT_HEADER;
187                 goto err;
188                 }
189
190         if (tag != V_ASN1_INTEGER)
191                 {
192                 i=ASN1_R_EXPECTING_AN_INTEGER;
193                 goto err;
194                 }
195
196         /* We must OPENSSL_malloc stuff, even for 0 bytes otherwise it
197          * signifies a missing NULL parameter. */
198         s=(unsigned char *)OPENSSL_malloc((int)len+1);
199         if (s == NULL)
200                 {
201                 i=ERR_R_MALLOC_FAILURE;
202                 goto err;
203                 }
204         to=s;
205         if(!len) {
206                 /* Strictly speaking this is an illegal INTEGER but we
207                  * tolerate it.
208                  */
209                 ret->type=V_ASN1_INTEGER;
210         } else if (*p & 0x80) /* a negative number */
211                 {
212                 ret->type=V_ASN1_NEG_INTEGER;
213                 if ((*p == 0xff) && (len != 1)) {
214                         p++;
215                         len--;
216                 }
217                 i = len;
218                 p += i - 1;
219                 to += i - 1;
220                 while((!*p) && i) {
221                         *(to--) = 0;
222                         i--;
223                         p--;
224                 }
225                 /* Special case: if all zeros then the number will be of
226                  * the form FF followed by n zero bytes: this corresponds to
227                  * 1 followed by n zero bytes. We've already written n zeros
228                  * so we just append an extra one and set the first byte to
229                  * a 1. This is treated separately because it is the only case
230                  * where the number of bytes is larger than len.
231                  */
232                 if(!i) {
233                         *s = 1;
234                         s[len] = 0;
235                         len++;
236                 } else {
237                         *(to--) = (*(p--) ^ 0xff) + 1;
238                         i--;
239                         for(;i > 0; i--) *(to--) = *(p--) ^ 0xff;
240                 }
241         } else {
242                 ret->type=V_ASN1_INTEGER;
243                 if ((*p == 0) && (len != 1))
244                         {
245                         p++;
246                         len--;
247                         }
248                 memcpy(s,p,(int)len);
249         }
250
251         if (ret->data != NULL) OPENSSL_free(ret->data);
252         ret->data=s;
253         ret->length=(int)len;
254         if (a != NULL) (*a)=ret;
255         *pp=pend;
256         return(ret);
257 err:
258         ASN1err(ASN1_F_D2I_ASN1_INTEGER,i);
259         if ((ret != NULL) && ((a == NULL) || (*a != ret)))
260                 M_ASN1_INTEGER_free(ret);
261         return(NULL);
262         }
263
264 /* This is a version of d2i_ASN1_INTEGER that ignores the sign bit of
265  * ASN1 integers: some broken software can encode a positive INTEGER
266  * with its MSB set as negative (it doesn't add a padding zero).
267  */
268
269 ASN1_INTEGER *d2i_ASN1_UINTEGER(ASN1_INTEGER **a, unsigned char **pp,
270              long length)
271         {
272         ASN1_INTEGER *ret=NULL;
273         unsigned char *p,*to,*s;
274         long len;
275         int inf,tag,xclass;
276         int i;
277
278         if ((a == NULL) || ((*a) == NULL))
279                 {
280                 if ((ret=M_ASN1_INTEGER_new()) == NULL) return(NULL);
281                 ret->type=V_ASN1_INTEGER;
282                 }
283         else
284                 ret=(*a);
285
286         p= *pp;
287         inf=ASN1_get_object(&p,&len,&tag,&xclass,length);
288         if (inf & 0x80)
289                 {
290                 i=ASN1_R_BAD_OBJECT_HEADER;
291                 goto err;
292                 }
293
294         if (tag != V_ASN1_INTEGER)
295                 {
296                 i=ASN1_R_EXPECTING_AN_INTEGER;
297                 goto err;
298                 }
299
300         /* We must OPENSSL_malloc stuff, even for 0 bytes otherwise it
301          * signifies a missing NULL parameter. */
302         s=(unsigned char *)OPENSSL_malloc((int)len+1);
303         if (s == NULL)
304                 {
305                 i=ERR_R_MALLOC_FAILURE;
306                 goto err;
307                 }
308         to=s;
309         ret->type=V_ASN1_INTEGER;
310         if(len) {
311                 if ((*p == 0) && (len != 1))
312                         {
313                         p++;
314                         len--;
315                         }
316                 memcpy(s,p,(int)len);
317                 p+=len;
318         }
319
320         if (ret->data != NULL) OPENSSL_free(ret->data);
321         ret->data=s;
322         ret->length=(int)len;
323         if (a != NULL) (*a)=ret;
324         *pp=p;
325         return(ret);
326 err:
327         ASN1err(ASN1_F_D2I_ASN1_UINTEGER,i);
328         if ((ret != NULL) && ((a == NULL) || (*a != ret)))
329                 M_ASN1_INTEGER_free(ret);
330         return(NULL);
331         }
332
333 int ASN1_INTEGER_set(ASN1_INTEGER *a, long v)
334         {
335         int i,j,k;
336         unsigned char buf[sizeof(long)+1];
337         long d;
338
339         a->type=V_ASN1_INTEGER;
340         if (a->length < (sizeof(long)+1))
341                 {
342                 if (a->data != NULL)
343                         OPENSSL_free(a->data);
344                 if ((a->data=(unsigned char *)OPENSSL_malloc(sizeof(long)+1)) != NULL)
345                         memset((char *)a->data,0,sizeof(long)+1);
346                 }
347         if (a->data == NULL)
348                 {
349                 ASN1err(ASN1_F_ASN1_INTEGER_SET,ERR_R_MALLOC_FAILURE);
350                 return(0);
351                 }
352         d=v;
353         if (d < 0)
354                 {
355                 d= -d;
356                 a->type=V_ASN1_NEG_INTEGER;
357                 }
358
359         for (i=0; i<sizeof(long); i++)
360                 {
361                 if (d == 0) break;
362                 buf[i]=(int)d&0xff;
363                 d>>=8;
364                 }
365         j=0;
366         for (k=i-1; k >=0; k--)
367                 a->data[j++]=buf[k];
368         a->length=j;
369         return(1);
370         }
371
372 long ASN1_INTEGER_get(ASN1_INTEGER *a)
373         {
374         int neg=0,i;
375         long r=0;
376
377         if (a == NULL) return(0L);
378         i=a->type;
379         if (i == V_ASN1_NEG_INTEGER)
380                 neg=1;
381         else if (i != V_ASN1_INTEGER)
382                 return(0);
383         
384         if (a->length > sizeof(long))
385                 {
386                 /* hmm... a bit ugly */
387                 return(0xffffffffL);
388                 }
389         if (a->data == NULL)
390                 return(0);
391
392         for (i=0; i<a->length; i++)
393                 {
394                 r<<=8;
395                 r|=(unsigned char)a->data[i];
396                 }
397         if (neg) r= -r;
398         return(r);
399         }
400
401 ASN1_INTEGER *BN_to_ASN1_INTEGER(BIGNUM *bn, ASN1_INTEGER *ai)
402         {
403         ASN1_INTEGER *ret;
404         int len,j;
405
406         if (ai == NULL)
407                 ret=M_ASN1_INTEGER_new();
408         else
409                 ret=ai;
410         if (ret == NULL)
411                 {
412                 ASN1err(ASN1_F_BN_TO_ASN1_INTEGER,ERR_R_NESTED_ASN1_ERROR);
413                 goto err;
414                 }
415         if(bn->neg) ret->type = V_ASN1_NEG_INTEGER;
416         else ret->type=V_ASN1_INTEGER;
417         j=BN_num_bits(bn);
418         len=((j == 0)?0:((j/8)+1));
419         ret->data=(unsigned char *)OPENSSL_malloc(len+4);
420         ret->length=BN_bn2bin(bn,ret->data);
421         return(ret);
422 err:
423         if (ret != ai) M_ASN1_INTEGER_free(ret);
424         return(NULL);
425         }
426
427 BIGNUM *ASN1_INTEGER_to_BN(ASN1_INTEGER *ai, BIGNUM *bn)
428         {
429         BIGNUM *ret;
430
431         if ((ret=BN_bin2bn(ai->data,ai->length,bn)) == NULL)
432                 ASN1err(ASN1_F_ASN1_INTEGER_TO_BN,ASN1_R_BN_LIB);
433         if(ai->type == V_ASN1_NEG_INTEGER) bn->neg = 1;
434         return(ret);
435         }
436
437 IMPLEMENT_STACK_OF(ASN1_INTEGER)
438 IMPLEMENT_ASN1_SET_OF(ASN1_INTEGER)