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