kbxutil: Print algo number and fold similar lines.
[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 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   {
295     int in_range = 0;
296     ulong first = 0;
297
298     for (n=0; n < nsigs; n++, p += siginfolen)
299       {
300         ulong sflags;
301
302         sflags = get32 (p);
303         if (!in_range && !sflags)
304           {
305             in_range = 1;
306             first = n;
307             continue;
308           }
309         if (in_range && !sflags)
310           continue;
311         if (in_range)
312           {
313             fprintf (fp, "Sig-Expire[%lu-%lu]: [not checked]\n", first, n-1);
314             in_range = 0;
315           }
316
317         fprintf (fp, "Sig-Expire[%lu]: ", n );
318         if (!sflags)
319           fputs ("[not checked]", fp);
320         else if (sflags == 1 )
321           fputs ("[missing key]", fp);
322         else if (sflags == 2 )
323           fputs ("[bad signature]", fp);
324         else if (sflags < 0x10000000)
325           fprintf (fp, "[bad flag %0lx]", sflags);
326         else if (sflags == 0xffffffff)
327           fputs ("0", fp );
328         else
329           fputs ("a time"/*strtimestamp( sflags )*/, fp );
330         putc ('\n', fp );
331       }
332     if (in_range)
333       {
334         fprintf (fp, "Sig-Expire[%lu-%lu]: [not checked]\n", first, n-1);
335         in_range = 0;
336       }
337   }
338   fprintf (fp, "Ownertrust: %d\n", p[0] );
339   fprintf (fp, "All-Validity: %d\n", p[1] );
340   p += 4;
341   n = get32 (p); p += 4;
342   fprintf (fp, "Recheck-After: %lu\n", n );
343   n = get32 (p ); p += 4;
344   fprintf( fp, "Latest-Timestamp: %lu\n", n );
345   n = get32 (p ); p += 4;
346   fprintf (fp, "Created-At: %lu\n", n );
347   n = get32 (p ); p += 4;
348   fprintf (fp, "Reserved-Space: %lu\n", n );
349
350   /* check that the keyblock is at the correct offset and other bounds */
351   /*fprintf (fp, "Blob-Checksum: [MD5-hash]\n");*/
352   return 0;
353 }
354
355
356 /* Compute the SHA_1 checksum of teh rawdata in BLOB and aput it into
357    DIGEST. */
358 static int
359 hash_blob_rawdata (KEYBOXBLOB blob, unsigned char *digest)
360 {
361   const unsigned char *buffer;
362   size_t n, length;
363   int type;
364   ulong rawdata_off, rawdata_len;
365
366   buffer = _keybox_get_blob_image (blob, &length);
367
368   if (length < 32)
369     return -1;
370   n = get32 (buffer);
371   if (n < length)
372     length = n;  /* Blob larger than length in header - ignore the rest. */
373
374   type = buffer[4];
375   switch (type)
376     {
377     case BLOBTYPE_PGP:
378     case BLOBTYPE_X509:
379       break;
380
381     case BLOBTYPE_EMPTY:
382     case BLOBTYPE_HEADER:
383     default:
384       memset (digest, 0, 20);
385       return 0;
386     }
387
388   if (length < 40)
389     return -1;
390
391   rawdata_off = get32 (buffer + 8);
392   rawdata_len = get32 (buffer + 12);
393
394   if (rawdata_off > length || rawdata_len > length
395       || rawdata_off+rawdata_off > length)
396     return -1; /* Out of bounds.  */
397
398   gcry_md_hash_buffer (GCRY_MD_SHA1, digest, buffer+rawdata_off, rawdata_len);
399   return 0;
400 }
401
402
403 struct file_stats_s
404 {
405   unsigned long too_short_blobs;
406   unsigned long too_large_blobs;
407   unsigned long total_blob_count;
408   unsigned long empty_blob_count;
409   unsigned long header_blob_count;
410   unsigned long pgp_blob_count;
411   unsigned long x509_blob_count;
412   unsigned long unknown_blob_count;
413   unsigned long non_flagged;
414   unsigned long secret_flagged;
415   unsigned long ephemeral_flagged;
416 };
417
418 static int
419 update_stats (KEYBOXBLOB blob, struct file_stats_s *s)
420 {
421   const unsigned char *buffer;
422   size_t length;
423   int type;
424   unsigned long n;
425
426   buffer = _keybox_get_blob_image (blob, &length);
427   if (length < 32)
428     {
429       s->too_short_blobs++;
430       return -1;
431     }
432
433   n = get32( buffer );
434   if (n > length)
435     s->too_large_blobs++;
436   else
437     length = n;  /* ignore the rest */
438
439   s->total_blob_count++;
440   type = buffer[4];
441   switch (type)
442     {
443     case BLOBTYPE_EMPTY:
444       s->empty_blob_count++;
445       return 0;
446     case BLOBTYPE_HEADER:
447       s->header_blob_count++;
448       return 0;
449     case BLOBTYPE_PGP:
450       s->pgp_blob_count++;
451       break;
452     case BLOBTYPE_X509:
453       s->x509_blob_count++;
454       break;
455     default:
456       s->unknown_blob_count++;
457       return 0;
458     }
459
460   if (length < 40)
461     {
462       s->too_short_blobs++;
463       return -1;
464     }
465
466   n = get16 (buffer + 6);
467   if (n)
468     {
469       if ((n & 1))
470         s->secret_flagged++;
471       if ((n & 2))
472         s->ephemeral_flagged++;
473     }
474   else
475     s->non_flagged++;
476
477   return 0;
478 }
479
480
481 \f
482 static FILE *
483 open_file (const char **filename, FILE *outfp)
484 {
485   FILE *fp;
486
487   if (!*filename)
488     {
489       *filename = "-";
490       fp = stdin;
491     }
492   else
493     fp = fopen (*filename, "rb");
494   if (!fp)
495     {
496       int save_errno = errno;
497       fprintf (outfp, "can't open '%s': %s\n", *filename, strerror(errno));
498       gpg_err_set_errno (save_errno);
499     }
500   return fp;
501 }
502
503
504
505 int
506 _keybox_dump_file (const char *filename, int stats_only, FILE *outfp)
507 {
508   FILE *fp;
509   KEYBOXBLOB blob;
510   int rc;
511   unsigned long count = 0;
512   struct file_stats_s stats;
513
514   memset (&stats, 0, sizeof stats);
515
516   if (!(fp = open_file (&filename, outfp)))
517     return gpg_error_from_syserror ();
518
519   while ( !(rc = _keybox_read_blob (&blob, fp)) )
520     {
521       if (stats_only)
522         {
523           update_stats (blob, &stats);
524         }
525       else
526         {
527           fprintf (outfp, "BEGIN-RECORD: %lu\n", count );
528           _keybox_dump_blob (blob, outfp);
529           fprintf (outfp, "END-RECORD\n");
530         }
531       _keybox_release_blob (blob);
532       count++;
533     }
534   if (rc == -1)
535     rc = 0;
536   if (rc)
537     fprintf (outfp, "error reading '%s': %s\n", filename, gpg_strerror (rc));
538
539   if (fp != stdin)
540     fclose (fp);
541
542   if (stats_only)
543     {
544       fprintf (outfp,
545                "Total number of blobs: %8lu\n"
546                "               header: %8lu\n"
547                "                empty: %8lu\n"
548                "              openpgp: %8lu\n"
549                "                 x509: %8lu\n"
550                "          non flagged: %8lu\n"
551                "       secret flagged: %8lu\n"
552                "    ephemeral flagged: %8lu\n",
553                stats.total_blob_count,
554                stats.header_blob_count,
555                stats.empty_blob_count,
556                stats.pgp_blob_count,
557                stats.x509_blob_count,
558                stats.non_flagged,
559                stats.secret_flagged,
560                stats.ephemeral_flagged);
561         if (stats.unknown_blob_count)
562           fprintf (outfp, "   unknown blob types: %8lu\n",
563                    stats.unknown_blob_count);
564         if (stats.too_short_blobs)
565           fprintf (outfp, "      too short blobs: %8lu\n",
566                    stats.too_short_blobs);
567         if (stats.too_large_blobs)
568           fprintf (outfp, "      too large blobs: %8lu\n",
569                    stats.too_large_blobs);
570     }
571
572   return rc;
573 }
574
575
576 \f
577 struct dupitem_s
578 {
579   unsigned long recno;
580   unsigned char digest[20];
581 };
582
583
584 static int
585 cmp_dupitems (const void *arg_a, const void *arg_b)
586 {
587   struct dupitem_s *a = (struct dupitem_s *)arg_a;
588   struct dupitem_s *b = (struct dupitem_s *)arg_b;
589
590   return memcmp (a->digest, b->digest, 20);
591 }
592
593
594 int
595 _keybox_dump_find_dups (const char *filename, int print_them, FILE *outfp)
596 {
597   FILE *fp;
598   KEYBOXBLOB blob;
599   int rc;
600   unsigned long recno = 0;
601   unsigned char zerodigest[20];
602   struct dupitem_s *dupitems;
603   size_t dupitems_size, dupitems_count, lastn, n;
604   char fprbuf[3*20+1];
605
606   (void)print_them;
607
608   memset (zerodigest, 0, sizeof zerodigest);
609
610   if (!(fp = open_file (&filename, outfp)))
611     return gpg_error_from_syserror ();
612
613   dupitems_size = 1000;
614   dupitems = malloc (dupitems_size * sizeof *dupitems);
615   if (!dupitems)
616     {
617       gpg_error_t tmperr = gpg_error_from_syserror ();
618       fprintf (outfp, "error allocating array for '%s': %s\n",
619                filename, strerror(errno));
620       return tmperr;
621     }
622   dupitems_count = 0;
623
624   while ( !(rc = _keybox_read_blob (&blob, fp)) )
625     {
626       unsigned char digest[20];
627
628       if (hash_blob_rawdata (blob, digest))
629         fprintf (outfp, "error in blob %ld of '%s'\n", recno, filename);
630       else if (memcmp (digest, zerodigest, 20))
631         {
632           if (dupitems_count >= dupitems_size)
633             {
634               struct dupitem_s *tmp;
635
636               dupitems_size += 1000;
637               tmp = realloc (dupitems, dupitems_size * sizeof *dupitems);
638               if (!tmp)
639                 {
640                   gpg_error_t tmperr = gpg_error_from_syserror ();
641                   fprintf (outfp, "error reallocating array for '%s': %s\n",
642                            filename, strerror(errno));
643                   free (dupitems);
644                   return tmperr;
645                 }
646               dupitems = tmp;
647             }
648           dupitems[dupitems_count].recno = recno;
649           memcpy (dupitems[dupitems_count].digest, digest, 20);
650           dupitems_count++;
651         }
652       _keybox_release_blob (blob);
653       recno++;
654     }
655   if (rc == -1)
656     rc = 0;
657   if (rc)
658     fprintf (outfp, "error reading '%s': %s\n", filename, gpg_strerror (rc));
659   if (fp != stdin)
660     fclose (fp);
661
662   qsort (dupitems, dupitems_count, sizeof *dupitems, cmp_dupitems);
663
664   for (lastn=0, n=1; n < dupitems_count; lastn=n, n++)
665     {
666       if (!memcmp (dupitems[lastn].digest, dupitems[n].digest, 20))
667         {
668           bin2hexcolon (dupitems[lastn].digest, 20, fprbuf);
669           fprintf (outfp, "fpr=%s recno=%lu", fprbuf, dupitems[lastn].recno);
670           do
671             fprintf (outfp, " %lu", dupitems[n].recno);
672           while (++n < dupitems_count
673                  && !memcmp (dupitems[lastn].digest, dupitems[n].digest, 20));
674           putc ('\n', outfp);
675           n--;
676         }
677     }
678
679   free (dupitems);
680
681   return rc;
682 }
683
684
685 /* Print records with record numbers FROM to TO to OUTFP.  */
686 int
687 _keybox_dump_cut_records (const char *filename, unsigned long from,
688                           unsigned long to, FILE *outfp)
689 {
690   FILE *fp;
691   KEYBOXBLOB blob;
692   int rc;
693   unsigned long recno = 0;
694
695   if (!(fp = open_file (&filename, stderr)))
696     return gpg_error_from_syserror ();
697
698   while ( !(rc = _keybox_read_blob (&blob, fp)) )
699     {
700       if (recno > to)
701         break; /* Ready.  */
702       if (recno >= from)
703         {
704           if ((rc = _keybox_write_blob (blob, outfp)))
705             {
706               fprintf (stderr, "error writing output: %s\n",
707                        gpg_strerror (rc));
708               goto leave;
709             }
710         }
711       _keybox_release_blob (blob);
712       recno++;
713     }
714   if (rc == -1)
715     rc = 0;
716   if (rc)
717     fprintf (stderr, "error reading '%s': %s\n", filename, gpg_strerror (rc));
718  leave:
719   if (fp != stdin)
720     fclose (fp);
721   return rc;
722 }