Use inline functions to convert buffer data to scalars.
[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 #include "host2net.h"
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 = buf32_to_ulong (buf);
98           buf += 4;
99           len -= 4;
100       }
101       else /* Partial length encoding is not allowed for key packets. */
102         return gpg_error (GPG_ERR_UNEXPECTED);
103     }
104   else /* Old style CTB.  */
105     {
106       int lenbytes;
107
108       pktlen = 0;
109       pkttype = (ctb>>2)&0xf;
110       lenbytes = ((ctb&3)==3)? 0 : (1<<(ctb & 3));
111       if (!lenbytes) /* Not allowed in key packets.  */
112         return gpg_error (GPG_ERR_UNEXPECTED);
113       if (len < lenbytes)
114         return gpg_error (GPG_ERR_INV_PACKET); /* Not enough length bytes.  */
115       for (; lenbytes; lenbytes--)
116         {
117           pktlen <<= 8;
118           pktlen |= *buf++; len--;
119         }
120     }
121
122   /* Do some basic sanity check.  */
123   switch (pkttype)
124     {
125     case PKT_SIGNATURE:
126     case PKT_SECRET_KEY:
127     case PKT_PUBLIC_KEY:
128     case PKT_SECRET_SUBKEY:
129     case PKT_MARKER:
130     case PKT_RING_TRUST:
131     case PKT_USER_ID:
132     case PKT_PUBLIC_SUBKEY:
133     case PKT_OLD_COMMENT:
134     case PKT_ATTRIBUTE:
135     case PKT_COMMENT:
136     case PKT_GPG_CONTROL:
137       break; /* Okay these are allowed packets. */
138     default:
139       return gpg_error (GPG_ERR_UNEXPECTED);
140     }
141
142   if (pktlen == (unsigned long)(-1))
143     return gpg_error (GPG_ERR_INV_PACKET);
144
145   if (pktlen > len)
146     return gpg_error (GPG_ERR_INV_PACKET); /* Packet length header too long. */
147
148   *r_data = buf;
149   *r_datalen = pktlen;
150   *r_pkttype = pkttype;
151   *r_ntotal = (buf - *bufptr) + pktlen;
152
153   *bufptr = buf + pktlen;
154   *buflen = len - pktlen;
155   if (!*buflen)
156     *bufptr = NULL;
157
158   return 0;
159 }
160
161
162 /* Parse a key packet and store the information in KI. */
163 static gpg_error_t
164 parse_key (const unsigned char *data, size_t datalen,
165            struct _keybox_openpgp_key_info *ki)
166 {
167   gpg_error_t err;
168   const unsigned char *data_start = data;
169   int i, version, algorithm;
170   size_t n;
171   int npkey;
172   unsigned char hashbuffer[768];
173   const unsigned char *mpi_n = NULL;
174   size_t mpi_n_len = 0, mpi_e_len = 0;
175   gcry_md_hd_t md;
176   int is_ecc = 0;
177
178   if (datalen < 5)
179     return gpg_error (GPG_ERR_INV_PACKET);
180   version = *data++; datalen--;
181   if (version < 2 || version > 4 )
182     return gpg_error (GPG_ERR_INV_PACKET); /* Invalid version. */
183
184   /*timestamp = ((data[0]<<24)|(data[1]<<16)|(data[2]<<8)|(data[3]));*/
185   data +=4; datalen -=4;
186
187   if (version < 4)
188     {
189       if (datalen < 2)
190         return gpg_error (GPG_ERR_INV_PACKET);
191       data +=2; datalen -= 2;
192     }
193
194   if (!datalen)
195     return gpg_error (GPG_ERR_INV_PACKET);
196   algorithm = *data++; datalen--;
197
198   switch (algorithm)
199     {
200     case PUBKEY_ALGO_RSA:
201     case PUBKEY_ALGO_RSA_E:
202     case PUBKEY_ALGO_RSA_S:
203       npkey = 2;
204       break;
205     case PUBKEY_ALGO_ELGAMAL_E:
206     case PUBKEY_ALGO_ELGAMAL:
207       npkey = 3;
208       break;
209     case PUBKEY_ALGO_DSA:
210       npkey = 4;
211       break;
212     case PUBKEY_ALGO_ECDH:
213       npkey = 3;
214       is_ecc = 1;
215       break;
216     case PUBKEY_ALGO_ECDSA:
217     case PUBKEY_ALGO_EDDSA:
218       npkey = 2;
219       is_ecc = 1;
220       break;
221     default: /* Unknown algorithm. */
222       return gpg_error (GPG_ERR_UNKNOWN_ALGORITHM);
223     }
224
225   ki->algo = algorithm;
226
227   for (i=0; i < npkey; i++ )
228     {
229       unsigned int nbits, nbytes;
230
231       if (datalen < 2)
232         return gpg_error (GPG_ERR_INV_PACKET);
233
234       if (is_ecc && (i == 0 || i == 2))
235         {
236           nbytes = data[0];
237           if (nbytes < 2 || nbytes > 254)
238             return gpg_error (GPG_ERR_INV_PACKET);
239           nbytes++; /* The size byte itself.  */
240           if (datalen < nbytes)
241             return gpg_error (GPG_ERR_INV_PACKET);
242         }
243       else
244         {
245           nbits = ((data[0]<<8)|(data[1]));
246           data += 2;
247           datalen -= 2;
248           nbytes = (nbits+7) / 8;
249           if (datalen < nbytes)
250             return gpg_error (GPG_ERR_INV_PACKET);
251           /* For use by v3 fingerprint calculation we need to know the RSA
252              modulus and exponent. */
253           if (i==0)
254             {
255               mpi_n = data;
256               mpi_n_len = nbytes;
257             }
258           else if (i==1)
259             mpi_e_len = nbytes;
260         }
261
262       data += nbytes; datalen -= nbytes;
263     }
264   n = data - data_start;
265
266   if (version < 4)
267     {
268       /* We do not support any other algorithm than RSA in v3
269          packets. */
270       if (algorithm < 1 || algorithm > 3)
271         return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
272
273       err = gcry_md_open (&md, GCRY_MD_MD5, 0);
274       if (err)
275         return err; /* Oops */
276       gcry_md_write (md, mpi_n, mpi_n_len);
277       gcry_md_write (md, mpi_n+mpi_n_len+2, mpi_e_len);
278       memcpy (ki->fpr, gcry_md_read (md, 0), 16);
279       gcry_md_close (md);
280       ki->fprlen = 16;
281
282       if (mpi_n_len < 8)
283         {
284           /* Moduli less than 64 bit are out of the specs scope.  Zero
285              them out because this is what gpg does too. */
286           memset (ki->keyid, 0, 8);
287         }
288       else
289         memcpy (ki->keyid, mpi_n + mpi_n_len - 8, 8);
290     }
291   else
292     {
293       /* Its a pitty that we need to prefix the buffer with the tag
294          and a length header: We can't simply pass it to the fast
295          hashing function for that reason.  It might be a good idea to
296          have a scatter-gather enabled hash function. What we do here
297          is to use a static buffer if this one is large enough and
298          only use the regular hash functions if this buffer is not
299          large enough. */
300       if ( 3 + n < sizeof hashbuffer )
301         {
302           hashbuffer[0] = 0x99;     /* CTB */
303           hashbuffer[1] = (n >> 8); /* 2 byte length header. */
304           hashbuffer[2] = n;
305           memcpy (hashbuffer + 3, data_start, n);
306           gcry_md_hash_buffer (GCRY_MD_SHA1, ki->fpr, hashbuffer, 3 + n);
307         }
308       else
309         {
310           err = gcry_md_open (&md, GCRY_MD_SHA1, 0);
311           if (err)
312             return err; /* Oops */
313           gcry_md_putc (md, 0x99 );     /* CTB */
314           gcry_md_putc (md, (n >> 8) ); /* 2 byte length header. */
315           gcry_md_putc (md, n );
316           gcry_md_write (md, data_start, n);
317           memcpy (ki->fpr, gcry_md_read (md, 0), 20);
318           gcry_md_close (md);
319         }
320       ki->fprlen = 20;
321       memcpy (ki->keyid, ki->fpr+12, 8);
322     }
323
324   return 0;
325 }
326
327
328
329 /* The caller must pass the address of an INFO structure which will
330    get filled on success with information pertaining to the OpenPGP
331    keyblock IMAGE of length IMAGELEN.  Note that a caller does only
332    need to release this INFO structure if the function returns
333    success.  If NPARSED is not NULL the actual number of bytes parsed
334    will be stored at this address.  */
335 gpg_error_t
336 _keybox_parse_openpgp (const unsigned char *image, size_t imagelen,
337                        size_t *nparsed, keybox_openpgp_info_t info)
338 {
339   gpg_error_t err = 0;
340   const unsigned char *image_start, *data;
341   size_t n, datalen;
342   int pkttype;
343   int first = 1;
344   int read_error = 0;
345   struct _keybox_openpgp_key_info *k, **ktail = NULL;
346   struct _keybox_openpgp_uid_info *u, **utail = NULL;
347
348   memset (info, 0, sizeof *info);
349   if (nparsed)
350     *nparsed = 0;
351
352   image_start = image;
353   while (image)
354     {
355       err = next_packet (&image, &imagelen, &data, &datalen, &pkttype, &n);
356       if (err)
357         {
358           read_error = 1;
359           break;
360         }
361
362       if (first)
363         {
364           if (pkttype == PKT_PUBLIC_KEY)
365             ;
366           else if (pkttype == PKT_SECRET_KEY)
367             info->is_secret = 1;
368           else
369             {
370               err = gpg_error (GPG_ERR_UNEXPECTED);
371               if (nparsed)
372                 *nparsed += n;
373               break;
374             }
375           first = 0;
376         }
377       else if (pkttype == PKT_PUBLIC_KEY || pkttype == PKT_SECRET_KEY)
378         break; /* Next keyblock encountered - ready. */
379
380       if (nparsed)
381         *nparsed += n;
382
383       if (pkttype == PKT_SIGNATURE)
384         {
385           /* For now we only count the total number of signatures. */
386           info->nsigs++;
387         }
388       else if (pkttype == PKT_USER_ID)
389         {
390           info->nuids++;
391           if (info->nuids == 1)
392             {
393               info->uids.off = data - image_start;
394               info->uids.len = datalen;
395               utail = &info->uids.next;
396             }
397           else
398             {
399               u = xtrycalloc (1, sizeof *u);
400               if (!u)
401                 {
402                   err = gpg_error_from_syserror ();
403                   break;
404                 }
405               u->off = data - image_start;
406               u->len = datalen;
407               *utail = u;
408               utail = &u->next;
409             }
410         }
411       else if (pkttype == PKT_PUBLIC_KEY || pkttype == PKT_SECRET_KEY)
412         {
413           err = parse_key (data, datalen, &info->primary);
414           if (err)
415             break;
416         }
417       else if( pkttype == PKT_PUBLIC_SUBKEY && datalen && *data == '#' )
418         {
419           /* Early versions of GnuPG used old PGP comment packets;
420            * luckily all those comments are prefixed by a hash
421            * sign - ignore these packets. */
422         }
423       else if (pkttype == PKT_PUBLIC_SUBKEY || pkttype == PKT_SECRET_SUBKEY)
424         {
425           info->nsubkeys++;
426           if (info->nsubkeys == 1)
427             {
428               err = parse_key (data, datalen, &info->subkeys);
429               if (err)
430                 {
431                   info->nsubkeys--;
432                   /* We ignore subkeys with unknown algorithms. */
433                   if (gpg_err_code (err) == GPG_ERR_UNKNOWN_ALGORITHM
434                       || gpg_err_code (err) == GPG_ERR_UNSUPPORTED_ALGORITHM)
435                     err = 0;
436                   if (err)
437                     break;
438                 }
439               else
440                 ktail = &info->subkeys.next;
441             }
442           else
443             {
444               k = xtrycalloc (1, sizeof *k);
445               if (!k)
446                 {
447                   err = gpg_error_from_syserror ();
448                   break;
449                 }
450               err = parse_key (data, datalen, k);
451               if (err)
452                 {
453                   xfree (k);
454                   info->nsubkeys--;
455                   /* We ignore subkeys with unknown algorithms. */
456                   if (gpg_err_code (err) == GPG_ERR_UNKNOWN_ALGORITHM
457                       || gpg_err_code (err) == GPG_ERR_UNSUPPORTED_ALGORITHM)
458                     err = 0;
459                   if (err)
460                     break;
461                 }
462               else
463                 {
464                   *ktail = k;
465                   ktail = &k->next;
466                 }
467             }
468         }
469     }
470
471   if (err)
472     {
473       _keybox_destroy_openpgp_info (info);
474       if (!read_error)
475         {
476           /* Packet parsing worked, thus we should be able to skip the
477              rest of the 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 }