kbx: Update blob specification
[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 1:
203     case 2:
204     case 3: /* RSA */
205       npkey = 2;
206       break;
207     case 16:
208     case 20: /* Elgamal */
209       npkey = 3;
210       break;
211     case 17: /* DSA */
212       npkey = 4;
213       break;
214     case 18: /* ECDH */
215       npkey = 3;
216       is_ecc = 1;
217       break;
218     case 19: /* ECDSA */
219       npkey = 2;
220       is_ecc = 1;
221       break;
222     default: /* Unknown algorithm. */
223       return gpg_error (GPG_ERR_UNKNOWN_ALGORITHM);
224     }
225
226   ki->algo = algorithm;
227
228   for (i=0; i < npkey; i++ )
229     {
230       unsigned int nbits, nbytes;
231
232       if (datalen < 2)
233         return gpg_error (GPG_ERR_INV_PACKET);
234
235       if (is_ecc && (i == 0 || i == 2))
236         {
237           nbytes = data[0];
238           if (nbytes < 2 || nbytes > 254)
239             return gpg_error (GPG_ERR_INV_PACKET);
240           nbytes++; /* The size byte itself.  */
241           if (datalen < nbytes)
242             return gpg_error (GPG_ERR_INV_PACKET);
243         }
244       else
245         {
246           nbits = ((data[0]<<8)|(data[1]));
247           data += 2;
248           datalen -= 2;
249           nbytes = (nbits+7) / 8;
250           if (datalen < nbytes)
251             return gpg_error (GPG_ERR_INV_PACKET);
252           /* For use by v3 fingerprint calculation we need to know the RSA
253              modulus and exponent. */
254           if (i==0)
255             {
256               mpi_n = data;
257               mpi_n_len = nbytes;
258             }
259           else if (i==1)
260             mpi_e_len = nbytes;
261         }
262
263       data += nbytes; datalen -= nbytes;
264     }
265   n = data - data_start;
266
267   if (version < 4)
268     {
269       /* We do not support any other algorithm than RSA in v3
270          packets. */
271       if (algorithm < 1 || algorithm > 3)
272         return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
273
274       err = gcry_md_open (&md, GCRY_MD_MD5, 0);
275       if (err)
276         return err; /* Oops */
277       gcry_md_write (md, mpi_n, mpi_n_len);
278       gcry_md_write (md, mpi_n+mpi_n_len+2, mpi_e_len);
279       memcpy (ki->fpr, gcry_md_read (md, 0), 16);
280       gcry_md_close (md);
281       ki->fprlen = 16;
282
283       if (mpi_n_len < 8)
284         {
285           /* Moduli less than 64 bit are out of the specs scope.  Zero
286              them out because this is what gpg does too. */
287           memset (ki->keyid, 0, 8);
288         }
289       else
290         memcpy (ki->keyid, mpi_n + mpi_n_len - 8, 8);
291     }
292   else
293     {
294       /* Its a pitty that we need to prefix the buffer with the tag
295          and a length header: We can't simply pass it to the fast
296          hashing function for that reason.  It might be a good idea to
297          have a scatter-gather enabled hash function. What we do here
298          is to use a static buffer if this one is large enough and
299          only use the regular hash functions if this buffer is not
300          large enough. */
301       if ( 3 + n < sizeof hashbuffer )
302         {
303           hashbuffer[0] = 0x99;     /* CTB */
304           hashbuffer[1] = (n >> 8); /* 2 byte length header. */
305           hashbuffer[2] = n;
306           memcpy (hashbuffer + 3, data_start, n);
307           gcry_md_hash_buffer (GCRY_MD_SHA1, ki->fpr, hashbuffer, 3 + n);
308         }
309       else
310         {
311           err = gcry_md_open (&md, GCRY_MD_SHA1, 0);
312           if (err)
313             return err; /* Oops */
314           gcry_md_putc (md, 0x99 );     /* CTB */
315           gcry_md_putc (md, (n >> 8) ); /* 2 byte length header. */
316           gcry_md_putc (md, n );
317           gcry_md_write (md, data_start, n);
318           memcpy (ki->fpr, gcry_md_read (md, 0), 20);
319           gcry_md_close (md);
320         }
321       ki->fprlen = 20;
322       memcpy (ki->keyid, ki->fpr+12, 8);
323     }
324
325   return 0;
326 }
327
328
329
330 /* The caller must pass the address of an INFO structure which will
331    get filled on success with information pertaining to the OpenPGP
332    keyblock IMAGE of length IMAGELEN.  Note that a caller does only
333    need to release this INFO structure if the function returns
334    success.  If NPARSED is not NULL the actual number of bytes parsed
335    will be stored at this address.  */
336 gpg_error_t
337 _keybox_parse_openpgp (const unsigned char *image, size_t imagelen,
338                        size_t *nparsed, keybox_openpgp_info_t info)
339 {
340   gpg_error_t err = 0;
341   const unsigned char *image_start, *data;
342   size_t n, datalen;
343   int pkttype;
344   int first = 1;
345   int read_error = 0;
346   struct _keybox_openpgp_key_info *k, **ktail = NULL;
347   struct _keybox_openpgp_uid_info *u, **utail = NULL;
348
349   memset (info, 0, sizeof *info);
350   if (nparsed)
351     *nparsed = 0;
352
353   image_start = image;
354   while (image)
355     {
356       err = next_packet (&image, &imagelen, &data, &datalen, &pkttype, &n);
357       if (err)
358         {
359           read_error = 1;
360           break;
361         }
362
363       if (first)
364         {
365           if (pkttype == PKT_PUBLIC_KEY)
366             ;
367           else if (pkttype == PKT_SECRET_KEY)
368             info->is_secret = 1;
369           else
370             {
371               err = gpg_error (GPG_ERR_UNEXPECTED);
372               if (nparsed)
373                 *nparsed += n;
374               break;
375             }
376           first = 0;
377         }
378       else if (pkttype == PKT_PUBLIC_KEY || pkttype == PKT_SECRET_KEY)
379         break; /* Next keyblock encountered - ready. */
380
381       if (nparsed)
382         *nparsed += n;
383
384       if (pkttype == PKT_SIGNATURE)
385         {
386           /* For now we only count the total number of signatures. */
387           info->nsigs++;
388         }
389       else if (pkttype == PKT_USER_ID)
390         {
391           info->nuids++;
392           if (info->nuids == 1)
393             {
394               info->uids.off = data - image_start;
395               info->uids.len = datalen;
396               utail = &info->uids.next;
397             }
398           else
399             {
400               u = xtrycalloc (1, sizeof *u);
401               if (!u)
402                 {
403                   err = gpg_error_from_syserror ();
404                   break;
405                 }
406               u->off = data - image_start;
407               u->len = datalen;
408               *utail = u;
409               utail = &u->next;
410             }
411         }
412       else if (pkttype == PKT_PUBLIC_KEY || pkttype == PKT_SECRET_KEY)
413         {
414           err = parse_key (data, datalen, &info->primary);
415           if (err)
416             break;
417         }
418       else if( pkttype == PKT_PUBLIC_SUBKEY && datalen && *data == '#' )
419         {
420           /* Early versions of GnuPG used old PGP comment packets;
421            * luckily all those comments are prefixed by a hash
422            * sign - ignore these packets. */
423         }
424       else if (pkttype == PKT_PUBLIC_SUBKEY || pkttype == PKT_SECRET_SUBKEY)
425         {
426           info->nsubkeys++;
427           if (info->nsubkeys == 1)
428             {
429               err = parse_key (data, datalen, &info->subkeys);
430               if (err)
431                 {
432                   info->nsubkeys--;
433                   /* We ignore subkeys with unknown algorithms. */
434                   if (gpg_err_code (err) == GPG_ERR_UNKNOWN_ALGORITHM
435                       || gpg_err_code (err) == GPG_ERR_UNSUPPORTED_ALGORITHM)
436                     err = 0;
437                   if (err)
438                     break;
439                 }
440               else
441                 ktail = &info->subkeys.next;
442             }
443           else
444             {
445               k = xtrycalloc (1, sizeof *k);
446               if (!k)
447                 {
448                   err = gpg_error_from_syserror ();
449                   break;
450                 }
451               err = parse_key (data, datalen, k);
452               if (err)
453                 {
454                   xfree (k);
455                   info->nsubkeys--;
456                   /* We ignore subkeys with unknown algorithms. */
457                   if (gpg_err_code (err) == GPG_ERR_UNKNOWN_ALGORITHM
458                       || gpg_err_code (err) == GPG_ERR_UNSUPPORTED_ALGORITHM)
459                     err = 0;
460                   if (err)
461                     break;
462                 }
463               else
464                 {
465                   *ktail = k;
466                   ktail = &k->next;
467                 }
468             }
469         }
470     }
471
472   if (err)
473     {
474       _keybox_destroy_openpgp_info (info);
475       if (!read_error)
476         {
477           /* Packet parsing worked, thus we should be able to skip the
478              rest of the keyblock.  */
479           while (image)
480             {
481               if (next_packet (&image, &imagelen,
482                                &data, &datalen, &pkttype, &n) )
483                 break; /* Another error - stop here. */
484
485               if (pkttype == PKT_PUBLIC_KEY || pkttype == PKT_SECRET_KEY)
486                 break; /* Next keyblock encountered - ready. */
487
488               if (nparsed)
489                 *nparsed += n;
490             }
491         }
492     }
493
494   return err;
495 }
496
497
498 /* Release any malloced data in INFO but not INFO itself! */
499 void
500 _keybox_destroy_openpgp_info (keybox_openpgp_info_t info)
501 {
502   struct _keybox_openpgp_key_info *k, *k2;
503   struct _keybox_openpgp_uid_info *u, *u2;
504
505   assert (!info->primary.next);
506   for (k=info->subkeys.next; k; k = k2)
507     {
508       k2 = k->next;
509       xfree (k);
510     }
511
512   for (u=info->uids.next; u; u = u2)
513     {
514       u2 = u->next;
515       xfree (u);
516     }
517 }