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 <https://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 }