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