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