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