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