scd: Clean up unused shutdown method.
[gnupg.git] / kbx / keybox-openpgp.c
1 /* keybox-openpgp.c - OpenPGP key parsing
2  *      Copyright (C) 2001, 2003 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 #include "../include/host2net.h"
38
39
40 enum packet_types
41   {
42     PKT_NONE               =0,
43     PKT_PUBKEY_ENC         =1, /* public key encrypted packet */
44     PKT_SIGNATURE          =2, /* secret key encrypted packet */
45     PKT_SYMKEY_ENC         =3, /* session key packet (OpenPGP)*/
46     PKT_ONEPASS_SIG        =4, /* one pass sig packet (OpenPGP)*/
47     PKT_SECRET_KEY         =5, /* secret key */
48     PKT_PUBLIC_KEY         =6, /* public key */
49     PKT_SECRET_SUBKEY      =7, /* secret subkey (OpenPGP) */
50     PKT_COMPRESSED         =8, /* compressed data packet */
51     PKT_ENCRYPTED          =9, /* conventional encrypted data */
52     PKT_MARKER            =10, /* marker packet (OpenPGP) */
53     PKT_PLAINTEXT         =11, /* plaintext data with filename and mode */
54     PKT_RING_TRUST        =12, /* keyring trust packet */
55     PKT_USER_ID           =13, /* user id packet */
56     PKT_PUBLIC_SUBKEY     =14, /* public subkey (OpenPGP) */
57     PKT_OLD_COMMENT       =16, /* comment packet from an OpenPGP draft */
58     PKT_ATTRIBUTE         =17, /* PGP's attribute packet */
59     PKT_ENCRYPTED_MDC     =18, /* integrity protected encrypted data */
60     PKT_MDC               =19, /* manipulation detection code packet */
61     PKT_COMMENT           =61, /* new comment packet (private) */
62     PKT_GPG_CONTROL       =63  /* internal control packet */
63   };
64
65
66
67 /* Assume a valid OpenPGP packet at the address pointed to by BUFBTR
68    which is of amaximum length as stored at BUFLEN.  Return the header
69    information of that packet and advance the pointer stored at BUFPTR
70    to the next packet; also adjust the length stored at BUFLEN to
71    match the remaining bytes. If there are no more packets, store NULL
72    at BUFPTR.  Return an non-zero error code on failure or the
73    follwing data on success:
74
75    R_DATAPKT = Pointer to the begin of the packet data.
76    R_DATALEN = Length of this data.  This has already been checked to fit
77                into the buffer.
78    R_PKTTYPE = The packet type.
79    R_NTOTAL  = The total number of bytes of this packet
80
81    Note that these values are only updated on success.
82 */
83 static gpg_error_t
84 next_packet (unsigned char const **bufptr, size_t *buflen,
85              unsigned char const **r_data, size_t *r_datalen, int *r_pkttype,
86              size_t *r_ntotal)
87 {
88   const unsigned char *buf = *bufptr;
89   size_t len = *buflen;
90   int c, ctb, pkttype;
91   unsigned long pktlen;
92
93   if (!len)
94     return gpg_error (GPG_ERR_NO_DATA);
95
96   ctb = *buf++; len--;
97   if ( !(ctb & 0x80) )
98     return gpg_error (GPG_ERR_INV_PACKET); /* Invalid CTB. */
99
100   pktlen = 0;
101   if ((ctb & 0x40))  /* New style (OpenPGP) CTB.  */
102     {
103       pkttype = (ctb & 0x3f);
104       if (!len)
105         return gpg_error (GPG_ERR_INV_PACKET); /* No 1st length byte. */
106       c = *buf++; len--;
107       if (pkttype == PKT_COMPRESSED)
108         return gpg_error (GPG_ERR_UNEXPECTED); /* ... packet in a keyblock. */
109       if ( c < 192 )
110         pktlen = c;
111       else if ( c < 224 )
112         {
113           pktlen = (c - 192) * 256;
114           if (!len)
115             return gpg_error (GPG_ERR_INV_PACKET); /* No 2nd length byte. */
116           c = *buf++; len--;
117           pktlen += c + 192;
118         }
119       else if (c == 255)
120         {
121           if (len <4 )
122             return gpg_error (GPG_ERR_INV_PACKET); /* No length bytes. */
123           pktlen = buf32_to_ulong (buf);
124           buf += 4;
125           len -= 4;
126       }
127       else /* Partial length encoding is not allowed for key packets. */
128         return gpg_error (GPG_ERR_UNEXPECTED);
129     }
130   else /* Old style CTB.  */
131     {
132       int lenbytes;
133
134       pktlen = 0;
135       pkttype = (ctb>>2)&0xf;
136       lenbytes = ((ctb&3)==3)? 0 : (1<<(ctb & 3));
137       if (!lenbytes) /* Not allowed in key packets.  */
138         return gpg_error (GPG_ERR_UNEXPECTED);
139       if (len < lenbytes)
140         return gpg_error (GPG_ERR_INV_PACKET); /* Not enough length bytes.  */
141       for (; lenbytes; lenbytes--)
142         {
143           pktlen <<= 8;
144           pktlen |= *buf++; len--;
145         }
146     }
147
148   /* Do some basic sanity check.  */
149   switch (pkttype)
150     {
151     case PKT_SIGNATURE:
152     case PKT_SECRET_KEY:
153     case PKT_PUBLIC_KEY:
154     case PKT_SECRET_SUBKEY:
155     case PKT_MARKER:
156     case PKT_RING_TRUST:
157     case PKT_USER_ID:
158     case PKT_PUBLIC_SUBKEY:
159     case PKT_OLD_COMMENT:
160     case PKT_ATTRIBUTE:
161     case PKT_COMMENT:
162     case PKT_GPG_CONTROL:
163       break; /* Okay these are allowed packets. */
164     default:
165       return gpg_error (GPG_ERR_UNEXPECTED);
166     }
167
168   if (pktlen == 0xffffffff)
169       return gpg_error (GPG_ERR_INV_PACKET);
170
171   if (pktlen > len)
172     return gpg_error (GPG_ERR_INV_PACKET); /* Packet length header too long. */
173
174   *r_data = buf;
175   *r_datalen = pktlen;
176   *r_pkttype = pkttype;
177   *r_ntotal = (buf - *bufptr) + pktlen;
178
179   *bufptr = buf + pktlen;
180   *buflen = len - pktlen;
181   if (!*buflen)
182     *bufptr = NULL;
183
184   return 0;
185 }
186
187
188 /* Parse a key packet and store the ionformation in KI. */
189 static gpg_error_t
190 parse_key (const unsigned char *data, size_t datalen,
191            struct _keybox_openpgp_key_info *ki)
192 {
193   gpg_error_t err;
194   const unsigned char *data_start = data;
195   int i, version, algorithm;
196   size_t n;
197   /*unsigned long timestamp;*/
198   int npkey;
199   unsigned char hashbuffer[768];
200   const unsigned char *mpi_n = NULL;
201   size_t mpi_n_len = 0, mpi_e_len = 0;
202   gcry_md_hd_t md;
203
204   if (datalen < 5)
205     return gpg_error (GPG_ERR_INV_PACKET);
206   version = *data++; datalen--;
207   if (version < 2 || version > 4 )
208     return gpg_error (GPG_ERR_INV_PACKET); /* Invalid version. */
209
210   /*timestamp = ((data[0]<<24)|(data[1]<<16)|(data[2]<<8)|(data[3]));*/
211   data +=4; datalen -=4;
212
213   if (version < 4)
214     {
215       if (datalen < 2)
216         return gpg_error (GPG_ERR_INV_PACKET);
217       data += 2; datalen -= 2;
218     }
219
220   if (!datalen)
221     return gpg_error (GPG_ERR_INV_PACKET);
222   algorithm = *data++; datalen--;
223
224   switch (algorithm)
225     {
226     case 1:
227     case 2:
228     case 3: /* RSA */
229       npkey = 2;
230       break;
231     case 16:
232     case 20: /* Elgamal */
233       npkey = 3;
234       break;
235     case 17: /* DSA */
236       npkey = 4;
237       break;
238     default: /* Unknown algorithm. */
239       return gpg_error (GPG_ERR_UNKNOWN_ALGORITHM);
240     }
241
242   for (i=0; i < npkey; i++ )
243     {
244       unsigned int nbits, nbytes;
245
246       if (datalen < 2)
247         return gpg_error (GPG_ERR_INV_PACKET);
248       nbits = ((data[0]<<8)|(data[1]));
249       data += 2; 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       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 becuase 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 fucntion 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 fucntions 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 when 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,
339                        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   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         break;
359
360       if (first)
361         {
362           if (pkttype == PKT_PUBLIC_KEY)
363             ;
364           else if (pkttype == PKT_SECRET_KEY)
365             info->is_secret = 1;
366           else
367             {
368               err = gpg_error (GPG_ERR_UNEXPECTED);
369               break;
370             }
371           first = 0;
372         }
373       else if (pkttype == PKT_PUBLIC_KEY || pkttype == PKT_SECRET_KEY)
374         break; /* Next keyblock encountered - ready. */
375
376       if (nparsed)
377         *nparsed += n;
378
379       if (pkttype == PKT_SIGNATURE)
380         {
381           /* For now we only count the total number of signatures. */
382           info->nsigs++;
383         }
384       else if (pkttype == PKT_USER_ID)
385         {
386           info->nuids++;
387           if (info->nuids == 1)
388             {
389               info->uids.off = data - image_start;
390               info->uids.len = datalen;
391               utail = &info->uids.next;
392             }
393           else
394             {
395               u = xtrycalloc (1, sizeof *u);
396               if (!u)
397                 {
398                   err = gpg_error_from_syserror ();
399                   break;
400                 }
401               u->off = data - image_start;
402               u->len = datalen;
403               *utail = u;
404               utail = &u->next;
405             }
406         }
407       else if (pkttype == PKT_PUBLIC_KEY || pkttype == PKT_SECRET_KEY)
408         {
409           err = parse_key (data, datalen, &info->primary);
410           if (err)
411             break;
412         }
413       else if( pkttype == PKT_PUBLIC_SUBKEY && datalen && *data == '#' )
414         {
415           /* Early versions of GnuPG used old PGP comment packets;
416            * luckily all those comments are prefixed by a hash
417            * sign - ignore these packets. */
418         }
419       else if (pkttype == PKT_PUBLIC_SUBKEY || pkttype == PKT_SECRET_SUBKEY)
420         {
421           info->nsubkeys++;
422           if (info->nsubkeys == 1)
423             {
424               err = parse_key (data, datalen, &info->subkeys);
425               if (err)
426                 {
427                   info->nsubkeys--;
428                   if (gpg_err_code (err) != GPG_ERR_UNKNOWN_ALGORITHM)
429                     break;
430                   /* We ignore subkeys with unknown algorithms. */
431                 }
432               else
433                 ktail = &info->subkeys.next;
434             }
435           else
436             {
437               k = xtrycalloc (1, sizeof *k);
438               if (!k)
439                 {
440                   err = gpg_error_from_syserror ();
441                   break;
442                 }
443               err = parse_key (data, datalen, k);
444               if (err)
445                 {
446                   xfree (k);
447                   info->nsubkeys--;
448                   if (gpg_err_code (err) != GPG_ERR_UNKNOWN_ALGORITHM)
449                     break;
450                   /* We ignore subkeys with unknown algorithms. */
451                 }
452               else
453                 {
454                   *ktail = k;
455                   ktail = &k->next;
456                 }
457             }
458         }
459     }
460
461   if (err)
462     {
463       _keybox_destroy_openpgp_info (info);
464       if (!first
465           && (gpg_err_code (err) == GPG_ERR_UNSUPPORTED_ALGORITHM
466               || gpg_err_code (err) == GPG_ERR_UNKNOWN_ALGORITHM))
467         {
468           /* We are able to skip to the end of this keyblock. */
469           while (image)
470             {
471               if (next_packet (&image, &imagelen,
472                                &data, &datalen, &pkttype, &n) )
473                 break; /* Another error - stop here. */
474
475               if (pkttype == PKT_PUBLIC_KEY || pkttype == PKT_SECRET_KEY)
476                 break; /* Next keyblock encountered - ready. */
477
478               if (nparsed)
479                 *nparsed += n;
480             }
481         }
482     }
483
484   return err;
485 }
486
487
488 /* Release any malloced data in INFO but not INFO itself! */
489 void
490 _keybox_destroy_openpgp_info (keybox_openpgp_info_t info)
491 {
492   struct _keybox_openpgp_key_info *k, *k2;
493   struct _keybox_openpgp_uid_info *u, *u2;
494
495   assert (!info->primary.next);
496   for (k=info->subkeys.next; k; k = k2)
497     {
498       k2 = k->next;
499       xfree (k);
500     }
501
502   for (u=info->uids.next; u; u = u2)
503     {
504       u2 = u->next;
505       xfree (u);
506     }
507 }