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