Use attribute __gnu_printf__ with our estream-printf functions.
[gnupg.git] / common / sexputil.c
1 /* sexputil.c - Utility functions for S-expressions.
2  * Copyright (C) 2005, 2007, 2009 Free Software Foundation, Inc.
3  * Copyright (C) 2013 Werner Koch
4  *
5  * This file is part of GnuPG.
6  *
7  * This file is free software; you can redistribute it and/or modify
8  * it under the terms of either
9  *
10  *   - the GNU Lesser General Public License as published by the Free
11  *     Software Foundation; either version 3 of the License, or (at
12  *     your option) any later version.
13  *
14  * or
15  *
16  *   - the GNU General Public License as published by the Free
17  *     Software Foundation; either version 2 of the License, or (at
18  *     your option) any later version.
19  *
20  * or both in parallel, as here.
21  *
22  * This file is distributed in the hope that it will be useful,
23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
25  * GNU General Public License for more details.
26  *
27  * You should have received a copy of the GNU General Public License
28  * along with this program; if not, see <http://www.gnu.org/licenses/>.
29  */
30
31 /* This file implements a few utility functions useful when working
32    with canonical encrypted S-expresions (i.e. not the S-exprssion
33    objects from libgcrypt).  */
34
35 #include <config.h>
36 #include <stdio.h>
37 #include <stdlib.h>
38 #include <string.h>
39 #include <unistd.h>
40 #include <errno.h>
41 #ifdef HAVE_LOCALE_H
42 #include <locale.h>
43 #endif
44
45 #include "util.h"
46 #include "tlv.h"
47 #include "sexp-parse.h"
48
49
50 /* Return a malloced string with the S-expression CANON in advanced
51    format.  Returns NULL on error.  */
52 static char *
53 sexp_to_string (gcry_sexp_t sexp)
54 {
55   size_t n;
56   char *result;
57
58   if (!sexp)
59     return NULL;
60   n = gcry_sexp_sprint (sexp, GCRYSEXP_FMT_ADVANCED, NULL, 0);
61   if (!n)
62     return NULL;
63   result = xtrymalloc (n);
64   if (!result)
65     return NULL;
66   n = gcry_sexp_sprint (sexp, GCRYSEXP_FMT_ADVANCED, result, n);
67   if (!n)
68     BUG ();
69
70   return result;
71 }
72
73
74 /* Return a malloced string with the S-expression CANON in advanced
75    format.  Returns NULL on error.  */
76 char *
77 canon_sexp_to_string (const unsigned char *canon, size_t canonlen)
78 {
79   size_t n;
80   gcry_sexp_t sexp;
81   char *result;
82
83   n = gcry_sexp_canon_len (canon, canonlen, NULL, NULL);
84   if (!n)
85     return NULL;
86   if (gcry_sexp_sscan (&sexp, NULL, canon, n))
87     return NULL;
88   result = sexp_to_string (sexp);
89   gcry_sexp_release (sexp);
90   return result;
91 }
92
93
94 /* Print the canonical encoded S-expression in SEXP in advanced
95    format.  SEXPLEN may be passed as 0 is SEXP is known to be valid.
96    With TEXT of NULL print just the raw S-expression, with TEXT just
97    an empty string, print a trailing linefeed, otherwise print an
98    entire debug line. */
99 void
100 log_printcanon (const char *text, const unsigned char *sexp, size_t sexplen)
101 {
102   if (text && *text)
103     log_debug ("%s ", text);
104   if (sexp)
105     {
106       char *buf = canon_sexp_to_string (sexp, sexplen);
107       log_printf ("%s", buf? buf : "[invalid S-expression]");
108       xfree (buf);
109     }
110   if (text)
111     log_printf ("\n");
112 }
113
114
115 /* Print the gcryp S-expression in SEXP in advanced format.  With TEXT
116    of NULL print just the raw S-expression, with TEXT just an empty
117    string, print a trailing linefeed, otherwise print an entire debug
118    line. */
119 void
120 log_printsexp (const char *text, gcry_sexp_t sexp)
121 {
122   if (text && *text)
123     log_debug ("%s ", text);
124   if (sexp)
125     {
126       char *buf = sexp_to_string (sexp);
127       log_printf ("%s", buf? buf : "[invalid S-expression]");
128       xfree (buf);
129     }
130   if (text)
131     log_printf ("\n");
132 }
133
134
135 /* Helper function to create a canonical encoded S-expression from a
136    Libgcrypt S-expression object.  The function returns 0 on success
137    and the malloced canonical S-expression is stored at R_BUFFER and
138    the allocated length at R_BUFLEN.  On error an error code is
139    returned and (NULL, 0) stored at R_BUFFER and R_BUFLEN.  If the
140    allocated buffer length is not required, NULL by be used for
141    R_BUFLEN.  */
142 gpg_error_t
143 make_canon_sexp (gcry_sexp_t sexp, unsigned char **r_buffer, size_t *r_buflen)
144 {
145   size_t len;
146   unsigned char *buf;
147
148   *r_buffer = NULL;
149   if (r_buflen)
150     *r_buflen = 0;;
151
152   len = gcry_sexp_sprint (sexp, GCRYSEXP_FMT_CANON, NULL, 0);
153   if (!len)
154     return gpg_error (GPG_ERR_BUG);
155   buf = xtrymalloc (len);
156   if (!buf)
157     return gpg_error_from_syserror ();
158   len = gcry_sexp_sprint (sexp, GCRYSEXP_FMT_CANON, buf, len);
159   if (!len)
160     return gpg_error (GPG_ERR_BUG);
161
162   *r_buffer = buf;
163   if (r_buflen)
164     *r_buflen = len;
165
166   return 0;
167 }
168
169
170 /* Same as make_canon_sexp but pad the buffer to multiple of 64
171    bits.  If SECURE is set, secure memory will be allocated.  */
172 gpg_error_t
173 make_canon_sexp_pad (gcry_sexp_t sexp, int secure,
174                      unsigned char **r_buffer, size_t *r_buflen)
175 {
176   size_t len;
177   unsigned char *buf;
178
179   *r_buffer = NULL;
180   if (r_buflen)
181     *r_buflen = 0;;
182
183   len = gcry_sexp_sprint (sexp, GCRYSEXP_FMT_CANON, NULL, 0);
184   if (!len)
185     return gpg_error (GPG_ERR_BUG);
186   len += (8 - len % 8) % 8;
187   buf = secure? xtrycalloc_secure (1, len) : xtrycalloc (1, len);
188   if (!buf)
189     return gpg_error_from_syserror ();
190   if (!gcry_sexp_sprint (sexp, GCRYSEXP_FMT_CANON, buf, len))
191     return gpg_error (GPG_ERR_BUG);
192
193   *r_buffer = buf;
194   if (r_buflen)
195     *r_buflen = len;
196
197   return 0;
198 }
199
200 /* Return the so called "keygrip" which is the SHA-1 hash of the
201    public key parameters expressed in a way depended on the algorithm.
202
203    KEY is expected to be an canonical encoded S-expression with a
204    public or private key. KEYLEN is the length of that buffer.
205
206    GRIP must be at least 20 bytes long.  On success 0 is returned, on
207    error an error code. */
208 gpg_error_t
209 keygrip_from_canon_sexp (const unsigned char *key, size_t keylen,
210                          unsigned char *grip)
211 {
212   gpg_error_t err;
213   gcry_sexp_t sexp;
214
215   if (!grip)
216     return gpg_error (GPG_ERR_INV_VALUE);
217   err = gcry_sexp_sscan (&sexp, NULL, (const char *)key, keylen);
218   if (err)
219     return err;
220   if (!gcry_pk_get_keygrip (sexp, grip))
221     err = gpg_error (GPG_ERR_INTERNAL);
222   gcry_sexp_release (sexp);
223   return err;
224 }
225
226
227 /* Compare two simple S-expressions like "(3:foo)".  Returns 0 if they
228    are identical or !0 if they are not.  Note that this function can't
229    be used for sorting. */
230 int
231 cmp_simple_canon_sexp (const unsigned char *a_orig,
232                        const unsigned char *b_orig)
233 {
234   const char *a = (const char *)a_orig;
235   const char *b = (const char *)b_orig;
236   unsigned long n1, n2;
237   char *endp;
238
239   if (!a && !b)
240     return 0; /* Both are NULL, they are identical. */
241   if (!a || !b)
242     return 1; /* One is NULL, they are not identical. */
243   if (*a != '(' || *b != '(')
244     log_bug ("invalid S-exp in cmp_simple_canon_sexp\n");
245
246   a++;
247   n1 = strtoul (a, &endp, 10);
248   a = endp;
249   b++;
250   n2 = strtoul (b, &endp, 10);
251   b = endp;
252
253   if (*a != ':' || *b != ':' )
254     log_bug ("invalid S-exp in cmp_simple_canon_sexp\n");
255   if (n1 != n2)
256     return 1; /* Not the same. */
257
258   for (a++, b++; n1; n1--, a++, b++)
259     if (*a != *b)
260       return 1; /* Not the same. */
261   return 0;
262 }
263
264
265 /* Create a simple S-expression from the hex string at LINE.  Returns
266    a newly allocated buffer with that canonical encoded S-expression
267    or NULL in case of an error.  On return the number of characters
268    scanned in LINE will be stored at NSCANNED.  This fucntions stops
269    converting at the first character not representing a hexdigit. Odd
270    numbers of hex digits are allowed; a leading zero is then
271    assumed. If no characters have been found, NULL is returned.*/
272 unsigned char *
273 make_simple_sexp_from_hexstr (const char *line, size_t *nscanned)
274 {
275   size_t n, len;
276   const char *s;
277   unsigned char *buf;
278   unsigned char *p;
279   char numbuf[50], *numbufp;
280   size_t numbuflen;
281
282   for (n=0, s=line; hexdigitp (s); s++, n++)
283     ;
284   if (nscanned)
285     *nscanned = n;
286   if (!n)
287     return NULL;
288   len = ((n+1) & ~0x01)/2;
289   numbufp = smklen (numbuf, sizeof numbuf, len, &numbuflen);
290   buf = xtrymalloc (1 + numbuflen + len + 1 + 1);
291   if (!buf)
292     return NULL;
293   buf[0] = '(';
294   p = (unsigned char *)stpcpy ((char *)buf+1, numbufp);
295   s = line;
296   if ((n&1))
297     {
298       *p++ = xtoi_1 (s);
299       s++;
300       n--;
301     }
302   for (; n > 1; n -=2, s += 2)
303     *p++ = xtoi_2 (s);
304   *p++ = ')';
305   *p = 0; /* (Not really neaded.) */
306
307   return buf;
308 }
309
310
311 /* Return the hash algorithm from a KSBA sig-val. SIGVAL is a
312    canonical encoded S-expression.  Return 0 if the hash algorithm is
313    not encoded in SIG-VAL or it is not supported by libgcrypt.  */
314 int
315 hash_algo_from_sigval (const unsigned char *sigval)
316 {
317   const unsigned char *s = sigval;
318   size_t n;
319   int depth;
320   char buffer[50];
321
322   if (!s || *s != '(')
323     return 0; /* Invalid S-expression.  */
324   s++;
325   n = snext (&s);
326   if (!n)
327     return 0; /* Invalid S-expression.  */
328   if (!smatch (&s, n, "sig-val"))
329     return 0; /* Not a sig-val.  */
330   if (*s != '(')
331     return 0; /* Invalid S-expression.  */
332   s++;
333   /* Skip over the algo+parameter list.  */
334   depth = 1;
335   if (sskip (&s, &depth) || depth)
336     return 0; /* Invalid S-expression.  */
337   if (*s != '(')
338     return 0; /* No futher list.  */
339   /* Check whether this is (hash ALGO).  */
340   s++;
341   n = snext (&s);
342   if (!n)
343     return 0; /* Invalid S-expression.  */
344   if (!smatch (&s, n, "hash"))
345     return 0; /* Not a "hash" keyword.  */
346   n = snext (&s);
347   if (!n || n+1 >= sizeof (buffer))
348     return 0; /* Algorithm string is missing or too long.  */
349   memcpy (buffer, s, n);
350   buffer[n] = 0;
351
352   return gcry_md_map_name (buffer);
353 }
354
355
356 /* Create a public key S-expression for an RSA public key from the
357    modulus M with length MLEN and the public exponent E with length
358    ELEN.  Returns a newly allocated buffer of NULL in case of a memory
359    allocation problem.  If R_LEN is not NULL, the length of the
360    canonical S-expression is stored there. */
361 unsigned char *
362 make_canon_sexp_from_rsa_pk (const void *m_arg, size_t mlen,
363                              const void *e_arg, size_t elen,
364                              size_t *r_len)
365 {
366   const unsigned char *m = m_arg;
367   const unsigned char *e = e_arg;
368   int m_extra = 0;
369   int e_extra = 0;
370   char mlen_str[35];
371   char elen_str[35];
372   unsigned char *keybuf, *p;
373   const char const part1[] = "(10:public-key(3:rsa(1:n";
374   const char const part2[] = ")(1:e";
375   const char const part3[] = ")))";
376
377   /* Remove leading zeroes.  */
378   for (; mlen && !*m; mlen--, m++)
379     ;
380   for (; elen && !*e; elen--, e++)
381     ;
382
383   /* Insert a leading zero if the number would be zero or interpreted
384      as negative.  */
385   if (!mlen || (m[0] & 0x80))
386     m_extra = 1;
387   if (!elen || (e[0] & 0x80))
388     e_extra = 1;
389
390   /* Build the S-expression.  */
391   snprintf (mlen_str, sizeof mlen_str, "%u:", (unsigned int)mlen+m_extra);
392   snprintf (elen_str, sizeof elen_str, "%u:", (unsigned int)elen+e_extra);
393
394   keybuf = xtrymalloc (strlen (part1) + strlen (mlen_str) + mlen + m_extra
395                        + strlen (part2) + strlen (elen_str) + elen + e_extra
396                        + strlen (part3) + 1);
397   if (!keybuf)
398     return NULL;
399
400   p = stpcpy (keybuf, part1);
401   p = stpcpy (p, mlen_str);
402   if (m_extra)
403     *p++ = 0;
404   memcpy (p, m, mlen);
405   p += mlen;
406   p = stpcpy (p, part2);
407   p = stpcpy (p, elen_str);
408   if (e_extra)
409     *p++ = 0;
410   memcpy (p, e, elen);
411   p += elen;
412   p = stpcpy (p, part3);
413
414   if (r_len)
415     *r_len = p - keybuf;
416
417   return keybuf;
418 }
419
420
421 /* Return the parameters of a public RSA key expressed as an
422    canonical encoded S-expression.  */
423 gpg_error_t
424 get_rsa_pk_from_canon_sexp (const unsigned char *keydata, size_t keydatalen,
425                             unsigned char const **r_n, size_t *r_nlen,
426                             unsigned char const **r_e, size_t *r_elen)
427 {
428   gpg_error_t err;
429   const unsigned char *buf, *tok;
430   size_t buflen, toklen;
431   int depth, last_depth1, last_depth2;
432   const unsigned char *rsa_n = NULL;
433   const unsigned char *rsa_e = NULL;
434   size_t rsa_n_len, rsa_e_len;
435
436   *r_n = NULL;
437   *r_nlen = 0;
438   *r_e = NULL;
439   *r_elen = 0;
440
441   buf = keydata;
442   buflen = keydatalen;
443   depth = 0;
444   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
445     return err;
446   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
447     return err;
448   if (!tok || toklen != 10 || memcmp ("public-key", tok, toklen))
449     return gpg_error (GPG_ERR_BAD_PUBKEY);
450   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
451     return err;
452   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
453     return err;
454   if (!tok || toklen != 3 || memcmp ("rsa", tok, toklen))
455     return gpg_error (GPG_ERR_WRONG_PUBKEY_ALGO);
456
457   last_depth1 = depth;
458   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
459          && depth && depth >= last_depth1)
460     {
461       if (tok)
462         return gpg_error (GPG_ERR_UNKNOWN_SEXP);
463       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
464         return err;
465       if (tok && toklen == 1)
466         {
467           const unsigned char **mpi;
468           size_t *mpi_len;
469
470           switch (*tok)
471             {
472             case 'n': mpi = &rsa_n; mpi_len = &rsa_n_len; break;
473             case 'e': mpi = &rsa_e; mpi_len = &rsa_e_len; break;
474             default:  mpi = NULL;   mpi_len = NULL; break;
475             }
476           if (mpi && *mpi)
477             return gpg_error (GPG_ERR_DUP_VALUE);
478
479           if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
480             return err;
481           if (tok && mpi)
482             {
483               /* Strip off leading zero bytes and save. */
484               for (;toklen && !*tok; toklen--, tok++)
485                 ;
486               *mpi = tok;
487               *mpi_len = toklen;
488             }
489         }
490
491       /* Skip to the end of the list. */
492       last_depth2 = depth;
493       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
494              && depth && depth >= last_depth2)
495         ;
496       if (err)
497         return err;
498     }
499
500   if (err)
501     return err;
502
503   if (!rsa_n || !rsa_n_len || !rsa_e || !rsa_e_len)
504     return gpg_error (GPG_ERR_BAD_PUBKEY);
505
506   *r_n = rsa_n;
507   *r_nlen = rsa_n_len;
508   *r_e = rsa_e;
509   *r_elen = rsa_e_len;
510   return 0;
511 }
512
513
514 /* Return the algo of a public RSA expressed as an canonical encoded
515    S-expression.  The return value is a statically allocated
516    string.  On error that string is set to NULL. */
517 gpg_error_t
518 get_pk_algo_from_canon_sexp (const unsigned char *keydata, size_t keydatalen,
519                              const char **r_algo)
520 {
521   gpg_error_t err;
522   const unsigned char *buf, *tok;
523   size_t buflen, toklen;
524   int depth;
525
526   *r_algo = NULL;
527
528   buf = keydata;
529   buflen = keydatalen;
530   depth = 0;
531   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
532     return err;
533   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
534     return err;
535   if (!tok || toklen != 10 || memcmp ("public-key", tok, toklen))
536     return gpg_error (GPG_ERR_BAD_PUBKEY);
537   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
538     return err;
539   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
540     return err;
541   if (!tok)
542     return gpg_error (GPG_ERR_BAD_PUBKEY);
543
544   if (toklen == 3 && !memcmp ("rsa", tok, toklen))
545     *r_algo = "rsa";
546   else if (toklen == 3 && !memcmp ("dsa", tok, toklen))
547     *r_algo = "dsa";
548   else if (toklen == 3 && !memcmp ("elg", tok, toklen))
549     *r_algo = "elg";
550   else if (toklen == 5 && !memcmp ("ecdsa", tok, toklen))
551     *r_algo = "ecdsa";
552   else if (toklen == 5 && !memcmp ("eddsa", tok, toklen))
553     *r_algo = "eddsa";
554   else
555     return gpg_error (GPG_ERR_PUBKEY_ALGO);
556
557   return 0;
558 }