We have reached a state where we are able to import certs and
[gnupg.git] / kbx / keybox-dump.c
1 /* keybox-dump.c - Debug helpers
2  *      Copyright (C) 2001 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_HEADER:
121       fprintf (fp, "Type:   Header\n");
122       return dump_header_blob (buffer, length, fp);
123     case BLOBTYPE_PGP:
124       fprintf (fp, "Type:   OpenPGP\n");
125       break;
126     case BLOBTYPE_X509:
127       fprintf (fp, "Type:   X.509\n");
128       break;
129     default:
130       fprintf (fp, "Type:   %d\n", type);
131       fprintf (fp, "[can't dump this blob type]\n");
132       return 0;
133     }
134   fprintf (fp, "Version: %d\n", buffer[5]);
135   
136   n = get16 (buffer + 6);
137   fprintf( fp, "Blob-Flags: %04lX\n", n);
138   
139   rawdata_off = get32 (buffer + 8);
140   rawdata_len = get32 (buffer + 12);
141
142   fprintf( fp, "Data-Offset: %lu\n", rawdata_off );
143   fprintf( fp, "Data-Length: %lu\n", rawdata_len );
144
145   nkeys = get16 (buffer + 16);
146   fprintf (fp, "Key-Count: %lu\n", nkeys );
147   if (!nkeys)
148     fprintf (fp, "[Error: no keys]\n");
149   if (nkeys > 1 && type == BLOBTYPE_X509)
150     fprintf (fp, "[Error: only one key allowed for X509]\n");
151
152   keyinfolen = get16 (buffer + 18 );
153   fprintf (fp, "Key-Info-Length: %lu\n", keyinfolen);
154   /* fixme: check bounds */
155   p = buffer + 20;
156   for (n=0; n < nkeys; n++, p += keyinfolen)
157     {
158       int i;
159       ulong kidoff, kflags;
160     
161       fprintf (fp, "Key-Fpr[%lu]: ", n );
162       for (i=0; i < 20; i++ )
163         fprintf (fp, "%02X", p[i]);
164       kidoff = get32 (p + 20);
165       fprintf (fp, "\nKey-Kid-Off[%lu]: %lu\n", n, kidoff );
166       fprintf (fp, "Key-Kid[%lu]: ", n );
167       /* fixme: check bounds */
168       for (i=0; i < 8; i++ )
169         fprintf (fp, "%02X", buffer[kidoff+i] );
170       kflags = get16 (p + 24 );
171       fprintf( fp, "\nKey-Flags[%lu]: %04lX\n", n, kflags);
172     }
173   
174   /* serial number */
175   fputs ("Serial-No: ", fp);
176   nserial = get16 (p);
177   p += 2;
178   if (!nserial)
179     fputs ("none", fp);
180   else
181     {
182       for (; nserial; nserial--, p++)
183         fprintf (fp, "%02X", *p);
184     }
185   putc ('\n', fp);
186
187   /* user IDs */
188   nuids = get16 (p);
189   fprintf (fp, "Uid-Count: %lu\n", nuids );
190   uidinfolen = get16  (p + 2);
191   fprintf (fp, "Uid-Info-Length: %lu\n", uidinfolen);
192   /* fixme: check bounds */
193   p += 4;
194   for (n=0; n < nuids; n++, p += uidinfolen)
195     {
196       ulong uidoff, uidlen, uflags;
197       
198       uidoff = get32( p );
199       uidlen = get32( p+4 );
200       if (type == BLOBTYPE_X509 && !n)
201         {
202           fprintf (fp, "Issuer-Off: %lu\n", uidoff );
203           fprintf (fp, "Issuer-Len: %lu\n", uidlen );
204           fprintf (fp, "Issuer: \"");
205         }
206       else if (type == BLOBTYPE_X509 && n == 1)
207         {
208           fprintf (fp, "Subject-Off: %lu\n", uidoff );
209           fprintf (fp, "Subject-Len: %lu\n", uidlen );
210           fprintf (fp, "Subject: \"");
211         }
212       else
213         {
214           fprintf (fp, "Uid-Off[%lu]: %lu\n", n, uidoff );
215           fprintf (fp, "Uid-Len[%lu]: %lu\n", n, uidlen );
216           fprintf (fp, "Uid[%lu]: \"", n );
217         }
218       print_string (fp, buffer+uidoff, uidlen, '\"');
219       fputs ("\"\n", fp);
220       uflags = get16 (p + 8);
221       if (type == BLOBTYPE_X509 && !n)
222         {
223           fprintf (fp, "Issuer-Flags: %04lX\n", uflags );
224           fprintf (fp, "Issuer-Validity: %d\n", p[10] );
225         }
226       else if (type == BLOBTYPE_X509 && n == 1)
227         {
228           fprintf (fp, "Subject-Flags: %04lX\n", uflags );
229           fprintf (fp, "Subject-Validity: %d\n", p[10] );
230         }
231       else
232         {
233           fprintf (fp, "Uid-Flags[%lu]: %04lX\n", n, uflags );
234           fprintf (fp, "Uid-Validity[%lu]: %d\n", n, p[10] );
235         }
236     }
237   
238   nsigs = get16 (p);
239   fprintf (fp, "Sig-Count: %lu\n", nsigs );
240   siginfolen = get16 (p + 2);
241   fprintf (fp, "Sig-Info-Length: %lu\n", siginfolen );
242   /* fixme: check bounds  */
243   p += 4;
244   for (n=0; n < nsigs; n++, p += siginfolen)
245     {
246       ulong sflags;
247     
248       sflags = get32 (p);
249       fprintf (fp, "Sig-Expire[%lu]: ", n );
250       if (!sflags)
251         fputs ("[not checked]", fp);
252       else if (sflags == 1 )
253         fputs ("[missing key]", fp);
254       else if (sflags == 2 )
255         fputs ("[bad signature]", fp);
256       else if (sflags < 0x10000000)
257         fprintf (fp, "[bad flag %0lx]", sflags);
258       else if (sflags == 0xffffffff)
259         fputs ("0", fp );
260       else
261         fputs ("a time"/*strtimestamp( sflags )*/, fp );
262       putc ('\n', fp );
263     }
264
265   fprintf (fp, "Ownertrust: %d\n", p[0] );
266   fprintf (fp, "All-Validity: %d\n", p[1] );
267   p += 4;
268   n = get32 (p); p += 4;
269   fprintf (fp, "Recheck-After: %s\n", /*n? strtimestamp(n) :*/ "0" );
270   n = get32 (p ); p += 4;
271   fprintf( fp, "Latest-Timestamp: %s\n", "0"/*strtimestamp(n)*/ );
272   n = get32 (p ); p += 4;
273   fprintf (fp, "Created-At: %s\n", "0"/*strtimestamp(n)*/ );
274   n = get32 (p ); p += 4;
275   fprintf (fp, "Reserved-Space: %lu\n", n );
276
277   /* check that the keyblock is at the correct offset and other bounds */
278   /*fprintf (fp, "Blob-Checksum: [MD5-hash]\n");*/
279   return 0;
280 }
281
282
283 \f
284 int
285 _keybox_dump_file (const char *filename, FILE *outfp)
286 {
287   FILE *fp;
288   KEYBOXBLOB blob;
289   int rc;
290   unsigned long count = 0;
291
292   if (!filename)
293     {
294       filename = "-";
295       fp = stdin;
296     }
297   else
298     fp = fopen (filename, "rb");
299   if (!fp)
300     {
301       fprintf (outfp, "can't open `%s': %s\n", filename, strerror(errno));
302       return KEYBOX_File_Error;
303     }
304
305   while ( !(rc = _keybox_read_blob (&blob, fp)) )
306     {
307       fprintf (outfp, "BEGIN-RECORD: %lu\n", count );
308       _keybox_dump_blob (blob, outfp);
309       _keybox_release_blob (blob);
310       fprintf (outfp, "END-RECORD\n");
311       count++;
312     }
313   if (rc == -1)
314     rc = 0;
315   if (rc)
316     fprintf (outfp, "error reading `%s': %s\n", filename,
317              rc == KEYBOX_Read_Error? keybox_strerror(rc):strerror (errno));
318   
319   if (fp != stdin)
320     fclose (fp);
321   return rc;
322 }