2003-08-05 17:11:04 +00:00
|
|
|
/* gpgsm.c - GnuPG for S/MIME
|
2010-03-08 12:22:18 +00:00
|
|
|
* Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
|
|
|
|
* 2010 Free Software Foundation, Inc.
|
2003-08-05 17:11:04 +00:00
|
|
|
*
|
|
|
|
* This file is part of GnuPG.
|
|
|
|
*
|
|
|
|
* GnuPG is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
2007-07-04 19:49:40 +00:00
|
|
|
* the Free Software Foundation; either version 3 of the License, or
|
2003-08-05 17:11:04 +00:00
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* GnuPG is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
2007-07-04 19:49:40 +00:00
|
|
|
* along with this program; if not, see <http://www.gnu.org/licenses/>.
|
2003-08-05 17:11:04 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include <config.h>
|
|
|
|
#include <errno.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <ctype.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <fcntl.h>
|
2006-12-21 08:05:29 +00:00
|
|
|
/*#include <mcheck.h>*/
|
2003-08-05 17:11:04 +00:00
|
|
|
|
|
|
|
#include "gpgsm.h"
|
|
|
|
#include <gcrypt.h>
|
|
|
|
#include <assuan.h> /* malloc hooks */
|
|
|
|
|
|
|
|
#include "../kbx/keybox.h" /* malloc hooks */
|
|
|
|
#include "i18n.h"
|
|
|
|
#include "keydb.h"
|
|
|
|
#include "sysutils.h"
|
2007-08-02 18:12:43 +00:00
|
|
|
#include "gc-opt-flags.h"
|
2010-03-11 12:34:11 +00:00
|
|
|
#include "asshelp.h"
|
2004-12-22 17:55:28 +00:00
|
|
|
|
|
|
|
#ifndef O_BINARY
|
|
|
|
#define O_BINARY 0
|
|
|
|
#endif
|
|
|
|
|
2003-08-05 17:11:04 +00:00
|
|
|
enum cmd_and_opt_values {
|
|
|
|
aNull = 0,
|
|
|
|
oArmor = 'a',
|
|
|
|
aDetachedSign = 'b',
|
|
|
|
aSym = 'c',
|
|
|
|
aDecrypt = 'd',
|
|
|
|
aEncr = 'e',
|
2003-12-16 16:31:16 +00:00
|
|
|
aListKeys = 'k',
|
|
|
|
aListSecretKeys = 'K',
|
2003-08-05 17:11:04 +00:00
|
|
|
oDryRun = 'n',
|
|
|
|
oOutput = 'o',
|
|
|
|
oQuiet = 'q',
|
|
|
|
oRecipient = 'r',
|
|
|
|
aSign = 's',
|
|
|
|
oUser = 'u',
|
|
|
|
oVerbose = 'v',
|
|
|
|
oBatch = 500,
|
|
|
|
aClearsign,
|
|
|
|
aKeygen,
|
|
|
|
aSignEncr,
|
|
|
|
aDeleteKey,
|
|
|
|
aImport,
|
|
|
|
aVerify,
|
|
|
|
aListExternalKeys,
|
2006-09-13 15:57:30 +00:00
|
|
|
aListChain,
|
2003-08-05 17:11:04 +00:00
|
|
|
aSendKeys,
|
|
|
|
aRecvKeys,
|
|
|
|
aExport,
|
2004-02-19 16:26:32 +00:00
|
|
|
aExportSecretKeyP12,
|
2003-08-05 17:11:04 +00:00
|
|
|
aServer,
|
|
|
|
aLearnCard,
|
|
|
|
aCallDirmngr,
|
|
|
|
aCallProtectTool,
|
|
|
|
aPasswd,
|
2004-02-18 17:00:21 +00:00
|
|
|
aGPGConfList,
|
2006-10-23 14:02:13 +00:00
|
|
|
aGPGConfTest,
|
2004-04-22 13:03:44 +00:00
|
|
|
aDumpKeys,
|
2006-09-13 15:57:30 +00:00
|
|
|
aDumpChain,
|
2004-04-22 13:03:44 +00:00
|
|
|
aDumpSecretKeys,
|
|
|
|
aDumpExternalKeys,
|
2004-04-28 08:59:34 +00:00
|
|
|
aKeydbClearSomeCertFlags,
|
2008-11-13 12:37:45 +00:00
|
|
|
aFingerprint,
|
2003-08-05 17:11:04 +00:00
|
|
|
|
|
|
|
oOptions,
|
|
|
|
oDebug,
|
2004-02-18 17:00:21 +00:00
|
|
|
oDebugLevel,
|
2003-08-05 17:11:04 +00:00
|
|
|
oDebugAll,
|
2005-07-21 18:29:13 +00:00
|
|
|
oDebugNone,
|
2003-08-05 17:11:04 +00:00
|
|
|
oDebugWait,
|
2004-05-11 09:54:52 +00:00
|
|
|
oDebugAllowCoreDump,
|
2003-08-05 17:11:04 +00:00
|
|
|
oDebugNoChainValidation,
|
2004-02-20 13:46:21 +00:00
|
|
|
oDebugIgnoreExpiration,
|
2004-08-17 15:26:22 +00:00
|
|
|
oFixedPassphrase,
|
2003-08-05 17:11:04 +00:00
|
|
|
oLogFile,
|
2005-07-21 18:29:13 +00:00
|
|
|
oNoLogFile,
|
2007-11-19 16:03:50 +00:00
|
|
|
oAuditLog,
|
2009-12-02 18:33:59 +00:00
|
|
|
oHtmlAuditLog,
|
2003-08-05 17:11:04 +00:00
|
|
|
|
|
|
|
oEnableSpecialFilenames,
|
|
|
|
|
|
|
|
oAgentProgram,
|
|
|
|
oDisplay,
|
|
|
|
oTTYname,
|
|
|
|
oTTYtype,
|
|
|
|
oLCctype,
|
|
|
|
oLCmessages,
|
2007-11-19 16:03:50 +00:00
|
|
|
oXauthority,
|
2003-08-05 17:11:04 +00:00
|
|
|
|
2004-11-23 17:09:51 +00:00
|
|
|
oPreferSystemDirmngr,
|
2003-08-05 17:11:04 +00:00
|
|
|
oDirmngrProgram,
|
2008-02-19 10:33:35 +00:00
|
|
|
oDisableDirmngr,
|
2004-02-13 12:40:23 +00:00
|
|
|
oProtectToolProgram,
|
2003-08-05 17:11:04 +00:00
|
|
|
oFakedSystemTime,
|
|
|
|
|
|
|
|
|
|
|
|
oAssumeArmor,
|
|
|
|
oAssumeBase64,
|
|
|
|
oAssumeBinary,
|
|
|
|
|
|
|
|
oBase64,
|
|
|
|
oNoArmor,
|
2007-03-20 10:00:55 +00:00
|
|
|
oP12Charset,
|
2003-08-05 17:11:04 +00:00
|
|
|
|
|
|
|
oDisableCRLChecks,
|
|
|
|
oEnableCRLChecks,
|
2005-04-21 09:33:07 +00:00
|
|
|
oDisableTrustedCertCRLCheck,
|
|
|
|
oEnableTrustedCertCRLCheck,
|
2004-04-07 17:59:18 +00:00
|
|
|
oForceCRLRefresh,
|
|
|
|
|
2003-12-01 10:54:30 +00:00
|
|
|
oDisableOCSP,
|
|
|
|
oEnableOCSP,
|
|
|
|
|
2003-08-05 17:11:04 +00:00
|
|
|
oIncludeCerts,
|
|
|
|
oPolicyFile,
|
|
|
|
oDisablePolicyChecks,
|
|
|
|
oEnablePolicyChecks,
|
|
|
|
oAutoIssuerKeyRetrieve,
|
|
|
|
|
|
|
|
oWithFingerprint,
|
2004-02-17 15:05:04 +00:00
|
|
|
oWithMD5Fingerprint,
|
2010-10-08 11:11:08 +00:00
|
|
|
oWithKeygrip,
|
2003-08-05 17:11:04 +00:00
|
|
|
oAnswerYes,
|
|
|
|
oAnswerNo,
|
|
|
|
oKeyring,
|
|
|
|
oDefaultKey,
|
|
|
|
oDefRecipient,
|
|
|
|
oDefRecipientSelf,
|
|
|
|
oNoDefRecipient,
|
|
|
|
oStatusFD,
|
|
|
|
oCipherAlgo,
|
|
|
|
oDigestAlgo,
|
2007-12-13 15:45:40 +00:00
|
|
|
oExtraDigestAlgo,
|
2003-08-05 17:11:04 +00:00
|
|
|
oNoVerbose,
|
|
|
|
oNoSecmemWarn,
|
|
|
|
oNoDefKeyring,
|
|
|
|
oNoGreeting,
|
|
|
|
oNoTTY,
|
|
|
|
oNoOptions,
|
|
|
|
oNoBatch,
|
|
|
|
oHomedir,
|
|
|
|
oWithColons,
|
|
|
|
oWithKeyData,
|
2004-02-17 15:05:04 +00:00
|
|
|
oWithValidation,
|
2004-08-06 16:14:10 +00:00
|
|
|
oWithEphemeralKeys,
|
2003-08-05 17:11:04 +00:00
|
|
|
oSkipVerify,
|
2007-08-10 16:52:05 +00:00
|
|
|
oValidationModel,
|
2003-08-05 17:11:04 +00:00
|
|
|
oKeyServer,
|
|
|
|
oEncryptTo,
|
|
|
|
oNoEncryptTo,
|
|
|
|
oLoggerFD,
|
|
|
|
oDisableCipherAlgo,
|
|
|
|
oDisablePubkeyAlgo,
|
|
|
|
oIgnoreTimeConflict,
|
|
|
|
oNoRandomSeedFile,
|
2009-12-10 13:00:30 +00:00
|
|
|
oNoCommonCertsImport,
|
|
|
|
oIgnoreCertExtension
|
2003-08-05 17:11:04 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
static ARGPARSE_OPTS opts[] = {
|
|
|
|
|
2008-11-13 12:37:45 +00:00
|
|
|
ARGPARSE_group (300, N_("@Commands:\n ")),
|
|
|
|
|
|
|
|
ARGPARSE_c (aSign, "sign", N_("make a signature")),
|
|
|
|
ARGPARSE_c (aClearsign, "clearsign", N_("make a clear text signature") ),
|
|
|
|
ARGPARSE_c (aDetachedSign, "detach-sign", N_("make a detached signature")),
|
|
|
|
ARGPARSE_c (aEncr, "encrypt", N_("encrypt data")),
|
|
|
|
ARGPARSE_c (aSym, "symmetric", N_("encryption only with symmetric cipher")),
|
|
|
|
ARGPARSE_c (aDecrypt, "decrypt", N_("decrypt data (default)")),
|
|
|
|
ARGPARSE_c (aVerify, "verify", N_("verify a signature")),
|
|
|
|
ARGPARSE_c (aListKeys, "list-keys", N_("list keys")),
|
|
|
|
ARGPARSE_c (aListExternalKeys, "list-external-keys",
|
|
|
|
N_("list external keys")),
|
|
|
|
ARGPARSE_c (aListSecretKeys, "list-secret-keys", N_("list secret keys")),
|
|
|
|
ARGPARSE_c (aListChain, "list-chain", N_("list certificate chain")),
|
|
|
|
ARGPARSE_c (aFingerprint, "fingerprint", N_("list keys and fingerprints")),
|
2009-07-07 10:02:41 +00:00
|
|
|
ARGPARSE_c (aKeygen, "gen-key", N_("generate a new key pair")),
|
2008-11-13 12:37:45 +00:00
|
|
|
ARGPARSE_c (aDeleteKey, "delete-keys",
|
|
|
|
N_("remove keys from the public keyring")),
|
|
|
|
ARGPARSE_c (aSendKeys, "send-keys", N_("export keys to a key server")),
|
|
|
|
ARGPARSE_c (aRecvKeys, "recv-keys", N_("import keys from a key server")),
|
|
|
|
ARGPARSE_c (aImport, "import", N_("import certificates")),
|
|
|
|
ARGPARSE_c (aExport, "export", N_("export certificates")),
|
|
|
|
ARGPARSE_c (aExportSecretKeyP12, "export-secret-key-p12", "@"),
|
|
|
|
ARGPARSE_c (aLearnCard, "learn-card", N_("register a smartcard")),
|
|
|
|
ARGPARSE_c (aServer, "server", N_("run in server mode")),
|
|
|
|
ARGPARSE_c (aCallDirmngr, "call-dirmngr",
|
|
|
|
N_("pass a command to the dirmngr")),
|
|
|
|
ARGPARSE_c (aCallProtectTool, "call-protect-tool",
|
|
|
|
N_("invoke gpg-protect-tool")),
|
|
|
|
ARGPARSE_c (aPasswd, "passwd", N_("change a passphrase")),
|
|
|
|
ARGPARSE_c (aGPGConfList, "gpgconf-list", "@"),
|
|
|
|
ARGPARSE_c (aGPGConfTest, "gpgconf-test", "@"),
|
|
|
|
|
|
|
|
ARGPARSE_c (aDumpKeys, "dump-cert", "@"),
|
|
|
|
ARGPARSE_c (aDumpKeys, "dump-keys", "@"),
|
|
|
|
ARGPARSE_c (aDumpChain, "dump-chain", "@"),
|
|
|
|
ARGPARSE_c (aDumpExternalKeys, "dump-external-keys", "@"),
|
|
|
|
ARGPARSE_c (aDumpSecretKeys, "dump-secret-keys", "@"),
|
|
|
|
ARGPARSE_c (aKeydbClearSomeCertFlags, "keydb-clear-some-cert-flags", "@"),
|
|
|
|
|
|
|
|
ARGPARSE_group (301, N_("@\nOptions:\n ")),
|
|
|
|
|
|
|
|
ARGPARSE_s_n (oArmor, "armor", N_("create ascii armored output")),
|
|
|
|
ARGPARSE_s_n (oArmor, "armour", "@"),
|
|
|
|
ARGPARSE_s_n (oBase64, "base64", N_("create base-64 encoded output")),
|
|
|
|
|
|
|
|
ARGPARSE_s_s (oP12Charset, "p12-charset", "@"),
|
|
|
|
|
|
|
|
ARGPARSE_s_n (oAssumeArmor, "assume-armor",
|
|
|
|
N_("assume input is in PEM format")),
|
|
|
|
ARGPARSE_s_n (oAssumeBase64, "assume-base64",
|
|
|
|
N_("assume input is in base-64 format")),
|
|
|
|
ARGPARSE_s_n (oAssumeBinary, "assume-binary",
|
|
|
|
N_("assume input is in binary format")),
|
|
|
|
|
|
|
|
ARGPARSE_s_s (oRecipient, "recipient", N_("|USER-ID|encrypt for USER-ID")),
|
|
|
|
|
2010-08-16 11:03:43 +00:00
|
|
|
ARGPARSE_s_n (oPreferSystemDirmngr,"prefer-system-dirmngr", "@"),
|
2008-11-13 12:37:45 +00:00
|
|
|
|
|
|
|
ARGPARSE_s_n (oDisableCRLChecks, "disable-crl-checks",
|
|
|
|
N_("never consult a CRL")),
|
|
|
|
ARGPARSE_s_n (oEnableCRLChecks, "enable-crl-checks", "@"),
|
|
|
|
ARGPARSE_s_n (oDisableTrustedCertCRLCheck,
|
|
|
|
"disable-trusted-cert-crl-check", "@"),
|
|
|
|
ARGPARSE_s_n (oEnableTrustedCertCRLCheck,
|
|
|
|
"enable-trusted-cert-crl-check", "@"),
|
|
|
|
|
|
|
|
ARGPARSE_s_n (oForceCRLRefresh, "force-crl-refresh", "@"),
|
|
|
|
|
|
|
|
ARGPARSE_s_n (oDisableOCSP, "disable-ocsp", "@"),
|
|
|
|
ARGPARSE_s_n (oEnableOCSP, "enable-ocsp", N_("check validity using OCSP")),
|
|
|
|
|
|
|
|
ARGPARSE_s_s (oValidationModel, "validation-model", "@"),
|
|
|
|
|
|
|
|
ARGPARSE_s_i (oIncludeCerts, "include-certs",
|
|
|
|
N_("|N|number of certificates to include") ),
|
|
|
|
|
|
|
|
ARGPARSE_s_s (oPolicyFile, "policy-file",
|
|
|
|
N_("|FILE|take policy information from FILE")),
|
|
|
|
|
|
|
|
ARGPARSE_s_n (oDisablePolicyChecks, "disable-policy-checks",
|
|
|
|
N_("do not check certificate policies")),
|
|
|
|
ARGPARSE_s_n (oEnablePolicyChecks, "enable-policy-checks", "@"),
|
|
|
|
|
|
|
|
ARGPARSE_s_n (oAutoIssuerKeyRetrieve, "auto-issuer-key-retrieve",
|
|
|
|
N_("fetch missing issuer certificates")),
|
|
|
|
|
|
|
|
ARGPARSE_s_s (oEncryptTo, "encrypt-to", "@"),
|
|
|
|
ARGPARSE_s_n (oNoEncryptTo, "no-encrypt-to", "@"),
|
|
|
|
|
|
|
|
ARGPARSE_s_s (oUser, "local-user",
|
|
|
|
N_("|USER-ID|use USER-ID to sign or decrypt")),
|
|
|
|
|
|
|
|
ARGPARSE_s_s (oOutput, "output", N_("|FILE|write output to FILE")),
|
|
|
|
ARGPARSE_s_n (oVerbose, "verbose", N_("verbose")),
|
|
|
|
ARGPARSE_s_n (oQuiet, "quiet", N_("be somewhat more quiet")),
|
|
|
|
ARGPARSE_s_n (oNoTTY, "no-tty", N_("don't use the terminal at all")),
|
|
|
|
ARGPARSE_s_s (oLogFile, "log-file",
|
|
|
|
N_("|FILE|write a server mode log to FILE")),
|
|
|
|
ARGPARSE_s_n (oNoLogFile, "no-log-file", "@"),
|
|
|
|
ARGPARSE_s_i (oLoggerFD, "logger-fd", "@"),
|
|
|
|
|
|
|
|
ARGPARSE_s_s (oAuditLog, "audit-log",
|
|
|
|
N_("|FILE|write an audit log to FILE")),
|
2010-10-01 20:33:53 +00:00
|
|
|
ARGPARSE_s_s (oHtmlAuditLog, "html-audit-log", "@"),
|
2008-11-13 12:37:45 +00:00
|
|
|
ARGPARSE_s_n (oDryRun, "dry-run", N_("do not make any changes")),
|
|
|
|
ARGPARSE_s_n (oBatch, "batch", N_("batch mode: never ask")),
|
|
|
|
ARGPARSE_s_n (oAnswerYes, "yes", N_("assume yes on most questions")),
|
|
|
|
ARGPARSE_s_n (oAnswerNo, "no", N_("assume no on most questions")),
|
|
|
|
|
|
|
|
ARGPARSE_s_s (oKeyring, "keyring",
|
|
|
|
N_("|FILE|add keyring to the list of keyrings")),
|
|
|
|
|
|
|
|
ARGPARSE_s_s (oDefaultKey, "default-key",
|
|
|
|
N_("|USER-ID|use USER-ID as default secret key")),
|
|
|
|
|
|
|
|
/* Not yet used: */
|
|
|
|
/* ARGPARSE_s_s (oDefRecipient, "default-recipient", */
|
|
|
|
/* N_("|NAME|use NAME as default recipient")), */
|
|
|
|
/* ARGPARSE_s_n (oDefRecipientSelf, "default-recipient-self", */
|
|
|
|
/* N_("use the default key as default recipient")), */
|
|
|
|
/* ARGPARSE_s_n (oNoDefRecipient, "no-default-recipient", "@"), */
|
|
|
|
|
|
|
|
ARGPARSE_s_s (oKeyServer, "keyserver",
|
|
|
|
N_("|SPEC|use this keyserver to lookup keys")),
|
|
|
|
ARGPARSE_s_s (oOptions, "options", N_("|FILE|read options from FILE")),
|
|
|
|
|
|
|
|
ARGPARSE_p_u (oDebug, "debug", "@"),
|
|
|
|
ARGPARSE_s_s (oDebugLevel, "debug-level",
|
|
|
|
N_("|LEVEL|set the debugging level to LEVEL")),
|
|
|
|
ARGPARSE_s_n (oDebugAll, "debug-all", "@"),
|
|
|
|
ARGPARSE_s_n (oDebugNone, "debug-none", "@"),
|
|
|
|
ARGPARSE_s_i (oDebugWait, "debug-wait", "@"),
|
|
|
|
ARGPARSE_s_n (oDebugAllowCoreDump, "debug-allow-core-dump", "@"),
|
|
|
|
ARGPARSE_s_n (oDebugNoChainValidation, "debug-no-chain-validation", "@"),
|
|
|
|
ARGPARSE_s_n (oDebugIgnoreExpiration, "debug-ignore-expiration", "@"),
|
|
|
|
ARGPARSE_s_s (oFixedPassphrase, "fixed-passphrase", "@"),
|
|
|
|
|
|
|
|
ARGPARSE_s_i (oStatusFD, "status-fd",
|
|
|
|
N_("|FD|write status info to this FD")),
|
|
|
|
|
|
|
|
ARGPARSE_s_s (oCipherAlgo, "cipher-algo",
|
|
|
|
N_("|NAME|use cipher algorithm NAME")),
|
|
|
|
ARGPARSE_s_s (oDigestAlgo, "digest-algo",
|
|
|
|
N_("|NAME|use message digest algorithm NAME")),
|
|
|
|
ARGPARSE_s_s (oExtraDigestAlgo, "extra-digest-algo", "@"),
|
2004-02-19 16:26:32 +00:00
|
|
|
|
2003-08-05 17:11:04 +00:00
|
|
|
|
2008-11-13 12:37:45 +00:00
|
|
|
ARGPARSE_group (302, N_(
|
2003-08-05 17:11:04 +00:00
|
|
|
"@\n(See the man page for a complete listing of all commands and options)\n"
|
2008-11-13 12:37:45 +00:00
|
|
|
)),
|
2003-08-05 17:11:04 +00:00
|
|
|
|
2008-11-13 12:37:45 +00:00
|
|
|
ARGPARSE_group (303, N_("@\nExamples:\n\n"
|
2003-08-05 17:11:04 +00:00
|
|
|
" -se -r Bob [file] sign and encrypt for user Bob\n"
|
|
|
|
" --clearsign [file] make a clear text signature\n"
|
|
|
|
" --detach-sign [file] make a detached signature\n"
|
|
|
|
" --list-keys [names] show keys\n"
|
2008-11-13 12:37:45 +00:00
|
|
|
" --fingerprint [names] show fingerprints\n" )),
|
|
|
|
|
|
|
|
/* Hidden options. */
|
|
|
|
ARGPARSE_s_n (oNoVerbose, "no-verbose", "@"),
|
|
|
|
ARGPARSE_s_n (oEnableSpecialFilenames, "enable-special-filenames", "@"),
|
|
|
|
ARGPARSE_s_n (oNoSecmemWarn, "no-secmem-warning", "@"),
|
|
|
|
ARGPARSE_s_n (oNoArmor, "no-armor", "@"),
|
|
|
|
ARGPARSE_s_n (oNoArmor, "no-armour", "@"),
|
|
|
|
ARGPARSE_s_n (oNoDefKeyring, "no-default-keyring", "@"),
|
|
|
|
ARGPARSE_s_n (oNoGreeting, "no-greeting", "@"),
|
|
|
|
ARGPARSE_s_n (oNoOptions, "no-options", "@"),
|
|
|
|
ARGPARSE_s_s (oHomedir, "homedir", "@"),
|
|
|
|
ARGPARSE_s_s (oAgentProgram, "agent-program", "@"),
|
|
|
|
ARGPARSE_s_s (oDisplay, "display", "@"),
|
|
|
|
ARGPARSE_s_s (oTTYname, "ttyname", "@"),
|
|
|
|
ARGPARSE_s_s (oTTYtype, "ttytype", "@"),
|
|
|
|
ARGPARSE_s_s (oLCctype, "lc-ctype", "@"),
|
|
|
|
ARGPARSE_s_s (oLCmessages, "lc-messages", "@"),
|
|
|
|
ARGPARSE_s_s (oXauthority, "xauthority", "@"),
|
|
|
|
ARGPARSE_s_s (oDirmngrProgram, "dirmngr-program", "@"),
|
|
|
|
ARGPARSE_s_n (oDisableDirmngr, "disable-dirmngr", "@"),
|
|
|
|
ARGPARSE_s_s (oProtectToolProgram, "protect-tool-program", "@"),
|
|
|
|
ARGPARSE_s_s (oFakedSystemTime, "faked-system-time", "@"),
|
|
|
|
ARGPARSE_s_n (oNoBatch, "no-batch", "@"),
|
|
|
|
ARGPARSE_s_n (oWithColons, "with-colons", "@"),
|
|
|
|
ARGPARSE_s_n (oWithKeyData,"with-key-data", "@"),
|
|
|
|
ARGPARSE_s_n (oWithValidation, "with-validation", "@"),
|
|
|
|
ARGPARSE_s_n (oWithMD5Fingerprint, "with-md5-fingerprint", "@"),
|
|
|
|
ARGPARSE_s_n (oWithEphemeralKeys, "with-ephemeral-keys", "@"),
|
|
|
|
ARGPARSE_s_n (oSkipVerify, "skip-verify", "@"),
|
|
|
|
ARGPARSE_s_n (oWithFingerprint, "with-fingerprint", "@"),
|
2010-10-08 11:11:08 +00:00
|
|
|
ARGPARSE_s_n (oWithKeygrip, "with-keygrip", "@"),
|
2008-11-13 12:37:45 +00:00
|
|
|
ARGPARSE_s_s (oDisableCipherAlgo, "disable-cipher-algo", "@"),
|
|
|
|
ARGPARSE_s_s (oDisablePubkeyAlgo, "disable-pubkey-algo", "@"),
|
|
|
|
ARGPARSE_s_n (oIgnoreTimeConflict, "ignore-time-conflict", "@"),
|
|
|
|
ARGPARSE_s_n (oNoRandomSeedFile, "no-random-seed-file", "@"),
|
|
|
|
ARGPARSE_s_n (oNoCommonCertsImport, "no-common-certs-import", "@"),
|
2009-12-10 13:00:30 +00:00
|
|
|
ARGPARSE_s_s (oIgnoreCertExtension, "ignore-cert-extension", "@"),
|
2008-11-13 12:37:45 +00:00
|
|
|
|
|
|
|
/* Command aliases. */
|
|
|
|
ARGPARSE_c (aListKeys, "list-key", "@"),
|
|
|
|
ARGPARSE_c (aListChain, "list-sig", "@"),
|
|
|
|
ARGPARSE_c (aListChain, "list-sigs", "@"),
|
|
|
|
ARGPARSE_c (aListChain, "check-sig", "@"),
|
|
|
|
ARGPARSE_c (aListChain, "check-sigs", "@"),
|
|
|
|
ARGPARSE_c (aDeleteKey, "delete-key", "@"),
|
|
|
|
|
|
|
|
ARGPARSE_end ()
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Global variable to keep an error count. */
|
2003-08-05 17:11:04 +00:00
|
|
|
int gpgsm_errors_seen = 0;
|
|
|
|
|
|
|
|
/* It is possible that we are currentlu running under setuid permissions */
|
|
|
|
static int maybe_setuid = 1;
|
|
|
|
|
2004-12-02 07:48:09 +00:00
|
|
|
/* Helper to implement --debug-level and --debug*/
|
|
|
|
static const char *debug_level;
|
|
|
|
static unsigned int debug_value;
|
|
|
|
|
2003-08-05 17:11:04 +00:00
|
|
|
/* Option --enable-special-filenames */
|
|
|
|
static int allow_special_filenames;
|
|
|
|
|
2009-10-19 09:18:46 +00:00
|
|
|
/* Default value for include-certs. We need an extra macro for
|
|
|
|
gpgconf-list because the variable will be changed by the command
|
|
|
|
line option.
|
|
|
|
|
|
|
|
It is often cumbersome to locate intermediate certificates, thus by
|
|
|
|
default we include all certificates in the chain. However we leave
|
|
|
|
out the root certificate because that would make it too easy for
|
|
|
|
the recipient to import that root certificate. A root certificate
|
|
|
|
should be installed only after due checks and thus it won't help to
|
|
|
|
send it along with each message. */
|
|
|
|
#define DEFAULT_INCLUDE_CERTS -2 /* Include all certs but root. */
|
|
|
|
static int default_include_certs = DEFAULT_INCLUDE_CERTS;
|
2006-06-20 17:21:37 +00:00
|
|
|
|
2007-08-10 16:52:05 +00:00
|
|
|
/* Whether the chain mode shall be used for validation. */
|
|
|
|
static int default_validation_model;
|
2006-06-20 17:21:37 +00:00
|
|
|
|
2009-10-19 09:18:46 +00:00
|
|
|
/* The default cipher algo. */
|
|
|
|
#define DEFAULT_CIPHER_ALGO "3DES" /*des-EDE3-CBC*/
|
|
|
|
|
2003-08-05 17:11:04 +00:00
|
|
|
|
|
|
|
static char *build_list (const char *text,
|
|
|
|
const char *(*mapf)(int), int (*chkf)(int));
|
|
|
|
static void set_cmd (enum cmd_and_opt_values *ret_cmd,
|
|
|
|
enum cmd_and_opt_values new_cmd );
|
|
|
|
|
|
|
|
static void emergency_cleanup (void);
|
2007-06-25 11:54:43 +00:00
|
|
|
static int check_special_filename (const char *fname, int for_write);
|
2003-08-05 17:11:04 +00:00
|
|
|
static int open_read (const char *filename);
|
2010-04-14 11:24:02 +00:00
|
|
|
static estream_t open_es_fread (const char *filename, const char *mode);
|
2007-03-19 14:35:04 +00:00
|
|
|
static estream_t open_es_fwrite (const char *filename);
|
2003-08-05 17:11:04 +00:00
|
|
|
static void run_protect_tool (int argc, char **argv);
|
|
|
|
|
|
|
|
static int
|
|
|
|
our_pk_test_algo (int algo)
|
|
|
|
{
|
2007-08-14 16:50:27 +00:00
|
|
|
switch (algo)
|
|
|
|
{
|
|
|
|
case GCRY_PK_RSA:
|
2008-09-29 15:02:55 +00:00
|
|
|
case GCRY_PK_ECDSA:
|
2007-08-14 16:50:27 +00:00
|
|
|
return gcry_pk_test_algo (algo);
|
|
|
|
default:
|
|
|
|
return 1;
|
|
|
|
}
|
2003-08-05 17:11:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
our_cipher_test_algo (int algo)
|
|
|
|
{
|
2007-08-14 16:50:27 +00:00
|
|
|
switch (algo)
|
|
|
|
{
|
|
|
|
case GCRY_CIPHER_3DES:
|
|
|
|
case GCRY_CIPHER_AES128:
|
|
|
|
case GCRY_CIPHER_AES192:
|
|
|
|
case GCRY_CIPHER_AES256:
|
|
|
|
case GCRY_CIPHER_SERPENT128:
|
|
|
|
case GCRY_CIPHER_SERPENT192:
|
|
|
|
case GCRY_CIPHER_SERPENT256:
|
2008-12-10 10:57:47 +00:00
|
|
|
case GCRY_CIPHER_SEED:
|
|
|
|
case GCRY_CIPHER_CAMELLIA128:
|
|
|
|
case GCRY_CIPHER_CAMELLIA192:
|
|
|
|
case GCRY_CIPHER_CAMELLIA256:
|
2007-08-14 16:50:27 +00:00
|
|
|
return gcry_cipher_test_algo (algo);
|
|
|
|
default:
|
|
|
|
return 1;
|
|
|
|
}
|
2003-08-05 17:11:04 +00:00
|
|
|
}
|
|
|
|
|
2007-08-14 16:50:27 +00:00
|
|
|
|
2003-08-05 17:11:04 +00:00
|
|
|
static int
|
|
|
|
our_md_test_algo (int algo)
|
|
|
|
{
|
2007-08-14 16:50:27 +00:00
|
|
|
switch (algo)
|
|
|
|
{
|
|
|
|
case GCRY_MD_MD5:
|
|
|
|
case GCRY_MD_SHA1:
|
|
|
|
case GCRY_MD_RMD160:
|
2008-12-10 10:57:47 +00:00
|
|
|
case GCRY_MD_SHA224:
|
2007-08-14 16:50:27 +00:00
|
|
|
case GCRY_MD_SHA256:
|
|
|
|
case GCRY_MD_SHA384:
|
|
|
|
case GCRY_MD_SHA512:
|
2008-12-10 10:57:47 +00:00
|
|
|
case GCRY_MD_WHIRLPOOL:
|
2007-08-14 16:50:27 +00:00
|
|
|
return gcry_md_test_algo (algo);
|
|
|
|
default:
|
|
|
|
return 1;
|
|
|
|
}
|
2003-08-05 17:11:04 +00:00
|
|
|
}
|
|
|
|
|
2007-08-14 16:50:27 +00:00
|
|
|
|
2008-11-18 18:01:03 +00:00
|
|
|
static char *
|
|
|
|
make_libversion (const char *libname, const char *(*getfnc)(const char*))
|
|
|
|
{
|
|
|
|
const char *s;
|
|
|
|
char *result;
|
|
|
|
|
|
|
|
if (maybe_setuid)
|
|
|
|
{
|
|
|
|
gcry_control (GCRYCTL_INIT_SECMEM, 0, 0); /* Drop setuid. */
|
|
|
|
maybe_setuid = 0;
|
|
|
|
}
|
|
|
|
s = getfnc (NULL);
|
|
|
|
result = xmalloc (strlen (libname) + 1 + strlen (s) + 1);
|
|
|
|
strcpy (stpcpy (stpcpy (result, libname), " "), s);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2003-08-05 17:11:04 +00:00
|
|
|
static const char *
|
|
|
|
my_strusage( int level )
|
|
|
|
{
|
2008-11-18 18:01:03 +00:00
|
|
|
static char *digests, *pubkeys, *ciphers;
|
|
|
|
static char *ver_gcry, *ver_ksba;
|
2003-08-05 17:11:04 +00:00
|
|
|
const char *p;
|
|
|
|
|
|
|
|
switch (level)
|
|
|
|
{
|
|
|
|
case 11: p = "gpgsm (GnuPG)";
|
|
|
|
break;
|
|
|
|
case 13: p = VERSION; break;
|
|
|
|
case 17: p = PRINTABLE_OS_NAME; break;
|
2009-07-21 14:21:05 +00:00
|
|
|
case 19: p = _("Please report bugs to <@EMAIL@>.\n"); break;
|
|
|
|
|
2003-08-05 17:11:04 +00:00
|
|
|
case 1:
|
|
|
|
case 40: p = _("Usage: gpgsm [options] [files] (-h for help)");
|
|
|
|
break;
|
|
|
|
case 41:
|
|
|
|
p = _("Syntax: gpgsm [options] [files]\n"
|
|
|
|
"sign, check, encrypt or decrypt using the S/MIME protocol\n"
|
|
|
|
"default operation depends on the input data\n");
|
|
|
|
break;
|
|
|
|
|
2008-11-18 18:01:03 +00:00
|
|
|
case 20:
|
|
|
|
if (!ver_gcry)
|
|
|
|
ver_gcry = make_libversion ("libgcrypt", gcry_check_version);
|
|
|
|
p = ver_gcry;
|
|
|
|
break;
|
|
|
|
case 21:
|
|
|
|
if (!ver_ksba)
|
|
|
|
ver_ksba = make_libversion ("libksba", ksba_check_version);
|
|
|
|
p = ver_ksba;
|
|
|
|
break;
|
|
|
|
|
2003-08-05 17:11:04 +00:00
|
|
|
case 31: p = "\nHome: "; break;
|
|
|
|
case 32: p = opt.homedir; break;
|
|
|
|
case 33: p = _("\nSupported algorithms:\n"); break;
|
|
|
|
case 34:
|
|
|
|
if (!ciphers)
|
|
|
|
ciphers = build_list ("Cipher: ", gcry_cipher_algo_name,
|
|
|
|
our_cipher_test_algo );
|
|
|
|
p = ciphers;
|
|
|
|
break;
|
|
|
|
case 35:
|
|
|
|
if (!pubkeys)
|
|
|
|
pubkeys = build_list ("Pubkey: ", gcry_pk_algo_name,
|
|
|
|
our_pk_test_algo );
|
|
|
|
p = pubkeys;
|
|
|
|
break;
|
|
|
|
case 36:
|
|
|
|
if (!digests)
|
|
|
|
digests = build_list("Hash: ", gcry_md_algo_name, our_md_test_algo );
|
|
|
|
p = digests;
|
|
|
|
break;
|
2007-09-14 13:38:36 +00:00
|
|
|
|
2003-08-05 17:11:04 +00:00
|
|
|
default: p = NULL; break;
|
|
|
|
}
|
|
|
|
return p;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static char *
|
|
|
|
build_list (const char *text, const char * (*mapf)(int), int (*chkf)(int))
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
size_t n=strlen(text)+2;
|
|
|
|
char *list, *p;
|
|
|
|
|
|
|
|
if (maybe_setuid) {
|
|
|
|
gcry_control (GCRYCTL_DROP_PRIVS); /* drop setuid */
|
|
|
|
}
|
|
|
|
|
2007-08-14 16:50:27 +00:00
|
|
|
for (i=1; i < 400; i++ )
|
2003-08-05 17:11:04 +00:00
|
|
|
if (!chkf(i))
|
|
|
|
n += strlen(mapf(i)) + 2;
|
|
|
|
list = xmalloc (21 + n);
|
|
|
|
*list = 0;
|
2007-08-14 16:50:27 +00:00
|
|
|
for (p=NULL, i=1; i < 400; i++)
|
2003-08-05 17:11:04 +00:00
|
|
|
{
|
|
|
|
if (!chkf(i))
|
|
|
|
{
|
|
|
|
if( !p )
|
|
|
|
p = stpcpy (list, text );
|
|
|
|
else
|
|
|
|
p = stpcpy (p, ", ");
|
|
|
|
p = stpcpy (p, mapf(i) );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (p)
|
|
|
|
p = stpcpy(p, "\n" );
|
|
|
|
return list;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2004-12-22 17:55:28 +00:00
|
|
|
/* Set the file pointer into binary mode if required. */
|
|
|
|
static void
|
|
|
|
set_binary (FILE *fp)
|
|
|
|
{
|
|
|
|
#ifdef HAVE_DOSISH_SYSTEM
|
|
|
|
setmode (fileno (fp), O_BINARY);
|
2008-10-20 13:53:23 +00:00
|
|
|
#else
|
|
|
|
(void)fp;
|
2004-12-22 17:55:28 +00:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2003-08-05 17:11:04 +00:00
|
|
|
static void
|
|
|
|
wrong_args (const char *text)
|
|
|
|
{
|
|
|
|
fputs (_("usage: gpgsm [options] "), stderr);
|
|
|
|
fputs (text, stderr);
|
|
|
|
putc ('\n', stderr);
|
|
|
|
gpgsm_exit (2);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-07-07 10:02:41 +00:00
|
|
|
static void
|
|
|
|
set_opt_session_env (const char *name, const char *value)
|
|
|
|
{
|
|
|
|
gpg_error_t err;
|
|
|
|
|
|
|
|
err = session_env_setenv (opt.session_env, name, value);
|
|
|
|
if (err)
|
|
|
|
log_fatal ("error setting session environment: %s\n",
|
|
|
|
gpg_strerror (err));
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2004-12-02 07:48:09 +00:00
|
|
|
/* Setup the debugging. With a DEBUG_LEVEL of NULL only the active
|
|
|
|
debug flags are propagated to the subsystems. With DEBUG_LEVEL
|
|
|
|
set, a specific set of debug flags is set; and individual debugging
|
|
|
|
flags will be added on top. */
|
2003-08-05 17:11:04 +00:00
|
|
|
static void
|
2004-12-02 07:48:09 +00:00
|
|
|
set_debug (void)
|
2003-08-05 17:11:04 +00:00
|
|
|
{
|
2009-12-03 18:04:40 +00:00
|
|
|
int numok = (debug_level && digitp (debug_level));
|
|
|
|
int numlvl = numok? atoi (debug_level) : 0;
|
|
|
|
|
2004-12-02 07:48:09 +00:00
|
|
|
if (!debug_level)
|
2004-02-18 17:00:21 +00:00
|
|
|
;
|
2009-12-03 18:04:40 +00:00
|
|
|
else if (!strcmp (debug_level, "none") || (numok && numlvl < 1))
|
2004-02-18 17:00:21 +00:00
|
|
|
opt.debug = 0;
|
2009-12-03 18:04:40 +00:00
|
|
|
else if (!strcmp (debug_level, "basic") || (numok && numlvl <= 2))
|
2004-02-18 17:00:21 +00:00
|
|
|
opt.debug = DBG_ASSUAN_VALUE;
|
2009-12-03 18:04:40 +00:00
|
|
|
else if (!strcmp (debug_level, "advanced") || (numok && numlvl <= 5))
|
2004-02-18 17:00:21 +00:00
|
|
|
opt.debug = DBG_ASSUAN_VALUE|DBG_X509_VALUE;
|
2009-12-03 18:04:40 +00:00
|
|
|
else if (!strcmp (debug_level, "expert") || (numok && numlvl <= 8))
|
2004-02-18 17:00:21 +00:00
|
|
|
opt.debug = (DBG_ASSUAN_VALUE|DBG_X509_VALUE
|
|
|
|
|DBG_CACHE_VALUE|DBG_CRYPTO_VALUE);
|
2009-12-03 18:04:40 +00:00
|
|
|
else if (!strcmp (debug_level, "guru") || numok)
|
|
|
|
{
|
|
|
|
opt.debug = ~0;
|
|
|
|
/* Unless the "guru" string has been used we don't want to allow
|
|
|
|
hashing debugging. The rationale is that people tend to
|
|
|
|
select the highest debug value and would then clutter their
|
|
|
|
disk with debug files which may reveal confidential data. */
|
|
|
|
if (numok)
|
|
|
|
opt.debug &= ~(DBG_HASHING_VALUE);
|
|
|
|
}
|
2004-02-18 17:00:21 +00:00
|
|
|
else
|
|
|
|
{
|
2004-12-02 07:48:09 +00:00
|
|
|
log_error (_("invalid debug-level `%s' given\n"), debug_level);
|
2009-12-03 18:04:40 +00:00
|
|
|
gpgsm_exit (2);
|
2004-02-18 17:00:21 +00:00
|
|
|
}
|
|
|
|
|
2004-12-02 07:48:09 +00:00
|
|
|
opt.debug |= debug_value;
|
2004-02-18 17:00:21 +00:00
|
|
|
|
|
|
|
if (opt.debug && !opt.verbose)
|
2004-12-02 07:48:09 +00:00
|
|
|
opt.verbose = 1;
|
|
|
|
if (opt.debug)
|
2004-02-18 17:00:21 +00:00
|
|
|
opt.quiet = 0;
|
|
|
|
|
2003-08-05 17:11:04 +00:00
|
|
|
if (opt.debug & DBG_MPI_VALUE)
|
|
|
|
gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 2);
|
|
|
|
if (opt.debug & DBG_CRYPTO_VALUE )
|
|
|
|
gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1);
|
2004-12-02 07:48:09 +00:00
|
|
|
gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
|
2009-12-03 18:04:40 +00:00
|
|
|
|
|
|
|
if (opt.debug)
|
|
|
|
log_info ("enabled debug flags:%s%s%s%s%s%s%s%s\n",
|
|
|
|
(opt.debug & DBG_X509_VALUE )? " x509":"",
|
|
|
|
(opt.debug & DBG_MPI_VALUE )? " mpi":"",
|
|
|
|
(opt.debug & DBG_CRYPTO_VALUE )? " crypto":"",
|
|
|
|
(opt.debug & DBG_MEMORY_VALUE )? " memory":"",
|
|
|
|
(opt.debug & DBG_CACHE_VALUE )? " cache":"",
|
|
|
|
(opt.debug & DBG_MEMSTAT_VALUE)? " memstat":"",
|
|
|
|
(opt.debug & DBG_HASHING_VALUE)? " hashing":"",
|
|
|
|
(opt.debug & DBG_ASSUAN_VALUE )? " assuan":"" );
|
2003-08-05 17:11:04 +00:00
|
|
|
}
|
2004-02-18 17:00:21 +00:00
|
|
|
|
2003-08-05 17:11:04 +00:00
|
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
set_cmd (enum cmd_and_opt_values *ret_cmd, enum cmd_and_opt_values new_cmd)
|
|
|
|
{
|
|
|
|
enum cmd_and_opt_values cmd = *ret_cmd;
|
|
|
|
|
|
|
|
if (!cmd || cmd == new_cmd)
|
|
|
|
cmd = new_cmd;
|
|
|
|
else if ( cmd == aSign && new_cmd == aEncr )
|
|
|
|
cmd = aSignEncr;
|
|
|
|
else if ( cmd == aEncr && new_cmd == aSign )
|
|
|
|
cmd = aSignEncr;
|
|
|
|
else if ( (cmd == aSign && new_cmd == aClearsign)
|
|
|
|
|| (cmd == aClearsign && new_cmd == aSign) )
|
|
|
|
cmd = aClearsign;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
log_error(_("conflicting commands\n"));
|
|
|
|
gpgsm_exit(2);
|
|
|
|
}
|
|
|
|
|
|
|
|
*ret_cmd = cmd;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2003-12-17 17:12:14 +00:00
|
|
|
/* Helper to add recipients to a list. */
|
|
|
|
static void
|
|
|
|
do_add_recipient (ctrl_t ctrl, const char *name,
|
2007-08-14 16:50:27 +00:00
|
|
|
certlist_t *recplist, int is_encrypt_to, int recp_required)
|
2003-12-17 17:12:14 +00:00
|
|
|
{
|
|
|
|
int rc = gpgsm_add_to_certlist (ctrl, name, 0, recplist, is_encrypt_to);
|
|
|
|
if (rc)
|
|
|
|
{
|
2007-08-14 16:50:27 +00:00
|
|
|
if (recp_required)
|
|
|
|
{
|
|
|
|
log_error ("can't encrypt to `%s': %s\n", name, gpg_strerror (rc));
|
|
|
|
gpgsm_status2 (ctrl, STATUS_INV_RECP,
|
2009-08-06 20:12:00 +00:00
|
|
|
get_inv_recpsgnr_code (rc), name, NULL);
|
2007-08-14 16:50:27 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
log_info (_("NOTE: won't be able to encrypt to `%s': %s\n"),
|
|
|
|
name, gpg_strerror (rc));
|
2003-12-17 17:12:14 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-08-10 16:52:05 +00:00
|
|
|
static void
|
|
|
|
parse_validation_model (const char *model)
|
|
|
|
{
|
|
|
|
int i = gpgsm_parse_validation_model (model);
|
|
|
|
if (i == -1)
|
|
|
|
log_error (_("unknown validation model `%s'\n"), model);
|
|
|
|
else
|
|
|
|
default_validation_model = i;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-06-12 14:24:46 +00:00
|
|
|
/* Release the list of SERVERS. As usual it is okay to call this
|
|
|
|
function with SERVERS passed as NULL. */
|
|
|
|
void
|
|
|
|
keyserver_list_free (struct keyserver_spec *servers)
|
|
|
|
{
|
|
|
|
while (servers)
|
|
|
|
{
|
|
|
|
struct keyserver_spec *tmp = servers->next;
|
|
|
|
xfree (servers->host);
|
|
|
|
xfree (servers->user);
|
|
|
|
if (servers->pass)
|
|
|
|
memset (servers->pass, 0, strlen (servers->pass));
|
|
|
|
xfree (servers->pass);
|
|
|
|
xfree (servers->base);
|
|
|
|
xfree (servers);
|
|
|
|
servers = tmp;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* See also dirmngr ldapserver_parse_one(). */
|
|
|
|
struct keyserver_spec *
|
|
|
|
parse_keyserver_line (char *line,
|
|
|
|
const char *filename, unsigned int lineno)
|
|
|
|
{
|
|
|
|
char *p;
|
|
|
|
char *endp;
|
|
|
|
struct keyserver_spec *server;
|
|
|
|
int fieldno;
|
|
|
|
int fail = 0;
|
|
|
|
|
|
|
|
/* Parse the colon separated fields. */
|
|
|
|
server = xcalloc (1, sizeof *server);
|
|
|
|
for (fieldno = 1, p = line; p; p = endp, fieldno++ )
|
|
|
|
{
|
|
|
|
endp = strchr (p, ':');
|
|
|
|
if (endp)
|
|
|
|
*endp++ = '\0';
|
|
|
|
trim_spaces (p);
|
|
|
|
switch (fieldno)
|
|
|
|
{
|
|
|
|
case 1:
|
|
|
|
if (*p)
|
|
|
|
server->host = xstrdup (p);
|
|
|
|
else
|
|
|
|
{
|
|
|
|
log_error (_("%s:%u: no hostname given\n"),
|
|
|
|
filename, lineno);
|
|
|
|
fail = 1;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 2:
|
|
|
|
if (*p)
|
|
|
|
server->port = atoi (p);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 3:
|
|
|
|
if (*p)
|
|
|
|
server->user = xstrdup (p);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 4:
|
|
|
|
if (*p && !server->user)
|
|
|
|
{
|
|
|
|
log_error (_("%s:%u: password given without user\n"),
|
|
|
|
filename, lineno);
|
|
|
|
fail = 1;
|
|
|
|
}
|
|
|
|
else if (*p)
|
|
|
|
server->pass = xstrdup (p);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 5:
|
|
|
|
if (*p)
|
|
|
|
server->base = xstrdup (p);
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
/* (We silently ignore extra fields.) */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (fail)
|
|
|
|
{
|
|
|
|
log_info (_("%s:%u: skipping this line\n"), filename, lineno);
|
|
|
|
keyserver_list_free (server);
|
|
|
|
}
|
|
|
|
|
|
|
|
return server;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2003-08-05 17:11:04 +00:00
|
|
|
int
|
|
|
|
main ( int argc, char **argv)
|
|
|
|
{
|
|
|
|
ARGPARSE_ARGS pargs;
|
|
|
|
int orig_argc;
|
|
|
|
char **orig_argv;
|
|
|
|
const char *fname;
|
|
|
|
/* char *username;*/
|
|
|
|
int may_coredump;
|
2006-10-02 11:54:35 +00:00
|
|
|
strlist_t sl, remusr= NULL, locusr=NULL;
|
|
|
|
strlist_t nrings=NULL;
|
2003-08-05 17:11:04 +00:00
|
|
|
int detached_sig = 0;
|
|
|
|
FILE *configfp = NULL;
|
|
|
|
char *configname = NULL;
|
|
|
|
unsigned configlineno;
|
|
|
|
int parse_debug = 0;
|
|
|
|
int no_more_options = 0;
|
|
|
|
int default_config =1;
|
|
|
|
int default_keyring = 1;
|
|
|
|
char *logfile = NULL;
|
2007-11-19 16:03:50 +00:00
|
|
|
char *auditlog = NULL;
|
2009-12-02 18:33:59 +00:00
|
|
|
char *htmlauditlog = NULL;
|
2003-08-05 17:11:04 +00:00
|
|
|
int greeting = 0;
|
|
|
|
int nogreeting = 0;
|
|
|
|
int debug_wait = 0;
|
|
|
|
int use_random_seed = 1;
|
2008-02-19 10:33:35 +00:00
|
|
|
int no_common_certs_import = 0;
|
2003-08-05 17:11:04 +00:00
|
|
|
int with_fpr = 0;
|
2009-03-26 19:27:04 +00:00
|
|
|
const char *forced_digest_algo = NULL;
|
|
|
|
const char *extra_digest_algo = NULL;
|
2003-08-05 17:11:04 +00:00
|
|
|
enum cmd_and_opt_values cmd = 0;
|
|
|
|
struct server_control_s ctrl;
|
2006-09-06 16:35:52 +00:00
|
|
|
certlist_t recplist = NULL;
|
|
|
|
certlist_t signerlist = NULL;
|
2004-02-18 17:00:21 +00:00
|
|
|
int do_not_setup_keys = 0;
|
2007-08-14 16:50:27 +00:00
|
|
|
int recp_required = 0;
|
2007-12-12 10:28:30 +00:00
|
|
|
estream_t auditfp = NULL;
|
2009-12-02 18:33:59 +00:00
|
|
|
estream_t htmlauditfp = NULL;
|
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* configure.ac (NEED_LIBASSUAN_API, NEED_LIBASSUAN_VERSION):
Update to new API (2, 1.1.0).
agent/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* gpg-agent.c (parse_rereadable_options): Don't set global assuan
log file (there ain't one anymore).
(main): Update to new API.
(check_own_socket_pid_cb): Return gpg_error_t instead of int.
(check_own_socket_thread, check_for_running_agent): Create assuan
context before connecting to server.
* command.c: Include "scdaemon.h" before <assuan.h> because of
GPG_ERR_SOURCE_DEFAULT check.
(write_and_clear_outbuf): Use gpg_error_t instead of
assuan_error_t.
(cmd_geteventcounter, cmd_istrusted, cmd_listtrusted)
(cmd_marktrusted, cmd_havekey, cmd_sigkey, cmd_setkeydesc)
(cmd_sethash, cmd_pksign, cmd_pkdecrypt, cmd_genkey, cmd_readkey)
(cmd_keyinfo, cmd_get_passphrase, cmd_clear_passphrase)
(cmd_get_confirmation, cmd_learn, cmd_passwd)
(cmd_preset_passphrase, cmd_scd, cmd_getval, cmd_putval)
(cmd_updatestartuptty, cmd_killagent, cmd_reloadagent)
(cmd_getinfo, option_handler): Return gpg_error_t instead of int.
(post_cmd_notify): Change type of ERR to gpg_error_t from int.
(io_monitor): Add hook argument. Use symbols for constants.
(register_commands): Change return type of HANDLER to gpg_error_t.
(start_command_handler): Allocate assuan context before starting
server.
* call-pinentry.c: Include "scdaemon.h" before <assuan.h> because
of GPG_ERR_SOURCE_DEFAULT check.
(unlock_pinentry): Call assuan_release instead of
assuan_disconnect.
(getinfo_pid_cb, getpin_cb): Return gpg_error_t instead of int.
(start_pinentry): Allocate assuan context before connecting to
server.
* call-scd.c (membuf_data_cb, learn_status_cb, get_serialno_cb)
(membuf_data_cb, inq_needpin, card_getattr_cb, pass_status_thru)
(pass_data_thru): Change return type to gpg_error_t.
(start_scd): Allocate assuan context before connecting to server.
common/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* asshelp.c (start_new_gpg_agent): Allocate assuan context before
starting server.
g10/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* call-agent.c: Include "scdaemon.h" before <assuan.h> because of
GPG_ERR_SOURCE_DEFAULT check.
(learn_status_cb, dummy_data_cb, get_serialno_cb, default_inq_cb)
(learn_status_cb, inq_writecert_parms, inq_writekey_parms)
(scd_genkey_cb, membuf_data_cb): Return gpg_error_t instead of
int.
* gpg.c: Include "scdaemon.h" before <assuan.h> because of
GPG_ERR_SOURCE_DEFAULT check.
(main): Update to new Assuan API.
* server.c: Include "scdaemon.h" before <assuan.h> because of
GPG_ERR_SOURCE_DEFAULT check.
(option_handler, cmd_recipient, cmd_signer, cmd_encrypt)
(cmd_decrypt, cmd_verify, cmd_sign, cmd_import, cmd_export)
(cmd_delkeys, cmd_message, do_listkeys, cmd_listkeys)
(cmd_listsecretkeys, cmd_genkey, cmd_getinfo): Return gpg_error_t
instead of int.
(register_commands): Allocate assuan context before starting
server.
(gpg_server): Allocate assuan_context before starting server.
scd/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* command.c: Include "scdaemon.h" before <assuan.h> because of
GPG_ERR_SOURCE_DEFAULT check.
(option_handler, open_card, cmd_serialno, cmd_lean, cmd_readcert)
(cmd_readkey, cmd_setdata, cmd_pksign, cmd_pkauth, cmd_pkdecrypt)
(cmd_getattr, cmd_setattr, cmd_writecert, cmd_writekey)
(cmd_genkey, cmd_random, cmd_passwd, cmd_checkpin, cmd_lock)
(cmd_unlock, cmd_getinfo, cmd_restart, cmd_disconnect, cmd_apdu)
(cmd_killscd): Return gpg_error_t instead of int.
(scd_command_handler): Allocate assuan context before starting server.
* scdaemon.c (main): Update to new Assuan API.
sm/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* gpgsm.c (main): Update to new assuan API.
* server.c: Include "gpgsm.h" before <assuan.h> due to check for
GPG_ERR_SOURCE_DEFAULT and assuan.h now including gpg-error.h.
(option_handler, cmd_recipient, cmd_signer, cmd_encrypt)
(cmd_decrypt, cmd_verify, cmd_sign, cmd_import, cmd_export)
(cmd_delkeys, cmd_message, cmd_listkeys, cmd_dumpkeys)
(cmd_listsecretkeys, cmd_dumpsecretkeys, cmd_genkey)
(cmd_getauditlog, cmd_getinfo): Return gpg_error_t instead of int.
(register_commands): Same for member HANDLER in table.
(gpgsm_server): Allocate assuan context before starting server.
* sm/call-dirmngr.c:
* call-dirmngr.c (prepare_dirmngr): Check for CTX and error before
setting LDAPSERVER.
(start_dirmngr_ext): Allocate assuan context before starting
server.
(inq_certificate, isvalid_status_cb, lookup_cb, lookup_status_cb)
(run_command_cb, run_command_inq_cb, run_command_status_cb):
Return gpg_error_t instead of int.
tools/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* gpg-connect-agent.c (getinfo_pid_cb, read_and_print_response)
(main): Update to new Assuan API.
2009-09-23 00:01:25 +00:00
|
|
|
struct assuan_malloc_hooks malloc_hooks;
|
2003-08-05 17:11:04 +00:00
|
|
|
|
2006-12-21 08:05:29 +00:00
|
|
|
/*mtrace();*/
|
2004-08-17 15:26:22 +00:00
|
|
|
|
2007-12-03 13:05:15 +00:00
|
|
|
gnupg_reopen_std ("gpgsm");
|
2003-08-05 17:11:04 +00:00
|
|
|
/* trap_unaligned ();*/
|
2007-06-26 13:48:44 +00:00
|
|
|
gnupg_rl_initialize ();
|
2003-08-05 17:11:04 +00:00
|
|
|
set_strusage (my_strusage);
|
|
|
|
gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
|
|
|
|
|
|
|
|
/* Please note that we may running SUID(ROOT), so be very CAREFUL
|
|
|
|
when adding any stuff between here and the call to secmem_init()
|
|
|
|
somewhere after the option parsing */
|
|
|
|
log_set_prefix ("gpgsm", 1);
|
2004-02-18 17:00:21 +00:00
|
|
|
|
2007-06-14 17:05:07 +00:00
|
|
|
/* Make sure that our subsystems are ready. */
|
2010-08-18 19:25:15 +00:00
|
|
|
i18n_init ();
|
2010-03-22 12:46:05 +00:00
|
|
|
init_common_subsystems (&argc, &argv);
|
2004-02-18 17:00:21 +00:00
|
|
|
|
|
|
|
/* Check that the libraries are suitable. Do it here because the
|
2003-08-05 17:11:04 +00:00
|
|
|
option parse may need services of the library */
|
|
|
|
if (!gcry_check_version (NEED_LIBGCRYPT_VERSION) )
|
2007-04-20 16:59:37 +00:00
|
|
|
log_fatal (_("%s is too old (need %s, have %s)\n"), "libgcrypt",
|
|
|
|
NEED_LIBGCRYPT_VERSION, gcry_check_version (NULL) );
|
2003-08-05 17:11:04 +00:00
|
|
|
if (!ksba_check_version (NEED_KSBA_VERSION) )
|
2007-04-20 16:59:37 +00:00
|
|
|
log_fatal (_("%s is too old (need %s, have %s)\n"), "libksba",
|
|
|
|
NEED_KSBA_VERSION, ksba_check_version (NULL) );
|
2003-08-05 17:11:04 +00:00
|
|
|
|
2004-12-15 14:15:54 +00:00
|
|
|
|
2003-08-05 17:11:04 +00:00
|
|
|
gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
|
|
|
|
|
|
|
|
may_coredump = disable_core_dumps ();
|
|
|
|
|
|
|
|
gnupg_init_signals (0, emergency_cleanup);
|
|
|
|
|
|
|
|
create_dotlock (NULL); /* register locking cleanup */
|
|
|
|
|
2009-07-07 10:02:41 +00:00
|
|
|
opt.session_env = session_env_new ();
|
|
|
|
if (!opt.session_env)
|
|
|
|
log_fatal ("error allocating session environment block: %s\n",
|
|
|
|
strerror (errno));
|
|
|
|
|
2008-12-10 10:57:47 +00:00
|
|
|
/* Note: If you change this default cipher algorithm , please
|
|
|
|
remember to update the Gpgconflist entry as well. */
|
2009-10-19 09:18:46 +00:00
|
|
|
opt.def_cipher_algoid = DEFAULT_CIPHER_ALGO;
|
2004-12-15 14:15:54 +00:00
|
|
|
|
2004-12-21 10:03:00 +00:00
|
|
|
opt.homedir = default_homedir ();
|
2003-08-05 17:11:04 +00:00
|
|
|
|
2010-04-14 11:24:02 +00:00
|
|
|
|
2004-12-21 10:03:00 +00:00
|
|
|
/* First check whether we have a config file on the commandline */
|
2003-08-05 17:11:04 +00:00
|
|
|
orig_argc = argc;
|
|
|
|
orig_argv = argv;
|
|
|
|
pargs.argc = &argc;
|
|
|
|
pargs.argv = &argv;
|
|
|
|
pargs.flags= 1|(1<<6); /* do not remove the args, ignore version */
|
|
|
|
while (arg_parse( &pargs, opts))
|
|
|
|
{
|
|
|
|
if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll)
|
|
|
|
parse_debug++;
|
|
|
|
else if (pargs.r_opt == oOptions)
|
|
|
|
{ /* yes there is one, so we do not try the default one but
|
|
|
|
read the config file when it is encountered at the
|
|
|
|
commandline */
|
|
|
|
default_config = 0;
|
|
|
|
}
|
|
|
|
else if (pargs.r_opt == oNoOptions)
|
|
|
|
default_config = 0; /* --no-options */
|
|
|
|
else if (pargs.r_opt == oHomedir)
|
|
|
|
opt.homedir = pargs.r.ret_str;
|
|
|
|
else if (pargs.r_opt == aCallProtectTool)
|
|
|
|
break; /* This break makes sure that --version and --help are
|
|
|
|
passed to the protect-tool. */
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-11-18 18:01:03 +00:00
|
|
|
/* Initialize the secure memory. */
|
2003-08-05 17:11:04 +00:00
|
|
|
gcry_control (GCRYCTL_INIT_SECMEM, 16384, 0);
|
|
|
|
maybe_setuid = 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
Now we are now working under our real uid
|
|
|
|
*/
|
|
|
|
|
|
|
|
ksba_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free );
|
2003-12-16 16:31:16 +00:00
|
|
|
|
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* configure.ac (NEED_LIBASSUAN_API, NEED_LIBASSUAN_VERSION):
Update to new API (2, 1.1.0).
agent/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* gpg-agent.c (parse_rereadable_options): Don't set global assuan
log file (there ain't one anymore).
(main): Update to new API.
(check_own_socket_pid_cb): Return gpg_error_t instead of int.
(check_own_socket_thread, check_for_running_agent): Create assuan
context before connecting to server.
* command.c: Include "scdaemon.h" before <assuan.h> because of
GPG_ERR_SOURCE_DEFAULT check.
(write_and_clear_outbuf): Use gpg_error_t instead of
assuan_error_t.
(cmd_geteventcounter, cmd_istrusted, cmd_listtrusted)
(cmd_marktrusted, cmd_havekey, cmd_sigkey, cmd_setkeydesc)
(cmd_sethash, cmd_pksign, cmd_pkdecrypt, cmd_genkey, cmd_readkey)
(cmd_keyinfo, cmd_get_passphrase, cmd_clear_passphrase)
(cmd_get_confirmation, cmd_learn, cmd_passwd)
(cmd_preset_passphrase, cmd_scd, cmd_getval, cmd_putval)
(cmd_updatestartuptty, cmd_killagent, cmd_reloadagent)
(cmd_getinfo, option_handler): Return gpg_error_t instead of int.
(post_cmd_notify): Change type of ERR to gpg_error_t from int.
(io_monitor): Add hook argument. Use symbols for constants.
(register_commands): Change return type of HANDLER to gpg_error_t.
(start_command_handler): Allocate assuan context before starting
server.
* call-pinentry.c: Include "scdaemon.h" before <assuan.h> because
of GPG_ERR_SOURCE_DEFAULT check.
(unlock_pinentry): Call assuan_release instead of
assuan_disconnect.
(getinfo_pid_cb, getpin_cb): Return gpg_error_t instead of int.
(start_pinentry): Allocate assuan context before connecting to
server.
* call-scd.c (membuf_data_cb, learn_status_cb, get_serialno_cb)
(membuf_data_cb, inq_needpin, card_getattr_cb, pass_status_thru)
(pass_data_thru): Change return type to gpg_error_t.
(start_scd): Allocate assuan context before connecting to server.
common/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* asshelp.c (start_new_gpg_agent): Allocate assuan context before
starting server.
g10/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* call-agent.c: Include "scdaemon.h" before <assuan.h> because of
GPG_ERR_SOURCE_DEFAULT check.
(learn_status_cb, dummy_data_cb, get_serialno_cb, default_inq_cb)
(learn_status_cb, inq_writecert_parms, inq_writekey_parms)
(scd_genkey_cb, membuf_data_cb): Return gpg_error_t instead of
int.
* gpg.c: Include "scdaemon.h" before <assuan.h> because of
GPG_ERR_SOURCE_DEFAULT check.
(main): Update to new Assuan API.
* server.c: Include "scdaemon.h" before <assuan.h> because of
GPG_ERR_SOURCE_DEFAULT check.
(option_handler, cmd_recipient, cmd_signer, cmd_encrypt)
(cmd_decrypt, cmd_verify, cmd_sign, cmd_import, cmd_export)
(cmd_delkeys, cmd_message, do_listkeys, cmd_listkeys)
(cmd_listsecretkeys, cmd_genkey, cmd_getinfo): Return gpg_error_t
instead of int.
(register_commands): Allocate assuan context before starting
server.
(gpg_server): Allocate assuan_context before starting server.
scd/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* command.c: Include "scdaemon.h" before <assuan.h> because of
GPG_ERR_SOURCE_DEFAULT check.
(option_handler, open_card, cmd_serialno, cmd_lean, cmd_readcert)
(cmd_readkey, cmd_setdata, cmd_pksign, cmd_pkauth, cmd_pkdecrypt)
(cmd_getattr, cmd_setattr, cmd_writecert, cmd_writekey)
(cmd_genkey, cmd_random, cmd_passwd, cmd_checkpin, cmd_lock)
(cmd_unlock, cmd_getinfo, cmd_restart, cmd_disconnect, cmd_apdu)
(cmd_killscd): Return gpg_error_t instead of int.
(scd_command_handler): Allocate assuan context before starting server.
* scdaemon.c (main): Update to new Assuan API.
sm/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* gpgsm.c (main): Update to new assuan API.
* server.c: Include "gpgsm.h" before <assuan.h> due to check for
GPG_ERR_SOURCE_DEFAULT and assuan.h now including gpg-error.h.
(option_handler, cmd_recipient, cmd_signer, cmd_encrypt)
(cmd_decrypt, cmd_verify, cmd_sign, cmd_import, cmd_export)
(cmd_delkeys, cmd_message, cmd_listkeys, cmd_dumpkeys)
(cmd_listsecretkeys, cmd_dumpsecretkeys, cmd_genkey)
(cmd_getauditlog, cmd_getinfo): Return gpg_error_t instead of int.
(register_commands): Same for member HANDLER in table.
(gpgsm_server): Allocate assuan context before starting server.
* sm/call-dirmngr.c:
* call-dirmngr.c (prepare_dirmngr): Check for CTX and error before
setting LDAPSERVER.
(start_dirmngr_ext): Allocate assuan context before starting
server.
(inq_certificate, isvalid_status_cb, lookup_cb, lookup_status_cb)
(run_command_cb, run_command_inq_cb, run_command_status_cb):
Return gpg_error_t instead of int.
tools/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* gpg-connect-agent.c (getinfo_pid_cb, read_and_print_response)
(main): Update to new Assuan API.
2009-09-23 00:01:25 +00:00
|
|
|
malloc_hooks.malloc = gcry_malloc;
|
|
|
|
malloc_hooks.realloc = gcry_realloc;
|
|
|
|
malloc_hooks.free = gcry_free;
|
|
|
|
assuan_set_malloc_hooks (&malloc_hooks);
|
|
|
|
assuan_set_gpg_err_source (GPG_ERR_SOURCE_DEFAULT);
|
2010-03-11 12:34:11 +00:00
|
|
|
setup_libassuan_logging (&opt.debug);
|
2003-12-16 16:31:16 +00:00
|
|
|
|
2003-08-05 17:11:04 +00:00
|
|
|
keybox_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
|
|
|
|
|
|
|
|
/* Setup a default control structure for command line mode */
|
|
|
|
memset (&ctrl, 0, sizeof ctrl);
|
|
|
|
gpgsm_init_default_ctrl (&ctrl);
|
|
|
|
ctrl.no_server = 1;
|
2009-07-07 10:02:41 +00:00
|
|
|
ctrl.status_fd = -1; /* No status output. */
|
2003-08-05 17:11:04 +00:00
|
|
|
ctrl.autodetect_encoding = 1;
|
|
|
|
|
2004-08-17 15:26:22 +00:00
|
|
|
/* Set the default option file */
|
2003-08-05 17:11:04 +00:00
|
|
|
if (default_config )
|
|
|
|
configname = make_filename (opt.homedir, "gpgsm.conf", NULL);
|
2004-08-17 15:26:22 +00:00
|
|
|
/* Set the default policy file */
|
2003-08-05 17:11:04 +00:00
|
|
|
opt.policy_file = make_filename (opt.homedir, "policies.txt", NULL);
|
|
|
|
|
|
|
|
argc = orig_argc;
|
|
|
|
argv = orig_argv;
|
|
|
|
pargs.argc = &argc;
|
|
|
|
pargs.argv = &argv;
|
|
|
|
pargs.flags = 1; /* do not remove the args */
|
|
|
|
|
|
|
|
next_pass:
|
|
|
|
if (configname) {
|
|
|
|
configlineno = 0;
|
|
|
|
configfp = fopen (configname, "r");
|
|
|
|
if (!configfp)
|
|
|
|
{
|
|
|
|
if (default_config)
|
|
|
|
{
|
|
|
|
if (parse_debug)
|
|
|
|
log_info (_("NOTE: no default option file `%s'\n"), configname);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
log_error (_("option file `%s': %s\n"), configname, strerror(errno));
|
|
|
|
gpgsm_exit(2);
|
|
|
|
}
|
|
|
|
xfree(configname);
|
|
|
|
configname = NULL;
|
|
|
|
}
|
|
|
|
if (parse_debug && configname)
|
|
|
|
log_info (_("reading options from `%s'\n"), configname);
|
|
|
|
default_config = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
while (!no_more_options
|
|
|
|
&& optfile_parse (configfp, configname, &configlineno, &pargs, opts))
|
|
|
|
{
|
|
|
|
switch (pargs.r_opt)
|
|
|
|
{
|
2004-02-18 17:00:21 +00:00
|
|
|
case aGPGConfList:
|
2006-10-23 14:02:13 +00:00
|
|
|
case aGPGConfTest:
|
2004-02-18 17:00:21 +00:00
|
|
|
set_cmd (&cmd, pargs.r_opt);
|
|
|
|
do_not_setup_keys = 1;
|
|
|
|
nogreeting = 1;
|
|
|
|
break;
|
|
|
|
|
2003-08-05 17:11:04 +00:00
|
|
|
case aServer:
|
|
|
|
opt.batch = 1;
|
|
|
|
set_cmd (&cmd, aServer);
|
|
|
|
break;
|
2004-02-18 17:00:21 +00:00
|
|
|
|
2003-08-05 17:11:04 +00:00
|
|
|
case aCallDirmngr:
|
|
|
|
opt.batch = 1;
|
|
|
|
set_cmd (&cmd, aCallDirmngr);
|
2004-02-18 17:00:21 +00:00
|
|
|
do_not_setup_keys = 1;
|
2003-08-05 17:11:04 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case aCallProtectTool:
|
|
|
|
opt.batch = 1;
|
|
|
|
set_cmd (&cmd, aCallProtectTool);
|
|
|
|
no_more_options = 1; /* Stop parsing. */
|
2004-02-18 17:00:21 +00:00
|
|
|
do_not_setup_keys = 1;
|
2003-08-05 17:11:04 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case aDeleteKey:
|
|
|
|
set_cmd (&cmd, aDeleteKey);
|
|
|
|
/*greeting=1;*/
|
2004-02-18 17:00:21 +00:00
|
|
|
do_not_setup_keys = 1;
|
2003-08-05 17:11:04 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case aDetachedSign:
|
|
|
|
detached_sig = 1;
|
|
|
|
set_cmd (&cmd, aSign );
|
|
|
|
break;
|
|
|
|
|
2004-02-18 17:00:21 +00:00
|
|
|
case aKeygen:
|
|
|
|
set_cmd (&cmd, aKeygen);
|
|
|
|
greeting=1;
|
|
|
|
do_not_setup_keys = 1;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case aImport:
|
|
|
|
case aSendKeys:
|
|
|
|
case aRecvKeys:
|
|
|
|
case aExport:
|
2004-02-19 16:26:32 +00:00
|
|
|
case aExportSecretKeyP12:
|
2004-04-22 13:03:44 +00:00
|
|
|
case aDumpKeys:
|
2006-09-13 15:57:30 +00:00
|
|
|
case aDumpChain:
|
2004-04-22 13:03:44 +00:00
|
|
|
case aDumpExternalKeys:
|
|
|
|
case aDumpSecretKeys:
|
2004-02-18 17:00:21 +00:00
|
|
|
case aListKeys:
|
|
|
|
case aListExternalKeys:
|
|
|
|
case aListSecretKeys:
|
2006-09-13 15:57:30 +00:00
|
|
|
case aListChain:
|
2004-02-18 17:00:21 +00:00
|
|
|
case aLearnCard:
|
|
|
|
case aPasswd:
|
2004-04-28 08:59:34 +00:00
|
|
|
case aKeydbClearSomeCertFlags:
|
2004-02-18 17:00:21 +00:00
|
|
|
do_not_setup_keys = 1;
|
|
|
|
set_cmd (&cmd, pargs.r_opt);
|
|
|
|
break;
|
|
|
|
|
2007-08-14 16:50:27 +00:00
|
|
|
case aEncr:
|
|
|
|
recp_required = 1;
|
|
|
|
set_cmd (&cmd, pargs.r_opt);
|
|
|
|
break;
|
|
|
|
|
2004-02-18 17:00:21 +00:00
|
|
|
case aSym:
|
|
|
|
case aDecrypt:
|
|
|
|
case aSign:
|
|
|
|
case aClearsign:
|
|
|
|
case aVerify:
|
|
|
|
set_cmd (&cmd, pargs.r_opt);
|
|
|
|
break;
|
2003-08-05 17:11:04 +00:00
|
|
|
|
2007-03-20 10:00:55 +00:00
|
|
|
/* Output encoding selection. */
|
2003-08-05 17:11:04 +00:00
|
|
|
case oArmor:
|
|
|
|
ctrl.create_pem = 1;
|
|
|
|
break;
|
|
|
|
case oBase64:
|
|
|
|
ctrl.create_pem = 0;
|
|
|
|
ctrl.create_base64 = 1;
|
|
|
|
break;
|
|
|
|
case oNoArmor:
|
|
|
|
ctrl.create_pem = 0;
|
|
|
|
ctrl.create_base64 = 0;
|
|
|
|
break;
|
|
|
|
|
2007-03-20 10:00:55 +00:00
|
|
|
case oP12Charset:
|
|
|
|
opt.p12_charset = pargs.r.ret_str;
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* Input encoding selection. */
|
2003-08-05 17:11:04 +00:00
|
|
|
case oAssumeArmor:
|
|
|
|
ctrl.autodetect_encoding = 0;
|
|
|
|
ctrl.is_pem = 1;
|
|
|
|
ctrl.is_base64 = 0;
|
|
|
|
break;
|
|
|
|
case oAssumeBase64:
|
|
|
|
ctrl.autodetect_encoding = 0;
|
|
|
|
ctrl.is_pem = 0;
|
|
|
|
ctrl.is_base64 = 1;
|
|
|
|
break;
|
|
|
|
case oAssumeBinary:
|
|
|
|
ctrl.autodetect_encoding = 0;
|
|
|
|
ctrl.is_pem = 0;
|
|
|
|
ctrl.is_base64 = 0;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case oDisableCRLChecks:
|
|
|
|
opt.no_crl_check = 1;
|
|
|
|
break;
|
|
|
|
case oEnableCRLChecks:
|
|
|
|
opt.no_crl_check = 0;
|
|
|
|
break;
|
2005-04-21 09:33:07 +00:00
|
|
|
case oDisableTrustedCertCRLCheck:
|
|
|
|
opt.no_trusted_cert_crl_check = 1;
|
|
|
|
break;
|
|
|
|
case oEnableTrustedCertCRLCheck:
|
|
|
|
opt.no_trusted_cert_crl_check = 0;
|
|
|
|
break;
|
2004-04-07 17:59:18 +00:00
|
|
|
case oForceCRLRefresh:
|
|
|
|
opt.force_crl_refresh = 1;
|
|
|
|
break;
|
2003-08-05 17:11:04 +00:00
|
|
|
|
2003-12-01 10:54:30 +00:00
|
|
|
case oDisableOCSP:
|
2004-03-15 08:39:48 +00:00
|
|
|
ctrl.use_ocsp = opt.enable_ocsp = 0;
|
2003-12-01 10:54:30 +00:00
|
|
|
break;
|
|
|
|
case oEnableOCSP:
|
2004-03-15 08:39:48 +00:00
|
|
|
ctrl.use_ocsp = opt.enable_ocsp = 1;
|
2003-12-01 10:54:30 +00:00
|
|
|
break;
|
|
|
|
|
2006-06-20 17:21:37 +00:00
|
|
|
case oIncludeCerts:
|
|
|
|
ctrl.include_certs = default_include_certs = pargs.r.ret_int;
|
|
|
|
break;
|
2003-08-05 17:11:04 +00:00
|
|
|
|
|
|
|
case oPolicyFile:
|
|
|
|
xfree (opt.policy_file);
|
|
|
|
if (*pargs.r.ret_str)
|
|
|
|
opt.policy_file = xstrdup (pargs.r.ret_str);
|
|
|
|
else
|
|
|
|
opt.policy_file = NULL;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case oDisablePolicyChecks:
|
|
|
|
opt.no_policy_check = 1;
|
|
|
|
break;
|
|
|
|
case oEnablePolicyChecks:
|
|
|
|
opt.no_policy_check = 0;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case oAutoIssuerKeyRetrieve:
|
|
|
|
opt.auto_issuer_key_retrieve = 1;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case oOutput: opt.outfile = pargs.r.ret_str; break;
|
|
|
|
|
|
|
|
|
|
|
|
case oQuiet: opt.quiet = 1; break;
|
|
|
|
case oNoTTY: /* fixme:tty_no_terminal(1);*/ break;
|
|
|
|
case oDryRun: opt.dry_run = 1; break;
|
|
|
|
|
|
|
|
case oVerbose:
|
|
|
|
opt.verbose++;
|
|
|
|
gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
|
|
|
|
break;
|
|
|
|
case oNoVerbose:
|
|
|
|
opt.verbose = 0;
|
|
|
|
gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case oLogFile: logfile = pargs.r.ret_str; break;
|
2005-07-21 18:29:13 +00:00
|
|
|
case oNoLogFile: logfile = NULL; break;
|
|
|
|
|
2007-11-19 16:03:50 +00:00
|
|
|
case oAuditLog: auditlog = pargs.r.ret_str; break;
|
2009-12-02 18:33:59 +00:00
|
|
|
case oHtmlAuditLog: htmlauditlog = pargs.r.ret_str; break;
|
2007-11-19 16:03:50 +00:00
|
|
|
|
2003-08-05 17:11:04 +00:00
|
|
|
case oBatch:
|
|
|
|
opt.batch = 1;
|
|
|
|
greeting = 0;
|
|
|
|
break;
|
|
|
|
case oNoBatch: opt.batch = 0; break;
|
|
|
|
|
|
|
|
case oAnswerYes: opt.answer_yes = 1; break;
|
|
|
|
case oAnswerNo: opt.answer_no = 1; break;
|
|
|
|
|
|
|
|
case oKeyring: append_to_strlist (&nrings, pargs.r.ret_str); break;
|
|
|
|
|
2004-12-02 07:48:09 +00:00
|
|
|
case oDebug: debug_value |= pargs.r.ret_ulong; break;
|
|
|
|
case oDebugAll: debug_value = ~0; break;
|
2005-07-21 18:29:13 +00:00
|
|
|
case oDebugNone: debug_value = 0; break;
|
2004-02-18 17:00:21 +00:00
|
|
|
case oDebugLevel: debug_level = pargs.r.ret_str; break;
|
2003-08-05 17:11:04 +00:00
|
|
|
case oDebugWait: debug_wait = pargs.r.ret_int; break;
|
2004-05-11 09:54:52 +00:00
|
|
|
case oDebugAllowCoreDump:
|
|
|
|
may_coredump = enable_core_dumps ();
|
|
|
|
break;
|
2003-08-05 17:11:04 +00:00
|
|
|
case oDebugNoChainValidation: opt.no_chain_validation = 1; break;
|
2004-02-20 13:46:21 +00:00
|
|
|
case oDebugIgnoreExpiration: opt.ignore_expiration = 1; break;
|
2004-08-17 15:26:22 +00:00
|
|
|
case oFixedPassphrase: opt.fixed_passphrase = pargs.r.ret_str; break;
|
2003-08-05 17:11:04 +00:00
|
|
|
|
|
|
|
case oStatusFD: ctrl.status_fd = pargs.r.ret_int; break;
|
|
|
|
case oLoggerFD: log_set_fd (pargs.r.ret_int ); break;
|
2004-02-17 15:05:04 +00:00
|
|
|
case oWithMD5Fingerprint:
|
|
|
|
opt.with_md5_fingerprint=1; /*fall thru*/
|
2003-08-05 17:11:04 +00:00
|
|
|
case oWithFingerprint:
|
|
|
|
with_fpr=1; /*fall thru*/
|
2008-11-13 12:37:45 +00:00
|
|
|
case aFingerprint:
|
2003-08-05 17:11:04 +00:00
|
|
|
opt.fingerprint++;
|
|
|
|
break;
|
2010-10-08 11:11:08 +00:00
|
|
|
|
|
|
|
case oWithKeygrip:
|
|
|
|
opt.with_keygrip = 1;
|
|
|
|
break;
|
2003-08-05 17:11:04 +00:00
|
|
|
|
|
|
|
case oOptions:
|
|
|
|
/* config files may not be nested (silently ignore them) */
|
|
|
|
if (!configfp)
|
|
|
|
{
|
|
|
|
xfree(configname);
|
|
|
|
configname = xstrdup (pargs.r.ret_str);
|
|
|
|
goto next_pass;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case oNoOptions: break; /* no-options */
|
|
|
|
case oHomedir: opt.homedir = pargs.r.ret_str; break;
|
|
|
|
case oAgentProgram: opt.agent_program = pargs.r.ret_str; break;
|
2009-07-07 10:02:41 +00:00
|
|
|
|
|
|
|
case oDisplay:
|
|
|
|
set_opt_session_env ("DISPLAY", pargs.r.ret_str);
|
|
|
|
break;
|
|
|
|
case oTTYname:
|
|
|
|
set_opt_session_env ("GPG_TTY", pargs.r.ret_str);
|
|
|
|
break;
|
|
|
|
case oTTYtype:
|
|
|
|
set_opt_session_env ("TERM", pargs.r.ret_str);
|
|
|
|
break;
|
|
|
|
case oXauthority:
|
|
|
|
set_opt_session_env ("XAUTHORITY", pargs.r.ret_str);
|
|
|
|
break;
|
|
|
|
|
2003-08-05 17:11:04 +00:00
|
|
|
case oLCctype: opt.lc_ctype = xstrdup (pargs.r.ret_str); break;
|
|
|
|
case oLCmessages: opt.lc_messages = xstrdup (pargs.r.ret_str); break;
|
2009-07-07 10:02:41 +00:00
|
|
|
|
2003-08-05 17:11:04 +00:00
|
|
|
case oDirmngrProgram: opt.dirmngr_program = pargs.r.ret_str; break;
|
2008-02-19 10:33:35 +00:00
|
|
|
case oDisableDirmngr: opt.disable_dirmngr = 1; break;
|
2010-08-16 11:03:43 +00:00
|
|
|
case oPreferSystemDirmngr: /* Obsolete */; break;
|
2004-02-13 12:40:23 +00:00
|
|
|
case oProtectToolProgram:
|
|
|
|
opt.protect_tool_program = pargs.r.ret_str;
|
|
|
|
break;
|
2003-08-05 17:11:04 +00:00
|
|
|
|
|
|
|
case oFakedSystemTime:
|
2007-08-10 16:52:05 +00:00
|
|
|
{
|
|
|
|
time_t faked_time = isotime2epoch (pargs.r.ret_str);
|
|
|
|
if (faked_time == (time_t)(-1))
|
|
|
|
faked_time = (time_t)strtoul (pargs.r.ret_str, NULL, 10);
|
|
|
|
gnupg_set_time (faked_time, 0);
|
|
|
|
}
|
2003-08-05 17:11:04 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case oNoDefKeyring: default_keyring = 0; break;
|
|
|
|
case oNoGreeting: nogreeting = 1; break;
|
|
|
|
|
|
|
|
case oDefaultKey:
|
2007-07-17 18:11:24 +00:00
|
|
|
if (*pargs.r.ret_str)
|
|
|
|
{
|
|
|
|
xfree (opt.local_user);
|
|
|
|
opt.local_user = xstrdup (pargs.r.ret_str);
|
|
|
|
}
|
2003-08-05 17:11:04 +00:00
|
|
|
break;
|
|
|
|
case oDefRecipient:
|
|
|
|
if (*pargs.r.ret_str)
|
|
|
|
opt.def_recipient = xstrdup (pargs.r.ret_str);
|
|
|
|
break;
|
|
|
|
case oDefRecipientSelf:
|
|
|
|
xfree (opt.def_recipient);
|
|
|
|
opt.def_recipient = NULL;
|
|
|
|
opt.def_recipient_self = 1;
|
|
|
|
break;
|
|
|
|
case oNoDefRecipient:
|
|
|
|
xfree (opt.def_recipient);
|
|
|
|
opt.def_recipient = NULL;
|
|
|
|
opt.def_recipient_self = 0;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case oWithKeyData: opt.with_key_data=1; /* fall thru */
|
|
|
|
case oWithColons: ctrl.with_colons = 1; break;
|
2004-02-17 15:05:04 +00:00
|
|
|
case oWithValidation: ctrl.with_validation=1; break;
|
2009-03-18 11:18:56 +00:00
|
|
|
case oWithEphemeralKeys: ctrl.with_ephemeral_keys=1; break;
|
2003-08-05 17:11:04 +00:00
|
|
|
|
|
|
|
case oSkipVerify: opt.skip_verify=1; break;
|
|
|
|
|
2003-12-17 17:12:14 +00:00
|
|
|
case oNoEncryptTo: opt.no_encrypt_to = 1; break;
|
|
|
|
case oEncryptTo: /* Store the recipient in the second list */
|
2003-08-05 17:11:04 +00:00
|
|
|
sl = add_to_strlist (&remusr, pargs.r.ret_str);
|
|
|
|
sl->flags = 1;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case oRecipient: /* store the recipient */
|
|
|
|
add_to_strlist ( &remusr, pargs.r.ret_str);
|
|
|
|
break;
|
|
|
|
|
2007-07-17 18:11:24 +00:00
|
|
|
case oUser: /* Store the local users, the first one is the default */
|
2003-08-05 17:11:04 +00:00
|
|
|
if (!opt.local_user)
|
2007-07-17 18:11:24 +00:00
|
|
|
opt.local_user = xstrdup (pargs.r.ret_str);
|
2003-08-05 17:11:04 +00:00
|
|
|
add_to_strlist (&locusr, pargs.r.ret_str);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case oNoSecmemWarn:
|
|
|
|
gcry_control (GCRYCTL_DISABLE_SECMEM_WARN);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case oCipherAlgo:
|
|
|
|
opt.def_cipher_algoid = pargs.r.ret_str;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case oDisableCipherAlgo:
|
|
|
|
{
|
|
|
|
int algo = gcry_cipher_map_name (pargs.r.ret_str);
|
|
|
|
gcry_cipher_ctl (NULL, GCRYCTL_DISABLE_ALGO, &algo, sizeof algo);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case oDisablePubkeyAlgo:
|
|
|
|
{
|
|
|
|
int algo = gcry_pk_map_name (pargs.r.ret_str);
|
|
|
|
gcry_pk_ctl (GCRYCTL_DISABLE_ALGO,&algo, sizeof algo );
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2008-11-13 12:37:45 +00:00
|
|
|
case oDigestAlgo:
|
2009-03-26 19:27:04 +00:00
|
|
|
forced_digest_algo = pargs.r.ret_str;
|
2008-11-13 12:37:45 +00:00
|
|
|
break;
|
|
|
|
|
2007-12-13 15:45:40 +00:00
|
|
|
case oExtraDigestAlgo:
|
|
|
|
extra_digest_algo = pargs.r.ret_str;
|
|
|
|
break;
|
|
|
|
|
2003-08-05 17:11:04 +00:00
|
|
|
case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
|
|
|
|
case oNoRandomSeedFile: use_random_seed = 0; break;
|
2008-02-19 10:33:35 +00:00
|
|
|
case oNoCommonCertsImport: no_common_certs_import = 1; break;
|
2003-08-05 17:11:04 +00:00
|
|
|
|
|
|
|
case oEnableSpecialFilenames: allow_special_filenames =1; break;
|
2007-08-10 16:52:05 +00:00
|
|
|
|
|
|
|
case oValidationModel: parse_validation_model (pargs.r.ret_str); break;
|
2003-08-05 17:11:04 +00:00
|
|
|
|
2008-06-12 14:24:46 +00:00
|
|
|
case oKeyServer:
|
|
|
|
{
|
|
|
|
struct keyserver_spec *keyserver;
|
|
|
|
keyserver = parse_keyserver_line (pargs.r.ret_str,
|
|
|
|
configname, configlineno);
|
|
|
|
if (! keyserver)
|
|
|
|
log_error (_("could not parse keyserver\n"));
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* FIXME: Keep last next pointer. */
|
|
|
|
struct keyserver_spec **next_p = &opt.keyserver;
|
|
|
|
while (*next_p)
|
|
|
|
next_p = &(*next_p)->next;
|
|
|
|
*next_p = keyserver;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2009-12-10 13:00:30 +00:00
|
|
|
case oIgnoreCertExtension:
|
|
|
|
add_to_strlist (&opt.ignored_cert_extensions, pargs.r.ret_str);
|
|
|
|
break;
|
|
|
|
|
2003-08-05 17:11:04 +00:00
|
|
|
default:
|
2008-11-13 12:37:45 +00:00
|
|
|
pargs.err = configfp? ARGPARSE_PRINT_WARNING:ARGPARSE_PRINT_ERROR;
|
2003-08-05 17:11:04 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (configfp)
|
|
|
|
{
|
|
|
|
fclose (configfp);
|
|
|
|
configfp = NULL;
|
2004-03-16 18:59:09 +00:00
|
|
|
/* Keep a copy of the config filename. */
|
2004-05-11 09:15:56 +00:00
|
|
|
opt.config_filename = configname;
|
2003-08-05 17:11:04 +00:00
|
|
|
configname = NULL;
|
|
|
|
goto next_pass;
|
|
|
|
}
|
|
|
|
xfree (configname);
|
|
|
|
configname = NULL;
|
|
|
|
|
2004-05-11 09:15:56 +00:00
|
|
|
if (!opt.config_filename)
|
|
|
|
opt.config_filename = make_filename (opt.homedir, "gpgsm.conf", NULL);
|
|
|
|
|
2003-08-05 17:11:04 +00:00
|
|
|
if (log_get_errorcount(0))
|
|
|
|
gpgsm_exit(2);
|
2007-08-10 16:52:05 +00:00
|
|
|
|
2009-07-07 10:02:41 +00:00
|
|
|
/* Now that we have the options parsed we need to update the default
|
2007-08-10 16:52:05 +00:00
|
|
|
control structure. */
|
|
|
|
gpgsm_init_default_ctrl (&ctrl);
|
|
|
|
|
2003-08-05 17:11:04 +00:00
|
|
|
if (nogreeting)
|
|
|
|
greeting = 0;
|
|
|
|
|
|
|
|
if (greeting)
|
|
|
|
{
|
2010-08-18 19:25:15 +00:00
|
|
|
es_fprintf (es_stderr, "%s %s; %s\n",
|
|
|
|
strusage(11), strusage(13), strusage(14) );
|
|
|
|
es_fprintf (es_stderr, "%s\n", strusage(15) );
|
2003-08-05 17:11:04 +00:00
|
|
|
}
|
|
|
|
# ifdef IS_DEVELOPMENT_VERSION
|
|
|
|
if (!opt.batch)
|
|
|
|
{
|
|
|
|
log_info ("NOTE: THIS IS A DEVELOPMENT VERSION!\n");
|
|
|
|
log_info ("It is only intended for test purposes and should NOT be\n");
|
|
|
|
log_info ("used in a production environment or with production keys!\n");
|
|
|
|
}
|
|
|
|
# endif
|
|
|
|
|
|
|
|
if (may_coredump && !opt.quiet)
|
|
|
|
log_info (_("WARNING: program may create a core file!\n"));
|
|
|
|
|
2005-11-23 09:05:45 +00:00
|
|
|
/* if (opt.qualsig_approval && !opt.quiet) */
|
|
|
|
/* log_info (_("This software has offically been approved to " */
|
|
|
|
/* "create and verify\n" */
|
|
|
|
/* "qualified signatures according to German law.\n")); */
|
|
|
|
|
2003-08-05 17:11:04 +00:00
|
|
|
if (logfile && cmd == aServer)
|
|
|
|
{
|
|
|
|
log_set_file (logfile);
|
|
|
|
log_set_prefix (NULL, 1|2|4);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (gnupg_faked_time_p ())
|
|
|
|
{
|
2003-10-31 12:12:47 +00:00
|
|
|
gnupg_isotime_t tbuf;
|
|
|
|
|
2003-08-05 17:11:04 +00:00
|
|
|
log_info (_("WARNING: running with faked system time: "));
|
2003-10-31 12:12:47 +00:00
|
|
|
gnupg_get_isotime (tbuf);
|
2009-03-16 09:44:44 +00:00
|
|
|
dump_isotime (tbuf);
|
2003-08-05 17:11:04 +00:00
|
|
|
log_printf ("\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
/*FIXME if (opt.batch) */
|
|
|
|
/* tty_batchmode (1); */
|
|
|
|
|
|
|
|
gcry_control (GCRYCTL_RESUME_SECMEM_WARN);
|
|
|
|
|
2004-12-02 07:48:09 +00:00
|
|
|
set_debug ();
|
2003-08-05 17:11:04 +00:00
|
|
|
|
2004-06-06 13:00:59 +00:00
|
|
|
/* Although we alwasy use gpgsm_exit, we better install a regualr
|
|
|
|
exit handler so that at least the secure memory gets wiped
|
|
|
|
out. */
|
|
|
|
if (atexit (emergency_cleanup))
|
|
|
|
{
|
|
|
|
log_error ("atexit failed\n");
|
|
|
|
gpgsm_exit (2);
|
|
|
|
}
|
2003-08-05 17:11:04 +00:00
|
|
|
|
2004-06-06 13:00:59 +00:00
|
|
|
/* Must do this after dropping setuid, because the mapping functions
|
2006-10-23 14:02:13 +00:00
|
|
|
may try to load an module and we may have disabled an algorithm.
|
|
|
|
We remap the commonly used algorithms to the OIDs for
|
|
|
|
convenience. We need to work with the OIDs because they are used
|
|
|
|
to check whether the encryption mode is actually available. */
|
|
|
|
if (!strcmp (opt.def_cipher_algoid, "3DES") )
|
|
|
|
opt.def_cipher_algoid = "1.2.840.113549.3.7";
|
|
|
|
else if (!strcmp (opt.def_cipher_algoid, "AES")
|
|
|
|
|| !strcmp (opt.def_cipher_algoid, "AES128"))
|
|
|
|
opt.def_cipher_algoid = "2.16.840.1.101.3.4.1.2";
|
|
|
|
else if (!strcmp (opt.def_cipher_algoid, "AES256") )
|
|
|
|
opt.def_cipher_algoid = "2.16.840.1.101.3.4.1.42";
|
2007-08-14 16:50:27 +00:00
|
|
|
else if (!strcmp (opt.def_cipher_algoid, "SERPENT")
|
|
|
|
|| !strcmp (opt.def_cipher_algoid, "SERPENT128") )
|
|
|
|
opt.def_cipher_algoid = "1.3.6.1.4.1.11591.13.2.2";
|
|
|
|
else if (!strcmp (opt.def_cipher_algoid, "SERPENT192") )
|
|
|
|
opt.def_cipher_algoid = "1.3.6.1.4.1.11591.13.2.22";
|
|
|
|
else if (!strcmp (opt.def_cipher_algoid, "SERPENT192") )
|
|
|
|
opt.def_cipher_algoid = "1.3.6.1.4.1.11591.13.2.42";
|
|
|
|
else if (!strcmp (opt.def_cipher_algoid, "SEED") )
|
|
|
|
opt.def_cipher_algoid = "1.2.410.200004.1.4";
|
|
|
|
else if (!strcmp (opt.def_cipher_algoid, "CAMELLIA")
|
|
|
|
|| !strcmp (opt.def_cipher_algoid, "CAMELLIA128") )
|
|
|
|
opt.def_cipher_algoid = "1.2.392.200011.61.1.1.1.2";
|
|
|
|
else if (!strcmp (opt.def_cipher_algoid, "CAMELLIA192") )
|
|
|
|
opt.def_cipher_algoid = "1.2.392.200011.61.1.1.1.3";
|
|
|
|
else if (!strcmp (opt.def_cipher_algoid, "CAMELLIA256") )
|
|
|
|
opt.def_cipher_algoid = "1.2.392.200011.61.1.1.1.4";
|
2006-10-23 14:02:13 +00:00
|
|
|
|
|
|
|
if (cmd != aGPGConfList)
|
2003-08-05 17:11:04 +00:00
|
|
|
{
|
2006-10-23 14:02:13 +00:00
|
|
|
if ( !gcry_cipher_map_name (opt.def_cipher_algoid)
|
|
|
|
|| !gcry_cipher_mode_from_oid (opt.def_cipher_algoid))
|
|
|
|
log_error (_("selected cipher algorithm is invalid\n"));
|
|
|
|
|
2009-03-26 19:27:04 +00:00
|
|
|
if (forced_digest_algo)
|
2006-10-23 14:02:13 +00:00
|
|
|
{
|
2009-03-26 19:27:04 +00:00
|
|
|
opt.forced_digest_algo = gcry_md_map_name (forced_digest_algo);
|
|
|
|
if (our_md_test_algo(opt.forced_digest_algo) )
|
2006-10-23 14:02:13 +00:00
|
|
|
log_error (_("selected digest algorithm is invalid\n"));
|
|
|
|
}
|
2007-12-13 15:45:40 +00:00
|
|
|
if (extra_digest_algo)
|
|
|
|
{
|
|
|
|
opt.extra_digest_algo = gcry_md_map_name (extra_digest_algo);
|
|
|
|
if (our_md_test_algo (opt.extra_digest_algo) )
|
|
|
|
log_error (_("selected digest algorithm is invalid\n"));
|
|
|
|
}
|
2003-08-05 17:11:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (log_get_errorcount(0))
|
|
|
|
gpgsm_exit(2);
|
|
|
|
|
2004-06-06 13:00:59 +00:00
|
|
|
/* Set the random seed file. */
|
2007-08-02 18:12:43 +00:00
|
|
|
if (use_random_seed)
|
|
|
|
{
|
|
|
|
char *p = make_filename (opt.homedir, "random_seed", NULL);
|
|
|
|
gcry_control (GCRYCTL_SET_RANDOM_SEED_FILE, p);
|
|
|
|
xfree(p);
|
|
|
|
}
|
|
|
|
|
2003-08-05 17:11:04 +00:00
|
|
|
if (!cmd && opt.fingerprint && !with_fpr)
|
|
|
|
set_cmd (&cmd, aListKeys);
|
|
|
|
|
2007-08-02 18:12:43 +00:00
|
|
|
/* Add default keybox. */
|
|
|
|
if (!nrings && default_keyring)
|
2006-09-18 09:28:58 +00:00
|
|
|
{
|
|
|
|
int created;
|
|
|
|
|
|
|
|
keydb_add_resource ("pubring.kbx", 0, 0, &created);
|
2008-02-19 10:33:35 +00:00
|
|
|
if (created && !no_common_certs_import)
|
2006-09-18 09:28:58 +00:00
|
|
|
{
|
|
|
|
/* Import the standard certificates for a new default keybox. */
|
|
|
|
char *filelist[2];
|
|
|
|
|
2007-06-14 17:05:07 +00:00
|
|
|
filelist[0] = make_filename (gnupg_datadir (),"com-certs.pem", NULL);
|
2006-09-18 09:28:58 +00:00
|
|
|
filelist[1] = NULL;
|
|
|
|
if (!access (filelist[0], F_OK))
|
|
|
|
{
|
|
|
|
log_info (_("importing common certificates `%s'\n"),
|
|
|
|
filelist[0]);
|
|
|
|
gpgsm_import_files (&ctrl, 1, filelist, open_read);
|
|
|
|
}
|
|
|
|
xfree (filelist[0]);
|
|
|
|
}
|
|
|
|
}
|
2003-08-05 17:11:04 +00:00
|
|
|
for (sl = nrings; sl; sl = sl->next)
|
2006-09-18 09:28:58 +00:00
|
|
|
keydb_add_resource (sl->d, 0, 0, NULL);
|
2003-08-05 17:11:04 +00:00
|
|
|
FREE_STRLIST(nrings);
|
|
|
|
|
2007-12-12 10:28:30 +00:00
|
|
|
|
|
|
|
/* Prepare the audit log feature for certain commands. */
|
2009-12-02 18:33:59 +00:00
|
|
|
if (auditlog || htmlauditlog)
|
2007-12-12 10:28:30 +00:00
|
|
|
{
|
|
|
|
switch (cmd)
|
|
|
|
{
|
|
|
|
case aEncr:
|
|
|
|
case aSign:
|
|
|
|
case aDecrypt:
|
|
|
|
case aVerify:
|
|
|
|
audit_release (ctrl.audit);
|
|
|
|
ctrl.audit = audit_new ();
|
2009-12-02 18:33:59 +00:00
|
|
|
if (auditlog)
|
|
|
|
auditfp = open_es_fwrite (auditlog);
|
|
|
|
if (htmlauditlog)
|
|
|
|
htmlauditfp = open_es_fwrite (htmlauditlog);
|
2007-12-12 10:28:30 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2004-02-18 17:00:21 +00:00
|
|
|
if (!do_not_setup_keys)
|
2003-08-05 17:11:04 +00:00
|
|
|
{
|
2004-02-18 17:00:21 +00:00
|
|
|
for (sl = locusr; sl ; sl = sl->next)
|
2003-08-05 17:11:04 +00:00
|
|
|
{
|
2004-02-18 17:00:21 +00:00
|
|
|
int rc = gpgsm_add_to_certlist (&ctrl, sl->d, 1, &signerlist, 0);
|
|
|
|
if (rc)
|
|
|
|
{
|
|
|
|
log_error (_("can't sign using `%s': %s\n"),
|
|
|
|
sl->d, gpg_strerror (rc));
|
2009-08-06 20:12:00 +00:00
|
|
|
gpgsm_status2 (&ctrl, STATUS_INV_SGNR,
|
|
|
|
get_inv_recpsgnr_code (rc), sl->d, NULL);
|
2004-02-18 17:00:21 +00:00
|
|
|
gpgsm_status2 (&ctrl, STATUS_INV_RECP,
|
2009-08-06 20:12:00 +00:00
|
|
|
get_inv_recpsgnr_code (rc), sl->d, NULL);
|
2004-02-18 17:00:21 +00:00
|
|
|
}
|
2003-08-05 17:11:04 +00:00
|
|
|
}
|
2004-02-18 17:00:21 +00:00
|
|
|
|
|
|
|
/* Build the recipient list. We first add the regular ones and then
|
2007-08-02 18:12:43 +00:00
|
|
|
the encrypt-to ones because the underlying function will silently
|
2004-02-18 17:00:21 +00:00
|
|
|
ignore duplicates and we can't allow to keep a duplicate which is
|
|
|
|
flagged as encrypt-to as the actually encrypt function would then
|
|
|
|
complain about no (regular) recipients. */
|
2003-12-17 17:12:14 +00:00
|
|
|
for (sl = remusr; sl; sl = sl->next)
|
2004-02-18 17:00:21 +00:00
|
|
|
if (!(sl->flags & 1))
|
2007-08-14 16:50:27 +00:00
|
|
|
do_add_recipient (&ctrl, sl->d, &recplist, 0, recp_required);
|
2004-02-18 17:00:21 +00:00
|
|
|
if (!opt.no_encrypt_to)
|
|
|
|
{
|
|
|
|
for (sl = remusr; sl; sl = sl->next)
|
|
|
|
if ((sl->flags & 1))
|
2007-08-14 16:50:27 +00:00
|
|
|
do_add_recipient (&ctrl, sl->d, &recplist, 1, recp_required);
|
2004-02-18 17:00:21 +00:00
|
|
|
}
|
2003-12-17 17:12:14 +00:00
|
|
|
}
|
2004-02-18 17:00:21 +00:00
|
|
|
|
2003-08-05 17:11:04 +00:00
|
|
|
if (log_get_errorcount(0))
|
2007-08-02 18:12:43 +00:00
|
|
|
gpgsm_exit(1); /* Must stop for invalid recipients. */
|
2003-08-05 17:11:04 +00:00
|
|
|
|
|
|
|
fname = argc? *argv : NULL;
|
|
|
|
|
2007-12-12 10:28:30 +00:00
|
|
|
/* Dispatch command. */
|
2003-08-05 17:11:04 +00:00
|
|
|
switch (cmd)
|
|
|
|
{
|
2004-02-18 17:00:21 +00:00
|
|
|
case aGPGConfList:
|
|
|
|
{ /* List options and default values in the GPG Conf format. */
|
2007-06-19 09:11:11 +00:00
|
|
|
char *config_filename_esc = percent_escape (opt.config_filename, NULL);
|
2007-06-18 20:15:01 +00:00
|
|
|
|
2010-08-18 19:25:15 +00:00
|
|
|
es_printf ("gpgconf-gpgsm.conf:%lu:\"%s\n",
|
|
|
|
GC_OPT_FLAG_DEFAULT, config_filename_esc);
|
2007-06-18 20:15:01 +00:00
|
|
|
xfree (config_filename_esc);
|
|
|
|
|
2010-08-18 19:25:15 +00:00
|
|
|
es_printf ("verbose:%lu:\n", GC_OPT_FLAG_NONE);
|
|
|
|
es_printf ("quiet:%lu:\n", GC_OPT_FLAG_NONE);
|
|
|
|
es_printf ("debug-level:%lu:\"none:\n", GC_OPT_FLAG_DEFAULT);
|
|
|
|
es_printf ("log-file:%lu:\n", GC_OPT_FLAG_NONE);
|
|
|
|
es_printf ("disable-crl-checks:%lu:\n", GC_OPT_FLAG_NONE);
|
|
|
|
es_printf ("disable-trusted-cert-crl-check:%lu:\n", GC_OPT_FLAG_NONE);
|
|
|
|
es_printf ("enable-ocsp:%lu:\n", GC_OPT_FLAG_NONE);
|
|
|
|
es_printf ("include-certs:%lu:%d:\n", GC_OPT_FLAG_DEFAULT,
|
|
|
|
DEFAULT_INCLUDE_CERTS);
|
|
|
|
es_printf ("disable-policy-checks:%lu:\n", GC_OPT_FLAG_NONE);
|
|
|
|
es_printf ("auto-issuer-key-retrieve:%lu:\n", GC_OPT_FLAG_NONE);
|
|
|
|
es_printf ("disable-dirmngr:%lu:\n", GC_OPT_FLAG_NONE);
|
|
|
|
es_printf ("cipher-algo:%lu:\"%s:\n", GC_OPT_FLAG_DEFAULT,
|
|
|
|
DEFAULT_CIPHER_ALGO);
|
|
|
|
es_printf ("p12-charset:%lu:\n", GC_OPT_FLAG_DEFAULT);
|
|
|
|
es_printf ("default-key:%lu:\n", GC_OPT_FLAG_DEFAULT);
|
|
|
|
es_printf ("encrypt-to:%lu:\n", GC_OPT_FLAG_DEFAULT);
|
|
|
|
es_printf ("keyserver:%lu:\n", GC_OPT_FLAG_NONE);
|
2004-03-16 18:59:09 +00:00
|
|
|
|
2009-11-23 19:18:04 +00:00
|
|
|
/* The next one is an info only item and should match what
|
|
|
|
proc_parameters actually implements. */
|
2010-08-18 19:25:15 +00:00
|
|
|
es_printf ("default_pubkey_algo:%lu:\"%s:\n", GC_OPT_FLAG_DEFAULT,
|
|
|
|
"RSA-2048");
|
2009-11-23 19:18:04 +00:00
|
|
|
|
2004-02-18 17:00:21 +00:00
|
|
|
}
|
|
|
|
break;
|
2006-10-23 14:02:13 +00:00
|
|
|
case aGPGConfTest:
|
|
|
|
/* This is merely a dummy command to test whether the
|
|
|
|
configuration file is valid. */
|
|
|
|
break;
|
2004-02-18 17:00:21 +00:00
|
|
|
|
2003-08-05 17:11:04 +00:00
|
|
|
case aServer:
|
|
|
|
if (debug_wait)
|
|
|
|
{
|
|
|
|
log_debug ("waiting for debugger - my pid is %u .....\n",
|
|
|
|
(unsigned int)getpid());
|
2007-06-20 11:16:42 +00:00
|
|
|
gnupg_sleep (debug_wait);
|
2003-08-05 17:11:04 +00:00
|
|
|
log_debug ("... okay\n");
|
|
|
|
}
|
2003-12-17 17:12:14 +00:00
|
|
|
gpgsm_server (recplist);
|
2003-08-05 17:11:04 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case aCallDirmngr:
|
|
|
|
if (!argc)
|
2004-04-06 10:01:04 +00:00
|
|
|
wrong_args ("--call-dirmngr <command> {args}");
|
2003-08-05 17:11:04 +00:00
|
|
|
else
|
|
|
|
if (gpgsm_dirmngr_run_command (&ctrl, *argv, argc-1, argv+1))
|
|
|
|
gpgsm_exit (1);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case aCallProtectTool:
|
|
|
|
run_protect_tool (argc, argv);
|
|
|
|
break;
|
|
|
|
|
2006-08-29 16:18:30 +00:00
|
|
|
case aEncr: /* Encrypt the given file. */
|
|
|
|
{
|
2010-03-08 12:22:18 +00:00
|
|
|
estream_t fp = open_es_fwrite (opt.outfile?opt.outfile:"-");
|
2006-08-29 16:18:30 +00:00
|
|
|
|
|
|
|
set_binary (stdin);
|
|
|
|
|
|
|
|
if (!argc) /* Source is stdin. */
|
|
|
|
gpgsm_encrypt (&ctrl, recplist, 0, fp);
|
|
|
|
else if (argc == 1) /* Source is the given file. */
|
|
|
|
gpgsm_encrypt (&ctrl, recplist, open_read (*argv), fp);
|
|
|
|
else
|
|
|
|
wrong_args ("--encrypt [datafile]");
|
|
|
|
|
2010-03-08 12:22:18 +00:00
|
|
|
es_fclose (fp);
|
2006-08-29 16:18:30 +00:00
|
|
|
}
|
2003-08-05 17:11:04 +00:00
|
|
|
break;
|
|
|
|
|
2006-08-29 16:18:30 +00:00
|
|
|
case aSign: /* Sign the given file. */
|
|
|
|
{
|
2010-03-08 12:22:18 +00:00
|
|
|
estream_t fp = open_es_fwrite (opt.outfile?opt.outfile:"-");
|
2006-08-29 16:18:30 +00:00
|
|
|
|
|
|
|
/* Fixme: We should also allow to concatenate multiple files for
|
|
|
|
signing because that is what gpg does.*/
|
|
|
|
set_binary (stdin);
|
|
|
|
if (!argc) /* Create from stdin. */
|
|
|
|
gpgsm_sign (&ctrl, signerlist, 0, detached_sig, fp);
|
|
|
|
else if (argc == 1) /* From file. */
|
|
|
|
gpgsm_sign (&ctrl, signerlist,
|
|
|
|
open_read (*argv), detached_sig, fp);
|
|
|
|
else
|
|
|
|
wrong_args ("--sign [datafile]");
|
|
|
|
|
2010-03-08 12:22:18 +00:00
|
|
|
es_fclose (fp);
|
2006-08-29 16:18:30 +00:00
|
|
|
}
|
2003-08-05 17:11:04 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case aSignEncr: /* sign and encrypt the given file */
|
|
|
|
log_error ("this command has not yet been implemented\n");
|
|
|
|
break;
|
|
|
|
|
|
|
|
case aClearsign: /* make a clearsig */
|
|
|
|
log_error ("this command has not yet been implemented\n");
|
|
|
|
break;
|
|
|
|
|
|
|
|
case aVerify:
|
|
|
|
{
|
2010-03-08 12:22:18 +00:00
|
|
|
estream_t fp = NULL;
|
2003-08-05 17:11:04 +00:00
|
|
|
|
2004-12-22 17:55:28 +00:00
|
|
|
set_binary (stdin);
|
2003-08-05 17:11:04 +00:00
|
|
|
if (argc == 2 && opt.outfile)
|
|
|
|
log_info ("option --output ignored for a detached signature\n");
|
|
|
|
else if (opt.outfile)
|
2010-03-08 12:22:18 +00:00
|
|
|
fp = open_es_fwrite (opt.outfile);
|
2003-08-05 17:11:04 +00:00
|
|
|
|
|
|
|
if (!argc)
|
|
|
|
gpgsm_verify (&ctrl, 0, -1, fp); /* normal signature from stdin */
|
|
|
|
else if (argc == 1)
|
|
|
|
gpgsm_verify (&ctrl, open_read (*argv), -1, fp); /* std signature */
|
|
|
|
else if (argc == 2) /* detached signature (sig, detached) */
|
|
|
|
gpgsm_verify (&ctrl, open_read (*argv), open_read (argv[1]), NULL);
|
|
|
|
else
|
2004-04-06 10:01:04 +00:00
|
|
|
wrong_args ("--verify [signature [detached_data]]");
|
2003-08-05 17:11:04 +00:00
|
|
|
|
2010-03-08 12:22:18 +00:00
|
|
|
es_fclose (fp);
|
2003-08-05 17:11:04 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case aDecrypt:
|
2006-08-29 16:18:30 +00:00
|
|
|
{
|
2010-03-08 12:22:18 +00:00
|
|
|
estream_t fp = open_es_fwrite (opt.outfile?opt.outfile:"-");
|
2006-08-29 16:18:30 +00:00
|
|
|
|
|
|
|
set_binary (stdin);
|
|
|
|
if (!argc)
|
|
|
|
gpgsm_decrypt (&ctrl, 0, fp); /* from stdin */
|
|
|
|
else if (argc == 1)
|
|
|
|
gpgsm_decrypt (&ctrl, open_read (*argv), fp); /* from file */
|
|
|
|
else
|
|
|
|
wrong_args ("--decrypt [filename]");
|
2010-03-08 12:22:18 +00:00
|
|
|
|
|
|
|
es_fclose (fp);
|
2006-08-29 16:18:30 +00:00
|
|
|
}
|
2003-08-05 17:11:04 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case aDeleteKey:
|
|
|
|
for (sl=NULL; argc; argc--, argv++)
|
|
|
|
add_to_strlist (&sl, *argv);
|
|
|
|
gpgsm_delete (&ctrl, sl);
|
|
|
|
free_strlist(sl);
|
|
|
|
break;
|
|
|
|
|
2006-09-13 15:57:30 +00:00
|
|
|
case aListChain:
|
|
|
|
case aDumpChain:
|
|
|
|
ctrl.with_chain = 1;
|
2003-08-05 17:11:04 +00:00
|
|
|
case aListKeys:
|
2004-04-22 13:03:44 +00:00
|
|
|
case aDumpKeys:
|
2003-08-05 17:11:04 +00:00
|
|
|
case aListExternalKeys:
|
2004-04-22 13:03:44 +00:00
|
|
|
case aDumpExternalKeys:
|
2003-08-05 17:11:04 +00:00
|
|
|
case aListSecretKeys:
|
2004-04-22 13:03:44 +00:00
|
|
|
case aDumpSecretKeys:
|
2006-09-13 15:57:30 +00:00
|
|
|
{
|
|
|
|
unsigned int mode;
|
2007-03-19 14:35:04 +00:00
|
|
|
estream_t fp;
|
2006-09-13 15:57:30 +00:00
|
|
|
|
|
|
|
switch (cmd)
|
|
|
|
{
|
|
|
|
case aListChain:
|
|
|
|
case aListKeys: mode = (0 | 0 | (1<<6)); break;
|
|
|
|
case aDumpChain:
|
|
|
|
case aDumpKeys: mode = (256 | 0 | (1<<6)); break;
|
|
|
|
case aListExternalKeys: mode = (0 | 0 | (1<<7)); break;
|
|
|
|
case aDumpExternalKeys: mode = (256 | 0 | (1<<7)); break;
|
|
|
|
case aListSecretKeys: mode = (0 | 2 | (1<<6)); break;
|
|
|
|
case aDumpSecretKeys: mode = (256 | 2 | (1<<6)); break;
|
|
|
|
default: BUG();
|
|
|
|
}
|
|
|
|
|
2007-03-19 14:35:04 +00:00
|
|
|
fp = open_es_fwrite (opt.outfile?opt.outfile:"-");
|
2006-09-13 15:57:30 +00:00
|
|
|
for (sl=NULL; argc; argc--, argv++)
|
|
|
|
add_to_strlist (&sl, *argv);
|
|
|
|
gpgsm_list_keys (&ctrl, sl, fp, mode);
|
|
|
|
free_strlist(sl);
|
2007-03-19 14:35:04 +00:00
|
|
|
es_fclose (fp);
|
2006-09-13 15:57:30 +00:00
|
|
|
}
|
2004-04-22 13:03:44 +00:00
|
|
|
break;
|
|
|
|
|
2006-09-13 15:57:30 +00:00
|
|
|
|
2007-01-31 14:24:41 +00:00
|
|
|
case aKeygen: /* Generate a key; well kind of. */
|
2007-06-21 18:44:48 +00:00
|
|
|
{
|
2009-07-01 18:30:33 +00:00
|
|
|
estream_t fpin = NULL;
|
2010-03-08 18:19:21 +00:00
|
|
|
estream_t fpout;
|
2009-07-01 18:30:33 +00:00
|
|
|
|
|
|
|
if (opt.batch)
|
|
|
|
{
|
|
|
|
if (!argc) /* Create from stdin. */
|
2010-04-14 11:24:02 +00:00
|
|
|
fpin = open_es_fread ("-", "r");
|
2009-07-01 18:30:33 +00:00
|
|
|
else if (argc == 1) /* From file. */
|
2010-04-14 11:24:02 +00:00
|
|
|
fpin = open_es_fread (*argv, "r");
|
2009-07-01 18:30:33 +00:00
|
|
|
else
|
|
|
|
wrong_args ("--gen-key --batch [parmfile]");
|
|
|
|
}
|
|
|
|
|
2010-03-08 18:19:21 +00:00
|
|
|
fpout = open_es_fwrite (opt.outfile?opt.outfile:"-");
|
2009-07-01 18:30:33 +00:00
|
|
|
|
|
|
|
if (fpin)
|
|
|
|
gpgsm_genkey (&ctrl, fpin, fpout);
|
|
|
|
else
|
|
|
|
gpgsm_gencertreq_tty (&ctrl, fpout);
|
|
|
|
|
2010-03-08 18:19:21 +00:00
|
|
|
es_fclose (fpout);
|
2007-06-21 18:44:48 +00:00
|
|
|
}
|
2003-08-05 17:11:04 +00:00
|
|
|
break;
|
|
|
|
|
2007-06-21 18:44:48 +00:00
|
|
|
|
2003-08-05 17:11:04 +00:00
|
|
|
case aImport:
|
|
|
|
gpgsm_import_files (&ctrl, argc, argv, open_read);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case aExport:
|
2006-08-29 16:18:30 +00:00
|
|
|
{
|
2010-03-08 18:19:21 +00:00
|
|
|
estream_t fp;
|
2006-08-29 16:18:30 +00:00
|
|
|
|
2010-03-08 18:19:21 +00:00
|
|
|
fp = open_es_fwrite (opt.outfile?opt.outfile:"-");
|
2006-08-29 16:18:30 +00:00
|
|
|
for (sl=NULL; argc; argc--, argv++)
|
|
|
|
add_to_strlist (&sl, *argv);
|
2010-03-08 18:19:21 +00:00
|
|
|
gpgsm_export (&ctrl, sl, fp);
|
2006-08-29 16:18:30 +00:00
|
|
|
free_strlist(sl);
|
2010-03-08 18:19:21 +00:00
|
|
|
es_fclose (fp);
|
2006-08-29 16:18:30 +00:00
|
|
|
}
|
2003-08-05 17:11:04 +00:00
|
|
|
break;
|
|
|
|
|
2004-02-19 16:26:32 +00:00
|
|
|
case aExportSecretKeyP12:
|
2006-08-29 16:18:30 +00:00
|
|
|
{
|
2010-06-21 10:01:24 +00:00
|
|
|
estream_t fp = open_es_fwrite (opt.outfile?opt.outfile:"-");
|
2006-08-29 16:18:30 +00:00
|
|
|
|
|
|
|
if (argc == 1)
|
2008-05-20 08:00:40 +00:00
|
|
|
gpgsm_p12_export (&ctrl, *argv, fp);
|
2006-08-29 16:18:30 +00:00
|
|
|
else
|
|
|
|
wrong_args ("--export-secret-key-p12 KEY-ID");
|
2010-06-21 10:01:24 +00:00
|
|
|
if (fp != es_stdout)
|
|
|
|
es_fclose (fp);
|
2006-08-29 16:18:30 +00:00
|
|
|
}
|
2004-02-19 16:26:32 +00:00
|
|
|
break;
|
2003-08-05 17:11:04 +00:00
|
|
|
|
|
|
|
case aSendKeys:
|
|
|
|
case aRecvKeys:
|
|
|
|
log_error ("this command has not yet been implemented\n");
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
|
|
case aLearnCard:
|
|
|
|
if (argc)
|
|
|
|
wrong_args ("--learn-card");
|
|
|
|
else
|
|
|
|
{
|
2004-04-26 13:29:09 +00:00
|
|
|
int rc = gpgsm_agent_learn (&ctrl);
|
2003-08-05 17:11:04 +00:00
|
|
|
if (rc)
|
|
|
|
log_error ("error learning card: %s\n", gpg_strerror (rc));
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case aPasswd:
|
|
|
|
if (argc != 1)
|
|
|
|
wrong_args ("--passwd <key-Id>");
|
|
|
|
else
|
|
|
|
{
|
|
|
|
int rc;
|
2003-12-17 12:28:24 +00:00
|
|
|
ksba_cert_t cert = NULL;
|
2003-08-05 17:11:04 +00:00
|
|
|
char *grip = NULL;
|
|
|
|
|
2005-04-18 10:44:46 +00:00
|
|
|
rc = gpgsm_find_cert (*argv, NULL, &cert);
|
2003-08-05 17:11:04 +00:00
|
|
|
if (rc)
|
|
|
|
;
|
|
|
|
else if (!(grip = gpgsm_get_keygrip_hexstring (cert)))
|
|
|
|
rc = gpg_error (GPG_ERR_BUG);
|
|
|
|
else
|
2004-02-21 13:05:52 +00:00
|
|
|
{
|
|
|
|
char *desc = gpgsm_format_keydesc (cert);
|
2004-04-26 13:29:09 +00:00
|
|
|
rc = gpgsm_agent_passwd (&ctrl, grip, desc);
|
2004-02-21 13:05:52 +00:00
|
|
|
xfree (desc);
|
|
|
|
}
|
2003-08-05 17:11:04 +00:00
|
|
|
if (rc)
|
|
|
|
log_error ("error changing passphrase: %s\n", gpg_strerror (rc));
|
|
|
|
xfree (grip);
|
|
|
|
ksba_cert_release (cert);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2004-04-28 08:59:34 +00:00
|
|
|
case aKeydbClearSomeCertFlags:
|
|
|
|
for (sl=NULL; argc; argc--, argv++)
|
|
|
|
add_to_strlist (&sl, *argv);
|
|
|
|
keydb_clear_some_cert_flags (&ctrl, sl);
|
|
|
|
free_strlist(sl);
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
2003-08-05 17:11:04 +00:00
|
|
|
default:
|
2008-05-09 09:54:35 +00:00
|
|
|
log_error (_("invalid command (there is no implicit command)\n"));
|
2003-08-05 17:11:04 +00:00
|
|
|
break;
|
|
|
|
}
|
2007-12-12 10:28:30 +00:00
|
|
|
|
|
|
|
/* Print the audit result if needed. */
|
2009-12-02 18:33:59 +00:00
|
|
|
if ((auditlog && auditfp) || (htmlauditlog && htmlauditfp))
|
2007-12-12 10:28:30 +00:00
|
|
|
{
|
2009-12-02 18:33:59 +00:00
|
|
|
if (auditlog && auditfp)
|
|
|
|
audit_print_result (ctrl.audit, auditfp, 0);
|
|
|
|
if (htmlauditlog && htmlauditfp)
|
|
|
|
audit_print_result (ctrl.audit, htmlauditfp, 1);
|
2007-12-12 10:28:30 +00:00
|
|
|
audit_release (ctrl.audit);
|
|
|
|
ctrl.audit = NULL;
|
|
|
|
es_fclose (auditfp);
|
2009-12-02 18:33:59 +00:00
|
|
|
es_fclose (htmlauditfp);
|
2007-12-12 10:28:30 +00:00
|
|
|
}
|
2003-08-05 17:11:04 +00:00
|
|
|
|
|
|
|
/* cleanup */
|
2008-06-12 14:24:46 +00:00
|
|
|
keyserver_list_free (opt.keyserver);
|
|
|
|
opt.keyserver = NULL;
|
2003-08-05 17:11:04 +00:00
|
|
|
gpgsm_release_certlist (recplist);
|
|
|
|
gpgsm_release_certlist (signerlist);
|
2006-10-02 11:54:35 +00:00
|
|
|
FREE_STRLIST (remusr);
|
|
|
|
FREE_STRLIST (locusr);
|
2003-08-05 17:11:04 +00:00
|
|
|
gpgsm_exit(0);
|
2006-10-02 11:54:35 +00:00
|
|
|
return 8; /*NOTREACHED*/
|
2003-08-05 17:11:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Note: This function is used by signal handlers!. */
|
|
|
|
static void
|
|
|
|
emergency_cleanup (void)
|
|
|
|
{
|
|
|
|
gcry_control (GCRYCTL_TERM_SECMEM );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
gpgsm_exit (int rc)
|
|
|
|
{
|
|
|
|
gcry_control (GCRYCTL_UPDATE_RANDOM_SEED_FILE);
|
|
|
|
if (opt.debug & DBG_MEMSTAT_VALUE)
|
|
|
|
{
|
|
|
|
gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
|
|
|
|
gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
|
|
|
|
}
|
|
|
|
if (opt.debug)
|
|
|
|
gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
|
|
|
|
emergency_cleanup ();
|
|
|
|
rc = rc? rc : log_get_errorcount(0)? 2 : gpgsm_errors_seen? 1 : 0;
|
|
|
|
exit (rc);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
gpgsm_init_default_ctrl (struct server_control_s *ctrl)
|
|
|
|
{
|
2006-06-20 17:21:37 +00:00
|
|
|
ctrl->include_certs = default_include_certs;
|
2003-12-01 10:54:30 +00:00
|
|
|
ctrl->use_ocsp = opt.enable_ocsp;
|
2007-08-10 16:52:05 +00:00
|
|
|
ctrl->validation_model = default_validation_model;
|
2003-08-05 17:11:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-08-10 16:52:05 +00:00
|
|
|
int
|
|
|
|
gpgsm_parse_validation_model (const char *model)
|
|
|
|
{
|
|
|
|
if (!ascii_strcasecmp (model, "shell") )
|
|
|
|
return 0;
|
|
|
|
else if ( !ascii_strcasecmp (model, "chain") )
|
|
|
|
return 1;
|
|
|
|
else
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2003-08-05 17:11:04 +00:00
|
|
|
|
|
|
|
/* Check whether the filename has the form "-&nnnn", where n is a
|
|
|
|
non-zero number. Returns this number or -1 if it is not the case. */
|
|
|
|
static int
|
2007-06-25 11:54:43 +00:00
|
|
|
check_special_filename (const char *fname, int for_write)
|
2003-08-05 17:11:04 +00:00
|
|
|
{
|
|
|
|
if (allow_special_filenames
|
|
|
|
&& fname && *fname == '-' && fname[1] == '&' ) {
|
|
|
|
int i;
|
|
|
|
|
|
|
|
fname += 2;
|
|
|
|
for (i=0; isdigit (fname[i]); i++ )
|
|
|
|
;
|
|
|
|
if ( !fname[i] )
|
2007-07-12 15:28:30 +00:00
|
|
|
return translate_sys2libc_fd_int (atoi (fname), for_write);
|
2003-08-05 17:11:04 +00:00
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2010-03-08 12:22:18 +00:00
|
|
|
/* Open the FILENAME for read and return the file descriptor. Stop
|
2003-08-05 17:11:04 +00:00
|
|
|
with an error message in case of problems. "-" denotes stdin and
|
2010-03-08 12:22:18 +00:00
|
|
|
if special filenames are allowed the given fd is opened instead. */
|
2003-08-05 17:11:04 +00:00
|
|
|
static int
|
|
|
|
open_read (const char *filename)
|
|
|
|
{
|
|
|
|
int fd;
|
|
|
|
|
|
|
|
if (filename[0] == '-' && !filename[1])
|
2004-12-22 17:55:28 +00:00
|
|
|
{
|
|
|
|
set_binary (stdin);
|
|
|
|
return 0; /* stdin */
|
|
|
|
}
|
2007-06-25 11:54:43 +00:00
|
|
|
fd = check_special_filename (filename, 0);
|
2003-08-05 17:11:04 +00:00
|
|
|
if (fd != -1)
|
|
|
|
return fd;
|
2004-12-22 17:55:28 +00:00
|
|
|
fd = open (filename, O_RDONLY | O_BINARY);
|
2003-08-05 17:11:04 +00:00
|
|
|
if (fd == -1)
|
|
|
|
{
|
|
|
|
log_error (_("can't open `%s': %s\n"), filename, strerror (errno));
|
|
|
|
gpgsm_exit (2);
|
|
|
|
}
|
|
|
|
return fd;
|
|
|
|
}
|
|
|
|
|
2009-07-01 18:30:33 +00:00
|
|
|
/* Same as open_read but return an estream_t. */
|
|
|
|
static estream_t
|
2010-04-14 11:24:02 +00:00
|
|
|
open_es_fread (const char *filename, const char *mode)
|
2009-07-01 18:30:33 +00:00
|
|
|
{
|
|
|
|
int fd;
|
|
|
|
estream_t fp;
|
|
|
|
|
|
|
|
if (filename[0] == '-' && !filename[1])
|
|
|
|
fd = fileno (stdin);
|
|
|
|
else
|
|
|
|
fd = check_special_filename (filename, 0);
|
|
|
|
if (fd != -1)
|
|
|
|
{
|
2010-04-14 11:24:02 +00:00
|
|
|
fp = es_fdopen_nc (fd, mode);
|
2009-07-01 18:30:33 +00:00
|
|
|
if (!fp)
|
|
|
|
{
|
|
|
|
log_error ("es_fdopen(%d) failed: %s\n", fd, strerror (errno));
|
|
|
|
gpgsm_exit (2);
|
|
|
|
}
|
|
|
|
return fp;
|
|
|
|
}
|
2010-04-14 11:24:02 +00:00
|
|
|
fp = es_fopen (filename, mode);
|
2009-07-01 18:30:33 +00:00
|
|
|
if (!fp)
|
|
|
|
{
|
|
|
|
log_error (_("can't open `%s': %s\n"), filename, strerror (errno));
|
|
|
|
gpgsm_exit (2);
|
|
|
|
}
|
|
|
|
return fp;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-03-19 14:35:04 +00:00
|
|
|
/* Open FILENAME for fwrite and return an extended stream. Stop with
|
|
|
|
an error message in case of problems. "-" denotes stdout and if
|
|
|
|
special filenames are allowed the given fd is opened instead.
|
|
|
|
Caller must close the returned stream. */
|
|
|
|
static estream_t
|
|
|
|
open_es_fwrite (const char *filename)
|
|
|
|
{
|
|
|
|
int fd;
|
|
|
|
estream_t fp;
|
|
|
|
|
|
|
|
if (filename[0] == '-' && !filename[1])
|
|
|
|
{
|
|
|
|
fflush (stdout);
|
2007-06-25 11:54:43 +00:00
|
|
|
fp = es_fdopen_nc (fileno(stdout), "wb");
|
2007-03-19 14:35:04 +00:00
|
|
|
return fp;
|
|
|
|
}
|
|
|
|
|
2007-06-25 11:54:43 +00:00
|
|
|
fd = check_special_filename (filename, 1);
|
2007-03-19 14:35:04 +00:00
|
|
|
if (fd != -1)
|
|
|
|
{
|
2007-06-25 11:54:43 +00:00
|
|
|
fp = es_fdopen_nc (fd, "wb");
|
2007-03-19 14:35:04 +00:00
|
|
|
if (!fp)
|
|
|
|
{
|
|
|
|
log_error ("es_fdopen(%d) failed: %s\n", fd, strerror (errno));
|
|
|
|
gpgsm_exit (2);
|
|
|
|
}
|
|
|
|
return fp;
|
|
|
|
}
|
|
|
|
fp = es_fopen (filename, "wb");
|
|
|
|
if (!fp)
|
|
|
|
{
|
|
|
|
log_error (_("can't open `%s': %s\n"), filename, strerror (errno));
|
|
|
|
gpgsm_exit (2);
|
|
|
|
}
|
|
|
|
return fp;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2003-08-05 17:11:04 +00:00
|
|
|
static void
|
|
|
|
run_protect_tool (int argc, char **argv)
|
|
|
|
{
|
2004-12-15 14:15:54 +00:00
|
|
|
#ifndef HAVE_W32_SYSTEM
|
2004-02-13 12:40:23 +00:00
|
|
|
const char *pgm;
|
2003-08-05 17:11:04 +00:00
|
|
|
char **av;
|
|
|
|
int i;
|
|
|
|
|
2004-02-13 12:40:23 +00:00
|
|
|
if (!opt.protect_tool_program || !*opt.protect_tool_program)
|
2007-06-14 17:05:07 +00:00
|
|
|
pgm = gnupg_module_name (GNUPG_MODULE_NAME_PROTECT_TOOL);
|
2004-02-13 12:40:23 +00:00
|
|
|
else
|
|
|
|
pgm = opt.protect_tool_program;
|
|
|
|
|
2003-08-05 17:11:04 +00:00
|
|
|
av = xcalloc (argc+2, sizeof *av);
|
|
|
|
av[0] = strrchr (pgm, '/');
|
|
|
|
if (!av[0])
|
2004-02-13 12:40:23 +00:00
|
|
|
av[0] = xstrdup (pgm);
|
2003-08-05 17:11:04 +00:00
|
|
|
for (i=1; argc; i++, argc--, argv++)
|
|
|
|
av[i] = *argv;
|
|
|
|
av[i] = NULL;
|
|
|
|
execv (pgm, av);
|
|
|
|
log_error ("error executing `%s': %s\n", pgm, strerror (errno));
|
2004-12-15 14:15:54 +00:00
|
|
|
#endif /*HAVE_W32_SYSTEM*/
|
2003-08-05 17:11:04 +00:00
|
|
|
gpgsm_exit (2);
|
|
|
|
}
|