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