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