fix up 6562de7475b21cd03c7b1a83a591fa563c589f5b
[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 <https://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 #include "../common/host2net.h"
40
41 struct keyparm_s
42 {
43   const char *mpi;
44   int len;   /* int to avoid a cast in gcry_sexp_build.  */
45 };
46
47
48 /* Assume a valid OpenPGP packet at the address pointed to by BUFBTR
49    which has a maximum length as stored at BUFLEN.  Return the header
50    information of that packet and advance the pointer stored at BUFPTR
51    to the next packet; also adjust the length stored at BUFLEN to
52    match the remaining bytes. If there are no more packets, store NULL
53    at BUFPTR.  Return an non-zero error code on failure or the
54    following data on success:
55
56    R_DATAPKT = Pointer to the begin of the packet data.
57    R_DATALEN = Length of this data.  This has already been checked to fit
58                into the buffer.
59    R_PKTTYPE = The packet type.
60    R_NTOTAL  = The total number of bytes of this packet
61
62    Note that these values are only updated on success.
63 */
64 static gpg_error_t
65 next_packet (unsigned char const **bufptr, size_t *buflen,
66              unsigned char const **r_data, size_t *r_datalen, int *r_pkttype,
67              size_t *r_ntotal)
68 {
69   const unsigned char *buf = *bufptr;
70   size_t len = *buflen;
71   int c, ctb, pkttype;
72   unsigned long pktlen;
73
74   if (!len)
75     return gpg_error (GPG_ERR_NO_DATA);
76
77   ctb = *buf++; len--;
78   if ( !(ctb & 0x80) )
79     return gpg_error (GPG_ERR_INV_PACKET); /* Invalid CTB. */
80
81   if ((ctb & 0x40))  /* New style (OpenPGP) CTB.  */
82     {
83       pkttype = (ctb & 0x3f);
84       if (!len)
85         return gpg_error (GPG_ERR_INV_PACKET); /* No 1st length byte. */
86       c = *buf++; len--;
87       if (pkttype == PKT_COMPRESSED)
88         return gpg_error (GPG_ERR_UNEXPECTED); /* ... packet in a keyblock. */
89       if ( c < 192 )
90         pktlen = c;
91       else if ( c < 224 )
92         {
93           pktlen = (c - 192) * 256;
94           if (!len)
95             return gpg_error (GPG_ERR_INV_PACKET); /* No 2nd length byte. */
96           c = *buf++; len--;
97           pktlen += c + 192;
98         }
99       else if (c == 255)
100         {
101           if (len <4 )
102             return gpg_error (GPG_ERR_INV_PACKET); /* No length bytes. */
103           pktlen = buf32_to_ulong (buf);
104           buf += 4;
105           len -= 4;
106       }
107       else /* Partial length encoding is not allowed for key packets. */
108         return gpg_error (GPG_ERR_UNEXPECTED);
109     }
110   else /* Old style CTB.  */
111     {
112       int lenbytes;
113
114       pktlen = 0;
115       pkttype = (ctb>>2)&0xf;
116       lenbytes = ((ctb&3)==3)? 0 : (1<<(ctb & 3));
117       if (!lenbytes) /* Not allowed in key packets.  */
118         return gpg_error (GPG_ERR_UNEXPECTED);
119       if (len < lenbytes)
120         return gpg_error (GPG_ERR_INV_PACKET); /* Not enough length bytes.  */
121       for (; lenbytes; lenbytes--)
122         {
123           pktlen <<= 8;
124           pktlen |= *buf++; len--;
125         }
126     }
127
128   /* Do some basic sanity check.  */
129   switch (pkttype)
130     {
131     case PKT_SIGNATURE:
132     case PKT_SECRET_KEY:
133     case PKT_PUBLIC_KEY:
134     case PKT_SECRET_SUBKEY:
135     case PKT_MARKER:
136     case PKT_RING_TRUST:
137     case PKT_USER_ID:
138     case PKT_PUBLIC_SUBKEY:
139     case PKT_OLD_COMMENT:
140     case PKT_ATTRIBUTE:
141     case PKT_COMMENT:
142     case PKT_GPG_CONTROL:
143       break; /* Okay these are allowed packets. */
144     default:
145       return gpg_error (GPG_ERR_UNEXPECTED);
146     }
147
148   if (pkttype == 63 && pktlen == 0xFFFFFFFF)
149     /* Sometimes the decompressing layer enters an error state in
150        which it simply outputs 0xff for every byte read.  If we have a
151        stream of 0xff bytes, then it will be detected as a new format
152        packet with type 63 and a 4-byte encoded length that is 4G-1.
153        Since packets with type 63 are private and we use them as a
154        control packet, which won't be 4 GB, we reject such packets as
155        invalid.  */
156     return gpg_error (GPG_ERR_INV_PACKET);
157
158   if (pktlen > len)
159     return gpg_error (GPG_ERR_INV_PACKET); /* Packet length header too long. */
160
161   *r_data = buf;
162   *r_datalen = pktlen;
163   *r_pkttype = pkttype;
164   *r_ntotal = (buf - *bufptr) + pktlen;
165
166   *bufptr = buf + pktlen;
167   *buflen = len - pktlen;
168   if (!*buflen)
169     *bufptr = NULL;
170
171   return 0;
172 }
173
174
175 /* Take a list of key parameters KP for the OpenPGP ALGO and compute
176  * the keygrip which will be stored at GRIP.  GRIP needs to be a
177  * buffer of 20 bytes.  */
178 static gpg_error_t
179 keygrip_from_keyparm (int algo, struct keyparm_s *kp, unsigned char *grip)
180 {
181   gpg_error_t err;
182   gcry_sexp_t s_pkey = NULL;
183
184   switch (algo)
185     {
186     case PUBKEY_ALGO_DSA:
187       err = gcry_sexp_build (&s_pkey, NULL,
188                              "(public-key(dsa(p%b)(q%b)(g%b)(y%b)))",
189                              kp[0].len, kp[0].mpi,
190                              kp[1].len, kp[1].mpi,
191                              kp[2].len, kp[2].mpi,
192                              kp[3].len, kp[3].mpi);
193       break;
194
195     case PUBKEY_ALGO_ELGAMAL:
196     case PUBKEY_ALGO_ELGAMAL_E:
197       err = gcry_sexp_build (&s_pkey, NULL,
198                              "(public-key(elg(p%b)(g%b)(y%b)))",
199                              kp[0].len, kp[0].mpi,
200                              kp[1].len, kp[1].mpi,
201                              kp[2].len, kp[2].mpi);
202       break;
203
204     case PUBKEY_ALGO_RSA:
205     case PUBKEY_ALGO_RSA_S:
206     case PUBKEY_ALGO_RSA_E:
207       err = gcry_sexp_build (&s_pkey, NULL,
208                              "(public-key(rsa(n%b)(e%b)))",
209                              kp[0].len, kp[0].mpi,
210                              kp[1].len, kp[1].mpi);
211       break;
212
213     case PUBKEY_ALGO_EDDSA:
214     case PUBKEY_ALGO_ECDSA:
215     case PUBKEY_ALGO_ECDH:
216       {
217         char *curve = openpgp_oidbuf_to_str (kp[0].mpi, kp[0].len);
218         if (!curve)
219           err = gpg_error_from_syserror ();
220         else
221           {
222             err = gcry_sexp_build
223               (&s_pkey, NULL,
224                (algo == PUBKEY_ALGO_EDDSA)?
225                "(public-key(ecc(curve%s)(flags eddsa)(q%b)))":
226                (algo == PUBKEY_ALGO_ECDH
227                 && openpgp_oidbuf_is_cv25519 (kp[0].mpi, kp[0].len))?
228                "(public-key(ecc(curve%s)(flags djb-tweak)(q%b)))":
229                "(public-key(ecc(curve%s)(q%b)))",
230                curve, kp[1].len, kp[1].mpi);
231             xfree (curve);
232           }
233       }
234       break;
235
236     default:
237       err = gpg_error (GPG_ERR_PUBKEY_ALGO);
238       break;
239     }
240
241   if (!err && !gcry_pk_get_keygrip (s_pkey, grip))
242     {
243       log_info ("kbx: error computing keygrip\n");
244       err = gpg_error (GPG_ERR_GENERAL);
245     }
246
247   gcry_sexp_release (s_pkey);
248
249   if (err)
250     memset (grip, 0, 20);
251   return err;
252 }
253
254
255 /* Parse a key packet and store the information in KI. */
256 static gpg_error_t
257 parse_key (const unsigned char *data, size_t datalen,
258            struct _keybox_openpgp_key_info *ki)
259 {
260   gpg_error_t err;
261   const unsigned char *data_start = data;
262   int i, version, algorithm;
263   size_t n;
264   int npkey;
265   unsigned char hashbuffer[768];
266   gcry_md_hd_t md;
267   int is_ecc = 0;
268   int is_v5;
269   /* unsigned int pkbytes;  for v5: # of octets of the public key params.  */
270   struct keyparm_s keyparm[OPENPGP_MAX_NPKEY];
271   unsigned char *helpmpibuf[OPENPGP_MAX_NPKEY] = { NULL };
272
273   if (datalen < 5)
274     return gpg_error (GPG_ERR_INV_PACKET);
275   version = *data++; datalen--;
276   if (version < 2 || version > 5 )
277     return gpg_error (GPG_ERR_INV_PACKET); /* Invalid version. */
278   is_v5 = version == 5;
279
280   /*timestamp = ((data[0]<<24)|(data[1]<<16)|(data[2]<<8)|(data[3]));*/
281   data +=4; datalen -=4;
282
283   if (version < 4)
284     {
285       if (datalen < 2)
286         return gpg_error (GPG_ERR_INV_PACKET);
287       data +=2; datalen -= 2;
288     }
289
290   if (!datalen)
291     return gpg_error (GPG_ERR_INV_PACKET);
292   algorithm = *data++; datalen--;
293
294   if (is_v5)
295     {
296       if (datalen < 4)
297         return gpg_error (GPG_ERR_INV_PACKET);
298       /* pkbytes = buf32_to_uint (data); */
299       data += 4;
300       datalen -= 4;
301     }
302
303   switch (algorithm)
304     {
305     case PUBKEY_ALGO_RSA:
306     case PUBKEY_ALGO_RSA_E:
307     case PUBKEY_ALGO_RSA_S:
308       npkey = 2;
309       break;
310     case PUBKEY_ALGO_ELGAMAL_E:
311     case PUBKEY_ALGO_ELGAMAL:
312       npkey = 3;
313       break;
314     case PUBKEY_ALGO_DSA:
315       npkey = 4;
316       break;
317     case PUBKEY_ALGO_ECDH:
318       npkey = 3;
319       is_ecc = 1;
320       break;
321     case PUBKEY_ALGO_ECDSA:
322     case PUBKEY_ALGO_EDDSA:
323       npkey = 2;
324       is_ecc = 1;
325       break;
326     default: /* Unknown algorithm. */
327       return gpg_error (GPG_ERR_UNKNOWN_ALGORITHM);
328     }
329
330   ki->version = version;
331   ki->algo = algorithm;
332
333   for (i=0; i < npkey; i++ )
334     {
335       unsigned int nbits, nbytes;
336
337       if (datalen < 2)
338         return gpg_error (GPG_ERR_INV_PACKET);
339
340       if (is_ecc && (i == 0 || i == 2))
341         {
342           nbytes = data[0];
343           if (nbytes < 2 || nbytes > 254)
344             return gpg_error (GPG_ERR_INV_PACKET);
345           nbytes++; /* The size byte itself.  */
346           if (datalen < nbytes)
347             return gpg_error (GPG_ERR_INV_PACKET);
348
349           keyparm[i].mpi = data;
350           keyparm[i].len = nbytes;
351         }
352       else
353         {
354           nbits = ((data[0]<<8)|(data[1]));
355           data += 2;
356           datalen -= 2;
357           nbytes = (nbits+7) / 8;
358           if (datalen < nbytes)
359             return gpg_error (GPG_ERR_INV_PACKET);
360
361           keyparm[i].mpi = data;
362           keyparm[i].len = nbytes;
363         }
364
365       data += nbytes; datalen -= nbytes;
366     }
367   n = data - data_start;
368
369
370   /* Note: Starting here we need to jump to leave on error. */
371
372   /* Make sure the MPIs are unsigned.  */
373   for (i=0; i < npkey; i++)
374     {
375       if (!keyparm[i].len || (keyparm[i].mpi[0] & 0x80))
376         {
377           helpmpibuf[i] = xtrymalloc (1+keyparm[i].len);
378           if (!helpmpibuf[i])
379             {
380               err = gpg_error_from_syserror ();
381               goto leave;
382             }
383           helpmpibuf[i][0] = 0;
384           memcpy (helpmpibuf[i]+1, keyparm[i].mpi, keyparm[i].len);
385           keyparm[i].mpi = helpmpibuf[i];
386           keyparm[i].len++;
387         }
388     }
389
390   err = keygrip_from_keyparm (algorithm, keyparm, ki->grip);
391   if (err)
392     goto leave;
393
394   if (version < 4)
395     {
396       /* We do not support any other algorithm than RSA in v3
397          packets. */
398       if (algorithm < 1 || algorithm > 3)
399         return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
400
401       err = gcry_md_open (&md, GCRY_MD_MD5, 0);
402       if (err)
403         return err; /* Oops */
404       gcry_md_write (md, keyparm[0].mpi, keyparm[0].len);
405       gcry_md_write (md, keyparm[1].mpi, keyparm[1].len);
406       memcpy (ki->fpr, gcry_md_read (md, 0), 16);
407       gcry_md_close (md);
408       ki->fprlen = 16;
409
410       if (keyparm[0].len < 8)
411         {
412           /* Moduli less than 64 bit are out of the specs scope.  Zero
413              them out because this is what gpg does too. */
414           memset (ki->keyid, 0, 8);
415         }
416       else
417         memcpy (ki->keyid, keyparm[0].mpi + keyparm[0].len - 8, 8);
418     }
419   else
420     {
421       /* Its a pity that we need to prefix the buffer with the tag
422          and a length header: We can't simply pass it to the fast
423          hashing function for that reason.  It might be a good idea to
424          have a scatter-gather enabled hash function. What we do here
425          is to use a static buffer if this one is large enough and
426          only use the regular hash functions if this buffer is not
427          large enough.
428          FIXME: Factor this out to a shared fingerprint function.
429        */
430       if (version == 5)
431         {
432           if ( 5 + n < sizeof hashbuffer )
433             {
434               hashbuffer[0] = 0x9a;     /* CTB */
435               hashbuffer[1] = (n >> 24);/* 4 byte length header. */
436               hashbuffer[2] = (n >> 16);
437               hashbuffer[3] = (n >>  8);
438               hashbuffer[4] = (n      );
439               memcpy (hashbuffer + 5, data_start, n);
440               gcry_md_hash_buffer (GCRY_MD_SHA256, ki->fpr, hashbuffer, 5 + n);
441             }
442           else
443             {
444               err = gcry_md_open (&md, GCRY_MD_SHA256, 0);
445               if (err)
446                 return err; /* Oops */
447               gcry_md_putc (md, 0x9a );     /* CTB */
448               gcry_md_putc (md, (n >> 24)); /* 4 byte length header. */
449               gcry_md_putc (md, (n >> 16));
450               gcry_md_putc (md, (n >>  8));
451               gcry_md_putc (md, (n      ));
452               gcry_md_write (md, data_start, n);
453               memcpy (ki->fpr, gcry_md_read (md, 0), 32);
454               gcry_md_close (md);
455             }
456           ki->fprlen = 32;
457           memcpy (ki->keyid, ki->fpr, 8);
458         }
459       else
460         {
461           if ( 3 + n < sizeof hashbuffer )
462             {
463               hashbuffer[0] = 0x99;     /* CTB */
464               hashbuffer[1] = (n >> 8); /* 2 byte length header. */
465               hashbuffer[2] = (n     );
466               memcpy (hashbuffer + 3, data_start, n);
467               gcry_md_hash_buffer (GCRY_MD_SHA1, ki->fpr, hashbuffer, 3 + n);
468             }
469           else
470             {
471               err = gcry_md_open (&md, GCRY_MD_SHA1, 0);
472               if (err)
473                 return err; /* Oops */
474               gcry_md_putc (md, 0x99 );     /* CTB */
475               gcry_md_putc (md, (n >> 8));  /* 2 byte length header. */
476               gcry_md_putc (md, (n     ));
477               gcry_md_write (md, data_start, n);
478               memcpy (ki->fpr, gcry_md_read (md, 0), 20);
479               gcry_md_close (md);
480             }
481           ki->fprlen = 20;
482           memcpy (ki->keyid, ki->fpr+12, 8);
483         }
484     }
485
486  leave:
487   for (i=0; i < npkey; i++)
488     xfree (helpmpibuf[i]);
489
490   return err;
491 }
492
493
494
495 /* The caller must pass the address of an INFO structure which will
496    get filled on success with information pertaining to the OpenPGP
497    keyblock IMAGE of length IMAGELEN.  Note that a caller does only
498    need to release this INFO structure if the function returns
499    success.  If NPARSED is not NULL the actual number of bytes parsed
500    will be stored at this address.  */
501 gpg_error_t
502 _keybox_parse_openpgp (const unsigned char *image, size_t imagelen,
503                        size_t *nparsed, keybox_openpgp_info_t info)
504 {
505   gpg_error_t err = 0;
506   const unsigned char *image_start, *data;
507   size_t n, datalen;
508   int pkttype;
509   int first = 1;
510   int read_error = 0;
511   struct _keybox_openpgp_key_info *k, **ktail = NULL;
512   struct _keybox_openpgp_uid_info *u, **utail = NULL;
513
514   memset (info, 0, sizeof *info);
515   if (nparsed)
516     *nparsed = 0;
517
518   image_start = image;
519   while (image)
520     {
521       err = next_packet (&image, &imagelen, &data, &datalen, &pkttype, &n);
522       if (err)
523         {
524           read_error = 1;
525           break;
526         }
527
528       if (first)
529         {
530           if (pkttype == PKT_PUBLIC_KEY)
531             ;
532           else if (pkttype == PKT_SECRET_KEY)
533             info->is_secret = 1;
534           else
535             {
536               err = gpg_error (GPG_ERR_UNEXPECTED);
537               if (nparsed)
538                 *nparsed += n;
539               break;
540             }
541           first = 0;
542         }
543       else if (pkttype == PKT_PUBLIC_KEY || pkttype == PKT_SECRET_KEY)
544         break; /* Next keyblock encountered - ready. */
545
546       if (nparsed)
547         *nparsed += n;
548
549       if (pkttype == PKT_SIGNATURE)
550         {
551           /* For now we only count the total number of signatures. */
552           info->nsigs++;
553         }
554       else if (pkttype == PKT_USER_ID)
555         {
556           info->nuids++;
557           if (info->nuids == 1)
558             {
559               info->uids.off = data - image_start;
560               info->uids.len = datalen;
561               utail = &info->uids.next;
562             }
563           else
564             {
565               u = xtrycalloc (1, sizeof *u);
566               if (!u)
567                 {
568                   err = gpg_error_from_syserror ();
569                   break;
570                 }
571               u->off = data - image_start;
572               u->len = datalen;
573               *utail = u;
574               utail = &u->next;
575             }
576         }
577       else if (pkttype == PKT_PUBLIC_KEY || pkttype == PKT_SECRET_KEY)
578         {
579           err = parse_key (data, datalen, &info->primary);
580           if (err)
581             break;
582         }
583       else if( pkttype == PKT_PUBLIC_SUBKEY && datalen && *data == '#' )
584         {
585           /* Early versions of GnuPG used old PGP comment packets;
586            * luckily all those comments are prefixed by a hash
587            * sign - ignore these packets. */
588         }
589       else if (pkttype == PKT_PUBLIC_SUBKEY || pkttype == PKT_SECRET_SUBKEY)
590         {
591           info->nsubkeys++;
592           if (info->nsubkeys == 1)
593             {
594               err = parse_key (data, datalen, &info->subkeys);
595               if (err)
596                 {
597                   info->nsubkeys--;
598                   /* We ignore subkeys with unknown algorithms. */
599                   if (gpg_err_code (err) == GPG_ERR_UNKNOWN_ALGORITHM
600                       || gpg_err_code (err) == GPG_ERR_UNSUPPORTED_ALGORITHM)
601                     err = 0;
602                   if (err)
603                     break;
604                 }
605               else
606                 ktail = &info->subkeys.next;
607             }
608           else
609             {
610               k = xtrycalloc (1, sizeof *k);
611               if (!k)
612                 {
613                   err = gpg_error_from_syserror ();
614                   break;
615                 }
616               err = parse_key (data, datalen, k);
617               if (err)
618                 {
619                   xfree (k);
620                   info->nsubkeys--;
621                   /* We ignore subkeys with unknown algorithms. */
622                   if (gpg_err_code (err) == GPG_ERR_UNKNOWN_ALGORITHM
623                       || gpg_err_code (err) == GPG_ERR_UNSUPPORTED_ALGORITHM)
624                     err = 0;
625                   if (err)
626                     break;
627                 }
628               else
629                 {
630                   *ktail = k;
631                   ktail = &k->next;
632                 }
633             }
634         }
635     }
636
637   if (err)
638     {
639       _keybox_destroy_openpgp_info (info);
640       if (!read_error)
641         {
642           /* Packet parsing worked, thus we should be able to skip the
643              rest of the keyblock.  */
644           while (image)
645             {
646               if (next_packet (&image, &imagelen,
647                                &data, &datalen, &pkttype, &n) )
648                 break; /* Another error - stop here. */
649
650               if (pkttype == PKT_PUBLIC_KEY || pkttype == PKT_SECRET_KEY)
651                 break; /* Next keyblock encountered - ready. */
652
653               if (nparsed)
654                 *nparsed += n;
655             }
656         }
657     }
658
659   return err;
660 }
661
662
663 /* Release any malloced data in INFO but not INFO itself! */
664 void
665 _keybox_destroy_openpgp_info (keybox_openpgp_info_t info)
666 {
667   struct _keybox_openpgp_key_info *k, *k2;
668   struct _keybox_openpgp_uid_info *u, *u2;
669
670   assert (!info->primary.next);
671   for (k=info->subkeys.next; k; k = k2)
672     {
673       k2 = k->next;
674       xfree (k);
675     }
676
677   for (u=info->uids.next; u; u = u2)
678     {
679       u2 = u->next;
680       xfree (u);
681     }
682 }