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