xref: /freebsd/crypto/openssl/crypto/asn1/a_int.c (revision e7be843b4a162e68651d3911f0357ed464915629)
1 /*
2  * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the Apache License 2.0 (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9 
10 #include <stdio.h>
11 #include "internal/cryptlib.h"
12 #include "internal/numbers.h"
13 #include <limits.h>
14 #include <openssl/asn1.h>
15 #include <openssl/bn.h>
16 #include "asn1_local.h"
17 
ASN1_INTEGER_dup(const ASN1_INTEGER * x)18 ASN1_INTEGER *ASN1_INTEGER_dup(const ASN1_INTEGER *x)
19 {
20     return ASN1_STRING_dup(x);
21 }
22 
ASN1_INTEGER_cmp(const ASN1_INTEGER * x,const ASN1_INTEGER * y)23 int ASN1_INTEGER_cmp(const ASN1_INTEGER *x, const ASN1_INTEGER *y)
24 {
25     int neg, ret;
26     /* Compare signs */
27     neg = x->type & V_ASN1_NEG;
28     if (neg != (y->type & V_ASN1_NEG)) {
29         if (neg)
30             return -1;
31         else
32             return 1;
33     }
34 
35     ret = ASN1_STRING_cmp(x, y);
36 
37     if (neg)
38         return -ret;
39     else
40         return ret;
41 }
42 
43 /*
44  * This converts a big endian buffer and sign into its content encoding.
45  * This is used for INTEGER and ENUMERATED types.
46  * The internal representation is an ASN1_STRING whose data is a big endian
47  * representation of the value, ignoring the sign. The sign is determined by
48  * the type: if type & V_ASN1_NEG is true it is negative, otherwise positive.
49  *
50  * Positive integers are no problem: they are almost the same as the DER
51  * encoding, except if the first byte is >= 0x80 we need to add a zero pad.
52  *
53  * Negative integers are a bit trickier...
54  * The DER representation of negative integers is in 2s complement form.
55  * The internal form is converted by complementing each octet and finally
56  * adding one to the result. This can be done less messily with a little trick.
57  * If the internal form has trailing zeroes then they will become FF by the
58  * complement and 0 by the add one (due to carry) so just copy as many trailing
59  * zeros to the destination as there are in the source. The carry will add one
60  * to the last none zero octet: so complement this octet and add one and finally
61  * complement any left over until you get to the start of the string.
62  *
63  * Padding is a little trickier too. If the first bytes is > 0x80 then we pad
64  * with 0xff. However if the first byte is 0x80 and one of the following bytes
65  * is non-zero we pad with 0xff. The reason for this distinction is that 0x80
66  * followed by optional zeros isn't padded.
67  */
68 
69 /*
70  * If |pad| is zero, the operation is effectively reduced to memcpy,
71  * and if |pad| is 0xff, then it performs two's complement, ~dst + 1.
72  * Note that in latter case sequence of zeros yields itself, and so
73  * does 0x80 followed by any number of zeros. These properties are
74  * used elsewhere below...
75  */
twos_complement(unsigned char * dst,const unsigned char * src,size_t len,unsigned char pad)76 static void twos_complement(unsigned char *dst, const unsigned char *src,
77                             size_t len, unsigned char pad)
78 {
79     unsigned int carry = pad & 1;
80 
81     /* Begin at the end of the encoding */
82     if (len != 0) {
83         /*
84          * if len == 0 then src/dst could be NULL, and this would be undefined
85          * behaviour.
86          */
87         dst += len;
88         src += len;
89     }
90     /* two's complement value: ~value + 1 */
91     while (len-- != 0) {
92         *(--dst) = (unsigned char)(carry += *(--src) ^ pad);
93         carry >>= 8;
94     }
95 }
96 
i2c_ibuf(const unsigned char * b,size_t blen,int neg,unsigned char ** pp)97 static size_t i2c_ibuf(const unsigned char *b, size_t blen, int neg,
98                        unsigned char **pp)
99 {
100     unsigned int pad = 0;
101     size_t ret, i;
102     unsigned char *p, pb = 0;
103 
104     if (b != NULL && blen) {
105         ret = blen;
106         i = b[0];
107         if (!neg && (i > 127)) {
108             pad = 1;
109             pb = 0;
110         } else if (neg) {
111             pb = 0xFF;
112             if (i > 128) {
113                 pad = 1;
114             } else if (i == 128) {
115                 /*
116                  * Special case [of minimal negative for given length]:
117                  * if any other bytes non zero we pad, otherwise we don't.
118                  */
119                 for (pad = 0, i = 1; i < blen; i++)
120                     pad |= b[i];
121                 pb = pad != 0 ? 0xffU : 0;
122                 pad = pb & 1;
123             }
124         }
125         ret += pad;
126     } else {
127         ret = 1;
128         blen = 0;   /* reduce '(b == NULL || blen == 0)' to '(blen == 0)' */
129     }
130 
131     if (pp == NULL || (p = *pp) == NULL)
132         return ret;
133 
134     /*
135      * This magically handles all corner cases, such as '(b == NULL ||
136      * blen == 0)', non-negative value, "negative" zero, 0x80 followed
137      * by any number of zeros...
138      */
139     *p = pb;
140     p += pad;       /* yes, p[0] can be written twice, but it's little
141                      * price to pay for eliminated branches */
142     twos_complement(p, b, blen, pb);
143 
144     *pp += ret;
145     return ret;
146 }
147 
148 /*
149  * convert content octets into a big endian buffer. Returns the length
150  * of buffer or 0 on error: for malformed INTEGER. If output buffer is
151  * NULL just return length.
152  */
153 
c2i_ibuf(unsigned char * b,int * pneg,const unsigned char * p,size_t plen)154 static size_t c2i_ibuf(unsigned char *b, int *pneg,
155                        const unsigned char *p, size_t plen)
156 {
157     int neg, pad;
158     /* Zero content length is illegal */
159     if (plen == 0) {
160         ERR_raise(ERR_LIB_ASN1, ASN1_R_ILLEGAL_ZERO_CONTENT);
161         return 0;
162     }
163     neg = p[0] & 0x80;
164     if (pneg)
165         *pneg = neg;
166     /* Handle common case where length is 1 octet separately */
167     if (plen == 1) {
168         if (b != NULL) {
169             if (neg)
170                 b[0] = (p[0] ^ 0xFF) + 1;
171             else
172                 b[0] = p[0];
173         }
174         return 1;
175     }
176 
177     pad = 0;
178     if (p[0] == 0) {
179         pad = 1;
180     } else if (p[0] == 0xFF) {
181         size_t i;
182 
183         /*
184          * Special case [of "one less minimal negative" for given length]:
185          * if any other bytes non zero it was padded, otherwise not.
186          */
187         for (pad = 0, i = 1; i < plen; i++)
188             pad |= p[i];
189         pad = pad != 0 ? 1 : 0;
190     }
191     /* reject illegal padding: first two octets MSB can't match */
192     if (pad && (neg == (p[1] & 0x80))) {
193         ERR_raise(ERR_LIB_ASN1, ASN1_R_ILLEGAL_PADDING);
194         return 0;
195     }
196 
197     /* skip over pad */
198     p += pad;
199     plen -= pad;
200 
201     if (b != NULL)
202         twos_complement(b, p, plen, neg ? 0xffU : 0);
203 
204     return plen;
205 }
206 
ossl_i2c_ASN1_INTEGER(ASN1_INTEGER * a,unsigned char ** pp)207 int ossl_i2c_ASN1_INTEGER(ASN1_INTEGER *a, unsigned char **pp)
208 {
209     return i2c_ibuf(a->data, a->length, a->type & V_ASN1_NEG, pp);
210 }
211 
212 /* Convert big endian buffer into uint64_t, return 0 on error */
asn1_get_uint64(uint64_t * pr,const unsigned char * b,size_t blen)213 static int asn1_get_uint64(uint64_t *pr, const unsigned char *b, size_t blen)
214 {
215     size_t i;
216     uint64_t r;
217 
218     if (blen > sizeof(*pr)) {
219         ERR_raise(ERR_LIB_ASN1, ASN1_R_TOO_LARGE);
220         return 0;
221     }
222     if (b == NULL)
223         return 0;
224     for (r = 0, i = 0; i < blen; i++) {
225         r <<= 8;
226         r |= b[i];
227     }
228     *pr = r;
229     return 1;
230 }
231 
232 /*
233  * Write uint64_t to big endian buffer and return offset to first
234  * written octet. In other words it returns offset in range from 0
235  * to 7, with 0 denoting 8 written octets and 7 - one.
236  */
asn1_put_uint64(unsigned char b[sizeof (uint64_t)],uint64_t r)237 static size_t asn1_put_uint64(unsigned char b[sizeof(uint64_t)], uint64_t r)
238 {
239     size_t off = sizeof(uint64_t);
240 
241     do {
242         b[--off] = (unsigned char)r;
243     } while (r >>= 8);
244 
245     return off;
246 }
247 
248 /*
249  * Absolute value of INT64_MIN: we can't just use -INT64_MIN as gcc produces
250  * overflow warnings.
251  */
252 #define ABS_INT64_MIN ((uint64_t)INT64_MAX + (-(INT64_MIN + INT64_MAX)))
253 
254 /* signed version of asn1_get_uint64 */
asn1_get_int64(int64_t * pr,const unsigned char * b,size_t blen,int neg)255 static int asn1_get_int64(int64_t *pr, const unsigned char *b, size_t blen,
256                           int neg)
257 {
258     uint64_t r;
259     if (asn1_get_uint64(&r, b, blen) == 0)
260         return 0;
261     if (neg) {
262         if (r <= INT64_MAX) {
263             /*
264              * Most significant bit is guaranteed to be clear, negation
265              * is guaranteed to be meaningful in platform-neutral sense.
266              */
267             *pr = -(int64_t)r;
268         } else if (r == ABS_INT64_MIN) {
269             /*
270              * This never happens if INT64_MAX == ABS_INT64_MIN, e.g.
271              * on ones'-complement system.
272              */
273             *pr = (int64_t)(0 - r);
274         } else {
275             ERR_raise(ERR_LIB_ASN1, ASN1_R_TOO_SMALL);
276             return 0;
277         }
278     } else {
279         if (r <= INT64_MAX) {
280             *pr = (int64_t)r;
281         } else {
282             ERR_raise(ERR_LIB_ASN1, ASN1_R_TOO_LARGE);
283             return 0;
284         }
285     }
286     return 1;
287 }
288 
289 /* Convert ASN1 INTEGER content octets to ASN1_INTEGER structure */
ossl_c2i_ASN1_INTEGER(ASN1_INTEGER ** a,const unsigned char ** pp,long len)290 ASN1_INTEGER *ossl_c2i_ASN1_INTEGER(ASN1_INTEGER **a, const unsigned char **pp,
291                                     long len)
292 {
293     ASN1_INTEGER *ret = NULL;
294     size_t r;
295     int neg;
296 
297     r = c2i_ibuf(NULL, NULL, *pp, len);
298 
299     if (r == 0)
300         return NULL;
301 
302     if ((a == NULL) || ((*a) == NULL)) {
303         ret = ASN1_INTEGER_new();
304         if (ret == NULL)
305             return NULL;
306         ret->type = V_ASN1_INTEGER;
307     } else
308         ret = *a;
309 
310     if (ASN1_STRING_set(ret, NULL, r) == 0) {
311         ERR_raise(ERR_LIB_ASN1, ERR_R_ASN1_LIB);
312         goto err;
313     }
314 
315     c2i_ibuf(ret->data, &neg, *pp, len);
316 
317     if (neg != 0)
318         ret->type |= V_ASN1_NEG;
319     else
320         ret->type &= ~V_ASN1_NEG;
321 
322     *pp += len;
323     if (a != NULL)
324         (*a) = ret;
325     return ret;
326  err:
327     if (a == NULL || *a != ret)
328         ASN1_INTEGER_free(ret);
329     return NULL;
330 }
331 
asn1_string_get_int64(int64_t * pr,const ASN1_STRING * a,int itype)332 static int asn1_string_get_int64(int64_t *pr, const ASN1_STRING *a, int itype)
333 {
334     if (a == NULL) {
335         ERR_raise(ERR_LIB_ASN1, ERR_R_PASSED_NULL_PARAMETER);
336         return 0;
337     }
338     if ((a->type & ~V_ASN1_NEG) != itype) {
339         ERR_raise(ERR_LIB_ASN1, ASN1_R_WRONG_INTEGER_TYPE);
340         return 0;
341     }
342     return asn1_get_int64(pr, a->data, a->length, a->type & V_ASN1_NEG);
343 }
344 
asn1_string_set_int64(ASN1_STRING * a,int64_t r,int itype)345 static int asn1_string_set_int64(ASN1_STRING *a, int64_t r, int itype)
346 {
347     unsigned char tbuf[sizeof(r)];
348     size_t off;
349 
350     a->type = itype;
351     if (r < 0) {
352         /*
353          * Most obvious '-r' triggers undefined behaviour for most
354          * common INT64_MIN. Even though below '0 - (uint64_t)r' can
355          * appear two's-complement centric, it does produce correct/
356          * expected result even on ones' complement. This is because
357          * cast to unsigned has to change bit pattern...
358          */
359         off = asn1_put_uint64(tbuf, 0 - (uint64_t)r);
360         a->type |= V_ASN1_NEG;
361     } else {
362         off = asn1_put_uint64(tbuf, r);
363         a->type &= ~V_ASN1_NEG;
364     }
365     return ASN1_STRING_set(a, tbuf + off, sizeof(tbuf) - off);
366 }
367 
asn1_string_get_uint64(uint64_t * pr,const ASN1_STRING * a,int itype)368 static int asn1_string_get_uint64(uint64_t *pr, const ASN1_STRING *a,
369                                   int itype)
370 {
371     if (a == NULL) {
372         ERR_raise(ERR_LIB_ASN1, ERR_R_PASSED_NULL_PARAMETER);
373         return 0;
374     }
375     if ((a->type & ~V_ASN1_NEG) != itype) {
376         ERR_raise(ERR_LIB_ASN1, ASN1_R_WRONG_INTEGER_TYPE);
377         return 0;
378     }
379     if (a->type & V_ASN1_NEG) {
380         ERR_raise(ERR_LIB_ASN1, ASN1_R_ILLEGAL_NEGATIVE_VALUE);
381         return 0;
382     }
383     return asn1_get_uint64(pr, a->data, a->length);
384 }
385 
asn1_string_set_uint64(ASN1_STRING * a,uint64_t r,int itype)386 static int asn1_string_set_uint64(ASN1_STRING *a, uint64_t r, int itype)
387 {
388     unsigned char tbuf[sizeof(r)];
389     size_t off;
390 
391     a->type = itype;
392     off = asn1_put_uint64(tbuf, r);
393     return ASN1_STRING_set(a, tbuf + off, sizeof(tbuf) - off);
394 }
395 
396 /*
397  * This is a version of d2i_ASN1_INTEGER that ignores the sign bit of ASN1
398  * integers: some broken software can encode a positive INTEGER with its MSB
399  * set as negative (it doesn't add a padding zero).
400  */
401 
d2i_ASN1_UINTEGER(ASN1_INTEGER ** a,const unsigned char ** pp,long length)402 ASN1_INTEGER *d2i_ASN1_UINTEGER(ASN1_INTEGER **a, const unsigned char **pp,
403                                 long length)
404 {
405     ASN1_INTEGER *ret = NULL;
406     const unsigned char *p;
407     unsigned char *s;
408     long len = 0;
409     int inf, tag, xclass;
410     int i = 0;
411 
412     if ((a == NULL) || ((*a) == NULL)) {
413         if ((ret = ASN1_INTEGER_new()) == NULL)
414             return NULL;
415         ret->type = V_ASN1_INTEGER;
416     } else
417         ret = (*a);
418 
419     p = *pp;
420     inf = ASN1_get_object(&p, &len, &tag, &xclass, length);
421     if (inf & 0x80) {
422         i = ASN1_R_BAD_OBJECT_HEADER;
423         goto err;
424     }
425 
426     if (tag != V_ASN1_INTEGER) {
427         i = ASN1_R_EXPECTING_AN_INTEGER;
428         goto err;
429     }
430 
431     if (len < 0) {
432         i = ASN1_R_ILLEGAL_NEGATIVE_VALUE;
433         goto err;
434     }
435     /*
436      * We must OPENSSL_malloc stuff, even for 0 bytes otherwise it signifies
437      * a missing NULL parameter.
438      */
439     s = OPENSSL_malloc((int)len + 1);
440     if (s == NULL)
441         goto err;
442     ret->type = V_ASN1_INTEGER;
443     if (len) {
444         if ((*p == 0) && (len != 1)) {
445             p++;
446             len--;
447         }
448         memcpy(s, p, (int)len);
449         p += len;
450     }
451 
452     ASN1_STRING_set0(ret, s, (int)len);
453     if (a != NULL)
454         (*a) = ret;
455     *pp = p;
456     return ret;
457  err:
458     if (i != 0)
459         ERR_raise(ERR_LIB_ASN1, i);
460     if ((a == NULL) || (*a != ret))
461         ASN1_INTEGER_free(ret);
462     return NULL;
463 }
464 
bn_to_asn1_string(const BIGNUM * bn,ASN1_STRING * ai,int atype)465 static ASN1_STRING *bn_to_asn1_string(const BIGNUM *bn, ASN1_STRING *ai,
466                                       int atype)
467 {
468     ASN1_INTEGER *ret;
469     int len;
470 
471     if (ai == NULL) {
472         ret = ASN1_STRING_type_new(atype);
473     } else {
474         ret = ai;
475         ret->type = atype;
476     }
477 
478     if (ret == NULL) {
479         ERR_raise(ERR_LIB_ASN1, ERR_R_NESTED_ASN1_ERROR);
480         goto err;
481     }
482 
483     if (BN_is_negative(bn) && !BN_is_zero(bn))
484         ret->type |= V_ASN1_NEG_INTEGER;
485 
486     len = BN_num_bytes(bn);
487 
488     if (len == 0)
489         len = 1;
490 
491     if (ASN1_STRING_set(ret, NULL, len) == 0) {
492         ERR_raise(ERR_LIB_ASN1, ERR_R_ASN1_LIB);
493         goto err;
494     }
495 
496     /* Correct zero case */
497     if (BN_is_zero(bn))
498         ret->data[0] = 0;
499     else
500         len = BN_bn2bin(bn, ret->data);
501     ret->length = len;
502     return ret;
503  err:
504     if (ret != ai)
505         ASN1_INTEGER_free(ret);
506     return NULL;
507 }
508 
asn1_string_to_bn(const ASN1_INTEGER * ai,BIGNUM * bn,int itype)509 static BIGNUM *asn1_string_to_bn(const ASN1_INTEGER *ai, BIGNUM *bn,
510                                  int itype)
511 {
512     BIGNUM *ret;
513 
514     if ((ai->type & ~V_ASN1_NEG) != itype) {
515         ERR_raise(ERR_LIB_ASN1, ASN1_R_WRONG_INTEGER_TYPE);
516         return NULL;
517     }
518 
519     ret = BN_bin2bn(ai->data, ai->length, bn);
520     if (ret == NULL) {
521         ERR_raise(ERR_LIB_ASN1, ASN1_R_BN_LIB);
522         return NULL;
523     }
524     if (ai->type & V_ASN1_NEG)
525         BN_set_negative(ret, 1);
526     return ret;
527 }
528 
ASN1_INTEGER_get_int64(int64_t * pr,const ASN1_INTEGER * a)529 int ASN1_INTEGER_get_int64(int64_t *pr, const ASN1_INTEGER *a)
530 {
531     return asn1_string_get_int64(pr, a, V_ASN1_INTEGER);
532 }
533 
ASN1_INTEGER_set_int64(ASN1_INTEGER * a,int64_t r)534 int ASN1_INTEGER_set_int64(ASN1_INTEGER *a, int64_t r)
535 {
536     return asn1_string_set_int64(a, r, V_ASN1_INTEGER);
537 }
538 
ASN1_INTEGER_get_uint64(uint64_t * pr,const ASN1_INTEGER * a)539 int ASN1_INTEGER_get_uint64(uint64_t *pr, const ASN1_INTEGER *a)
540 {
541     return asn1_string_get_uint64(pr, a, V_ASN1_INTEGER);
542 }
543 
ASN1_INTEGER_set_uint64(ASN1_INTEGER * a,uint64_t r)544 int ASN1_INTEGER_set_uint64(ASN1_INTEGER *a, uint64_t r)
545 {
546     return asn1_string_set_uint64(a, r, V_ASN1_INTEGER);
547 }
548 
ASN1_INTEGER_set(ASN1_INTEGER * a,long v)549 int ASN1_INTEGER_set(ASN1_INTEGER *a, long v)
550 {
551     return ASN1_INTEGER_set_int64(a, v);
552 }
553 
ASN1_INTEGER_get(const ASN1_INTEGER * a)554 long ASN1_INTEGER_get(const ASN1_INTEGER *a)
555 {
556     int i;
557     int64_t r;
558     if (a == NULL)
559         return 0;
560     i = ASN1_INTEGER_get_int64(&r, a);
561     if (i == 0)
562         return -1;
563     if (r > LONG_MAX || r < LONG_MIN)
564         return -1;
565     return (long)r;
566 }
567 
BN_to_ASN1_INTEGER(const BIGNUM * bn,ASN1_INTEGER * ai)568 ASN1_INTEGER *BN_to_ASN1_INTEGER(const BIGNUM *bn, ASN1_INTEGER *ai)
569 {
570     return bn_to_asn1_string(bn, ai, V_ASN1_INTEGER);
571 }
572 
ASN1_INTEGER_to_BN(const ASN1_INTEGER * ai,BIGNUM * bn)573 BIGNUM *ASN1_INTEGER_to_BN(const ASN1_INTEGER *ai, BIGNUM *bn)
574 {
575     return asn1_string_to_bn(ai, bn, V_ASN1_INTEGER);
576 }
577 
ASN1_ENUMERATED_get_int64(int64_t * pr,const ASN1_ENUMERATED * a)578 int ASN1_ENUMERATED_get_int64(int64_t *pr, const ASN1_ENUMERATED *a)
579 {
580     return asn1_string_get_int64(pr, a, V_ASN1_ENUMERATED);
581 }
582 
ASN1_ENUMERATED_set_int64(ASN1_ENUMERATED * a,int64_t r)583 int ASN1_ENUMERATED_set_int64(ASN1_ENUMERATED *a, int64_t r)
584 {
585     return asn1_string_set_int64(a, r, V_ASN1_ENUMERATED);
586 }
587 
ASN1_ENUMERATED_set(ASN1_ENUMERATED * a,long v)588 int ASN1_ENUMERATED_set(ASN1_ENUMERATED *a, long v)
589 {
590     return ASN1_ENUMERATED_set_int64(a, v);
591 }
592 
ASN1_ENUMERATED_get(const ASN1_ENUMERATED * a)593 long ASN1_ENUMERATED_get(const ASN1_ENUMERATED *a)
594 {
595     int i;
596     int64_t r;
597     if (a == NULL)
598         return 0;
599     if ((a->type & ~V_ASN1_NEG) != V_ASN1_ENUMERATED)
600         return -1;
601     if (a->length > (int)sizeof(long))
602         return 0xffffffffL;
603     i = ASN1_ENUMERATED_get_int64(&r, a);
604     if (i == 0)
605         return -1;
606     if (r > LONG_MAX || r < LONG_MIN)
607         return -1;
608     return (long)r;
609 }
610 
BN_to_ASN1_ENUMERATED(const BIGNUM * bn,ASN1_ENUMERATED * ai)611 ASN1_ENUMERATED *BN_to_ASN1_ENUMERATED(const BIGNUM *bn, ASN1_ENUMERATED *ai)
612 {
613     return bn_to_asn1_string(bn, ai, V_ASN1_ENUMERATED);
614 }
615 
ASN1_ENUMERATED_to_BN(const ASN1_ENUMERATED * ai,BIGNUM * bn)616 BIGNUM *ASN1_ENUMERATED_to_BN(const ASN1_ENUMERATED *ai, BIGNUM *bn)
617 {
618     return asn1_string_to_bn(ai, bn, V_ASN1_ENUMERATED);
619 }
620 
621 /* Internal functions used by x_int64.c */
ossl_c2i_uint64_int(uint64_t * ret,int * neg,const unsigned char ** pp,long len)622 int ossl_c2i_uint64_int(uint64_t *ret, int *neg,
623                         const unsigned char **pp, long len)
624 {
625     unsigned char buf[sizeof(uint64_t)];
626     size_t buflen;
627 
628     buflen = c2i_ibuf(NULL, NULL, *pp, len);
629     if (buflen == 0)
630         return 0;
631     if (buflen > sizeof(uint64_t)) {
632         ERR_raise(ERR_LIB_ASN1, ASN1_R_TOO_LARGE);
633         return 0;
634     }
635     (void)c2i_ibuf(buf, neg, *pp, len);
636     return asn1_get_uint64(ret, buf, buflen);
637 }
638 
ossl_i2c_uint64_int(unsigned char * p,uint64_t r,int neg)639 int ossl_i2c_uint64_int(unsigned char *p, uint64_t r, int neg)
640 {
641     unsigned char buf[sizeof(uint64_t)];
642     size_t off;
643 
644     off = asn1_put_uint64(buf, r);
645     return i2c_ibuf(buf + off, sizeof(buf) - off, neg, &p);
646 }
647 
648