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