Remove macro hacks for internal vs. external functions. Part 2 and last.
[libgcrypt.git] / mpi / mpicoder.c
1 /* mpicoder.c  -  Coder for the external representation of MPIs
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003
3  *               2008 Free Software Foundation, Inc.
4  * Copyright (C) 2013 g10 Code GmbH
5  *
6  * This file is part of Libgcrypt.
7  *
8  * Libgcrypt is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU Lesser General Public License as
10  * published by the Free Software Foundation; either version 2.1 of
11  * the License, or (at your option) any later version.
12  *
13  * Libgcrypt is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
20  */
21
22 #include <config.h>
23 #include <stdio.h>
24 #include <string.h>
25 #include <stdlib.h>
26
27 #include "mpi-internal.h"
28 #include "g10lib.h"
29
30 #define MAX_EXTERN_MPI_BITS 16384
31
32 /* Helper used to scan PGP style MPIs.  Returns NULL on failure. */
33 static gcry_mpi_t
34 mpi_read_from_buffer (const unsigned char *buffer, unsigned *ret_nread,
35                       int secure)
36 {
37   int i, j;
38   unsigned int nbits, nbytes, nlimbs, nread=0;
39   mpi_limb_t a;
40   gcry_mpi_t val = MPI_NULL;
41
42   if ( *ret_nread < 2 )
43     goto leave;
44   nbits = buffer[0] << 8 | buffer[1];
45   if ( nbits > MAX_EXTERN_MPI_BITS )
46     {
47 /*       log_debug ("mpi too large (%u bits)\n", nbits); */
48       goto leave;
49     }
50   buffer += 2;
51   nread = 2;
52
53   nbytes = (nbits+7) / 8;
54   nlimbs = (nbytes+BYTES_PER_MPI_LIMB-1) / BYTES_PER_MPI_LIMB;
55   val = secure? mpi_alloc_secure (nlimbs) : mpi_alloc (nlimbs);
56   i = BYTES_PER_MPI_LIMB - nbytes % BYTES_PER_MPI_LIMB;
57   i %= BYTES_PER_MPI_LIMB;
58   j= val->nlimbs = nlimbs;
59   val->sign = 0;
60   for ( ; j > 0; j-- )
61     {
62       a = 0;
63       for (; i < BYTES_PER_MPI_LIMB; i++ )
64         {
65           if ( ++nread > *ret_nread )
66             {
67 /*               log_debug ("mpi larger than buffer"); */
68               mpi_free (val);
69               val = NULL;
70               goto leave;
71             }
72           a <<= 8;
73           a |= *buffer++;
74         }
75       i = 0;
76       val->d[j-1] = a;
77     }
78
79  leave:
80   *ret_nread = nread;
81   return val;
82 }
83
84
85 /****************
86  * Fill the mpi VAL from the hex string in STR.
87  */
88 static int
89 mpi_fromstr (gcry_mpi_t val, const char *str)
90 {
91   int sign = 0;
92   int prepend_zero = 0;
93   int i, j, c, c1, c2;
94   unsigned int nbits, nbytes, nlimbs;
95   mpi_limb_t a;
96
97   if ( *str == '-' )
98     {
99       sign = 1;
100       str++;
101     }
102
103   /* Skip optional hex prefix.  */
104   if ( *str == '0' && str[1] == 'x' )
105     str += 2;
106
107   nbits = 4 * strlen (str);
108   if ((nbits % 8))
109     prepend_zero = 1;
110
111   nbytes = (nbits+7) / 8;
112   nlimbs = (nbytes+BYTES_PER_MPI_LIMB-1) / BYTES_PER_MPI_LIMB;
113
114   if ( val->alloced < nlimbs )
115     mpi_resize (val, nlimbs);
116
117   i = BYTES_PER_MPI_LIMB - (nbytes % BYTES_PER_MPI_LIMB);
118   i %= BYTES_PER_MPI_LIMB;
119   j = val->nlimbs = nlimbs;
120   val->sign = sign;
121   for (; j > 0; j--)
122     {
123       a = 0;
124       for (; i < BYTES_PER_MPI_LIMB; i++)
125         {
126           if (prepend_zero)
127             {
128               c1 = '0';
129               prepend_zero = 0;
130             }
131           else
132             c1 = *str++;
133
134           if (!c1)
135             {
136               mpi_clear (val);
137               return 1;  /* Error.  */
138             }
139           c2 = *str++;
140           if (!c2)
141             {
142               mpi_clear (val);
143               return 1;  /* Error.  */
144             }
145           if ( c1 >= '0' && c1 <= '9' )
146             c = c1 - '0';
147           else if ( c1 >= 'a' && c1 <= 'f' )
148             c = c1 - 'a' + 10;
149           else if ( c1 >= 'A' && c1 <= 'F' )
150             c = c1 - 'A' + 10;
151           else
152             {
153               mpi_clear (val);
154               return 1;  /* Error.  */
155             }
156           c <<= 4;
157           if ( c2 >= '0' && c2 <= '9' )
158             c |= c2 - '0';
159           else if( c2 >= 'a' && c2 <= 'f' )
160             c |= c2 - 'a' + 10;
161           else if( c2 >= 'A' && c2 <= 'F' )
162             c |= c2 - 'A' + 10;
163           else
164             {
165               mpi_clear(val);
166               return 1;  /* Error. */
167             }
168           a <<= 8;
169           a |= c;
170         }
171       i = 0;
172       val->d[j-1] = a;
173     }
174
175   return 0;  /* Okay.  */
176 }
177
178
179 /* Return an allocated buffer with the MPI (msb first).  NBYTES
180    receives the length of this buffer.  If FILL_LE is not 0, the
181    returned value is stored as little endian and right padded with
182    zeroes so that the returned buffer has at least FILL_LE bytes.
183
184    Caller must free the return string.  This function returns an
185    allocated buffer with NBYTES set to zero if the value of A is zero.
186    If sign is not NULL, it will be set to the sign of the A.  On error
187    NULL is returned and ERRNO set appropriately.  */
188 static unsigned char *
189 do_get_buffer (gcry_mpi_t a, unsigned int fill_le,
190                unsigned int *nbytes, int *sign, int force_secure)
191 {
192   unsigned char *p, *buffer;
193   unsigned int length, tmp;
194   mpi_limb_t alimb;
195   int i;
196   size_t n;
197
198   if (sign)
199     *sign = a->sign;
200
201   *nbytes = a->nlimbs * BYTES_PER_MPI_LIMB;
202   n = *nbytes? *nbytes:1; /* Allocate at least one byte.  */
203   if (n < fill_le)
204     n = fill_le;
205   p = buffer = (force_secure || mpi_is_secure(a))? xtrymalloc_secure (n)
206                                                  : xtrymalloc (n);
207   if (!buffer)
208     return NULL;
209
210   for (i=a->nlimbs-1; i >= 0; i--)
211     {
212       alimb = a->d[i];
213 #if BYTES_PER_MPI_LIMB == 4
214       *p++ = alimb >> 24;
215       *p++ = alimb >> 16;
216       *p++ = alimb >>  8;
217       *p++ = alimb        ;
218 #elif BYTES_PER_MPI_LIMB == 8
219       *p++ = alimb >> 56;
220       *p++ = alimb >> 48;
221       *p++ = alimb >> 40;
222       *p++ = alimb >> 32;
223       *p++ = alimb >> 24;
224       *p++ = alimb >> 16;
225       *p++ = alimb >>  8;
226       *p++ = alimb        ;
227 #else
228 #     error please implement for this limb size.
229 #endif
230     }
231
232   if (fill_le)
233     {
234       length = *nbytes;
235       /* Reverse buffer and pad with zeroes.  */
236       for (i=0; i < length/2; i++)
237         {
238           tmp = buffer[i];
239           buffer[i] = buffer[length-1-i];
240           buffer[length-1-i] = tmp;
241         }
242       /* Pad with zeroes.  */
243       for (p = buffer + length; length < fill_le; length++)
244         *p++ = 0;
245       *nbytes = length;
246
247       return buffer;
248     }
249
250   /* This is sub-optimal but we need to do the shift operation because
251      the caller has to free the returned buffer.  */
252   for (p=buffer; *nbytes && !*p; p++, --*nbytes)
253     ;
254   if (p != buffer)
255     memmove (buffer,p, *nbytes);
256   return buffer;
257 }
258
259
260 byte *
261 _gcry_mpi_get_buffer (gcry_mpi_t a, unsigned int fill_le,
262                       unsigned int *r_nbytes, int *sign)
263 {
264   return do_get_buffer (a, fill_le, r_nbytes, sign, 0);
265 }
266
267 byte *
268 _gcry_mpi_get_secure_buffer (gcry_mpi_t a, unsigned int fill_le,
269                              unsigned int *r_nbytes, int *sign)
270 {
271   return do_get_buffer (a, fill_le, r_nbytes, sign, 1);
272 }
273
274
275 /*
276  * Use the NBYTES at BUFFER_ARG to update A.  Set the sign of a to
277  * SIGN.
278  */
279 void
280 _gcry_mpi_set_buffer (gcry_mpi_t a, const void *buffer_arg,
281                       unsigned int nbytes, int sign)
282 {
283   const unsigned char *buffer = (const unsigned char*)buffer_arg;
284   const unsigned char *p;
285   mpi_limb_t alimb;
286   int nlimbs;
287   int i;
288
289   if (mpi_is_immutable (a))
290     {
291       mpi_immutable_failed ();
292       return;
293     }
294
295   nlimbs = (nbytes + BYTES_PER_MPI_LIMB - 1) / BYTES_PER_MPI_LIMB;
296   RESIZE_IF_NEEDED(a, nlimbs);
297   a->sign = sign;
298
299   for (i=0, p = buffer+nbytes-1; p >= buffer+BYTES_PER_MPI_LIMB; )
300     {
301 #if BYTES_PER_MPI_LIMB == 4
302       alimb  = *p--         ;
303       alimb |= *p-- <<  8 ;
304       alimb |= *p-- << 16 ;
305       alimb |= *p-- << 24 ;
306 #elif BYTES_PER_MPI_LIMB == 8
307       alimb  = (mpi_limb_t)*p-- ;
308       alimb |= (mpi_limb_t)*p-- <<  8 ;
309       alimb |= (mpi_limb_t)*p-- << 16 ;
310       alimb |= (mpi_limb_t)*p-- << 24 ;
311       alimb |= (mpi_limb_t)*p-- << 32 ;
312       alimb |= (mpi_limb_t)*p-- << 40 ;
313       alimb |= (mpi_limb_t)*p-- << 48 ;
314       alimb |= (mpi_limb_t)*p-- << 56 ;
315 #else
316 #       error please implement for this limb size.
317 #endif
318       a->d[i++] = alimb;
319     }
320   if ( p >= buffer )
321     {
322 #if BYTES_PER_MPI_LIMB == 4
323       alimb  = *p--;
324       if (p >= buffer)
325         alimb |= *p-- <<  8;
326       if (p >= buffer)
327         alimb |= *p-- << 16;
328       if (p >= buffer)
329         alimb |= *p-- << 24;
330 #elif BYTES_PER_MPI_LIMB == 8
331       alimb  = (mpi_limb_t)*p--;
332       if (p >= buffer)
333         alimb |= (mpi_limb_t)*p-- << 8;
334       if (p >= buffer)
335         alimb |= (mpi_limb_t)*p-- << 16;
336       if (p >= buffer)
337         alimb |= (mpi_limb_t)*p-- << 24;
338       if (p >= buffer)
339         alimb |= (mpi_limb_t)*p-- << 32;
340       if (p >= buffer)
341         alimb |= (mpi_limb_t)*p-- << 40;
342       if (p >= buffer)
343         alimb |= (mpi_limb_t)*p-- << 48;
344       if (p >= buffer)
345         alimb |= (mpi_limb_t)*p-- << 56;
346 #else
347 #     error please implement for this limb size.
348 #endif
349       a->d[i++] = alimb;
350     }
351   a->nlimbs = i;
352   gcry_assert (i == nlimbs);
353 }
354
355
356 static void
357 onecompl (gcry_mpi_t a)
358 {
359   mpi_ptr_t ap;
360   mpi_size_t n;
361   unsigned int i;
362   unsigned int nbits = mpi_get_nbits (a);
363
364   if (mpi_is_immutable (a))
365     {
366       mpi_immutable_failed ();
367       return;
368     }
369
370   mpi_normalize (a);
371   ap = a->d;
372   n = a->nlimbs;
373
374   for( i = 0; i < n; i++ )
375     ap[i] ^= (mpi_limb_t)(-1);
376
377   a->sign = 0;
378   mpi_clear_highbit (a, nbits-1);
379 }
380
381
382 /* Perform a two's complement operation on buffer P of size N bytes.  */
383 static void
384 twocompl (unsigned char *p, unsigned int n)
385 {
386   int i;
387
388   for (i=n-1; i >= 0 && !p[i]; i--)
389     ;
390   if (i >= 0)
391     {
392       if ((p[i] & 0x01))
393         p[i] = (((p[i] ^ 0xfe) | 0x01) & 0xff);
394       else if ((p[i] & 0x02))
395         p[i] = (((p[i] ^ 0xfc) | 0x02) & 0xfe);
396       else if ((p[i] & 0x04))
397         p[i] = (((p[i] ^ 0xf8) | 0x04) & 0xfc);
398       else if ((p[i] & 0x08))
399         p[i] = (((p[i] ^ 0xf0) | 0x08) & 0xf8);
400       else if ((p[i] & 0x10))
401         p[i] = (((p[i] ^ 0xe0) | 0x10) & 0xf0);
402       else if ((p[i] & 0x20))
403         p[i] = (((p[i] ^ 0xc0) | 0x20) & 0xe0);
404       else if ((p[i] & 0x40))
405         p[i] = (((p[i] ^ 0x80) | 0x40) & 0xc0);
406       else
407         p[i] = 0x80;
408
409       for (i--; i >= 0; i--)
410         p[i] ^= 0xff;
411     }
412 }
413
414
415 /* Convert the external representation of an integer stored in BUFFER
416    with a length of BUFLEN into a newly create MPI returned in
417    RET_MPI.  If NBYTES is not NULL, it will receive the number of
418    bytes actually scanned after a successful operation.  */
419 gcry_err_code_t
420 _gcry_mpi_scan (struct gcry_mpi **ret_mpi, enum gcry_mpi_format format,
421                 const void *buffer_arg, size_t buflen, size_t *nscanned)
422 {
423   const unsigned char *buffer = (const unsigned char*)buffer_arg;
424   struct gcry_mpi *a = NULL;
425   unsigned int len;
426   int secure = (buffer && _gcry_is_secure (buffer));
427
428   if (format == GCRYMPI_FMT_SSH)
429     len = 0;
430   else
431     len = buflen;
432
433   if (format == GCRYMPI_FMT_STD)
434     {
435       const unsigned char *s = buffer;
436
437       a = secure? mpi_alloc_secure ((len+BYTES_PER_MPI_LIMB-1)
438                                     /BYTES_PER_MPI_LIMB)
439                 : mpi_alloc ((len+BYTES_PER_MPI_LIMB-1)/BYTES_PER_MPI_LIMB);
440       if (len)
441         {
442           _gcry_mpi_set_buffer (a, s, len, 0);
443           a->sign = !!(*s & 0x80);
444           if (a->sign)
445             {
446               onecompl (a);
447               mpi_add_ui (a, a, 1);
448               a->sign = 1;
449             }
450         }
451       if (ret_mpi)
452         {
453           mpi_normalize ( a );
454           *ret_mpi = a;
455         }
456       else
457         mpi_free(a);
458       if (nscanned)
459         *nscanned = len;
460       return 0;
461     }
462   else if (format == GCRYMPI_FMT_USG)
463     {
464       a = secure? mpi_alloc_secure ((len+BYTES_PER_MPI_LIMB-1)
465                                     /BYTES_PER_MPI_LIMB)
466                 : mpi_alloc ((len+BYTES_PER_MPI_LIMB-1)/BYTES_PER_MPI_LIMB);
467
468       if (len)
469         _gcry_mpi_set_buffer (a, buffer, len, 0);
470       if (ret_mpi)
471         {
472           mpi_normalize ( a );
473           *ret_mpi = a;
474         }
475       else
476         mpi_free(a);
477       if (nscanned)
478         *nscanned = len;
479       return 0;
480     }
481   else if (format == GCRYMPI_FMT_PGP)
482     {
483       a = mpi_read_from_buffer (buffer, &len, secure);
484       if (nscanned)
485         *nscanned = len;
486       if (ret_mpi && a)
487         {
488           mpi_normalize (a);
489           *ret_mpi = a;
490         }
491       else if (a)
492         {
493           mpi_free(a);
494           a = NULL;
495         }
496       return a? 0 : GPG_ERR_INV_OBJ;
497     }
498   else if (format == GCRYMPI_FMT_SSH)
499     {
500       const unsigned char *s = buffer;
501       size_t n;
502
503       /* This test is not strictly necessary and an assert (!len)
504          would be sufficient.  We keep this test in case we later
505          allow the BUFLEN argument to act as a sanitiy check.  Same
506          below. */
507       if (len && len < 4)
508         return GPG_ERR_TOO_SHORT;
509
510       n = (s[0] << 24 | s[1] << 16 | s[2] << 8 | s[3]);
511       s += 4;
512       if (len)
513         len -= 4;
514       if (len && n > len)
515         return GPG_ERR_TOO_LARGE;
516
517       a = secure? mpi_alloc_secure ((n+BYTES_PER_MPI_LIMB-1)
518                                     /BYTES_PER_MPI_LIMB)
519                 : mpi_alloc ((n+BYTES_PER_MPI_LIMB-1)/BYTES_PER_MPI_LIMB);
520       if (n)
521         {
522           _gcry_mpi_set_buffer( a, s, n, 0 );
523           a->sign = !!(*s & 0x80);
524           if (a->sign)
525             {
526               onecompl (a);
527               mpi_add_ui (a, a, 1);
528               a->sign = 1;
529             }
530         }
531       if (nscanned)
532         *nscanned = n+4;
533       if (ret_mpi)
534         {
535           mpi_normalize ( a );
536           *ret_mpi = a;
537         }
538       else
539         mpi_free(a);
540       return 0;
541     }
542   else if (format == GCRYMPI_FMT_HEX)
543     {
544       /* We can only handle C strings for now.  */
545       if (buflen)
546         return GPG_ERR_INV_ARG;
547
548       a = secure? mpi_alloc_secure (0) : mpi_alloc(0);
549       if (mpi_fromstr (a, (const char *)buffer))
550         {
551           mpi_free (a);
552           return GPG_ERR_INV_OBJ;
553         }
554       if (ret_mpi)
555         {
556           mpi_normalize ( a );
557           *ret_mpi = a;
558         }
559       else
560         mpi_free(a);
561       if (nscanned)
562         *nscanned = strlen ((const char*)buffer);
563       return 0;
564     }
565   else
566     return GPG_ERR_INV_ARG;
567 }
568
569
570 /* Convert the big integer A into the external representation
571    described by FORMAT and store it in the provided BUFFER which has
572    been allocated by the user with a size of BUFLEN bytes.  NWRITTEN
573    receives the actual length of the external representation unless it
574    has been passed as NULL.  BUFFER may be NULL to query the required
575    length.  */
576 gcry_err_code_t
577 _gcry_mpi_print (enum gcry_mpi_format format,
578                  unsigned char *buffer, size_t buflen,
579                  size_t *nwritten, struct gcry_mpi *a)
580 {
581   unsigned int nbits = mpi_get_nbits (a);
582   size_t len;
583   size_t dummy_nwritten;
584   int negative;
585
586   if (!nwritten)
587     nwritten = &dummy_nwritten;
588
589   /* Libgcrypt does no always care to set clear the sign if the value
590      is 0.  For printing this is a bit of a surprise, in particular
591      because if some of the formats don't support negative numbers but
592      should be able to print a zero.  Thus we need this extra test
593      for a negative number.  */
594   if (a->sign && _gcry_mpi_cmp_ui (a, 0))
595     negative = 1;
596   else
597     negative = 0;
598
599   len = buflen;
600   *nwritten = 0;
601   if (format == GCRYMPI_FMT_STD)
602     {
603       unsigned char *tmp;
604       int extra = 0;
605       unsigned int n;
606
607       tmp = _gcry_mpi_get_buffer (a, 0, &n, NULL);
608       if (!tmp)
609         return gpg_err_code_from_syserror ();
610
611       if (negative)
612         {
613           twocompl (tmp, n);
614           if (!(*tmp & 0x80))
615             {
616               /* Need to extend the sign.  */
617               n++;
618               extra = 2;
619             }
620         }
621       else if (n && (*tmp & 0x80))
622         {
623           /* Positive but the high bit of the returned buffer is set.
624              Thus we need to print an extra leading 0x00 so that the
625              output is interpreted as a positive number.  */
626           n++;
627           extra = 1;
628         }
629
630       if (buffer && n > len)
631         {
632           /* The provided buffer is too short. */
633           xfree (tmp);
634           return GPG_ERR_TOO_SHORT;
635         }
636       if (buffer)
637         {
638           unsigned char *s = buffer;
639
640           if (extra == 1)
641             *s++ = 0;
642           else if (extra)
643             *s++ = 0xff;
644           memcpy (s, tmp, n-!!extra);
645         }
646       xfree (tmp);
647       *nwritten = n;
648       return 0;
649     }
650   else if (format == GCRYMPI_FMT_USG)
651     {
652       unsigned int n = (nbits + 7)/8;
653
654       /* Note:  We ignore the sign for this format.  */
655       /* FIXME: for performance reasons we should put this into
656          mpi_aprint because we can then use the buffer directly.  */
657
658       if (buffer && n > len)
659         return GPG_ERR_TOO_SHORT;
660       if (buffer)
661         {
662           unsigned char *tmp;
663
664           tmp = _gcry_mpi_get_buffer (a, 0, &n, NULL);
665           if (!tmp)
666             return gpg_err_code_from_syserror ();
667           memcpy (buffer, tmp, n);
668           xfree (tmp);
669         }
670       *nwritten = n;
671       return 0;
672     }
673   else if (format == GCRYMPI_FMT_PGP)
674     {
675       unsigned int n = (nbits + 7)/8;
676
677       /* The PGP format can only handle unsigned integers.  */
678       if (negative)
679         return GPG_ERR_INV_ARG;
680
681       if (buffer && n+2 > len)
682         return GPG_ERR_TOO_SHORT;
683
684       if (buffer)
685         {
686           unsigned char *tmp;
687           unsigned char *s = buffer;
688
689           s[0] = nbits >> 8;
690           s[1] = nbits;
691
692           tmp = _gcry_mpi_get_buffer (a, 0, &n, NULL);
693           if (!tmp)
694             return gpg_err_code_from_syserror ();
695           memcpy (s+2, tmp, n);
696           xfree (tmp);
697         }
698       *nwritten = n+2;
699       return 0;
700     }
701   else if (format == GCRYMPI_FMT_SSH)
702     {
703       unsigned char *tmp;
704       int extra = 0;
705       unsigned int n;
706
707       tmp = _gcry_mpi_get_buffer (a, 0, &n, NULL);
708       if (!tmp)
709         return gpg_err_code_from_syserror ();
710
711       if (negative)
712         {
713           twocompl (tmp, n);
714           if (!(*tmp & 0x80))
715             {
716               /* Need to extend the sign.  */
717               n++;
718               extra = 2;
719             }
720         }
721       else if (n && (*tmp & 0x80))
722         {
723           n++;
724           extra=1;
725         }
726
727       if (buffer && n+4 > len)
728         {
729           xfree(tmp);
730           return GPG_ERR_TOO_SHORT;
731         }
732
733       if (buffer)
734         {
735           unsigned char *s = buffer;
736
737           *s++ = n >> 24;
738           *s++ = n >> 16;
739           *s++ = n >> 8;
740           *s++ = n;
741           if (extra == 1)
742             *s++ = 0;
743           else if (extra)
744             *s++ = 0xff;
745           memcpy (s, tmp, n-!!extra);
746         }
747       xfree (tmp);
748       *nwritten = 4+n;
749       return 0;
750     }
751   else if (format == GCRYMPI_FMT_HEX)
752     {
753       unsigned char *tmp;
754       int i;
755       int extra = 0;
756       unsigned int n = 0;
757
758       tmp = _gcry_mpi_get_buffer (a, 0, &n, NULL);
759       if (!tmp)
760         return gpg_err_code_from_syserror ();
761       if (!n || (*tmp & 0x80))
762         extra = 2;
763
764       if (buffer && 2*n + extra + negative + 1 > len)
765         {
766           xfree(tmp);
767           return GPG_ERR_TOO_SHORT;
768         }
769       if (buffer)
770         {
771           unsigned char *s = buffer;
772
773           if (negative)
774             *s++ = '-';
775           if (extra)
776             {
777               *s++ = '0';
778               *s++ = '0';
779             }
780
781           for (i=0; i < n; i++)
782             {
783               unsigned int c = tmp[i];
784
785               *s++ = (c >> 4) < 10? '0'+(c>>4) : 'A'+(c>>4)-10 ;
786               c &= 15;
787               *s++ = c < 10? '0'+c : 'A'+c-10 ;
788             }
789           *s++ = 0;
790           *nwritten = s - buffer;
791         }
792       else
793         {
794           *nwritten = 2*n + extra + negative + 1;
795         }
796       xfree (tmp);
797       return 0;
798     }
799   else
800     return GPG_ERR_INV_ARG;
801 }
802
803
804 /*
805  * Like gcry_mpi_print but this function allocates the buffer itself.
806  * The caller has to supply the address of a pointer.  NWRITTEN may be
807  * NULL.
808  */
809 gcry_err_code_t
810 _gcry_mpi_aprint (enum gcry_mpi_format format,
811                   unsigned char **buffer, size_t *nwritten,
812                   struct gcry_mpi *a)
813 {
814   size_t n;
815   gcry_err_code_t rc;
816
817   *buffer = NULL;
818   rc = _gcry_mpi_print (format, NULL, 0, &n, a);
819   if (rc)
820     return rc;
821
822   *buffer = mpi_is_secure(a) ? xtrymalloc_secure (n?n:1) : xtrymalloc (n?n:1);
823   if (!*buffer)
824     return gpg_err_code_from_syserror ();
825   /* If the returned buffer will have a length of 0, we nevertheless
826      allocated 1 byte (malloc needs it anyway) and store a 0.  */
827   if (!n)
828     **buffer = 0;
829   rc = _gcry_mpi_print( format, *buffer, n, &n, a );
830   if (rc)
831     {
832       xfree (*buffer);
833       *buffer = NULL;
834     }
835   else if (nwritten)
836     *nwritten = n;
837   return rc;
838 }
839
840
841 /* Turn VALUE into an octet string and store it in an allocated buffer
842    at R_FRAME or - if R_RAME is NULL - copy it into the caller
843    provided buffer SPACE; either SPACE or R_FRAME may be used.  If
844    SPACE if not NULL, the caller must provide a buffer of at least
845    NBYTES.  If the resulting octet string is shorter than NBYTES pad
846    it to the left with zeroes.  If VALUE does not fit into NBYTES
847    return an error code.  */
848 gpg_err_code_t
849 _gcry_mpi_to_octet_string (unsigned char **r_frame, void *space,
850                            gcry_mpi_t value, size_t nbytes)
851 {
852   gpg_err_code_t rc;
853   size_t nframe, noff, n;
854   unsigned char *frame;
855
856   if (!r_frame == !space)
857     return GPG_ERR_INV_ARG;  /* Only one may be used.  */
858
859   if (r_frame)
860     *r_frame = NULL;
861
862   rc = _gcry_mpi_print (GCRYMPI_FMT_USG, NULL, 0, &nframe, value);
863   if (rc)
864     return rc;
865   if (nframe > nbytes)
866     return GPG_ERR_TOO_LARGE; /* Value too long to fit into NBYTES.  */
867
868   noff = (nframe < nbytes)? nbytes - nframe : 0;
869   n = nframe + noff;
870   if (space)
871     frame = space;
872   else
873     {
874       frame = mpi_is_secure (value)? xtrymalloc_secure (n) : xtrymalloc (n);
875       if (!frame)
876         {
877           rc = gpg_err_code_from_syserror ();
878           return rc;
879         }
880     }
881   if (noff)
882     memset (frame, 0, noff);
883   nframe += noff;
884   rc = _gcry_mpi_print (GCRYMPI_FMT_USG, frame+noff, nframe-noff, NULL, value);
885   if (rc)
886     {
887       xfree (frame);
888       return rc;
889     }
890
891   if (r_frame)
892     *r_frame = frame;
893   return 0;
894 }