changed trustdb design
[gnupg.git] / g10 / g10.c
1 /* g10.c - The GNUPG utility (main for gpg)
2  *      Copyright (C) 1998 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 <unistd.h>
27
28 /* #define MAINTAINER_OPTIONS */
29
30 #include "packet.h"
31 #include "iobuf.h"
32 #include "memory.h"
33 #include "util.h"
34 #include "main.h"
35 #include "options.h"
36 #include "keydb.h"
37 #include "mpi.h"
38 #include "cipher.h"
39 #include "filter.h"
40 #include "trustdb.h"
41 #include "ttyio.h"
42 #include "i18n.h"
43 #include "status.h"
44
45 #ifndef IS_G10MAINT
46   #define IS_G10 1
47 #endif
48
49
50 static ARGPARSE_OPTS opts[] = {
51
52     { 300, NULL, 0, N_("@Commands:\n ") },
53
54   #ifdef IS_G10
55     { 's', "sign",      256, N_("|[file]|make a signature")},
56     { 539, "clearsign", 256, N_("|[file]|make a clear text signature") },
57     { 'b', "detach-sign", 256, N_("make a detached signature")},
58     { 'e', "encrypt",   256, N_("encrypt data")},
59     { 'c', "symmetric", 256, N_("encryption only with symmetric cipher")},
60     { 507, "store",     256, N_("store only")},
61     { 'd', "decrypt",   256, N_("decrypt data (default)")},
62     { 550, "verify"   , 256, N_("verify a signature")},
63   #endif
64     { 551, "list-keys", 256, N_("list keys")},
65     { 552, "list-sigs", 256, N_("list keys and signatures")},
66     { 508, "check-sigs",256, N_("check key signatures")},
67     { 515, "fingerprint", 256, N_("list keys and fingerprints")},
68     { 558, "list-secret-keys", 256, N_("list secret keys")},
69   #ifdef IS_G10
70     { 503, "gen-key",   256, N_("generate a new key pair")},
71     { 554, "add-key",   256, N_("add a subkey to a key pair")},
72     { 506, "sign-key"  ,256, N_("make a signature on a key in the keyring")},
73     { 505, "delete-key",256, N_("remove key from the public keyring")},
74     { 524, "edit-key"  ,256, N_("edit a key signature")},
75     { 525, "change-passphrase", 256, N_("change the passphrase of your secret keyring")},
76     { 542, "gen-revoke",256, N_("generate a revocation certificate")},
77   #endif
78     { 537, "export"          , 256, N_("export keys") },
79     { 563, "export-secret-keys" , 256, "@" },
80     { 565, "do-not-export-rsa", 0, "@" },
81     { 530, "import",      256     , N_("import/merge keys")},
82     { 521, "list-packets",256,N_("list only the sequence of packets")},
83   #ifdef IS_G10MAINT
84     { 564, "list-ownertrust", 256, N_("list the ownertrust values")},
85     { 567, "check-trustdb",0 , N_("|[NAMES]|check the trust database")},
86     { 546, "dearmor", 256, N_("De-Armor a file or stdin") },
87     { 547, "enarmor", 256, N_("En-Armor a file or stdin") },
88     { 555, "print-md" , 256, N_("|algo [files]|print message digests")},
89     { 516, "print-mds" , 256, N_("print all message digests")},
90     #ifdef MAINTAINER_OPTIONS
91     { 513, "gen-prime" , 256, "@" },
92     { 548, "gen-random" , 256, "@" },
93     #endif
94   #endif
95
96     { 301, NULL, 0, N_("@\nOptions:\n ") },
97
98     { 'a', "armor",     0, N_("create ascii armored output")},
99   #ifdef IS_G10
100     { 'u', "local-user",2, N_("use this user-id to sign or decrypt")},
101     { 'r', "remote-user", 2, N_("use this user-id for encryption")},
102     { 'z', NULL,        1, N_("|N|set compress level N (0 disables)") },
103     { 't', "textmode",  0, N_("use canonical text mode")},
104   #endif
105     { 'o', "output",    2, N_("use as output file")},
106     { 'v', "verbose",   0, N_("verbose") },
107     { 'n', "dry-run",   0, N_("do not make any changes") },
108     { 500, "batch",     0, N_("batch mode: never ask")},
109     { 501, "yes",       0, N_("assume yes on most questions")},
110     { 502, "no",        0, N_("assume no on most questions")},
111     { 509, "keyring"   ,2, N_("add this keyring to the list of keyrings")},
112     { 517, "secret-keyring" ,2, N_("add this secret keyring to the list")},
113     { 541, "default-key" ,2, N_("|NAME|use NAME as default secret key")},
114     { 518, "options"   , 2, N_("read options from file")},
115
116     { 510, "debug"     ,4|16, N_("set debugging flags")},
117     { 511, "debug-all" ,0, N_("enable full debugging")},
118     { 512, "status-fd" ,1, N_("|FD|write status info to this FD") },
119     { 534, "no-comment", 0,   N_("do not write comment packets")},
120     { 535, "completes-needed", 1, N_("(default is 1)")},
121     { 536, "marginals-needed", 1, N_("(default is 3)")},
122     { 560, "load-extension" ,2, N_("|file|load extension module")},
123     { 561, "rfc1991",   0, N_("emulate the mode described in RFC1991")},
124   #ifdef IS_G10
125     { 527, "cipher-algo", 2 , N_("|NAME|use cipher algorithm NAME")},
126     { 529, "digest-algo", 2 , N_("|NAME|use message digest algorithm NAME")},
127     { 556, "compress-algo", 1 , N_("|N|use compress algorithm N")},
128   #else /* some dummies */
129     { 527, "cipher-algo", 2 , "@"},
130     { 529, "digest-algo", 2 , "@"},
131     { 556, "compress-algo", 1 , "@"},
132   #endif
133
134   #ifdef IS_G10
135     { 302, NULL, 0, N_("@\nExamples:\n\n"
136     " -se -r Bob [file]          sign and encrypt for user Bob\n"
137     " -sat [file]                make a clear text signature\n"
138     " -sb  [file]                make a detached signature\n"
139     " -k   [userid]              show keys\n"
140     " -kc  [userid]              show fingerprint\n"  ) },
141   #endif
142
143   /* hidden options */
144   #ifdef IS_G10MAINT
145     { 514, "test"      , 0, "@" },
146     { 564, "list-ownertrust",0 , "@"},
147     { 567, "check-trustdb",0 , "@"},
148     { 531, "list-trustdb",0 , "@"},
149     { 533, "list-trust-path",0, "@"},
150   #endif
151   #ifdef IS_G10
152     { 'k', NULL,        0, "@"},
153     { 504, "delete-secret-key",0, "@" },
154     { 524, "edit-sig"  ,0, "@"}, /* alias for edit-key */
155     { 523, "passphrase-fd",1, "@" },
156   #endif
157     { 532, "quick-random", 0, "@"},
158     { 526, "no-verbose", 0, "@"},
159     { 538, "trustdb-name", 2, "@" },
160     { 540, "no-secmem-warning", 0, "@" }, /* used only by regression tests */
161     { 519, "no-armor",   0, "@"},
162     { 520, "no-default-keyring", 0, "@" },
163     { 522, "no-greeting", 0, "@" },
164     { 543, "no-options", 0, "@" }, /* shortcut for --options /dev/null */
165     { 544, "homedir", 2, "@" },   /* defaults to "~/.gnupg" */
166     { 545, "no-batch", 0, "@" },
167     { 549, "with-colons", 0, "@"},
168     { 551, "list-key", 0, "@" }, /* alias */
169     { 552, "list-sig", 0, "@" }, /* alias */
170     { 508, "check-sig",0, "@" }, /* alias */
171     { 553, "skip-verify",0, "@" },
172     { 557, "compress-keys",0, "@"},
173     { 566, "compress-sigs",0, "@"},
174     { 559, "always-trust", 0, "@"},
175     { 562, "emulate-checksum-bug", 0, "@"},
176
177 {0} };
178
179
180 enum cmd_values { aNull = 0,
181     aSym, aStore, aEncr, aKeygen, aSign, aSignEncr,
182     aSignKey, aClearsign, aListPackets, aEditKey, aDeleteKey, aDeleteSecretKey,
183     aKMode, aKModeC, aChangePass, aImport, aVerify, aDecrypt, aListKeys,
184     aListSigs, aKeyadd, aListSecretKeys,
185     aExport, aExportSecret,
186     aCheckKeys, aGenRevoke, aPrimegen, aPrintMD, aPrintMDs,
187     aCheckTrustDB, aListTrustDB, aListTrustPath, aListOwnerTrust,
188     aDeArmor, aEnArmor, aGenRandom,
189 aTest };
190
191 static int maybe_setuid = 1;
192
193 static char *build_list( const char *text,
194                          const char *(*mapf)(int), int (*chkf)(int) );
195 static void set_cmd( enum cmd_values *ret_cmd,
196                         enum cmd_values new_cmd );
197 #ifdef IS_G10MAINT
198 static void print_hex( byte *p, size_t n );
199 static void print_mds( const char *fname, int algo );
200 #endif
201
202 const char *
203 strusage( int level )
204 {
205   static char *digests, *pubkeys, *ciphers;
206     const char *p;
207     switch( level ) {
208       case 11: p =
209           #ifdef IS_G10MAINT
210             "gpgm (GNUPG)";
211           #else
212             "gpg (GNUPG)";
213           #endif
214         break;
215       case 13: p = VERSION; break;
216       case 17: p = PRINTABLE_OS_NAME; break;
217       case 19: p =
218             _("Please report bugs to <gnupg-bugs@gnu.org>.\n");
219         break;
220       case 1:
221       case 40:  p =
222           #ifdef IS_G10MAINT
223             _("Usage: gpgm [options] [files] (-h for help)");
224           #else
225             _("Usage: gpg [options] [files] (-h for help)");
226           #endif
227         break;
228       case 41:  p =
229           #ifdef IS_G10MAINT
230             _("Syntax: gpgm [options] [files]\n"
231               "GNUPG maintenance utility\n");
232           #else
233             _("Syntax: gpg [options] [files]\n"
234               "sign, check, encrypt or decrypt\n"
235               "default operation depends on the input data\n");
236           #endif
237         break;
238
239       case 31: p = "\n"; break;
240       case 32:
241         if( !ciphers )
242             ciphers = build_list("Supported ciphers: ", cipher_algo_to_string,
243                                                         check_cipher_algo );
244         p = ciphers;
245         break;
246       case 33:
247         if( !pubkeys )
248             pubkeys = build_list("Supported pubkeys: ", pubkey_algo_to_string,
249                                                         check_pubkey_algo );
250         p = pubkeys;
251         break;
252       case 34:
253         if( !digests )
254             digests = build_list("Supported digests: ", digest_algo_to_string,
255                                                         check_digest_algo );
256         p = digests;
257         break;
258
259       default:  p = default_strusage(level);
260     }
261     return p;
262 }
263
264
265 static char *
266 build_list( const char *text, const char * (*mapf)(int), int (*chkf)(int) )
267 {
268     int i;
269     const char *s;
270     size_t n=strlen(text)+2;
271     char *list, *p;
272
273     if( maybe_setuid )
274         secmem_init( 0 );    /* drop setuid */
275
276     for(i=1; i < 110; i++ )
277         if( !chkf(i) && (s=mapf(i)) )
278             n += strlen(s) + 2;
279     list = m_alloc( 21 + n ); *list = 0;
280     for(p=NULL, i=1; i < 110; i++ ) {
281         if( !chkf(i) && (s=mapf(i)) ) {
282             if( !p )
283                 p = stpcpy( list, text );
284             else
285                 p = stpcpy( p, ", ");
286             p = stpcpy(p, s );
287         }
288     }
289     if( p )
290         p = stpcpy(p, "\n" );
291     return list;
292 }
293
294
295 static void
296 i18n_init(void)
297 {
298   #ifdef ENABLE_NLS
299     #ifdef HAVE_LC_MESSAGES
300        setlocale( LC_MESSAGES, "" );
301     #else
302        setlocale( LC_ALL, "" );
303     #endif
304     bindtextdomain( PACKAGE, G10_LOCALEDIR );
305     textdomain( PACKAGE );
306   #endif
307 }
308
309 static void
310 wrong_args( const char *text)
311 {
312   #ifdef IS_G10MAINT
313     fputs(_("usage: gpgm [options] "),stderr);
314   #else
315     fputs(_("usage: gpg [options] "),stderr);
316   #endif
317     fputs(text,stderr);
318     putc('\n',stderr);
319     g10_exit(2);
320 }
321
322 static void
323 set_debug(void)
324 {
325     if( opt.debug & DBG_MEMORY_VALUE )
326         memory_debug_mode = 1;
327     if( opt.debug & DBG_MEMSTAT_VALUE )
328         memory_stat_debug_mode = 1;
329     if( opt.debug & DBG_MPI_VALUE )
330         mpi_debug_mode = 1;
331     if( opt.debug & DBG_CIPHER_VALUE )
332         g10c_debug_mode = 1;
333     if( opt.debug & DBG_IOBUF_VALUE )
334         iobuf_debug_mode = 1;
335
336 }
337
338
339 static void
340 set_cmd( enum cmd_values *ret_cmd, enum cmd_values new_cmd )
341 {
342     enum cmd_values cmd = *ret_cmd;
343
344     if( !cmd || cmd == new_cmd )
345         cmd = new_cmd;
346     else if( cmd == aSign && new_cmd == aEncr )
347         cmd = aSignEncr;
348     else if( cmd == aEncr && new_cmd == aSign )
349         cmd = aSignEncr;
350     else if( cmd == aKMode && new_cmd == aSym )
351         cmd = aKModeC;
352     else if(    ( cmd == aSign     && new_cmd == aClearsign )
353              || ( cmd == aClearsign && new_cmd == aSign )  )
354         cmd = aClearsign;
355     else {
356         log_error(_("conflicting commands\n"));
357         g10_exit(2);
358     }
359
360     *ret_cmd = cmd;
361 }
362
363
364
365 static void
366 check_opts(void)
367 {
368     if( !opt.def_cipher_algo || check_cipher_algo(opt.def_cipher_algo) )
369         log_error(_("selected cipher algorithm is invalid\n"));
370     if( opt.def_digest_algo && check_digest_algo(opt.def_digest_algo) )
371         log_error(_("selected digest algorithm is invalid\n"));
372     if( opt.def_compress_algo < 1 || opt.def_compress_algo > 2 )
373         log_error(_("compress algorithm must be in range %d..%d\n"), 1, 2);
374     if( opt.completes_needed < 1 )
375         log_error(_("completes-needed must be greater than 0\n"));
376     if( opt.marginals_needed < 2 )
377         log_error(_("marginals-needed must be greater than 1\n"));
378 }
379
380
381
382
383 int
384 main( int argc, char **argv )
385 {
386     ARGPARSE_ARGS pargs;
387     IOBUF a;
388     int rc=0;
389     int orig_argc;
390     char **orig_argv;
391     const char *fname;
392     STRLIST sl, remusr= NULL, locusr=NULL;
393     STRLIST nrings=NULL, sec_nrings=NULL;
394     armor_filter_context_t afx;
395     int detached_sig = 0;
396     FILE *configfp = NULL;
397     char *configname = NULL;
398     unsigned configlineno;
399     int parse_debug = 0;
400     int default_config =1;
401     int errors=0;
402     int default_keyring = 1;
403     int greeting = 1;
404     enum cmd_values cmd = 0;
405     const char *trustdb_name = NULL;
406     char *def_cipher_string = NULL;
407     char *def_digest_string = NULL;
408
409     trap_unaligned();
410   #ifdef IS_G10MAINT
411     secmem_init( 0 );      /* disable use of secmem */
412     maybe_setuid = 0;
413     log_set_name("gpgm");
414   #else
415     /* Please note that we may running SUID(ROOT), so be very CAREFUL
416      * when adding any stuff between here and the call to
417      * secmem_init()  somewhere after the option parsing
418      */
419     log_set_name("gpg");
420     secure_random_alloc(); /* put random number into secure memory */
421     disable_core_dumps();
422     init_signals();
423   #endif
424     i18n_init();
425     opt.compress = -1; /* defaults to standard compress level */
426     /* fixme: set the next two to zero and decide where used */
427     opt.def_cipher_algo = DEFAULT_CIPHER_ALGO;
428     opt.def_digest_algo = 0;
429     opt.def_compress_algo = 2;
430     opt.completes_needed = 1;
431     opt.marginals_needed = 3;
432     opt.homedir = getenv("GNUPGHOME");
433     if( !opt.homedir || !*opt.homedir ) {
434       #ifdef __MINGW32__
435         opt.homedir = "c:/gnupg";
436       #else
437         opt.homedir = "~/.gnupg";
438       #endif
439     }
440
441     /* check whether we have a config file on the commandline */
442     orig_argc = argc;
443     orig_argv = argv;
444     pargs.argc = &argc;
445     pargs.argv = &argv;
446     pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
447     while( arg_parse( &pargs, opts) ) {
448         if( pargs.r_opt == 510 || pargs.r_opt == 511 )
449             parse_debug++;
450         else if( pargs.r_opt == 518 ) {
451             /* yes there is one, so we do not try the default one, but
452              * read the option file when it is encountered at the commandline
453              */
454             default_config = 0;
455         }
456         else if( pargs.r_opt == 543 )
457             default_config = 0; /* --no-options */
458         else if( pargs.r_opt == 544 )
459             opt.homedir = pargs.r.ret_str;
460     }
461
462     if( default_config )
463         configname = make_filename(opt.homedir, "options", NULL );
464
465     argc = orig_argc;
466     argv = orig_argv;
467     pargs.argc = &argc;
468     pargs.argv = &argv;
469     pargs.flags=  1;  /* do not remove the args */
470   next_pass:
471     if( configname ) {
472         configlineno = 0;
473         configfp = fopen( configname, "r" );
474         if( !configfp ) {
475             if( default_config ) {
476                 if( parse_debug )
477                     log_info(_("note: no default option file '%s'\n"),
478                                                             configname );
479             }
480             else {
481                 log_error(_("option file '%s': %s\n"),
482                                     configname, strerror(errno) );
483                 g10_exit(1);
484             }
485             m_free(configname); configname = NULL;
486         }
487         if( parse_debug && configname )
488             log_info(_("reading options from '%s'\n"), configname );
489         default_config = 0;
490     }
491
492     while( optfile_parse( configfp, configname, &configlineno,
493                                                 &pargs, opts) ) {
494         switch( pargs.r_opt ) {
495
496           case 'a': opt.armor = 1; opt.no_armor=0; break;
497         #ifdef IS_G10
498           case 'b': detached_sig = 1; set_cmd( &cmd, aSign ); break;
499           case 'c': set_cmd( &cmd, aSym); break;
500           case 'd': set_cmd( &cmd, aDecrypt); break;
501           case 'e': set_cmd( &cmd, aEncr); break;
502           case 'r': /* store the remote users */
503             sl = m_alloc( sizeof *sl + strlen(pargs.r.ret_str));
504             strcpy(sl->d, pargs.r.ret_str);
505             sl->next = remusr;
506             remusr = sl;
507             break;
508           case 's': set_cmd( &cmd, aSign );  break;
509           case 't': opt.textmode=1;  break;
510           case 'u': /* store the local users */
511             sl = m_alloc( sizeof *sl + strlen(pargs.r.ret_str));
512             strcpy(sl->d, pargs.r.ret_str);
513             sl->next = locusr;
514             locusr = sl;
515             break;
516           case 'z': opt.compress = pargs.r.ret_int; break;
517           case 503: set_cmd( &cmd, aKeygen); break;
518           case 504: set_cmd( &cmd, aDeleteSecretKey); break;
519           case 505: set_cmd( &cmd, aDeleteKey); break;
520           case 506: set_cmd( &cmd, aSignKey); break;
521           case 507: set_cmd( &cmd, aStore); break;
522           case 523: set_passphrase_fd( pargs.r.ret_int ); break;
523           case 524: set_cmd( &cmd, aEditKey); break;
524           case 525: set_cmd( &cmd, aChangePass); break;
525           case 527: def_cipher_string = m_strdup(pargs.r.ret_str); break;
526           case 529: def_digest_string = m_strdup(pargs.r.ret_str); break;
527           case 539: set_cmd( &cmd, aClearsign); break;
528           case 540: secmem_set_flags( secmem_get_flags() | 1 ); break;
529           case 542: set_cmd( &cmd, aGenRevoke); break;
530           case 550: set_cmd( &cmd, aVerify); break;
531         #else
532           case 527:
533           case 529:
534             break;
535         #endif /* !IS_G10 */
536
537         #ifdef IS_G10MAINT
538           #ifdef MAINTAINER_OPTIONS
539             case 513: set_cmd( &cmd, aPrimegen); break;
540             case 514: set_cmd( &cmd, aTest); break;
541             case 548: set_cmd( &cmd, aGenRandom); break;
542           #endif
543           case 516: set_cmd( &cmd, aPrintMDs); break;
544           case 531: set_cmd( &cmd, aListTrustDB); break;
545           case 567: set_cmd( &cmd, aCheckTrustDB); break;
546           case 533: set_cmd( &cmd, aListTrustPath); break;
547           case 540: break; /* dummy */
548           case 546: set_cmd( &cmd, aDeArmor); break;
549           case 547: set_cmd( &cmd, aEnArmor); break;
550           case 555: set_cmd( &cmd, aPrintMD); break;
551           case 564: set_cmd( &cmd, aListOwnerTrust); break;
552         #endif /* IS_G10MAINT */
553
554           case 'o': opt.outfile = pargs.r.ret_str; break;
555           case 'v': g10_opt_verbose++;
556                     opt.verbose++; opt.list_sigs=1; break;
557           case 'k': set_cmd( &cmd, aKMode ); break;
558
559           case 500: opt.batch = 1; greeting = 0; break;
560           case 501: opt.answer_yes = 1; break;
561           case 502: opt.answer_no = 1; break;
562           case 508: set_cmd( &cmd, aCheckKeys); break;
563           case 509: append_to_strlist( &nrings, pargs.r.ret_str); break;
564           case 510: opt.debug |= pargs.r.ret_ulong; break;
565           case 511: opt.debug = ~0; break;
566           case 512: set_status_fd( pargs.r.ret_int ); break;
567           case 515: opt.fingerprint = 1; break;
568           case 517: append_to_strlist( &sec_nrings, pargs.r.ret_str); break;
569           case 518:
570             /* config files may not be nested (silently ignore them) */
571             if( !configfp ) {
572                 m_free(configname);
573                 configname = m_strdup(pargs.r.ret_str);
574                 goto next_pass;
575             }
576             break;
577           case 519: opt.no_armor=1; opt.armor=0; break;
578           case 520: default_keyring = 0; break;
579           case 521: set_cmd( &cmd, aListPackets); break;
580           case 522: greeting = 0; break;
581           case 526: g10_opt_verbose = 0;
582                     opt.verbose = 0; opt.list_sigs=0; break;
583           case 530: set_cmd( &cmd, aImport); break;
584           case 532: quick_random_gen(1); break;
585           case 534: opt.no_comment=1; break;
586           case 535: opt.completes_needed = pargs.r.ret_int; break;
587           case 536: opt.marginals_needed = pargs.r.ret_int; break;
588           case 537: set_cmd( &cmd, aExport); break;
589           case 538: trustdb_name = pargs.r.ret_str; break;
590           case 541: opt.def_secret_key = pargs.r.ret_str; break;
591           case 543: break; /* no-options */
592           case 544: opt.homedir = pargs.r.ret_str; break;
593           case 545: opt.batch = 0; break;
594           case 549: opt.with_colons=':'; break;
595           case 551: set_cmd( &cmd, aListKeys); break;
596           case 552: set_cmd( &cmd, aListSigs); break;
597           case 553: opt.skip_verify=1; break;
598           case 554: set_cmd( &cmd, aKeyadd); break;
599           case 556: opt.def_compress_algo = pargs.r.ret_int; break;
600           case 557: opt.compress_keys = 1; break;
601           case 558: set_cmd( &cmd, aListSecretKeys); break;
602           case 559: opt.always_trust = 1; break;
603           case 560: register_cipher_extension(pargs.r.ret_str); break;
604           case 561: opt.rfc1991 = 1; break;
605           case 562: opt.emulate_bugs |= 1; break;
606           case 563: set_cmd( &cmd, aExportSecret); break;
607           case 565: opt.do_not_export_rsa = 1; break;
608           case 566: opt.compress_sigs = 1; break;
609           default : errors++; pargs.err = configfp? 1:2; break;
610         }
611     }
612     if( configfp ) {
613         fclose( configfp );
614         configfp = NULL;
615         m_free(configname); configname = NULL;
616         goto next_pass;
617     }
618     m_free( configname ); configname = NULL;
619     if( log_get_errorcount(0) )
620         g10_exit(2);
621
622     if( greeting ) {
623         tty_printf("%s %s; %s\n", strusage(11), strusage(13), strusage(14) );
624         tty_printf("%s\n", strusage(15) );
625     }
626
627   #ifdef IS_G10
628     /* initialize the secure memory. */
629     secmem_init( 16384 );
630     maybe_setuid = 0;
631     /* Okay, we are now working under our real uid */
632   #endif
633
634     /*write_status( STATUS_ENTER );*/
635
636     set_debug();
637
638     /* must do this after dropping setuid, because string_to...
639      * may try to load an module */
640     if( def_cipher_string ) {
641         opt.def_cipher_algo = string_to_cipher_algo(def_cipher_string);
642         m_free(def_cipher_string); def_cipher_string = NULL;
643     }
644     if( def_digest_string ) {
645         opt.def_digest_algo = string_to_digest_algo(def_digest_string);
646         m_free(def_digest_string); def_digest_string = NULL;
647     }
648     check_opts();
649     if( log_get_errorcount(0) )
650         g10_exit(2);
651
652     if( !cmd && opt.fingerprint )
653         set_cmd( &cmd, aListKeys);
654
655     if( cmd == aKMode || cmd == aKModeC ) { /* kludge to be compatible to pgp */
656         if( cmd == aKModeC ) {
657             opt.fingerprint = 1;
658             cmd = aKMode;
659         }
660         opt.list_sigs = 0;
661         if( opt.verbose > 2 )
662             opt.check_sigs++;
663         if( opt.verbose > 1 )
664             opt.list_sigs++;
665
666         opt.verbose = opt.verbose > 1;
667         g10_opt_verbose = opt.verbose;
668     }
669
670
671     /* kludge to let -sat generate a clear text signature */
672     if( opt.textmode && !detached_sig && opt.armor && cmd == aSign )
673         cmd = aClearsign;
674
675     if( opt.verbose > 1 )
676         set_packet_list_mode(1);
677
678     /* add the keyrings, but not for some special commands and
679      * not in case of "-kvv userid keyring" */
680     if( cmd != aDeArmor && cmd != aEnArmor
681         && !(cmd == aKMode && argc == 2 ) ) {
682
683         if( !sec_nrings || default_keyring )  /* add default secret rings */
684             add_secret_keyring("secring.gpg");
685         for(sl = sec_nrings; sl; sl = sl->next )
686             add_secret_keyring( sl->d );
687         if( !nrings || default_keyring )  /* add default ring */
688             add_keyring("pubring.gpg");
689         for(sl = nrings; sl; sl = sl->next )
690             add_keyring( sl->d );
691     }
692     FREE_STRLIST(nrings);
693     FREE_STRLIST(sec_nrings);
694
695     if( argc )
696         fname = *argv;
697     else {
698         fname = NULL;
699         if( get_passphrase_fd() == 0 ) {
700             /* reading data and passphrase from stdin:
701              * we assume the first line is the passphrase, so
702              * we should read it now.
703              *
704              * We should do it here, but for now it is not needed.
705              * Anyway, this password scheme is not quite good
706              */
707         }
708     }
709
710     switch( cmd ) {
711       case aPrimegen:
712       case aPrintMD:
713       case aPrintMDs:
714       case aGenRandom:
715       case aDeArmor:
716       case aEnArmor:
717         break;
718       case aKMode:
719       case aListKeys:
720       case aListSecretKeys:
721       case aCheckKeys:
722         if( opt.with_colons ) /* need this to list the trust */
723             rc = init_trustdb(1, trustdb_name );
724         break;
725       case aListOwnerTrust: rc = init_trustdb( 0, trustdb_name ); break;
726       case aListTrustDB: rc = init_trustdb( argc? 1:0, trustdb_name ); break;
727       default: rc = init_trustdb(1, trustdb_name ); break;
728     }
729     if( rc )
730         log_error(_("failed to initialize the TrustDB: %s\n"), g10_errstr(rc));
731
732
733     switch( cmd ) {
734       case aStore: /* only store the file */
735         if( argc > 1 )
736             wrong_args(_("--store [filename]"));
737         if( (rc = encode_store(fname)) )
738             log_error_f( print_fname_stdin(fname),
739                         "store failed: %s\n", g10_errstr(rc) );
740         break;
741     #ifdef IS_G10
742       case aSym: /* encrypt the given file only with the symmetric cipher */
743         if( argc > 1 )
744             wrong_args(_("--symmetric [filename]"));
745         if( (rc = encode_symmetric(fname)) )
746             log_error_f(print_fname_stdin(fname),
747                         "symmetric encryption failed: %s\n",g10_errstr(rc) );
748         break;
749
750       case aEncr: /* encrypt the given file */
751         if( argc > 1 )
752             wrong_args(_("--encrypt [filename]"));
753         if( (rc = encode_crypt(fname,remusr)) )
754             log_error("%s: encryption failed: %s\n", print_fname_stdin(fname), g10_errstr(rc) );
755         break;
756
757       case aSign: /* sign the given file */
758         sl = NULL;
759         if( detached_sig ) { /* sign all files */
760             for( ; argc; argc--, argv++ )
761                 add_to_strlist( &sl, *argv );
762         }
763         else {
764             if( argc > 1 )
765                 wrong_args(_("--sign [filename]"));
766             if( argc ) {
767                 sl = m_alloc_clear( sizeof *sl + strlen(fname));
768                 strcpy(sl->d, fname);
769             }
770         }
771         if( (rc = sign_file( sl, detached_sig, locusr, 0, NULL, NULL)) )
772             log_error("signing failed: %s\n", g10_errstr(rc) );
773         free_strlist(sl);
774         break;
775
776       case aSignEncr: /* sign and encrypt the given file */
777         if( argc > 1 )
778             wrong_args(_("--sign --encrypt [filename]"));
779         if( argc ) {
780             sl = m_alloc_clear( sizeof *sl + strlen(fname));
781             strcpy(sl->d, fname);
782         }
783         else
784             sl = NULL;
785         if( (rc = sign_file(sl, detached_sig, locusr, 1, remusr, NULL)) )
786             log_error("%s: sign+encrypt failed: %s\n", print_fname_stdin(fname), g10_errstr(rc) );
787         free_strlist(sl);
788         break;
789
790       case aClearsign: /* make a clearsig */
791         if( argc > 1 )
792             wrong_args(_("--clearsign [filename]"));
793         if( (rc = clearsign_file(fname, locusr, NULL)) )
794             log_error("%s: clearsign failed: %s\n", print_fname_stdin(fname), g10_errstr(rc) );
795         break;
796
797       case aVerify:
798         if( (rc = verify_signatures( argc, argv ) ))
799             log_error("verify signatures failed: %s\n", g10_errstr(rc) );
800         break;
801
802       case aDecrypt:
803         if( argc > 1 )
804             wrong_args(_("--decrypt [filename]"));
805         if( (rc = decrypt_message( fname ) ))
806             log_error("decrypt_message failed: %s\n", g10_errstr(rc) );
807         break;
808
809
810       case aSignKey: /* sign the key given as argument */
811         if( argc != 1 )
812             wrong_args(_("--sign-key username"));
813         /* note: fname is the user id! */
814         if( (rc = sign_key(fname, locusr)) )
815             log_error("%s: sign key failed: %s\n", print_fname_stdin(fname), g10_errstr(rc) );
816         break;
817
818       case aEditKey: /* Edit a key signature */
819         if( argc != 1 )
820             wrong_args(_("--edit-key username"));
821         /* note: fname is the user id! */
822         if( (rc = edit_keysigs(fname)) )
823             log_error("%s: edit signature failed: %s\n", print_fname_stdin(fname), g10_errstr(rc) );
824         break;
825
826       case aDeleteSecretKey:
827         if( argc != 1 )
828             wrong_args(_("--delete-secret-key username"));
829       case aDeleteKey:
830         if( argc != 1 )
831             wrong_args(_("--delete-key username"));
832         /* note: fname is the user id! */
833         if( (rc = delete_key(fname, cmd==aDeleteSecretKey)) )
834             log_error("%s: delete key failed: %s\n", print_fname_stdin(fname), g10_errstr(rc) );
835         break;
836
837       case aChangePass: /* Change the passphrase */
838         if( argc > 1 ) /* no arg: use default, 1 arg use this one */
839             wrong_args(_("--change-passphrase [username]"));
840         /* note: fname is the user id! */
841         if( (rc = change_passphrase(fname)) )
842             log_error("%s: change passphrase failed: %s\n", print_fname_stdin(fname),
843                                                        g10_errstr(rc) );
844         break;
845       #endif /* IS_G10 */
846
847       case aCheckKeys:
848         opt.check_sigs = 1;
849       case aListSigs:
850         opt.list_sigs = 1;
851       case aListKeys:
852         public_key_list( argc, argv );
853         break;
854       case aListSecretKeys:
855         secret_key_list( argc, argv );
856         break;
857
858       case aKMode: /* list keyring */
859         if( argc < 2 )  /* -kv [userid] */
860             public_key_list( (argc && **argv)? 1:0, argv );
861         else if( argc == 2 ) { /* -kv userid keyring */
862             if( access( argv[1], R_OK ) ) {
863                 log_error(_("can't open %s: %s\n"),
864                                print_fname_stdin(argv[1]), strerror(errno));
865             }
866             else {
867                 /* add keyring (default keyrings are not registered in this
868                  * special case */
869                 add_keyring( argv[1] );
870                 public_key_list( **argv?1:0, argv );
871             }
872         }
873         else
874             wrong_args(_("-k[v][v][v][c] [userid] [keyring]") );
875         break;
876
877     #ifdef IS_G10
878       case aKeygen: /* generate a key (interactive) */
879         if( argc )
880             wrong_args("--gen-key");
881         generate_keypair();
882         break;
883       case aKeyadd: /* add a subkey (interactive) */
884         if( argc != 1 )
885             wrong_args("--add-key userid");
886         generate_subkeypair(*argv);
887         break;
888     #endif
889
890       case aImport:
891         if( !argc  ) {
892             rc = import_keys( NULL );
893             if( rc )
894                 log_error("import failed: %s\n", g10_errstr(rc) );
895         }
896         for( ; argc; argc--, argv++ ) {
897             rc = import_keys( *argv );
898             if( rc )
899                 log_error("import from '%s' failed: %s\n",
900                                                 *argv, g10_errstr(rc) );
901         }
902         break;
903
904       case aExport:
905         sl = NULL;
906         for( ; argc; argc--, argv++ )
907             add_to_strlist( &sl, *argv );
908         export_pubkeys( sl );
909         free_strlist(sl);
910         break;
911
912       case aExportSecret:
913         sl = NULL;
914         for( ; argc; argc--, argv++ )
915             add_to_strlist( &sl, *argv );
916         export_seckeys( sl );
917         free_strlist(sl);
918         break;
919
920     #ifdef IS_G10
921       case aGenRevoke:
922         if( argc != 1 )
923             wrong_args("--gen-revoke user-id");
924         gen_revoke( *argv );
925         break;
926     #endif
927
928     #ifdef IS_G10MAINT
929       case aDeArmor:
930         if( argc > 1 )
931             wrong_args("--dearmor [file]");
932         rc = dearmor_file( argc? *argv: NULL );
933         if( rc )
934             log_error(_("dearmoring failed: %s\n"), g10_errstr(rc));
935         break;
936
937       case aEnArmor:
938         if( argc > 1 )
939             wrong_args("--enarmor [file]");
940         rc = enarmor_file( argc? *argv: NULL );
941         if( rc )
942             log_error(_("enarmoring failed: %s\n"), g10_errstr(rc));
943         break;
944
945
946      #ifdef MAINTAINER_OPTIONS
947       case aPrimegen:
948         if( argc == 1 ) {
949             mpi_print( stdout, generate_public_prime( atoi(argv[0]) ), 1);
950             putchar('\n');
951         }
952         else if( argc == 2 ) {
953             mpi_print( stdout, generate_elg_prime( 0, atoi(argv[0]),
954                                                    atoi(argv[1]), NULL,NULL ), 1);
955             putchar('\n');
956         }
957         else if( argc == 3 ) {
958             MPI g = mpi_alloc(1);
959             mpi_print( stdout, generate_elg_prime( 0, atoi(argv[0]),
960                                                    atoi(argv[1]), g, NULL ), 1);
961             printf("\nGenerator: ");
962             mpi_print( stdout, g, 1 );
963             putchar('\n');
964             mpi_free(g);
965         }
966         else if( argc == 4 ) {
967             mpi_print( stdout, generate_elg_prime( 1, atoi(argv[0]),
968                                                    atoi(argv[1]), NULL,NULL ), 1);
969             putchar('\n');
970         }
971         else
972             usage(1);
973         break;
974       #endif /* MAINTAINER OPTIONS */
975
976       #ifdef MAINTAINER_OPTIONS
977       case aGenRandom:
978         if( argc < 1 || argc > 2 )
979             wrong_args("--gen-random level [hex]");
980         {
981             int level = atoi(*argv);
982             for(;;) {
983                 int c = get_random_byte(level);
984                 if( argc == 1 ) {
985                     printf("%02x", c );
986                     fflush(stdout);
987                 }
988                 else
989                     putchar(c&0xff);
990             }
991         }
992         break;
993       #endif /* MAINTAINER OPTIONS */
994
995       case aPrintMD:
996         if( argc < 1)
997             wrong_args("--print-md algo [file]");
998         else {
999             int algo = string_to_digest_algo(*argv);
1000
1001             if( !algo )
1002                 log_error(_("invalid hash algorithm '%s'\n"), *argv );
1003             else {
1004                 argc--; argv++;
1005                 if( !argc )
1006                     print_mds(NULL, algo);
1007                 else {
1008                     for(; argc; argc--, argv++ )
1009                         print_mds(*argv, algo);
1010                 }
1011             }
1012         }
1013         break;
1014
1015       case aPrintMDs:
1016         if( !argc )
1017             print_mds(NULL,0);
1018         else {
1019             for(; argc; argc--, argv++ )
1020                 print_mds(*argv,0);
1021         }
1022         break;
1023
1024      #ifdef MAINTAINER_OPTIONS
1025       case aTest: do_test( argc? atoi(*argv): 1 ); break;
1026       #endif /* MAINTAINER OPTIONS */
1027
1028       case aListTrustDB:
1029         if( !argc )
1030             list_trustdb(NULL);
1031         else {
1032             for( ; argc; argc--, argv++ )
1033                 list_trustdb( *argv );
1034         }
1035         break;
1036
1037       case aCheckTrustDB:
1038         if( !argc )
1039             check_trustdb(NULL);
1040         else {
1041             for( ; argc; argc--, argv++ )
1042                 check_trustdb( *argv );
1043         }
1044         break;
1045
1046       case aListTrustPath:
1047         if( argc != 2 )
1048             wrong_args("--list-trust-path [-- -]<maxdepth> <username>");
1049         list_trust_path( atoi(*argv), argv[1] );
1050         break;
1051
1052       case aListOwnerTrust:
1053         if( argc )
1054             wrong_args("--list-ownertrust");
1055         list_ownertrust();
1056         break;
1057
1058      #endif /* IS_G10MAINT */
1059
1060
1061       case aListPackets:
1062         opt.list_packets=1;
1063       default:
1064         /* fixme: g10maint should do regular maintenace tasks here */
1065         if( argc > 1 )
1066             wrong_args(_("[filename]"));
1067         if( !(a = iobuf_open(fname)) )
1068             log_error(_("can't open '%s'\n"), print_fname_stdin(fname));
1069         else {
1070             if( !opt.no_armor ) {
1071                 if( use_armor_filter( a ) ) {
1072                     memset( &afx, 0, sizeof afx);
1073                     iobuf_push_filter( a, armor_filter, &afx );
1074                 }
1075             }
1076             if( cmd == aListPackets ) {
1077                 set_packet_list_mode(1);
1078                 opt.list_packets=1;
1079             }
1080             proc_packets( a );
1081             iobuf_close(a);
1082         }
1083         break;
1084     }
1085
1086     /* cleanup */
1087     FREE_STRLIST(remusr);
1088     FREE_STRLIST(locusr);
1089     g10_exit(0);
1090     return 8; /*NEVER REACHED*/
1091 }
1092
1093
1094 void
1095 g10_exit( int rc )
1096 {
1097     if( opt.debug )
1098         secmem_dump_stats();
1099     secmem_term();
1100     rc = rc? rc : log_get_errorcount(0)? 2:0;
1101     /*write_status( STATUS_LEAVE );*/
1102     exit(rc );
1103 }
1104
1105
1106 void
1107 do_not_use_RSA()
1108 {
1109     static int did_rsa_note = 0;
1110
1111     if( !did_rsa_note ) {
1112         did_rsa_note = 1;
1113         log_info(_("RSA keys are deprecated; please consider "
1114                    "creating a new key and use this key in the future\n"));
1115     }
1116 }
1117
1118
1119 #ifdef IS_G10MAINT
1120 static void
1121 print_hex( byte *p, size_t n )
1122 {
1123     int i;
1124
1125     if( n == 20 ) {
1126         for(i=0; i < n ; i++, i++, p += 2 ) {
1127             if( i )
1128                 putchar(' ');
1129             if( i == 10 )
1130                 putchar(' ');
1131             printf("%02X%02X", *p, p[1] );
1132         }
1133     }
1134     else if( n == 24 ) {
1135         for(i=0; i < n ; i += 4, p += 4 ) {
1136             if( i )
1137                 putchar(' ');
1138             if( i == 12 )
1139                 putchar(' ');
1140             printf("%02X%02X%02X%02X", *p, p[1], p[2], p[3] );
1141         }
1142     }
1143     else {
1144         for(i=0; i < n ; i++, p++ ) {
1145             if( i )
1146                 putchar(' ');
1147             if( i && !(i%8) )
1148                 putchar(' ');
1149             printf("%02X", *p );
1150         }
1151     }
1152 }
1153
1154 static void
1155 print_mds( const char *fname, int algo )
1156 {
1157     FILE *fp;
1158     char buf[1024];
1159     size_t n;
1160     MD_HANDLE md;
1161     char *pname;
1162
1163     if( !fname ) {
1164         fp = stdin;
1165         pname = m_strdup("[stdin]: ");
1166     }
1167     else {
1168         pname = m_alloc(strlen(fname)+3);
1169         strcpy(stpcpy(pname,fname),": ");
1170         fp = fopen( fname, "rb" );
1171     }
1172     if( !fp ) {
1173         log_error("%s%s\n", pname, strerror(errno) );
1174         m_free(pname);
1175         return;
1176     }
1177
1178     md = md_open( 0, 0 );
1179     if( algo )
1180         md_enable( md, algo );
1181     else {
1182         md_enable( md, DIGEST_ALGO_MD5 );
1183         md_enable( md, DIGEST_ALGO_SHA1 );
1184         md_enable( md, DIGEST_ALGO_RMD160 );
1185         if( !check_digest_algo(DIGEST_ALGO_TIGER) )
1186             md_enable( md, DIGEST_ALGO_TIGER );
1187     }
1188
1189     while( (n=fread( buf, 1, DIM(buf), fp )) )
1190         md_write( md, buf, n );
1191     if( ferror(fp) )
1192         log_error("%s%s\n", pname, strerror(errno) );
1193     else {
1194         md_final(md);
1195         if( algo ) {
1196             if( fname )
1197                 fputs( pname, stdout );
1198             print_hex(md_read(md, algo), md_digest_length(algo) );
1199         }
1200         else {
1201             printf(  "%s   MD5 = ", fname?pname:"" );
1202                             print_hex(md_read(md, DIGEST_ALGO_MD5), 16 );
1203             printf("\n%s  SHA1 = ", fname?pname:""  );
1204                             print_hex(md_read(md, DIGEST_ALGO_SHA1), 20 );
1205             printf("\n%sRMD160 = ", fname?pname:""  );
1206                             print_hex(md_read(md, DIGEST_ALGO_RMD160), 20 );
1207             if( !check_digest_algo(DIGEST_ALGO_TIGER) ) {
1208                 printf("\n%s TIGER = ", fname?pname:""  );
1209                             print_hex(md_read(md, DIGEST_ALGO_TIGER), 24 );
1210             }
1211         }
1212         putchar('\n');
1213     }
1214     md_close(md);
1215
1216     if( fp != stdin )
1217         fclose(fp);
1218 }
1219
1220
1221
1222 #ifdef MAINTAINER_OPTIONS
1223 static void
1224 do_test(int times)
1225 {
1226     m_check(NULL);
1227 }
1228 #endif /* MAINTAINER OPTIONS */
1229 #endif /* IS_G10MAINT */
1230