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