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