* NEWS: Note --sig-keyserver-url and the ability to use a preferred
[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 2 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, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21 #include <config.h>
22 #include <stdlib.h>
23 #include <stdio.h>
24 #include <string.h>
25 #include <errno.h>
26
27 #include "keybox-defs.h"
28
29 static ulong
30 get32 (const byte *buffer)
31 {
32   ulong a;
33   a =  *buffer << 24;
34   a |= buffer[1] << 16;
35   a |= buffer[2] << 8;
36   a |= buffer[3];
37   return a;
38 }
39
40 static ulong
41 get16 (const byte *buffer)
42 {
43   ulong a;
44   a =  *buffer << 8;
45   a |= buffer[1];
46   return a;
47 }
48
49 void
50 print_string (FILE *fp, const byte *p, size_t n, int delim)
51 {
52   for ( ; n; n--, p++ )
53     {
54       if (*p < 0x20 || (*p >= 0x7f && *p < 0xa0) || *p == delim)
55         {
56           putc('\\', fp);
57           if( *p == '\n' )
58             putc('n', fp);
59           else if( *p == '\r' )
60             putc('r', fp);
61           else if( *p == '\f' )
62             putc('f', fp);
63           else if( *p == '\v' )
64             putc('v', fp);
65           else if( *p == '\b' )
66             putc('b', fp);
67           else if( !*p )
68             putc('0', fp);
69           else
70             fprintf(fp, "x%02x", *p );
71         }
72       else
73         putc(*p, fp);
74     }
75 }
76
77
78 static int
79 dump_header_blob (const byte *buffer, size_t length, FILE *fp)
80 {
81   fprintf (fp, "Version: %d\n", buffer[5]);
82   if ( memcmp (buffer+8, "KBXf", 4))
83     fprintf (fp, "[Error: invalid magic number]\n");
84   return 0;
85 }
86
87 \f
88 /* Dump one block to FP */
89 int
90 _keybox_dump_blob (KEYBOXBLOB blob, FILE *fp)
91 {
92   const byte *buffer;
93   size_t length;
94   int type;
95   ulong n, nkeys, keyinfolen;
96   ulong nuids, uidinfolen;
97   ulong nsigs, siginfolen;
98   ulong rawdata_off, rawdata_len;
99   ulong nserial;
100   const byte *p;
101
102   buffer = _keybox_get_blob_image (blob, &length);
103   
104   if (length < 40)
105     {
106       fprintf (fp, "[blob too short]\n");
107       return -1;
108     }
109
110   n = get32( buffer );
111   if (n > length) 
112     fprintf (fp, "[blob larger than length - output truncated]\n");
113   else
114     length = n;  /* ignore the rest */
115
116   fprintf (fp, "Length: %lu\n", n );
117   type = buffer[4];
118   switch (type)
119     {
120     case BLOBTYPE_EMPTY:
121       fprintf (fp, "Type:   Empty\n");
122       return 0;
123
124     case BLOBTYPE_HEADER:
125       fprintf (fp, "Type:   Header\n");
126       return dump_header_blob (buffer, length, fp);
127     case BLOBTYPE_PGP:
128       fprintf (fp, "Type:   OpenPGP\n");
129       break;
130     case BLOBTYPE_X509:
131       fprintf (fp, "Type:   X.509\n");
132       break;
133     default:
134       fprintf (fp, "Type:   %d\n", type);
135       fprintf (fp, "[can't dump this blob type]\n");
136       return 0;
137     }
138   fprintf (fp, "Version: %d\n", buffer[5]);
139   
140   n = get16 (buffer + 6);
141   fprintf( fp, "Blob-Flags: %04lX", n);
142   if (n)
143     {
144       int any = 0;
145
146       fputs (" (", fp);
147       if ((n & 1))
148         {
149           fputs ("secret", fp);
150           any++;
151         }
152       if ((n & 2))
153         {
154           if (any)
155             putc (',', fp);
156           fputs ("ephemeral", fp);
157           any++;
158         }
159       putc (')', fp);
160     }
161   putc ('\n', fp);
162
163   rawdata_off = get32 (buffer + 8);
164   rawdata_len = get32 (buffer + 12);
165
166   fprintf( fp, "Data-Offset: %lu\n", rawdata_off );
167   fprintf( fp, "Data-Length: %lu\n", rawdata_len );
168
169   nkeys = get16 (buffer + 16);
170   fprintf (fp, "Key-Count: %lu\n", nkeys );
171   if (!nkeys)
172     fprintf (fp, "[Error: no keys]\n");
173   if (nkeys > 1 && type == BLOBTYPE_X509)
174     fprintf (fp, "[Error: only one key allowed for X509]\n");
175
176   keyinfolen = get16 (buffer + 18 );
177   fprintf (fp, "Key-Info-Length: %lu\n", keyinfolen);
178   /* fixme: check bounds */
179   p = buffer + 20;
180   for (n=0; n < nkeys; n++, p += keyinfolen)
181     {
182       int i;
183       ulong kidoff, kflags;
184     
185       fprintf (fp, "Key-Fpr[%lu]: ", n );
186       for (i=0; i < 20; i++ )
187         fprintf (fp, "%02X", p[i]);
188       kidoff = get32 (p + 20);
189       fprintf (fp, "\nKey-Kid-Off[%lu]: %lu\n", n, kidoff );
190       fprintf (fp, "Key-Kid[%lu]: ", n );
191       /* fixme: check bounds */
192       for (i=0; i < 8; i++ )
193         fprintf (fp, "%02X", buffer[kidoff+i] );
194       kflags = get16 (p + 24 );
195       fprintf( fp, "\nKey-Flags[%lu]: %04lX\n", n, kflags);
196     }
197   
198   /* serial number */
199   fputs ("Serial-No: ", fp);
200   nserial = get16 (p);
201   p += 2;
202   if (!nserial)
203     fputs ("none", fp);
204   else
205     {
206       for (; nserial; nserial--, p++)
207         fprintf (fp, "%02X", *p);
208     }
209   putc ('\n', fp);
210
211   /* user IDs */
212   nuids = get16 (p);
213   fprintf (fp, "Uid-Count: %lu\n", nuids );
214   uidinfolen = get16  (p + 2);
215   fprintf (fp, "Uid-Info-Length: %lu\n", uidinfolen);
216   /* fixme: check bounds */
217   p += 4;
218   for (n=0; n < nuids; n++, p += uidinfolen)
219     {
220       ulong uidoff, uidlen, uflags;
221       
222       uidoff = get32( p );
223       uidlen = get32( p+4 );
224       if (type == BLOBTYPE_X509 && !n)
225         {
226           fprintf (fp, "Issuer-Off: %lu\n", uidoff );
227           fprintf (fp, "Issuer-Len: %lu\n", uidlen );
228           fprintf (fp, "Issuer: \"");
229         }
230       else if (type == BLOBTYPE_X509 && n == 1)
231         {
232           fprintf (fp, "Subject-Off: %lu\n", uidoff );
233           fprintf (fp, "Subject-Len: %lu\n", uidlen );
234           fprintf (fp, "Subject: \"");
235         }
236       else
237         {
238           fprintf (fp, "Uid-Off[%lu]: %lu\n", n, uidoff );
239           fprintf (fp, "Uid-Len[%lu]: %lu\n", n, uidlen );
240           fprintf (fp, "Uid[%lu]: \"", n );
241         }
242       print_string (fp, buffer+uidoff, uidlen, '\"');
243       fputs ("\"\n", fp);
244       uflags = get16 (p + 8);
245       if (type == BLOBTYPE_X509 && !n)
246         {
247           fprintf (fp, "Issuer-Flags: %04lX\n", uflags );
248           fprintf (fp, "Issuer-Validity: %d\n", p[10] );
249         }
250       else if (type == BLOBTYPE_X509 && n == 1)
251         {
252           fprintf (fp, "Subject-Flags: %04lX\n", uflags );
253           fprintf (fp, "Subject-Validity: %d\n", p[10] );
254         }
255       else
256         {
257           fprintf (fp, "Uid-Flags[%lu]: %04lX\n", n, uflags );
258           fprintf (fp, "Uid-Validity[%lu]: %d\n", n, p[10] );
259         }
260     }
261   
262   nsigs = get16 (p);
263   fprintf (fp, "Sig-Count: %lu\n", nsigs );
264   siginfolen = get16 (p + 2);
265   fprintf (fp, "Sig-Info-Length: %lu\n", siginfolen );
266   /* fixme: check bounds  */
267   p += 4;
268   for (n=0; n < nsigs; n++, p += siginfolen)
269     {
270       ulong sflags;
271     
272       sflags = get32 (p);
273       fprintf (fp, "Sig-Expire[%lu]: ", n );
274       if (!sflags)
275         fputs ("[not checked]", fp);
276       else if (sflags == 1 )
277         fputs ("[missing key]", fp);
278       else if (sflags == 2 )
279         fputs ("[bad signature]", fp);
280       else if (sflags < 0x10000000)
281         fprintf (fp, "[bad flag %0lx]", sflags);
282       else if (sflags == 0xffffffff)
283         fputs ("0", fp );
284       else
285         fputs ("a time"/*strtimestamp( sflags )*/, fp );
286       putc ('\n', fp );
287     }
288
289   fprintf (fp, "Ownertrust: %d\n", p[0] );
290   fprintf (fp, "All-Validity: %d\n", p[1] );
291   p += 4;
292   n = get32 (p); p += 4;
293   fprintf (fp, "Recheck-After: %s\n", /*n? strtimestamp(n) :*/ "0" );
294   n = get32 (p ); p += 4;
295   fprintf( fp, "Latest-Timestamp: %s\n", "0"/*strtimestamp(n)*/ );
296   n = get32 (p ); p += 4;
297   fprintf (fp, "Created-At: %s\n", "0"/*strtimestamp(n)*/ );
298   n = get32 (p ); p += 4;
299   fprintf (fp, "Reserved-Space: %lu\n", n );
300
301   /* check that the keyblock is at the correct offset and other bounds */
302   /*fprintf (fp, "Blob-Checksum: [MD5-hash]\n");*/
303   return 0;
304 }
305
306
307 \f
308 int
309 _keybox_dump_file (const char *filename, FILE *outfp)
310 {
311   FILE *fp;
312   KEYBOXBLOB blob;
313   int rc;
314   unsigned long count = 0;
315
316   if (!filename)
317     {
318       filename = "-";
319       fp = stdin;
320     }
321   else
322     fp = fopen (filename, "rb");
323   if (!fp)
324     {
325       gpg_error_t tmperr = gpg_error (gpg_err_code_from_errno (errno));
326       fprintf (outfp, "can't open `%s': %s\n", filename, strerror(errno));
327       return tmperr;
328     }
329
330   while ( !(rc = _keybox_read_blob (&blob, fp)) )
331     {
332       fprintf (outfp, "BEGIN-RECORD: %lu\n", count );
333       _keybox_dump_blob (blob, outfp);
334       _keybox_release_blob (blob);
335       fprintf (outfp, "END-RECORD\n");
336       count++;
337     }
338   if (rc == -1)
339     rc = 0;
340   if (rc)
341     fprintf (outfp, "error reading `%s': %s\n", filename, gpg_strerror (rc));
342   
343   if (fp != stdin)
344     fclose (fp);
345   return rc;
346 }