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