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