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