See ChangeLog: Thu Jul 15 10:15:35 CEST 1999 Werner Koch
[gnupg.git] / g10 / g10.c
1 /* g10.c - The GnuPG utility (main for gpg)
2  *      Copyright (C) 1998, 1999 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 <ctype.h>
27 #include <unistd.h>
28
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 "trustdb.h"
38 #include "mpi.h"
39 #include "cipher.h"
40 #include "filter.h"
41 #include "ttyio.h"
42 #include "i18n.h"
43 #include "status.h"
44 #include "g10defs.h"
45 #include "hkp.h"
46
47
48 enum cmd_and_opt_values { aNull = 0,
49     oArmor        = 'a',
50     aDetachedSign = 'b',
51     aSym          = 'c',
52     aDecrypt      = 'd',
53     aEncr         = 'e',
54     oInteractive  = 'i',
55     oKOption      = 'k',
56     oDryRun       = 'n',
57     oOutput       = 'o',
58     oQuiet        = 'q',
59     oRecipient    = 'r',
60     aSign         = 's',
61     oTextmodeShort= 't',
62     oUser         = 'u',
63     oVerbose      = 'v',
64     oCompress     = 'z',
65     oNotation     = 'N',
66     oBatch        = 500,
67     aClearsign,
68     aStore,
69     aKeygen,
70     aSignEncr,
71     aSignKey,
72     aLSignKey,
73     aListPackets,
74     aEditKey,
75     aDeleteKey,
76     aDeleteSecretKey,
77     aKMode,
78     aKModeC,
79     aImport,
80     aFastImport,
81     aVerify,
82     aListKeys,
83     aListSigs,
84     aListSecretKeys,
85     aSendKeys,
86     aRecvKeys,
87     aExport,
88     aExportAll,
89     aExportSecret,
90     aCheckKeys,
91     aGenRevoke,
92     aPrimegen,
93     aPrintMD,
94     aPrintMDs,
95     aCheckTrustDB,
96     aUpdateTrustDB,
97     aFixTrustDB,
98     aListTrustDB,
99     aListTrustPath,
100     aExportOwnerTrust,
101     aImportOwnerTrust,
102     aDeArmor,
103     aEnArmor,
104     aGenRandom,
105
106     oTextmode,
107     oFingerprint,
108     oWithFingerprint,
109     oAnswerYes,
110     oAnswerNo,
111     oKeyring,
112     oSecretKeyring,
113     oDefaultKey,
114     oDefRecipient,
115     oDefRecipientSelf,
116     oNoDefRecipient,
117     oOptions,
118     oDebug,
119     oDebugAll,
120     oStatusFD,
121     oNoComment,
122     oNoVersion,
123     oEmitVersion,
124     oCompletesNeeded,
125     oMarginalsNeeded,
126     oMaxCertDepth,
127     oLoadExtension,
128     oRFC1991,
129     oOpenPGP,
130     oCipherAlgo,
131     oDigestAlgo,
132     oCompressAlgo,
133     oPasswdFD,
134     oQuickRandom,
135     oNoVerbose,
136     oTrustDBName,
137     oNoSecmemWarn,
138     oNoArmor,
139     oNoDefKeyring,
140     oNoGreeting,
141     oNoTTY,
142     oNoOptions,
143     oNoBatch,
144     oHomedir,
145     oWithColons,
146     oWithKeyData,
147     oSkipVerify,
148     oCompressKeys,
149     oCompressSigs,
150     oAlwaysTrust,
151     oEmuChecksumBug,
152     oRunAsShmCP,
153     oSetFilename,
154     oSetPolicyURL,
155     oUseEmbeddedFilename,
156     oComment,
157     oDefaultComment,
158     oThrowKeyid,
159     oForceV3Sigs,
160     oForceMDC,
161     oS2KMode,
162     oS2KDigest,
163     oS2KCipher,
164     oCharset,
165     oNotDashEscaped,
166     oEscapeFrom,
167     oLockOnce,
168     oLockMultiple,
169     oKeyServer,
170     oEncryptTo,
171     oNoEncryptTo,
172     oLoggerFD,
173     oUtf8Strings,
174     oNoUtf8Strings,
175     oDisableCipherAlgo,
176     oDisablePubkeyAlgo,
177 aTest };
178
179
180 static ARGPARSE_OPTS opts[] = {
181
182     { 300, NULL, 0, N_("@Commands:\n ") },
183
184     { aSign, "sign",      256, N_("|[file]|make a signature")},
185     { aClearsign, "clearsign", 256, N_("|[file]|make a clear text signature") },
186     { aDetachedSign, "detach-sign", 256, N_("make a detached signature")},
187     { aEncr, "encrypt",   256, N_("encrypt data")},
188     { aSym, "symmetric", 256, N_("encryption only with symmetric cipher")},
189     { aStore, "store",     256, N_("store only")},
190     { aDecrypt, "decrypt",   256, N_("decrypt data (default)")},
191     { aVerify, "verify"   , 256, N_("verify a signature")},
192     { aListKeys, "list-keys", 256, N_("list keys")},
193     { aListKeys, "list-public-keys", 256, "@" },
194     { aListSigs, "list-sigs", 256, N_("list keys and signatures")},
195     { aCheckKeys, "check-sigs",256, N_("check key signatures")},
196     { oFingerprint, "fingerprint", 256, N_("list keys and fingerprints")},
197     { aListSecretKeys, "list-secret-keys", 256, N_("list secret keys")},
198     { aKeygen,     "gen-key",  256, N_("generate a new key pair")},
199     { aDeleteKey, "delete-key",256, N_("remove key from the public keyring")},
200     { aSignKey,  "sign-key"   ,256, N_("sign a key")},
201     { aLSignKey, "lsign-key"  ,256, N_("sign a key locally")},
202     { aEditKey,  "edit-key"   ,256, N_("sign or edit a key")},
203     { aGenRevoke, "gen-revoke",256, N_("generate a revocation certificate")},
204     { aExport, "export"           , 256, N_("export keys") },
205     { aSendKeys, "send-keys"     , 256, N_("export keys to a key server") },
206     { aRecvKeys, "recv-keys"     , 256, N_("import keys from a key server") },
207     { aExportAll, "export-all"    , 256, "@" },
208     { aExportSecret, "export-secret-keys" , 256, "@" },
209     { aImport, "import",      256     , N_("import/merge keys")},
210     { aFastImport, "fast-import",  256 , "@"},
211     { aListPackets, "list-packets",256,N_("list only the sequence of packets")},
212     { aExportOwnerTrust,
213               "export-ownertrust", 256, N_("export the ownertrust values")},
214     { aImportOwnerTrust,
215               "import-ownertrust", 256 , N_("import ownertrust values")},
216     { aUpdateTrustDB,
217               "update-trustdb",0 , N_("update the trust database")},
218     { aCheckTrustDB,
219               "check-trustdb",0 , N_("|[NAMES]|check the trust database")},
220     { aFixTrustDB, "fix-trustdb",0 , N_("fix a corrupted trust database")},
221     { aDeArmor, "dearmor", 256, N_("De-Armor a file or stdin") },
222     { aEnArmor, "enarmor", 256, N_("En-Armor a file or stdin") },
223     { aPrintMD,  "print-md" , 256, N_("|algo [files]|print message digests")},
224     { aPrimegen, "gen-prime" , 256, "@" },
225     { aGenRandom, "gen-random" , 256, "@" },
226
227     { 301, NULL, 0, N_("@\nOptions:\n ") },
228
229     { oArmor, "armor",     0, N_("create ascii armored output")},
230     { oRecipient, "recipient", 2, N_("|NAME|encrypt for NAME")},
231     { oRecipient, "remote-user", 2, "@"},  /* old option name */
232     { oDefRecipient, "default-recipient" ,2,
233                                   N_("|NAME|use NAME as default recipient")},
234     { oDefRecipientSelf, "default-recipient-self" ,0,
235                                 N_("use the default key as default recipient")},
236     { oNoDefRecipient, "no-default-recipient", 0, "@" },
237     { oEncryptTo, "encrypt-to", 2, "@" },
238     { oNoEncryptTo, "no-encrypt-to", 0, "@" },
239     { oUser, "local-user",2, N_("use this user-id to sign or decrypt")},
240     { oCompress, NULL,        1, N_("|N|set compress level N (0 disables)") },
241     { oTextmodeShort, NULL,   0, "@"},
242     { oTextmode, "textmode",  0, N_("use canonical text mode")},
243     { oOutput, "output",    2, N_("use as output file")},
244     { oVerbose, "verbose",   0, N_("verbose") },
245     { oQuiet,   "quiet",   0, N_("be somewhat more quiet") },
246     { oNoTTY, "no-tty", 0, N_("don't use the terminal at all") },
247     { oForceV3Sigs, "force-v3-sigs", 0, N_("force v3 signatures") },
248     { oForceMDC, "force-mdc", 0, N_("always use a MDC for encryption") },
249     { oDryRun, "dry-run",   0, N_("do not make any changes") },
250   /*{ oInteractive, "interactive", 0, N_("prompt before overwriting") }, */
251     { oBatch, "batch",     0, N_("batch mode: never ask")},
252     { oAnswerYes, "yes",       0, N_("assume yes on most questions")},
253     { oAnswerNo,  "no",        0, N_("assume no on most questions")},
254     { oKeyring, "keyring"   ,2, N_("add this keyring to the list of keyrings")},
255     { oSecretKeyring, "secret-keyring" ,2, N_("add this secret keyring to the list")},
256     { oDefaultKey, "default-key" ,2, N_("|NAME|use NAME as default secret key")},
257     { oKeyServer, "keyserver",2, N_("|HOST|use this keyserver to lookup keys")},
258     { oCharset, "charset"   , 2, N_("|NAME|set terminal charset to NAME") },
259     { oOptions, "options"   , 2, N_("read options from file")},
260
261     { oDebug, "debug"     ,4|16, N_("set debugging flags")},
262     { oDebugAll, "debug-all" ,0, N_("enable full debugging")},
263     { oStatusFD, "status-fd" ,1, N_("|FD|write status info to this FD") },
264     { oNoComment, "no-comment", 0,   N_("do not write comment packets")},
265     { oCompletesNeeded, "completes-needed", 1, N_("(default is 1)")},
266     { oMarginalsNeeded, "marginals-needed", 1, N_("(default is 3)")},
267     { oMaxCertDepth,    "max-cert-depth", 1, "@" },
268     { oLoadExtension, "load-extension" ,2, N_("|FILE|load extension module FILE")},
269     { oRFC1991, "rfc1991",   0, N_("emulate the mode described in RFC1991")},
270     { oOpenPGP, "openpgp", 0, N_("set all packet, cipher and digest options to OpenPGP behavior")},
271     { oS2KMode, "s2k-mode",  1, N_("|N|use passphrase mode N")},
272     { oS2KDigest, "s2k-digest-algo",2,
273                 N_("|NAME|use message digest algorithm NAME for passphrases")},
274     { oS2KCipher, "s2k-cipher-algo",2,
275                 N_("|NAME|use cipher algorithm NAME for passphrases")},
276     { oCipherAlgo, "cipher-algo", 2 , N_("|NAME|use cipher algorithm NAME")},
277     { oDigestAlgo, "digest-algo", 2 , N_("|NAME|use message digest algorithm NAME")},
278     { oCompressAlgo, "compress-algo", 1 , N_("|N|use compress algorithm N")},
279     { oThrowKeyid, "throw-keyid", 0, N_("throw keyid field of encrypted packets")},
280     { oNotation,   "notation-data", 2, N_("|NAME=VALUE|use this notation data")},
281
282     { 302, NULL, 0, N_("@\nExamples:\n\n"
283     " -se -r Bob [file]          sign and encrypt for user Bob\n"
284     " --clearsign [file]         make a clear text signature\n"
285     " --detach-sign [file]       make a detached signature\n"
286     " --list-keys [names]        show keys\n"
287     " --fingerprint [names]      show fingerprints\n"  ) },
288
289   /* hidden options */
290     { aExportOwnerTrust, "list-ownertrust",0 , "@"},  /* alias */
291     { aPrintMDs, "print-mds" , 256, "@"}, /* old */
292     { aListTrustDB, "list-trustdb",0 , "@"},
293     { aListTrustPath, "list-trust-path",0, "@"},
294     { oKOption, NULL,    0, "@"},
295     { oPasswdFD, "passphrase-fd",1, "@" },
296     { aDeleteSecretKey, "delete-secret-key",0, "@" },
297     { oQuickRandom, "quick-random", 0, "@"},
298     { oNoVerbose, "no-verbose", 0, "@"},
299     { oTrustDBName, "trustdb-name", 2, "@" },
300     { oNoSecmemWarn, "no-secmem-warning", 0, "@" }, /* used only by regression tests */
301     { oNoArmor, "no-armor",   0, "@"},
302     { oNoDefKeyring, "no-default-keyring", 0, "@" },
303     { oNoGreeting, "no-greeting", 0, "@" },
304     { oNoOptions, "no-options", 0, "@" }, /* shortcut for --options /dev/null */
305     { oHomedir, "homedir", 2, "@" },   /* defaults to "~/.gnupg" */
306     { oNoBatch, "no-batch", 0, "@" },
307     { oWithColons, "with-colons", 0, "@"},
308     { oWithKeyData,"with-key-data", 0, "@"},
309     { aListKeys, "list-key", 0, "@" }, /* alias */
310     { aListSigs, "list-sig", 0, "@" }, /* alias */
311     { aCheckKeys, "check-sig",0, "@" }, /* alias */
312     { oSkipVerify, "skip-verify",0, "@" },
313     { oCompressKeys, "compress-keys",0, "@"},
314     { oCompressSigs, "compress-sigs",0, "@"},
315     { oAlwaysTrust, "always-trust", 0, "@"},
316     { oEmuChecksumBug, "emulate-checksum-bug", 0, "@"},
317     { oRunAsShmCP, "run-as-shm-coprocess", 4, "@" },
318     { oSetFilename, "set-filename", 2, "@" },
319     { oSetPolicyURL, "set-policy-url", 2, "@" },
320     { oComment, "comment", 2, "@" },
321     { oDefaultComment, "default-comment", 0, "@" },
322     { oNoVersion, "no-version", 0, "@"},
323     { oEmitVersion, "emit-version", 0, "@"},
324     { oNotDashEscaped, "not-dash-escaped", 0, "@" },
325     { oEscapeFrom, "escape-from-lines", 0, "@" },
326     { oLockOnce, "lock-once", 0, "@" },
327     { oLockMultiple, "lock-multiple", 0, "@" },
328     { oLoggerFD, "logger-fd",1, "@" },
329     { oUseEmbeddedFilename, "use-embedded-filename", 0, "@" },
330     { oUtf8Strings, "utf8-strings", 0, "@" },
331     { oNoUtf8Strings, "no-utf8-strings", 0, "@" },
332     { oWithFingerprint, "with-fingerprint", 0, "@" },
333     { oDisableCipherAlgo,  "disable-cipher-algo", 2, "@" },
334     { oDisablePubkeyAlgo,  "disable-pubkey-algo", 2, "@" },
335 {0} };
336
337
338
339 int g10_errors_seen = 0;
340
341 static int utf8_strings = 0;
342 static int maybe_setuid = 1;
343
344 static char *build_list( const char *text,
345                          const char *(*mapf)(int), int (*chkf)(int) );
346 static void set_cmd( enum cmd_and_opt_values *ret_cmd,
347                         enum cmd_and_opt_values new_cmd );
348 static void print_hex( byte *p, size_t n );
349 static void print_mds( const char *fname, int algo );
350 static void add_notation_data( const char *string );
351 static int  check_policy_url( const char *s );
352
353 const char *
354 strusage( int level )
355 {
356   static char *digests, *pubkeys, *ciphers;
357     const char *p;
358     switch( level ) {
359       case 11: p = "gpg (GnuPG)";
360         break;
361       case 13: p = VERSION; break;
362       case 17: p = PRINTABLE_OS_NAME; break;
363       case 19: p =
364             _("Please report bugs to <gnupg-bugs@gnu.org>.\n");
365         break;
366       case 1:
367       case 40:  p =
368             _("Usage: gpg [options] [files] (-h for help)");
369         break;
370       case 41:  p =
371             _("Syntax: gpg [options] [files]\n"
372               "sign, check, encrypt or decrypt\n"
373               "default operation depends on the input data\n");
374         break;
375
376       case 31: p = _("\nSupported algorithms:\n"); break;
377       case 32:
378         if( !ciphers )
379             ciphers = build_list("Cipher: ", cipher_algo_to_string,
380                                                         check_cipher_algo );
381         p = ciphers;
382         break;
383       case 33:
384         if( !pubkeys )
385             pubkeys = build_list("Pubkey: ", pubkey_algo_to_string,
386                                                         check_pubkey_algo );
387         p = pubkeys;
388         break;
389       case 34:
390         if( !digests )
391             digests = build_list("Hash: ", digest_algo_to_string,
392                                                         check_digest_algo );
393         p = digests;
394         break;
395
396       default:  p = default_strusage(level);
397     }
398     return p;
399 }
400
401
402 static char *
403 build_list( const char *text, const char * (*mapf)(int), int (*chkf)(int) )
404 {
405     int i;
406     const char *s;
407     size_t n=strlen(text)+2;
408     char *list, *p;
409
410     if( maybe_setuid )
411         secmem_init( 0 );    /* drop setuid */
412
413     for(i=1; i < 110; i++ )
414         if( !chkf(i) && (s=mapf(i)) )
415             n += strlen(s) + 2;
416     list = m_alloc( 21 + n ); *list = 0;
417     for(p=NULL, i=1; i < 110; i++ ) {
418         if( !chkf(i) && (s=mapf(i)) ) {
419             if( !p )
420                 p = stpcpy( list, text );
421             else
422                 p = stpcpy( p, ", ");
423             p = stpcpy(p, s );
424         }
425     }
426     if( p )
427         p = stpcpy(p, "\n" );
428     return list;
429 }
430
431
432 static void
433 i18n_init(void)
434 {
435   #ifdef ENABLE_NLS
436     #ifdef HAVE_LC_MESSAGES
437        setlocale( LC_TIME, "" );
438        setlocale( LC_MESSAGES, "" );
439     #else
440        setlocale( LC_ALL, "" );
441     #endif
442     bindtextdomain( PACKAGE, G10_LOCALEDIR );
443     textdomain( PACKAGE );
444   #endif
445 }
446
447 static void
448 wrong_args( const char *text)
449 {
450     fputs(_("usage: gpg [options] "),stderr);
451     fputs(text,stderr);
452     putc('\n',stderr);
453     g10_exit(2);
454 }
455
456
457 static char *
458 make_username( const char *string )
459 {
460     char *p;
461     if( utf8_strings )
462         p = native_to_utf8( string );
463     else
464         p = m_strdup(string);
465     return p;
466 }
467
468
469 static void
470 set_debug(void)
471 {
472     if( opt.debug & DBG_MEMORY_VALUE )
473         memory_debug_mode = 1;
474     if( opt.debug & DBG_MEMSTAT_VALUE )
475         memory_stat_debug_mode = 1;
476     if( opt.debug & DBG_MPI_VALUE )
477         mpi_debug_mode = 1;
478     if( opt.debug & DBG_CIPHER_VALUE )
479         g10c_debug_mode = 1;
480     if( opt.debug & DBG_IOBUF_VALUE )
481         iobuf_debug_mode = 1;
482
483 }
484
485
486 static void
487 set_cmd( enum cmd_and_opt_values *ret_cmd, enum cmd_and_opt_values new_cmd )
488 {
489     enum cmd_and_opt_values cmd = *ret_cmd;
490
491     if( !cmd || cmd == new_cmd )
492         cmd = new_cmd;
493     else if( cmd == aSign && new_cmd == aEncr )
494         cmd = aSignEncr;
495     else if( cmd == aEncr && new_cmd == aSign )
496         cmd = aSignEncr;
497     else if( cmd == aKMode && new_cmd == aSym )
498         cmd = aKModeC;
499     else if(    ( cmd == aSign     && new_cmd == aClearsign )
500              || ( cmd == aClearsign && new_cmd == aSign )  )
501         cmd = aClearsign;
502     else {
503         log_error(_("conflicting commands\n"));
504         g10_exit(2);
505     }
506
507     *ret_cmd = cmd;
508 }
509
510
511
512 int
513 main( int argc, char **argv )
514 {
515     ARGPARSE_ARGS pargs;
516     IOBUF a;
517     int rc=0;
518     int orig_argc;
519     char **orig_argv;
520     const char *fname;
521     char *username;
522     STRLIST sl, remusr= NULL, locusr=NULL;
523     STRLIST nrings=NULL, sec_nrings=NULL;
524     armor_filter_context_t afx;
525     int detached_sig = 0;
526     FILE *configfp = NULL;
527     char *configname = NULL;
528     unsigned configlineno;
529     int parse_debug = 0;
530     int default_config =1;
531     int default_keyring = 1;
532     int greeting = 0;
533     int nogreeting = 0;
534     enum cmd_and_opt_values cmd = 0;
535     const char *trustdb_name = NULL;
536     char *def_cipher_string = NULL;
537     char *def_digest_string = NULL;
538     char *s2k_cipher_string = NULL;
539     char *s2k_digest_string = NULL;
540     int pwfd = -1;
541     int with_fpr = 0; /* make an option out of --fingerprint */
542   #ifdef USE_SHM_COPROCESSING
543     ulong requested_shm_size=0;
544   #endif
545
546     trap_unaligned();
547     secmem_set_flags( secmem_get_flags() | 2 ); /* suspend warnings */
548     /* Please note that we may running SUID(ROOT), so be very CAREFUL
549      * when adding any stuff between here and the call to
550      * secmem_init()  somewhere after the option parsing
551      */
552     log_set_name("gpg");
553     secure_random_alloc(); /* put random number into secure memory */
554     disable_core_dumps();
555     init_signals();
556     create_dotlock(NULL); /* register locking cleanup */
557     i18n_init();
558     opt.compress = -1; /* defaults to standard compress level */
559     /* note: if you change these lines, look at oOpenPGP */
560     opt.def_cipher_algo = 0;
561     opt.def_digest_algo = 0;
562     opt.def_compress_algo = 2;
563     opt.s2k_mode = 3; /* iterated+salted */
564     opt.s2k_digest_algo = DIGEST_ALGO_RMD160;
565     opt.s2k_cipher_algo = CIPHER_ALGO_BLOWFISH;
566     opt.completes_needed = 1;
567     opt.marginals_needed = 3;
568     opt.max_cert_depth = 5;
569     opt.homedir = getenv("GNUPGHOME");
570     if( !opt.homedir || !*opt.homedir ) {
571       #ifdef HAVE_DRIVE_LETTERS
572         opt.homedir = "c:/gnupg";
573       #else
574         opt.homedir = "~/.gnupg";
575       #endif
576     }
577
578     /* check whether we have a config file on the commandline */
579     orig_argc = argc;
580     orig_argv = argv;
581     pargs.argc = &argc;
582     pargs.argv = &argv;
583     pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
584     while( arg_parse( &pargs, opts) ) {
585         if( pargs.r_opt == oDebug || pargs.r_opt == oDebugAll )
586             parse_debug++;
587         else if( pargs.r_opt == oOptions ) {
588             /* yes there is one, so we do not try the default one, but
589              * read the option file when it is encountered at the commandline
590              */
591             default_config = 0;
592         }
593         else if( pargs.r_opt == oNoOptions )
594             default_config = 0; /* --no-options */
595         else if( pargs.r_opt == oHomedir )
596             opt.homedir = pargs.r.ret_str;
597       #ifdef USE_SHM_COPROCESSING
598         else if( pargs.r_opt == oRunAsShmCP ) {
599             /* does not make sense in a options file, we do it here,
600              * so that we are the able to drop setuid as soon as possible */
601             opt.shm_coprocess = 1;
602             requested_shm_size = pargs.r.ret_ulong;
603         }
604         else if ( pargs.r_opt == oStatusFD ) {
605             /* this is needed to ensure that the status-fd filedescriptor is
606              * initialized when init_shm_coprocessing() is called */
607             set_status_fd( pargs.r.ret_int );
608         }
609       #endif
610     }
611
612
613   #ifdef USE_SHM_COPROCESSING
614     if( opt.shm_coprocess ) {
615         init_shm_coprocessing(requested_shm_size, 1 );
616     }
617   #endif
618     /* initialize the secure memory. */
619     secmem_init( 16384 );
620     maybe_setuid = 0;
621     /* Okay, we are now working under our real uid */
622
623     if( default_config )
624         configname = make_filename(opt.homedir, "options", NULL );
625
626     argc = orig_argc;
627     argv = orig_argv;
628     pargs.argc = &argc;
629     pargs.argv = &argv;
630     pargs.flags=  1;  /* do not remove the args */
631   next_pass:
632     if( configname ) {
633         configlineno = 0;
634         configfp = fopen( configname, "r" );
635         if( !configfp ) {
636             if( default_config ) {
637                 if( parse_debug )
638                     log_info(_("NOTE: no default option file `%s'\n"),
639                                                             configname );
640             }
641             else {
642                 log_error(_("option file `%s': %s\n"),
643                                     configname, strerror(errno) );
644                 g10_exit(2);
645             }
646             m_free(configname); configname = NULL;
647         }
648         if( parse_debug && configname )
649             log_info(_("reading options from `%s'\n"), configname );
650         default_config = 0;
651     }
652
653     while( optfile_parse( configfp, configname, &configlineno,
654                                                 &pargs, opts) ) {
655         switch( pargs.r_opt ) {
656           case aCheckKeys: set_cmd( &cmd, aCheckKeys); break;
657           case aListPackets: set_cmd( &cmd, aListPackets); break;
658           case aImport: set_cmd( &cmd, aImport); break;
659           case aFastImport: set_cmd( &cmd, aFastImport); break;
660           case aSendKeys: set_cmd( &cmd, aSendKeys); break;
661           case aRecvKeys: set_cmd( &cmd, aRecvKeys); break;
662           case aExport: set_cmd( &cmd, aExport); break;
663           case aExportAll: set_cmd( &cmd, aExportAll); break;
664           case aListKeys: set_cmd( &cmd, aListKeys); break;
665           case aListSigs: set_cmd( &cmd, aListSigs); break;
666           case aExportSecret: set_cmd( &cmd, aExportSecret); break;
667           case aDeleteSecretKey: set_cmd( &cmd, aDeleteSecretKey);
668                                                         greeting=1; break;
669           case aDeleteKey: set_cmd( &cmd, aDeleteKey); greeting=1; break;
670
671           case aDetachedSign: detached_sig = 1; set_cmd( &cmd, aSign ); break;
672           case aSym: set_cmd( &cmd, aSym); break;
673           case aDecrypt: set_cmd( &cmd, aDecrypt); break;
674           case aEncr: set_cmd( &cmd, aEncr); break;
675           case aSign: set_cmd( &cmd, aSign );  break;
676           case aKeygen: set_cmd( &cmd, aKeygen); greeting=1; break;
677           case aSignKey: set_cmd( &cmd, aSignKey); break;
678           case aLSignKey: set_cmd( &cmd, aLSignKey); break;
679           case aStore: set_cmd( &cmd, aStore); break;
680           case aEditKey: set_cmd( &cmd, aEditKey); greeting=1; break;
681           case aClearsign: set_cmd( &cmd, aClearsign); break;
682           case aGenRevoke: set_cmd( &cmd, aGenRevoke); break;
683           case aVerify: set_cmd( &cmd, aVerify); break;
684           case aPrimegen: set_cmd( &cmd, aPrimegen); break;
685           case aGenRandom: set_cmd( &cmd, aGenRandom); break;
686           case aPrintMD: set_cmd( &cmd, aPrintMD); break;
687           case aPrintMDs: set_cmd( &cmd, aPrintMDs); break;
688           case aListTrustDB: set_cmd( &cmd, aListTrustDB); break;
689           case aCheckTrustDB: set_cmd( &cmd, aCheckTrustDB); break;
690           case aUpdateTrustDB: set_cmd( &cmd, aUpdateTrustDB); break;
691           case aFixTrustDB: set_cmd( &cmd, aFixTrustDB); break;
692           case aListTrustPath: set_cmd( &cmd, aListTrustPath); break;
693           case aDeArmor: set_cmd( &cmd, aDeArmor); break;
694           case aEnArmor: set_cmd( &cmd, aEnArmor); break;
695           case aExportOwnerTrust: set_cmd( &cmd, aExportOwnerTrust); break;
696           case aImportOwnerTrust: set_cmd( &cmd, aImportOwnerTrust); break;
697
698           case oArmor: opt.armor = 1; opt.no_armor=0; break;
699           case oOutput: opt.outfile = pargs.r.ret_str; break;
700           case oQuiet: opt.quiet = 1; break;
701           case oNoTTY: opt.quiet = 1; tty_no_terminal(1); break;
702           case oDryRun: opt.dry_run = 1; break;
703           case oInteractive: opt.interactive = 1; break;
704           case oVerbose: g10_opt_verbose++;
705                     opt.verbose++; opt.list_sigs=1; break;
706           case oKOption: set_cmd( &cmd, aKMode ); break;
707
708           case oBatch: opt.batch = 1; greeting = 0; break;
709           case oAnswerYes: opt.answer_yes = 1; break;
710           case oAnswerNo: opt.answer_no = 1; break;
711           case oKeyring: append_to_strlist( &nrings, pargs.r.ret_str); break;
712           case oDebug: opt.debug |= pargs.r.ret_ulong; break;
713           case oDebugAll: opt.debug = ~0; break;
714           case oStatusFD: set_status_fd( pargs.r.ret_int ); break;
715           case oLoggerFD: log_set_logfile( NULL, pargs.r.ret_int ); break;
716           case oWithFingerprint:
717                 with_fpr=1; /*fall thru*/
718           case oFingerprint: opt.fingerprint++; break;
719           case oSecretKeyring: append_to_strlist( &sec_nrings, pargs.r.ret_str); break;
720           case oOptions:
721             /* config files may not be nested (silently ignore them) */
722             if( !configfp ) {
723                 m_free(configname);
724                 configname = m_strdup(pargs.r.ret_str);
725                 goto next_pass;
726             }
727             break;
728           case oNoArmor: opt.no_armor=1; opt.armor=0; break;
729           case oNoDefKeyring: default_keyring = 0; break;
730           case oNoGreeting: nogreeting = 1; break;
731           case oNoVerbose: g10_opt_verbose = 0;
732                            opt.verbose = 0; opt.list_sigs=0; break;
733           case oQuickRandom: quick_random_gen(1); break;
734           case oNoComment: opt.no_comment=1; break;
735           case oNoVersion: opt.no_version=1; break;
736           case oEmitVersion: opt.no_version=0; break;
737           case oCompletesNeeded: opt.completes_needed = pargs.r.ret_int; break;
738           case oMarginalsNeeded: opt.marginals_needed = pargs.r.ret_int; break;
739           case oMaxCertDepth: opt.max_cert_depth = pargs.r.ret_int; break;
740           case oTrustDBName: trustdb_name = pargs.r.ret_str; break;
741           case oDefaultKey: opt.def_secret_key = pargs.r.ret_str; break;
742           case oDefRecipient:
743                     if( *pargs.r.ret_str )
744                         opt.def_recipient = make_username(pargs.r.ret_str);
745                     break;
746           case oDefRecipientSelf:
747                     m_free(opt.def_recipient); opt.def_recipient = NULL;
748                     opt.def_recipient_self = 1;
749                     break;
750           case oNoDefRecipient:
751                     m_free(opt.def_recipient); opt.def_recipient = NULL;
752                     opt.def_recipient_self = 0;
753                     break;
754           case oNoOptions: break; /* no-options */
755           case oHomedir: opt.homedir = pargs.r.ret_str; break;
756           case oNoBatch: opt.batch = 0; break;
757           case oWithKeyData: opt.with_key_data=1; /* fall thru */
758           case oWithColons: opt.with_colons=':'; break;
759
760           case oSkipVerify: opt.skip_verify=1; break;
761           case oCompressAlgo: opt.def_compress_algo = pargs.r.ret_int; break;
762           case oCompressKeys: opt.compress_keys = 1; break;
763           case aListSecretKeys: set_cmd( &cmd, aListSecretKeys); break;
764           case oAlwaysTrust: opt.always_trust = 1; break;
765           case oLoadExtension:
766             register_cipher_extension(orig_argc? *orig_argv:NULL,
767                                       pargs.r.ret_str);
768             break;
769           case oRFC1991:
770             opt.rfc1991 = 1;
771             opt.no_comment = 1;
772             opt.escape_from = 1;
773             break;
774           case oOpenPGP:
775             opt.rfc1991 = 0;
776             opt.escape_from = 0;
777             opt.force_v3_sigs = 0;
778             opt.compress_keys = 0;          /* not mandated  but we do it */
779             opt.compress_sigs = 0;          /* ditto. */
780             opt.not_dash_escaped = 0;
781             opt.def_cipher_algo = 0;
782             opt.def_digest_algo = 0;
783             opt.def_compress_algo = 2;
784             opt.s2k_mode = 3; /* iterated+salted */
785             opt.s2k_digest_algo = DIGEST_ALGO_RMD160;
786             opt.s2k_cipher_algo = CIPHER_ALGO_BLOWFISH;
787             break;
788           case oEmuChecksumBug: opt.emulate_bugs |= EMUBUG_GPGCHKSUM; break;
789           case oCompressSigs: opt.compress_sigs = 1; break;
790           case oRunAsShmCP:
791           #ifndef USE_SHM_COPROCESSING
792             /* not possible in the option file,
793              * but we print the warning here anyway */
794             log_error("shared memory coprocessing is not available\n");
795           #endif
796             break;
797           case oSetFilename: opt.set_filename = pargs.r.ret_str; break;
798           case oSetPolicyURL: opt.set_policy_url = pargs.r.ret_str; break;
799           case oUseEmbeddedFilename: opt.use_embedded_filename = 1; break;
800           case oComment: opt.comment_string = pargs.r.ret_str; break;
801           case oDefaultComment: opt.comment_string = NULL; break;
802           case oThrowKeyid: opt.throw_keyid = 1; break;
803           case oForceV3Sigs: opt.force_v3_sigs = 1; break;
804           case oForceMDC: opt.force_mdc = 1; break;
805           case oS2KMode:   opt.s2k_mode = pargs.r.ret_int; break;
806           case oS2KDigest: s2k_digest_string = m_strdup(pargs.r.ret_str); break;
807           case oS2KCipher: s2k_cipher_string = m_strdup(pargs.r.ret_str); break;
808
809           case oNoEncryptTo: opt.no_encrypt_to = 1; break;
810           case oEncryptTo: /* store the recipient in the second list */
811             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
812             sl->flags = 1;
813             break;
814           case oRecipient: /* store the recipient */
815             add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
816             break;
817           case oTextmodeShort: opt.textmode = 2; break;
818           case oTextmode: opt.textmode=1;  break;
819           case oUser: /* store the local users */
820             add_to_strlist2( &locusr, pargs.r.ret_str, utf8_strings );
821             break;
822           case oCompress: opt.compress = pargs.r.ret_int; break;
823           case oPasswdFD: pwfd = pargs.r.ret_int; break;
824           case oCipherAlgo: def_cipher_string = m_strdup(pargs.r.ret_str); break;
825           case oDigestAlgo: def_digest_string = m_strdup(pargs.r.ret_str); break;
826           case oNoSecmemWarn: secmem_set_flags( secmem_get_flags() | 1 ); break;
827           case oCharset:
828             if( set_native_charset( pargs.r.ret_str ) )
829                 log_error(_("%s is not a valid character set\n"),
830                                                     pargs.r.ret_str);
831             break;
832           case oNotDashEscaped: opt.not_dash_escaped = 1; break;
833           case oEscapeFrom: opt.escape_from = 1; break;
834           case oLockOnce: opt.lock_once = 1; break;
835           case oLockMultiple: opt.lock_once = 0; break;
836           case oKeyServer: opt.keyserver_name = pargs.r.ret_str; break;
837           case oNotation: add_notation_data( pargs.r.ret_str ); break;
838           case oUtf8Strings: utf8_strings = 1; break;
839           case oNoUtf8Strings: utf8_strings = 0; break;
840           case oDisableCipherAlgo:
841                 disable_cipher_algo( string_to_cipher_algo(pargs.r.ret_str) );
842                 break;
843           case oDisablePubkeyAlgo:
844                 disable_pubkey_algo( string_to_pubkey_algo(pargs.r.ret_str) );
845                 break;
846
847           default : pargs.err = configfp? 1:2; break;
848         }
849     }
850     if( configfp ) {
851         fclose( configfp );
852         configfp = NULL;
853         m_free(configname); configname = NULL;
854         goto next_pass;
855     }
856     m_free( configname ); configname = NULL;
857     if( log_get_errorcount(0) )
858         g10_exit(2);
859     if( nogreeting )
860         greeting = 0;
861
862     if( greeting ) {
863         fprintf(stderr, "%s %s; %s\n",
864                         strusage(11), strusage(13), strusage(14) );
865         fprintf(stderr, "%s\n", strusage(15) );
866     }
867   #ifdef IS_DEVELOPMENT_VERSION
868     if( !opt.batch )
869         log_info("NOTE: this is a development version!\n");
870   #endif
871     if( opt.force_mdc ) {
872         log_info("--force-mdc ignored because"
873                  " the OpenPGP WG has not yet aggreed on MDCs\n");
874         opt.force_mdc = 0;
875     }
876     if( opt.batch )
877         tty_batchmode( 1 );
878
879     secmem_set_flags( secmem_get_flags() & ~2 ); /* resume warnings */
880
881     set_debug();
882     g10_opt_homedir = opt.homedir;
883
884     /* must do this after dropping setuid, because string_to...
885      * may try to load an module */
886     if( def_cipher_string ) {
887         opt.def_cipher_algo = string_to_cipher_algo(def_cipher_string);
888         m_free(def_cipher_string); def_cipher_string = NULL;
889         if( check_cipher_algo(opt.def_cipher_algo) )
890             log_error(_("selected cipher algorithm is invalid\n"));
891     }
892     if( def_digest_string ) {
893         opt.def_digest_algo = string_to_digest_algo(def_digest_string);
894         m_free(def_digest_string); def_digest_string = NULL;
895         if( check_digest_algo(opt.def_digest_algo) )
896             log_error(_("selected digest algorithm is invalid\n"));
897     }
898     if( s2k_cipher_string ) {
899         opt.s2k_cipher_algo = string_to_cipher_algo(s2k_cipher_string);
900         m_free(s2k_cipher_string); s2k_cipher_string = NULL;
901         if( check_cipher_algo(opt.s2k_cipher_algo) )
902             log_error(_("selected cipher algorithm is invalid\n"));
903     }
904     if( s2k_digest_string ) {
905         opt.s2k_digest_algo = string_to_digest_algo(s2k_digest_string);
906         m_free(s2k_digest_string); s2k_digest_string = NULL;
907         if( check_digest_algo(opt.s2k_digest_algo) )
908             log_error(_("selected digest algorithm is invalid\n"));
909     }
910     if( opt.set_policy_url ) {
911         if( check_policy_url( opt.set_policy_url ) )
912             log_error(_("the given policy URL is invalid\n"));
913     }
914     if( opt.def_compress_algo < 1 || opt.def_compress_algo > 2 )
915         log_error(_("compress algorithm must be in range %d..%d\n"), 1, 2);
916     if( opt.completes_needed < 1 )
917         log_error(_("completes-needed must be greater than 0\n"));
918     if( opt.marginals_needed < 2 )
919         log_error(_("marginals-needed must be greater than 1\n"));
920     if( opt.max_cert_depth < 1 || opt.max_cert_depth > 255 )
921         log_error(_("max-cert-depth must be in range 1 to 255\n"));
922     switch( opt.s2k_mode ) {
923       case 0:
924         log_info(_("NOTE: simple S2K mode (0) is strongly discouraged\n"));
925         break;
926       case 1: case 3: break;
927       default:
928         log_error(_("invalid S2K mode; must be 0, 1 or 3\n"));
929     }
930
931
932     if( log_get_errorcount(0) )
933         g10_exit(2);
934
935     if( !cmd && opt.fingerprint && !with_fpr )
936         set_cmd( &cmd, aListKeys);
937
938     if( cmd == aKMode || cmd == aKModeC ) { /* kludge to be compatible to pgp */
939         if( cmd == aKModeC ) {
940             opt.fingerprint = 1;
941             cmd = aKMode;
942         }
943         opt.list_sigs = 0;
944         if( opt.verbose > 2 )
945             opt.check_sigs++;
946         if( opt.verbose > 1 )
947             opt.list_sigs++;
948
949         opt.verbose = opt.verbose > 1;
950         g10_opt_verbose = opt.verbose;
951     }
952
953
954     /* kludge to let -sat generate a clear text signature */
955     if( opt.textmode == 2 && !detached_sig && opt.armor && cmd == aSign )
956         cmd = aClearsign;
957
958     if( opt.verbose > 1 )
959         set_packet_list_mode(1);
960
961     /* add the keyrings, but not for some special commands and
962      * not in case of "-kvv userid keyring" */
963     if( cmd != aDeArmor && cmd != aEnArmor
964         && !(cmd == aKMode && argc == 2 ) ) {
965
966         if( !sec_nrings && default_keyring )  /* add default secret rings */
967             add_keyblock_resource("secring.gpg", 0, 1);
968         for(sl = sec_nrings; sl; sl = sl->next )
969             add_keyblock_resource( sl->d, 0, 1 );
970         if( !nrings && default_keyring )  /* add default ring */
971             add_keyblock_resource("pubring.gpg", 0, 0);
972         for(sl = nrings; sl; sl = sl->next )
973             add_keyblock_resource( sl->d, 0, 0 );
974     }
975     FREE_STRLIST(nrings);
976     FREE_STRLIST(sec_nrings);
977
978
979     if( pwfd != -1 )  /* read the passphrase now. */
980         read_passphrase_from_fd( pwfd );
981
982     fname = argc? *argv : NULL;
983
984     switch( cmd ) {
985       case aPrimegen:
986       case aPrintMD:
987       case aPrintMDs:
988       case aGenRandom:
989       case aDeArmor:
990       case aEnArmor:
991       case aFixTrustDB:
992         break;
993       case aKMode:
994       case aListKeys:
995       case aListSecretKeys:
996       case aCheckKeys:
997         if( opt.with_colons ) /* need this to list the trust */
998             rc = setup_trustdb(1, trustdb_name );
999         break;
1000       case aExportOwnerTrust: rc = setup_trustdb( 0, trustdb_name ); break;
1001       case aListTrustDB: rc = setup_trustdb( argc? 1:0, trustdb_name ); break;
1002       default: rc = setup_trustdb(1, trustdb_name ); break;
1003     }
1004     if( rc )
1005         log_error(_("failed to initialize the TrustDB: %s\n"), g10_errstr(rc));
1006
1007
1008     switch( cmd ) {
1009       case aStore: /* only store the file */
1010         if( argc > 1 )
1011             wrong_args(_("--store [filename]"));
1012         if( (rc = encode_store(fname)) )
1013             log_error_f( print_fname_stdin(fname),
1014                         "store failed: %s\n", g10_errstr(rc) );
1015         break;
1016       case aSym: /* encrypt the given file only with the symmetric cipher */
1017         if( argc > 1 )
1018             wrong_args(_("--symmetric [filename]"));
1019         if( (rc = encode_symmetric(fname)) )
1020             log_error_f(print_fname_stdin(fname),
1021                         "symmetric encryption failed: %s\n",g10_errstr(rc) );
1022         break;
1023
1024       case aEncr: /* encrypt the given file */
1025         if( argc > 1 )
1026             wrong_args(_("--encrypt [filename]"));
1027         if( (rc = encode_crypt(fname,remusr)) )
1028             log_error("%s: encryption failed: %s\n", print_fname_stdin(fname), g10_errstr(rc) );
1029         break;
1030
1031       case aSign: /* sign the given file */
1032         sl = NULL;
1033         if( detached_sig ) { /* sign all files */
1034             for( ; argc; argc--, argv++ )
1035                 add_to_strlist( &sl, *argv );
1036         }
1037         else {
1038             if( argc > 1 )
1039                 wrong_args(_("--sign [filename]"));
1040             if( argc ) {
1041                 sl = m_alloc_clear( sizeof *sl + strlen(fname));
1042                 strcpy(sl->d, fname);
1043             }
1044         }
1045         if( (rc = sign_file( sl, detached_sig, locusr, 0, NULL, NULL)) )
1046             log_error("signing failed: %s\n", g10_errstr(rc) );
1047         free_strlist(sl);
1048         break;
1049
1050       case aSignEncr: /* sign and encrypt the given file */
1051         if( argc > 1 )
1052             wrong_args(_("--sign --encrypt [filename]"));
1053         if( argc ) {
1054             sl = m_alloc_clear( sizeof *sl + strlen(fname));
1055             strcpy(sl->d, fname);
1056         }
1057         else
1058             sl = NULL;
1059         if( (rc = sign_file(sl, detached_sig, locusr, 1, remusr, NULL)) )
1060             log_error("%s: sign+encrypt failed: %s\n", print_fname_stdin(fname), g10_errstr(rc) );
1061         free_strlist(sl);
1062         break;
1063
1064       case aClearsign: /* make a clearsig */
1065         if( argc > 1 )
1066             wrong_args(_("--clearsign [filename]"));
1067         if( (rc = clearsign_file(fname, locusr, NULL)) )
1068             log_error("%s: clearsign failed: %s\n", print_fname_stdin(fname), g10_errstr(rc) );
1069         break;
1070
1071       case aVerify:
1072         if( (rc = verify_signatures( argc, argv ) ))
1073             log_error("verify signatures failed: %s\n", g10_errstr(rc) );
1074         break;
1075
1076       case aDecrypt:
1077         if( argc > 1 )
1078             wrong_args(_("--decrypt [filename]"));
1079         if( (rc = decrypt_message( fname ) ))
1080             log_error("decrypt_message failed: %s\n", g10_errstr(rc) );
1081         break;
1082
1083
1084       case aSignKey: /* sign the key given as argument */
1085         if( argc != 1 )
1086             wrong_args(_("--sign-key user-id"));
1087         username = make_username( fname );
1088         keyedit_menu(fname, locusr, NULL, 1 );
1089         m_free(username);
1090         break;
1091
1092       case aLSignKey:
1093         if( argc != 1 )
1094             wrong_args(_("--lsign-key user-id"));
1095         username = make_username( fname );
1096         keyedit_menu(fname, locusr, NULL, 2 );
1097         m_free(username);
1098         break;
1099
1100       case aEditKey: /* Edit a key signature */
1101         if( !argc )
1102             wrong_args(_("--edit-key user-id [commands]"));
1103         username = make_username( fname );
1104         if( argc > 1 ) {
1105             sl = NULL;
1106             for( argc--, argv++ ; argc; argc--, argv++ )
1107                 append_to_strlist( &sl, *argv );
1108             keyedit_menu( username, locusr, sl, 0 );
1109             free_strlist(sl);
1110         }
1111         else
1112             keyedit_menu(username, locusr, NULL, 0 );
1113         m_free(username);
1114         break;
1115
1116       case aDeleteSecretKey:
1117         if( argc != 1 )
1118             wrong_args(_("--delete-secret-key user-id"));
1119       case aDeleteKey:
1120         if( argc != 1 )
1121             wrong_args(_("--delete-key user-id"));
1122         username = make_username( fname );
1123         if( (rc = delete_key(username, cmd==aDeleteSecretKey)) )
1124             log_error("%s: delete key failed: %s\n", username, g10_errstr(rc) );
1125         m_free(username);
1126         break;
1127
1128
1129       case aCheckKeys:
1130         opt.check_sigs = 1;
1131       case aListSigs:
1132         opt.list_sigs = 1;
1133       case aListKeys:
1134         public_key_list( argc, argv );
1135         break;
1136       case aListSecretKeys:
1137         secret_key_list( argc, argv );
1138         break;
1139
1140       case aKMode: /* list keyring -- NOTE: This will be removed soon */
1141         if( argc < 2 )  /* -kv [userid] */
1142             public_key_list( (argc && **argv)? 1:0, argv );
1143         else if( argc == 2 ) { /* -kv userid keyring */
1144             if( access( argv[1], R_OK ) ) {
1145                 log_error(_("can't open %s: %s\n"),
1146                                print_fname_stdin(argv[1]), strerror(errno));
1147             }
1148             else {
1149                 /* add keyring (default keyrings are not registered in this
1150                  * special case */
1151                 add_keyblock_resource( argv[1], 0, 0 );
1152                 public_key_list( **argv?1:0, argv );
1153             }
1154         }
1155         else
1156             wrong_args(_("-k[v][v][v][c] [userid] [keyring]") );
1157         break;
1158
1159       case aKeygen: /* generate a key (interactive) */
1160         if( argc )
1161             wrong_args("--gen-key");
1162         generate_keypair();
1163         break;
1164
1165       case aFastImport:
1166       case aImport:
1167         if( !argc  ) {
1168             rc = import_keys( NULL, (cmd == aFastImport) );
1169             if( rc )
1170                 log_error("import failed: %s\n", g10_errstr(rc) );
1171         }
1172         for( ; argc; argc--, argv++ ) {
1173             rc = import_keys( *argv, (cmd == aFastImport) );
1174             if( rc )
1175                 log_error("import from `%s' failed: %s\n",
1176                                                 *argv, g10_errstr(rc) );
1177         }
1178         break;
1179
1180       case aExport:
1181       case aExportAll:
1182       case aSendKeys:
1183       case aRecvKeys:
1184         sl = NULL;
1185         for( ; argc; argc--, argv++ )
1186             add_to_strlist2( &sl, *argv, utf8_strings );
1187         if( cmd == aSendKeys )
1188             hkp_export( sl );
1189         else if( cmd == aRecvKeys )
1190             hkp_import( sl );
1191         else
1192             export_pubkeys( sl, (cmd == aExport) );
1193         free_strlist(sl);
1194         break;
1195
1196       case aExportSecret:
1197         sl = NULL;
1198         for( ; argc; argc--, argv++ )
1199             add_to_strlist2( &sl, *argv, utf8_strings );
1200         export_seckeys( sl );
1201         free_strlist(sl);
1202         break;
1203
1204       case aGenRevoke:
1205         if( argc != 1 )
1206             wrong_args("--gen-revoke user-id");
1207         username =  make_username(*argv);
1208         gen_revoke( username );
1209         m_free( username );
1210         break;
1211
1212       case aDeArmor:
1213         if( argc > 1 )
1214             wrong_args("--dearmor [file]");
1215         rc = dearmor_file( argc? *argv: NULL );
1216         if( rc )
1217             log_error(_("dearmoring failed: %s\n"), g10_errstr(rc));
1218         break;
1219
1220       case aEnArmor:
1221         if( argc > 1 )
1222             wrong_args("--enarmor [file]");
1223         rc = enarmor_file( argc? *argv: NULL );
1224         if( rc )
1225             log_error(_("enarmoring failed: %s\n"), g10_errstr(rc));
1226         break;
1227
1228
1229       case aPrimegen:
1230         {   int mode = argc < 2 ? 0 : atoi(*argv);
1231
1232             if( mode == 1 && argc == 2 ) {
1233                 mpi_print( stdout, generate_public_prime( atoi(argv[1]) ), 1);
1234             }
1235             else if( mode == 2 && argc == 3 ) {
1236                 mpi_print( stdout, generate_elg_prime(
1237                                              0, atoi(argv[1]),
1238                                              atoi(argv[2]), NULL,NULL ), 1);
1239             }
1240             else if( mode == 3 && argc == 3 ) {
1241                 MPI *factors;
1242                 mpi_print( stdout, generate_elg_prime(
1243                                              1, atoi(argv[1]),
1244                                              atoi(argv[2]), NULL,&factors ), 1);
1245                 putchar('\n');
1246                 mpi_print( stdout, factors[0], 1 ); /* print q */
1247             }
1248             else if( mode == 4 && argc == 3 ) {
1249                 MPI g = mpi_alloc(1);
1250                 mpi_print( stdout, generate_elg_prime(
1251                                                  0, atoi(argv[1]),
1252                                                  atoi(argv[2]), g, NULL ), 1);
1253                 putchar('\n');
1254                 mpi_print( stdout, g, 1 );
1255                 mpi_free(g);
1256             }
1257             else
1258                 wrong_args("--gen-prime mode bits [qbits] ");
1259             putchar('\n');
1260         }
1261         break;
1262
1263       case aGenRandom:
1264         {
1265             int level = argc ? atoi(*argv):0;
1266             int count = argc > 1 ? atoi(argv[1]): 0;
1267             int endless = !count;
1268
1269             if( argc < 1 || argc > 2 || level < 0 || level > 2 || count < 0 )
1270                 wrong_args("--gen-random 0|1|2 [count]");
1271
1272             while( endless || count ) {
1273                 byte *p;
1274                 size_t n = !endless && count < 100? count : 100;
1275
1276                 p = get_random_bits( n*8, level, 0);
1277                 fwrite( p, n, 1, stdout );
1278                 m_free(p);
1279                 if( !endless )
1280                     count -= n;
1281             }
1282         }
1283         break;
1284
1285       case aPrintMD:
1286         if( argc < 1)
1287             wrong_args("--print-md algo [files]");
1288         {
1289             int all_algos = (**argv=='*' && !(*argv)[1]);
1290             int algo = all_algos? 0 : string_to_digest_algo(*argv);
1291
1292             if( !algo && !all_algos )
1293                 log_error(_("invalid hash algorithm `%s'\n"), *argv );
1294             else {
1295                 argc--; argv++;
1296                 if( !argc )
1297                     print_mds(NULL, algo);
1298                 else {
1299                     for(; argc; argc--, argv++ )
1300                         print_mds(*argv, algo);
1301                 }
1302             }
1303         }
1304         break;
1305
1306       case aPrintMDs: /* old option */
1307         if( !argc )
1308             print_mds(NULL,0);
1309         else {
1310             for(; argc; argc--, argv++ )
1311                 print_mds(*argv,0);
1312         }
1313         break;
1314
1315       case aListTrustDB:
1316         if( !argc )
1317             list_trustdb(NULL);
1318         else {
1319             for( ; argc; argc--, argv++ )
1320                 list_trustdb( *argv );
1321         }
1322         break;
1323
1324       case aUpdateTrustDB:
1325         if( argc )
1326             wrong_args("--update-trustdb");
1327         update_trustdb();
1328         break;
1329
1330       case aCheckTrustDB:
1331         if( !argc )
1332             check_trustdb(NULL);
1333         else {
1334             for( ; argc; argc--, argv++ ) {
1335                 username = make_username( *argv );
1336                 check_trustdb( username );
1337                 m_free(username);
1338             }
1339         }
1340         break;
1341
1342       case aFixTrustDB:
1343         log_error("this command ist not yet implemented.\"\n");
1344         log_error("A workaround is to use \"--export-ownertrust\", remove\n");
1345         log_error("the trustdb file and do an \"--import-ownertrust\".\n" );
1346         break;
1347
1348       case aListTrustPath:
1349         if( !argc )
1350             wrong_args("--list-trust-path <user-ids>");
1351         for( ; argc; argc--, argv++ ) {
1352             username = make_username( *argv );
1353             list_trust_path( username );
1354             m_free(username);
1355         }
1356         break;
1357
1358       case aExportOwnerTrust:
1359         if( argc )
1360             wrong_args("--export-ownertrust");
1361         export_ownertrust();
1362         break;
1363
1364       case aImportOwnerTrust:
1365         if( argc > 1 )
1366             wrong_args("--import-ownertrust [file]");
1367         import_ownertrust( argc? *argv:NULL );
1368         break;
1369
1370       case aListPackets:
1371         opt.list_packets=1;
1372       default:
1373         if( argc > 1 )
1374             wrong_args(_("[filename]"));
1375         /* Issue some output for the unix newbie */
1376         if( !fname && !opt.outfile && isatty( fileno(stdin) )
1377                 && isatty( fileno(stdout) ) && isatty( fileno(stderr) ) )
1378             log_info(_("Go ahead and type your message ...\n"));
1379
1380         if( !(a = iobuf_open(fname)) )
1381             log_error(_("can't open `%s'\n"), print_fname_stdin(fname));
1382         else {
1383
1384             if( !opt.no_armor ) {
1385                 if( use_armor_filter( a ) ) {
1386                     memset( &afx, 0, sizeof afx);
1387                     iobuf_push_filter( a, armor_filter, &afx );
1388                 }
1389             }
1390             if( cmd == aListPackets ) {
1391                 set_packet_list_mode(1);
1392                 opt.list_packets=1;
1393             }
1394             rc = proc_packets(NULL, a );
1395             if( rc )
1396                 log_error("processing message failed: %s\n", g10_errstr(rc) );
1397             iobuf_close(a);
1398         }
1399         break;
1400     }
1401
1402     /* cleanup */
1403     FREE_STRLIST(remusr);
1404     FREE_STRLIST(locusr);
1405     g10_exit(0);
1406     return 8; /*NEVER REACHED*/
1407 }
1408
1409
1410 void
1411 g10_exit( int rc )
1412 {
1413     if( opt.debug & DBG_MEMSTAT_VALUE ) {
1414         m_print_stats("on exit");
1415         random_dump_stats();
1416     }
1417     if( opt.debug )
1418         secmem_dump_stats();
1419     secmem_term();
1420     rc = rc? rc : log_get_errorcount(0)? 2 :
1421                         g10_errors_seen? 1 : 0;
1422     /*write_status( STATUS_LEAVE );*/
1423     exit(rc );
1424 }
1425
1426
1427
1428
1429 static void
1430 print_hex( byte *p, size_t n )
1431 {
1432     int i;
1433
1434     if( n == 20 ) {
1435         for(i=0; i < n ; i++, i++, p += 2 ) {
1436             if( i )
1437                 putchar(' ');
1438             if( i == 10 )
1439                 putchar(' ');
1440             printf("%02X%02X", *p, p[1] );
1441         }
1442     }
1443     else if( n == 24 ) {
1444         for(i=0; i < n ; i += 4, p += 4 ) {
1445             if( i )
1446                 putchar(' ');
1447             if( i == 12 )
1448                 putchar(' ');
1449             printf("%02X%02X%02X%02X", *p, p[1], p[2], p[3] );
1450         }
1451     }
1452     else {
1453         for(i=0; i < n ; i++, p++ ) {
1454             if( i )
1455                 putchar(' ');
1456             if( i && !(i%8) )
1457                 putchar(' ');
1458             printf("%02X", *p );
1459         }
1460     }
1461 }
1462
1463 static void
1464 print_mds( const char *fname, int algo )
1465 {
1466     FILE *fp;
1467     char buf[1024];
1468     size_t n;
1469     MD_HANDLE md;
1470     char *pname;
1471
1472     if( !fname ) {
1473         fp = stdin;
1474         pname = m_strdup("[stdin]: ");
1475     }
1476     else {
1477         pname = m_alloc(strlen(fname)+3);
1478         strcpy(stpcpy(pname,fname),": ");
1479         fp = fopen( fname, "rb" );
1480     }
1481     if( !fp ) {
1482         log_error("%s%s\n", pname, strerror(errno) );
1483         m_free(pname);
1484         return;
1485     }
1486
1487     md = md_open( 0, 0 );
1488     if( algo )
1489         md_enable( md, algo );
1490     else {
1491         md_enable( md, DIGEST_ALGO_MD5 );
1492         md_enable( md, DIGEST_ALGO_SHA1 );
1493         md_enable( md, DIGEST_ALGO_RMD160 );
1494         if( !check_digest_algo(DIGEST_ALGO_TIGER) )
1495             md_enable( md, DIGEST_ALGO_TIGER );
1496     }
1497
1498     while( (n=fread( buf, 1, DIM(buf), fp )) )
1499         md_write( md, buf, n );
1500     if( ferror(fp) )
1501         log_error("%s%s\n", pname, strerror(errno) );
1502     else {
1503         md_final(md);
1504         if( algo ) {
1505             if( fname )
1506                 fputs( pname, stdout );
1507             print_hex(md_read(md, algo), md_digest_length(algo) );
1508         }
1509         else {
1510             printf(  "%s   MD5 = ", fname?pname:"" );
1511                             print_hex(md_read(md, DIGEST_ALGO_MD5), 16 );
1512             printf("\n%s  SHA1 = ", fname?pname:""  );
1513                             print_hex(md_read(md, DIGEST_ALGO_SHA1), 20 );
1514             printf("\n%sRMD160 = ", fname?pname:""  );
1515                             print_hex(md_read(md, DIGEST_ALGO_RMD160), 20 );
1516             if( !check_digest_algo(DIGEST_ALGO_TIGER) ) {
1517                 printf("\n%s TIGER = ", fname?pname:""  );
1518                             print_hex(md_read(md, DIGEST_ALGO_TIGER), 24 );
1519             }
1520         }
1521         putchar('\n');
1522     }
1523     md_close(md);
1524
1525     if( fp != stdin )
1526         fclose(fp);
1527 }
1528
1529
1530 /****************
1531  * Check the supplied name,value string and add it to the notation
1532  * data to be used for signatures.
1533  */
1534 static void
1535 add_notation_data( const char *string )
1536 {
1537     const char *s;
1538     const char *s2;
1539     STRLIST sl;
1540     int critical=0;
1541     int highbit=0;
1542
1543     if( *string == '!' ) {
1544         critical = 1;
1545         string++;
1546     }
1547     s = string;
1548
1549     if( !*s || (*s & 0x80) || (!isalpha(*s) && *s != '_') ) {
1550         log_error(_("the first character of a notation name "
1551                     "must be a letter or an underscore\n") );
1552         return;
1553     }
1554     for(s++; *s != '='; s++ ) {
1555         if( !*s || (*s & 0x80) || (!isalnum(*s) && *s != '_' && *s != '.' ) ) {
1556             log_error(_("a notation name must have only letters, "
1557                         "digits, dots or underscores and end with an '='\n") );
1558             return;
1559         }
1560     }
1561     if( s[-1] == '.' || ((s2=strstr(string, "..")) && s2 < s ) ) {
1562         log_error(_("dots in a notation name must be surrounded "
1563                     "by other characters\n") );
1564         return;
1565     }
1566     /* we do only support printabe text - therefore we enforce the use
1567      * of only printable characters (an empty value is valid) */
1568     for( s++; *s ; s++ ) {
1569         if( iscntrl(*s) ) {
1570             log_error(_("a notation value must not use "
1571                         "any control characters\n") );
1572             return;
1573         }
1574         else if( *s & 0x80 )
1575             highbit = 1;
1576     }
1577
1578     if( highbit )   /* must use UTF8 encoding */
1579         sl = add_to_strlist2( &opt.notation_data, string, utf8_strings );
1580     else
1581         sl = add_to_strlist( &opt.notation_data, string );
1582
1583     if( critical )
1584         sl->flags |= 1;
1585 }
1586
1587
1588 static int
1589 check_policy_url( const char *s )
1590 {
1591     if( *s == '!' )
1592         s++;
1593     if( !*s )
1594         return -1;
1595     for(; *s ; s++ ) {
1596         if( (*s & 0x80) || iscntrl(*s) )
1597             return -1;
1598     }
1599     return 0;
1600 }
1601