* http.c (connect_server): [_WIN32] actually fill in the sin_addr so we
[gnupg.git] / kbx / keybox-blob.c
1 /* keybox-blob.c - KBX Blob handling
2  *      Copyright (C) 2000, 2001, 2002, 2003 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 2 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, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21
22 /* The keybox data formats
23
24 The KeyBox uses an augmented OpenPGP/X.509 key format.  This makes
25 random access to a keyblock/Certificate easier and also gives the
26 opportunity to store additional information (e.g. the fingerprint)
27 along with the key.  All integers are stored in network byte order,
28 offsets are counted from the beginning of the Blob.
29
30 The first record of a plain KBX file has a special format:
31
32  u32  length of the first record
33  byte Blob type (1)
34  byte version number (1)
35  byte reserved
36  byte reserved
37  u32  magic 'KBXf'
38  byte pgp_marginals  used for validity calculation of this file
39  byte pgp_completes  ditto.
40  byte pgp_cert_depth ditto.
41
42 The OpenPGP and X.509 blob are verry similiar, things which are
43 X.509 specific are noted like [X.509: xxx]
44
45  u32  length of this blob (including these 4 bytes)
46  byte Blob type (2) [X509: 3]
47  byte version number of this blob type (1)
48  u16  Blob flags
49         bit 0 = contains secret key material
50         bit 1 = ephemeral blob (e.g. used while quering external resources)
51
52  u32  offset to the OpenPGP keyblock or X509 DER encoded certificate
53  u32  and its length
54  u16  number of keys (at least 1!) [X509: always 1]
55  u16  size of additional key information
56  n times:
57    b20  The keys fingerprint
58         (fingerprints are always 20 bytes, MD5 left padded with zeroes)
59    u32  offset to the n-th key's keyID (a keyID is always 8 byte)
60         or 0 if not known which is the case opnly for X509.
61    u16  special key flags
62          bit 0 =
63    u16  reserved
64  u16  size of serialnumber(may be zero) 
65    n  u16 (see above) bytes of serial number
66  u16  number of user IDs
67  u16  size of additional user ID information
68  n times:
69    u32  offset to the n-th user ID
70    u32  length of this user ID.
71    u16  special user ID flags.
72          bit 0 =
73    byte validity
74    byte reserved
75    [For X509, the first user ID is the ISsuer, the second the subject
76    and the others are subjectAltNames]
77  u16  number of signatures
78  u16  size of signature information (4)
79    u32  expiration time of signature with some special values:
80         0x00000000 = not checked
81         0x00000001 = missing key
82         0x00000002 = bad signature
83         0x10000000 = valid and expires at some date in 1978.
84         0xffffffff = valid and does not expire
85  u8     assigned ownertrust [X509: no used]
86  u8     all_validity        [X509: no used]
87  u16    reserved
88  u32    recheck_after
89  u32    Newest timestamp in the keyblock (useful for KS syncronsiation?)
90  u32    Blob created at
91  u32    size of reserved space (not including this field)
92       reserved space
93
94     Here we might want to put other data
95
96     Here comes the keyblock
97
98     maybe we put a signature here later.
99
100  b16    MD5 checksum  (useful for KS syncronisation), we might also want to use
101     a mac here.
102  b4    resevered
103
104 */
105
106
107 #include <config.h>
108 #include <stdio.h>
109 #include <stdlib.h>
110 #include <string.h>
111 #include <errno.h>
112 #include <assert.h>
113
114 #include "keybox-defs.h"
115 #include <gcrypt.h>
116
117 #ifdef KEYBOX_WITH_OPENPGP
118 /* include stuff to parse the packets */
119 #endif
120 #ifdef KEYBOX_WITH_X509
121 #include <ksba.h>
122 #endif
123
124
125
126 /* special values of the signature status */
127 #define SF_NONE(a)  ( !(a) )
128 #define SF_NOKEY(a) ((a) & (1<<0))
129 #define SF_BAD(a)   ((a) & (1<<1))
130 #define SF_VALID(a) ((a) & (1<<29))
131
132
133 struct membuf {
134   size_t len;
135   size_t size;
136   char *buf;
137   int out_of_core;
138 };
139
140
141 /*  #if MAX_FINGERPRINT_LEN < 20 */
142 /*    #error fingerprints are 20 bytes */
143 /*  #endif */
144
145 struct keyboxblob_key {
146   char   fpr[20];
147   u32    off_kid;
148   ulong  off_kid_addr;
149   u16    flags;
150 };
151 struct keyboxblob_uid {
152   ulong  off_addr;
153   char   *name;     /* used only with x509 */
154   u32    len;
155   u16    flags;
156   byte   validity;
157 };
158
159 struct keyid_list {
160     struct keyid_list *next;
161     int seqno;
162     byte kid[8];
163 };
164
165 struct fixup_list {
166     struct fixup_list *next;
167     u32 off;
168     u32 val;
169 };
170
171
172 struct keyboxblob {
173   byte *blob;
174   size_t bloblen;
175   off_t fileoffset;
176   
177   /* stuff used only by keybox_create_blob */
178   unsigned char *serialbuf;
179   const unsigned char *serial;
180   size_t seriallen;
181   int nkeys;
182   struct keyboxblob_key *keys;
183   int nuids;
184   struct keyboxblob_uid *uids;
185   int nsigs;
186   u32  *sigs;
187   struct fixup_list *fixups;
188   int fixup_out_of_core;
189   
190   struct keyid_list *temp_kids;
191   struct membuf bufbuf; /* temporary store for the blob */
192   struct membuf *buf; 
193 };
194
195
196 \f
197 /* A simple implemnation of a dynamic buffer.  Use init_membuf() to
198    create a buffer, put_membuf to append bytes and get_membuf to
199    release and return the buffer.  Allocation errors are detected but
200    only returned at the final get_membuf(), this helps not to clutter
201    the code with out of core checks.  */
202
203 static void
204 init_membuf (struct membuf *mb, int initiallen)
205 {
206   mb->len = 0;
207   mb->size = initiallen;
208   mb->out_of_core = 0;
209   mb->buf = xtrymalloc (initiallen);
210   if (!mb->buf)
211       mb->out_of_core = 1;
212 }
213
214 static void
215 put_membuf (struct membuf *mb, const void *buf, size_t len)
216 {
217   if (mb->out_of_core)
218     return;
219
220   if (mb->len + len >= mb->size)
221     {
222       char *p;
223       
224       mb->size += len + 1024;
225       p = xtryrealloc (mb->buf, mb->size);
226       if (!p)
227         {
228           mb->out_of_core = 1;
229           return;
230         }
231       mb->buf = p;
232     }
233   memcpy (mb->buf + mb->len, buf, len);
234   mb->len += len;
235 }
236
237 static void *
238 get_membuf (struct membuf *mb, size_t *len)
239 {
240   char *p;
241
242   if (mb->out_of_core)
243     {
244       xfree (mb->buf);
245       mb->buf = NULL;
246       return NULL;
247     }
248
249   p = mb->buf;
250   *len = mb->len;
251   mb->buf = NULL;
252   mb->out_of_core = 1; /* don't allow a reuse */
253   return p;
254 }
255
256
257 static void
258 put8 (struct membuf *mb, byte a )
259 {
260   put_membuf (mb, &a, 1);
261 }
262
263 static void
264 put16 (struct membuf *mb, u16 a )
265 {
266   unsigned char tmp[2];
267   tmp[0] = a>>8;
268   tmp[1] = a;
269   put_membuf (mb, tmp, 2);
270 }
271
272 static void
273 put32 (struct membuf *mb, u32 a )
274 {
275   unsigned char tmp[4];
276   tmp[0] = a>>24;
277   tmp[1] = a>>16;
278   tmp[2] = a>>8;
279   tmp[3] = a;
280   put_membuf (mb, tmp, 4);
281 }
282
283 \f
284 /* Store a value in the fixup list */
285 static void
286 add_fixup (KEYBOXBLOB blob, u32 off, u32 val)
287 {
288   struct fixup_list *fl;
289   
290   if (blob->fixup_out_of_core)
291     return;
292
293   fl = xtrycalloc(1, sizeof *fl);
294   if (!fl)
295     blob->fixup_out_of_core = 1;
296   else 
297     {
298       fl->off = off;
299       fl->val = val;
300       fl->next = blob->fixups;
301       blob->fixups = fl;
302     }
303 }
304
305 \f
306 /*
307  Some wrappers
308 */
309
310 static u32
311 make_timestamp (void)
312 {
313   return time(NULL);
314 }
315
316
317 \f
318 #ifdef KEYBOX_WITH_OPENPGP
319 /*
320   OpenPGP specific stuff 
321 */
322
323
324 /*
325   We must store the keyid at some place because we can't calculate the
326   offset yet. This is only used for v3 keyIDs.  Function returns an
327   index value for later fixup or -1 for out of core. The value must be
328   a non-zero value */
329 static int
330 pgp_temp_store_kid (KEYBOXBLOB blob, PKT_public_key *pk)
331 {
332   struct keyid_list *k, *r;
333   
334   k = xtrymalloc (sizeof *k); 
335   if (!k)
336     return -1;
337   k->kid[0] = pk->keyid[0] >> 24 ;
338   k->kid[1] = pk->keyid[0] >> 16 ;
339   k->kid[2] = pk->keyid[0] >>  8 ;
340   k->kid[3] = pk->keyid[0]         ;
341   k->kid[4] = pk->keyid[0] >> 24 ;
342   k->kid[5] = pk->keyid[0] >> 16 ;
343   k->kid[6] = pk->keyid[0] >>  8 ;
344   k->kid[7] = pk->keyid[0]         ;
345   k->seqno = 0;
346   k->next = blob->temp_kids;
347   blob->temp_kids = k;
348   for (r=k; r; r = r->next) 
349     k->seqno++;
350   
351   return k->seqno;
352 }
353
354 static int
355 pgp_create_key_part (KEYBOXBLOB blob, KBNODE keyblock)
356 {
357   KBNODE node;
358   size_t fprlen;
359   int n;
360
361   for (n=0, node = keyblock; node; node = node->next)
362     {
363       if ( node->pkt->pkttype == PKT_PUBLIC_KEY
364            || node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) 
365         {
366           PKT_public_key *pk = node->pkt->pkt.public_key;
367           char tmp[20];
368
369           fingerprint_from_pk (pk, tmp , &fprlen);
370           memcpy (blob->keys[n].fpr, tmp, 20);
371           if ( fprlen != 20 ) /*v3 fpr - shift right and fill with zeroes*/
372             {
373               assert (fprlen == 16);
374               memmove (blob->keys[n].fpr+4, blob->keys[n].fpr, 16);
375               memset (blob->keys[n].fpr, 0, 4);
376               blob->keys[n].off_kid = pgp_temp_store_kid (blob, pk);
377             }
378           else
379             {
380               blob->keys[n].off_kid = 0; /* will be fixed up later */
381             }
382           blob->keys[n].flags = 0;
383           n++;
384         }
385       else if ( node->pkt->pkttype == PKT_SECRET_KEY
386                   || node->pkt->pkttype == PKT_SECRET_SUBKEY ) 
387         {
388           never_reached (); /* actually not yet implemented */
389         }
390     }
391   assert (n == blob->nkeys);
392   return 0;
393 }
394
395 static int
396 pgp_create_uid_part (KEYBOXBLOB blob, KBNODE keyblock)
397 {
398   KBNODE node;
399   int n;
400
401   for (n=0, node = keyblock; node; node = node->next)
402     {
403       if (node->pkt->pkttype == PKT_USER_ID)
404         {
405           PKT_user_id *u = node->pkt->pkt.user_id;
406           
407           blob->uids[n].len = u->len;
408           blob->uids[n].flags = 0;
409           blob->uids[n].validity = 0;
410           n++;
411         }
412     }
413   assert (n == blob->nuids);
414   return 0;
415 }
416
417 static int
418 pgp_create_sig_part (KEYBOXBLOB blob, KBNODE keyblock)
419 {
420   KBNODE node;
421   int n;
422   
423   for (n=0, node = keyblock; node; node = node->next)
424     {
425       if (node->pkt->pkttype == PKT_SIGNATURE)
426         {
427           PKT_signature *sig = node->pkt->pkt.signature;
428           
429           blob->sigs[n] = 0;    /* FIXME: check the signature here */
430           n++;
431         }
432     }
433   assert( n == blob->nsigs );
434   return 0;
435 }
436
437 static int
438 pgp_create_blob_keyblock (KEYBOXBLOB blob, KBNODE keyblock)
439 {
440   struct membuf *a = blob->buf;
441   KBNODE node;
442   int rc;
443   int n;
444   u32 kbstart = a->len;
445
446   add_fixup (blob, kbstart);
447
448   for (n = 0, node = keyblock; node; node = node->next)
449     {
450       rc = build_packet ( a, node->pkt );
451       if ( rc ) {
452         gpg_log_error ("build_packet(%d) for keyboxblob failed: %s\n",
453                       node->pkt->pkttype, gpg_errstr(rc) );
454         return GPGERR_WRITE_FILE;
455       }
456       if ( node->pkt->pkttype == PKT_USER_ID ) 
457         {
458           PKT_user_id *u = node->pkt->pkt.user_id;
459           /* build_packet has set the offset of the name into u ;
460            * now we can do the fixup */
461           add_fixup (blob, blob->uids[n].off_addr, u->stored_at);
462           n++;
463         }
464     }
465   assert (n == blob->nuids);
466
467   add_fixup (blob, a->len - kbstart);
468   return 0;
469 }
470  
471 #endif /*KEYBOX_WITH_OPENPGP*/
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, KsbaCert 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     return 0;
636 }
637
638
639 static int
640 create_blob_finish (KEYBOXBLOB blob)
641 {
642   struct membuf *a = blob->buf;
643   byte *p;
644   char *pp;
645   int i;
646   size_t n;
647
648   /* write a placeholder for the checksum */
649   for (i = 0; i < 16; i++ )
650     put32 (a, 0);  /* Hmmm: why put32() ?? */
651   
652   /* get the memory area */
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   /* calculate and store the MD5 checksum */
678   gcry_md_hash_buffer (GCRY_MD_MD5, p + n - 16, p, n - 16);
679
680   pp = xtrymalloc (n);
681   if ( !pp )
682     return gpg_error (gpg_err_code_from_errno (errno));
683   memcpy (pp , p, n);
684   blob->blob = pp;
685   blob->bloblen = n;
686   
687   return 0;
688 }
689
690 \f
691 #ifdef KEYBOX_WITH_OPENPGP
692
693 int
694 _keybox_create_pgp_blob (KEYBOXBLOB *r_blob, KBNODE keyblock, int as_ephemeral)
695 {
696   int rc = 0;
697   KBNODE node;
698   KEYBOXBLOB blob;
699
700   *r_blob = NULL;
701   blob = xtrycalloc (1, sizeof *blob);
702   if (!blob)
703     return gpg_error (gpg_err_code_from_errno (errno));
704
705   /* fixme: Do some sanity checks on the keyblock */
706
707   /* count userids and keys so that we can allocate the arrays */
708   for (node = keyblock; node; node = node->next) 
709     {
710       switch (node->pkt->pkttype)
711         {
712         case PKT_PUBLIC_KEY:
713         case PKT_SECRET_KEY:
714         case PKT_PUBLIC_SUBKEY:
715         case PKT_SECRET_SUBKEY: blob->nkeys++; break;
716         case PKT_USER_ID:  blob->nuids++; break;
717         case PKT_SIGNATURE: blob->nsigs++; break;
718         default: break;
719         }
720     }
721
722   blob->keys = xtrycalloc (blob->nkeys, sizeof *blob->keys );
723   blob->uids = xtrycalloc (blob->nuids, sizeof *blob->uids );
724   blob->sigs = xtrycalloc (blob->nsigs, sizeof *blob->sigs );
725   if (!blob->keys || !blob->uids || !blob->sigs)
726     {
727       rc = gpg_error (GPG_ERR_ENOMEM);
728       goto leave;
729     }
730
731   rc = pgp_create_key_part ( blob, keyblock );
732   if (rc)
733     goto leave;
734   rc = pgp_create_uid_part ( blob, keyblock );
735   if (rc)
736     goto leave;
737   rc = pgp_create_sig_part ( blob, keyblock );
738   if (rc)
739     goto leave;
740   
741   init_membuf (&blob->bufbuf, 1024);
742   blob->buf = &blob->bufbuf;
743   rc = create_blob_header (blob, BLOBTYPE_OPENPGP, as_ephemeral);
744   if (rc)
745     goto leave;
746   rc = pgp_create_blob_keyblock (blob, keyblock);
747   if (rc)
748     goto leave;
749   rc = create_blob_trailer (blob);
750   if (rc)
751     goto leave;
752   rc = create_blob_finish ( blob );
753   if (rc)
754     goto leave;
755
756   
757  leave:
758   release_kid_list (blob->temp_kids);
759   blob->temp_kids = NULL;
760   if (rc)
761     {
762       keybox_release_blob (blob);
763       *r_blob = NULL;
764     }
765   else
766     {
767       *r_blob = blob;
768     }
769   return rc;
770 }
771 #endif /*KEYBOX_WITH_OPENPGP*/
772
773 #ifdef KEYBOX_WITH_X509
774
775 /* return an allocated string with the email address extracted from a
776    DN */
777 static char *
778 x509_email_kludge (const char *name)
779 {
780   const unsigned char *p;
781   unsigned char *buf;
782   int n;
783
784   if (strncmp (name, "1.2.840.113549.1.9.1=#", 22))
785     return NULL;
786   /* This looks pretty much like an email address in the subject's DN
787      we use this to add an additional user ID entry.  This way,
788      openSSL generated keys get a nicer and usable listing */
789   name += 22;    
790   for (n=0, p=name; hexdigitp (p) && hexdigitp (p+1); p +=2, n++)
791     ;
792   if (*p != '#' || !n)
793     return NULL;
794   buf = xtrymalloc (n+3);
795   if (!buf)
796     return NULL; /* oops, out of core */
797   *buf = '<';
798   for (n=1, p=name; *p != '#'; p +=2, n++)
799     buf[n] = xtoi_2 (p);
800   buf[n++] = '>';
801   buf[n] = 0;
802   return buf;
803 }
804
805
806
807 /* Note: We should move calculation of the digest into libksba and
808    remove that parameter */
809 int
810 _keybox_create_x509_blob (KEYBOXBLOB *r_blob, KsbaCert cert,
811                           unsigned char *sha1_digest, int as_ephemeral)
812 {
813   int i, rc = 0;
814   KEYBOXBLOB blob;
815   unsigned char *p;
816   unsigned char **names = NULL;
817   size_t max_names;
818
819   *r_blob = NULL;
820   blob = xtrycalloc (1, sizeof *blob);
821   if( !blob )
822     return gpg_error (gpg_err_code_from_errno (errno));
823
824   p = ksba_cert_get_serial (cert);
825   if (p)
826     {
827       size_t n, len;
828       n = gcry_sexp_canon_len (p, 0, NULL, NULL);
829       if (n < 2)
830         {
831           xfree (p);
832           return gpg_error (GPG_ERR_GENERAL);
833         }
834       blob->serialbuf = p;
835       p++; n--; /* skip '(' */
836       for (len=0; n && *p && *p != ':' && digitp (p); n--, p++)
837         len = len*10 + atoi_1 (p);
838       if (*p != ':')
839         {
840           xfree (blob->serialbuf);
841           blob->serialbuf = NULL;
842           return gpg_error (GPG_ERR_GENERAL);
843         }
844       p++;
845       blob->serial = p;
846       blob->seriallen = len;
847     }
848
849   blob->nkeys = 1;
850
851   /* create list of names */
852   blob->nuids = 0;
853   max_names = 100;
854   names = xtrymalloc (max_names * sizeof *names);
855   if (!names)
856     {
857       rc = gpg_error (gpg_err_code_from_errno (errno));
858       goto leave;
859     }
860   p = ksba_cert_get_issuer (cert, 0);
861   if (!p)
862     {
863       rc =  gpg_error (GPG_ERR_MISSING_VALUE);
864       goto leave;
865     }
866   names[blob->nuids++] = p;
867   for (i=0; (p = ksba_cert_get_subject (cert, i)); i++)
868     {
869
870       if (blob->nuids >= max_names)
871         {
872           unsigned char **tmp;
873           
874           max_names += 100;
875           tmp = xtryrealloc (names, max_names * sizeof *names);
876           if (!tmp)
877             {
878               rc = gpg_error (gpg_err_code_from_errno (errno));
879               goto leave;
880             }
881         }
882       names[blob->nuids++] = p;
883       if (!i && (p=x509_email_kludge (p)))
884         names[blob->nuids++] = p; /* due to !i we don't need to check bounds*/
885     }
886   
887   /* space for signature information */
888   blob->nsigs = 1; 
889
890   blob->keys = xtrycalloc (blob->nkeys, sizeof *blob->keys );
891   blob->uids = xtrycalloc (blob->nuids, sizeof *blob->uids );
892   blob->sigs = xtrycalloc (blob->nsigs, sizeof *blob->sigs );
893   if (!blob->keys || !blob->uids || !blob->sigs)
894     {
895       rc = gpg_error (GPG_ERR_ENOMEM);
896       goto leave;
897     }
898
899   memcpy (blob->keys[0].fpr, sha1_digest, 20);
900   blob->keys[0].off_kid = 0; /* We don't have keyids */
901   blob->keys[0].flags = 0;
902
903   /* issuer and subject names */
904   for (i=0; i < blob->nuids; i++)
905     {
906       blob->uids[i].name = names[i];
907       blob->uids[i].len = strlen(names[i]);
908       names[i] = NULL;
909       blob->uids[i].flags = 0;
910       blob->uids[i].validity = 0;
911     }
912   xfree (names);
913   names = NULL;
914
915   /* signatures */
916   blob->sigs[0] = 0;    /* not yet checked */
917
918   /* Create a temporary buffer for further processing */
919   init_membuf (&blob->bufbuf, 1024);
920   blob->buf = &blob->bufbuf;
921   /* write out what we already have */
922   rc = create_blob_header (blob, BLOBTYPE_X509, as_ephemeral);
923   if (rc)
924     goto leave;
925   rc = x509_create_blob_cert (blob, cert);
926   if (rc)
927     goto leave;
928   rc = create_blob_trailer (blob);
929   if (rc)
930     goto leave;
931   rc = create_blob_finish ( blob );
932   if (rc)
933     goto leave;
934
935   
936  leave:
937   release_kid_list (blob->temp_kids);
938   blob->temp_kids = NULL;
939   if (blob && names)
940     {
941       for (i=0; i < blob->nuids; i++)
942         xfree (names[i]); 
943     }
944   xfree (names);
945   if (rc)
946     {
947       _keybox_release_blob (blob);
948       *r_blob = NULL;
949     }
950   else
951     {
952       *r_blob = blob;
953     }
954   return rc;
955 }
956 #endif /*KEYBOX_WITH_X509*/
957
958
959 \f
960 int
961 _keybox_new_blob (KEYBOXBLOB *r_blob, char *image, size_t imagelen, off_t off)
962 {
963   KEYBOXBLOB blob;
964   
965   *r_blob = NULL;
966   blob = xtrycalloc (1, sizeof *blob);
967   if (!blob)
968     return gpg_error (gpg_err_code_from_errno (errno));
969
970   blob->blob = image;
971   blob->bloblen = imagelen;
972   blob->fileoffset = off;
973   *r_blob = blob;
974   return 0;
975 }
976
977 void
978 _keybox_release_blob (KEYBOXBLOB blob)
979 {
980   int i;
981   if (!blob)
982     return;
983   /* hmmm: release membuf here?*/
984   xfree (blob->keys );
985   xfree (blob->serialbuf);
986   for (i=0; i < blob->nuids; i++)
987     xfree (blob->uids[i].name);
988   xfree (blob->uids );
989   xfree (blob->sigs );
990   xfree (blob->blob );
991   xfree (blob );
992 }
993
994
995
996 const char *
997 _keybox_get_blob_image ( KEYBOXBLOB blob, size_t *n )
998 {
999   *n = blob->bloblen;
1000   return blob->blob;
1001 }
1002
1003 off_t
1004 _keybox_get_blob_fileoffset (KEYBOXBLOB blob)
1005 {
1006   return blob->fileoffset;
1007 }
1008