kbx/keybox-dump.c

   1 /* keybox-dump.c - Debug helpers
   2  *      Copyright (C) 2001, 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 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 #include <config.h>
  21 #include <stdlib.h>
  22 #include <stdio.h>
  23 #include <string.h>
  24 #include <errno.h>
  25
  26 #include "keybox-defs.h"
  27 #include <gcrypt.h>
  28
  29 /* Argg, we can't include ../common/util.h */
  30 char *bin2hexcolon (const void *buffer, size_t length, char *stringbuf);
  31
  32
  33 static ulong
  34 get32 (const byte *buffer)
  35 {
  36   ulong a;
  37   a =  *buffer << 24;
  38   a |= buffer[1] << 16;
  39   a |= buffer[2] << 8;
  40   a |= buffer[3];
  41   return a;
  42 }
  43
  44 static ulong
  45 get16 (const byte *buffer)
  46 {
  47   ulong a;
  48   a =  *buffer << 8;
  49   a |= buffer[1];
  50   return a;
  51 }
  52
  53 void
  54 print_string (FILE *fp, const byte *p, size_t n, int delim)
  55 {
  56   for ( ; n; n--, p++ )
  57     {
  58       if (*p < 0x20 || (*p >= 0x7f && *p < 0xa0) || *p == delim)
  59         {
  60           putc('\\', fp);
  61           if( *p == '\n' )
  62             putc('n', fp);
  63           else if( *p == '\r' )
  64             putc('r', fp);
  65           else if( *p == '\f' )
  66             putc('f', fp);
  67           else if( *p == '\v' )
  68             putc('v', fp);
  69           else if( *p == '\b' )
  70             putc('b', fp);
  71           else if( !*p )
  72             putc('0', fp);
  73           else
  74             fprintf(fp, "x%02x", *p );
  75         }
  76       else
  77         putc(*p, fp);
  78     }
  79 }
  80
  81
  82 static int
  83 dump_header_blob (const byte *buffer, size_t length, FILE *fp)
  84 {
  85   unsigned long n;
  86
  87   if (length < 32)
  88     {
  89       fprintf (fp, "[blob too short]\n");
  90       return -1;
  91     }
  92   fprintf (fp, "Version: %d\n", buffer[5]);
  93   if ( memcmp (buffer+8, "KBXf", 4))
  94     fprintf (fp, "[Error: invalid magic number]\n");
  95
  96   n = get32 (buffer+16);
  97   fprintf( fp, "created-at: %lu\n", n );
  98   n = get32 (buffer+20);
  99   fprintf( fp, "last-maint: %lu\n", n );
 100
 101   return 0;
 102 }
 103
 104 \f
 105 /* Dump one block to FP */
 106 int
 107 _keybox_dump_blob (KEYBOXBLOB blob, FILE *fp)
 108 {
 109   const byte *buffer;
 110   size_t length;
 111   int type;
 112   ulong n, nkeys, keyinfolen;
 113   ulong nuids, uidinfolen;
 114   ulong nsigs, siginfolen;
 115   ulong rawdata_off, rawdata_len;
 116   ulong nserial;
 117   const byte *p;
 118
 119   buffer = _keybox_get_blob_image (blob, &length);
 120
 121   if (length < 32)
 122     {
 123       fprintf (fp, "[blob too short]\n");
 124       return -1;
 125     }
 126
 127   n = get32( buffer );
 128   if (n > length)
 129     fprintf (fp, "[blob larger than length - output truncated]\n");
 130   else
 131     length = n;  /* ignore the rest */
 132
 133   fprintf (fp, "Length: %lu\n", n );
 134   type = buffer[4];
 135   switch (type)
 136     {
 137     case BLOBTYPE_EMPTY:
 138       fprintf (fp, "Type:   Empty\n");
 139       return 0;
 140
 141     case BLOBTYPE_HEADER:
 142       fprintf (fp, "Type:   Header\n");
 143       return dump_header_blob (buffer, length, fp);
 144     case BLOBTYPE_PGP:
 145       fprintf (fp, "Type:   OpenPGP\n");
 146       break;
 147     case BLOBTYPE_X509:
 148       fprintf (fp, "Type:   X.509\n");
 149       break;
 150     default:
 151       fprintf (fp, "Type:   %d\n", type);
 152       fprintf (fp, "[can't dump this blob type]\n");
 153       return 0;
 154     }
 155   fprintf (fp, "Version: %d\n", buffer[5]);
 156
 157   if (length < 40)
 158     {
 159       fprintf (fp, "[blob too short]\n");
 160       return -1;
 161     }
 162
 163   n = get16 (buffer + 6);
 164   fprintf( fp, "Blob-Flags: %04lX", n);
 165   if (n)
 166     {
 167       int any = 0;
 168
 169       fputs (" (", fp);
 170       if ((n & 1))
 171         {
 172           fputs ("secret", fp);
 173           any++;
 174         }
 175       if ((n & 2))
 176         {
 177           if (any)
 178             putc (',', fp);
 179           fputs ("ephemeral", fp);
 180           any++;
 181         }
 182       putc (')', fp);
 183     }
 184   putc ('\n', fp);
 185
 186   rawdata_off = get32 (buffer + 8);
 187   rawdata_len = get32 (buffer + 12);
 188
 189   fprintf( fp, "Data-Offset: %lu\n", rawdata_off );
 190   fprintf( fp, "Data-Length: %lu\n", rawdata_len );
 191   if (rawdata_off > length || rawdata_len > length
 192       || rawdata_off+rawdata_off > length)
 193     fprintf (fp, "[Error: raw data larger than blob]\n");
 194
 195   nkeys = get16 (buffer + 16);
 196   fprintf (fp, "Key-Count: %lu\n", nkeys );
 197   if (!nkeys)
 198     fprintf (fp, "[Error: no keys]\n");
 199   if (nkeys > 1 && type == BLOBTYPE_X509)
 200     fprintf (fp, "[Error: only one key allowed for X509]\n");
 201
 202   keyinfolen = get16 (buffer + 18 );
 203   fprintf (fp, "Key-Info-Length: %lu\n", keyinfolen);
 204   /* fixme: check bounds */
 205   p = buffer + 20;
 206   for (n=0; n < nkeys; n++, p += keyinfolen)
 207     {
 208       int i;
 209       ulong kidoff, kflags;
 210
 211       fprintf (fp, "Key-Fpr[%lu]: ", n );
 212       for (i=0; i < 20; i++ )
 213         fprintf (fp, "%02X", p[i]);
 214       kidoff = get32 (p + 20);
 215       fprintf (fp, "\nKey-Kid-Off[%lu]: %lu\n", n, kidoff );
 216       fprintf (fp, "Key-Kid[%lu]: ", n );
 217       /* fixme: check bounds */
 218       for (i=0; i < 8; i++ )
 219         fprintf (fp, "%02X", buffer[kidoff+i] );
 220       kflags = get16 (p + 24 );
 221       fprintf( fp, "\nKey-Flags[%lu]: %04lX\n", n, kflags);
 222     }
 223
 224   /* serial number */
 225   fputs ("Serial-No: ", fp);
 226   nserial = get16 (p);
 227   p += 2;
 228   if (!nserial)
 229     fputs ("none", fp);
 230   else
 231     {
 232       for (; nserial; nserial--, p++)
 233         fprintf (fp, "%02X", *p);
 234     }
 235   putc ('\n', fp);
 236
 237   /* user IDs */
 238   nuids = get16 (p);
 239   fprintf (fp, "Uid-Count: %lu\n", nuids );
 240   uidinfolen = get16  (p + 2);
 241   fprintf (fp, "Uid-Info-Length: %lu\n", uidinfolen);
 242   /* fixme: check bounds */
 243   p += 4;
 244   for (n=0; n < nuids; n++, p += uidinfolen)
 245     {
 246       ulong uidoff, uidlen, uflags;
 247
 248       uidoff = get32( p );
 249       uidlen = get32( p+4 );
 250       if (type == BLOBTYPE_X509 && !n)
 251         {
 252           fprintf (fp, "Issuer-Off: %lu\n", uidoff );
 253           fprintf (fp, "Issuer-Len: %lu\n", uidlen );
 254           fprintf (fp, "Issuer: \"");
 255         }
 256       else if (type == BLOBTYPE_X509 && n == 1)
 257         {
 258           fprintf (fp, "Subject-Off: %lu\n", uidoff );
 259           fprintf (fp, "Subject-Len: %lu\n", uidlen );
 260           fprintf (fp, "Subject: \"");
 261         }
 262       else
 263         {
 264           fprintf (fp, "Uid-Off[%lu]: %lu\n", n, uidoff );
 265           fprintf (fp, "Uid-Len[%lu]: %lu\n", n, uidlen );
 266           fprintf (fp, "Uid[%lu]: \"", n );
 267         }
 268       print_string (fp, buffer+uidoff, uidlen, '\"');
 269       fputs ("\"\n", fp);
 270       uflags = get16 (p + 8);
 271       if (type == BLOBTYPE_X509 && !n)
 272         {
 273           fprintf (fp, "Issuer-Flags: %04lX\n", uflags );
 274           fprintf (fp, "Issuer-Validity: %d\n", p[10] );
 275         }
 276       else if (type == BLOBTYPE_X509 && n == 1)
 277         {
 278           fprintf (fp, "Subject-Flags: %04lX\n", uflags );
 279           fprintf (fp, "Subject-Validity: %d\n", p[10] );
 280         }
 281       else
 282         {
 283           fprintf (fp, "Uid-Flags[%lu]: %04lX\n", n, uflags );
 284           fprintf (fp, "Uid-Validity[%lu]: %d\n", n, p[10] );
 285         }
 286     }
 287
 288   nsigs = get16 (p);
 289   fprintf (fp, "Sig-Count: %lu\n", nsigs );
 290   siginfolen = get16 (p + 2);
 291   fprintf (fp, "Sig-Info-Length: %lu\n", siginfolen );
 292   /* fixme: check bounds  */
 293   p += 4;
 294   for (n=0; n < nsigs; n++, p += siginfolen)
 295     {
 296       ulong sflags;
 297
 298       sflags = get32 (p);
 299       fprintf (fp, "Sig-Expire[%lu]: ", n );
 300       if (!sflags)
 301         fputs ("[not checked]", fp);
 302       else if (sflags == 1 )
 303         fputs ("[missing key]", fp);
 304       else if (sflags == 2 )
 305         fputs ("[bad signature]", fp);
 306       else if (sflags < 0x10000000)
 307         fprintf (fp, "[bad flag %0lx]", sflags);
 308       else if (sflags == 0xffffffff)
 309         fputs ("0", fp );
 310       else
 311         fputs ("a time"/*strtimestamp( sflags )*/, fp );
 312       putc ('\n', fp );
 313     }
 314
 315   fprintf (fp, "Ownertrust: %d\n", p[0] );
 316   fprintf (fp, "All-Validity: %d\n", p[1] );
 317   p += 4;
 318   n = get32 (p); p += 4;
 319   fprintf (fp, "Recheck-After: %lu\n", n );
 320   n = get32 (p ); p += 4;
 321   fprintf( fp, "Latest-Timestamp: %lu\n", n );
 322   n = get32 (p ); p += 4;
 323   fprintf (fp, "Created-At: %lu\n", n );
 324   n = get32 (p ); p += 4;
 325   fprintf (fp, "Reserved-Space: %lu\n", n );
 326
 327   /* check that the keyblock is at the correct offset and other bounds */
 328   /*fprintf (fp, "Blob-Checksum: [MD5-hash]\n");*/
 329   return 0;
 330 }
 331
 332
 333 /* Compute the SHA_1 checksum of teh rawdata in BLOB and aput it into
 334    DIGEST. */
 335 static int
 336 hash_blob_rawdata (KEYBOXBLOB blob, unsigned char *digest)
 337 {
 338   const unsigned char *buffer;
 339   size_t n, length;
 340   int type;
 341   ulong rawdata_off, rawdata_len;
 342
 343   buffer = _keybox_get_blob_image (blob, &length);
 344
 345   if (length < 32)
 346     return -1;
 347   n = get32 (buffer);
 348   if (n < length)
 349     length = n;  /* Blob larger than length in header - ignore the rest. */
 350
 351   type = buffer[4];
 352   switch (type)
 353     {
 354     case BLOBTYPE_PGP:
 355     case BLOBTYPE_X509:
 356       break;
 357
 358     case BLOBTYPE_EMPTY:
 359     case BLOBTYPE_HEADER:
 360     default:
 361       memset (digest, 0, 20);
 362       return 0;
 363     }
 364
 365   if (length < 40)
 366     return -1;
 367
 368   rawdata_off = get32 (buffer + 8);
 369   rawdata_len = get32 (buffer + 12);
 370
 371   if (rawdata_off > length || rawdata_len > length
 372       || rawdata_off+rawdata_off > length)
 373     return -1; /* Out of bounds.  */
 374
 375   gcry_md_hash_buffer (GCRY_MD_SHA1, digest, buffer+rawdata_off, rawdata_len);
 376   return 0;
 377 }
 378
 379
 380 struct file_stats_s
 381 {
 382   unsigned long too_short_blobs;
 383   unsigned long too_large_blobs;
 384   unsigned long total_blob_count;
 385   unsigned long empty_blob_count;
 386   unsigned long header_blob_count;
 387   unsigned long pgp_blob_count;
 388   unsigned long x509_blob_count;
 389   unsigned long unknown_blob_count;
 390   unsigned long non_flagged;
 391   unsigned long secret_flagged;
 392   unsigned long ephemeral_flagged;
 393 };
 394
 395 static int
 396 update_stats (KEYBOXBLOB blob, struct file_stats_s *s)
 397 {
 398   const unsigned char *buffer;
 399   size_t length;
 400   int type;
 401   unsigned long n;
 402
 403   buffer = _keybox_get_blob_image (blob, &length);
 404   if (length < 32)
 405     {
 406       s->too_short_blobs++;
 407       return -1;
 408     }
 409
 410   n = get32( buffer );
 411   if (n > length)
 412     s->too_large_blobs++;
 413   else
 414     length = n;  /* ignore the rest */
 415
 416   s->total_blob_count++;
 417   type = buffer[4];
 418   switch (type)
 419     {
 420     case BLOBTYPE_EMPTY:
 421       s->empty_blob_count++;
 422       return 0;
 423     case BLOBTYPE_HEADER:
 424       s->header_blob_count++;
 425       return 0;
 426     case BLOBTYPE_PGP:
 427       s->pgp_blob_count++;
 428       break;
 429     case BLOBTYPE_X509:
 430       s->x509_blob_count++;
 431       break;
 432     default:
 433       s->unknown_blob_count++;
 434       return 0;
 435     }
 436
 437   if (length < 40)
 438     {
 439       s->too_short_blobs++;
 440       return -1;
 441     }
 442
 443   n = get16 (buffer + 6);
 444   if (n)
 445     {
 446       if ((n & 1))
 447         s->secret_flagged++;
 448       if ((n & 2))
 449         s->ephemeral_flagged++;
 450     }
 451   else
 452     s->non_flagged++;
 453
 454   return 0;
 455 }
 456
 457
 458 \f
 459 static FILE *
 460 open_file (const char **filename, FILE *outfp)
 461 {
 462   FILE *fp;
 463
 464   if (!*filename)
 465     {
 466       *filename = "-";
 467       fp = stdin;
 468     }
 469   else
 470     fp = fopen (*filename, "rb");
 471   if (!fp)
 472     {
 473       int save_errno = errno;
 474       fprintf (outfp, "can't open `%s': %s\n", *filename, strerror(errno));
 475       errno = save_errno;
 476     }
 477   return fp;
 478 }
 479
 480
 481
 482 int
 483 _keybox_dump_file (const char *filename, int stats_only, FILE *outfp)
 484 {
 485   FILE *fp;
 486   KEYBOXBLOB blob;
 487   int rc;
 488   unsigned long count = 0;
 489   struct file_stats_s stats;
 490
 491   memset (&stats, 0, sizeof stats);
 492
 493   if (!(fp = open_file (&filename, outfp)))
 494     return gpg_error_from_syserror ();
 495
 496   while ( !(rc = _keybox_read_blob (&blob, fp)) )
 497     {
 498       if (stats_only)
 499         {
 500           update_stats (blob, &stats);
 501         }
 502       else
 503         {
 504           fprintf (outfp, "BEGIN-RECORD: %lu\n", count );
 505           _keybox_dump_blob (blob, outfp);
 506           fprintf (outfp, "END-RECORD\n");
 507         }
 508       _keybox_release_blob (blob);
 509       count++;
 510     }
 511   if (rc == -1)
 512     rc = 0;
 513   if (rc)
 514     fprintf (outfp, "error reading `%s': %s\n", filename, gpg_strerror (rc));
 515
 516   if (fp != stdin)
 517     fclose (fp);
 518
 519   if (stats_only)
 520     {
 521       fprintf (outfp,
 522                "Total number of blobs: %8lu\n"
 523                "               header: %8lu\n"
 524                "                empty: %8lu\n"
 525                "              openpgp: %8lu\n"
 526                "                 x509: %8lu\n"
 527                "          non flagged: %8lu\n"
 528                "       secret flagged: %8lu\n"
 529                "    ephemeral flagged: %8lu\n",
 530                stats.total_blob_count,
 531                stats.header_blob_count,
 532                stats.empty_blob_count,
 533                stats.pgp_blob_count,
 534                stats.x509_blob_count,
 535                stats.non_flagged,
 536                stats.secret_flagged,
 537                stats.ephemeral_flagged);
 538         if (stats.unknown_blob_count)
 539           fprintf (outfp, "   unknown blob types: %8lu\n",
 540                    stats.unknown_blob_count);
 541         if (stats.too_short_blobs)
 542           fprintf (outfp, "      too short blobs: %8lu\n",
 543                    stats.too_short_blobs);
 544         if (stats.too_large_blobs)
 545           fprintf (outfp, "      too large blobs: %8lu\n",
 546                    stats.too_large_blobs);
 547     }
 548
 549   return rc;
 550 }
 551
 552
 553 \f
 554 struct dupitem_s
 555 {
 556   unsigned long recno;
 557   unsigned char digest[20];
 558 };
 559
 560
 561 static int
 562 cmp_dupitems (const void *arg_a, const void *arg_b)
 563 {
 564   struct dupitem_s *a = (struct dupitem_s *)arg_a;
 565   struct dupitem_s *b = (struct dupitem_s *)arg_b;
 566
 567   return memcmp (a->digest, b->digest, 20);
 568 }
 569
 570
 571 int
 572 _keybox_dump_find_dups (const char *filename, int print_them, FILE *outfp)
 573 {
 574   FILE *fp;
 575   KEYBOXBLOB blob;
 576   int rc;
 577   unsigned long recno = 0;
 578   unsigned char zerodigest[20];
 579   struct dupitem_s *dupitems;
 580   size_t dupitems_size, dupitems_count, lastn, n;
 581   char fprbuf[3*20+1];
 582
 583   (void)print_them;
 584
 585   memset (zerodigest, 0, sizeof zerodigest);
 586
 587   if (!(fp = open_file (&filename, outfp)))
 588     return gpg_error_from_syserror ();
 589
 590   dupitems_size = 1000;
 591   dupitems = malloc (dupitems_size * sizeof *dupitems);
 592   if (!dupitems)
 593     {
 594       gpg_error_t tmperr = gpg_error_from_syserror ();
 595       fprintf (outfp, "error allocating array for `%s': %s\n",
 596                filename, strerror(errno));
 597       return tmperr;
 598     }
 599   dupitems_count = 0;
 600
 601   while ( !(rc = _keybox_read_blob (&blob, fp)) )
 602     {
 603       unsigned char digest[20];
 604
 605       if (hash_blob_rawdata (blob, digest))
 606         fprintf (outfp, "error in blob %ld of `%s'\n", recno, filename);
 607       else if (memcmp (digest, zerodigest, 20))
 608         {
 609           if (dupitems_count >= dupitems_size)
 610             {
 611               struct dupitem_s *tmp;
 612
 613               dupitems_size += 1000;
 614               tmp = realloc (dupitems, dupitems_size * sizeof *dupitems);
 615               if (!tmp)
 616                 {
 617                   gpg_error_t tmperr = gpg_error_from_syserror ();
 618                   fprintf (outfp, "error reallocating array for `%s': %s\n",
 619                            filename, strerror(errno));
 620                   free (dupitems);
 621                   return tmperr;
 622                 }
 623               dupitems = tmp;
 624             }
 625           dupitems[dupitems_count].recno = recno;
 626           memcpy (dupitems[dupitems_count].digest, digest, 20);
 627           dupitems_count++;
 628         }
 629       _keybox_release_blob (blob);
 630       recno++;
 631     }
 632   if (rc == -1)
 633     rc = 0;
 634   if (rc)
 635     fprintf (outfp, "error reading `%s': %s\n", filename, gpg_strerror (rc));
 636   if (fp != stdin)
 637     fclose (fp);
 638
 639   qsort (dupitems, dupitems_count, sizeof *dupitems, cmp_dupitems);
 640
 641   for (lastn=0, n=1; n < dupitems_count; lastn=n, n++)
 642     {
 643       if (!memcmp (dupitems[lastn].digest, dupitems[n].digest, 20))
 644         {
 645           bin2hexcolon (dupitems[lastn].digest, 20, fprbuf);
 646           fprintf (outfp, "fpr=%s recno=%lu", fprbuf, dupitems[lastn].recno);
 647           do
 648             fprintf (outfp, " %lu", dupitems[n].recno);
 649           while (++n < dupitems_count
 650                  && !memcmp (dupitems[lastn].digest, dupitems[n].digest, 20));
 651           putc ('\n', outfp);
 652           n--;
 653         }
 654     }
 655
 656   free (dupitems);
 657
 658   return rc;
 659 }
 660
 661
 662 /* Print records with record numbers FROM to TO to OUTFP.  */
 663 int
 664 _keybox_dump_cut_records (const char *filename, unsigned long from,
 665                           unsigned long to, FILE *outfp)
 666 {
 667   FILE *fp;
 668   KEYBOXBLOB blob;
 669   int rc;
 670   unsigned long recno = 0;
 671
 672   if (!(fp = open_file (&filename, stderr)))
 673     return gpg_error_from_syserror ();
 674
 675   while ( !(rc = _keybox_read_blob (&blob, fp)) )
 676     {
 677       if (recno > to)
 678         break; /* Ready.  */
 679       if (recno >= from)
 680         {
 681           if ((rc = _keybox_write_blob (blob, outfp)))
 682             {
 683               fprintf (stderr, "error writing output: %s\n",
 684                        gpg_strerror (rc));
 685               goto leave;
 686             }
 687         }
 688       _keybox_release_blob (blob);
 689       recno++;
 690     }
 691   if (rc == -1)
 692     rc = 0;
 693   if (rc)
 694     fprintf (stderr, "error reading `%s': %s\n", filename, gpg_strerror (rc));
 695  leave:
 696   if (fp != stdin)
 697     fclose (fp);
 698   return rc;
 699 }