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