agent: Stop scdaemon after reload when disable_scdaemon.
[gnupg.git] / kbx / keybox-blob.c
1 /* keybox-blob.c - KBX Blob handling
2  * Copyright (C) 2000, 2001, 2002, 2003, 2008 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 /*
21 * The keybox data format
22
23    The KeyBox uses an augmented OpenPGP/X.509 key format.  This makes
24    random access to a keyblock/certificate easier and also gives the
25    opportunity to store additional information (e.g. the fingerprint)
26    along with the key.  All integers are stored in network byte order,
27    offsets are counted from the beginning of the Blob.
28
29 ** Overview of blob types
30
31    | Byte 4 | Blob type    |
32    |--------+--------------|
33    |      0 | Empty blob   |
34    |      1 | First blob   |
35    |      2 | OpenPGP blob |
36    |      3 | X.509 blob   |
37
38 ** The First blob
39
40    The first blob of a plain KBX file has a special format:
41
42    - u32  Length of this blob
43    - byte Blob type (1)
44    - byte Version number (1)
45    - u16  Header flags
46           bit 0 - RFU
47           bit 1 - Is being or has been used for OpenPGP blobs
48    - b4   Magic 'KBXf'
49    - u32  RFU
50    - u32  file_created_at
51    - u32  last_maintenance_run
52    - u32  RFU
53    - u32  RFU
54
55 ** The OpenPGP and X.509 blobs
56
57    The OpenPGP and X.509 blobs are very similar, things which are
58    X.509 specific are noted like [X.509: xxx]
59
60    - u32  Length of this blob (including these 4 bytes)
61    - byte Blob type
62            2 = OpenPGP
63            3 = X509
64    - byte Version number of this blob type
65            1 = Blob with 20 byte fingerprints
66            2 = Blob with 32 byte fingerprints and no keyids.
67    - u16  Blob flags
68           bit 0 = contains secret key material (not used)
69           bit 1 = ephemeral blob (e.g. used while querying external resources)
70    - u32  Offset to the OpenPGP keyblock or the X.509 DER encoded
71           certificate
72    - u32  The length of the keyblock or certificate
73    - u16  [NKEYS] Number of keys (at least 1!) [X509: always 1]
74    - u16  Size of the key information structure (at least 28 or 56).
75    - NKEYS times:
76      Version 1 blob:
77       - b20  The fingerprint of the key.
78              Fingerprints are always 20 bytes, MD5 left padded with zeroes.
79       - u32  Offset to the n-th key's keyID (a keyID is always 8 byte)
80              or 0 if not known which is the case only for X.509.
81              Note that this separate keyid is not anymore used by
82              gnupg since the support for v3 keys has been removed.
83              We create this field anyway for backward compatibility with
84              old EOL-ed versions.  Eventually we will completely move
85              to the version 2 blob format.
86       - u16  Key flags
87              bit 0 = qualified signature (not yet implemented}
88       - u16  RFU
89       - bN   Optional filler up to the specified length of this
90              structure.
91      Version 2 blob:
92       - b32  The fingerprint of the key.  This fingerprint is
93              either 20 or 32 bytes.  A 20 byte fingerprint is
94              right filled with zeroes.
95       - u16  Key flags
96              bit 0 = qualified signature (not yet implemented}
97              bit 7 = 32 byte fingerprint in use.
98       - u16  RFU
99       - b20  keygrip
100       - bN   Optional filler up to the specified length of this
101              structure.
102    - u16  Size of the serial number (may be zero)
103       -  bN  The serial number. N as given above.
104    - u16  Number of user IDs
105    - u16  [NUIDS] Size of user ID information structure
106    - NUIDS times:
107
108       For X509, the first user ID is the Issuer, the second the
109       Subject and the others are subjectAltNames.  For OpenPGP we only
110       store the information from UserID packets here.
111
112       - u32  Blob offset to the n-th user ID
113       - u32  Length of this user ID.
114       - u16  User ID flags.
115              (not yet used)
116       - byte Validity
117       - byte RFU
118
119    - u16  [NSIGS] Number of signatures
120    - u16  Size of signature information (4)
121    - NSIGS times:
122       - u32  Expiration time of signature with some special values.
123              Since version 2.1.20 these special valuesare not anymore
124              used for OpenPGP:
125              - 0x00000000 = not checked
126              - 0x00000001 = missing key
127              - 0x00000002 = bad signature
128              - 0x10000000 = valid and expires at some date in 1978.
129              - 0xffffffff = valid and does not expire
130    - u8 Assigned ownertrust [X509: not used]
131    - u8 All_Validity
132         OpenPGP: See ../g10/trustdb/TRUST_* [not yet used]
133         X509: Bit 4 set := key has been revoked.
134                            Note that this value matches TRUST_FLAG_REVOKED
135    - u16  RFU
136    - u32  Recheck_after
137    - u32  Latest timestamp in the keyblock (useful for KS syncronsiation?)
138    - u32  Blob created at
139    - u32  [NRES] Size of reserved space (not including this field)
140    - bN   Reserved space of size NRES for future use.
141    - bN   Arbitrary space for example used to store data which is not
142           part of the keyblock or certificate.  For example the v3 key
143           IDs go here.
144    - bN   Space for the keyblock or certificate.
145    - bN   RFU.  This is the remaining space after keyblock and before
146           the checksum.  It is not covered by the checksum.
147    - b20  SHA-1 checksum (useful for KS syncronisation?)
148           Note, that KBX versions before GnuPG 2.1 used an MD5
149           checksum.  However it was only created but never checked.
150           Thus we do not expect problems if we switch to SHA-1.  If
151           the checksum fails and the first 4 bytes are zero, we can
152           try again with MD5.  SHA-1 has the advantage that it is
153           faster on CPUs with dedicated SHA-1 support.
154
155
156 */
157
158
159 #include <config.h>
160 #include <stdio.h>
161 #include <stdlib.h>
162 #include <string.h>
163 #include <errno.h>
164 #include <assert.h>
165 #include <time.h>
166
167 #include "keybox-defs.h"
168 #include <gcrypt.h>
169
170 #ifdef KEYBOX_WITH_X509
171 #include <ksba.h>
172 #endif
173
174
175 #include "../common/gettime.h"
176
177
178 /* special values of the signature status */
179 #define SF_NONE(a)  ( !(a) )
180 #define SF_NOKEY(a) ((a) & (1<<0))
181 #define SF_BAD(a)   ((a) & (1<<1))
182 #define SF_VALID(a) ((a) & (1<<29))
183
184
185 struct membuf {
186   size_t len;
187   size_t size;
188   char *buf;
189   int out_of_core;
190 };
191
192
193 struct keyboxblob_key {
194   char   fpr[32];
195   u32    off_kid;
196   ulong  off_kid_addr;
197   u16    flags;
198   u16    fprlen;  /* Either 20 or 32 */
199 };
200 struct keyboxblob_uid {
201   u32    off;
202   ulong  off_addr;
203   char   *name;     /* used only with x509 */
204   u32    len;
205   u16    flags;
206   byte   validity;
207 };
208
209 struct keyid_list {
210     struct keyid_list *next;
211     int seqno;
212     byte kid[8];
213 };
214
215 struct fixup_list {
216     struct fixup_list *next;
217     u32 off;
218     u32 val;
219 };
220
221
222 struct keyboxblob {
223   byte *blob;
224   size_t bloblen;
225   off_t fileoffset;
226
227   /* stuff used only by keybox_create_blob */
228   unsigned char *serialbuf;
229   const unsigned char *serial;
230   size_t seriallen;
231   int nkeys;
232   struct keyboxblob_key *keys;
233   int nuids;
234   struct keyboxblob_uid *uids;
235   int nsigs;
236   u32  *sigs;
237   struct fixup_list *fixups;
238   int fixup_out_of_core;
239
240   struct keyid_list *temp_kids;
241   struct membuf bufbuf; /* temporary store for the blob */
242   struct membuf *buf;
243 };
244
245
246 \f
247 /* A simple implementation of a dynamic buffer.  Use init_membuf() to
248    create a buffer, put_membuf to append bytes and get_membuf to
249    release and return the buffer.  Allocation errors are detected but
250    only returned at the final get_membuf(), this helps not to clutter
251    the code with out of core checks.  */
252
253 static void
254 init_membuf (struct membuf *mb, int initiallen)
255 {
256   mb->len = 0;
257   mb->size = initiallen;
258   mb->out_of_core = 0;
259   mb->buf = xtrymalloc (initiallen);
260   if (!mb->buf)
261       mb->out_of_core = 1;
262 }
263
264 static void
265 put_membuf (struct membuf *mb, const void *buf, size_t len)
266 {
267   if (mb->out_of_core)
268     return;
269
270   if (mb->len + len >= mb->size)
271     {
272       char *p;
273
274       mb->size += len + 1024;
275       p = xtryrealloc (mb->buf, mb->size);
276       if (!p)
277         {
278           mb->out_of_core = 1;
279           return;
280         }
281       mb->buf = p;
282     }
283   if (buf)
284     memcpy (mb->buf + mb->len, buf, len);
285   else
286     memset (mb->buf + mb->len, 0, len);
287   mb->len += len;
288 }
289
290 static void *
291 get_membuf (struct membuf *mb, size_t *len)
292 {
293   char *p;
294
295   if (mb->out_of_core)
296     {
297       xfree (mb->buf);
298       mb->buf = NULL;
299       return NULL;
300     }
301
302   p = mb->buf;
303   *len = mb->len;
304   mb->buf = NULL;
305   mb->out_of_core = 1; /* don't allow a reuse */
306   return p;
307 }
308
309
310 static void
311 put8 (struct membuf *mb, byte a )
312 {
313   put_membuf (mb, &a, 1);
314 }
315
316 static void
317 put16 (struct membuf *mb, u16 a )
318 {
319   unsigned char tmp[2];
320   tmp[0] = a>>8;
321   tmp[1] = a;
322   put_membuf (mb, tmp, 2);
323 }
324
325 static void
326 put32 (struct membuf *mb, u32 a )
327 {
328   unsigned char tmp[4];
329   tmp[0] = a>>24;
330   tmp[1] = a>>16;
331   tmp[2] = a>>8;
332   tmp[3] = a;
333   put_membuf (mb, tmp, 4);
334 }
335
336
337 \f
338 /* Store a value in the fixup list */
339 static void
340 add_fixup (KEYBOXBLOB blob, u32 off, u32 val)
341 {
342   struct fixup_list *fl;
343
344   if (blob->fixup_out_of_core)
345     return;
346
347   fl = xtrycalloc(1, sizeof *fl);
348   if (!fl)
349     blob->fixup_out_of_core = 1;
350   else
351     {
352       fl->off = off;
353       fl->val = val;
354       fl->next = blob->fixups;
355       blob->fixups = fl;
356     }
357 }
358
359
360 \f
361 /*
362   OpenPGP specific stuff
363 */
364
365
366 /* We must store the keyid at some place because we can't calculate
367    the offset yet. This is only used for v3 keyIDs.  Function returns
368    an index value for later fixup or -1 for out of core.  The value
369    must be a non-zero value. */
370 static int
371 pgp_temp_store_kid (KEYBOXBLOB blob, struct _keybox_openpgp_key_info *kinfo)
372 {
373   struct keyid_list *k, *r;
374
375   k = xtrymalloc (sizeof *k);
376   if (!k)
377     return -1;
378   memcpy (k->kid, kinfo->keyid, 8);
379   k->seqno = 0;
380   k->next = blob->temp_kids;
381   blob->temp_kids = k;
382   for (r=k; r; r = r->next)
383     k->seqno++;
384
385   return k->seqno;
386 }
387
388
389 /* Helper for pgp_create_key_part.  */
390 static gpg_error_t
391 pgp_create_key_part_single (KEYBOXBLOB blob, int n,
392                             struct _keybox_openpgp_key_info *kinfo)
393 {
394   size_t fprlen;
395   int off;
396
397   fprlen = kinfo->fprlen;
398   memcpy (blob->keys[n].fpr, kinfo->fpr, fprlen);
399   blob->keys[n].fprlen = fprlen;
400   if (fprlen < 20) /* v3 fpr - shift right and fill with zeroes. */
401     {
402       memmove (blob->keys[n].fpr + 20 - fprlen, blob->keys[n].fpr, fprlen);
403       memset (blob->keys[n].fpr, 0, 20 - fprlen);
404       off = pgp_temp_store_kid (blob, kinfo);
405       if (off == -1)
406         return gpg_error_from_syserror ();
407       blob->keys[n].off_kid = off;
408     }
409   else
410     blob->keys[n].off_kid = 0; /* Will be fixed up later */
411   blob->keys[n].flags = 0;
412   return 0;
413 }
414
415
416 static gpg_error_t
417 pgp_create_key_part (KEYBOXBLOB blob, keybox_openpgp_info_t info)
418 {
419   gpg_error_t err;
420   int n = 0;
421   struct _keybox_openpgp_key_info *kinfo;
422
423   err = pgp_create_key_part_single (blob, n++, &info->primary);
424   if (err)
425     return err;
426   if (info->nsubkeys)
427     for (kinfo = &info->subkeys; kinfo; kinfo = kinfo->next)
428       if ((err=pgp_create_key_part_single (blob, n++, kinfo)))
429         return err;
430
431   assert (n == blob->nkeys);
432   return 0;
433 }
434
435
436 static void
437 pgp_create_uid_part (KEYBOXBLOB blob, keybox_openpgp_info_t info)
438 {
439   int n = 0;
440   struct _keybox_openpgp_uid_info *u;
441
442   if (info->nuids)
443     {
444       for (u = &info->uids; u; u = u->next)
445         {
446           blob->uids[n].off = u->off;
447           blob->uids[n].len = u->len;
448           blob->uids[n].flags = 0;
449           blob->uids[n].validity = 0;
450           n++;
451         }
452     }
453
454   assert (n == blob->nuids);
455 }
456
457
458 static void
459 pgp_create_sig_part (KEYBOXBLOB blob, u32 *sigstatus)
460 {
461   int n;
462
463   for (n=0; n < blob->nsigs; n++)
464     {
465       blob->sigs[n] = sigstatus? sigstatus[n+1] : 0;
466     }
467 }
468
469
470 static int
471 pgp_create_blob_keyblock (KEYBOXBLOB blob,
472                           const unsigned char *image, size_t imagelen)
473 {
474   struct membuf *a = blob->buf;
475   int n;
476   u32 kbstart = a->len;
477
478   add_fixup (blob, 8, kbstart);
479
480   for (n = 0; n < blob->nuids; n++)
481     add_fixup (blob, blob->uids[n].off_addr, kbstart + blob->uids[n].off);
482
483   put_membuf (a, image, imagelen);
484
485   add_fixup (blob, 12, a->len - kbstart);
486   return 0;
487 }
488
489
490 \f
491 #ifdef KEYBOX_WITH_X509
492 /*
493    X.509 specific stuff
494  */
495
496 /* Write the raw certificate out */
497 static int
498 x509_create_blob_cert (KEYBOXBLOB blob, ksba_cert_t cert)
499 {
500   struct membuf *a = blob->buf;
501   const unsigned char *image;
502   size_t length;
503   u32 kbstart = a->len;
504
505   /* Store our offset for later fixup */
506   add_fixup (blob, 8, kbstart);
507
508   image = ksba_cert_get_image (cert, &length);
509   if (!image)
510     return gpg_error (GPG_ERR_GENERAL);
511   put_membuf (a, image, length);
512
513   add_fixup (blob, 12, a->len - kbstart);
514   return 0;
515 }
516
517 #endif /*KEYBOX_WITH_X509*/
518
519 /* Write a stored keyID out to the buffer */
520 static void
521 write_stored_kid (KEYBOXBLOB blob, int seqno)
522 {
523   struct keyid_list *r;
524
525   for ( r = blob->temp_kids; r; r = r->next )
526     {
527       if (r->seqno == seqno )
528         {
529           put_membuf (blob->buf, r->kid, 8);
530           return;
531         }
532     }
533   never_reached ();
534 }
535
536 /* Release a list of key IDs */
537 static void
538 release_kid_list (struct keyid_list *kl)
539 {
540   struct keyid_list *r, *r2;
541
542   for ( r = kl; r; r = r2 )
543     {
544       r2 = r->next;
545       xfree (r);
546     }
547 }
548
549
550 /* Create a new blob header.  If WANT_FPR32 is set a version 2 blob is
551  * created.  */
552 static int
553 create_blob_header (KEYBOXBLOB blob, int blobtype, int as_ephemeral,
554                     int want_fpr32)
555 {
556   struct membuf *a = blob->buf;
557   int i;
558
559   put32 ( a, 0 ); /* blob length, needs fixup */
560   put8 ( a, blobtype);
561   put8 ( a, want_fpr32? 2:1 );  /* blob type version */
562   put16 ( a, as_ephemeral? 2:0 ); /* blob flags */
563
564   put32 ( a, 0 ); /* offset to the raw data, needs fixup */
565   put32 ( a, 0 ); /* length of the raw data, needs fixup */
566
567   put16 ( a, blob->nkeys );
568   if (want_fpr32)
569     put16 ( a, 32 + 2 + 2 + 20);  /* size of key info */
570   else
571     put16 ( a, 20 + 4 + 2 + 2 );  /* size of key info */
572   for ( i=0; i < blob->nkeys; i++ )
573     {
574       if (want_fpr32)
575         {
576           put_membuf (a, blob->keys[i].fpr, blob->keys[i].fprlen);
577           blob->keys[i].off_kid_addr = a->len;
578           if (blob->keys[i].fprlen == 32)
579             put16 ( a, (blob->keys[i].flags | 0x80));
580           else
581             put16 ( a, blob->keys[i].flags);
582           put16 ( a, 0 ); /* reserved */
583           /* FIXME: Put the real grip here instead of the filler.  */
584           put_membuf (a, "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0", 20);
585         }
586       else
587         {
588           log_assert (blob->keys[i].fprlen <= 20);
589           put_membuf (a, blob->keys[i].fpr, 20);
590           blob->keys[i].off_kid_addr = a->len;
591           put32 ( a, 0 ); /* offset to keyid, fixed up later */
592           put16 ( a, blob->keys[i].flags );
593           put16 ( a, 0 ); /* reserved */
594         }
595     }
596
597   put16 (a, blob->seriallen); /*fixme: check that it fits into 16 bits*/
598   if (blob->serial)
599     put_membuf (a, blob->serial, blob->seriallen);
600
601   put16 ( a, blob->nuids );
602   put16 ( a, 4 + 4 + 2 + 1 + 1 );  /* size of uid info */
603   for (i=0; i < blob->nuids; i++)
604     {
605       blob->uids[i].off_addr = a->len;
606       put32 ( a, 0 ); /* offset to userid, fixed up later */
607       put32 ( a, blob->uids[i].len );
608       put16 ( a, blob->uids[i].flags );
609       put8  ( a, 0 ); /* validity */
610       put8  ( a, 0 ); /* reserved */
611     }
612
613   put16 ( a, blob->nsigs );
614   put16 ( a, 4 );  /* size of sig info */
615   for (i=0; i < blob->nsigs; i++)
616     {
617       put32 ( a, blob->sigs[i]);
618     }
619
620   put8 ( a, 0 );  /* assigned ownertrust */
621   put8 ( a, 0 );  /* validity of all user IDs */
622   put16 ( a, 0 );  /* reserved */
623   put32 ( a, 0 );  /* time of next recheck */
624   put32 ( a, 0 );  /* newest timestamp (none) */
625   put32 ( a, make_timestamp() );  /* creation time */
626   put32 ( a, 0 );  /* size of reserved space */
627   /* reserved space (which is currently of size 0) */
628
629   /* space where we write keyIDs and other stuff so that the
630      pointers can actually point to somewhere */
631   if (blobtype == KEYBOX_BLOBTYPE_PGP && !want_fpr32)
632     {
633       /* For version 1 blobs, we need to store the keyids for all v3
634        * keys because those key IDs are not part of the fingerprint.
635        * While we are doing that, we fixup all the keyID offsets.  For
636        * version 2 blobs (which can't carry v3 keys) we compute the
637        * keyids in the fly because they are just stripped down
638        * fingerprints.  */
639       for (i=0; i < blob->nkeys; i++ )
640         {
641           if (blob->keys[i].off_kid)
642             { /* this is a v3 one */
643               add_fixup (blob, blob->keys[i].off_kid_addr, a->len);
644               write_stored_kid (blob, blob->keys[i].off_kid);
645             }
646           else
647             { /* the better v4 key IDs - just store an offset 8 bytes back */
648               add_fixup (blob, blob->keys[i].off_kid_addr,
649                          blob->keys[i].off_kid_addr - 8);
650             }
651         }
652     }
653
654   if (blobtype == KEYBOX_BLOBTYPE_X509)
655     {
656       /* We don't want to point to ASN.1 encoded UserIDs (DNs) but to
657          the utf-8 string representation of them */
658       for (i=0; i < blob->nuids; i++ )
659         {
660           if (blob->uids[i].name)
661             { /* this is a v3 one */
662               add_fixup (blob, blob->uids[i].off_addr, a->len);
663               put_membuf (blob->buf, blob->uids[i].name, blob->uids[i].len);
664             }
665         }
666     }
667
668     return 0;
669 }
670
671
672
673 static int
674 create_blob_trailer (KEYBOXBLOB blob)
675 {
676   (void)blob;
677   return 0;
678 }
679
680
681 static int
682 create_blob_finish (KEYBOXBLOB blob)
683 {
684   struct membuf *a = blob->buf;
685   unsigned char *p;
686   unsigned char *pp;
687   size_t n;
688
689   /* Write a placeholder for the checksum */
690   put_membuf (a, NULL, 20);
691
692   /* get the memory area */
693   n = 0; /* (Just to avoid compiler warning.) */
694   p = get_membuf (a, &n);
695   if (!p)
696     return gpg_error (GPG_ERR_ENOMEM);
697   assert (n >= 20);
698
699   /* fixup the length */
700   add_fixup (blob, 0, n);
701
702   /* do the fixups */
703   if (blob->fixup_out_of_core)
704     {
705       xfree (p);
706       return gpg_error (GPG_ERR_ENOMEM);
707     }
708
709   {
710     struct fixup_list *fl, *next;
711     for (fl = blob->fixups; fl; fl = next)
712       {
713         assert (fl->off+4 <= n);
714         p[fl->off+0] = fl->val >> 24;
715         p[fl->off+1] = fl->val >> 16;
716         p[fl->off+2] = fl->val >>  8;
717         p[fl->off+3] = fl->val;
718         next = fl->next;
719         xfree (fl);
720       }
721     blob->fixups = NULL;
722   }
723
724   /* Compute and store the SHA-1 checksum. */
725   gcry_md_hash_buffer (GCRY_MD_SHA1, p + n - 20, p, n - 20);
726
727   pp = xtrymalloc (n);
728   if ( !pp )
729     {
730       xfree (p);
731       return gpg_error_from_syserror ();
732     }
733   memcpy (pp , p, n);
734   xfree (p);
735   blob->blob = pp;
736   blob->bloblen = n;
737
738   return 0;
739 }
740
741
742 \f
743 gpg_error_t
744 _keybox_create_openpgp_blob (KEYBOXBLOB *r_blob,
745                              keybox_openpgp_info_t info,
746                              const unsigned char *image,
747                              size_t imagelen,
748                              int as_ephemeral)
749 {
750   gpg_error_t err;
751   KEYBOXBLOB blob;
752   int need_fpr32 = 0;
753
754   *r_blob = NULL;
755
756
757   /* Check whether we need a blob with 32 bit fingerprints. We could
758    * use this always but for backward compatiblity we do this only for
759    * v5 keys.  */
760   if (info->primary.version == 5)
761     need_fpr32 = 1;
762   else
763     {
764       struct _keybox_openpgp_key_info *kinfo;
765       for (kinfo = &info->subkeys; kinfo; kinfo = kinfo->next)
766         if (kinfo->version == 5)
767           {
768             need_fpr32 = 1;
769             break;
770           }
771     }
772
773   blob = xtrycalloc (1, sizeof *blob);
774   if (!blob)
775     return gpg_error_from_syserror ();
776
777   blob->nkeys = 1 + info->nsubkeys;
778   blob->keys = xtrycalloc (blob->nkeys, sizeof *blob->keys );
779   if (!blob->keys)
780     {
781       err = gpg_error_from_syserror ();
782       goto leave;
783     }
784
785   blob->nuids = info->nuids;
786   if (blob->nuids)
787     {
788       blob->uids = xtrycalloc (blob->nuids, sizeof *blob->uids );
789       if (!blob->uids)
790         {
791           err = gpg_error_from_syserror ();
792           goto leave;
793         }
794     }
795
796   blob->nsigs = info->nsigs;
797   if (blob->nsigs)
798     {
799       blob->sigs = xtrycalloc (blob->nsigs, sizeof *blob->sigs );
800       if (!blob->sigs)
801         {
802           err = gpg_error_from_syserror ();
803           goto leave;
804         }
805     }
806
807   err = pgp_create_key_part (blob, info);
808   if (err)
809     goto leave;
810   pgp_create_uid_part (blob, info);
811   pgp_create_sig_part (blob, NULL);
812
813   init_membuf (&blob->bufbuf, 1024);
814   blob->buf = &blob->bufbuf;
815   err = create_blob_header (blob, KEYBOX_BLOBTYPE_PGP,
816                             as_ephemeral, need_fpr32);
817   if (err)
818     goto leave;
819   err = pgp_create_blob_keyblock (blob, image, imagelen);
820   if (err)
821     goto leave;
822   err = create_blob_trailer (blob);
823   if (err)
824     goto leave;
825   err = create_blob_finish (blob);
826   if (err)
827     goto leave;
828
829  leave:
830   release_kid_list (blob->temp_kids);
831   blob->temp_kids = NULL;
832   if (err)
833     _keybox_release_blob (blob);
834   else
835     *r_blob = blob;
836   return err;
837 }
838
839
840 #ifdef KEYBOX_WITH_X509
841
842 /* Return an allocated string with the email address extracted from a
843    DN.  Note hat we use this code also in ../sm/keylist.c.  */
844 static char *
845 x509_email_kludge (const char *name)
846 {
847   const char *p, *string;
848   unsigned char *buf;
849   int n;
850
851   string = name;
852   for (;;)
853     {
854       p = strstr (string, "1.2.840.113549.1.9.1=#");
855       if (!p)
856         return NULL;
857       if (p == name || (p > string+1 && p[-1] == ',' && p[-2] != '\\'))
858         {
859           name = p + 22;
860           break;
861         }
862       string = p + 22;
863     }
864
865
866   /* This looks pretty much like an email address in the subject's DN
867      we use this to add an additional user ID entry.  This way,
868      OpenSSL generated keys get a nicer and usable listing.  */
869   for (n=0, p=name; hexdigitp (p) && hexdigitp (p+1); p +=2, n++)
870     ;
871   if (!n)
872     return NULL;
873   buf = xtrymalloc (n+3);
874   if (!buf)
875     return NULL; /* oops, out of core */
876   *buf = '<';
877   for (n=1, p=name; hexdigitp (p); p +=2, n++)
878     buf[n] = xtoi_2 (p);
879   buf[n++] = '>';
880   buf[n] = 0;
881   return (char*)buf;
882 }
883
884
885
886 /* Note: We should move calculation of the digest into libksba and
887    remove that parameter */
888 int
889 _keybox_create_x509_blob (KEYBOXBLOB *r_blob, ksba_cert_t cert,
890                           unsigned char *sha1_digest, int as_ephemeral)
891 {
892   int i, rc = 0;
893   KEYBOXBLOB blob;
894   unsigned char *sn;
895   char *p;
896   char **names = NULL;
897   size_t max_names;
898
899   *r_blob = NULL;
900   blob = xtrycalloc (1, sizeof *blob);
901   if( !blob )
902     return gpg_error_from_syserror ();
903
904   sn = ksba_cert_get_serial (cert);
905   if (sn)
906     {
907       size_t n, len;
908       n = gcry_sexp_canon_len (sn, 0, NULL, NULL);
909       if (n < 2)
910         {
911           xfree (sn);
912           return gpg_error (GPG_ERR_GENERAL);
913         }
914       blob->serialbuf = sn;
915       sn++; n--; /* skip '(' */
916       for (len=0; n && *sn && *sn != ':' && digitp (sn); n--, sn++)
917         len = len*10 + atoi_1 (sn);
918       if (*sn != ':')
919         {
920           xfree (blob->serialbuf);
921           blob->serialbuf = NULL;
922           return gpg_error (GPG_ERR_GENERAL);
923         }
924       sn++;
925       blob->serial = sn;
926       blob->seriallen = len;
927     }
928
929   blob->nkeys = 1;
930
931   /* create list of names */
932   blob->nuids = 0;
933   max_names = 100;
934   names = xtrymalloc (max_names * sizeof *names);
935   if (!names)
936     {
937       rc = gpg_error_from_syserror ();
938       goto leave;
939     }
940
941   p = ksba_cert_get_issuer (cert, 0);
942   if (!p)
943     {
944       rc =  gpg_error (GPG_ERR_MISSING_VALUE);
945       goto leave;
946     }
947   names[blob->nuids++] = p;
948   for (i=0; (p = ksba_cert_get_subject (cert, i)); i++)
949     {
950       if (blob->nuids >= max_names)
951         {
952           char **tmp;
953
954           max_names += 100;
955           tmp = xtryrealloc (names, max_names * sizeof *names);
956           if (!tmp)
957             {
958               rc = gpg_error_from_syserror ();
959               goto leave;
960             }
961           names = tmp;
962         }
963       names[blob->nuids++] = p;
964       if (!i && (p=x509_email_kludge (p)))
965         names[blob->nuids++] = p; /* due to !i we don't need to check bounds*/
966     }
967
968   /* space for signature information */
969   blob->nsigs = 1;
970
971   blob->keys = xtrycalloc (blob->nkeys, sizeof *blob->keys );
972   blob->uids = xtrycalloc (blob->nuids, sizeof *blob->uids );
973   blob->sigs = xtrycalloc (blob->nsigs, sizeof *blob->sigs );
974   if (!blob->keys || !blob->uids || !blob->sigs)
975     {
976       rc = gpg_error (GPG_ERR_ENOMEM);
977       goto leave;
978     }
979
980   memcpy (blob->keys[0].fpr, sha1_digest, 20);
981   blob->keys[0].off_kid = 0; /* We don't have keyids */
982   blob->keys[0].flags = 0;
983
984   /* issuer and subject names */
985   for (i=0; i < blob->nuids; i++)
986     {
987       blob->uids[i].name = names[i];
988       blob->uids[i].len = strlen(names[i]);
989       names[i] = NULL;
990       blob->uids[i].flags = 0;
991       blob->uids[i].validity = 0;
992     }
993   xfree (names);
994   names = NULL;
995
996   /* signatures */
997   blob->sigs[0] = 0;    /* not yet checked */
998
999   /* Create a temporary buffer for further processing */
1000   init_membuf (&blob->bufbuf, 1024);
1001   blob->buf = &blob->bufbuf;
1002   /* write out what we already have */
1003   rc = create_blob_header (blob, KEYBOX_BLOBTYPE_X509, as_ephemeral, 0);
1004   if (rc)
1005     goto leave;
1006   rc = x509_create_blob_cert (blob, cert);
1007   if (rc)
1008     goto leave;
1009   rc = create_blob_trailer (blob);
1010   if (rc)
1011     goto leave;
1012   rc = create_blob_finish ( blob );
1013   if (rc)
1014     goto leave;
1015
1016
1017  leave:
1018   release_kid_list (blob->temp_kids);
1019   blob->temp_kids = NULL;
1020   if (names)
1021     {
1022       for (i=0; i < blob->nuids; i++)
1023         xfree (names[i]);
1024       xfree (names);
1025     }
1026   if (rc)
1027     {
1028       _keybox_release_blob (blob);
1029       *r_blob = NULL;
1030     }
1031   else
1032     {
1033       *r_blob = blob;
1034     }
1035   return rc;
1036 }
1037 #endif /*KEYBOX_WITH_X509*/
1038
1039
1040 \f
1041 int
1042 _keybox_new_blob (KEYBOXBLOB *r_blob,
1043                   unsigned char *image, size_t imagelen, off_t off)
1044 {
1045   KEYBOXBLOB blob;
1046
1047   *r_blob = NULL;
1048   blob = xtrycalloc (1, sizeof *blob);
1049   if (!blob)
1050     return gpg_error_from_syserror ();
1051
1052   blob->blob = image;
1053   blob->bloblen = imagelen;
1054   blob->fileoffset = off;
1055   *r_blob = blob;
1056   return 0;
1057 }
1058
1059
1060 void
1061 _keybox_release_blob (KEYBOXBLOB blob)
1062 {
1063   int i;
1064   if (!blob)
1065     return;
1066   if (blob->buf)
1067     {
1068       size_t len;
1069       xfree (get_membuf (blob->buf, &len));
1070     }
1071   xfree (blob->keys );
1072   xfree (blob->serialbuf);
1073   for (i=0; i < blob->nuids; i++)
1074     xfree (blob->uids[i].name);
1075   xfree (blob->uids );
1076   xfree (blob->sigs );
1077   xfree (blob->blob );
1078   xfree (blob );
1079 }
1080
1081
1082
1083 const unsigned char *
1084 _keybox_get_blob_image ( KEYBOXBLOB blob, size_t *n )
1085 {
1086   *n = blob->bloblen;
1087   return blob->blob;
1088 }
1089
1090 off_t
1091 _keybox_get_blob_fileoffset (KEYBOXBLOB blob)
1092 {
1093   return blob->fileoffset;
1094 }
1095
1096
1097
1098 void
1099 _keybox_update_header_blob (KEYBOXBLOB blob, int for_openpgp)
1100 {
1101   if (blob->bloblen >= 32 && blob->blob[4] == KEYBOX_BLOBTYPE_HEADER)
1102     {
1103       u32 val = make_timestamp ();
1104
1105       /* Update the last maintenance run times tamp. */
1106       blob->blob[20]   = (val >> 24);
1107       blob->blob[20+1] = (val >> 16);
1108       blob->blob[20+2] = (val >>  8);
1109       blob->blob[20+3] = (val      );
1110
1111       if (for_openpgp)
1112         blob->blob[7] |= 0x02;  /* OpenPGP data may be available.  */
1113     }
1114 }