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