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