1 /* keybox-dump.c - Debug helpers
2 * Copyright (C) 2001, 2003 Free Software Foundation, Inc.
4 * This file is part of GnuPG.
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.
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.
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/>.
26 #include "keybox-defs.h"
30 /* Argg, we can't include ../common/util.h */
31 char *bin2hexcolon (const void *buffer, size_t length, char *stringbuf);
33 #define get32(a) buf32_to_ulong ((a))
34 #define get16(a) buf16_to_ulong ((a))
38 print_string (FILE *fp, const byte *p, size_t n, int delim)
42 if (*p < 0x20 || (*p >= 0x7f && *p < 0xa0) || *p == delim)
58 fprintf(fp, "x%02x", *p );
67 print_checksum (const byte *buffer, size_t length, size_t unhashed, FILE *fp)
72 unsigned char digest[20];
74 fprintf (fp, "Checksum: ");
75 if (unhashed && unhashed < 20)
77 fputs ("[specified unhashed sized too short]\n", fp);
87 if (length < 5+unhashed)
89 fputs ("[blob too short for a checksum]\n", fp);
93 p = buffer + length - hashlen;
94 for (i=0; i < hashlen; p++, i++)
95 fprintf (fp, "%02x", *p);
97 if (hashlen == 16) /* Compatibility method. */
99 gcry_md_hash_buffer (GCRY_MD_MD5, digest, buffer, length - 16);
100 if (!memcmp (buffer + length - 16, digest, 16))
101 fputs (" [valid]\n", fp);
103 fputs (" [bad]\n", fp);
107 gcry_md_hash_buffer (GCRY_MD_SHA1, digest, buffer, length - unhashed);
108 if (!memcmp (buffer + length - hashlen, digest, hashlen))
109 fputs (" [valid]\n", fp);
111 fputs (" [bad]\n", fp);
118 dump_header_blob (const byte *buffer, size_t length, FILE *fp)
124 fprintf (fp, "[blob too short]\n");
127 fprintf (fp, "Version: %d\n", buffer[5]);
129 n = get16 (buffer + 6);
130 fprintf( fp, "Flags: %04lX", n);
140 fputs ("openpgp", fp);
147 if ( memcmp (buffer+8, "KBXf", 4))
148 fprintf (fp, "[Error: invalid magic number]\n");
150 n = get32 (buffer+16);
151 fprintf( fp, "created-at: %lu\n", n );
152 n = get32 (buffer+20);
153 fprintf( fp, "last-maint: %lu\n", n );
159 /* Dump one block to FP */
161 _keybox_dump_blob (KEYBOXBLOB blob, FILE *fp)
166 ulong n, nkeys, keyinfolen;
167 ulong nuids, uidinfolen;
168 ulong nsigs, siginfolen;
169 ulong rawdata_off, rawdata_len;
174 buffer = _keybox_get_blob_image (blob, &length);
178 fprintf (fp, "[blob too short]\n");
184 fprintf (fp, "[blob larger than length - output truncated]\n");
186 length = n; /* ignore the rest */
188 fprintf (fp, "Length: %lu\n", n );
192 case KEYBOX_BLOBTYPE_EMPTY:
193 fprintf (fp, "Type: Empty\n");
196 case KEYBOX_BLOBTYPE_HEADER:
197 fprintf (fp, "Type: Header\n");
198 return dump_header_blob (buffer, length, fp);
199 case KEYBOX_BLOBTYPE_PGP:
200 fprintf (fp, "Type: OpenPGP\n");
202 case KEYBOX_BLOBTYPE_X509:
203 fprintf (fp, "Type: X.509\n");
206 fprintf (fp, "Type: %d\n", type);
207 fprintf (fp, "[can't dump this blob type]\n");
210 fprintf (fp, "Version: %d\n", buffer[5]);
214 fprintf (fp, "[blob too short]\n");
218 n = get16 (buffer + 6);
219 fprintf( fp, "Blob-Flags: %04lX", n);
227 fputs ("secret", fp);
234 fputs ("ephemeral", fp);
241 rawdata_off = get32 (buffer + 8);
242 rawdata_len = get32 (buffer + 12);
244 fprintf( fp, "Data-Offset: %lu\n", rawdata_off );
245 fprintf( fp, "Data-Length: %lu\n", rawdata_len );
246 if (rawdata_off > length || rawdata_len > length
247 || rawdata_off+rawdata_len > length
248 || rawdata_len + 4 > length
249 || rawdata_off+rawdata_len + 4 > length)
250 fprintf (fp, "[Error: raw data larger than blob]\n");
251 unhashed = length - rawdata_off - rawdata_len;
252 fprintf (fp, "Unhashed: %lu\n", unhashed);
254 nkeys = get16 (buffer + 16);
255 fprintf (fp, "Key-Count: %lu\n", nkeys );
257 fprintf (fp, "[Error: no keys]\n");
258 if (nkeys > 1 && type == KEYBOX_BLOBTYPE_X509)
259 fprintf (fp, "[Error: only one key allowed for X509]\n");
261 keyinfolen = get16 (buffer + 18 );
262 fprintf (fp, "Key-Info-Length: %lu\n", keyinfolen);
263 /* fixme: check bounds */
265 for (n=0; n < nkeys; n++, p += keyinfolen)
267 ulong kidoff, kflags;
269 fprintf (fp, "Key-Fpr[%lu]: ", n );
270 for (i=0; i < 20; i++ )
271 fprintf (fp, "%02X", p[i]);
272 kidoff = get32 (p + 20);
273 fprintf (fp, "\nKey-Kid-Off[%lu]: %lu\n", n, kidoff );
274 fprintf (fp, "Key-Kid[%lu]: ", n );
275 /* fixme: check bounds */
276 for (i=0; i < 8; i++ )
277 fprintf (fp, "%02X", buffer[kidoff+i] );
278 kflags = get16 (p + 24 );
279 fprintf( fp, "\nKey-Flags[%lu]: %04lX\n", n, kflags);
283 fputs ("Serial-No: ", fp);
290 for (; nserial; nserial--, p++)
291 fprintf (fp, "%02X", *p);
297 fprintf (fp, "Uid-Count: %lu\n", nuids );
298 uidinfolen = get16 (p + 2);
299 fprintf (fp, "Uid-Info-Length: %lu\n", uidinfolen);
300 /* fixme: check bounds */
302 for (n=0; n < nuids; n++, p += uidinfolen)
304 ulong uidoff, uidlen, uflags;
307 uidlen = get32( p+4 );
308 if (type == KEYBOX_BLOBTYPE_X509 && !n)
310 fprintf (fp, "Issuer-Off: %lu\n", uidoff );
311 fprintf (fp, "Issuer-Len: %lu\n", uidlen );
312 fprintf (fp, "Issuer: \"");
314 else if (type == KEYBOX_BLOBTYPE_X509 && n == 1)
316 fprintf (fp, "Subject-Off: %lu\n", uidoff );
317 fprintf (fp, "Subject-Len: %lu\n", uidlen );
318 fprintf (fp, "Subject: \"");
322 fprintf (fp, "Uid-Off[%lu]: %lu\n", n, uidoff );
323 fprintf (fp, "Uid-Len[%lu]: %lu\n", n, uidlen );
324 fprintf (fp, "Uid[%lu]: \"", n );
326 print_string (fp, buffer+uidoff, uidlen, '\"');
328 uflags = get16 (p + 8);
329 if (type == KEYBOX_BLOBTYPE_X509 && !n)
331 fprintf (fp, "Issuer-Flags: %04lX\n", uflags );
332 fprintf (fp, "Issuer-Validity: %d\n", p[10] );
334 else if (type == KEYBOX_BLOBTYPE_X509 && n == 1)
336 fprintf (fp, "Subject-Flags: %04lX\n", uflags );
337 fprintf (fp, "Subject-Validity: %d\n", p[10] );
341 fprintf (fp, "Uid-Flags[%lu]: %04lX\n", n, uflags );
342 fprintf (fp, "Uid-Validity[%lu]: %d\n", n, p[10] );
347 fprintf (fp, "Sig-Count: %lu\n", nsigs );
348 siginfolen = get16 (p + 2);
349 fprintf (fp, "Sig-Info-Length: %lu\n", siginfolen );
350 /* fixme: check bounds */
356 for (n=0; n < nsigs; n++, p += siginfolen)
361 if (!in_range && !sflags)
367 if (in_range && !sflags)
371 fprintf (fp, "Sig-Expire[%lu-%lu]: [not checked]\n", first, n-1);
375 fprintf (fp, "Sig-Expire[%lu]: ", n );
377 fputs ("[not checked]", fp);
378 else if (sflags == 1 )
379 fputs ("[missing key]", fp);
380 else if (sflags == 2 )
381 fputs ("[bad signature]", fp);
382 else if (sflags < 0x10000000)
383 fprintf (fp, "[bad flag %0lx]", sflags);
384 else if (sflags == (ulong)(-1))
385 fputs ("[good - does not expire]", fp );
387 fprintf (fp, "[good - expires at %lu]", sflags);
391 fprintf (fp, "Sig-Expire[%lu-%lu]: [not checked]\n", first, n-1);
393 fprintf (fp, "Ownertrust: %d\n", p[0] );
394 fprintf (fp, "All-Validity: %d\n", p[1] );
398 fprintf (fp, "Recheck-After: %lu\n", n );
401 fprintf( fp, "Latest-Timestamp: %lu\n", n );
404 fprintf (fp, "Created-At: %lu\n", n );
406 fprintf (fp, "Reserved-Space: %lu\n", n );
408 if (n >= 4 && unhashed >= 24)
410 n = get32 ( buffer + length - unhashed);
411 fprintf (fp, "Storage-Flags: %08lx\n", n );
413 print_checksum (buffer, length, unhashed, fp);
418 /* Compute the SHA-1 checksum of the rawdata in BLOB and put it into
421 hash_blob_rawdata (KEYBOXBLOB blob, unsigned char *digest)
423 const unsigned char *buffer;
426 ulong rawdata_off, rawdata_len;
428 buffer = _keybox_get_blob_image (blob, &length);
434 length = n; /* Blob larger than length in header - ignore the rest. */
439 case KEYBOX_BLOBTYPE_PGP:
440 case KEYBOX_BLOBTYPE_X509:
443 case KEYBOX_BLOBTYPE_EMPTY:
444 case KEYBOX_BLOBTYPE_HEADER:
446 memset (digest, 0, 20);
453 rawdata_off = get32 (buffer + 8);
454 rawdata_len = get32 (buffer + 12);
456 if (rawdata_off > length || rawdata_len > length
457 || rawdata_off+rawdata_off > length)
458 return -1; /* Out of bounds. */
460 gcry_md_hash_buffer (GCRY_MD_SHA1, digest, buffer+rawdata_off, rawdata_len);
467 unsigned long too_short_blobs;
468 unsigned long too_large_blobs;
469 unsigned long total_blob_count;
470 unsigned long empty_blob_count;
471 unsigned long header_blob_count;
472 unsigned long pgp_blob_count;
473 unsigned long x509_blob_count;
474 unsigned long unknown_blob_count;
475 unsigned long non_flagged;
476 unsigned long secret_flagged;
477 unsigned long ephemeral_flagged;
478 unsigned long skipped_long_blobs;
482 update_stats (KEYBOXBLOB blob, struct file_stats_s *s)
484 const unsigned char *buffer;
489 buffer = _keybox_get_blob_image (blob, &length);
492 s->too_short_blobs++;
498 s->too_large_blobs++;
500 length = n; /* ignore the rest */
502 s->total_blob_count++;
506 case KEYBOX_BLOBTYPE_EMPTY:
507 s->empty_blob_count++;
509 case KEYBOX_BLOBTYPE_HEADER:
510 s->header_blob_count++;
512 case KEYBOX_BLOBTYPE_PGP:
515 case KEYBOX_BLOBTYPE_X509:
516 s->x509_blob_count++;
519 s->unknown_blob_count++;
525 s->too_short_blobs++;
529 n = get16 (buffer + 6);
535 s->ephemeral_flagged++;
546 open_file (const char **filename, FILE *outfp)
556 fp = fopen (*filename, "rb");
559 int save_errno = errno;
560 fprintf (outfp, "can't open '%s': %s\n", *filename, strerror(errno));
561 gpg_err_set_errno (save_errno);
569 _keybox_dump_file (const char *filename, int stats_only, FILE *outfp)
574 unsigned long count = 0;
575 struct file_stats_s stats;
577 memset (&stats, 0, sizeof stats);
579 if (!(fp = open_file (&filename, outfp)))
580 return gpg_error_from_syserror ();
584 rc = _keybox_read_blob (&blob, fp);
585 if (gpg_err_code (rc) == GPG_ERR_TOO_LARGE
586 && gpg_err_source (rc) == GPG_ERR_SOURCE_KEYBOX)
589 stats.skipped_long_blobs++;
592 fprintf (outfp, "BEGIN-RECORD: %lu\n", count );
593 fprintf (outfp, "# Record too large\nEND-RECORD\n");
603 update_stats (blob, &stats);
607 fprintf (outfp, "BEGIN-RECORD: %lu\n", count );
608 _keybox_dump_blob (blob, outfp);
609 fprintf (outfp, "END-RECORD\n");
611 _keybox_release_blob (blob);
617 fprintf (outfp, "# error reading '%s': %s\n", filename, gpg_strerror (rc));
625 "Total number of blobs: %8lu\n"
630 " non flagged: %8lu\n"
631 " secret flagged: %8lu\n"
632 " ephemeral flagged: %8lu\n",
633 stats.total_blob_count,
634 stats.header_blob_count,
635 stats.empty_blob_count,
636 stats.pgp_blob_count,
637 stats.x509_blob_count,
639 stats.secret_flagged,
640 stats.ephemeral_flagged);
641 if (stats.skipped_long_blobs)
642 fprintf (outfp, " skipped long blobs: %8lu\n",
643 stats.skipped_long_blobs);
644 if (stats.unknown_blob_count)
645 fprintf (outfp, " unknown blob types: %8lu\n",
646 stats.unknown_blob_count);
647 if (stats.too_short_blobs)
648 fprintf (outfp, " too short blobs: %8lu (error)\n",
649 stats.too_short_blobs);
650 if (stats.too_large_blobs)
651 fprintf (outfp, " too large blobs: %8lu (error)\n",
652 stats.too_large_blobs);
663 unsigned char digest[20];
668 cmp_dupitems (const void *arg_a, const void *arg_b)
670 struct dupitem_s *a = (struct dupitem_s *)arg_a;
671 struct dupitem_s *b = (struct dupitem_s *)arg_b;
673 return memcmp (a->digest, b->digest, 20);
678 _keybox_dump_find_dups (const char *filename, int print_them, FILE *outfp)
683 unsigned long recno = 0;
684 unsigned char zerodigest[20];
685 struct dupitem_s *dupitems;
686 size_t dupitems_size, dupitems_count, lastn, n;
691 memset (zerodigest, 0, sizeof zerodigest);
693 if (!(fp = open_file (&filename, outfp)))
694 return gpg_error_from_syserror ();
696 dupitems_size = 1000;
697 dupitems = malloc (dupitems_size * sizeof *dupitems);
700 gpg_error_t tmperr = gpg_error_from_syserror ();
701 fprintf (outfp, "error allocating array for '%s': %s\n",
702 filename, strerror(errno));
707 while ( !(rc = _keybox_read_blob (&blob, fp)) )
709 unsigned char digest[20];
711 if (hash_blob_rawdata (blob, digest))
712 fprintf (outfp, "error in blob %ld of '%s'\n", recno, filename);
713 else if (memcmp (digest, zerodigest, 20))
715 if (dupitems_count >= dupitems_size)
717 struct dupitem_s *tmp;
719 dupitems_size += 1000;
720 tmp = realloc (dupitems, dupitems_size * sizeof *dupitems);
723 gpg_error_t tmperr = gpg_error_from_syserror ();
724 fprintf (outfp, "error reallocating array for '%s': %s\n",
725 filename, strerror(errno));
731 dupitems[dupitems_count].recno = recno;
732 memcpy (dupitems[dupitems_count].digest, digest, 20);
735 _keybox_release_blob (blob);
741 fprintf (outfp, "error reading '%s': %s\n", filename, gpg_strerror (rc));
745 qsort (dupitems, dupitems_count, sizeof *dupitems, cmp_dupitems);
747 for (lastn=0, n=1; n < dupitems_count; lastn=n, n++)
749 if (!memcmp (dupitems[lastn].digest, dupitems[n].digest, 20))
751 bin2hexcolon (dupitems[lastn].digest, 20, fprbuf);
752 fprintf (outfp, "fpr=%s recno=%lu", fprbuf, dupitems[lastn].recno);
754 fprintf (outfp, " %lu", dupitems[n].recno);
755 while (++n < dupitems_count
756 && !memcmp (dupitems[lastn].digest, dupitems[n].digest, 20));
768 /* Print records with record numbers FROM to TO to OUTFP. */
770 _keybox_dump_cut_records (const char *filename, unsigned long from,
771 unsigned long to, FILE *outfp)
776 unsigned long recno = 0;
778 if (!(fp = open_file (&filename, stderr)))
779 return gpg_error_from_syserror ();
781 while ( !(rc = _keybox_read_blob (&blob, fp)) )
787 if ((rc = _keybox_write_blob (blob, outfp)))
789 fprintf (stderr, "error writing output: %s\n",
794 _keybox_release_blob (blob);
800 fprintf (stderr, "error reading '%s': %s\n", filename, gpg_strerror (rc));