Two minor code cleanups and one NULL deref on error fix.
[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 (!info->nuids || !info->nsigs)
706     return gpg_error (GPG_ERR_BAD_PUBKEY);
707
708   /* If we have a signature status vector, check that the number of
709      elements matches the actual number of signatures.  */
710   if (sigstatus && sigstatus[0] != info->nsigs)
711     return gpg_error (GPG_ERR_INTERNAL);
712
713   blob = xtrycalloc (1, sizeof *blob);
714   if (!blob)
715     return gpg_error_from_syserror ();
716
717   blob->nkeys = 1 + info->nsubkeys;
718   blob->keys = xtrycalloc (blob->nkeys, sizeof *blob->keys );
719   if (!blob->keys)
720     {
721       err = gpg_error_from_syserror ();
722       goto leave;
723     }
724   blob->nuids = info->nuids;
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   blob->nsigs = info->nsigs;
732   blob->sigs = xtrycalloc (blob->nsigs, sizeof *blob->sigs );
733   if (!blob->sigs)
734     {
735       err = gpg_error_from_syserror ();
736       goto leave;
737     }
738
739   err = pgp_create_key_part (blob, info);
740   if (err)
741     goto leave;
742   pgp_create_uid_part (blob, info);
743   pgp_create_sig_part (blob, sigstatus);
744
745   init_membuf (&blob->bufbuf, 1024);
746   blob->buf = &blob->bufbuf;
747   err = create_blob_header (blob, BLOBTYPE_PGP, as_ephemeral);
748   if (err)
749     goto leave;
750   err = pgp_create_blob_keyblock (blob, image, imagelen);
751   if (err)
752     goto leave;
753   err = create_blob_trailer (blob);
754   if (err)
755     goto leave;
756   err = create_blob_finish (blob);
757   if (err)
758     goto leave;
759
760  leave:
761   release_kid_list (blob->temp_kids);
762   blob->temp_kids = NULL;
763   if (err)
764     _keybox_release_blob (blob);
765   else
766     *r_blob = blob;
767   return err;
768 }
769
770
771 #ifdef KEYBOX_WITH_X509
772
773 /* Return an allocated string with the email address extracted from a
774    DN.  Note hat we use this code also in ../sm/keylist.c.  */
775 static char *
776 x509_email_kludge (const char *name)
777 {
778   const char *p, *string;
779   unsigned char *buf;
780   int n;
781
782   string = name;
783   for (;;)
784     {
785       p = strstr (string, "1.2.840.113549.1.9.1=#");
786       if (!p)
787         return NULL;
788       if (p == name || (p > string+1 && p[-1] == ',' && p[-2] != '\\'))
789         {
790           name = p + 22;
791           break;
792         }
793       string = p + 22;
794     }
795
796
797   /* This looks pretty much like an email address in the subject's DN
798      we use this to add an additional user ID entry.  This way,
799      OpenSSL generated keys get a nicer and usable listing.  */
800   for (n=0, p=name; hexdigitp (p) && hexdigitp (p+1); p +=2, n++)
801     ;
802   if (!n)
803     return NULL;
804   buf = xtrymalloc (n+3);
805   if (!buf)
806     return NULL; /* oops, out of core */
807   *buf = '<';
808   for (n=1, p=name; hexdigitp (p); p +=2, n++)
809     buf[n] = xtoi_2 (p);
810   buf[n++] = '>';
811   buf[n] = 0;
812   return (char*)buf;
813 }
814
815
816
817 /* Note: We should move calculation of the digest into libksba and
818    remove that parameter */
819 int
820 _keybox_create_x509_blob (KEYBOXBLOB *r_blob, ksba_cert_t cert,
821                           unsigned char *sha1_digest, int as_ephemeral)
822 {
823   int i, rc = 0;
824   KEYBOXBLOB blob;
825   unsigned char *sn;
826   char *p;
827   char **names = NULL;
828   size_t max_names;
829
830   *r_blob = NULL;
831   blob = xtrycalloc (1, sizeof *blob);
832   if( !blob )
833     return gpg_error_from_syserror ();
834
835   sn = ksba_cert_get_serial (cert);
836   if (sn)
837     {
838       size_t n, len;
839       n = gcry_sexp_canon_len (sn, 0, NULL, NULL);
840       if (n < 2)
841         {
842           xfree (sn);
843           return gpg_error (GPG_ERR_GENERAL);
844         }
845       blob->serialbuf = sn;
846       sn++; n--; /* skip '(' */
847       for (len=0; n && *sn && *sn != ':' && digitp (sn); n--, sn++)
848         len = len*10 + atoi_1 (sn);
849       if (*sn != ':')
850         {
851           xfree (blob->serialbuf);
852           blob->serialbuf = NULL;
853           return gpg_error (GPG_ERR_GENERAL);
854         }
855       sn++;
856       blob->serial = sn;
857       blob->seriallen = len;
858     }
859
860   blob->nkeys = 1;
861
862   /* create list of names */
863   blob->nuids = 0;
864   max_names = 100;
865   names = xtrymalloc (max_names * sizeof *names);
866   if (!names)
867     {
868       rc = gpg_error_from_syserror ();
869       goto leave;
870     }
871
872   p = ksba_cert_get_issuer (cert, 0);
873   if (!p)
874     {
875       rc =  gpg_error (GPG_ERR_MISSING_VALUE);
876       goto leave;
877     }
878   names[blob->nuids++] = p;
879   for (i=0; (p = ksba_cert_get_subject (cert, i)); i++)
880     {
881       if (blob->nuids >= max_names)
882         {
883           char **tmp;
884
885           max_names += 100;
886           tmp = xtryrealloc (names, max_names * sizeof *names);
887           if (!tmp)
888             {
889               rc = gpg_error_from_syserror ();
890               goto leave;
891             }
892           names = tmp;
893         }
894       names[blob->nuids++] = p;
895       if (!i && (p=x509_email_kludge (p)))
896         names[blob->nuids++] = p; /* due to !i we don't need to check bounds*/
897     }
898
899   /* space for signature information */
900   blob->nsigs = 1;
901
902   blob->keys = xtrycalloc (blob->nkeys, sizeof *blob->keys );
903   blob->uids = xtrycalloc (blob->nuids, sizeof *blob->uids );
904   blob->sigs = xtrycalloc (blob->nsigs, sizeof *blob->sigs );
905   if (!blob->keys || !blob->uids || !blob->sigs)
906     {
907       rc = gpg_error (GPG_ERR_ENOMEM);
908       goto leave;
909     }
910
911   memcpy (blob->keys[0].fpr, sha1_digest, 20);
912   blob->keys[0].off_kid = 0; /* We don't have keyids */
913   blob->keys[0].flags = 0;
914
915   /* issuer and subject names */
916   for (i=0; i < blob->nuids; i++)
917     {
918       blob->uids[i].name = names[i];
919       blob->uids[i].len = strlen(names[i]);
920       names[i] = NULL;
921       blob->uids[i].flags = 0;
922       blob->uids[i].validity = 0;
923     }
924   xfree (names);
925   names = NULL;
926
927   /* signatures */
928   blob->sigs[0] = 0;    /* not yet checked */
929
930   /* Create a temporary buffer for further processing */
931   init_membuf (&blob->bufbuf, 1024);
932   blob->buf = &blob->bufbuf;
933   /* write out what we already have */
934   rc = create_blob_header (blob, BLOBTYPE_X509, as_ephemeral);
935   if (rc)
936     goto leave;
937   rc = x509_create_blob_cert (blob, cert);
938   if (rc)
939     goto leave;
940   rc = create_blob_trailer (blob);
941   if (rc)
942     goto leave;
943   rc = create_blob_finish ( blob );
944   if (rc)
945     goto leave;
946
947
948  leave:
949   release_kid_list (blob->temp_kids);
950   blob->temp_kids = NULL;
951   if (names)
952     {
953       for (i=0; i < blob->nuids; i++)
954         xfree (names[i]);
955       xfree (names);
956     }
957   if (rc)
958     {
959       _keybox_release_blob (blob);
960       *r_blob = NULL;
961     }
962   else
963     {
964       *r_blob = blob;
965     }
966   return rc;
967 }
968 #endif /*KEYBOX_WITH_X509*/
969
970
971 \f
972 int
973 _keybox_new_blob (KEYBOXBLOB *r_blob,
974                   unsigned char *image, size_t imagelen, off_t off)
975 {
976   KEYBOXBLOB blob;
977
978   *r_blob = NULL;
979   blob = xtrycalloc (1, sizeof *blob);
980   if (!blob)
981     return gpg_error_from_syserror ();
982
983   blob->blob = image;
984   blob->bloblen = imagelen;
985   blob->fileoffset = off;
986   *r_blob = blob;
987   return 0;
988 }
989
990
991 void
992 _keybox_release_blob (KEYBOXBLOB blob)
993 {
994   int i;
995   if (!blob)
996     return;
997   /* hmmm: release membuf here?*/
998   xfree (blob->keys );
999   xfree (blob->serialbuf);
1000   for (i=0; i < blob->nuids; i++)
1001     xfree (blob->uids[i].name);
1002   xfree (blob->uids );
1003   xfree (blob->sigs );
1004   xfree (blob->blob );
1005   xfree (blob );
1006 }
1007
1008
1009
1010 const unsigned char *
1011 _keybox_get_blob_image ( KEYBOXBLOB blob, size_t *n )
1012 {
1013   *n = blob->bloblen;
1014   return blob->blob;
1015 }
1016
1017 off_t
1018 _keybox_get_blob_fileoffset (KEYBOXBLOB blob)
1019 {
1020   return blob->fileoffset;
1021 }
1022
1023
1024
1025 void
1026 _keybox_update_header_blob (KEYBOXBLOB blob)
1027 {
1028   if (blob->bloblen >= 32 && blob->blob[4] == BLOBTYPE_HEADER)
1029     {
1030       u32 val = make_timestamp ();
1031
1032       /* Update the last maintenance run times tamp. */
1033       blob->blob[20]   = (val >> 24);
1034       blob->blob[20+1] = (val >> 16);
1035       blob->blob[20+2] = (val >>  8);
1036       blob->blob[20+3] = (val      );
1037     }
1038 }