speedo: Improve building of the w32 installer.
[gnupg.git] / kbx / keybox-openpgp.c
1 /* keybox-openpgp.c - OpenPGP key parsing
2  * Copyright (C) 2001, 2003, 2011 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 3 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, see <http://www.gnu.org/licenses/>.
18  */
19
20 /* This is a simple OpenPGP parser suitable for all OpenPGP key
21    material.  It just provides the functionality required to build and
22    parse an KBX OpenPGP key blob.  Thus it is not a complete parser.
23    However it is self-contained and optimized for fast in-memory
24    parsing.  Note that we don't support old ElGamal v3 keys
25    anymore. */
26
27 #include <config.h>
28 #include <stdlib.h>
29 #include <stdio.h>
30 #include <string.h>
31 #include <errno.h>
32 #include <assert.h>
33
34 #include "keybox-defs.h"
35
36 #include <gcrypt.h>
37
38 #include "../common/openpgpdefs.h"
39
40
41 /* Assume a valid OpenPGP packet at the address pointed to by BUFBTR
42    which has a maximum length as stored at BUFLEN.  Return the header
43    information of that packet and advance the pointer stored at BUFPTR
44    to the next packet; also adjust the length stored at BUFLEN to
45    match the remaining bytes. If there are no more packets, store NULL
46    at BUFPTR.  Return an non-zero error code on failure or the
47    following data on success:
48
49    R_DATAPKT = Pointer to the begin of the packet data.
50    R_DATALEN = Length of this data.  This has already been checked to fit
51                into the buffer.
52    R_PKTTYPE = The packet type.
53    R_NTOTAL  = The total number of bytes of this packet
54
55    Note that these values are only updated on success.
56 */
57 static gpg_error_t
58 next_packet (unsigned char const **bufptr, size_t *buflen,
59              unsigned char const **r_data, size_t *r_datalen, int *r_pkttype,
60              size_t *r_ntotal)
61 {
62   const unsigned char *buf = *bufptr;
63   size_t len = *buflen;
64   int c, ctb, pkttype;
65   unsigned long pktlen;
66
67   if (!len)
68     return gpg_error (GPG_ERR_NO_DATA);
69
70   ctb = *buf++; len--;
71   if ( !(ctb & 0x80) )
72     return gpg_error (GPG_ERR_INV_PACKET); /* Invalid CTB. */
73
74   pktlen = 0;
75   if ((ctb & 0x40))  /* New style (OpenPGP) CTB.  */
76     {
77       pkttype = (ctb & 0x3f);
78       if (!len)
79         return gpg_error (GPG_ERR_INV_PACKET); /* No 1st length byte. */
80       c = *buf++; len--;
81       if (pkttype == PKT_COMPRESSED)
82         return gpg_error (GPG_ERR_UNEXPECTED); /* ... packet in a keyblock. */
83       if ( c < 192 )
84         pktlen = c;
85       else if ( c < 224 )
86         {
87           pktlen = (c - 192) * 256;
88           if (!len)
89             return gpg_error (GPG_ERR_INV_PACKET); /* No 2nd length byte. */
90           c = *buf++; len--;
91           pktlen += c + 192;
92         }
93       else if (c == 255)
94         {
95           if (len <4 )
96             return gpg_error (GPG_ERR_INV_PACKET); /* No length bytes. */
97           pktlen  = (*buf++) << 24;
98           pktlen |= (*buf++) << 16;
99           pktlen |= (*buf++) << 8;
100           pktlen |= (*buf++);
101           len -= 4;
102       }
103       else /* Partial length encoding is not allowed for key packets. */
104         return gpg_error (GPG_ERR_UNEXPECTED);
105     }
106   else /* Old style CTB.  */
107     {
108       int lenbytes;
109
110       pktlen = 0;
111       pkttype = (ctb>>2)&0xf;
112       lenbytes = ((ctb&3)==3)? 0 : (1<<(ctb & 3));
113       if (!lenbytes) /* Not allowed in key packets.  */
114         return gpg_error (GPG_ERR_UNEXPECTED);
115       if (len < lenbytes)
116         return gpg_error (GPG_ERR_INV_PACKET); /* Not enough length bytes.  */
117       for (; lenbytes; lenbytes--)
118         {
119           pktlen <<= 8;
120           pktlen |= *buf++; len--;
121         }
122     }
123
124   /* Do some basic sanity check.  */
125   switch (pkttype)
126     {
127     case PKT_SIGNATURE:
128     case PKT_SECRET_KEY:
129     case PKT_PUBLIC_KEY:
130     case PKT_SECRET_SUBKEY:
131     case PKT_MARKER:
132     case PKT_RING_TRUST:
133     case PKT_USER_ID:
134     case PKT_PUBLIC_SUBKEY:
135     case PKT_OLD_COMMENT:
136     case PKT_ATTRIBUTE:
137     case PKT_COMMENT:
138     case PKT_GPG_CONTROL:
139       break; /* Okay these are allowed packets. */
140     default:
141       return gpg_error (GPG_ERR_UNEXPECTED);
142     }
143
144   if (pktlen == (unsigned long)(-1))
145     return gpg_error (GPG_ERR_INV_PACKET);
146
147   if (pktlen > len)
148     return gpg_error (GPG_ERR_INV_PACKET); /* Packet length header too long. */
149
150   *r_data = buf;
151   *r_datalen = pktlen;
152   *r_pkttype = pkttype;
153   *r_ntotal = (buf - *bufptr) + pktlen;
154
155   *bufptr = buf + pktlen;
156   *buflen = len - pktlen;
157   if (!*buflen)
158     *bufptr = NULL;
159
160   return 0;
161 }
162
163
164 /* Parse a key packet and store the information in KI. */
165 static gpg_error_t
166 parse_key (const unsigned char *data, size_t datalen,
167            struct _keybox_openpgp_key_info *ki)
168 {
169   gpg_error_t err;
170   const unsigned char *data_start = data;
171   int i, version, algorithm;
172   size_t n;
173   int npkey;
174   unsigned char hashbuffer[768];
175   const unsigned char *mpi_n = NULL;
176   size_t mpi_n_len = 0, mpi_e_len = 0;
177   gcry_md_hd_t md;
178   int is_ecc = 0;
179
180   if (datalen < 5)
181     return gpg_error (GPG_ERR_INV_PACKET);
182   version = *data++; datalen--;
183   if (version < 2 || version > 4 )
184     return gpg_error (GPG_ERR_INV_PACKET); /* Invalid version. */
185
186   /*timestamp = ((data[0]<<24)|(data[1]<<16)|(data[2]<<8)|(data[3]));*/
187   data +=4; datalen -=4;
188
189   if (version < 4)
190     {
191       if (datalen < 2)
192         return gpg_error (GPG_ERR_INV_PACKET);
193       data +=2; datalen -= 2;
194     }
195
196   if (!datalen)
197     return gpg_error (GPG_ERR_INV_PACKET);
198   algorithm = *data++; datalen--;
199
200   switch (algorithm)
201     {
202     case PUBKEY_ALGO_RSA:
203     case PUBKEY_ALGO_RSA_E:
204     case PUBKEY_ALGO_RSA_S:
205       npkey = 2;
206       break;
207     case PUBKEY_ALGO_ELGAMAL_E:
208     case PUBKEY_ALGO_ELGAMAL:
209       npkey = 3;
210       break;
211     case PUBKEY_ALGO_DSA:
212       npkey = 4;
213       break;
214     case PUBKEY_ALGO_ECDH:
215       npkey = 3;
216       is_ecc = 1;
217       break;
218     case PUBKEY_ALGO_ECDSA:
219     case PUBKEY_ALGO_EDDSA:
220       npkey = 2;
221       is_ecc = 1;
222       break;
223     default: /* Unknown algorithm. */
224       return gpg_error (GPG_ERR_UNKNOWN_ALGORITHM);
225     }
226
227   ki->algo = algorithm;
228
229   for (i=0; i < npkey; i++ )
230     {
231       unsigned int nbits, nbytes;
232
233       if (datalen < 2)
234         return gpg_error (GPG_ERR_INV_PACKET);
235
236       if (is_ecc && (i == 0 || i == 2))
237         {
238           nbytes = data[0];
239           if (nbytes < 2 || nbytes > 254)
240             return gpg_error (GPG_ERR_INV_PACKET);
241           nbytes++; /* The size byte itself.  */
242           if (datalen < nbytes)
243             return gpg_error (GPG_ERR_INV_PACKET);
244         }
245       else
246         {
247           nbits = ((data[0]<<8)|(data[1]));
248           data += 2;
249           datalen -= 2;
250           nbytes = (nbits+7) / 8;
251           if (datalen < nbytes)
252             return gpg_error (GPG_ERR_INV_PACKET);
253           /* For use by v3 fingerprint calculation we need to know the RSA
254              modulus and exponent. */
255           if (i==0)
256             {
257               mpi_n = data;
258               mpi_n_len = nbytes;
259             }
260           else if (i==1)
261             mpi_e_len = nbytes;
262         }
263
264       data += nbytes; datalen -= nbytes;
265     }
266   n = data - data_start;
267
268   if (version < 4)
269     {
270       /* We do not support any other algorithm than RSA in v3
271          packets. */
272       if (algorithm < 1 || algorithm > 3)
273         return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
274
275       err = gcry_md_open (&md, GCRY_MD_MD5, 0);
276       if (err)
277         return err; /* Oops */
278       gcry_md_write (md, mpi_n, mpi_n_len);
279       gcry_md_write (md, mpi_n+mpi_n_len+2, mpi_e_len);
280       memcpy (ki->fpr, gcry_md_read (md, 0), 16);
281       gcry_md_close (md);
282       ki->fprlen = 16;
283
284       if (mpi_n_len < 8)
285         {
286           /* Moduli less than 64 bit are out of the specs scope.  Zero
287              them out because this is what gpg does too. */
288           memset (ki->keyid, 0, 8);
289         }
290       else
291         memcpy (ki->keyid, mpi_n + mpi_n_len - 8, 8);
292     }
293   else
294     {
295       /* Its a pitty that we need to prefix the buffer with the tag
296          and a length header: We can't simply pass it to the fast
297          hashing function for that reason.  It might be a good idea to
298          have a scatter-gather enabled hash function. What we do here
299          is to use a static buffer if this one is large enough and
300          only use the regular hash functions if this buffer is not
301          large enough. */
302       if ( 3 + n < sizeof hashbuffer )
303         {
304           hashbuffer[0] = 0x99;     /* CTB */
305           hashbuffer[1] = (n >> 8); /* 2 byte length header. */
306           hashbuffer[2] = n;
307           memcpy (hashbuffer + 3, data_start, n);
308           gcry_md_hash_buffer (GCRY_MD_SHA1, ki->fpr, hashbuffer, 3 + n);
309         }
310       else
311         {
312           err = gcry_md_open (&md, GCRY_MD_SHA1, 0);
313           if (err)
314             return err; /* Oops */
315           gcry_md_putc (md, 0x99 );     /* CTB */
316           gcry_md_putc (md, (n >> 8) ); /* 2 byte length header. */
317           gcry_md_putc (md, n );
318           gcry_md_write (md, data_start, n);
319           memcpy (ki->fpr, gcry_md_read (md, 0), 20);
320           gcry_md_close (md);
321         }
322       ki->fprlen = 20;
323       memcpy (ki->keyid, ki->fpr+12, 8);
324     }
325
326   return 0;
327 }
328
329
330
331 /* The caller must pass the address of an INFO structure which will
332    get filled on success with information pertaining to the OpenPGP
333    keyblock IMAGE of length IMAGELEN.  Note that a caller does only
334    need to release this INFO structure if the function returns
335    success.  If NPARSED is not NULL the actual number of bytes parsed
336    will be stored at this address.  */
337 gpg_error_t
338 _keybox_parse_openpgp (const unsigned char *image, size_t imagelen,
339                        size_t *nparsed, keybox_openpgp_info_t info)
340 {
341   gpg_error_t err = 0;
342   const unsigned char *image_start, *data;
343   size_t n, datalen;
344   int pkttype;
345   int first = 1;
346   int read_error = 0;
347   struct _keybox_openpgp_key_info *k, **ktail = NULL;
348   struct _keybox_openpgp_uid_info *u, **utail = NULL;
349
350   memset (info, 0, sizeof *info);
351   if (nparsed)
352     *nparsed = 0;
353
354   image_start = image;
355   while (image)
356     {
357       err = next_packet (&image, &imagelen, &data, &datalen, &pkttype, &n);
358       if (err)
359         {
360           read_error = 1;
361           break;
362         }
363
364       if (first)
365         {
366           if (pkttype == PKT_PUBLIC_KEY)
367             ;
368           else if (pkttype == PKT_SECRET_KEY)
369             info->is_secret = 1;
370           else
371             {
372               err = gpg_error (GPG_ERR_UNEXPECTED);
373               if (nparsed)
374                 *nparsed += n;
375               break;
376             }
377           first = 0;
378         }
379       else if (pkttype == PKT_PUBLIC_KEY || pkttype == PKT_SECRET_KEY)
380         break; /* Next keyblock encountered - ready. */
381
382       if (nparsed)
383         *nparsed += n;
384
385       if (pkttype == PKT_SIGNATURE)
386         {
387           /* For now we only count the total number of signatures. */
388           info->nsigs++;
389         }
390       else if (pkttype == PKT_USER_ID)
391         {
392           info->nuids++;
393           if (info->nuids == 1)
394             {
395               info->uids.off = data - image_start;
396               info->uids.len = datalen;
397               utail = &info->uids.next;
398             }
399           else
400             {
401               u = xtrycalloc (1, sizeof *u);
402               if (!u)
403                 {
404                   err = gpg_error_from_syserror ();
405                   break;
406                 }
407               u->off = data - image_start;
408               u->len = datalen;
409               *utail = u;
410               utail = &u->next;
411             }
412         }
413       else if (pkttype == PKT_PUBLIC_KEY || pkttype == PKT_SECRET_KEY)
414         {
415           err = parse_key (data, datalen, &info->primary);
416           if (err)
417             break;
418         }
419       else if( pkttype == PKT_PUBLIC_SUBKEY && datalen && *data == '#' )
420         {
421           /* Early versions of GnuPG used old PGP comment packets;
422            * luckily all those comments are prefixed by a hash
423            * sign - ignore these packets. */
424         }
425       else if (pkttype == PKT_PUBLIC_SUBKEY || pkttype == PKT_SECRET_SUBKEY)
426         {
427           info->nsubkeys++;
428           if (info->nsubkeys == 1)
429             {
430               err = parse_key (data, datalen, &info->subkeys);
431               if (err)
432                 {
433                   info->nsubkeys--;
434                   /* We ignore subkeys with unknown algorithms. */
435                   if (gpg_err_code (err) == GPG_ERR_UNKNOWN_ALGORITHM
436                       || gpg_err_code (err) == GPG_ERR_UNSUPPORTED_ALGORITHM)
437                     err = 0;
438                   if (err)
439                     break;
440                 }
441               else
442                 ktail = &info->subkeys.next;
443             }
444           else
445             {
446               k = xtrycalloc (1, sizeof *k);
447               if (!k)
448                 {
449                   err = gpg_error_from_syserror ();
450                   break;
451                 }
452               err = parse_key (data, datalen, k);
453               if (err)
454                 {
455                   xfree (k);
456                   info->nsubkeys--;
457                   /* We ignore subkeys with unknown algorithms. */
458                   if (gpg_err_code (err) == GPG_ERR_UNKNOWN_ALGORITHM
459                       || gpg_err_code (err) == GPG_ERR_UNSUPPORTED_ALGORITHM)
460                     err = 0;
461                   if (err)
462                     break;
463                 }
464               else
465                 {
466                   *ktail = k;
467                   ktail = &k->next;
468                 }
469             }
470         }
471     }
472
473   if (err)
474     {
475       _keybox_destroy_openpgp_info (info);
476       if (!read_error)
477         {
478           /* Packet parsing worked, thus we should be able to skip the
479              rest of the keyblock.  */
480           while (image)
481             {
482               if (next_packet (&image, &imagelen,
483                                &data, &datalen, &pkttype, &n) )
484                 break; /* Another error - stop here. */
485
486               if (pkttype == PKT_PUBLIC_KEY || pkttype == PKT_SECRET_KEY)
487                 break; /* Next keyblock encountered - ready. */
488
489               if (nparsed)
490                 *nparsed += n;
491             }
492         }
493     }
494
495   return err;
496 }
497
498
499 /* Release any malloced data in INFO but not INFO itself! */
500 void
501 _keybox_destroy_openpgp_info (keybox_openpgp_info_t info)
502 {
503   struct _keybox_openpgp_key_info *k, *k2;
504   struct _keybox_openpgp_uid_info *u, *u2;
505
506   assert (!info->primary.next);
507   for (k=info->subkeys.next; k; k = k2)
508     {
509       k2 = k->next;
510       xfree (k);
511     }
512
513   for (u=info->uids.next; u; u = u2)
514     {
515       u2 = u->next;
516       xfree (u);
517     }
518 }