2006-06-09 Marcus Brinkmann <marcus@g10code.de>
[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 2 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, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21 /* This is a simple OpenPGP parser suitable for all OpenPGP key
22    material.  It just provides the functionality required to build and
23    parse an KBX OpenPGP key blob.  Thus it is not a complete parser.
24    However it is self-contained and optimized for fast in-memory
25    parsing.  Note that we don't support old ElGamal v3 keys
26    anymore. */
27
28 #include <config.h>
29 #include <stdlib.h>
30 #include <stdio.h>
31 #include <string.h>
32 #include <errno.h>
33 #include <assert.h>
34
35 #include "keybox-defs.h"
36
37 #include <gcrypt.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  = (*buf++) << 24;
124           pktlen |= (*buf++) << 16;
125           pktlen |= (*buf++) << 8;
126           pktlen |= (*buf++);
127           len -= 4;
128       }
129       else /* Partial length encoding is not allowed for key packets. */
130         return gpg_error (GPG_ERR_UNEXPECTED);
131     }
132   else /* Old style CTB.  */
133     {
134       int lenbytes;
135
136       pktlen = 0;
137       pkttype = (ctb>>2)&0xf;
138       lenbytes = ((ctb&3)==3)? 0 : (1<<(ctb & 3));
139       if (!lenbytes) /* Not allowed in key packets.  */
140         return gpg_error (GPG_ERR_UNEXPECTED);
141       if (len < lenbytes)
142         return gpg_error (GPG_ERR_INV_PACKET); /* Not enough length bytes.  */
143       for (; lenbytes; lenbytes--)
144         {
145           pktlen <<= 8;
146           pktlen |= *buf++; len--;
147         }
148     }
149
150   /* Do some basic sanity check.  */
151   switch (pkttype)
152     {
153     case PKT_SIGNATURE:
154     case PKT_SECRET_KEY:        
155     case PKT_PUBLIC_KEY:
156     case PKT_SECRET_SUBKEY:
157     case PKT_MARKER:
158     case PKT_RING_TRUST:
159     case PKT_USER_ID:
160     case PKT_PUBLIC_SUBKEY:
161     case PKT_OLD_COMMENT:
162     case PKT_ATTRIBUTE:
163     case PKT_COMMENT:
164     case PKT_GPG_CONTROL:
165       break; /* Okay these are allowed packets. */
166     default:
167       return gpg_error (GPG_ERR_UNEXPECTED);
168     }
169
170   if (pktlen == 0xffffffff) 
171       return gpg_error (GPG_ERR_INV_PACKET);
172   
173   if (pktlen > len)
174     return gpg_error (GPG_ERR_INV_PACKET); /* Packet length header too long. */
175
176   *r_data = buf;
177   *r_datalen = pktlen;
178   *r_pkttype = pkttype;
179   *r_ntotal = (buf - *bufptr) + pktlen;
180
181   *bufptr = buf + pktlen;
182   *buflen = len - pktlen;
183   if (!*buflen)
184     *bufptr = NULL;
185
186   return 0;
187 }
188
189
190 /* Parse a key packet and store the ionformation in KI. */
191 static gpg_error_t
192 parse_key (const unsigned char *data, size_t datalen,
193            struct _keybox_openpgp_key_info *ki)
194 {
195   gpg_error_t err;
196   const unsigned char *data_start = data;
197   int i, version, algorithm;
198   size_t n;
199   unsigned long timestamp, expiredate;
200   int npkey;
201   unsigned char hashbuffer[768];
202   const unsigned char *mpi_n = NULL;
203   size_t mpi_n_len = 0, mpi_e_len = 0;
204   gcry_md_hd_t md;
205
206   if (datalen < 5)
207     return gpg_error (GPG_ERR_INV_PACKET);
208   version = *data++; datalen--;
209   if (version < 2 || version > 4 )
210     return gpg_error (GPG_ERR_INV_PACKET); /* Invalid version. */
211   
212   timestamp = ((data[0]<<24)|(data[1]<<16)|(data[2]<<8)|(data[3]));
213   data +=4; datalen -=4;
214
215   if (version < 4)
216     {
217       unsigned short ndays;
218       
219       if (datalen < 2)
220         return gpg_error (GPG_ERR_INV_PACKET);
221       ndays = ((data[0]<<8)|(data[1]));
222       data +=2; datalen -= 2;
223       if (ndays)
224       expiredate = ndays? (timestamp + ndays * 86400L) : 0;
225     }
226   else
227     expiredate = 0; /* This is stored in the self-signature. */
228
229   if (!datalen)
230     return gpg_error (GPG_ERR_INV_PACKET);
231   algorithm = *data++; datalen--;
232
233   switch (algorithm)
234     {
235     case 1:
236     case 2:
237     case 3: /* RSA */
238       npkey = 2; 
239       break;
240     case 16:
241     case 20: /* Elgamal */
242       npkey = 3;
243       break;
244     case 17: /* DSA */
245       npkey = 4;
246       break;
247     default: /* Unknown algorithm. */
248       return gpg_error (GPG_ERR_UNKNOWN_ALGORITHM);
249     }
250
251   for (i=0; i < npkey; i++ )
252     {
253       unsigned int nbits, nbytes;
254       
255       if (datalen < 2)
256         return gpg_error (GPG_ERR_INV_PACKET);
257       nbits = ((data[0]<<8)|(data[1]));
258       data += 2; datalen -=2;
259       nbytes = (nbits+7) / 8;
260       if (datalen < nbytes)
261         return gpg_error (GPG_ERR_INV_PACKET);
262       /* For use by v3 fingerprint calculation we need to know the RSA
263          modulus and exponent. */
264       if (i==0) 
265         {
266           mpi_n = data; 
267           mpi_n_len = nbytes;
268         }
269       else if (i==1)
270         mpi_e_len = nbytes;
271         
272       data += nbytes; datalen -= nbytes;
273     }
274   n = data - data_start;
275
276   if (version < 4)
277     {
278       /* We do not support any other algorithm than RSA in v3
279          packets. */
280       if (algorithm < 1 || algorithm > 3)
281         return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
282
283       err = gcry_md_open (&md, GCRY_MD_MD5, 0);
284       if (err)
285         return err; /* Oops */
286       gcry_md_write (md, mpi_n, mpi_n_len);
287       gcry_md_write (md, mpi_n+mpi_n_len+2, mpi_e_len);
288       memcpy (ki->fpr, gcry_md_read (md, 0), 16);
289       gcry_md_close (md);
290       ki->fprlen = 16;
291       
292       if (mpi_n_len < 8)
293         {
294           /* Moduli less than 64 bit are out of the specs scope.  Zero
295              them out becuase this is what gpg does too. */
296           memset (ki->keyid, 0, 8); 
297         }
298       else
299         memcpy (ki->keyid, mpi_n + mpi_n_len - 8, 8);
300     }
301   else
302     {
303       /* Its a pitty that we need to prefix the buffer with the tag
304          and a length header: We can't simply pass it to the fast
305          hashing fucntion for that reason.  It might be a good idea to
306          have a scatter-gather enabled hash function. What we do here
307          is to use a static buffer if this one is large enough and
308          only use the regular hash fucntions if this buffer is not
309          large enough. */
310       if ( 3 + n < sizeof hashbuffer )
311         {
312           hashbuffer[0] = 0x99;     /* CTB */
313           hashbuffer[1] = (n >> 8); /* 2 byte length header. */
314           hashbuffer[2] = n;
315           memcpy (hashbuffer + 3, data_start, n);
316           gcry_md_hash_buffer (GCRY_MD_SHA1, ki->fpr, hashbuffer, 3 + n);
317         }
318       else
319         {
320           err = gcry_md_open (&md, GCRY_MD_SHA1, 0);
321           if (err)
322             return err; /* Oops */
323           gcry_md_putc (md, 0x99 );     /* CTB */
324           gcry_md_putc (md, (n >> 8) ); /* 2 byte length header. */
325           gcry_md_putc (md, n );
326           gcry_md_write (md, data_start, n);
327           memcpy (ki->fpr, gcry_md_read (md, 0), 20);
328           gcry_md_close (md);
329         }
330       ki->fprlen = 20;
331       memcpy (ki->keyid, ki->fpr+12, 8);
332     }
333
334   return 0;
335 }
336
337
338
339 /* The caller must pass the address of an INFO structure which will
340    get filled on success with information pertaining to the OpenPGP
341    keyblock IMAGE of length IMAGELEN.  Note that a caller does only
342    need to release this INFO structure when the function returns
343    success.  If NPARSED is not NULL the actual number of bytes parsed
344    will be stored at this address.  */
345 gpg_error_t
346 _keybox_parse_openpgp (const unsigned char *image, size_t imagelen,
347                        size_t *nparsed,
348                        keybox_openpgp_info_t info)
349 {
350   gpg_error_t err = 0;
351   const unsigned char *image_start, *data;
352   size_t n, datalen;
353   int pkttype;
354   int first = 1;
355   struct _keybox_openpgp_key_info *k, **ktail = NULL;
356   struct _keybox_openpgp_uid_info *u, **utail = NULL;
357   
358   memset (info, 0, sizeof *info);
359   if (nparsed)
360     *nparsed = 0;
361
362   image_start = image;
363   while (image)
364     {
365       err = next_packet (&image, &imagelen, &data, &datalen, &pkttype, &n);
366       if (err)
367         break;
368
369       if (first)
370         {
371           if (pkttype == PKT_PUBLIC_KEY)
372             ;
373           else if (pkttype == PKT_SECRET_KEY)
374             info->is_secret = 1;
375           else
376             {
377               err = gpg_error (GPG_ERR_UNEXPECTED);
378               break;
379             }
380           first = 0;
381         }
382       else if (pkttype == PKT_PUBLIC_KEY || pkttype == PKT_SECRET_KEY)
383         break; /* Next keyblock encountered - ready. */
384       
385       if (nparsed)
386         *nparsed += n;
387
388       if (pkttype == PKT_SIGNATURE)
389         {
390           /* For now we only count the total number of signatures. */
391           info->nsigs++;
392         }
393       else if (pkttype == PKT_USER_ID)
394         {
395           info->nuids++;
396           if (info->nuids == 1)
397             {
398               info->uids.off = data - image_start;
399               info->uids.len = datalen;
400               utail = &info->uids.next;
401             }
402           else
403             {
404               u = xtrycalloc (1, sizeof *u);
405               if (!u)
406                 {
407                   err = gpg_error_from_errno (errno);
408                   break;
409                 }
410               u->off = data - image_start;
411               u->len = datalen;
412               *utail = u;
413               utail = &u->next;
414             }
415         }
416       else if (pkttype == PKT_PUBLIC_KEY || pkttype == PKT_SECRET_KEY)
417         {
418           err = parse_key (data, datalen, &info->primary);
419           if (err)
420             break;
421         }
422       else if( pkttype == PKT_PUBLIC_SUBKEY && datalen && *data == '#' ) 
423         {
424           /* Early versions of GnuPG used old PGP comment packets;
425            * luckily all those comments are prefixed by a hash
426            * sign - ignore these packets. */
427         }
428       else if (pkttype == PKT_PUBLIC_SUBKEY || pkttype == PKT_SECRET_SUBKEY)
429         {
430           info->nsubkeys++;
431           if (info->nsubkeys == 1)
432             {
433               err = parse_key (data, datalen, &info->subkeys);
434               if (err)
435                 {
436                   info->nsubkeys--;
437                   if (gpg_err_code (err) != GPG_ERR_UNKNOWN_ALGORITHM)
438                     break;
439                   /* We ignore subkeys with unknown algorithms. */
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_errno (errno);
450                   break;
451                 }
452               err = parse_key (data, datalen, k);
453               if (err)
454                 {
455                   xfree (k);
456                   info->nsubkeys--;
457                   if (gpg_err_code (err) != GPG_ERR_UNKNOWN_ALGORITHM)
458                     break;
459                   /* We ignore subkeys with unknown algorithms. */
460                 }
461               else
462                 {
463                   *ktail = k;
464                   ktail = &k->next;
465                 }
466             }
467         }
468     }
469
470   if (err)
471     {
472       _keybox_destroy_openpgp_info (info);
473       if (!first
474           && (gpg_err_code (err) == GPG_ERR_UNSUPPORTED_ALGORITHM
475               || gpg_err_code (err) == GPG_ERR_UNKNOWN_ALGORITHM))
476         {
477           /* We are able to skip to the end of this keyblock. */
478           while (image)
479             {
480               if (next_packet (&image, &imagelen,
481                                &data, &datalen, &pkttype, &n) )
482                 break; /* Another error - stop here. */
483
484               if (pkttype == PKT_PUBLIC_KEY || pkttype == PKT_SECRET_KEY)
485                 break; /* Next keyblock encountered - ready. */
486               
487               if (nparsed)
488                 *nparsed += n;
489             }
490         }
491     }
492
493   return err;
494 }
495
496
497 /* Release any malloced data in INFO but not INFO itself! */
498 void
499 _keybox_destroy_openpgp_info (keybox_openpgp_info_t info)
500 {
501   struct _keybox_openpgp_key_info *k, *k2;
502   struct _keybox_openpgp_uid_info *u, *u2;
503
504   assert (!info->primary.next);
505   for (k=info->subkeys.next; k; k = k2)
506     {
507       k2 = k->next;
508       xfree (k);
509     }
510
511   for (u=info->uids.next; u; u = u2)
512     {
513       u2 = u->next;
514       xfree (u);
515     }
516 }