Allow setting of the passphrase encoding of pkcs#12 files.
[gnupg.git] / sm / gpgsm.c
1 /* gpgsm.c - GnuPG for S/MIME 
2  * Copyright (C) 2001, 2002, 2003, 2004, 2005,
3  *               2006  Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
20  * USA.
21  */
22
23 #include <config.h>
24 #include <errno.h>
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <string.h>
28 #include <ctype.h>
29 #include <unistd.h>
30 #include <fcntl.h>
31 /*#include <mcheck.h>*/
32
33 #include "gpgsm.h"
34 #include <gcrypt.h>
35 #include <assuan.h> /* malloc hooks */
36
37 #include "../kbx/keybox.h" /* malloc hooks */
38 #include "i18n.h"
39 #include "keydb.h"
40 #include "sysutils.h"
41
42
43 #ifndef O_BINARY
44 #define O_BINARY 0
45 #endif
46
47 enum cmd_and_opt_values {
48   aNull = 0,
49   oArmor        = 'a',
50   aDetachedSign = 'b',
51   aSym          = 'c',
52   aDecrypt      = 'd',
53   aEncr         = 'e',
54   oInteractive  = 'i',
55   aListKeys     = 'k',
56   aListSecretKeys = 'K',
57   oDryRun       = 'n',
58   oOutput       = 'o',
59   oQuiet        = 'q',
60   oRecipient    = 'r',
61   aSign         = 's',
62   oTextmodeShort= 't',
63   oUser         = 'u',
64   oVerbose      = 'v',
65   oCompress     = 'z',
66   oNotation     = 'N',
67   oBatch        = 500,
68   aClearsign,
69   aStore,
70   aKeygen,
71   aSignEncr,
72   aSignKey,
73   aLSignKey,
74   aListPackets,
75   aEditKey,
76   aDeleteKey,
77   aImport,
78   aVerify,
79   aVerifyFiles,
80   aListExternalKeys,
81   aListChain,
82   aSendKeys,
83   aRecvKeys,
84   aExport,
85   aExportSecretKeyP12,
86   aCheckKeys, /* nyi */
87   aServer,                        
88   aLearnCard,
89   aCallDirmngr,
90   aCallProtectTool,
91   aPasswd,
92   aGPGConfList,
93   aGPGConfTest,
94   aDumpKeys,
95   aDumpChain,
96   aDumpSecretKeys,
97   aDumpExternalKeys,
98   aKeydbClearSomeCertFlags,
99
100   oOptions,
101   oDebug,
102   oDebugLevel,
103   oDebugAll,
104   oDebugNone,
105   oDebugWait,
106   oDebugAllowCoreDump,
107   oDebugNoChainValidation,
108   oDebugIgnoreExpiration,
109   oFixedPassphrase,
110   oLogFile,
111   oNoLogFile,
112
113   oEnableSpecialFilenames,
114
115   oAgentProgram,
116   oDisplay,
117   oTTYname,
118   oTTYtype,
119   oLCctype,
120   oLCmessages,
121
122   oPreferSystemDirmngr,
123   oDirmngrProgram,
124   oProtectToolProgram,
125   oFakedSystemTime,
126
127
128   oAssumeArmor,
129   oAssumeBase64,
130   oAssumeBinary,
131
132   oBase64,
133   oNoArmor,
134   oP12Charset,
135
136   oDisableCRLChecks,
137   oEnableCRLChecks,
138   oDisableTrustedCertCRLCheck,
139   oEnableTrustedCertCRLCheck,
140   oForceCRLRefresh,
141
142   oDisableOCSP,
143   oEnableOCSP,
144
145   oIncludeCerts,
146   oPolicyFile,
147   oDisablePolicyChecks,
148   oEnablePolicyChecks,
149   oAutoIssuerKeyRetrieve,
150   
151
152   oTextmode,
153   oFingerprint,
154   oWithFingerprint,
155   oWithMD5Fingerprint,
156   oAnswerYes,
157   oAnswerNo,
158   oKeyring,
159   oSecretKeyring,
160   oDefaultKey,
161   oDefRecipient,
162   oDefRecipientSelf,
163   oNoDefRecipient,
164   oStatusFD,
165   oNoComment,
166   oNoVersion,
167   oEmitVersion,
168   oCompletesNeeded,
169   oMarginalsNeeded,
170   oMaxCertDepth,
171   oLoadExtension,
172   oRFC1991,
173   oOpenPGP,
174   oCipherAlgo,
175   oDigestAlgo,
176   oCompressAlgo,
177   oCommandFD,
178   oNoVerbose,
179   oTrustDBName,
180   oNoSecmemWarn,
181   oNoDefKeyring,
182   oNoGreeting,
183   oNoTTY,
184   oNoOptions,
185   oNoBatch,
186   oHomedir,
187   oWithColons,
188   oWithKeyData,
189   oWithValidation,
190   oWithEphemeralKeys,
191   oSkipVerify,
192   oCompressKeys,
193   oCompressSigs,
194   oAlwaysTrust,
195   oRunAsShmCP,
196   oSetFilename,
197   oSetPolicyURL,
198   oUseEmbeddedFilename,
199   oComment,
200   oDefaultComment,
201   oThrowKeyid,
202   oForceV3Sigs,
203   oForceMDC,
204   oS2KMode,
205   oS2KDigest,
206   oS2KCipher,
207   oCharset,
208   oNotDashEscaped,
209   oEscapeFrom,
210   oLockOnce,
211   oLockMultiple,
212   oLockNever,
213   oKeyServer,
214   oEncryptTo,
215   oNoEncryptTo,
216   oLoggerFD,
217   oUtf8Strings,
218   oNoUtf8Strings,
219   oDisableCipherAlgo,
220   oDisablePubkeyAlgo,
221   oAllowNonSelfsignedUID,
222   oAllowFreeformUID,
223   oNoLiteral,
224   oSetFilesize,
225   oHonorHttpProxy,
226   oFastListMode,
227   oListOnly,
228   oIgnoreTimeConflict,
229   oNoRandomSeedFile,
230   oNoAutoKeyRetrieve,
231   oUseAgent,
232   oMergeOnly,
233   oTryAllSecrets,
234   oTrustedKey,
235   oEmuMDEncodeBug,
236   aDummy
237  };
238
239
240 static ARGPARSE_OPTS opts[] = {
241
242     { 300, NULL, 0, N_("@Commands:\n ") },
243
244     { aSign, "sign",      256, N_("|[FILE]|make a signature")},
245     { aClearsign, "clearsign", 256, N_("|[FILE]|make a clear text signature") },
246     { aDetachedSign, "detach-sign", 256, N_("make a detached signature")},
247     { aEncr, "encrypt",   256, N_("encrypt data")},
248     { aSym, "symmetric", 256, N_("encryption only with symmetric cipher")},
249     { aDecrypt, "decrypt",   256, N_("decrypt data (default)")},
250     { aVerify, "verify"   , 256, N_("verify a signature")},
251     { aVerifyFiles, "verify-files" , 256, "@" },
252     { aListKeys, "list-keys", 256, N_("list keys")},
253     { aListExternalKeys, "list-external-keys", 256, N_("list external keys")},
254     { aListSecretKeys, "list-secret-keys", 256, N_("list secret keys")},
255     { aListChain,   "list-chain",  256, N_("list certificate chain")}, 
256     { oFingerprint, "fingerprint", 256, N_("list keys and fingerprints")},
257     { aKeygen,     "gen-key",  256, "@" },
258     { aDeleteKey, "delete-key",256, N_("remove key from the public keyring")},
259     { aSendKeys, "send-keys"     , 256, N_("export keys to a key server") },
260     { aRecvKeys, "recv-keys"     , 256, N_("import keys from a key server") },
261     { aImport, "import",      256     , N_("import certificates")},
262     { aExport, "export",      256     , N_("export certificates")},
263     { aLearnCard, "learn-card", 256 ,N_("register a smartcard")},
264     { aServer, "server",      256, N_("run in server mode")},
265     { aCallDirmngr, "call-dirmngr", 256, N_("pass a command to the dirmngr")},
266     { aCallProtectTool, "call-protect-tool", 256,
267                                    N_("invoke gpg-protect-tool")},
268     { aPasswd, "passwd",      256, N_("change a passphrase")},
269     { aGPGConfList, "gpgconf-list", 256, "@" },
270     { aGPGConfTest, "gpgconf-test", 256, "@" },
271
272     { aDumpKeys, "dump-cert", 256, "@"},
273     { aDumpKeys, "dump-keys", 256, "@"},
274     { aDumpChain, "dump-chain", 256, "@"},
275     { aDumpExternalKeys, "dump-external-keys", 256, "@"},
276     { aDumpSecretKeys, "dump-secret-keys", 256, "@"},
277     { aKeydbClearSomeCertFlags, "keydb-clear-some-cert-flags", 256, "@"},
278
279     { 301, NULL, 0, N_("@\nOptions:\n ") },
280
281     { oArmor, "armor",     0, N_("create ascii armored output")},
282     { oArmor, "armour",    0, "@" },
283     { oBase64, "base64",    0, N_("create base-64 encoded output")},
284
285     { oP12Charset, "p12-charset", 2, "@" },
286     
287     { oAssumeArmor,  "assume-armor", 0, N_("assume input is in PEM format")},
288     { oAssumeBase64, "assume-base64", 0,
289                                       N_("assume input is in base-64 format")},
290     { oAssumeBinary, "assume-binary", 0,
291                                       N_("assume input is in binary format")},
292
293     { oRecipient, "recipient", 2, N_("|NAME|encrypt for NAME")},
294
295     { oPreferSystemDirmngr,"prefer-system-dirmngr", 0,
296       N_("use system's dirmngr if available")},
297     { oDisableCRLChecks, "disable-crl-checks", 0, N_("never consult a CRL")},
298     { oEnableCRLChecks, "enable-crl-checks", 0, "@"},
299     { oDisableTrustedCertCRLCheck, "disable-trusted-cert-crl-check", 0, "@"},
300     { oEnableTrustedCertCRLCheck, "enable-trusted-cert-crl-check", 0, "@"},
301     { oForceCRLRefresh, "force-crl-refresh", 0, "@"},
302
303     { oDisableOCSP, "disable-ocsp", 0, "@" },
304     { oEnableOCSP,  "enable-ocsp", 0, N_("check validity using OCSP")},
305
306     { oIncludeCerts, "include-certs", 1,
307                                  N_("|N|number of certificates to include") },
308
309     { oPolicyFile, "policy-file", 2,
310                     N_("|FILE|take policy information from FILE") },
311
312     { oDisablePolicyChecks, "disable-policy-checks", 0,
313                            N_("do not check certificate policies")},
314     { oEnablePolicyChecks, "enable-policy-checks", 0, "@"},
315
316     { oAutoIssuerKeyRetrieve, "auto-issuer-key-retrieve", 0, 
317       N_("fetch missing issuer certificates")},
318
319 #if 0
320     { oDefRecipient, "default-recipient" ,2,
321                                   N_("|NAME|use NAME as default recipient")},
322     { oDefRecipientSelf, "default-recipient-self" ,0,
323                                 N_("use the default key as default recipient")},
324     { oNoDefRecipient, "no-default-recipient", 0, "@" },
325 #endif
326     { oEncryptTo, "encrypt-to", 2, "@" },
327     { oNoEncryptTo, "no-encrypt-to", 0, "@" },
328
329     { oUser, "local-user",2, N_("use this user-id to sign or decrypt")},
330
331 #if 0
332     { oCompress, NULL,        1, N_("|N|set compress level N (0 disables)") },
333     { oTextmodeShort, NULL,   0, "@"},
334     { oTextmode, "textmode",  0, N_("use canonical text mode")},
335 #endif
336
337     { oOutput, "output",    2, N_("use as output file")},
338     { oVerbose, "verbose",   0, N_("verbose") },
339     { oQuiet,   "quiet",   0, N_("be somewhat more quiet") },
340     { oNoTTY, "no-tty", 0, N_("don't use the terminal at all") },
341     { oLogFile, "log-file"   ,2, N_("use a log file for the server")},
342     { oNoLogFile, "no-log-file" ,0, "@"},
343 #if 0
344     { oForceV3Sigs, "force-v3-sigs", 0, N_("force v3 signatures") },
345     { oForceMDC, "force-mdc", 0, N_("always use a MDC for encryption") },
346 #endif
347     { oDryRun, "dry-run",   0, N_("do not make any changes") },
348   /*{ oInteractive, "interactive", 0, N_("prompt before overwriting") }, */
349     /*{ oUseAgent, "use-agent",0, N_("use the gpg-agent")},*/
350     { oBatch, "batch",     0, N_("batch mode: never ask")},
351     { oAnswerYes, "yes",       0, N_("assume yes on most questions")},
352     { oAnswerNo,  "no",        0, N_("assume no on most questions")},
353
354     { oKeyring, "keyring"   ,2, N_("add this keyring to the list of keyrings")},
355     { oSecretKeyring, "secret-keyring" ,2, N_("add this secret keyring to the list")},
356     { oDefaultKey, "default-key" ,2, N_("|NAME|use NAME as default secret key")},
357     { oKeyServer, "keyserver",2, N_("|HOST|use this keyserver to lookup keys")},
358     { oCharset, "charset"   , 2, N_("|NAME|set terminal charset to NAME") },
359     { oOptions, "options"   , 2, N_("read options from file")},
360
361     { oDebug, "debug"     ,4|16, "@"},
362     { oDebugLevel, "debug-level" ,2, N_("|LEVEL|set the debugging level to LEVEL")},
363     { oDebugAll, "debug-all" ,0, "@"},
364     { oDebugNone, "debug-none" ,0, "@"},
365     { oDebugWait, "debug-wait" ,1, "@"},
366     { oDebugAllowCoreDump, "debug-allow-core-dump", 0, "@" },
367     { oDebugNoChainValidation, "debug-no-chain-validation", 0, "@"},
368     { oDebugIgnoreExpiration,  "debug-ignore-expiration", 0, "@"},
369     { oFixedPassphrase,        "fixed-passphrase", 2, "@"},
370     { oStatusFD, "status-fd" ,1, N_("|FD|write status info to this FD") },
371     { aDummy, "no-comment", 0,   "@"},
372     { aDummy, "completes-needed", 1, "@"},
373     { aDummy, "marginals-needed", 1, "@"},
374     { oMaxCertDepth,    "max-cert-depth", 1, "@" },
375     { aDummy, "trusted-key", 2, "@"},
376     { oLoadExtension, "load-extension" ,2,
377       N_("|FILE|load extension module FILE")},
378     { aDummy, "rfc1991",   0, "@"},
379     { aDummy, "openpgp",   0, "@"},
380     { aDummy, "s2k-mode",  1, "@"},
381     { aDummy, "s2k-digest-algo",2, "@"},
382     { aDummy, "s2k-cipher-algo",2, "@"},
383     { oCipherAlgo, "cipher-algo", 2 , N_("|NAME|use cipher algorithm NAME")},
384     { oDigestAlgo, "digest-algo", 2 ,
385       N_("|NAME|use message digest algorithm NAME")},
386 #if 0
387     { oCompressAlgo, "compress-algo", 1 , N_("|N|use compress algorithm N")},
388 #endif
389     { aDummy, "throw-keyid", 0, "@"},
390     { aDummy, "notation-data", 2, "@"},
391     { aExportSecretKeyP12, "export-secret-key-p12", 256, "@"}, 
392     
393
394     { 302, NULL, 0, N_(
395   "@\n(See the man page for a complete listing of all commands and options)\n"
396                       )},
397
398     { 303, NULL, 0, N_("@\nExamples:\n\n"
399     " -se -r Bob [file]          sign and encrypt for user Bob\n"
400     " --clearsign [file]         make a clear text signature\n"
401     " --detach-sign [file]       make a detached signature\n"
402     " --list-keys [names]        show keys\n"
403     " --fingerprint [names]      show fingerprints\n"  ) },
404
405   /* hidden options */
406     { oNoVerbose, "no-verbose", 0, "@"},
407
408     { oEnableSpecialFilenames, "enable-special-filenames", 0, "@" },
409
410
411     { oTrustDBName, "trustdb-name", 2, "@" },
412     { oNoSecmemWarn, "no-secmem-warning", 0, "@" }, 
413     { oNoArmor, "no-armor",   0, "@"},
414     { oNoArmor, "no-armour",   0, "@"},
415     { oNoDefKeyring, "no-default-keyring", 0, "@" },
416     { oNoGreeting, "no-greeting", 0, "@" },
417     { oNoOptions, "no-options", 0, "@" }, /* shortcut for --options /dev/null */
418     { oHomedir, "homedir", 2, "@" },   /* defaults to "~/.gnupg" */
419     { oAgentProgram, "agent-program", 2 , "@" },
420     { oDisplay,    "display",     2, "@" },
421     { oTTYname,    "ttyname",     2, "@" },
422     { oTTYtype,    "ttytype",     2, "@" },
423     { oLCctype,    "lc-ctype",    2, "@" },
424     { oLCmessages, "lc-messages", 2, "@" },
425     { oDirmngrProgram, "dirmngr-program", 2 , "@" },
426     { oProtectToolProgram, "protect-tool-program", 2 , "@" },
427     { oFakedSystemTime, "faked-system-time", 4, "@" }, /* (epoch time) */
428
429
430     { oNoBatch, "no-batch", 0, "@" },
431     { oWithColons, "with-colons", 0, "@"},
432     { oWithKeyData,"with-key-data", 0, "@"},
433     { oWithValidation, "with-validation", 0, "@"},
434     { oWithMD5Fingerprint, "with-md5-fingerprint", 0, "@"},
435     { oWithEphemeralKeys,  "with-ephemeral-keys", 0, "@"},
436     { aListKeys, "list-key", 256, "@" },  /* alias */
437     { aListChain, "list-sig", 256, "@" }, /* alias */
438     { aListChain, "list-sigs",256, "@" }, /* alias */
439     { aListChain, "check-sig",256, "@" }, /* alias */
440     { aListChain, "check-sigs",256, "@"}, /* alias */
441     { oSkipVerify, "skip-verify",0, "@" },
442     { oCompressKeys, "compress-keys",0, "@"},
443     { oCompressSigs, "compress-sigs",0, "@"},
444     { oAlwaysTrust, "always-trust", 0, "@"},
445     { oNoVersion, "no-version", 0, "@"},
446     { oLockOnce, "lock-once", 0, "@" },
447     { oLockMultiple, "lock-multiple", 0, "@" },
448     { oLockNever, "lock-never", 0, "@" },
449     { oLoggerFD, "logger-fd",1, "@" },
450     { oWithFingerprint, "with-fingerprint", 0, "@" },
451     { oDisableCipherAlgo,  "disable-cipher-algo", 2, "@" },
452     { oDisablePubkeyAlgo,  "disable-pubkey-algo", 2, "@" },
453     { oHonorHttpProxy,"honor-http-proxy", 0, "@" },
454     { oListOnly, "list-only", 0, "@"},
455     { oIgnoreTimeConflict, "ignore-time-conflict", 0, "@" },
456     { oNoRandomSeedFile,  "no-random-seed-file", 0, "@" },
457 {0} };
458
459
460
461 int gpgsm_errors_seen = 0;
462
463 /* It is possible that we are currentlu running under setuid permissions */
464 static int maybe_setuid = 1;
465
466 /* Helper to implement --debug-level and --debug*/
467 static const char *debug_level;
468 static unsigned int debug_value;
469
470 /* Option --enable-special-filenames */
471 static int allow_special_filenames;
472
473 /* Default value for include-certs. */
474 static int default_include_certs = 1; /* Only include the signer's cert. */
475
476
477
478 static char *build_list (const char *text,
479                          const char *(*mapf)(int), int (*chkf)(int));
480 static void set_cmd (enum cmd_and_opt_values *ret_cmd,
481                      enum cmd_and_opt_values new_cmd );
482
483 static void emergency_cleanup (void);
484 static int check_special_filename (const char *fname);
485 static int open_read (const char *filename);
486 static FILE *open_fwrite (const char *filename);
487 static estream_t open_es_fwrite (const char *filename);
488 static void run_protect_tool (int argc, char **argv);
489
490
491 static int
492 our_pk_test_algo (int algo)
493 {
494   return 1;
495 }
496
497 static int
498 our_cipher_test_algo (int algo)
499 {
500   return 1;
501 }
502
503 static int
504 our_md_test_algo (int algo)
505 {
506   return 1;
507 }
508
509 static const char *
510 my_strusage( int level )
511 {
512   static char *digests, *pubkeys, *ciphers;
513   const char *p;
514
515   switch (level)
516     {
517     case 11: p = "gpgsm (GnuPG)";
518       break;
519     case 13: p = VERSION; break;
520     case 17: p = PRINTABLE_OS_NAME; break;
521     case 19: p = _("Please report bugs to <" PACKAGE_BUGREPORT ">.\n");
522       break;
523     case 1:
524     case 40: p = _("Usage: gpgsm [options] [files] (-h for help)");
525       break;
526     case 41:
527       p = _("Syntax: gpgsm [options] [files]\n"
528             "sign, check, encrypt or decrypt using the S/MIME protocol\n"
529             "default operation depends on the input data\n");
530       break;
531
532     case 31: p = "\nHome: "; break;
533     case 32: p = opt.homedir; break;
534     case 33: p = _("\nSupported algorithms:\n"); break;
535     case 34:
536       if (!ciphers)
537         ciphers = build_list ("Cipher: ", gcry_cipher_algo_name,
538                               our_cipher_test_algo );
539       p = ciphers;
540       break;
541     case 35:
542       if (!pubkeys)
543         pubkeys = build_list ("Pubkey: ", gcry_pk_algo_name,
544                               our_pk_test_algo );
545       p = pubkeys;
546       break;
547     case 36:
548       if (!digests)
549         digests = build_list("Hash: ", gcry_md_algo_name, our_md_test_algo );
550       p = digests;
551       break;
552       
553     default: p = NULL; break;
554     }
555   return p;
556 }
557
558
559 static char *
560 build_list (const char *text, const char * (*mapf)(int), int (*chkf)(int))
561 {
562   int i;
563   size_t n=strlen(text)+2;
564   char *list, *p;
565   
566   if (maybe_setuid) {
567     gcry_control (GCRYCTL_DROP_PRIVS); /* drop setuid */
568   }
569
570   for (i=1; i < 110; i++ )
571     if (!chkf(i))
572       n += strlen(mapf(i)) + 2;
573   list = xmalloc (21 + n);
574   *list = 0;
575   for (p=NULL, i=1; i < 110; i++)
576     {
577       if (!chkf(i))
578         {
579           if( !p )
580             p = stpcpy (list, text );
581           else
582             p = stpcpy (p, ", ");
583           p = stpcpy (p, mapf(i) );
584         }
585     }
586   if (p)
587     p = stpcpy(p, "\n" );
588   return list;
589 }
590
591
592 /* Set the file pointer into binary mode if required.  */
593 static void
594 set_binary (FILE *fp)
595 {
596 #ifdef HAVE_DOSISH_SYSTEM
597   setmode (fileno (fp), O_BINARY);
598 #endif
599 }
600
601
602
603 static void
604 i18n_init(void)
605 {
606 #ifdef USE_SIMPLE_GETTEXT
607   set_gettext_file (PACKAGE_GT);
608 #else
609 # ifdef ENABLE_NLS
610   setlocale (LC_ALL, "" );
611   bindtextdomain (PACKAGE_GT, LOCALEDIR);
612   textdomain (PACKAGE_GT);
613 # endif
614 #endif
615 }
616
617
618 static void
619 wrong_args (const char *text)
620 {
621   fputs (_("usage: gpgsm [options] "), stderr);
622   fputs (text, stderr);
623   putc ('\n', stderr);
624   gpgsm_exit (2);
625 }
626
627
628 /* Setup the debugging.  With a DEBUG_LEVEL of NULL only the active
629    debug flags are propagated to the subsystems.  With DEBUG_LEVEL
630    set, a specific set of debug flags is set; and individual debugging
631    flags will be added on top.  */
632 static void
633 set_debug (void)
634 {
635   if (!debug_level)
636     ;
637   else if (!strcmp (debug_level, "none"))
638     opt.debug = 0;
639   else if (!strcmp (debug_level, "basic"))
640     opt.debug = DBG_ASSUAN_VALUE;
641   else if (!strcmp (debug_level, "advanced"))
642     opt.debug = DBG_ASSUAN_VALUE|DBG_X509_VALUE;
643   else if (!strcmp (debug_level, "expert"))
644     opt.debug = (DBG_ASSUAN_VALUE|DBG_X509_VALUE
645                  |DBG_CACHE_VALUE|DBG_CRYPTO_VALUE);
646   else if (!strcmp (debug_level, "guru"))
647     opt.debug = ~0;
648   else
649     {
650       log_error (_("invalid debug-level `%s' given\n"), debug_level);
651       gpgsm_exit(2);
652     }
653
654   opt.debug |= debug_value;
655
656   if (opt.debug && !opt.verbose)
657     opt.verbose = 1;
658   if (opt.debug)
659     opt.quiet = 0;
660
661   if (opt.debug & DBG_MPI_VALUE)
662     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 2);
663   if (opt.debug & DBG_CRYPTO_VALUE )
664     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1);
665   gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
666 }
667  
668
669
670 static void
671 set_cmd (enum cmd_and_opt_values *ret_cmd, enum cmd_and_opt_values new_cmd)
672 {
673   enum cmd_and_opt_values cmd = *ret_cmd;
674
675   if (!cmd || cmd == new_cmd)
676     cmd = new_cmd;
677   else if ( cmd == aSign && new_cmd == aEncr )
678     cmd = aSignEncr;
679   else if ( cmd == aEncr && new_cmd == aSign )
680     cmd = aSignEncr;
681   else if ( (cmd == aSign && new_cmd == aClearsign)
682             || (cmd == aClearsign && new_cmd == aSign) )
683     cmd = aClearsign;
684   else 
685     {
686       log_error(_("conflicting commands\n"));
687       gpgsm_exit(2);
688     }
689
690   *ret_cmd = cmd;
691 }
692
693
694 /* Helper to add recipients to a list. */
695 static void
696 do_add_recipient (ctrl_t ctrl, const char *name,
697                   certlist_t *recplist, int is_encrypt_to)
698 {
699   int rc = gpgsm_add_to_certlist (ctrl, name, 0, recplist, is_encrypt_to);
700   if (rc)
701     {
702       log_error (_("can't encrypt to `%s': %s\n"), name, gpg_strerror (rc));
703       gpgsm_status2 (ctrl, STATUS_INV_RECP,
704                      gpg_err_code (rc) == -1?                         "1":
705                      gpg_err_code (rc) == GPG_ERR_NO_PUBKEY?          "1":
706                      gpg_err_code (rc) == GPG_ERR_AMBIGUOUS_NAME?     "2":
707                      gpg_err_code (rc) == GPG_ERR_WRONG_KEY_USAGE?    "3":
708                      gpg_err_code (rc) == GPG_ERR_CERT_REVOKED?       "4":
709                      gpg_err_code (rc) == GPG_ERR_CERT_EXPIRED?       "5":
710                      gpg_err_code (rc) == GPG_ERR_NO_CRL_KNOWN?       "6":
711                      gpg_err_code (rc) == GPG_ERR_CRL_TOO_OLD?        "7":
712                      gpg_err_code (rc) == GPG_ERR_NO_POLICY_MATCH?    "8":
713                      "0",
714                      name, NULL);
715     }
716 }
717
718
719 int
720 main ( int argc, char **argv)
721 {
722   ARGPARSE_ARGS pargs;
723   int orig_argc;
724   char **orig_argv;
725   const char *fname;
726   /*  char *username;*/
727   int may_coredump;
728   strlist_t sl, remusr= NULL, locusr=NULL;
729   strlist_t nrings=NULL;
730   int detached_sig = 0;
731   FILE *configfp = NULL;
732   char *configname = NULL;
733   unsigned configlineno;
734   int parse_debug = 0;
735   int no_more_options = 0;
736   int default_config =1;
737   int default_keyring = 1;
738   char *logfile = NULL;
739   int greeting = 0;
740   int nogreeting = 0;
741   int debug_wait = 0;
742   int use_random_seed = 1;
743   int with_fpr = 0;
744   char *def_digest_string = NULL;
745   enum cmd_and_opt_values cmd = 0;
746   struct server_control_s ctrl;
747   certlist_t recplist = NULL;
748   certlist_t signerlist = NULL;
749   int do_not_setup_keys = 0;
750
751   /*mtrace();*/
752
753   /* trap_unaligned ();*/
754   set_strusage (my_strusage);
755   gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
756   /* We don't need any locking in libgcrypt unless we use any kind of
757      threading. */
758   gcry_control (GCRYCTL_DISABLE_INTERNAL_LOCKING);
759
760   /* Please note that we may running SUID(ROOT), so be very CAREFUL
761      when adding any stuff between here and the call to secmem_init()
762      somewhere after the option parsing */
763   log_set_prefix ("gpgsm", 1);
764
765   /* Try to auto set the character set.  */
766   set_native_charset (NULL); 
767
768   /* Check that the libraries are suitable.  Do it here because the
769      option parse may need services of the library */
770   if (!gcry_check_version (NEED_LIBGCRYPT_VERSION) )
771     {
772       log_fatal( _("libgcrypt is too old (need %s, have %s)\n"),
773                  NEED_LIBGCRYPT_VERSION, gcry_check_version (NULL) );
774     }
775   if (!ksba_check_version (NEED_KSBA_VERSION) )
776     {
777       log_fatal( _("libksba is too old (need %s, have %s)\n"),
778                  NEED_KSBA_VERSION, ksba_check_version (NULL) );
779     }
780
781
782   gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
783
784   may_coredump = disable_core_dumps ();
785   
786   gnupg_init_signals (0, emergency_cleanup);
787   
788   create_dotlock (NULL); /* register locking cleanup */
789   i18n_init();
790
791   opt.def_cipher_algoid = "3DES";  /*des-EDE3-CBC*/
792
793   opt.homedir = default_homedir ();
794 #ifdef HAVE_W32_SYSTEM
795   opt.no_crl_check = 1;
796 #endif
797
798   /* First check whether we have a config file on the commandline */
799   orig_argc = argc;
800   orig_argv = argv;
801   pargs.argc = &argc;
802   pargs.argv = &argv;
803   pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
804   while (arg_parse( &pargs, opts))
805     {
806       if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll)
807         parse_debug++;
808       else if (pargs.r_opt == oOptions)
809         { /* yes there is one, so we do not try the default one but
810              read the config file when it is encountered at the
811              commandline */
812           default_config = 0;
813         }
814       else if (pargs.r_opt == oNoOptions)
815         default_config = 0; /* --no-options */
816       else if (pargs.r_opt == oHomedir)
817         opt.homedir = pargs.r.ret_str;
818       else if (pargs.r_opt == aCallProtectTool)
819         break; /* This break makes sure that --version and --help are
820                   passed to the protect-tool. */
821     }
822   
823   
824   /* initialize the secure memory. */
825   gcry_control (GCRYCTL_INIT_SECMEM, 16384, 0);
826   maybe_setuid = 0;
827
828   /* 
829      Now we are now working under our real uid 
830   */
831
832   ksba_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free );
833
834   assuan_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
835   assuan_set_assuan_log_stream (log_get_stream ());
836   assuan_set_assuan_log_prefix (log_get_prefix (NULL));
837   assuan_set_assuan_err_source (GPG_ERR_SOURCE_DEFAULT);
838
839   keybox_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
840
841   /* Setup a default control structure for command line mode */
842   memset (&ctrl, 0, sizeof ctrl);
843   gpgsm_init_default_ctrl (&ctrl);
844   ctrl.no_server = 1;
845   ctrl.status_fd = -1; /* not status output */
846   ctrl.autodetect_encoding = 1;
847
848   /* Set the default option file */
849   if (default_config )
850     configname = make_filename (opt.homedir, "gpgsm.conf", NULL);
851   /* Set the default policy file */
852   opt.policy_file = make_filename (opt.homedir, "policies.txt", NULL);
853   
854   argc        = orig_argc;
855   argv        = orig_argv;
856   pargs.argc  = &argc;
857   pargs.argv  = &argv;
858   pargs.flags =  1;  /* do not remove the args */
859
860  next_pass:
861   if (configname) {
862     configlineno = 0;
863     configfp = fopen (configname, "r");
864     if (!configfp)
865       {
866         if (default_config)
867           {
868             if (parse_debug)
869               log_info (_("NOTE: no default option file `%s'\n"), configname);
870           }
871         else 
872           {
873             log_error (_("option file `%s': %s\n"), configname, strerror(errno));
874             gpgsm_exit(2);
875           }
876         xfree(configname);
877         configname = NULL;
878       }
879     if (parse_debug && configname)
880       log_info (_("reading options from `%s'\n"), configname);
881     default_config = 0;
882   }
883
884   while (!no_more_options 
885          && optfile_parse (configfp, configname, &configlineno, &pargs, opts))
886     {
887       switch (pargs.r_opt)
888         {
889         case aGPGConfList: 
890         case aGPGConfTest: 
891           set_cmd (&cmd, pargs.r_opt);
892           do_not_setup_keys = 1;
893           nogreeting = 1;
894           break;
895
896         case aServer: 
897           opt.batch = 1;
898           set_cmd (&cmd, aServer);
899           break;
900
901         case aCallDirmngr:
902           opt.batch = 1;
903           set_cmd (&cmd, aCallDirmngr);
904           do_not_setup_keys = 1;
905           break;
906
907         case aCallProtectTool:
908           opt.batch = 1;
909           set_cmd (&cmd, aCallProtectTool);
910           no_more_options = 1; /* Stop parsing. */
911           do_not_setup_keys = 1;
912           break;
913         
914         case aDeleteKey:
915           set_cmd (&cmd, aDeleteKey);
916           /*greeting=1;*/
917           do_not_setup_keys = 1;
918           break;
919
920         case aDetachedSign:
921           detached_sig = 1;
922           set_cmd (&cmd, aSign ); 
923           break;
924
925         case aKeygen:
926           set_cmd (&cmd, aKeygen);
927           greeting=1; 
928           do_not_setup_keys = 1;
929           break;
930
931         case aCheckKeys:
932         case aImport: 
933         case aSendKeys: 
934         case aRecvKeys: 
935         case aExport: 
936         case aExportSecretKeyP12: 
937         case aDumpKeys:
938         case aDumpChain:
939         case aDumpExternalKeys: 
940         case aDumpSecretKeys: 
941         case aListKeys:
942         case aListExternalKeys: 
943         case aListSecretKeys: 
944         case aListChain: 
945         case aLearnCard: 
946         case aPasswd: 
947         case aKeydbClearSomeCertFlags:
948           do_not_setup_keys = 1;
949           set_cmd (&cmd, pargs.r_opt);
950           break;
951
952         case aSym:
953         case aDecrypt: 
954         case aEncr: 
955         case aSign: 
956         case aClearsign: 
957         case aVerify: 
958           set_cmd (&cmd, pargs.r_opt);
959           break;
960
961           /* Output encoding selection.  */
962         case oArmor:
963           ctrl.create_pem = 1;
964           break;
965         case oBase64: 
966           ctrl.create_pem = 0;
967           ctrl.create_base64 = 1;
968           break;
969         case oNoArmor: 
970           ctrl.create_pem = 0;
971           ctrl.create_base64 = 0;
972           break;
973           
974         case oP12Charset:
975           opt.p12_charset = pargs.r.ret_str;
976           break;
977
978           /* Input encoding selection.  */
979         case oAssumeArmor:
980           ctrl.autodetect_encoding = 0;
981           ctrl.is_pem = 1;
982           ctrl.is_base64 = 0;
983           break;
984         case oAssumeBase64:
985           ctrl.autodetect_encoding = 0;
986           ctrl.is_pem = 0;
987           ctrl.is_base64 = 1;
988           break;
989         case oAssumeBinary:
990           ctrl.autodetect_encoding = 0;
991           ctrl.is_pem = 0;
992           ctrl.is_base64 = 0;
993           break;
994
995         case oDisableCRLChecks:
996           opt.no_crl_check = 1;
997           break;
998         case oEnableCRLChecks:
999           opt.no_crl_check = 0;
1000           break;
1001         case oDisableTrustedCertCRLCheck:
1002           opt.no_trusted_cert_crl_check = 1;
1003           break;
1004         case oEnableTrustedCertCRLCheck:
1005           opt.no_trusted_cert_crl_check = 0;
1006           break;
1007         case oForceCRLRefresh:
1008           opt.force_crl_refresh = 1;
1009           break;
1010
1011         case oDisableOCSP:
1012           ctrl.use_ocsp = opt.enable_ocsp = 0;
1013           break;
1014         case oEnableOCSP:
1015           ctrl.use_ocsp = opt.enable_ocsp = 1;
1016           break;
1017
1018         case oIncludeCerts: 
1019           ctrl.include_certs = default_include_certs = pargs.r.ret_int; 
1020           break;
1021
1022         case oPolicyFile:
1023           xfree (opt.policy_file);
1024           if (*pargs.r.ret_str)
1025             opt.policy_file = xstrdup (pargs.r.ret_str);
1026           else
1027             opt.policy_file = NULL;
1028           break;
1029
1030         case oDisablePolicyChecks:
1031           opt.no_policy_check = 1;
1032           break;
1033         case oEnablePolicyChecks:
1034           opt.no_policy_check = 0;
1035           break;
1036           
1037         case oAutoIssuerKeyRetrieve:
1038           opt.auto_issuer_key_retrieve = 1;
1039           break;
1040
1041         case oOutput: opt.outfile = pargs.r.ret_str; break;
1042
1043         
1044         case oQuiet: opt.quiet = 1; break;
1045         case oNoTTY: /* fixme:tty_no_terminal(1);*/ break;
1046         case oDryRun: opt.dry_run = 1; break;
1047
1048         case oVerbose:
1049           opt.verbose++;
1050           gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
1051           break;
1052         case oNoVerbose:
1053           opt.verbose = 0;
1054           gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
1055           break;
1056
1057         case oLogFile: logfile = pargs.r.ret_str; break;
1058         case oNoLogFile: logfile = NULL; break;          
1059
1060         case oBatch: 
1061           opt.batch = 1;
1062           greeting = 0;
1063           break;
1064         case oNoBatch: opt.batch = 0; break;
1065           
1066         case oAnswerYes: opt.answer_yes = 1; break;
1067         case oAnswerNo: opt.answer_no = 1; break;
1068
1069         case oKeyring: append_to_strlist (&nrings, pargs.r.ret_str); break;
1070
1071         case oDebug: debug_value |= pargs.r.ret_ulong; break;
1072         case oDebugAll: debug_value = ~0; break;
1073         case oDebugNone: debug_value = 0; break;
1074         case oDebugLevel: debug_level = pargs.r.ret_str; break;
1075         case oDebugWait: debug_wait = pargs.r.ret_int; break;
1076         case oDebugAllowCoreDump:
1077           may_coredump = enable_core_dumps ();
1078           break;
1079         case oDebugNoChainValidation: opt.no_chain_validation = 1; break;
1080         case oDebugIgnoreExpiration: opt.ignore_expiration = 1; break;
1081         case oFixedPassphrase: opt.fixed_passphrase = pargs.r.ret_str; break;
1082
1083         case oStatusFD: ctrl.status_fd = pargs.r.ret_int; break;
1084         case oLoggerFD: log_set_fd (pargs.r.ret_int ); break;
1085         case oWithMD5Fingerprint:
1086           opt.with_md5_fingerprint=1; /*fall thru*/
1087         case oWithFingerprint:
1088           with_fpr=1; /*fall thru*/
1089         case oFingerprint:
1090           opt.fingerprint++;
1091           break;
1092
1093         case oOptions:
1094           /* config files may not be nested (silently ignore them) */
1095           if (!configfp)
1096             {
1097               xfree(configname);
1098               configname = xstrdup (pargs.r.ret_str);
1099               goto next_pass;
1100             }
1101           break;
1102         case oNoOptions: break; /* no-options */
1103         case oHomedir: opt.homedir = pargs.r.ret_str; break;
1104         case oAgentProgram: opt.agent_program = pargs.r.ret_str;  break;
1105         case oDisplay: opt.display = xstrdup (pargs.r.ret_str); break;
1106         case oTTYname: opt.ttyname = xstrdup (pargs.r.ret_str); break;
1107         case oTTYtype: opt.ttytype = xstrdup (pargs.r.ret_str); break;
1108         case oLCctype: opt.lc_ctype = xstrdup (pargs.r.ret_str); break;
1109         case oLCmessages: opt.lc_messages = xstrdup (pargs.r.ret_str); break;
1110         case oDirmngrProgram: opt.dirmngr_program = pargs.r.ret_str;  break;
1111         case oPreferSystemDirmngr: opt.prefer_system_dirmngr = 1; break;
1112         case oProtectToolProgram:
1113           opt.protect_tool_program = pargs.r.ret_str; 
1114           break;
1115           
1116         case oFakedSystemTime:
1117           gnupg_set_time ( (time_t)pargs.r.ret_ulong, 0);
1118           break;
1119
1120         case oNoDefKeyring: default_keyring = 0; break;
1121         case oNoGreeting: nogreeting = 1; break;
1122
1123         case oDefaultKey:
1124           /* fixme:opt.def_secret_key = pargs.r.ret_str;*/
1125           log_info ("WARNING: --default-key has not yet been implemented\n");
1126           break;
1127         case oDefRecipient:
1128           if (*pargs.r.ret_str)
1129             opt.def_recipient = xstrdup (pargs.r.ret_str);
1130           break;
1131         case oDefRecipientSelf:
1132           xfree (opt.def_recipient);
1133           opt.def_recipient = NULL;
1134           opt.def_recipient_self = 1;
1135           break;
1136         case oNoDefRecipient:
1137           xfree (opt.def_recipient);
1138           opt.def_recipient = NULL;
1139           opt.def_recipient_self = 0;
1140           break;
1141
1142         case oWithKeyData: opt.with_key_data=1; /* fall thru */
1143         case oWithColons: ctrl.with_colons = 1; break;
1144         case oWithValidation: ctrl.with_validation=1; break;
1145         case oWithEphemeralKeys: opt.with_ephemeral_keys=1; break;
1146
1147         case oSkipVerify: opt.skip_verify=1; break;
1148
1149         case oNoEncryptTo: opt.no_encrypt_to = 1; break;
1150         case oEncryptTo: /* Store the recipient in the second list */
1151           sl = add_to_strlist (&remusr, pargs.r.ret_str);
1152           sl->flags = 1;
1153           break;
1154
1155         case oRecipient: /* store the recipient */
1156           add_to_strlist ( &remusr, pargs.r.ret_str);
1157           break;
1158
1159         case oTextmodeShort: /*fixme:opt.textmode = 2;*/ break;
1160         case oTextmode: /*fixme:opt.textmode=1;*/  break;
1161
1162         case oUser: /* store the local users, the first one is the default */
1163           if (!opt.local_user)
1164             opt.local_user = pargs.r.ret_str;
1165           add_to_strlist (&locusr, pargs.r.ret_str);
1166           break;
1167
1168         case oNoSecmemWarn:
1169           gcry_control (GCRYCTL_DISABLE_SECMEM_WARN); 
1170           break;
1171
1172         case oCipherAlgo:
1173           opt.def_cipher_algoid = pargs.r.ret_str;
1174           break;
1175
1176         case oDisableCipherAlgo: 
1177           {
1178             int algo = gcry_cipher_map_name (pargs.r.ret_str);
1179             gcry_cipher_ctl (NULL, GCRYCTL_DISABLE_ALGO, &algo, sizeof algo);
1180           }
1181           break;
1182         case oDisablePubkeyAlgo: 
1183           {
1184             int algo = gcry_pk_map_name (pargs.r.ret_str);
1185             gcry_pk_ctl (GCRYCTL_DISABLE_ALGO,&algo, sizeof algo );
1186           }
1187           break;
1188
1189         case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
1190         case oNoRandomSeedFile: use_random_seed = 0; break;
1191
1192         case oEnableSpecialFilenames: allow_special_filenames =1; break;
1193           
1194
1195         case aDummy:
1196           break;
1197         default: 
1198           pargs.err = configfp? 1:2; 
1199           break;
1200         }
1201     }
1202
1203   if (configfp)
1204     {
1205       fclose (configfp);
1206       configfp = NULL;
1207       /* Keep a copy of the config filename. */
1208       opt.config_filename = configname;
1209       configname = NULL;
1210       goto next_pass;
1211     }
1212   xfree (configname);
1213   configname = NULL;
1214
1215   if (!opt.config_filename)
1216     opt.config_filename = make_filename (opt.homedir, "gpgsm.conf", NULL);
1217
1218   if (log_get_errorcount(0))
1219     gpgsm_exit(2);
1220   
1221   if (nogreeting)
1222     greeting = 0;
1223   
1224   if (greeting)
1225     {
1226       fprintf(stderr, "%s %s; %s\n",
1227               strusage(11), strusage(13), strusage(14) );
1228       fprintf(stderr, "%s\n", strusage(15) );
1229     }
1230 #  ifdef IS_DEVELOPMENT_VERSION
1231   if (!opt.batch)
1232     {
1233       log_info ("NOTE: THIS IS A DEVELOPMENT VERSION!\n");
1234       log_info ("It is only intended for test purposes and should NOT be\n");
1235       log_info ("used in a production environment or with production keys!\n");
1236     }
1237 #  endif
1238
1239   if (may_coredump && !opt.quiet)
1240     log_info (_("WARNING: program may create a core file!\n"));
1241
1242 /*   if (opt.qualsig_approval && !opt.quiet) */
1243 /*     log_info (_("This software has offically been approved to " */
1244 /*                 "create and verify\n" */
1245 /*                 "qualified signatures according to German law.\n")); */
1246
1247   if (logfile && cmd == aServer)
1248     {
1249       log_set_file (logfile);
1250       log_set_prefix (NULL, 1|2|4);
1251     }
1252
1253   if (gnupg_faked_time_p ())
1254     {
1255       gnupg_isotime_t tbuf;
1256
1257       log_info (_("WARNING: running with faked system time: "));
1258       gnupg_get_isotime (tbuf);
1259       gpgsm_dump_time (tbuf);
1260       log_printf ("\n");
1261     }
1262   
1263 /*FIXME    if (opt.batch) */
1264 /*      tty_batchmode (1); */
1265
1266   gcry_control (GCRYCTL_RESUME_SECMEM_WARN);
1267
1268   set_debug ();
1269
1270   /* Although we alwasy use gpgsm_exit, we better install a regualr
1271      exit handler so that at least the secure memory gets wiped
1272      out. */
1273   if (atexit (emergency_cleanup))
1274     {
1275       log_error ("atexit failed\n");
1276       gpgsm_exit (2);
1277     }
1278
1279   /* Must do this after dropping setuid, because the mapping functions
1280      may try to load an module and we may have disabled an algorithm.
1281      We remap the commonly used algorithms to the OIDs for
1282      convenience.  We need to work with the OIDs because they are used
1283      to check whether the encryption mode is actually available. */
1284   if (!strcmp (opt.def_cipher_algoid, "3DES") )
1285     opt.def_cipher_algoid = "1.2.840.113549.3.7";
1286   else if (!strcmp (opt.def_cipher_algoid, "AES")
1287            || !strcmp (opt.def_cipher_algoid, "AES128"))
1288     opt.def_cipher_algoid = "2.16.840.1.101.3.4.1.2";
1289   else if (!strcmp (opt.def_cipher_algoid, "AES256") )
1290     opt.def_cipher_algoid = "2.16.840.1.101.3.4.1.42";
1291
1292   if (cmd != aGPGConfList)
1293     {
1294       if ( !gcry_cipher_map_name (opt.def_cipher_algoid)
1295            || !gcry_cipher_mode_from_oid (opt.def_cipher_algoid))
1296         log_error (_("selected cipher algorithm is invalid\n"));
1297
1298       if (def_digest_string)
1299         {
1300           opt.def_digest_algo = gcry_md_map_name (def_digest_string);
1301           xfree (def_digest_string);
1302           def_digest_string = NULL;
1303           if (our_md_test_algo(opt.def_digest_algo) )
1304             log_error (_("selected digest algorithm is invalid\n"));
1305         }
1306     }
1307
1308   if (log_get_errorcount(0))
1309     gpgsm_exit(2);
1310   
1311   /* Set the random seed file. */
1312   if (use_random_seed) {
1313     char *p = make_filename (opt.homedir, "random_seed", NULL);
1314     gcry_control (GCRYCTL_SET_RANDOM_SEED_FILE, p);
1315     xfree(p);
1316   }
1317
1318
1319   if (!cmd && opt.fingerprint && !with_fpr)
1320     set_cmd (&cmd, aListKeys);
1321   
1322   if (!nrings && default_keyring)  /* Add default keybox. */
1323     {
1324       int created;
1325
1326       keydb_add_resource ("pubring.kbx", 0, 0, &created);
1327       if (created)
1328         {
1329           /* Import the standard certificates for a new default keybox. */
1330           char *filelist[2];
1331           
1332           filelist[0] = make_filename (GNUPG_DATADIR, "com-certs.pem", NULL);
1333           filelist[1] = NULL;
1334           if (!access (filelist[0], F_OK))
1335             {
1336               log_info (_("importing common certificates `%s'\n"),
1337                         filelist[0]);
1338               gpgsm_import_files (&ctrl, 1, filelist, open_read);
1339             }
1340           xfree (filelist[0]);
1341         }
1342     }
1343   for (sl = nrings; sl; sl = sl->next)
1344     keydb_add_resource (sl->d, 0, 0, NULL);
1345   FREE_STRLIST(nrings);
1346
1347   if (!do_not_setup_keys)
1348     {
1349       for (sl = locusr; sl ; sl = sl->next)
1350         {
1351           int rc = gpgsm_add_to_certlist (&ctrl, sl->d, 1, &signerlist, 0);
1352           if (rc)
1353             {
1354               log_error (_("can't sign using `%s': %s\n"),
1355                          sl->d, gpg_strerror (rc));
1356               gpgsm_status2 (&ctrl, STATUS_INV_RECP,
1357                          gpg_err_code (rc) == -1?                      "1":
1358                          gpg_err_code (rc) == GPG_ERR_NO_PUBKEY?       "1":
1359                          gpg_err_code (rc) == GPG_ERR_AMBIGUOUS_NAME?  "2":
1360                          gpg_err_code (rc) == GPG_ERR_WRONG_KEY_USAGE? "3":
1361                          gpg_err_code (rc) == GPG_ERR_CERT_REVOKED?    "4":
1362                          gpg_err_code (rc) == GPG_ERR_CERT_EXPIRED?    "5":
1363                          gpg_err_code (rc) == GPG_ERR_NO_CRL_KNOWN?    "6":
1364                          gpg_err_code (rc) == GPG_ERR_CRL_TOO_OLD?     "7":
1365                          gpg_err_code (rc) == GPG_ERR_NO_POLICY_MATCH? "8":
1366                          gpg_err_code (rc) == GPG_ERR_NO_SECKEY?       "9":
1367                          "0",
1368                          sl->d, NULL);
1369             }
1370         }
1371       
1372       /* Build the recipient list.  We first add the regular ones and then
1373          the encrypt-to ones because the underlying function will silenty
1374          ignore duplicates and we can't allow to keep a duplicate which is
1375          flagged as encrypt-to as the actually encrypt function would then
1376          complain about no (regular) recipients. */
1377       for (sl = remusr; sl; sl = sl->next)
1378         if (!(sl->flags & 1))
1379           do_add_recipient (&ctrl, sl->d, &recplist, 0);
1380       if (!opt.no_encrypt_to)
1381         {
1382           for (sl = remusr; sl; sl = sl->next)
1383             if ((sl->flags & 1))
1384               do_add_recipient (&ctrl, sl->d, &recplist, 1);
1385         }
1386     }
1387
1388   if (log_get_errorcount(0))
1389     gpgsm_exit(1); /* must stop for invalid recipients */
1390   
1391   fname = argc? *argv : NULL;
1392   
1393   switch (cmd)
1394     {
1395     case aGPGConfList: 
1396       { /* List options and default values in the GPG Conf format.  */
1397
1398         /* The following list is taken from gnupg/tools/gpgconf-comp.c.  */
1399         /* Option flags.  YOU MUST NOT CHANGE THE NUMBERS OF THE EXISTING
1400            FLAGS, AS THEY ARE PART OF THE EXTERNAL INTERFACE.  */
1401 #define GC_OPT_FLAG_NONE        0UL
1402         /* The RUNTIME flag for an option indicates that the option can be
1403            changed at runtime.  */
1404 #define GC_OPT_FLAG_RUNTIME     (1UL << 3)
1405         /* The DEFAULT flag for an option indicates that the option has a
1406            default value.  */
1407 #define GC_OPT_FLAG_DEFAULT     (1UL << 4)
1408         /* The DEF_DESC flag for an option indicates that the option has a
1409            default, which is described by the value of the default field.  */
1410 #define GC_OPT_FLAG_DEF_DESC    (1UL << 5)
1411         /* The NO_ARG_DESC flag for an option indicates that the argument has
1412            a default, which is described by the value of the ARGDEF field.  */
1413 #define GC_OPT_FLAG_NO_ARG_DESC (1UL << 6)
1414
1415         printf ("gpgconf-gpgsm.conf:%lu:\"%s\n",
1416                 GC_OPT_FLAG_DEFAULT, opt.config_filename);
1417         
1418         printf ("verbose:%lu:\n"
1419                 "quiet:%lu:\n"
1420                 "debug-level:%lu:\"none:\n"
1421                 "log-file:%lu:\n",
1422                 GC_OPT_FLAG_NONE,
1423                 GC_OPT_FLAG_NONE,
1424                 GC_OPT_FLAG_DEFAULT,
1425                 GC_OPT_FLAG_NONE );
1426         printf ("disable-crl-checks:%lu:\n",
1427                 GC_OPT_FLAG_NONE );
1428         printf ("disable-trusted-cert-crl-check:%lu:\n",
1429                 GC_OPT_FLAG_NONE );
1430         printf ("enable-ocsp:%lu:\n",
1431                 GC_OPT_FLAG_NONE );
1432         printf ("include-certs:%lu:1:\n",
1433                 GC_OPT_FLAG_DEFAULT );
1434         printf ("disable-policy-checks:%lu:\n",
1435                 GC_OPT_FLAG_NONE );
1436         printf ("auto-issuer-key-retrieve:%lu:\n",
1437                 GC_OPT_FLAG_NONE );
1438         printf ("prefer-system-dirmngr:%lu:\n",
1439                 GC_OPT_FLAG_NONE );
1440         printf ("cipher-algo:%lu:\"3DES:\n",
1441                 GC_OPT_FLAG_DEFAULT );
1442
1443       }
1444       break;
1445     case aGPGConfTest:
1446       /* This is merely a dummy command to test whether the
1447          configuration file is valid.  */
1448       break;
1449
1450     case aServer:
1451       if (debug_wait)
1452         {
1453           log_debug ("waiting for debugger - my pid is %u .....\n",
1454                      (unsigned int)getpid());
1455           sleep (debug_wait);
1456           log_debug ("... okay\n");
1457          }
1458       gpgsm_server (recplist);
1459       break;
1460
1461     case aCallDirmngr:
1462       if (!argc)
1463         wrong_args ("--call-dirmngr <command> {args}");
1464       else
1465         if (gpgsm_dirmngr_run_command (&ctrl, *argv, argc-1, argv+1))
1466           gpgsm_exit (1);
1467       break;
1468
1469     case aCallProtectTool:
1470       run_protect_tool (argc, argv);
1471       break;
1472
1473     case aEncr: /* Encrypt the given file. */
1474       {
1475         FILE *fp = open_fwrite (opt.outfile?opt.outfile:"-");
1476
1477         set_binary (stdin);
1478
1479         if (!argc) /* Source is stdin. */
1480           gpgsm_encrypt (&ctrl, recplist, 0, fp); 
1481         else if (argc == 1)  /* Source is the given file. */
1482           gpgsm_encrypt (&ctrl, recplist, open_read (*argv), fp);
1483         else
1484           wrong_args ("--encrypt [datafile]");
1485
1486         if (fp != stdout)
1487           fclose (fp);
1488       }
1489       break;
1490
1491     case aSign: /* Sign the given file. */
1492       {
1493         FILE *fp = open_fwrite (opt.outfile?opt.outfile:"-");
1494
1495         /* Fixme: We should also allow to concatenate multiple files for
1496            signing because that is what gpg does.*/
1497         set_binary (stdin);
1498         if (!argc) /* Create from stdin. */
1499           gpgsm_sign (&ctrl, signerlist, 0, detached_sig, fp); 
1500         else if (argc == 1) /* From file. */
1501           gpgsm_sign (&ctrl, signerlist,
1502                       open_read (*argv), detached_sig, fp); 
1503         else
1504           wrong_args ("--sign [datafile]");
1505
1506         if (fp != stdout)
1507           fclose (fp);
1508       }
1509       break;
1510         
1511     case aSignEncr: /* sign and encrypt the given file */
1512       log_error ("this command has not yet been implemented\n");
1513       break;
1514
1515     case aClearsign: /* make a clearsig */
1516       log_error ("this command has not yet been implemented\n");
1517       break;
1518
1519     case aVerify:
1520       {
1521         FILE *fp = NULL;
1522
1523         set_binary (stdin);
1524         if (argc == 2 && opt.outfile)
1525           log_info ("option --output ignored for a detached signature\n");
1526         else if (opt.outfile)
1527           fp = open_fwrite (opt.outfile);
1528
1529         if (!argc)
1530           gpgsm_verify (&ctrl, 0, -1, fp); /* normal signature from stdin */
1531         else if (argc == 1)
1532           gpgsm_verify (&ctrl, open_read (*argv), -1, fp); /* std signature */
1533         else if (argc == 2) /* detached signature (sig, detached) */
1534           gpgsm_verify (&ctrl, open_read (*argv), open_read (argv[1]), NULL); 
1535         else
1536           wrong_args ("--verify [signature [detached_data]]");
1537
1538         if (fp && fp != stdout)
1539           fclose (fp);
1540       }
1541       break;
1542
1543     case aVerifyFiles:
1544       log_error (_("this command has not yet been implemented\n"));
1545       break;
1546
1547     case aDecrypt:
1548       {
1549         FILE *fp = open_fwrite (opt.outfile?opt.outfile:"-");
1550
1551         set_binary (stdin);
1552         if (!argc)
1553           gpgsm_decrypt (&ctrl, 0, fp); /* from stdin */
1554         else if (argc == 1)
1555           gpgsm_decrypt (&ctrl, open_read (*argv), fp); /* from file */
1556         else
1557           wrong_args ("--decrypt [filename]");
1558         if (fp != stdout)
1559           fclose (fp);
1560       }
1561       break;
1562
1563     case aDeleteKey:
1564       for (sl=NULL; argc; argc--, argv++)
1565         add_to_strlist (&sl, *argv);
1566       gpgsm_delete (&ctrl, sl);
1567       free_strlist(sl);
1568       break;
1569
1570     case aListChain:
1571     case aDumpChain:
1572        ctrl.with_chain = 1;
1573     case aListKeys:
1574     case aDumpKeys:
1575     case aListExternalKeys:
1576     case aDumpExternalKeys:
1577     case aListSecretKeys:
1578     case aDumpSecretKeys:
1579       {
1580         unsigned int mode;
1581         estream_t fp;
1582
1583         switch (cmd)
1584           {
1585           case aListChain:
1586           case aListKeys:         mode = (0   | 0 | (1<<6)); break;
1587           case aDumpChain: 
1588           case aDumpKeys:         mode = (256 | 0 | (1<<6)); break;
1589           case aListExternalKeys: mode = (0   | 0 | (1<<7)); break;
1590           case aDumpExternalKeys: mode = (256 | 0 | (1<<7)); break;
1591           case aListSecretKeys:   mode = (0   | 2 | (1<<6)); break;
1592           case aDumpSecretKeys:   mode = (256 | 2 | (1<<6)); break;
1593           default: BUG();
1594           }
1595
1596         fp = open_es_fwrite (opt.outfile?opt.outfile:"-");
1597         for (sl=NULL; argc; argc--, argv++)
1598           add_to_strlist (&sl, *argv);
1599         gpgsm_list_keys (&ctrl, sl, fp, mode);
1600         free_strlist(sl);
1601         es_fclose (fp);
1602       }
1603       break;
1604
1605
1606     case aKeygen: /* Generate a key; well kind of. */
1607       log_error 
1608         (_("key generation is not available from the commandline\n"));
1609       log_info (_("please use the script \"%s\" to generate a new key\n"),
1610                 "gpgsm-gencert.sh");
1611       break;
1612
1613     case aImport:
1614       gpgsm_import_files (&ctrl, argc, argv, open_read);
1615       break;
1616
1617     case aExport:
1618       {
1619         FILE *fp = open_fwrite (opt.outfile?opt.outfile:"-");
1620
1621         for (sl=NULL; argc; argc--, argv++)
1622           add_to_strlist (&sl, *argv);
1623         gpgsm_export (&ctrl, sl, fp, NULL);
1624         free_strlist(sl);
1625         if (fp != stdout)
1626           fclose (fp);
1627       }
1628       break;
1629
1630     case aExportSecretKeyP12:
1631       {
1632         FILE *fp = open_fwrite (opt.outfile?opt.outfile:"-");
1633
1634         if (argc == 1)
1635           gpgsm_p12_export (&ctrl, *argv, stdout);
1636         else
1637           wrong_args ("--export-secret-key-p12 KEY-ID");
1638         if (fp != stdout)
1639           fclose (fp);
1640       }
1641       break;
1642       
1643     case aSendKeys:
1644     case aRecvKeys:
1645       log_error ("this command has not yet been implemented\n");
1646       break;
1647
1648
1649     case aLearnCard:
1650       if (argc)
1651         wrong_args ("--learn-card");
1652       else
1653         {
1654           int rc = gpgsm_agent_learn (&ctrl);
1655           if (rc)
1656             log_error ("error learning card: %s\n", gpg_strerror (rc));
1657         }
1658       break;
1659
1660     case aPasswd:
1661       if (argc != 1)
1662         wrong_args ("--passwd <key-Id>");
1663       else
1664         {
1665           int rc;
1666           ksba_cert_t cert = NULL;
1667           char *grip = NULL;
1668
1669           rc = gpgsm_find_cert (*argv, NULL, &cert);
1670           if (rc)
1671             ;
1672           else if (!(grip = gpgsm_get_keygrip_hexstring (cert)))
1673             rc = gpg_error (GPG_ERR_BUG);
1674           else 
1675             {
1676               char *desc = gpgsm_format_keydesc (cert);
1677               rc = gpgsm_agent_passwd (&ctrl, grip, desc);
1678               xfree (desc);
1679             }
1680           if (rc)
1681             log_error ("error changing passphrase: %s\n", gpg_strerror (rc));
1682           xfree (grip);
1683           ksba_cert_release (cert);
1684         }
1685       break;
1686
1687     case aKeydbClearSomeCertFlags:
1688       for (sl=NULL; argc; argc--, argv++)
1689         add_to_strlist (&sl, *argv);
1690       keydb_clear_some_cert_flags (&ctrl, sl);
1691       free_strlist(sl);
1692       break;
1693
1694
1695     default:
1696         log_error ("invalid command (there is no implicit command)\n");
1697         break;
1698     }
1699   
1700   /* cleanup */
1701   gpgsm_release_certlist (recplist);
1702   gpgsm_release_certlist (signerlist);
1703   FREE_STRLIST (remusr);
1704   FREE_STRLIST (locusr);
1705   gpgsm_exit(0);
1706   return 8; /*NOTREACHED*/
1707 }
1708
1709 /* Note: This function is used by signal handlers!. */
1710 static void
1711 emergency_cleanup (void)
1712 {
1713   gcry_control (GCRYCTL_TERM_SECMEM );
1714 }
1715
1716
1717 void
1718 gpgsm_exit (int rc)
1719 {
1720   gcry_control (GCRYCTL_UPDATE_RANDOM_SEED_FILE);
1721   if (opt.debug & DBG_MEMSTAT_VALUE)
1722     {
1723       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
1724       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
1725     }
1726   if (opt.debug)
1727     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
1728   emergency_cleanup ();
1729   rc = rc? rc : log_get_errorcount(0)? 2 : gpgsm_errors_seen? 1 : 0;
1730   exit (rc);
1731 }
1732
1733
1734 void
1735 gpgsm_init_default_ctrl (struct server_control_s *ctrl)
1736 {
1737   ctrl->include_certs = default_include_certs;
1738   ctrl->use_ocsp = opt.enable_ocsp;
1739 }
1740
1741
1742
1743 /* Check whether the filename has the form "-&nnnn", where n is a
1744    non-zero number.  Returns this number or -1 if it is not the case.  */
1745 static int
1746 check_special_filename (const char *fname)
1747 {
1748   if (allow_special_filenames
1749       && fname && *fname == '-' && fname[1] == '&' ) {
1750     int i;
1751     
1752     fname += 2;
1753     for (i=0; isdigit (fname[i]); i++ )
1754       ;
1755     if ( !fname[i] ) 
1756       return atoi (fname);
1757   }
1758   return -1;
1759 }
1760
1761
1762
1763 /* Open the FILENAME for read and return the filedescriptor.  Stop
1764    with an error message in case of problems.  "-" denotes stdin and
1765    if special filenames are allowed the given fd is opened instead. */
1766 static int 
1767 open_read (const char *filename)
1768 {
1769   int fd;
1770
1771   if (filename[0] == '-' && !filename[1])
1772     {
1773       set_binary (stdin);
1774       return 0; /* stdin */
1775     }
1776   fd = check_special_filename (filename);
1777   if (fd != -1)
1778     return fd;
1779   fd = open (filename, O_RDONLY | O_BINARY);
1780   if (fd == -1)
1781     {
1782       log_error (_("can't open `%s': %s\n"), filename, strerror (errno));
1783       gpgsm_exit (2);
1784     }
1785   return fd;
1786 }
1787
1788 /* Open FILENAME for fwrite and return the stream.  Stop with an error
1789    message in case of problems.  "-" denotes stdout and if special
1790    filenames are allowed the given fd is opened instead. Caller must
1791    close the returned stream unless it is stdout. */
1792 static FILE *
1793 open_fwrite (const char *filename)
1794 {
1795   int fd;
1796   FILE *fp;
1797
1798   if (filename[0] == '-' && !filename[1])
1799     {
1800       set_binary (stdout);
1801       return stdout;
1802     }
1803
1804   fd = check_special_filename (filename);
1805   if (fd != -1)
1806     {
1807       fp = fdopen (dup (fd), "wb");
1808       if (!fp)
1809         {
1810           log_error ("fdopen(%d) failed: %s\n", fd, strerror (errno));
1811           gpgsm_exit (2);
1812         }
1813       set_binary (fp);
1814       return fp;
1815     }
1816   fp = fopen (filename, "wb");
1817   if (!fp)
1818     {
1819       log_error (_("can't open `%s': %s\n"), filename, strerror (errno));
1820       gpgsm_exit (2);
1821     }
1822   return fp;
1823 }
1824
1825
1826 /* Open FILENAME for fwrite and return an extended stream.  Stop with
1827    an error message in case of problems.  "-" denotes stdout and if
1828    special filenames are allowed the given fd is opened instead.
1829    Caller must close the returned stream. */
1830 static estream_t
1831 open_es_fwrite (const char *filename)
1832 {
1833   int fd;
1834   estream_t fp;
1835
1836   if (filename[0] == '-' && !filename[1])
1837     {
1838       fflush (stdout);
1839       fp = es_fdopen (dup (fileno(stdout)), "wb");
1840       return fp;
1841     }
1842
1843   fd = check_special_filename (filename);
1844   if (fd != -1)
1845     {
1846       fp = es_fdopen (dup (fd), "wb");
1847       if (!fp)
1848         {
1849           log_error ("es_fdopen(%d) failed: %s\n", fd, strerror (errno));
1850           gpgsm_exit (2);
1851         }
1852       return fp;
1853     }
1854   fp = es_fopen (filename, "wb");
1855   if (!fp)
1856     {
1857       log_error (_("can't open `%s': %s\n"), filename, strerror (errno));
1858       gpgsm_exit (2);
1859     }
1860   return fp;
1861 }
1862
1863
1864 static void
1865 run_protect_tool (int argc, char **argv)
1866 {
1867 #ifndef HAVE_W32_SYSTEM
1868   const char *pgm;
1869   char **av;
1870   int i;
1871
1872   if (!opt.protect_tool_program || !*opt.protect_tool_program)
1873     pgm = GNUPG_DEFAULT_PROTECT_TOOL;
1874   else
1875     pgm = opt.protect_tool_program;
1876
1877   av = xcalloc (argc+2, sizeof *av);
1878   av[0] = strrchr (pgm, '/');
1879   if (!av[0])
1880     av[0] = xstrdup (pgm);
1881   for (i=1; argc; i++, argc--, argv++)
1882     av[i] = *argv;
1883   av[i] = NULL;
1884   execv (pgm, av); 
1885   log_error ("error executing `%s': %s\n", pgm, strerror (errno));
1886 #endif /*HAVE_W32_SYSTEM*/
1887   gpgsm_exit (2);
1888 }