Implemented the --gen-key command as we can't use the gpgsm-gencert.sh under Windows.
[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 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 wrong_args (const char *text)
605 {
606   fputs (_("usage: gpgsm [options] "), stderr);
607   fputs (text, stderr);
608   putc ('\n', stderr);
609   gpgsm_exit (2);
610 }
611
612
613 /* Setup the debugging.  With a DEBUG_LEVEL of NULL only the active
614    debug flags are propagated to the subsystems.  With DEBUG_LEVEL
615    set, a specific set of debug flags is set; and individual debugging
616    flags will be added on top.  */
617 static void
618 set_debug (void)
619 {
620   if (!debug_level)
621     ;
622   else if (!strcmp (debug_level, "none"))
623     opt.debug = 0;
624   else if (!strcmp (debug_level, "basic"))
625     opt.debug = DBG_ASSUAN_VALUE;
626   else if (!strcmp (debug_level, "advanced"))
627     opt.debug = DBG_ASSUAN_VALUE|DBG_X509_VALUE;
628   else if (!strcmp (debug_level, "expert"))
629     opt.debug = (DBG_ASSUAN_VALUE|DBG_X509_VALUE
630                  |DBG_CACHE_VALUE|DBG_CRYPTO_VALUE);
631   else if (!strcmp (debug_level, "guru"))
632     opt.debug = ~0;
633   else
634     {
635       log_error (_("invalid debug-level `%s' given\n"), debug_level);
636       gpgsm_exit(2);
637     }
638
639   opt.debug |= debug_value;
640
641   if (opt.debug && !opt.verbose)
642     opt.verbose = 1;
643   if (opt.debug)
644     opt.quiet = 0;
645
646   if (opt.debug & DBG_MPI_VALUE)
647     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 2);
648   if (opt.debug & DBG_CRYPTO_VALUE )
649     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1);
650   gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
651 }
652  
653
654
655 static void
656 set_cmd (enum cmd_and_opt_values *ret_cmd, enum cmd_and_opt_values new_cmd)
657 {
658   enum cmd_and_opt_values cmd = *ret_cmd;
659
660   if (!cmd || cmd == new_cmd)
661     cmd = new_cmd;
662   else if ( cmd == aSign && new_cmd == aEncr )
663     cmd = aSignEncr;
664   else if ( cmd == aEncr && new_cmd == aSign )
665     cmd = aSignEncr;
666   else if ( (cmd == aSign && new_cmd == aClearsign)
667             || (cmd == aClearsign && new_cmd == aSign) )
668     cmd = aClearsign;
669   else 
670     {
671       log_error(_("conflicting commands\n"));
672       gpgsm_exit(2);
673     }
674
675   *ret_cmd = cmd;
676 }
677
678
679 /* Helper to add recipients to a list. */
680 static void
681 do_add_recipient (ctrl_t ctrl, const char *name,
682                   certlist_t *recplist, int is_encrypt_to)
683 {
684   int rc = gpgsm_add_to_certlist (ctrl, name, 0, recplist, is_encrypt_to);
685   if (rc)
686     {
687       log_error (_("can't encrypt to `%s': %s\n"), name, gpg_strerror (rc));
688       gpgsm_status2 (ctrl, STATUS_INV_RECP,
689                      gpg_err_code (rc) == -1?                         "1":
690                      gpg_err_code (rc) == GPG_ERR_NO_PUBKEY?          "1":
691                      gpg_err_code (rc) == GPG_ERR_AMBIGUOUS_NAME?     "2":
692                      gpg_err_code (rc) == GPG_ERR_WRONG_KEY_USAGE?    "3":
693                      gpg_err_code (rc) == GPG_ERR_CERT_REVOKED?       "4":
694                      gpg_err_code (rc) == GPG_ERR_CERT_EXPIRED?       "5":
695                      gpg_err_code (rc) == GPG_ERR_NO_CRL_KNOWN?       "6":
696                      gpg_err_code (rc) == GPG_ERR_CRL_TOO_OLD?        "7":
697                      gpg_err_code (rc) == GPG_ERR_NO_POLICY_MATCH?    "8":
698                      "0",
699                      name, NULL);
700     }
701 }
702
703
704 int
705 main ( int argc, char **argv)
706 {
707   ARGPARSE_ARGS pargs;
708   int orig_argc;
709   char **orig_argv;
710   const char *fname;
711   /*  char *username;*/
712   int may_coredump;
713   strlist_t sl, remusr= NULL, locusr=NULL;
714   strlist_t nrings=NULL;
715   int detached_sig = 0;
716   FILE *configfp = NULL;
717   char *configname = NULL;
718   unsigned configlineno;
719   int parse_debug = 0;
720   int no_more_options = 0;
721   int default_config =1;
722   int default_keyring = 1;
723   char *logfile = NULL;
724   int greeting = 0;
725   int nogreeting = 0;
726   int debug_wait = 0;
727   int use_random_seed = 1;
728   int with_fpr = 0;
729   char *def_digest_string = NULL;
730   enum cmd_and_opt_values cmd = 0;
731   struct server_control_s ctrl;
732   certlist_t recplist = NULL;
733   certlist_t signerlist = NULL;
734   int do_not_setup_keys = 0;
735
736   /*mtrace();*/
737
738   /* trap_unaligned ();*/
739   set_strusage (my_strusage);
740   gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
741   /* We don't need any locking in libgcrypt unless we use any kind of
742      threading. */
743   gcry_control (GCRYCTL_DISABLE_INTERNAL_LOCKING);
744
745   /* Please note that we may running SUID(ROOT), so be very CAREFUL
746      when adding any stuff between here and the call to secmem_init()
747      somewhere after the option parsing */
748   log_set_prefix ("gpgsm", 1);
749
750   /* Make sure that our subsystems are ready.  */
751   init_common_subsystems ();
752
753   /* Check that the libraries are suitable.  Do it here because the
754      option parse may need services of the library */
755   if (!gcry_check_version (NEED_LIBGCRYPT_VERSION) )
756     log_fatal (_("%s is too old (need %s, have %s)\n"), "libgcrypt", 
757                NEED_LIBGCRYPT_VERSION, gcry_check_version (NULL) );
758   if (!ksba_check_version (NEED_KSBA_VERSION) )
759     log_fatal (_("%s is too old (need %s, have %s)\n"), "libksba",
760                NEED_KSBA_VERSION, ksba_check_version (NULL) );
761
762
763   gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
764
765   may_coredump = disable_core_dumps ();
766   
767   gnupg_init_signals (0, emergency_cleanup);
768   
769   create_dotlock (NULL); /* register locking cleanup */
770   i18n_init();
771
772   opt.def_cipher_algoid = "3DES";  /*des-EDE3-CBC*/
773
774   opt.homedir = default_homedir ();
775 #ifdef HAVE_W32_SYSTEM
776   opt.no_crl_check = 1;
777 #endif
778
779   /* First check whether we have a config file on the commandline */
780   orig_argc = argc;
781   orig_argv = argv;
782   pargs.argc = &argc;
783   pargs.argv = &argv;
784   pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
785   while (arg_parse( &pargs, opts))
786     {
787       if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll)
788         parse_debug++;
789       else if (pargs.r_opt == oOptions)
790         { /* yes there is one, so we do not try the default one but
791              read the config file when it is encountered at the
792              commandline */
793           default_config = 0;
794         }
795       else if (pargs.r_opt == oNoOptions)
796         default_config = 0; /* --no-options */
797       else if (pargs.r_opt == oHomedir)
798         opt.homedir = pargs.r.ret_str;
799       else if (pargs.r_opt == aCallProtectTool)
800         break; /* This break makes sure that --version and --help are
801                   passed to the protect-tool. */
802     }
803   
804   
805   /* initialize the secure memory. */
806   gcry_control (GCRYCTL_INIT_SECMEM, 16384, 0);
807   maybe_setuid = 0;
808
809   /* 
810      Now we are now working under our real uid 
811   */
812
813   ksba_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free );
814
815   assuan_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
816   assuan_set_assuan_log_stream (log_get_stream ());
817   assuan_set_assuan_log_prefix (log_get_prefix (NULL));
818   assuan_set_assuan_err_source (GPG_ERR_SOURCE_DEFAULT);
819
820   keybox_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
821
822   /* Setup a default control structure for command line mode */
823   memset (&ctrl, 0, sizeof ctrl);
824   gpgsm_init_default_ctrl (&ctrl);
825   ctrl.no_server = 1;
826   ctrl.status_fd = -1; /* not status output */
827   ctrl.autodetect_encoding = 1;
828
829   /* Set the default option file */
830   if (default_config )
831     configname = make_filename (opt.homedir, "gpgsm.conf", NULL);
832   /* Set the default policy file */
833   opt.policy_file = make_filename (opt.homedir, "policies.txt", NULL);
834   
835   argc        = orig_argc;
836   argv        = orig_argv;
837   pargs.argc  = &argc;
838   pargs.argv  = &argv;
839   pargs.flags =  1;  /* do not remove the args */
840
841  next_pass:
842   if (configname) {
843     configlineno = 0;
844     configfp = fopen (configname, "r");
845     if (!configfp)
846       {
847         if (default_config)
848           {
849             if (parse_debug)
850               log_info (_("NOTE: no default option file `%s'\n"), configname);
851           }
852         else 
853           {
854             log_error (_("option file `%s': %s\n"), configname, strerror(errno));
855             gpgsm_exit(2);
856           }
857         xfree(configname);
858         configname = NULL;
859       }
860     if (parse_debug && configname)
861       log_info (_("reading options from `%s'\n"), configname);
862     default_config = 0;
863   }
864
865   while (!no_more_options 
866          && optfile_parse (configfp, configname, &configlineno, &pargs, opts))
867     {
868       switch (pargs.r_opt)
869         {
870         case aGPGConfList: 
871         case aGPGConfTest: 
872           set_cmd (&cmd, pargs.r_opt);
873           do_not_setup_keys = 1;
874           nogreeting = 1;
875           break;
876
877         case aServer: 
878           opt.batch = 1;
879           set_cmd (&cmd, aServer);
880           break;
881
882         case aCallDirmngr:
883           opt.batch = 1;
884           set_cmd (&cmd, aCallDirmngr);
885           do_not_setup_keys = 1;
886           break;
887
888         case aCallProtectTool:
889           opt.batch = 1;
890           set_cmd (&cmd, aCallProtectTool);
891           no_more_options = 1; /* Stop parsing. */
892           do_not_setup_keys = 1;
893           break;
894         
895         case aDeleteKey:
896           set_cmd (&cmd, aDeleteKey);
897           /*greeting=1;*/
898           do_not_setup_keys = 1;
899           break;
900
901         case aDetachedSign:
902           detached_sig = 1;
903           set_cmd (&cmd, aSign ); 
904           break;
905
906         case aKeygen:
907           set_cmd (&cmd, aKeygen);
908           greeting=1; 
909           do_not_setup_keys = 1;
910           break;
911
912         case aCheckKeys:
913         case aImport: 
914         case aSendKeys: 
915         case aRecvKeys: 
916         case aExport: 
917         case aExportSecretKeyP12: 
918         case aDumpKeys:
919         case aDumpChain:
920         case aDumpExternalKeys: 
921         case aDumpSecretKeys: 
922         case aListKeys:
923         case aListExternalKeys: 
924         case aListSecretKeys: 
925         case aListChain: 
926         case aLearnCard: 
927         case aPasswd: 
928         case aKeydbClearSomeCertFlags:
929           do_not_setup_keys = 1;
930           set_cmd (&cmd, pargs.r_opt);
931           break;
932
933         case aSym:
934         case aDecrypt: 
935         case aEncr: 
936         case aSign: 
937         case aClearsign: 
938         case aVerify: 
939           set_cmd (&cmd, pargs.r_opt);
940           break;
941
942           /* Output encoding selection.  */
943         case oArmor:
944           ctrl.create_pem = 1;
945           break;
946         case oBase64: 
947           ctrl.create_pem = 0;
948           ctrl.create_base64 = 1;
949           break;
950         case oNoArmor: 
951           ctrl.create_pem = 0;
952           ctrl.create_base64 = 0;
953           break;
954           
955         case oP12Charset:
956           opt.p12_charset = pargs.r.ret_str;
957           break;
958
959           /* Input encoding selection.  */
960         case oAssumeArmor:
961           ctrl.autodetect_encoding = 0;
962           ctrl.is_pem = 1;
963           ctrl.is_base64 = 0;
964           break;
965         case oAssumeBase64:
966           ctrl.autodetect_encoding = 0;
967           ctrl.is_pem = 0;
968           ctrl.is_base64 = 1;
969           break;
970         case oAssumeBinary:
971           ctrl.autodetect_encoding = 0;
972           ctrl.is_pem = 0;
973           ctrl.is_base64 = 0;
974           break;
975
976         case oDisableCRLChecks:
977           opt.no_crl_check = 1;
978           break;
979         case oEnableCRLChecks:
980           opt.no_crl_check = 0;
981           break;
982         case oDisableTrustedCertCRLCheck:
983           opt.no_trusted_cert_crl_check = 1;
984           break;
985         case oEnableTrustedCertCRLCheck:
986           opt.no_trusted_cert_crl_check = 0;
987           break;
988         case oForceCRLRefresh:
989           opt.force_crl_refresh = 1;
990           break;
991
992         case oDisableOCSP:
993           ctrl.use_ocsp = opt.enable_ocsp = 0;
994           break;
995         case oEnableOCSP:
996           ctrl.use_ocsp = opt.enable_ocsp = 1;
997           break;
998
999         case oIncludeCerts: 
1000           ctrl.include_certs = default_include_certs = pargs.r.ret_int; 
1001           break;
1002
1003         case oPolicyFile:
1004           xfree (opt.policy_file);
1005           if (*pargs.r.ret_str)
1006             opt.policy_file = xstrdup (pargs.r.ret_str);
1007           else
1008             opt.policy_file = NULL;
1009           break;
1010
1011         case oDisablePolicyChecks:
1012           opt.no_policy_check = 1;
1013           break;
1014         case oEnablePolicyChecks:
1015           opt.no_policy_check = 0;
1016           break;
1017           
1018         case oAutoIssuerKeyRetrieve:
1019           opt.auto_issuer_key_retrieve = 1;
1020           break;
1021
1022         case oOutput: opt.outfile = pargs.r.ret_str; break;
1023
1024         
1025         case oQuiet: opt.quiet = 1; break;
1026         case oNoTTY: /* fixme:tty_no_terminal(1);*/ break;
1027         case oDryRun: opt.dry_run = 1; break;
1028
1029         case oVerbose:
1030           opt.verbose++;
1031           gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
1032           break;
1033         case oNoVerbose:
1034           opt.verbose = 0;
1035           gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
1036           break;
1037
1038         case oLogFile: logfile = pargs.r.ret_str; break;
1039         case oNoLogFile: logfile = NULL; break;          
1040
1041         case oBatch: 
1042           opt.batch = 1;
1043           greeting = 0;
1044           break;
1045         case oNoBatch: opt.batch = 0; break;
1046           
1047         case oAnswerYes: opt.answer_yes = 1; break;
1048         case oAnswerNo: opt.answer_no = 1; break;
1049
1050         case oKeyring: append_to_strlist (&nrings, pargs.r.ret_str); break;
1051
1052         case oDebug: debug_value |= pargs.r.ret_ulong; break;
1053         case oDebugAll: debug_value = ~0; break;
1054         case oDebugNone: debug_value = 0; break;
1055         case oDebugLevel: debug_level = pargs.r.ret_str; break;
1056         case oDebugWait: debug_wait = pargs.r.ret_int; break;
1057         case oDebugAllowCoreDump:
1058           may_coredump = enable_core_dumps ();
1059           break;
1060         case oDebugNoChainValidation: opt.no_chain_validation = 1; break;
1061         case oDebugIgnoreExpiration: opt.ignore_expiration = 1; break;
1062         case oFixedPassphrase: opt.fixed_passphrase = pargs.r.ret_str; break;
1063
1064         case oStatusFD: ctrl.status_fd = pargs.r.ret_int; break;
1065         case oLoggerFD: log_set_fd (pargs.r.ret_int ); break;
1066         case oWithMD5Fingerprint:
1067           opt.with_md5_fingerprint=1; /*fall thru*/
1068         case oWithFingerprint:
1069           with_fpr=1; /*fall thru*/
1070         case oFingerprint:
1071           opt.fingerprint++;
1072           break;
1073
1074         case oOptions:
1075           /* config files may not be nested (silently ignore them) */
1076           if (!configfp)
1077             {
1078               xfree(configname);
1079               configname = xstrdup (pargs.r.ret_str);
1080               goto next_pass;
1081             }
1082           break;
1083         case oNoOptions: break; /* no-options */
1084         case oHomedir: opt.homedir = pargs.r.ret_str; break;
1085         case oAgentProgram: opt.agent_program = pargs.r.ret_str;  break;
1086         case oDisplay: opt.display = xstrdup (pargs.r.ret_str); break;
1087         case oTTYname: opt.ttyname = xstrdup (pargs.r.ret_str); break;
1088         case oTTYtype: opt.ttytype = xstrdup (pargs.r.ret_str); break;
1089         case oLCctype: opt.lc_ctype = xstrdup (pargs.r.ret_str); break;
1090         case oLCmessages: opt.lc_messages = xstrdup (pargs.r.ret_str); break;
1091         case oDirmngrProgram: opt.dirmngr_program = pargs.r.ret_str;  break;
1092         case oPreferSystemDirmngr: opt.prefer_system_dirmngr = 1; break;
1093         case oProtectToolProgram:
1094           opt.protect_tool_program = pargs.r.ret_str; 
1095           break;
1096           
1097         case oFakedSystemTime:
1098           gnupg_set_time ( (time_t)pargs.r.ret_ulong, 0);
1099           break;
1100
1101         case oNoDefKeyring: default_keyring = 0; break;
1102         case oNoGreeting: nogreeting = 1; break;
1103
1104         case oDefaultKey:
1105           /* fixme:opt.def_secret_key = pargs.r.ret_str;*/
1106           log_info ("WARNING: --default-key has not yet been implemented\n");
1107           break;
1108         case oDefRecipient:
1109           if (*pargs.r.ret_str)
1110             opt.def_recipient = xstrdup (pargs.r.ret_str);
1111           break;
1112         case oDefRecipientSelf:
1113           xfree (opt.def_recipient);
1114           opt.def_recipient = NULL;
1115           opt.def_recipient_self = 1;
1116           break;
1117         case oNoDefRecipient:
1118           xfree (opt.def_recipient);
1119           opt.def_recipient = NULL;
1120           opt.def_recipient_self = 0;
1121           break;
1122
1123         case oWithKeyData: opt.with_key_data=1; /* fall thru */
1124         case oWithColons: ctrl.with_colons = 1; break;
1125         case oWithValidation: ctrl.with_validation=1; break;
1126         case oWithEphemeralKeys: opt.with_ephemeral_keys=1; break;
1127
1128         case oSkipVerify: opt.skip_verify=1; break;
1129
1130         case oNoEncryptTo: opt.no_encrypt_to = 1; break;
1131         case oEncryptTo: /* Store the recipient in the second list */
1132           sl = add_to_strlist (&remusr, pargs.r.ret_str);
1133           sl->flags = 1;
1134           break;
1135
1136         case oRecipient: /* store the recipient */
1137           add_to_strlist ( &remusr, pargs.r.ret_str);
1138           break;
1139
1140         case oTextmodeShort: /*fixme:opt.textmode = 2;*/ break;
1141         case oTextmode: /*fixme:opt.textmode=1;*/  break;
1142
1143         case oUser: /* store the local users, the first one is the default */
1144           if (!opt.local_user)
1145             opt.local_user = pargs.r.ret_str;
1146           add_to_strlist (&locusr, pargs.r.ret_str);
1147           break;
1148
1149         case oNoSecmemWarn:
1150           gcry_control (GCRYCTL_DISABLE_SECMEM_WARN); 
1151           break;
1152
1153         case oCipherAlgo:
1154           opt.def_cipher_algoid = pargs.r.ret_str;
1155           break;
1156
1157         case oDisableCipherAlgo: 
1158           {
1159             int algo = gcry_cipher_map_name (pargs.r.ret_str);
1160             gcry_cipher_ctl (NULL, GCRYCTL_DISABLE_ALGO, &algo, sizeof algo);
1161           }
1162           break;
1163         case oDisablePubkeyAlgo: 
1164           {
1165             int algo = gcry_pk_map_name (pargs.r.ret_str);
1166             gcry_pk_ctl (GCRYCTL_DISABLE_ALGO,&algo, sizeof algo );
1167           }
1168           break;
1169
1170         case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
1171         case oNoRandomSeedFile: use_random_seed = 0; break;
1172
1173         case oEnableSpecialFilenames: allow_special_filenames =1; break;
1174           
1175
1176         case aDummy:
1177           break;
1178         default: 
1179           pargs.err = configfp? 1:2; 
1180           break;
1181         }
1182     }
1183
1184   if (configfp)
1185     {
1186       fclose (configfp);
1187       configfp = NULL;
1188       /* Keep a copy of the config filename. */
1189       opt.config_filename = configname;
1190       configname = NULL;
1191       goto next_pass;
1192     }
1193   xfree (configname);
1194   configname = NULL;
1195
1196   if (!opt.config_filename)
1197     opt.config_filename = make_filename (opt.homedir, "gpgsm.conf", NULL);
1198
1199   if (log_get_errorcount(0))
1200     gpgsm_exit(2);
1201   
1202   if (nogreeting)
1203     greeting = 0;
1204   
1205   if (greeting)
1206     {
1207       fprintf(stderr, "%s %s; %s\n",
1208               strusage(11), strusage(13), strusage(14) );
1209       fprintf(stderr, "%s\n", strusage(15) );
1210     }
1211 #  ifdef IS_DEVELOPMENT_VERSION
1212   if (!opt.batch)
1213     {
1214       log_info ("NOTE: THIS IS A DEVELOPMENT VERSION!\n");
1215       log_info ("It is only intended for test purposes and should NOT be\n");
1216       log_info ("used in a production environment or with production keys!\n");
1217     }
1218 #  endif
1219
1220   if (may_coredump && !opt.quiet)
1221     log_info (_("WARNING: program may create a core file!\n"));
1222
1223 /*   if (opt.qualsig_approval && !opt.quiet) */
1224 /*     log_info (_("This software has offically been approved to " */
1225 /*                 "create and verify\n" */
1226 /*                 "qualified signatures according to German law.\n")); */
1227
1228   if (logfile && cmd == aServer)
1229     {
1230       log_set_file (logfile);
1231       log_set_prefix (NULL, 1|2|4);
1232     }
1233
1234   if (gnupg_faked_time_p ())
1235     {
1236       gnupg_isotime_t tbuf;
1237
1238       log_info (_("WARNING: running with faked system time: "));
1239       gnupg_get_isotime (tbuf);
1240       gpgsm_dump_time (tbuf);
1241       log_printf ("\n");
1242     }
1243   
1244 /*FIXME    if (opt.batch) */
1245 /*      tty_batchmode (1); */
1246
1247   gcry_control (GCRYCTL_RESUME_SECMEM_WARN);
1248
1249   set_debug ();
1250
1251   /* Although we alwasy use gpgsm_exit, we better install a regualr
1252      exit handler so that at least the secure memory gets wiped
1253      out. */
1254   if (atexit (emergency_cleanup))
1255     {
1256       log_error ("atexit failed\n");
1257       gpgsm_exit (2);
1258     }
1259
1260   /* Must do this after dropping setuid, because the mapping functions
1261      may try to load an module and we may have disabled an algorithm.
1262      We remap the commonly used algorithms to the OIDs for
1263      convenience.  We need to work with the OIDs because they are used
1264      to check whether the encryption mode is actually available. */
1265   if (!strcmp (opt.def_cipher_algoid, "3DES") )
1266     opt.def_cipher_algoid = "1.2.840.113549.3.7";
1267   else if (!strcmp (opt.def_cipher_algoid, "AES")
1268            || !strcmp (opt.def_cipher_algoid, "AES128"))
1269     opt.def_cipher_algoid = "2.16.840.1.101.3.4.1.2";
1270   else if (!strcmp (opt.def_cipher_algoid, "AES256") )
1271     opt.def_cipher_algoid = "2.16.840.1.101.3.4.1.42";
1272
1273   if (cmd != aGPGConfList)
1274     {
1275       if ( !gcry_cipher_map_name (opt.def_cipher_algoid)
1276            || !gcry_cipher_mode_from_oid (opt.def_cipher_algoid))
1277         log_error (_("selected cipher algorithm is invalid\n"));
1278
1279       if (def_digest_string)
1280         {
1281           opt.def_digest_algo = gcry_md_map_name (def_digest_string);
1282           xfree (def_digest_string);
1283           def_digest_string = NULL;
1284           if (our_md_test_algo(opt.def_digest_algo) )
1285             log_error (_("selected digest algorithm is invalid\n"));
1286         }
1287     }
1288
1289   if (log_get_errorcount(0))
1290     gpgsm_exit(2);
1291   
1292   /* Set the random seed file. */
1293   if (use_random_seed) {
1294     char *p = make_filename (opt.homedir, "random_seed", NULL);
1295     gcry_control (GCRYCTL_SET_RANDOM_SEED_FILE, p);
1296     xfree(p);
1297   }
1298
1299
1300   if (!cmd && opt.fingerprint && !with_fpr)
1301     set_cmd (&cmd, aListKeys);
1302   
1303   if (!nrings && default_keyring)  /* Add default keybox. */
1304     {
1305       int created;
1306
1307       keydb_add_resource ("pubring.kbx", 0, 0, &created);
1308       if (created)
1309         {
1310           /* Import the standard certificates for a new default keybox. */
1311           char *filelist[2];
1312           
1313           filelist[0] = make_filename (gnupg_datadir (),"com-certs.pem", NULL);
1314           filelist[1] = NULL;
1315           if (!access (filelist[0], F_OK))
1316             {
1317               log_info (_("importing common certificates `%s'\n"),
1318                         filelist[0]);
1319               gpgsm_import_files (&ctrl, 1, filelist, open_read);
1320             }
1321           xfree (filelist[0]);
1322         }
1323     }
1324   for (sl = nrings; sl; sl = sl->next)
1325     keydb_add_resource (sl->d, 0, 0, NULL);
1326   FREE_STRLIST(nrings);
1327
1328   if (!do_not_setup_keys)
1329     {
1330       for (sl = locusr; sl ; sl = sl->next)
1331         {
1332           int rc = gpgsm_add_to_certlist (&ctrl, sl->d, 1, &signerlist, 0);
1333           if (rc)
1334             {
1335               log_error (_("can't sign using `%s': %s\n"),
1336                          sl->d, gpg_strerror (rc));
1337               gpgsm_status2 (&ctrl, STATUS_INV_RECP,
1338                          gpg_err_code (rc) == -1?                      "1":
1339                          gpg_err_code (rc) == GPG_ERR_NO_PUBKEY?       "1":
1340                          gpg_err_code (rc) == GPG_ERR_AMBIGUOUS_NAME?  "2":
1341                          gpg_err_code (rc) == GPG_ERR_WRONG_KEY_USAGE? "3":
1342                          gpg_err_code (rc) == GPG_ERR_CERT_REVOKED?    "4":
1343                          gpg_err_code (rc) == GPG_ERR_CERT_EXPIRED?    "5":
1344                          gpg_err_code (rc) == GPG_ERR_NO_CRL_KNOWN?    "6":
1345                          gpg_err_code (rc) == GPG_ERR_CRL_TOO_OLD?     "7":
1346                          gpg_err_code (rc) == GPG_ERR_NO_POLICY_MATCH? "8":
1347                          gpg_err_code (rc) == GPG_ERR_NO_SECKEY?       "9":
1348                          "0",
1349                          sl->d, NULL);
1350             }
1351         }
1352       
1353       /* Build the recipient list.  We first add the regular ones and then
1354          the encrypt-to ones because the underlying function will silenty
1355          ignore duplicates and we can't allow to keep a duplicate which is
1356          flagged as encrypt-to as the actually encrypt function would then
1357          complain about no (regular) recipients. */
1358       for (sl = remusr; sl; sl = sl->next)
1359         if (!(sl->flags & 1))
1360           do_add_recipient (&ctrl, sl->d, &recplist, 0);
1361       if (!opt.no_encrypt_to)
1362         {
1363           for (sl = remusr; sl; sl = sl->next)
1364             if ((sl->flags & 1))
1365               do_add_recipient (&ctrl, sl->d, &recplist, 1);
1366         }
1367     }
1368
1369   if (log_get_errorcount(0))
1370     gpgsm_exit(1); /* must stop for invalid recipients */
1371   
1372   fname = argc? *argv : NULL;
1373   
1374   switch (cmd)
1375     {
1376     case aGPGConfList: 
1377       { /* List options and default values in the GPG Conf format.  */
1378
1379         /* The following list is taken from gnupg/tools/gpgconf-comp.c.  */
1380         /* Option flags.  YOU MUST NOT CHANGE THE NUMBERS OF THE EXISTING
1381            FLAGS, AS THEY ARE PART OF THE EXTERNAL INTERFACE.  */
1382 #define GC_OPT_FLAG_NONE        0UL
1383         /* The RUNTIME flag for an option indicates that the option can be
1384            changed at runtime.  */
1385 #define GC_OPT_FLAG_RUNTIME     (1UL << 3)
1386         /* The DEFAULT flag for an option indicates that the option has a
1387            default value.  */
1388 #define GC_OPT_FLAG_DEFAULT     (1UL << 4)
1389         /* The DEF_DESC flag for an option indicates that the option has a
1390            default, which is described by the value of the default field.  */
1391 #define GC_OPT_FLAG_DEF_DESC    (1UL << 5)
1392         /* The NO_ARG_DESC flag for an option indicates that the argument has
1393            a default, which is described by the value of the ARGDEF field.  */
1394 #define GC_OPT_FLAG_NO_ARG_DESC (1UL << 6)
1395
1396         char *config_filename_esc = percent_escape (opt.config_filename, NULL);
1397
1398         printf ("gpgconf-gpgsm.conf:%lu:\"%s\n",
1399                 GC_OPT_FLAG_DEFAULT, config_filename_esc);
1400         xfree (config_filename_esc);
1401
1402         printf ("verbose:%lu:\n"
1403                 "quiet:%lu:\n"
1404                 "debug-level:%lu:\"none:\n"
1405                 "log-file:%lu:\n",
1406                 GC_OPT_FLAG_NONE,
1407                 GC_OPT_FLAG_NONE,
1408                 GC_OPT_FLAG_DEFAULT,
1409                 GC_OPT_FLAG_NONE );
1410         printf ("disable-crl-checks:%lu:\n",
1411                 GC_OPT_FLAG_NONE );
1412         printf ("disable-trusted-cert-crl-check:%lu:\n",
1413                 GC_OPT_FLAG_NONE );
1414         printf ("enable-ocsp:%lu:\n",
1415                 GC_OPT_FLAG_NONE );
1416         printf ("include-certs:%lu:1:\n",
1417                 GC_OPT_FLAG_DEFAULT );
1418         printf ("disable-policy-checks:%lu:\n",
1419                 GC_OPT_FLAG_NONE );
1420         printf ("auto-issuer-key-retrieve:%lu:\n",
1421                 GC_OPT_FLAG_NONE );
1422         printf ("prefer-system-dirmngr:%lu:\n",
1423                 GC_OPT_FLAG_NONE );
1424         printf ("cipher-algo:%lu:\"3DES:\n",
1425                 GC_OPT_FLAG_DEFAULT );
1426         printf ("p12-charset:%lu:\n",
1427                 GC_OPT_FLAG_DEFAULT );
1428
1429       }
1430       break;
1431     case aGPGConfTest:
1432       /* This is merely a dummy command to test whether the
1433          configuration file is valid.  */
1434       break;
1435
1436     case aServer:
1437       if (debug_wait)
1438         {
1439           log_debug ("waiting for debugger - my pid is %u .....\n",
1440                      (unsigned int)getpid());
1441           gnupg_sleep (debug_wait);
1442           log_debug ("... okay\n");
1443          }
1444       gpgsm_server (recplist);
1445       break;
1446
1447     case aCallDirmngr:
1448       if (!argc)
1449         wrong_args ("--call-dirmngr <command> {args}");
1450       else
1451         if (gpgsm_dirmngr_run_command (&ctrl, *argv, argc-1, argv+1))
1452           gpgsm_exit (1);
1453       break;
1454
1455     case aCallProtectTool:
1456       run_protect_tool (argc, argv);
1457       break;
1458
1459     case aEncr: /* Encrypt the given file. */
1460       {
1461         FILE *fp = open_fwrite (opt.outfile?opt.outfile:"-");
1462
1463         set_binary (stdin);
1464
1465         if (!argc) /* Source is stdin. */
1466           gpgsm_encrypt (&ctrl, recplist, 0, fp); 
1467         else if (argc == 1)  /* Source is the given file. */
1468           gpgsm_encrypt (&ctrl, recplist, open_read (*argv), fp);
1469         else
1470           wrong_args ("--encrypt [datafile]");
1471
1472         if (fp != stdout)
1473           fclose (fp);
1474       }
1475       break;
1476
1477     case aSign: /* Sign the given file. */
1478       {
1479         FILE *fp = open_fwrite (opt.outfile?opt.outfile:"-");
1480
1481         /* Fixme: We should also allow to concatenate multiple files for
1482            signing because that is what gpg does.*/
1483         set_binary (stdin);
1484         if (!argc) /* Create from stdin. */
1485           gpgsm_sign (&ctrl, signerlist, 0, detached_sig, fp); 
1486         else if (argc == 1) /* From file. */
1487           gpgsm_sign (&ctrl, signerlist,
1488                       open_read (*argv), detached_sig, fp); 
1489         else
1490           wrong_args ("--sign [datafile]");
1491
1492         if (fp != stdout)
1493           fclose (fp);
1494       }
1495       break;
1496         
1497     case aSignEncr: /* sign and encrypt the given file */
1498       log_error ("this command has not yet been implemented\n");
1499       break;
1500
1501     case aClearsign: /* make a clearsig */
1502       log_error ("this command has not yet been implemented\n");
1503       break;
1504
1505     case aVerify:
1506       {
1507         FILE *fp = NULL;
1508
1509         set_binary (stdin);
1510         if (argc == 2 && opt.outfile)
1511           log_info ("option --output ignored for a detached signature\n");
1512         else if (opt.outfile)
1513           fp = open_fwrite (opt.outfile);
1514
1515         if (!argc)
1516           gpgsm_verify (&ctrl, 0, -1, fp); /* normal signature from stdin */
1517         else if (argc == 1)
1518           gpgsm_verify (&ctrl, open_read (*argv), -1, fp); /* std signature */
1519         else if (argc == 2) /* detached signature (sig, detached) */
1520           gpgsm_verify (&ctrl, open_read (*argv), open_read (argv[1]), NULL); 
1521         else
1522           wrong_args ("--verify [signature [detached_data]]");
1523
1524         if (fp && fp != stdout)
1525           fclose (fp);
1526       }
1527       break;
1528
1529     case aVerifyFiles:
1530       log_error (_("this command has not yet been implemented\n"));
1531       break;
1532
1533     case aDecrypt:
1534       {
1535         FILE *fp = open_fwrite (opt.outfile?opt.outfile:"-");
1536
1537         set_binary (stdin);
1538         if (!argc)
1539           gpgsm_decrypt (&ctrl, 0, fp); /* from stdin */
1540         else if (argc == 1)
1541           gpgsm_decrypt (&ctrl, open_read (*argv), fp); /* from file */
1542         else
1543           wrong_args ("--decrypt [filename]");
1544         if (fp != stdout)
1545           fclose (fp);
1546       }
1547       break;
1548
1549     case aDeleteKey:
1550       for (sl=NULL; argc; argc--, argv++)
1551         add_to_strlist (&sl, *argv);
1552       gpgsm_delete (&ctrl, sl);
1553       free_strlist(sl);
1554       break;
1555
1556     case aListChain:
1557     case aDumpChain:
1558        ctrl.with_chain = 1;
1559     case aListKeys:
1560     case aDumpKeys:
1561     case aListExternalKeys:
1562     case aDumpExternalKeys:
1563     case aListSecretKeys:
1564     case aDumpSecretKeys:
1565       {
1566         unsigned int mode;
1567         estream_t fp;
1568
1569         switch (cmd)
1570           {
1571           case aListChain:
1572           case aListKeys:         mode = (0   | 0 | (1<<6)); break;
1573           case aDumpChain: 
1574           case aDumpKeys:         mode = (256 | 0 | (1<<6)); break;
1575           case aListExternalKeys: mode = (0   | 0 | (1<<7)); break;
1576           case aDumpExternalKeys: mode = (256 | 0 | (1<<7)); break;
1577           case aListSecretKeys:   mode = (0   | 2 | (1<<6)); break;
1578           case aDumpSecretKeys:   mode = (256 | 2 | (1<<6)); break;
1579           default: BUG();
1580           }
1581
1582         fp = open_es_fwrite (opt.outfile?opt.outfile:"-");
1583         for (sl=NULL; argc; argc--, argv++)
1584           add_to_strlist (&sl, *argv);
1585         gpgsm_list_keys (&ctrl, sl, fp, mode);
1586         free_strlist(sl);
1587         es_fclose (fp);
1588       }
1589       break;
1590
1591
1592     case aKeygen: /* Generate a key; well kind of. */
1593       {
1594         FILE *fp = open_fwrite (opt.outfile?opt.outfile:"-");
1595         gpgsm_gencertreq_tty (&ctrl, fp);
1596         if (fp != stdout)
1597           fclose (fp);
1598       }
1599       break;
1600
1601
1602     case aImport:
1603       gpgsm_import_files (&ctrl, argc, argv, open_read);
1604       break;
1605
1606     case aExport:
1607       {
1608         FILE *fp = open_fwrite (opt.outfile?opt.outfile:"-");
1609
1610         for (sl=NULL; argc; argc--, argv++)
1611           add_to_strlist (&sl, *argv);
1612         gpgsm_export (&ctrl, sl, fp, NULL);
1613         free_strlist(sl);
1614         if (fp != stdout)
1615           fclose (fp);
1616       }
1617       break;
1618
1619     case aExportSecretKeyP12:
1620       {
1621         FILE *fp = open_fwrite (opt.outfile?opt.outfile:"-");
1622
1623         if (argc == 1)
1624           gpgsm_p12_export (&ctrl, *argv, stdout);
1625         else
1626           wrong_args ("--export-secret-key-p12 KEY-ID");
1627         if (fp != stdout)
1628           fclose (fp);
1629       }
1630       break;
1631       
1632     case aSendKeys:
1633     case aRecvKeys:
1634       log_error ("this command has not yet been implemented\n");
1635       break;
1636
1637
1638     case aLearnCard:
1639       if (argc)
1640         wrong_args ("--learn-card");
1641       else
1642         {
1643           int rc = gpgsm_agent_learn (&ctrl);
1644           if (rc)
1645             log_error ("error learning card: %s\n", gpg_strerror (rc));
1646         }
1647       break;
1648
1649     case aPasswd:
1650       if (argc != 1)
1651         wrong_args ("--passwd <key-Id>");
1652       else
1653         {
1654           int rc;
1655           ksba_cert_t cert = NULL;
1656           char *grip = NULL;
1657
1658           rc = gpgsm_find_cert (*argv, NULL, &cert);
1659           if (rc)
1660             ;
1661           else if (!(grip = gpgsm_get_keygrip_hexstring (cert)))
1662             rc = gpg_error (GPG_ERR_BUG);
1663           else 
1664             {
1665               char *desc = gpgsm_format_keydesc (cert);
1666               rc = gpgsm_agent_passwd (&ctrl, grip, desc);
1667               xfree (desc);
1668             }
1669           if (rc)
1670             log_error ("error changing passphrase: %s\n", gpg_strerror (rc));
1671           xfree (grip);
1672           ksba_cert_release (cert);
1673         }
1674       break;
1675
1676     case aKeydbClearSomeCertFlags:
1677       for (sl=NULL; argc; argc--, argv++)
1678         add_to_strlist (&sl, *argv);
1679       keydb_clear_some_cert_flags (&ctrl, sl);
1680       free_strlist(sl);
1681       break;
1682
1683
1684     default:
1685         log_error ("invalid command (there is no implicit command)\n");
1686         break;
1687     }
1688   
1689   /* cleanup */
1690   gpgsm_release_certlist (recplist);
1691   gpgsm_release_certlist (signerlist);
1692   FREE_STRLIST (remusr);
1693   FREE_STRLIST (locusr);
1694   gpgsm_exit(0);
1695   return 8; /*NOTREACHED*/
1696 }
1697
1698 /* Note: This function is used by signal handlers!. */
1699 static void
1700 emergency_cleanup (void)
1701 {
1702   gcry_control (GCRYCTL_TERM_SECMEM );
1703 }
1704
1705
1706 void
1707 gpgsm_exit (int rc)
1708 {
1709   gcry_control (GCRYCTL_UPDATE_RANDOM_SEED_FILE);
1710   if (opt.debug & DBG_MEMSTAT_VALUE)
1711     {
1712       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
1713       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
1714     }
1715   if (opt.debug)
1716     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
1717   emergency_cleanup ();
1718   rc = rc? rc : log_get_errorcount(0)? 2 : gpgsm_errors_seen? 1 : 0;
1719   exit (rc);
1720 }
1721
1722
1723 void
1724 gpgsm_init_default_ctrl (struct server_control_s *ctrl)
1725 {
1726   ctrl->include_certs = default_include_certs;
1727   ctrl->use_ocsp = opt.enable_ocsp;
1728 }
1729
1730
1731
1732 /* Check whether the filename has the form "-&nnnn", where n is a
1733    non-zero number.  Returns this number or -1 if it is not the case.  */
1734 static int
1735 check_special_filename (const char *fname)
1736 {
1737   if (allow_special_filenames
1738       && fname && *fname == '-' && fname[1] == '&' ) {
1739     int i;
1740     
1741     fname += 2;
1742     for (i=0; isdigit (fname[i]); i++ )
1743       ;
1744     if ( !fname[i] ) 
1745       return atoi (fname);
1746   }
1747   return -1;
1748 }
1749
1750
1751
1752 /* Open the FILENAME for read and return the filedescriptor.  Stop
1753    with an error message in case of problems.  "-" denotes stdin and
1754    if special filenames are allowed the given fd is opened instead. */
1755 static int 
1756 open_read (const char *filename)
1757 {
1758   int fd;
1759
1760   if (filename[0] == '-' && !filename[1])
1761     {
1762       set_binary (stdin);
1763       return 0; /* stdin */
1764     }
1765   fd = check_special_filename (filename);
1766   if (fd != -1)
1767     return fd;
1768   fd = open (filename, O_RDONLY | O_BINARY);
1769   if (fd == -1)
1770     {
1771       log_error (_("can't open `%s': %s\n"), filename, strerror (errno));
1772       gpgsm_exit (2);
1773     }
1774   return fd;
1775 }
1776
1777 /* Open FILENAME for fwrite and return the stream.  Stop with an error
1778    message in case of problems.  "-" denotes stdout and if special
1779    filenames are allowed the given fd is opened instead. Caller must
1780    close the returned stream unless it is stdout. */
1781 static FILE *
1782 open_fwrite (const char *filename)
1783 {
1784   int fd;
1785   FILE *fp;
1786
1787   if (filename[0] == '-' && !filename[1])
1788     {
1789       set_binary (stdout);
1790       return stdout;
1791     }
1792
1793   fd = check_special_filename (filename);
1794   if (fd != -1)
1795     {
1796       fp = fdopen (dup (fd), "wb");
1797       if (!fp)
1798         {
1799           log_error ("fdopen(%d) failed: %s\n", fd, strerror (errno));
1800           gpgsm_exit (2);
1801         }
1802       set_binary (fp);
1803       return fp;
1804     }
1805   fp = fopen (filename, "wb");
1806   if (!fp)
1807     {
1808       log_error (_("can't open `%s': %s\n"), filename, strerror (errno));
1809       gpgsm_exit (2);
1810     }
1811   return fp;
1812 }
1813
1814
1815 /* Open FILENAME for fwrite and return an extended stream.  Stop with
1816    an error message in case of problems.  "-" denotes stdout and if
1817    special filenames are allowed the given fd is opened instead.
1818    Caller must close the returned stream. */
1819 static estream_t
1820 open_es_fwrite (const char *filename)
1821 {
1822   int fd;
1823   estream_t fp;
1824
1825   if (filename[0] == '-' && !filename[1])
1826     {
1827       fflush (stdout);
1828       fp = es_fdopen (dup (fileno(stdout)), "wb");
1829       return fp;
1830     }
1831
1832   fd = check_special_filename (filename);
1833   if (fd != -1)
1834     {
1835       fp = es_fdopen (dup (fd), "wb");
1836       if (!fp)
1837         {
1838           log_error ("es_fdopen(%d) failed: %s\n", fd, strerror (errno));
1839           gpgsm_exit (2);
1840         }
1841       return fp;
1842     }
1843   fp = es_fopen (filename, "wb");
1844   if (!fp)
1845     {
1846       log_error (_("can't open `%s': %s\n"), filename, strerror (errno));
1847       gpgsm_exit (2);
1848     }
1849   return fp;
1850 }
1851
1852
1853 static void
1854 run_protect_tool (int argc, char **argv)
1855 {
1856 #ifndef HAVE_W32_SYSTEM
1857   const char *pgm;
1858   char **av;
1859   int i;
1860
1861   if (!opt.protect_tool_program || !*opt.protect_tool_program)
1862     pgm = gnupg_module_name (GNUPG_MODULE_NAME_PROTECT_TOOL);
1863   else
1864     pgm = opt.protect_tool_program;
1865
1866   av = xcalloc (argc+2, sizeof *av);
1867   av[0] = strrchr (pgm, '/');
1868   if (!av[0])
1869     av[0] = xstrdup (pgm);
1870   for (i=1; argc; i++, argc--, argv++)
1871     av[i] = *argv;
1872   av[i] = NULL;
1873   execv (pgm, av); 
1874   log_error ("error executing `%s': %s\n", pgm, strerror (errno));
1875 #endif /*HAVE_W32_SYSTEM*/
1876   gpgsm_exit (2);
1877 }