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