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