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