gnupg extension are now working
[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     { 530, "import",      0     , N_("import/merge keys")},
79     { 521, "list-packets",0,N_("list only the sequence of packets")},
80   #ifdef IS_G10MAINT
81     { 546, "dearmor", 0, N_("De-Armor a file or stdin") },
82     { 547, "enarmor", 0, N_("En-Armor a file or stdin") },
83     { 555, "print-md" , 0, N_("|algo [files]|print message digests")},
84     { 516, "print-mds" , 0, N_("print all message digests")},
85     { 513, "gen-prime" , 0, "@" },
86     { 548, "gen-random" , 0, "@" },
87   #endif
88
89     { 301, NULL, 0, N_("@\nOptions:\n ") },
90
91     { 'a', "armor",     0, N_("create ascii armored output")},
92   #ifdef IS_G10
93     { 'u', "local-user",2, N_("use this user-id to sign or decrypt")},
94     { 'r', "remote-user", 2, N_("use this user-id for encryption")},
95     { 'z', NULL,        1, N_("|N|set compress level N (0 disables)") },
96     { 't', "textmode",  0, N_("use canonical text mode")},
97   #endif
98     { 'o', "output",    2, N_("use as output file")},
99     { 'v', "verbose",   0, N_("verbose") },
100     { 'n', "dry-run",   0, N_("do not make any changes") },
101     { 500, "batch",     0, N_("batch mode: never ask")},
102     { 501, "yes",       0, N_("assume yes on most questions")},
103     { 502, "no",        0, N_("assume no on most questions")},
104     { 509, "keyring"   ,2, N_("add this keyring to the list of keyrings")},
105     { 517, "secret-keyring" ,2, N_("add this secret keyring to the list")},
106     { 518, "options"   , 2, N_("read options from file")},
107
108     { 510, "debug"     ,4|16, N_("set debugging flags")},
109     { 511, "debug-all" ,0, N_("enable full debugging")},
110     { 512, "status-fd" ,1, N_("|FD|write status info to this FD") },
111     { 534, "no-comment", 0,   N_("do not write comment packets")},
112     { 535, "completes-needed", 1, N_("(default is 1)")},
113     { 536, "marginals-needed", 1, N_("(default is 3)")},
114     { 560, "load-extension" ,2, N_("|file|load extension module")},
115     { 561, "rfc1991",   0, N_("emulate the mode described in RFC1991")},
116   #ifdef IS_G10
117     { 527, "cipher-algo", 2 , N_("|NAME|use cipher algorithm NAME")},
118     { 528, "pubkey-algo", 2 , N_("|NAME|use public key algorithm NAME")},
119     { 529, "digest-algo", 2 , N_("|NAME|use message digest algorithm NAME")},
120     { 556, "compress-algo", 1 , N_("|N|use compress algorithm N")},
121   #else /* some dummies */
122     { 527, "cipher-algo", 2 , "@"},
123     { 528, "pubkey-algo", 2 , "@"},
124     { 529, "digest-algo", 2 , "@"},
125     { 556, "compress-algo", 1 , "@"},
126   #endif
127
128   #ifdef IS_G10
129     { 302, NULL, 0, N_("@\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, "@" },
140     { 531, "list-trustdb",0 , "@"},
141     { 533, "list-trust-path",0, "@"},
142   #endif
143   #ifdef IS_G10
144     { 'k', NULL,        0, "@"},
145     { 504, "delete-secret-key",0, "@" },
146     { 524, "edit-sig"  ,0, "@"}, /* alias for edit-key */
147     { 523, "passphrase-fd",1, "@" },
148   #endif
149     { 532, "quick-random", 0, "@"},
150     { 526, "no-verbose", 0, "@"},
151     { 538, "trustdb-name", 2, "@" },
152     { 540, "no-secmem-warning", 0, "@" }, /* used only by regression tests */
153     { 519, "no-armor",   0, "@"},
154     { 520, "no-default-keyring", 0, "@" },
155     { 522, "no-greeting", 0, "@" },
156     { 541, "no-operation", 0, "@" },      /* used by regression tests */
157     { 543, "no-options", 0, "@" }, /* shortcut for --options /dev/null */
158     { 544, "homedir", 2, "@" },   /* defaults to "~/.gnupg" */
159     { 545, "no-batch", 0, "@" },
160     { 549, "with-colons", 0, "@"},
161     { 551, "list-key", 0, "@" }, /* alias */
162     { 552, "list-sig", 0, "@" }, /* alias */
163     { 508, "check-sig",0, "@" }, /* alias */
164     { 553, "skip-verify",0, "@" },
165     { 557, "compress-keys",0, "@"},
166     { 559, "always-trust", 0, "@"},
167
168 {0} };
169
170
171
172
173 enum cmd_values { aNull = 0,
174     aSym, aStore, aEncr, aKeygen, aSign, aSignEncr,
175     aSignKey, aClearsign, aListPackets, aEditSig, aDeleteKey, aDeleteSecretKey,
176     aKMode, aKModeC, aChangePass, aImport, aVerify, aDecrypt, aListKeys,
177     aListSigs, aKeyadd, aListSecretKeys,
178     aExport, aCheckKeys, aGenRevoke, aPrimegen, aPrintMD, aPrintMDs,
179     aListTrustDB, aListTrustPath, aDeArmor, aEnArmor, aGenRandom, aTest,
180 aNOP };
181
182
183 static char *build_list( const char *text,
184                          const char *(*mapf)(int), int (*chkf)(int) );
185 static void set_cmd( enum cmd_values *ret_cmd,
186                         enum cmd_values new_cmd );
187 #ifdef IS_G10MAINT
188 static void print_hex( byte *p, size_t n );
189 static void print_mds( const char *fname, int algo );
190 static void do_test(int);
191 #endif
192
193 const char *
194 strusage( int level )
195 {
196   static char *digests, *pubkeys, *ciphers;
197     const char *p;
198     switch( level ) {
199       case 11: p =
200           #ifdef IS_G10MAINT
201             "gpgm (GNUPG)";
202           #else
203             "gpg (GNUPG)";
204           #endif
205         break;
206       case 13: p = VERSION; break;
207       case 17: p = PRINTABLE_OS_NAME; break;
208       case 19: p =
209             _("Please report bugs to <gnupg-bugs@gnu.org>.\n");
210         break;
211       case 1:
212       case 40:  p =
213           #ifdef IS_G10MAINT
214             _("Usage: gpgm [options] [files] (-h for help)");
215           #else
216             _("Usage: gpg [options] [files] (-h for help)");
217           #endif
218         break;
219       case 41:  p =
220           #ifdef IS_G10MAINT
221             _("Syntax: gpgm [options] [files]\n"
222               "GNUPG maintenance utility\n");
223           #else
224             _("Syntax: gpg [options] [files]\n"
225               "sign, check, encrypt or decrypt\n"
226               "default operation depends on the input data\n");
227           #endif
228         break;
229
230       case 31: p = "\n"; break;
231       case 32:
232         if( !ciphers )
233             ciphers = build_list("Supported ciphers: ", cipher_algo_to_string,
234                                                         check_cipher_algo );
235         p = ciphers;
236         break;
237       case 33:
238         if( !pubkeys )
239             pubkeys = build_list("Supported pubkeys: ", pubkey_algo_to_string,
240                                                         check_pubkey_algo );
241         p = pubkeys;
242         break;
243       case 34:
244         if( !digests )
245             digests = build_list("Supported digests: ", digest_algo_to_string,
246                                                         check_digest_algo );
247         p = digests;
248         break;
249
250       default:  p = default_strusage(level);
251     }
252     return p;
253 }
254
255
256 static char *
257 build_list( const char *text, const char * (*mapf)(int), int (*chkf)(int) )
258 {
259     int i;
260     const char *s;
261     size_t n=strlen(text)+2;
262     char *list, *p;
263
264     for(i=1; i < 110; i++ )
265         if( !chkf(i) && (s=mapf(i)) )
266             n += strlen(s) + 2;
267     list = m_alloc( 21 + n ); *list = 0;
268     for(p=NULL, i=1; i < 110; i++ ) {
269         if( !chkf(i) && (s=mapf(i)) ) {
270             if( !p )
271                 p = stpcpy( list, text );
272             else
273                 p = stpcpy( p, ", ");
274             p = stpcpy(p, s );
275         }
276     }
277     if( p )
278         p = stpcpy(p, "\n" );
279     return list;
280 }
281
282
283 static void
284 i18n_init(void)
285 {
286   #ifdef ENABLE_NLS
287     #ifdef HAVE_LC_MESSAGES
288        setlocale( LC_MESSAGES, "" );
289     #else
290        setlocale( LC_ALL, "" );
291     #endif
292     bindtextdomain( PACKAGE, G10_LOCALEDIR );
293     textdomain( PACKAGE );
294   #endif
295 }
296
297 static void
298 wrong_args( const char *text)
299 {
300   #ifdef IS_G10MAINT
301     fputs(_("usage: gpgm [options] "),stderr);
302   #else
303     fputs(_("usage: gpg [options] "),stderr);
304   #endif
305     fputs(text,stderr);
306     putc('\n',stderr);
307     g10_exit(2);
308 }
309
310 static void
311 set_debug(void)
312 {
313     volatile char *p = g10_malloc(1);
314     volatile MPI a = g10m_new(1);
315     *p = g10c_get_random_byte( 0 );
316
317
318     if( opt.debug & DBG_MEMORY_VALUE )
319         memory_debug_mode = 1;
320     if( opt.debug & DBG_MEMSTAT_VALUE )
321         memory_stat_debug_mode = 1;
322     if( opt.debug & DBG_MPI_VALUE )
323         mpi_debug_mode = 1;
324     if( opt.debug & DBG_CIPHER_VALUE )
325         g10c_debug_mode = 1;
326     if( opt.debug & DBG_IOBUF_VALUE )
327         iobuf_debug_mode = 1;
328
329 }
330
331
332 static void
333 set_cmd( enum cmd_values *ret_cmd, enum cmd_values new_cmd )
334 {
335     enum cmd_values cmd = *ret_cmd;
336
337     if( !cmd || cmd == new_cmd )
338         cmd = new_cmd;
339     else if( cmd == aSign && new_cmd == aEncr )
340         cmd = aSignEncr;
341     else if( cmd == aEncr && new_cmd == aSign )
342         cmd = aSignEncr;
343     else if( cmd == aKMode && new_cmd == aSym )
344         cmd = aKModeC;
345     else if(    ( cmd == aSign     && new_cmd == aClearsign )
346              || ( cmd == aClearsign && new_cmd == aSign )  )
347         cmd = aClearsign;
348     else {
349         log_error(_("conflicting commands\n"));
350         g10_exit(2);
351     }
352
353     *ret_cmd = cmd;
354 }
355
356
357
358 static void
359 check_opts(void)
360 {
361     if( !opt.def_cipher_algo || check_cipher_algo(opt.def_cipher_algo) )
362         log_error(_("selected cipher algorithm is invalid\n"));
363     if( !opt.def_pubkey_algo || check_pubkey_algo(opt.def_pubkey_algo) )
364         log_error(_("selected pubkey algorithm is invalid\n"));
365     if( opt.def_digest_algo && check_digest_algo(opt.def_digest_algo) )
366         log_error(_("selected digest algorithm is invalid\n"));
367     if( opt.def_compress_algo < 1 || opt.def_compress_algo > 2 )
368         log_error(_("compress algorithm must be in range %d..%d\n"), 1, 2);
369     if( opt.completes_needed < 1 )
370         log_error(_("completes-needed must be greater than 0\n"));
371     if( opt.marginals_needed < 2 )
372         log_error(_("marginals-needed must be greater than 1\n"));
373 }
374
375
376
377
378 int
379 main( int argc, char **argv )
380 {
381     ARGPARSE_ARGS pargs;
382     IOBUF a;
383     int rc=0;
384     int orig_argc;
385     char **orig_argv;
386     const char *fname;
387     STRLIST sl, remusr= NULL, locusr=NULL;
388     int nrings=0, sec_nrings=0;
389     armor_filter_context_t afx;
390     int detached_sig = 0;
391     FILE *configfp = NULL;
392     char *configname = NULL;
393     unsigned configlineno;
394     int parse_debug = 0;
395     int default_config =1;
396     int errors=0;
397     int default_keyring = 1;
398     int greeting = 1;
399     enum cmd_values cmd = 0;
400     const char *trustdb_name = NULL;
401
402     trap_unaligned();
403   #ifdef IS_G10MAINT
404     secmem_init( 0 );      /* disable use of secmem */
405     log_set_name("gpgm");
406   #else
407     /* Please note that we may running SUID(ROOT), so be very CAREFUL
408      * when adding any stuff between here and the call to
409      * secmem_init()  somewhere after the option parsing
410      */
411     log_set_name("gpg");
412     secure_random_alloc(); /* put random number into secure memory */
413     init_signals();
414   #endif
415     i18n_init();
416     opt.compress = -1; /* defaults to standard compress level */
417     /* fixme: set the next two to zero and decide where used */
418     opt.def_cipher_algo = DEFAULT_CIPHER_ALGO;
419     opt.def_pubkey_algo = DEFAULT_PUBKEY_ALGO;
420     opt.def_digest_algo = 0;
421     opt.def_compress_algo = 2;
422     opt.completes_needed = 1;
423     opt.marginals_needed = 3;
424     opt.homedir = getenv("GNUPGHOME");
425     if( !opt.homedir || !*opt.homedir ) {
426       #ifdef __MINGW32__
427         opt.homedir = "c:/gnupg";
428       #else
429         opt.homedir = "~/.gnupg";
430       #endif
431     }
432
433     /* check whether we have a config file on the commandline */
434     orig_argc = argc;
435     orig_argv = argv;
436     pargs.argc = &argc;
437     pargs.argv = &argv;
438     pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
439     while( arg_parse( &pargs, opts) ) {
440         if( pargs.r_opt == 510 || pargs.r_opt == 511 )
441             parse_debug++;
442         else if( pargs.r_opt == 518 ) {
443             /* yes there is one, so we do not try the default one, but
444              * read the option file when it is encountered at the commandline
445              */
446             default_config = 0;
447         }
448         else if( pargs.r_opt == 543 )
449             default_config = 0; /* --no-options */
450         else if( pargs.r_opt == 544 )
451             opt.homedir = pargs.r.ret_str;
452     }
453
454     if( default_config )
455         configname = make_filename(opt.homedir, "options", NULL );
456
457     argc = orig_argc;
458     argv = orig_argv;
459     pargs.argc = &argc;
460     pargs.argv = &argv;
461     pargs.flags=  1;  /* do not remove the args */
462   next_pass:
463     if( configname ) {
464         configlineno = 0;
465         configfp = fopen( configname, "r" );
466         if( !configfp ) {
467             if( default_config ) {
468                 if( parse_debug )
469                     log_info(_("note: no default option file '%s'\n"),
470                                                             configname );
471             }
472             else {
473                 log_error(_("option file '%s': %s\n"),
474                                     configname, strerror(errno) );
475                 g10_exit(1);
476             }
477             m_free(configname); configname = NULL;
478         }
479         if( parse_debug && configname )
480             log_info(_("reading options from '%s'\n"), configname );
481         default_config = 0;
482     }
483
484     while( optfile_parse( configfp, configname, &configlineno,
485                                                 &pargs, opts) ) {
486         switch( pargs.r_opt ) {
487
488           case 'a': opt.armor = 1; opt.no_armor=0; break;
489         #ifdef IS_G10
490           case 'b': detached_sig = 1; set_cmd( &cmd, aSign ); break;
491           case 'c': set_cmd( &cmd, aSym); break;
492           case 'd': set_cmd( &cmd, aDecrypt); break;
493           case 'e': set_cmd( &cmd, aEncr); break;
494           case 'r': /* store the remote users */
495             sl = m_alloc( sizeof *sl + strlen(pargs.r.ret_str));
496             strcpy(sl->d, pargs.r.ret_str);
497             sl->next = remusr;
498             remusr = sl;
499             break;
500           case 's': set_cmd( &cmd, aSign );  break;
501           case 't': opt.textmode=1;  break;
502           case 'u': /* store the local users */
503             sl = m_alloc( sizeof *sl + strlen(pargs.r.ret_str));
504             strcpy(sl->d, pargs.r.ret_str);
505             sl->next = locusr;
506             locusr = sl;
507             break;
508           case 'z': opt.compress = pargs.r.ret_int; break;
509           case 503: set_cmd( &cmd, aKeygen); break;
510           case 504: set_cmd( &cmd, aDeleteSecretKey); break;
511           case 505: set_cmd( &cmd, aDeleteKey); break;
512           case 506: set_cmd( &cmd, aSignKey); break;
513           case 507: set_cmd( &cmd, aStore); break;
514           case 523: set_passphrase_fd( pargs.r.ret_int ); break;
515           case 524: set_cmd( &cmd, aEditSig); break;
516           case 525: set_cmd( &cmd, aChangePass); break;
517           case 527:
518             opt.def_cipher_algo = string_to_cipher_algo(pargs.r.ret_str);
519             break;
520           case 528:
521             opt.def_pubkey_algo = string_to_pubkey_algo(pargs.r.ret_str);
522             break;
523           case 529:
524             opt.def_digest_algo = string_to_digest_algo(pargs.r.ret_str);
525             break;
526           case 539: set_cmd( &cmd, aClearsign); break;
527           case 540: secmem_set_flags( secmem_get_flags() | 1 ); break;
528           case 542: set_cmd( &cmd, aGenRevoke); break;
529           case 550: set_cmd( &cmd, aVerify); break;
530         #else
531           case 527:
532           case 528:
533           case 529:
534             break;
535         #endif /* !IS_G10 */
536
537         #ifdef IS_G10MAINT
538           case 513: set_cmd( &cmd, aPrimegen); break;
539           case 514: set_cmd( &cmd, aTest); break;
540           case 516: set_cmd( &cmd, aPrintMDs); break;
541           case 531: set_cmd( &cmd, aListTrustDB); break;
542           case 533: set_cmd( &cmd, aListTrustPath); break;
543           case 540: break; /* dummy */
544           case 546: set_cmd( &cmd, aDeArmor); break;
545           case 547: set_cmd( &cmd, aEnArmor); break;
546           case 548: set_cmd( &cmd, aGenRandom); break;
547           case 555: set_cmd( &cmd, aPrintMD); break;
548         #endif /* IS_G10MAINT */
549
550           case 'o': opt.outfile = pargs.r.ret_str; break;
551           case 'v': g10_opt_verbose++;
552                     opt.verbose++; opt.list_sigs=1; break;
553           case 'k': set_cmd( &cmd, aKMode ); break;
554
555           case 500: opt.batch = 1; greeting = 0; break;
556           case 501: opt.answer_yes = 1; break;
557           case 502: opt.answer_no = 1; break;
558           case 508: set_cmd( &cmd, aCheckKeys); break;
559           case 509: add_keyring(pargs.r.ret_str); nrings++; break;
560           case 510: opt.debug |= pargs.r.ret_ulong; break;
561           case 511: opt.debug = ~0; break;
562           case 512: set_status_fd( pargs.r.ret_int ); break;
563           case 515: opt.fingerprint = 1; break;
564           case 517: add_secret_keyring(pargs.r.ret_str); sec_nrings++; break;
565           case 518:
566             /* config files may not be nested (silently ignore them) */
567             if( !configfp ) {
568                 m_free(configname);
569                 configname = m_strdup(pargs.r.ret_str);
570                 goto next_pass;
571             }
572             break;
573           case 519: opt.no_armor=1; opt.armor=0; break;
574           case 520: default_keyring = 0; break;
575           case 521: set_cmd( &cmd, aListPackets); break;
576           case 522: greeting = 0; break;
577           case 526: g10_opt_verbose = 0;
578                     opt.verbose = 0; opt.list_sigs=0; break;
579           case 530: set_cmd( &cmd, aImport); break;
580           case 532: quick_random_gen(1); break;
581           case 534: opt.no_comment=1; break;
582           case 535: opt.completes_needed = pargs.r.ret_int; break;
583           case 536: opt.marginals_needed = pargs.r.ret_int; break;
584           case 537: set_cmd( &cmd, aExport); break;
585           case 538: trustdb_name = pargs.r.ret_str; break;
586           case 541: set_cmd( &cmd, aNOP); break;
587           case 543: break; /* no-options */
588           case 544: opt.homedir = pargs.r.ret_str; break;
589           case 545: opt.batch = 0; break;
590           case 549: opt.with_colons=':'; break;
591           case 551: set_cmd( &cmd, aListKeys); break;
592           case 552: set_cmd( &cmd, aListSigs); break;
593           case 553: opt.skip_verify=1; break;
594           case 554: set_cmd( &cmd, aKeyadd); break;
595           case 556: opt.def_compress_algo = pargs.r.ret_int; break;
596           case 557: opt.compress_keys = 1; break;
597           case 558: set_cmd( &cmd, aListSecretKeys); break;
598           case 559: opt.always_trust = 1; break;
599           case 560: register_cipher_extension(pargs.r.ret_str); break;
600           case 561: opt.rfc1991 = 1; 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_pubkeys( NULL );
862             if( rc )
863                 log_error("import failed: %s\n", g10_errstr(rc) );
864         }
865         for( ; argc; argc--, argv++ ) {
866             rc = import_pubkeys( *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     #ifdef IS_G10
882       case aGenRevoke:
883         if( argc != 1 )
884             wrong_args("--gen-revoke user-id");
885         gen_revoke( *argv );
886         break;
887     #endif
888
889     #ifdef IS_G10MAINT
890       case aDeArmor:
891         if( argc > 1 )
892             wrong_args("--dearmor [file]");
893         rc = dearmor_file( argc? *argv: NULL );
894         if( rc )
895             log_error(_("dearmoring failed: %s\n"), g10_errstr(rc));
896         break;
897
898       case aEnArmor:
899         if( argc > 1 )
900             wrong_args("--enarmor [file]");
901         rc = enarmor_file( argc? *argv: NULL );
902         if( rc )
903             log_error(_("enarmoring failed: %s\n"), g10_errstr(rc));
904         break;
905
906
907       case aPrimegen:
908         if( argc == 1 ) {
909             mpi_print( stdout, generate_public_prime( atoi(argv[0]) ), 1);
910             putchar('\n');
911         }
912         else if( argc == 2 ) {
913             mpi_print( stdout, generate_elg_prime( 0, atoi(argv[0]),
914                                                    atoi(argv[1]), NULL,NULL ), 1);
915             putchar('\n');
916         }
917         else if( argc == 3 ) {
918             MPI g = mpi_alloc(1);
919             mpi_print( stdout, generate_elg_prime( 0, atoi(argv[0]),
920                                                    atoi(argv[1]), g, NULL ), 1);
921             printf("\nGenerator: ");
922             mpi_print( stdout, g, 1 );
923             putchar('\n');
924             mpi_free(g);
925         }
926         else if( argc == 4 ) {
927             mpi_print( stdout, generate_elg_prime( 1, atoi(argv[0]),
928                                                    atoi(argv[1]), NULL,NULL ), 1);
929             putchar('\n');
930         }
931         else
932             usage(1);
933         break;
934
935       case aGenRandom:
936         if( argc < 1 || argc > 2 )
937             wrong_args("--gen-random level [hex]");
938         {
939             int level = atoi(*argv);
940             for(;;) {
941                 int c = get_random_byte(level);
942                 if( argc == 1 ) {
943                     printf("%02x", c );
944                     fflush(stdout);
945                 }
946                 else
947                     putchar(c&0xff);
948             }
949         }
950         break;
951
952       case aPrintMD:
953         if( argc < 1)
954             wrong_args("--print-md algo [file]");
955         else {
956             int algo = string_to_digest_algo(*argv);
957
958             if( !algo )
959                 log_error(_("invalid hash algorithm '%s'\n"), *argv );
960             else {
961                 argc--; argv++;
962                 if( !argc )
963                     print_mds(NULL, algo);
964                 else {
965                     for(; argc; argc--, argv++ )
966                         print_mds(*argv, algo);
967                 }
968             }
969         }
970         break;
971
972       case aPrintMDs:
973         if( !argc )
974             print_mds(NULL,0);
975         else {
976             for(; argc; argc--, argv++ )
977                 print_mds(*argv,0);
978         }
979         break;
980
981       case aTest: do_test( argc? atoi(*argv): 1 ); break;
982
983       case aListTrustDB:
984         if( !argc )
985             list_trustdb(NULL);
986         else {
987             for( ; argc; argc--, argv++ )
988                 list_trustdb( *argv );
989         }
990         break;
991
992       case aListTrustPath:
993         if( argc != 2 )
994             wrong_args("--list-trust-path [-- -]<maxdepth> <username>");
995         list_trust_path( atoi(*argv), argv[1] );
996         break;
997
998      #endif /* IS_G10MAINT */
999
1000
1001       case aNOP:
1002         break;
1003
1004       case aListPackets:
1005         opt.list_packets=1;
1006       default:
1007         /* fixme: g10maint should do regular maintenace tasks here */
1008         if( argc > 1 )
1009             wrong_args(_("[filename]"));
1010         if( !(a = iobuf_open(fname)) )
1011             log_error(_("can't open '%s'\n"), print_fname_stdin(fname));
1012         else {
1013             if( !opt.no_armor ) {
1014                 if( use_armor_filter( a ) ) {
1015                     memset( &afx, 0, sizeof afx);
1016                     iobuf_push_filter( a, armor_filter, &afx );
1017                 }
1018             }
1019             if( cmd == aListPackets ) {
1020                 set_packet_list_mode(1);
1021                 opt.list_packets=1;
1022             }
1023             proc_packets( a );
1024             iobuf_close(a);
1025         }
1026         break;
1027     }
1028
1029     /* cleanup */
1030     FREE_STRLIST(remusr);
1031     FREE_STRLIST(locusr);
1032     g10_exit(0);
1033     return 8; /*NEVER REACHED*/
1034 }
1035
1036
1037 void
1038 g10_exit( int rc )
1039 {
1040     if( opt.debug )
1041         secmem_dump_stats();
1042     secmem_term();
1043     rc = rc? rc : log_get_errorcount(0)? 2:0;
1044     /*write_status( STATUS_LEAVE );*/
1045     exit(rc );
1046 }
1047
1048 #ifdef IS_G10MAINT
1049 static void
1050 print_hex( byte *p, size_t n )
1051 {
1052     int i;
1053
1054     if( n == 20 ) {
1055         for(i=0; i < n ; i++, i++, p += 2 ) {
1056             if( i )
1057                 putchar(' ');
1058             if( i == 10 )
1059                 putchar(' ');
1060             printf("%02X%02X", *p, p[1] );
1061         }
1062     }
1063     else if( n == 24 ) {
1064         for(i=0; i < n ; i += 4, p += 4 ) {
1065             if( i )
1066                 putchar(' ');
1067             if( i == 12 )
1068                 putchar(' ');
1069             printf("%02X%02X%02X%02X", *p, p[1], p[2], p[3] );
1070         }
1071     }
1072     else {
1073         for(i=0; i < n ; i++, p++ ) {
1074             if( i )
1075                 putchar(' ');
1076             if( i && !(i%8) )
1077                 putchar(' ');
1078             printf("%02X", *p );
1079         }
1080     }
1081 }
1082
1083 static void
1084 print_mds( const char *fname, int algo )
1085 {
1086     FILE *fp;
1087     char buf[1024];
1088     size_t n;
1089     MD_HANDLE md;
1090     char *pname;
1091
1092     if( !fname ) {
1093         fp = stdin;
1094         pname = m_strdup("[stdin]: ");
1095     }
1096     else {
1097         pname = m_alloc(strlen(fname)+3);
1098         strcpy(stpcpy(pname,fname),": ");
1099         fp = fopen( fname, "rb" );
1100     }
1101     if( !fp ) {
1102         log_error("%s%s\n", pname, strerror(errno) );
1103         m_free(pname);
1104         return;
1105     }
1106
1107     md = md_open( 0, 0 );
1108     if( algo )
1109         md_enable( md, algo );
1110     else {
1111         md_enable( md, DIGEST_ALGO_MD5 );
1112         md_enable( md, DIGEST_ALGO_SHA1 );
1113         md_enable( md, DIGEST_ALGO_RMD160 );
1114       #ifdef WITH_TIGER_HASH
1115         md_enable( md, DIGEST_ALGO_TIGER );
1116       #endif
1117     }
1118
1119     while( (n=fread( buf, 1, DIM(buf), fp )) )
1120         md_write( md, buf, n );
1121     if( ferror(fp) )
1122         log_error("%s%s\n", pname, strerror(errno) );
1123     else {
1124         md_final(md);
1125         if( algo ) {
1126             if( fname )
1127                 fputs( pname, stdout );
1128             print_hex(md_read(md, algo), md_digest_length(algo) );
1129         }
1130         else {
1131             printf(  "%s   MD5 = ", fname?pname:"" );
1132                             print_hex(md_read(md, DIGEST_ALGO_MD5), 16 );
1133             printf("\n%s  SHA1 = ", fname?pname:""  );
1134                             print_hex(md_read(md, DIGEST_ALGO_SHA1), 20 );
1135             printf("\n%sRMD160 = ", fname?pname:""  );
1136                             print_hex(md_read(md, DIGEST_ALGO_RMD160), 20 );
1137           #ifdef WITH_TIGER_HASH
1138             printf("\n%s TIGER = ", fname?pname:""  );
1139                             print_hex(md_read(md, DIGEST_ALGO_TIGER), 24 );
1140           #endif
1141         }
1142         putchar('\n');
1143     }
1144     md_close(md);
1145
1146     if( fp != stdin )
1147         fclose(fp);
1148 }
1149
1150
1151
1152 static void
1153 do_test(int times)
1154 {
1155     MPI base[4];
1156     MPI exp[4];
1157     MPI t1 = mpi_alloc(50);
1158     MPI t2 = mpi_alloc(50);
1159     MPI t3 = mpi_alloc(50);
1160     MPI tmp= mpi_alloc(50);
1161     MPI m =   mpi_alloc(50);
1162     MPI res = mpi_alloc(50);
1163
1164     mpi_fromstr( m, "0x10000000000000000000000000" );
1165     base[0] = mpi_alloc_set_ui( 3 );
1166     mpi_fromstr( base[0], "0x145984358945989898495ffdd13" );
1167     base[1] = mpi_alloc_set_ui( 5 );
1168     mpi_fromstr( base[1], "0x000effff9999000000001100001" );
1169     base[2] = mpi_alloc_set_ui( 2 );
1170     mpi_fromstr( base[2], "0x499eeeaaaaa0444444545466672" );
1171     base[3] = NULL;
1172     exp[0]  = mpi_alloc_set_ui( 30 );
1173     exp[1]  = mpi_alloc_set_ui( 10 );
1174     mpi_fromstr( exp[1], "0x3457878888888888aabbbccccc1" );
1175     exp[2]  = mpi_alloc_set_ui( 24 );
1176     exp[3] = NULL;
1177
1178     mpi_powm( t1, base[0], exp[0], m );
1179     mpi_powm( t2, base[1], exp[1], m );
1180     mpi_powm( t3, base[2], exp[2], m );
1181     mpi_mulm( tmp, t1, t2, m );
1182     mpi_mulm( t1, tmp, t3, m );
1183     log_mpidump("X=", t1 );
1184
1185
1186     mpi_mulpowm( res, base, exp, m );
1187     log_mpidump("X=", res );
1188
1189
1190     m_check(NULL);
1191 }
1192 #endif /* IS_G10MAINT */
1193