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