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