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