Changed to GPLv3.
[gnupg.git] / kbx / kbxutil.c
1 /* kbxutil.c - The Keybox utility
2  *      Copyright (C) 2000, 2001, 2004 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 <errno.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <ctype.h>
26 #include <sys/stat.h>
27 #include <unistd.h>
28 #include <assert.h>
29
30 #define JNLIB_NEED_LOG_LOGV
31 #include "../jnlib/logging.h"
32 #include "../jnlib/argparse.h"
33 #include "../jnlib/stringhelp.h"
34 #include "../jnlib/utf8conv.h"
35 #include "i18n.h"
36 #include "init.h"
37 #include "keybox-defs.h"
38
39 #include <gcrypt.h>
40
41 enum cmd_and_opt_values {
42   aNull = 0,
43   oArmor          = 'a',
44   oDryRun         = 'n',
45   oOutput         = 'o',
46   oQuiet          = 'q',
47   oVerbose        = 'v',
48   
49   aNoSuchCmd    = 500,   /* force other values not to be a letter */
50   aFindByFpr,
51   aFindByKid,
52   aFindByUid,
53   aStats,
54   aImportOpenPGP,
55
56   oDebug,
57   oDebugAll,
58
59   oNoArmor,
60   
61
62   aTest
63 };
64
65
66 static ARGPARSE_OPTS opts[] = {
67   { 300, NULL, 0, N_("@Commands:\n ") },
68
69 /*   { aFindByFpr,  "find-by-fpr", 0, "|FPR| find key using it's fingerprnt" }, */
70 /*   { aFindByKid,  "find-by-kid", 0, "|KID| find key using it's keyid" }, */
71 /*   { aFindByUid,  "find-by-uid", 0, "|NAME| find key by user name" }, */
72   { aStats,      "stats",       0, "show key statistics" }, 
73   { aImportOpenPGP, "import-openpgp", 0, "import OpenPGP keyblocks"},
74   
75   { 301, NULL, 0, N_("@\nOptions:\n ") },
76   
77 /*   { oArmor, "armor",     0, N_("create ascii armored output")}, */
78 /*   { oArmor, "armour",     0, "@" }, */
79 /*   { oOutput, "output",    2, N_("use as output file")}, */
80   { oVerbose, "verbose",   0, N_("verbose") },
81   { oQuiet,     "quiet",   0, N_("be somewhat more quiet") },
82   { oDryRun, "dry-run",   0, N_("do not make any changes") },
83   
84   { oDebug, "debug"     ,4|16, N_("set debugging flags")},
85   { oDebugAll, "debug-all" ,0, N_("enable full debugging")},
86
87   {0} /* end of list */
88 };
89
90
91 void myexit (int rc);
92
93 int keybox_errors_seen = 0;
94
95
96 static const char *
97 my_strusage( int level )
98 {
99     const char *p;
100     switch( level ) {
101       case 11: p = "kbxutil (GnuPG)";
102         break;
103       case 13: p = VERSION; break;
104       case 17: p = PRINTABLE_OS_NAME; break;
105       case 19: p =
106             _("Please report bugs to " PACKAGE_BUGREPORT ".\n");
107         break;
108       case 1:
109       case 40:  p =
110             _("Usage: kbxutil [options] [files] (-h for help)");
111         break;
112       case 41:  p =
113             _("Syntax: kbxutil [options] [files]\n"
114               "list, export, import Keybox data\n");
115         break;
116
117
118       default:  p = NULL;
119     }
120     return p;
121 }
122
123
124 /* Used by gcry for logging */
125 static void
126 my_gcry_logger (void *dummy, int level, const char *fmt, va_list arg_ptr)
127 {
128   /* Map the log levels.  */
129   switch (level)
130     {
131     case GCRY_LOG_CONT: level = JNLIB_LOG_CONT; break;
132     case GCRY_LOG_INFO: level = JNLIB_LOG_INFO; break;
133     case GCRY_LOG_WARN: level = JNLIB_LOG_WARN; break;
134     case GCRY_LOG_ERROR:level = JNLIB_LOG_ERROR; break;
135     case GCRY_LOG_FATAL:level = JNLIB_LOG_FATAL; break;
136     case GCRY_LOG_BUG:  level = JNLIB_LOG_BUG; break;
137     case GCRY_LOG_DEBUG:level = JNLIB_LOG_DEBUG; break;
138     default:            level = JNLIB_LOG_ERROR; break;  
139     }
140   log_logv (level, fmt, arg_ptr);
141 }
142
143
144
145 /*  static void */
146 /*  wrong_args( const char *text ) */
147 /*  { */
148 /*      log_error("usage: kbxutil %s\n", text); */
149 /*      myexit ( 1 ); */
150 /*  } */
151
152
153 #if 0
154 static int
155 hextobyte( const byte *s )
156 {
157     int c;
158
159     if( *s >= '0' && *s <= '9' )
160         c = 16 * (*s - '0');
161     else if( *s >= 'A' && *s <= 'F' )
162         c = 16 * (10 + *s - 'A');
163     else if( *s >= 'a' && *s <= 'f' )
164         c = 16 * (10 + *s - 'a');
165     else
166         return -1;
167     s++;
168     if( *s >= '0' && *s <= '9' )
169         c += *s - '0';
170     else if( *s >= 'A' && *s <= 'F' )
171         c += 10 + *s - 'A';
172     else if( *s >= 'a' && *s <= 'f' )
173         c += 10 + *s - 'a';
174     else
175         return -1;
176     return c;
177 }
178 #endif
179
180 #if 0
181 static char *
182 format_fingerprint ( const char *s )
183 {
184     int i, c;
185     byte fpr[20];
186
187     for (i=0; i < 20 && *s; ) {
188         if ( *s == ' ' || *s == '\t' ) {
189             s++;
190             continue;
191         }
192         c = hextobyte(s);
193         if (c == -1) {
194             return NULL;
195         }
196         fpr[i++] = c;
197         s += 2;
198     }
199     return gcry_xstrdup ( fpr );
200 }
201 #endif
202
203 #if 0
204 static int
205 format_keyid ( const char *s, u32 *kid )
206 {
207     char helpbuf[9];
208     switch ( strlen ( s ) ) {
209       case 8:
210         kid[0] = 0;
211         kid[1] = strtoul( s, NULL, 16 );
212         return 10;
213
214       case 16:
215         mem2str( helpbuf, s, 9 );
216         kid[0] = strtoul( helpbuf, NULL, 16 );
217         kid[1] = strtoul( s+8, NULL, 16 );
218         return 11;
219     }
220     return 0; /* error */
221 }
222 #endif
223
224 static char *
225 read_file (const char *fname, size_t *r_length)
226 {
227   FILE *fp;
228   char *buf;
229   size_t buflen;
230   
231   if (!strcmp (fname, "-"))
232     {
233       size_t nread, bufsize = 0;
234
235       fp = stdin;
236       buf = NULL;
237       buflen = 0;
238 #define NCHUNK 8192
239       do 
240         {
241           bufsize += NCHUNK;
242           if (!buf)
243             buf = xtrymalloc (bufsize);
244           else
245             buf = xtryrealloc (buf, bufsize);
246           if (!buf)
247             log_fatal ("can't allocate buffer: %s\n", strerror (errno));
248
249           nread = fread (buf+buflen, 1, NCHUNK, fp);
250           if (nread < NCHUNK && ferror (fp))
251             {
252               log_error ("error reading `[stdin]': %s\n", strerror (errno));
253               xfree (buf);
254               return NULL;
255             }
256           buflen += nread;
257         }
258       while (nread == NCHUNK);
259 #undef NCHUNK
260
261     }
262   else
263     {
264       struct stat st;
265
266       fp = fopen (fname, "rb");
267       if (!fp)
268         {
269           log_error ("can't open `%s': %s\n", fname, strerror (errno));
270           return NULL;
271         }
272   
273       if (fstat (fileno(fp), &st))
274         {
275           log_error ("can't stat `%s': %s\n", fname, strerror (errno));
276           fclose (fp);
277           return NULL;
278         }
279       
280       buflen = st.st_size;
281       buf = xtrymalloc (buflen+1);
282       if (!buf)
283         log_fatal ("can't allocate buffer: %s\n", strerror (errno));
284       if (fread (buf, buflen, 1, fp) != 1)
285         {
286           log_error ("error reading `%s': %s\n", fname, strerror (errno));
287           fclose (fp);
288           xfree (buf);
289           return NULL;
290         }
291       fclose (fp);
292     }
293
294   *r_length = buflen;
295   return buf;
296 }
297
298
299 static void
300 dump_fpr (const unsigned char *buffer, size_t len)
301 {
302   int i;
303
304   for (i=0; i < len; i++, buffer++)
305     {
306       if (len == 20)
307         {
308           if (i == 10)
309             putchar (' ');
310           printf (" %02X%02X", buffer[0], buffer[1]);
311           i++; buffer++;
312         }
313       else
314         {
315           if (i && !(i % 8))
316             putchar (' ');
317           printf (" %02X", buffer[0]);
318         }
319     }
320 }
321
322
323 static void
324 dump_openpgp_key (keybox_openpgp_info_t info, const unsigned char *image)
325 {
326   printf ("pub %02X%02X%02X%02X",
327           info->primary.keyid[4], info->primary.keyid[5],
328           info->primary.keyid[6], info->primary.keyid[7] );
329   dump_fpr (info->primary.fpr, info->primary.fprlen);
330   putchar ('\n');
331   if (info->nsubkeys)
332     {
333       struct _keybox_openpgp_key_info *k;
334
335       k = &info->subkeys;
336       do 
337         {
338           printf ("sub %02X%02X%02X%02X",
339                   k->keyid[4], k->keyid[5],
340                   k->keyid[6], k->keyid[7] );
341           dump_fpr (k->fpr, k->fprlen);
342           putchar ('\n');
343           k = k->next;
344         }
345       while (k);
346     }
347   if (info->nuids)
348     {
349       struct _keybox_openpgp_uid_info *u;
350
351       u = &info->uids;
352       do 
353         {
354           printf ("uid\t\t%.*s\n", (int)u->len, image + u->off);
355           u = u->next;
356         }
357       while (u);
358     }
359 }
360
361
362 static void
363 import_openpgp (const char *filename)
364 {
365   gpg_error_t err;
366   char *buffer;
367   size_t buflen, nparsed;
368   unsigned char *p;
369   struct _keybox_openpgp_info info;
370
371   buffer = read_file (filename, &buflen);
372   if (!buffer)
373     return;
374   p = (unsigned char *)buffer;
375   for (;;)
376     {
377       err = _keybox_parse_openpgp (p, buflen, &nparsed, &info);
378       assert (nparsed <= buflen);
379       if (err)
380         {
381           if (gpg_err_code (err) == GPG_ERR_NO_DATA)
382             break;
383           log_info ("%s: failed to parse OpenPGP keyblock: %s\n",
384                     filename, gpg_strerror (err));
385         }
386       else
387         {
388           dump_openpgp_key (&info, p);
389           _keybox_destroy_openpgp_info (&info);
390         }
391       p += nparsed;
392       buflen -= nparsed;
393     }
394   xfree (buffer);
395 }
396
397
398
399
400 int
401 main( int argc, char **argv )
402 {
403   ARGPARSE_ARGS pargs;
404   enum cmd_and_opt_values cmd = 0;
405   
406   set_strusage( my_strusage );
407   gcry_control (GCRYCTL_DISABLE_SECMEM);
408   log_set_prefix ("kbxutil", 1); 
409
410   /* Make sure that our subsystems are ready.  */
411   init_common_subsystems ();
412
413   i18n_init ();
414
415   /* Check that the libraries are suitable.  Do it here because
416      the option parsing may need services of the library.  */
417   if (!gcry_check_version (NEED_LIBGCRYPT_VERSION) )
418     {
419       log_fatal (_("%s is too old (need %s, have %s)\n"), "libgcrypt",
420                  NEED_LIBGCRYPT_VERSION, gcry_check_version (NULL) );
421     }
422
423   gcry_set_log_handler (my_gcry_logger, NULL);
424
425   /*create_dotlock(NULL); register locking cleanup */
426
427   /* We need to use the gcry malloc function because jnlib does use them */
428   keybox_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
429   ksba_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free );
430
431
432   pargs.argc = &argc;
433   pargs.argv = &argv;
434   pargs.flags=  1;  /* do not remove the args */
435   while (arg_parse( &pargs, opts) )
436     {
437       switch (pargs.r_opt)
438         {
439         case oVerbose:
440           /*opt.verbose++;*/
441           /*gcry_control( GCRYCTL_SET_VERBOSITY, (int)opt.verbose );*/
442           break;
443         case oDebug:
444           /*opt.debug |= pargs.r.ret_ulong; */
445           break;
446         case oDebugAll:
447           /*opt.debug = ~0;*/
448           break;
449
450         case aFindByFpr:
451         case aFindByKid:
452         case aFindByUid:
453         case aStats:
454         case aImportOpenPGP:
455           cmd = pargs.r_opt;
456           break;
457
458         default:
459           pargs.err = 2;
460           break;
461         }
462     }
463   if (log_get_errorcount(0) )
464     myexit(2);
465   
466   if (!cmd)
467     { /* Default is to list a KBX file */
468       if (!argc) 
469         _keybox_dump_file (NULL, 0, stdout);
470       else
471         {
472           for (; argc; argc--, argv++) 
473             _keybox_dump_file (*argv, 0, stdout);
474         }
475     }
476   else if (cmd == aStats )
477     {
478       if (!argc) 
479         _keybox_dump_file (NULL, 1, stdout);
480       else
481         {
482           for (; argc; argc--, argv++) 
483             _keybox_dump_file (*argv, 1, stdout);
484         }
485     }
486   else if (cmd == aImportOpenPGP)
487     {
488       if (!argc)
489         import_openpgp ("-");
490       else
491         {
492           for (; argc; argc--, argv++) 
493             import_openpgp (*argv);
494         }
495     }
496 #if 0
497   else if ( cmd == aFindByFpr ) 
498     {
499       char *fpr;
500       if ( argc != 2 )
501         wrong_args ("kbxfile foingerprint");
502       fpr = format_fingerprint ( argv[1] );
503       if ( !fpr )
504         log_error ("invalid formatted fingerprint\n");
505       else 
506         {
507           kbxfile_search_by_fpr ( argv[0], fpr );
508           gcry_free ( fpr );
509         }
510     }
511   else if ( cmd == aFindByKid ) 
512     {
513       u32 kid[2];
514       int mode;
515       
516       if ( argc != 2 )
517         wrong_args ("kbxfile short-or-long-keyid");
518       mode = format_keyid ( argv[1], kid );
519       if ( !mode )
520         log_error ("invalid formatted keyID\n");
521       else
522         {
523           kbxfile_search_by_kid ( argv[0], kid, mode );
524         }
525     }
526   else if ( cmd == aFindByUid ) 
527     {
528       if ( argc != 2 )
529         wrong_args ("kbxfile userID");
530       kbxfile_search_by_uid ( argv[0], argv[1] );
531     }
532 #endif
533   else
534       log_error ("unsupported action\n");
535   
536   myexit(0);
537   return 8; /*NEVER REACHED*/
538 }
539
540
541 void
542 myexit( int rc )
543 {
544   /*    if( opt.debug & DBG_MEMSTAT_VALUE ) {*/
545 /*      gcry_control( GCRYCTL_DUMP_MEMORY_STATS ); */
546 /*      gcry_control( GCRYCTL_DUMP_RANDOM_STATS ); */
547   /*    }*/
548 /*      if( opt.debug ) */
549 /*      gcry_control( GCRYCTL_DUMP_SECMEM_STATS ); */
550     rc = rc? rc : log_get_errorcount(0)? 2 :
551                         keybox_errors_seen? 1 : 0;
552     exit(rc );
553 }
554
555