Changed wording of passphrase checking messages.
[gnupg.git] / kbx / kbxutil.c
1 /* kbxutil.c - The Keybox utility
2  * Copyright (C) 2000, 2001, 2004, 2007 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 "../jnlib/logging.h"
33 #include "../jnlib/argparse.h"
34 #include "../jnlib/stringhelp.h"
35 #include "../jnlib/utf8conv.h"
36 #include "i18n.h"
37 #include "init.h"
38 #include "keybox-defs.h"
39
40 #include <gcrypt.h>
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   {0} /* 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 =
114             _("Please report bugs to " PACKAGE_BUGREPORT ".\n");
115         break;
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   /* Map the log levels.  */
137   switch (level)
138     {
139     case GCRY_LOG_CONT: level = JNLIB_LOG_CONT; break;
140     case GCRY_LOG_INFO: level = JNLIB_LOG_INFO; break;
141     case GCRY_LOG_WARN: level = JNLIB_LOG_WARN; break;
142     case GCRY_LOG_ERROR:level = JNLIB_LOG_ERROR; break;
143     case GCRY_LOG_FATAL:level = JNLIB_LOG_FATAL; break;
144     case GCRY_LOG_BUG:  level = JNLIB_LOG_BUG; break;
145     case GCRY_LOG_DEBUG:level = JNLIB_LOG_DEBUG; break;
146     default:            level = JNLIB_LOG_ERROR; break;  
147     }
148   log_logv (level, fmt, arg_ptr);
149 }
150
151
152
153 /*  static void */
154 /*  wrong_args( const char *text ) */
155 /*  { */
156 /*      log_error("usage: kbxutil %s\n", text); */
157 /*      myexit ( 1 ); */
158 /*  } */
159
160
161 #if 0
162 static int
163 hextobyte( const byte *s )
164 {
165     int c;
166
167     if( *s >= '0' && *s <= '9' )
168         c = 16 * (*s - '0');
169     else if( *s >= 'A' && *s <= 'F' )
170         c = 16 * (10 + *s - 'A');
171     else if( *s >= 'a' && *s <= 'f' )
172         c = 16 * (10 + *s - 'a');
173     else
174         return -1;
175     s++;
176     if( *s >= '0' && *s <= '9' )
177         c += *s - '0';
178     else if( *s >= 'A' && *s <= 'F' )
179         c += 10 + *s - 'A';
180     else if( *s >= 'a' && *s <= 'f' )
181         c += 10 + *s - 'a';
182     else
183         return -1;
184     return c;
185 }
186 #endif
187
188 #if 0
189 static char *
190 format_fingerprint ( const char *s )
191 {
192     int i, c;
193     byte fpr[20];
194
195     for (i=0; i < 20 && *s; ) {
196         if ( *s == ' ' || *s == '\t' ) {
197             s++;
198             continue;
199         }
200         c = hextobyte(s);
201         if (c == -1) {
202             return NULL;
203         }
204         fpr[i++] = c;
205         s += 2;
206     }
207     return gcry_xstrdup ( fpr );
208 }
209 #endif
210
211 #if 0
212 static int
213 format_keyid ( const char *s, u32 *kid )
214 {
215     char helpbuf[9];
216     switch ( strlen ( s ) ) {
217       case 8:
218         kid[0] = 0;
219         kid[1] = strtoul( s, NULL, 16 );
220         return 10;
221
222       case 16:
223         mem2str( helpbuf, s, 9 );
224         kid[0] = strtoul( helpbuf, NULL, 16 );
225         kid[1] = strtoul( s+8, NULL, 16 );
226         return 11;
227     }
228     return 0; /* error */
229 }
230 #endif
231
232 static char *
233 read_file (const char *fname, size_t *r_length)
234 {
235   FILE *fp;
236   char *buf;
237   size_t buflen;
238   
239   if (!strcmp (fname, "-"))
240     {
241       size_t nread, bufsize = 0;
242
243       fp = stdin;
244       buf = NULL;
245       buflen = 0;
246 #define NCHUNK 8192
247       do 
248         {
249           bufsize += NCHUNK;
250           if (!buf)
251             buf = xtrymalloc (bufsize);
252           else
253             buf = xtryrealloc (buf, bufsize);
254           if (!buf)
255             log_fatal ("can't allocate buffer: %s\n", strerror (errno));
256
257           nread = fread (buf+buflen, 1, NCHUNK, fp);
258           if (nread < NCHUNK && ferror (fp))
259             {
260               log_error ("error reading `[stdin]': %s\n", strerror (errno));
261               xfree (buf);
262               return NULL;
263             }
264           buflen += nread;
265         }
266       while (nread == NCHUNK);
267 #undef NCHUNK
268
269     }
270   else
271     {
272       struct stat st;
273
274       fp = fopen (fname, "rb");
275       if (!fp)
276         {
277           log_error ("can't open `%s': %s\n", fname, strerror (errno));
278           return NULL;
279         }
280   
281       if (fstat (fileno(fp), &st))
282         {
283           log_error ("can't stat `%s': %s\n", fname, strerror (errno));
284           fclose (fp);
285           return NULL;
286         }
287       
288       buflen = st.st_size;
289       buf = xtrymalloc (buflen+1);
290       if (!buf)
291         log_fatal ("can't allocate buffer: %s\n", strerror (errno));
292       if (fread (buf, buflen, 1, fp) != 1)
293         {
294           log_error ("error reading `%s': %s\n", fname, strerror (errno));
295           fclose (fp);
296           xfree (buf);
297           return NULL;
298         }
299       fclose (fp);
300     }
301
302   *r_length = buflen;
303   return buf;
304 }
305
306
307 static void
308 dump_fpr (const unsigned char *buffer, size_t len)
309 {
310   int i;
311
312   for (i=0; i < len; i++, buffer++)
313     {
314       if (len == 20)
315         {
316           if (i == 10)
317             putchar (' ');
318           printf (" %02X%02X", buffer[0], buffer[1]);
319           i++; buffer++;
320         }
321       else
322         {
323           if (i && !(i % 8))
324             putchar (' ');
325           printf (" %02X", buffer[0]);
326         }
327     }
328 }
329
330
331 static void
332 dump_openpgp_key (keybox_openpgp_info_t info, const unsigned char *image)
333 {
334   printf ("pub %02X%02X%02X%02X",
335           info->primary.keyid[4], info->primary.keyid[5],
336           info->primary.keyid[6], info->primary.keyid[7] );
337   dump_fpr (info->primary.fpr, info->primary.fprlen);
338   putchar ('\n');
339   if (info->nsubkeys)
340     {
341       struct _keybox_openpgp_key_info *k;
342
343       k = &info->subkeys;
344       do 
345         {
346           printf ("sub %02X%02X%02X%02X",
347                   k->keyid[4], k->keyid[5],
348                   k->keyid[6], k->keyid[7] );
349           dump_fpr (k->fpr, k->fprlen);
350           putchar ('\n');
351           k = k->next;
352         }
353       while (k);
354     }
355   if (info->nuids)
356     {
357       struct _keybox_openpgp_uid_info *u;
358
359       u = &info->uids;
360       do 
361         {
362           printf ("uid\t\t%.*s\n", (int)u->len, image + u->off);
363           u = u->next;
364         }
365       while (u);
366     }
367 }
368
369
370 static void
371 import_openpgp (const char *filename)
372 {
373   gpg_error_t err;
374   char *buffer;
375   size_t buflen, nparsed;
376   unsigned char *p;
377   struct _keybox_openpgp_info info;
378
379   buffer = read_file (filename, &buflen);
380   if (!buffer)
381     return;
382   p = (unsigned char *)buffer;
383   for (;;)
384     {
385       err = _keybox_parse_openpgp (p, buflen, &nparsed, &info);
386       assert (nparsed <= buflen);
387       if (err)
388         {
389           if (gpg_err_code (err) == GPG_ERR_NO_DATA)
390             break;
391           log_info ("%s: failed to parse OpenPGP keyblock: %s\n",
392                     filename, gpg_strerror (err));
393         }
394       else
395         {
396           dump_openpgp_key (&info, p);
397           _keybox_destroy_openpgp_info (&info);
398         }
399       p += nparsed;
400       buflen -= nparsed;
401     }
402   xfree (buffer);
403 }
404
405
406
407
408 int
409 main( int argc, char **argv )
410 {
411   ARGPARSE_ARGS pargs;
412   enum cmd_and_opt_values cmd = 0;
413   unsigned long from = 0, to = ULONG_MAX;
414   
415   set_strusage( my_strusage );
416   gcry_control (GCRYCTL_DISABLE_SECMEM);
417   log_set_prefix ("kbxutil", 1); 
418
419   /* Make sure that our subsystems are ready.  */
420   init_common_subsystems ();
421
422   i18n_init ();
423
424   /* Check that the libraries are suitable.  Do it here because
425      the option parsing may need services of the library.  */
426   if (!gcry_check_version (NEED_LIBGCRYPT_VERSION) )
427     {
428       log_fatal (_("%s is too old (need %s, have %s)\n"), "libgcrypt",
429                  NEED_LIBGCRYPT_VERSION, gcry_check_version (NULL) );
430     }
431
432   gcry_set_log_handler (my_gcry_logger, NULL);
433
434   /*create_dotlock(NULL); register locking cleanup */
435
436   /* We need to use the gcry malloc function because jnlib does use them */
437   keybox_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
438   ksba_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free );
439
440
441   pargs.argc = &argc;
442   pargs.argv = &argv;
443   pargs.flags=  1;  /* do not remove the args */
444   while (arg_parse( &pargs, opts) )
445     {
446       switch (pargs.r_opt)
447         {
448         case oVerbose:
449           /*opt.verbose++;*/
450           /*gcry_control( GCRYCTL_SET_VERBOSITY, (int)opt.verbose );*/
451           break;
452         case oDebug:
453           /*opt.debug |= pargs.r.ret_ulong; */
454           break;
455         case oDebugAll:
456           /*opt.debug = ~0;*/
457           break;
458
459         case aFindByFpr:
460         case aFindByKid:
461         case aFindByUid:
462         case aStats:
463         case aImportOpenPGP:
464         case aFindDups:
465         case aCut:
466           cmd = pargs.r_opt;
467           break;
468
469         case oFrom: from = pargs.r.ret_ulong; break;
470         case oTo: to = pargs.r.ret_ulong; break;
471
472         default:
473           pargs.err = 2;
474           break;
475         }
476     }
477   
478   if (to < from)
479     log_error ("record number of \"--to\" is lower than \"--from\" one\n");
480
481
482   if (log_get_errorcount(0) )
483     myexit(2);
484   
485   if (!cmd)
486     { /* Default is to list a KBX file */
487       if (!argc) 
488         _keybox_dump_file (NULL, 0, stdout);
489       else
490         {
491           for (; argc; argc--, argv++) 
492             _keybox_dump_file (*argv, 0, stdout);
493         }
494     }
495   else if (cmd == aStats )
496     {
497       if (!argc) 
498         _keybox_dump_file (NULL, 1, stdout);
499       else
500         {
501           for (; argc; argc--, argv++) 
502             _keybox_dump_file (*argv, 1, stdout);
503         }
504     }
505   else if (cmd == aFindDups )
506     {
507       if (!argc) 
508         _keybox_dump_find_dups (NULL, 0, stdout);
509       else
510         {
511           for (; argc; argc--, argv++) 
512             _keybox_dump_find_dups (*argv, 0, stdout);
513         }
514     }
515   else if (cmd == aCut )
516     {
517       if (!argc) 
518         _keybox_dump_cut_records (NULL, from, to, stdout);
519       else
520         {
521           for (; argc; argc--, argv++) 
522             _keybox_dump_cut_records (*argv, from, to, stdout);
523         }
524     }
525   else if (cmd == aImportOpenPGP)
526     {
527       if (!argc)
528         import_openpgp ("-");
529       else
530         {
531           for (; argc; argc--, argv++) 
532             import_openpgp (*argv);
533         }
534     }
535 #if 0
536   else if ( cmd == aFindByFpr ) 
537     {
538       char *fpr;
539       if ( argc != 2 )
540         wrong_args ("kbxfile foingerprint");
541       fpr = format_fingerprint ( argv[1] );
542       if ( !fpr )
543         log_error ("invalid formatted fingerprint\n");
544       else 
545         {
546           kbxfile_search_by_fpr ( argv[0], fpr );
547           gcry_free ( fpr );
548         }
549     }
550   else if ( cmd == aFindByKid ) 
551     {
552       u32 kid[2];
553       int mode;
554       
555       if ( argc != 2 )
556         wrong_args ("kbxfile short-or-long-keyid");
557       mode = format_keyid ( argv[1], kid );
558       if ( !mode )
559         log_error ("invalid formatted keyID\n");
560       else
561         {
562           kbxfile_search_by_kid ( argv[0], kid, mode );
563         }
564     }
565   else if ( cmd == aFindByUid ) 
566     {
567       if ( argc != 2 )
568         wrong_args ("kbxfile userID");
569       kbxfile_search_by_uid ( argv[0], argv[1] );
570     }
571 #endif
572   else
573       log_error ("unsupported action\n");
574   
575   myexit(0);
576   return 8; /*NEVER REACHED*/
577 }
578
579
580 void
581 myexit( int rc )
582 {
583   /*    if( opt.debug & DBG_MEMSTAT_VALUE ) {*/
584 /*      gcry_control( GCRYCTL_DUMP_MEMORY_STATS ); */
585 /*      gcry_control( GCRYCTL_DUMP_RANDOM_STATS ); */
586   /*    }*/
587 /*      if( opt.debug ) */
588 /*      gcry_control( GCRYCTL_DUMP_SECMEM_STATS ); */
589     rc = rc? rc : log_get_errorcount(0)? 2 :
590                         keybox_errors_seen? 1 : 0;
591     exit(rc );
592 }
593
594