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