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