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