No OneTemporary
Actions

Size

138 KB

Subscribers

None

View Options

	diff --git a/doc/gpgsm.texi b/doc/gpgsm.texi
	index 5e9a1b181..1c329a713 100644
	--- a/doc/gpgsm.texi
	+++ b/doc/gpgsm.texi
	@@ -1,1643 +1,1648 @@
	@c Copyright (C) 2002 Free Software Foundation, Inc.
	@c This is part of the GnuPG manual.
	@c For copying conditions, see the file gnupg.texi.

	@include defs.inc

	@node Invoking GPGSM
	@chapter Invoking GPGSM
	@cindex GPGSM command options
	@cindex command options
	@cindex options, GPGSM command

	@manpage gpgsm.1
	@ifset manverb
	.B gpgsm
	\- CMS encryption and signing tool
	@end ifset

	@mansect synopsis
	@ifset manverb
	.B gpgsm
	.RB [ \-\-homedir
	.IR dir ]
	.RB [ \-\-options
	.IR file ]
	.RI [ options ]
	.I command
	.RI [ args ]
	@end ifset


	@mansect description
	@command{gpgsm} is a tool similar to @command{gpg} to provide digital
	encryption and signing services on X.509 certificates and the CMS
	protocol. It is mainly used as a backend for S/MIME mail processing.
	@command{gpgsm} includes a full featured certificate management and
	complies with all rules defined for the German Sphinx project.

	@manpause
	@xref{Option Index}, for an index to @command{GPGSM}'s commands and options.
	@mancont

	@menu
	* GPGSM Commands:: List of all commands.
	* GPGSM Options:: List of all options.
	* GPGSM Configuration:: Configuration files.
	* GPGSM Examples:: Some usage examples.

	Developer information:
	* Unattended Usage:: Using @command{gpgsm} from other programs.
	* GPGSM Protocol:: The protocol the server mode uses.
	@end menu

	@c *******************************************
	@c ************* **************
	@c ************* COMMANDS **************
	@c ************* **************
	@c *******************************************
	@mansect commands
	@node GPGSM Commands
	@section Commands

	Commands are not distinguished from options except for the fact that
	only one command is allowed.

	@menu
	* General GPGSM Commands:: Commands not specific to the functionality.
	* Operational GPGSM Commands:: Commands to select the type of operation.
	* Certificate Management:: How to manage certificates.
	@end menu


	@c *******************************************
	@c ******** GENERAL COMMANDS ***********
	@c *******************************************
	@node General GPGSM Commands
	@subsection Commands not specific to the function

	@table @gnupgtabopt
	@item --version
	@opindex version
	Print the program version and licensing information. Note that you
	cannot abbreviate this command.

	@item --help, -h
	@opindex help
	Print a usage message summarizing the most useful command-line options.
	Note that you cannot abbreviate this command.

	@item --warranty
	@opindex warranty
	Print warranty information. Note that you cannot abbreviate this
	command.

	@item --dump-options
	@opindex dump-options
	Print a list of all available options and commands. Note that you cannot
	abbreviate this command.
	@end table


	@c *******************************************
	@c ****** OPERATIONAL COMMANDS *********
	@c *******************************************
	@node Operational GPGSM Commands
	@subsection Commands to select the type of operation

	@table @gnupgtabopt
	@item --encrypt
	@opindex encrypt
	Perform an encryption. The keys the data is encrypted to must be set
	using the option @option{--recipient}.

	@item --decrypt
	@opindex decrypt
	Perform a decryption; the type of input is automatically determined. It
	may either be in binary form or PEM encoded; automatic determination of
	base-64 encoding is not done.

	@item --sign
	@opindex sign
	Create a digital signature. The key used is either the fist one found
	in the keybox or those set with the @option{--local-user} option.

	@item --verify
	@opindex verify
	Check a signature file for validity. Depending on the arguments a
	detached signature may also be checked.

	@item --server
	@opindex server
	Run in server mode and wait for commands on the @code{stdin}.

	@item --call-dirmngr @var{command} [@var{args}]
	@opindex call-dirmngr
	Behave as a Dirmngr client issuing the request @var{command} with the
	optional list of @var{args}. The output of the Dirmngr is printed
	stdout. Please note that file names given as arguments should have an
	absolute file name (i.e. commencing with @code{/}) because they are
	passed verbatim to the Dirmngr and the working directory of the
	Dirmngr might not be the same as the one of this client. Currently it
	is not possible to pass data via stdin to the Dirmngr. @var{command}
	should not contain spaces.

	This is command is required for certain maintaining tasks of the dirmngr
	where a dirmngr must be able to call back to @command{gpgsm}. See the Dirmngr
	manual for details.

	@item --call-protect-tool @var{arguments}
	@opindex call-protect-tool
	Certain maintenance operations are done by an external program call
	@command{gpg-protect-tool}; this is usually not installed in a directory
	listed in the PATH variable. This command provides a simple wrapper to
	access this tool. @var{arguments} are passed verbatim to this command;
	use @samp{--help} to get a list of supported operations.


	@end table


	@c *******************************************
	@c ***** CERTIFICATE MANAGEMENT ********
	@c *******************************************
	@node Certificate Management
	@subsection How to manage the certificates and keys

	@table @gnupgtabopt
	@item --generate-key
	@opindex generate-key
	@itemx --gen-key
	@opindex gen-key
	This command allows the creation of a certificate signing request or a
	self-signed certificate. It is commonly used along with the
	@option{--output} option to save the created CSR or certificate into a
	file. If used with the @option{--batch} a parameter file is used to
	create the CSR or certificate and it is further possible to create
	non-self-signed certificates.

	@item --list-keys
	@itemx -k
	@opindex list-keys
	List all available certificates stored in the local key database.
	Note that the displayed data might be reformatted for better human
	readability and illegal characters are replaced by safe substitutes.

	@item --list-secret-keys
	@itemx -K
	@opindex list-secret-keys
	List all available certificates for which a corresponding a secret key
	is available.

	@item --list-external-keys @var{pattern}
	@opindex list-keys
	List certificates matching @var{pattern} using an external server. This
	utilizes the @code{dirmngr} service.

	@item --list-chain
	@opindex list-chain
	Same as @option{--list-keys} but also prints all keys making up the chain.


	@item --dump-cert
	@itemx --dump-keys
	@opindex dump-cert
	@opindex dump-keys
	List all available certificates stored in the local key database using a
	format useful mainly for debugging.

	@item --dump-chain
	@opindex dump-chain
	Same as @option{--dump-keys} but also prints all keys making up the chain.

	@item --dump-secret-keys
	@opindex dump-secret-keys
	List all available certificates for which a corresponding a secret key
	is available using a format useful mainly for debugging.

	@item --dump-external-keys @var{pattern}
	@opindex dump-external-keys
	List certificates matching @var{pattern} using an external server.
	This utilizes the @code{dirmngr} service. It uses a format useful
	mainly for debugging.

	@item --keydb-clear-some-cert-flags
	@opindex keydb-clear-some-cert-flags
	This is a debugging aid to reset certain flags in the key database
	which are used to cache certain certificate stati. It is especially
	useful if a bad CRL or a weird running OCSP responder did accidentally
	revoke certificate. There is no security issue with this command
	because @command{gpgsm} always make sure that the validity of a certificate is
	checked right before it is used.

	@item --delete-keys @var{pattern}
	@opindex delete-keys
	Delete the keys matching @var{pattern}. Note that there is no command
	to delete the secret part of the key directly. In case you need to do
	this, you should run the command @code{gpgsm --dump-secret-keys KEYID}
	before you delete the key, copy the string of hex-digits in the
	``keygrip'' line and delete the file consisting of these hex-digits
	and the suffix @code{.key} from the @file{private-keys-v1.d} directory
	below our GnuPG home directory (usually @file{~/.gnupg}).

	@item --export [@var{pattern}]
	@opindex export
	Export all certificates stored in the Keybox or those specified by the
	optional @var{pattern}. Those pattern consist of a list of user ids
	(@pxref{how-to-specify-a-user-id}). When used along with the
	@option{--armor} option a few informational lines are prepended before
	each block. There is one limitation: As there is no commonly agreed
	upon way to pack more than one certificate into an ASN.1 structure,
	the binary export (i.e. without using @option{armor}) works only for
	the export of one certificate. Thus it is required to specify a
	@var{pattern} which yields exactly one certificate. Ephemeral
	certificate are only exported if all @var{pattern} are given as
	fingerprints or keygrips.

	@item --export-secret-key-p12 @var{key-id}
	@opindex export-secret-key-p12
	Export the private key and the certificate identified by @var{key-id}
	using the PKCS#12 format. When used with the @code{--armor} option a few
	informational lines are prepended to the output. Note, that the PKCS#12
	format is not very secure and proper transport security should be used
	to convey the exported key. (@xref{option --p12-charset}.)

	@item --export-secret-key-p8 @var{key-id}
	@itemx --export-secret-key-raw @var{key-id}
	@opindex export-secret-key-p8
	@opindex export-secret-key-raw
	Export the private key of the certificate identified by @var{key-id}
	with any encryption stripped. The @code{...-raw} command exports in
	PKCS#1 format; the @code{...-p8} command exports in PKCS#8 format.
	When used with the @code{--armor} option a few informational lines are
	prepended to the output. These commands are useful to prepare a key
	for use on a TLS server.

	@item --import [@var{files}]
	@opindex import
	Import the certificates from the PEM or binary encoded files as well as
	from signed-only messages. This command may also be used to import a
	secret key from a PKCS#12 file.

	@item --learn-card
	@opindex learn-card
	Read information about the private keys from the smartcard and import
	the certificates from there. This command utilizes the @command{gpg-agent}
	and in turn the @command{scdaemon}.

	@item --change-passphrase @var{user_id}
	@opindex change-passphrase
	@itemx --passwd @var{user_id}
	@opindex passwd
	Change the passphrase of the private key belonging to the certificate
	specified as @var{user_id}. Note, that changing the passphrase/PIN of a
	smartcard is not yet supported.

	@end table


	@c *******************************************
	@c ************* **************
	@c ************* OPTIONS **************
	@c ************* **************
	@c *******************************************
	@mansect options
	@node GPGSM Options
	@section Option Summary

	@command{GPGSM} features a bunch of options to control the exact behaviour
	and to change the default configuration.

	@menu
	* Configuration Options:: How to change the configuration.
	* Certificate Options:: Certificate related options.
	* Input and Output:: Input and Output.
	* CMS Options:: How to change how the CMS is created.
	* Esoteric Options:: Doing things one usually do not want to do.
	@end menu


	@c *******************************************
	@c ****** CONFIGURATION OPTIONS ********
	@c *******************************************
	@node Configuration Options
	@subsection How to change the configuration

	These options are used to change the configuration and are usually found
	in the option file.

	@table @gnupgtabopt

	@anchor{gpgsm-option --options}
	@item --options @var{file}
	@opindex options
	Reads configuration from @var{file} instead of from the default
	per-user configuration file. The default configuration file is named
	@file{gpgsm.conf} and expected in the @file{.gnupg} directory directly
	below the home directory of the user.

	@include opt-homedir.texi


	@item -v
	@item --verbose
	@opindex v
	@opindex verbose
	Outputs additional information while running.
	You can increase the verbosity by giving several
	verbose commands to @command{gpgsm}, such as @samp{-vv}.

	@item --policy-file @var{filename}
	@opindex policy-file
	Change the default name of the policy file to @var{filename}.

	@item --agent-program @var{file}
	@opindex agent-program
	Specify an agent program to be used for secret key operations. The
	default value is determined by running the command @command{gpgconf}.
	Note that the pipe symbol (@code{\|}) is used for a regression test
	suite hack and may thus not be used in the file name.

	@item --dirmngr-program @var{file}
	@opindex dirmngr-program
	Specify a dirmngr program to be used for @acronym{CRL} checks. The
	default value is @file{@value{BINDIR}/dirmngr}.

	@item --prefer-system-dirmngr
	@opindex prefer-system-dirmngr
	This option is obsolete and ignored.

	@item --disable-dirmngr
	Entirely disable the use of the Dirmngr.

	@item --no-autostart
	@opindex no-autostart
	Do not start the gpg-agent or the dirmngr if it has not yet been
	started and its service is required. This option is mostly useful on
	machines where the connection to gpg-agent has been redirected to
	another machines. If dirmngr is required on the remote machine, it
	may be started manually using @command{gpgconf --launch dirmngr}.

	@item --no-secmem-warning
	@opindex no-secmem-warning
	Do not print a warning when the so called "secure memory" cannot be used.

	@item --log-file @var{file}
	@opindex log-file
	When running in server mode, append all logging output to @var{file}.
	Use @file{socket://} to log to socket.

	@end table


	@c *******************************************
	@c ****** CERTIFICATE OPTIONS **********
	@c *******************************************
	@node Certificate Options
	@subsection Certificate related options

	@table @gnupgtabopt

	@item --enable-policy-checks
	@itemx --disable-policy-checks
	@opindex enable-policy-checks
	@opindex disable-policy-checks
	By default policy checks are enabled. These options may be used to
	change it.

	@item --enable-crl-checks
	@itemx --disable-crl-checks
	@opindex enable-crl-checks
	@opindex disable-crl-checks
	-By default the @acronym{CRL} checks are enabled and the DirMngr is used
	-to check for revoked certificates. The disable option is most useful
	-with an off-line network connection to suppress this check.
	+By default the @acronym{CRL} checks are enabled and the DirMngr is
	+used to check for revoked certificates. The disable option is most
	+useful with an off-line network connection to suppress this check and
	+also to avoid that new certificates introduce a web bug by including a
	+certificate specific CRL DP. The disable option also disables an
	+issuer certificate lookup via the authorityInfoAccess property of the
	+certificate; the @option{--enable-issuer-key-retrieve} can be used
	+to make use of that property anyway.

	@item --enable-trusted-cert-crl-check
	@itemx --disable-trusted-cert-crl-check
	@opindex enable-trusted-cert-crl-check
	@opindex disable-trusted-cert-crl-check
	By default the @acronym{CRL} for trusted root certificates are checked
	like for any other certificates. This allows a CA to revoke its own
	certificates voluntary without the need of putting all ever issued
	certificates into a CRL. The disable option may be used to switch this
	extra check off. Due to the caching done by the Dirmngr, there will not be
	any noticeable performance gain. Note, that this also disables possible
	OCSP checks for trusted root certificates. A more specific way of
	disabling this check is by adding the ``relax'' keyword to the root CA
	line of the @file{trustlist.txt}


	@item --force-crl-refresh
	@opindex force-crl-refresh
	Tell the dirmngr to reload the CRL for each request. For better
	performance, the dirmngr will actually optimize this by suppressing
	the loading for short time intervals (e.g. 30 minutes). This option
	is useful to make sure that a fresh CRL is available for certificates
	hold in the keybox. The suggested way of doing this is by using it
	along with the option @option{--with-validation} for a key listing
	command. This option should not be used in a configuration file.

	@item --enable-issuer-based-crl-check
	@opindex enable-issuer-based-crl-check
	Run a CRL check even for certificates which do not have any CRL
	distribution point. This requires that a suitable LDAP server has
	been configured in Dirmngr and that the CRL can be found using the
	issuer. This option reverts to what GnuPG did up to version 2.2.20.
	This option is in general not useful.

	@item --enable-ocsp
	@itemx --disable-ocsp
	@opindex enable-ocsp
	@opindex disable-ocsp
	By default @acronym{OCSP} checks are disabled. The enable option may
	be used to enable OCSP checks via Dirmngr. If @acronym{CRL} checks
	are also enabled, CRLs will be used as a fallback if for some reason an
	OCSP request will not succeed. Note, that you have to allow OCSP
	requests in Dirmngr's configuration too (option
	@option{--allow-ocsp}) and configure Dirmngr properly. If you do not do
	so you will get the error code @samp{Not supported}.

	@item --auto-issuer-key-retrieve
	@opindex auto-issuer-key-retrieve
	If a required certificate is missing while validating the chain of
	certificates, try to load that certificate from an external location.
	This usually means that Dirmngr is employed to search for the
	certificate. Note that this option makes a "web bug" like behavior
	possible. LDAP server operators can see which keys you request, so by
	sending you a message signed by a brand new key (which you naturally
	will not have on your local keybox), the operator can tell both your IP
	address and the time when you verified the signature.


	@anchor{gpgsm-option --validation-model}
	@item --validation-model @var{name}
	@opindex validation-model
	This option changes the default validation model. The only possible
	values are "shell" (which is the default), "chain" which forces the
	use of the chain model and "steed" for a new simplified model. The
	chain model is also used if an option in the @file{trustlist.txt} or
	an attribute of the certificate requests it. However the standard
	model (shell) is in that case always tried first.

	@item --ignore-cert-extension @var{oid}
	@opindex ignore-cert-extension
	Add @var{oid} to the list of ignored certificate extensions. The
	@var{oid} is expected to be in dotted decimal form, like
	@code{2.5.29.3}. This option may be used more than once. Critical
	flagged certificate extensions matching one of the OIDs in the list
	are treated as if they are actually handled and thus the certificate
	will not be rejected due to an unknown critical extension. Use this
	option with care because extensions are usually flagged as critical
	for a reason.

	@end table

	@c *******************************************
	@c ********* INPUT AND OUTPUT **********
	@c *******************************************
	@node Input and Output
	@subsection Input and Output

	@table @gnupgtabopt
	@item --armor
	@itemx -a
	@opindex armor
	Create PEM encoded output. Default is binary output.

	@item --base64
	@opindex base64
	Create Base-64 encoded output; i.e. PEM without the header lines.

	@item --assume-armor
	@opindex assume-armor
	Assume the input data is PEM encoded. Default is to autodetect the
	encoding but this is may fail.

	@item --assume-base64
	@opindex assume-base64
	Assume the input data is plain base-64 encoded.

	@item --assume-binary
	@opindex assume-binary
	Assume the input data is binary encoded.

	@anchor{option --p12-charset}
	@item --p12-charset @var{name}
	@opindex p12-charset
	@command{gpgsm} uses the UTF-8 encoding when encoding passphrases for
	PKCS#12 files. This option may be used to force the passphrase to be
	encoded in the specified encoding @var{name}. This is useful if the
	application used to import the key uses a different encoding and thus
	will not be able to import a file generated by @command{gpgsm}. Commonly
	used values for @var{name} are @code{Latin1} and @code{CP850}. Note
	that @command{gpgsm} itself automagically imports any file with a
	passphrase encoded to the most commonly used encodings.


	@item --default-key @var{user_id}
	@opindex default-key
	Use @var{user_id} as the standard key for signing. This key is used if
	no other key has been defined as a signing key. Note, that the first
	@option{--local-users} option also sets this key if it has not yet been
	set; however @option{--default-key} always overrides this.


	@item --local-user @var{user_id}
	@item -u @var{user_id}
	@opindex local-user
	Set the user(s) to be used for signing. The default is the first
	secret key found in the database.


	@item --recipient @var{name}
	@itemx -r
	@opindex recipient
	Encrypt to the user id @var{name}. There are several ways a user id
	may be given (@pxref{how-to-specify-a-user-id}).


	@item --output @var{file}
	@itemx -o @var{file}
	@opindex output
	Write output to @var{file}. The default is to write it to stdout.


	@anchor{gpgsm-option --with-key-data}
	@item --with-key-data
	@opindex with-key-data
	Displays extra information with the @code{--list-keys} commands. Especially
	a line tagged @code{grp} is printed which tells you the keygrip of a
	key. This string is for example used as the file name of the
	secret key. Implies @code{--with-colons}.

	@anchor{gpgsm-option --with-validation}
	@item --with-validation
	@opindex with-validation
	When doing a key listing, do a full validation check for each key and
	print the result. This is usually a slow operation because it
	requires a CRL lookup and other operations.

	When used along with @option{--import}, a validation of the certificate to
	import is done and only imported if it succeeds the test. Note that
	this does not affect an already available certificate in the DB.
	This option is therefore useful to simply verify a certificate.


	@item --with-md5-fingerprint
	For standard key listings, also print the MD5 fingerprint of the
	certificate.

	@item --with-keygrip
	Include the keygrip in standard key listings. Note that the keygrip is
	always listed in @option{--with-colons} mode.

	@item --with-secret
	@opindex with-secret
	Include info about the presence of a secret key in public key listings
	done with @code{--with-colons}.

	@end table

	@c *******************************************
	@c *********** CMS OPTIONS *************
	@c *******************************************
	@node CMS Options
	@subsection How to change how the CMS is created

	@table @gnupgtabopt
	@item --include-certs @var{n}
	@opindex include-certs
	Using @var{n} of -2 includes all certificate except for the root cert,
	-1 includes all certs, 0 does not include any certs, 1 includes only the
	signers cert and all other positive values include up to @var{n}
	certificates starting with the signer cert. The default is -2.

	@item --cipher-algo @var{oid}
	@opindex cipher-algo
	Use the cipher algorithm with the ASN.1 object identifier @var{oid} for
	encryption. For convenience the strings @code{3DES}, @code{AES} and
	@code{AES256} may be used instead of their OIDs. The default is
	@code{AES} (2.16.840.1.101.3.4.1.2).

	@item --digest-algo @code{name}
	Use @code{name} as the message digest algorithm. Usually this
	algorithm is deduced from the respective signing certificate. This
	option forces the use of the given algorithm and may lead to severe
	interoperability problems.

	@end table



	@c *******************************************
	@c ****** ESOTERIC OPTIONS *************
	@c *******************************************
	@node Esoteric Options
	@subsection Doing things one usually do not want to do


	@table @gnupgtabopt

	@item --extra-digest-algo @var{name}
	@opindex extra-digest-algo
	Sometimes signatures are broken in that they announce a different digest
	algorithm than actually used. @command{gpgsm} uses a one-pass data
	processing model and thus needs to rely on the announced digest
	algorithms to properly hash the data. As a workaround this option may
	be used to tell @command{gpgsm} to also hash the data using the algorithm
	@var{name}; this slows processing down a little bit but allows verification of
	such broken signatures. If @command{gpgsm} prints an error like
	``digest algo 8 has not been enabled'' you may want to try this option,
	with @samp{SHA256} for @var{name}.


	@item --faked-system-time @var{epoch}
	@opindex faked-system-time
	This option is only useful for testing; it sets the system time back or
	forth to @var{epoch} which is the number of seconds elapsed since the year
	1970. Alternatively @var{epoch} may be given as a full ISO time string
	(e.g. "20070924T154812").

	@item --with-ephemeral-keys
	@opindex with-ephemeral-keys
	Include ephemeral flagged keys in the output of key listings. Note
	that they are included anyway if the key specification for a listing
	is given as fingerprint or keygrip.

	@item --debug-level @var{level}
	@opindex debug-level
	Select the debug level for investigating problems. @var{level} may be
	a numeric value or by a keyword:

	@table @code
	@item none
	No debugging at all. A value of less than 1 may be used instead of
	the keyword.
	@item basic
	Some basic debug messages. A value between 1 and 2 may be used
	instead of the keyword.
	@item advanced
	More verbose debug messages. A value between 3 and 5 may be used
	instead of the keyword.
	@item expert
	Even more detailed messages. A value between 6 and 8 may be used
	instead of the keyword.
	@item guru
	All of the debug messages you can get. A value greater than 8 may be
	used instead of the keyword. The creation of hash tracing files is
	only enabled if the keyword is used.
	@end table

	How these messages are mapped to the actual debugging flags is not
	specified and may change with newer releases of this program. They are
	however carefully selected to best aid in debugging.

	@item --debug @var{flags}
	@opindex debug
	This option is only useful for debugging and the behaviour may change
	at any time without notice; using @code{--debug-levels} is the
	preferred method to select the debug verbosity. FLAGS are bit encoded
	and may be given in usual C-Syntax. The currently defined bits are:

	@table @code
	@item 0 (1)
	X.509 or OpenPGP protocol related data
	@item 1 (2)
	values of big number integers
	@item 2 (4)
	low level crypto operations
	@item 5 (32)
	memory allocation
	@item 6 (64)
	caching
	@item 7 (128)
	show memory statistics
	@item 9 (512)
	write hashed data to files named @code{dbgmd-000*}
	@item 10 (1024)
	trace Assuan protocol
	@end table

	Note, that all flags set using this option may get overridden by
	@code{--debug-level}.

	@item --debug-all
	@opindex debug-all
	Same as @code{--debug=0xffffffff}

	@item --debug-allow-core-dump
	@opindex debug-allow-core-dump
	Usually @command{gpgsm} tries to avoid dumping core by well written code and by
	disabling core dumps for security reasons. However, bugs are pretty
	durable beasts and to squash them it is sometimes useful to have a core
	dump. This option enables core dumps unless the Bad Thing happened
	before the option parsing.

	@item --debug-no-chain-validation
	@opindex debug-no-chain-validation
	This is actually not a debugging option but only useful as such. It
	lets @command{gpgsm} bypass all certificate chain validation checks.

	@item --debug-ignore-expiration
	@opindex debug-ignore-expiration
	This is actually not a debugging option but only useful as such. It
	lets @command{gpgsm} ignore all notAfter dates, this is used by the regression
	tests.

	@item --passphrase-fd @code{n}
	@opindex passphrase-fd
	Read the passphrase from file descriptor @code{n}. Only the first line
	will be read from file descriptor @code{n}. If you use 0 for @code{n},
	the passphrase will be read from STDIN. This can only be used if only
	one passphrase is supplied.

	Note that this passphrase is only used if the option @option{--batch}
	has also been given.

	@item --pinentry-mode @code{mode}
	@opindex pinentry-mode
	Set the pinentry mode to @code{mode}. Allowed values for @code{mode}
	are:
	@table @asis
	@item default
	Use the default of the agent, which is @code{ask}.
	@item ask
	Force the use of the Pinentry.
	@item cancel
	Emulate use of Pinentry's cancel button.
	@item error
	Return a Pinentry error (``No Pinentry'').
	@item loopback
	Redirect Pinentry queries to the caller. Note that in contrast to
	Pinentry the user is not prompted again if he enters a bad password.
	@end table

	@item --request-origin @var{origin}
	@opindex request-origin
	Tell gpgsm to assume that the operation ultimately originated at
	@var{origin}. Depending on the origin certain restrictions are applied
	and the Pinentry may include an extra note on the origin. Supported
	values for @var{origin} are: @code{local} which is the default,
	@code{remote} to indicate a remote origin or @code{browser} for an
	operation requested by a web browser.

	@item --no-common-certs-import
	@opindex no-common-certs-import
	Suppress the import of common certificates on keybox creation.

	@end table

	All the long options may also be given in the configuration file after
	stripping off the two leading dashes.

	@c *******************************************
	@c ************* **************
	@c ************* USER ID **************
	@c ************* **************
	@c *******************************************
	@mansect how to specify a user id
	@ifset isman
	@include specify-user-id.texi
	@end ifset

	@c *******************************************
	@c ************* **************
	@c ************* FILES **************
	@c ************* **************
	@c *******************************************
	@mansect files
	@node GPGSM Configuration
	@section Configuration files

	There are a few configuration files to control certain aspects of
	@command{gpgsm}'s operation. Unless noted, they are expected in the
	current home directory (@pxref{option --homedir}).

	@table @file

	@item gpgsm.conf
	@efindex gpgsm.conf
	This is the standard configuration file read by @command{gpgsm} on
	startup. It may contain any valid long option; the leading two dashes
	may not be entered and the option may not be abbreviated. This default
	name may be changed on the command line (@pxref{gpgsm-option --options}).
	You should backup this file.


	@item policies.txt
	@efindex policies.txt
	This is a list of allowed CA policies. This file should list the
	object identifiers of the policies line by line. Empty lines and
	lines starting with a hash mark are ignored. Policies missing in this
	file and not marked as critical in the certificate will print only a
	warning; certificates with policies marked as critical and not listed
	in this file will fail the signature verification. You should backup
	this file.

	For example, to allow only the policy 2.289.9.9, the file should look
	like this:

	@c man:.RS
	@example
	# Allowed policies
	2.289.9.9
	@end example
	@c man:.RE

	@item qualified.txt
	@efindex qualified.txt
	This is the list of root certificates used for qualified certificates.
	They are defined as certificates capable of creating legally binding
	signatures in the same way as handwritten signatures are. Comments
	start with a hash mark and empty lines are ignored. Lines do have a
	length limit but this is not a serious limitation as the format of the
	entries is fixed and checked by @command{gpgsm}: A non-comment line starts with
	optional whitespace, followed by exactly 40 hex characters, white space
	and a lowercased 2 letter country code. Additional data delimited with
	by a white space is current ignored but might late be used for other
	purposes.

	Note that even if a certificate is listed in this file, this does not
	mean that the certificate is trusted; in general the certificates listed
	in this file need to be listed also in @file{trustlist.txt}.

	This is a global file an installed in the data directory
	(e.g. @file{@value{DATADIR}/qualified.txt}). GnuPG installs a suitable
	file with root certificates as used in Germany. As new Root-CA
	certificates may be issued over time, these entries may need to be
	updated; new distributions of this software should come with an updated
	list but it is still the responsibility of the Administrator to check
	that this list is correct.

	Every time @command{gpgsm} uses a certificate for signing or verification
	this file will be consulted to check whether the certificate under
	question has ultimately been issued by one of these CAs. If this is the
	case the user will be informed that the verified signature represents a
	legally binding (``qualified'') signature. When creating a signature
	using such a certificate an extra prompt will be issued to let the user
	confirm that such a legally binding signature shall really be created.

	Because this software has not yet been approved for use with such
	certificates, appropriate notices will be shown to indicate this fact.

	@item help.txt
	@efindex help.txt
	This is plain text file with a few help entries used with
	@command{pinentry} as well as a large list of help items for
	@command{gpg} and @command{gpgsm}. The standard file has English help
	texts; to install localized versions use filenames like @file{help.LL.txt}
	with LL denoting the locale. GnuPG comes with a set of predefined help
	files in the data directory (e.g. @file{@value{DATADIR}/gnupg/help.de.txt})
	and allows overriding of any help item by help files stored in the
	system configuration directory (e.g. @file{@value{SYSCONFDIR}/help.de.txt}).
	For a reference of the help file's syntax, please see the installed
	@file{help.txt} file.


	@item com-certs.pem
	@efindex com-certs.pem
	This file is a collection of common certificates used to populated a
	newly created @file{pubring.kbx}. An administrator may replace this
	file with a custom one. The format is a concatenation of PEM encoded
	X.509 certificates. This global file is installed in the data directory
	(e.g. @file{@value{DATADIR}/com-certs.pem}).

	@end table

	@c man:.RE
	Note that on larger installations, it is useful to put predefined files
	into the directory @file{/etc/skel/.gnupg/} so that newly created users
	start up with a working configuration. For existing users a small
	helper script is provided to create these files (@pxref{addgnupghome}).

	For internal purposes @command{gpgsm} creates and maintains a few other files;
	they all live in the current home directory (@pxref{option
	--homedir}). Only @command{gpgsm} may modify these files.


	@table @file
	@item pubring.kbx
	@efindex pubring.kbx
	This a database file storing the certificates as well as meta
	information. For debugging purposes the tool @command{kbxutil} may be
	used to show the internal structure of this file. You should backup
	this file.

	@item random_seed
	@efindex random_seed
	This content of this file is used to maintain the internal state of the
	random number generator across invocations. The same file is used by
	other programs of this software too.

	@item S.gpg-agent
	@efindex S.gpg-agent
	If this file exists
	@command{gpgsm} will first try to connect to this socket for
	accessing @command{gpg-agent} before starting a new @command{gpg-agent}
	instance. Under Windows this socket (which in reality be a plain file
	describing a regular TCP listening port) is the standard way of
	connecting the @command{gpg-agent}.

	@end table


	@c *******************************************
	@c ************* **************
	@c ************* EXAMPLES **************
	@c ************* **************
	@c *******************************************
	@mansect examples
	@node GPGSM Examples
	@section Examples

	@example
	$ gpgsm -er goo@@bar.net <plaintext >ciphertext
	@end example


	@c *******************************************
	@c ************* ************
	@c ************* UNATTENDED ************
	@c ************* ************
	@c *******************************************
	@manpause
	@node Unattended Usage
	@section Unattended Usage

	@command{gpgsm} is often used as a backend engine by other software. To help
	with this a machine interface has been defined to have an unambiguous
	way to do this. This is most likely used with the @code{--server} command
	but may also be used in the standard operation mode by using the
	@code{--status-fd} option.

	@menu
	* Automated signature checking:: Automated signature checking.
	* CSR and certificate creation:: CSR and certificate creation.
	@end menu

	@node Automated signature checking
	@subsection Automated signature checking

	It is very important to understand the semantics used with signature
	verification. Checking a signature is not as simple as it may sound and
	so the operation is a bit complicated. In most cases it is required
	to look at several status lines. Here is a table of all cases a signed
	message may have:

	@table @asis
	@item The signature is valid
	This does mean that the signature has been successfully verified, the
	certificates are all sane. However there are two subcases with
	important information: One of the certificates may have expired or a
	signature of a message itself as expired. It is a sound practise to
	consider such a signature still as valid but additional information
	should be displayed. Depending on the subcase @command{gpgsm} will issue
	these status codes:
	@table @asis
	@item signature valid and nothing did expire
	@code{GOODSIG}, @code{VALIDSIG}, @code{TRUST_FULLY}
	@item signature valid but at least one certificate has expired
	@code{EXPKEYSIG}, @code{VALIDSIG}, @code{TRUST_FULLY}
	@item signature valid but expired
	@code{EXPSIG}, @code{VALIDSIG}, @code{TRUST_FULLY}
	Note, that this case is currently not implemented.
	@end table

	@item The signature is invalid
	This means that the signature verification failed (this is an indication
	of a transfer error, a program error or tampering with the message).
	@command{gpgsm} issues one of these status codes sequences:
	@table @code
	@item @code{BADSIG}
	@item @code{GOODSIG}, @code{VALIDSIG} @code{TRUST_NEVER}
	@end table

	@item Error verifying a signature
	For some reason the signature could not be verified, i.e. it cannot be
	decided whether the signature is valid or invalid. A common reason for
	this is a missing certificate.

	@end table

	@node CSR and certificate creation
	@subsection CSR and certificate creation

	The command @option{--generate-key} may be used along with the option
	@option{--batch} to either create a certificate signing request (CSR)
	or an X.509 certificate. This is controlled by a parameter file; the
	format of this file is as follows:

	@itemize @bullet
	@item Text only, line length is limited to about 1000 characters.
	@item UTF-8 encoding must be used to specify non-ASCII characters.
	@item Empty lines are ignored.
	@item Leading and trailing while space is ignored.
	@item A hash sign as the first non white space character indicates
	a comment line.
	@item Control statements are indicated by a leading percent sign, the
	arguments are separated by white space from the keyword.
	@item Parameters are specified by a keyword, followed by a colon. Arguments
	are separated by white space.
	@item The first parameter must be @samp{Key-Type}, control statements
	may be placed anywhere.
	@item
	The order of the parameters does not matter except for @samp{Key-Type}
	which must be the first parameter. The parameters are only used for
	the generated CSR/certificate; parameters from previous sets are not
	used. Some syntactically checks may be performed.
	@item
	Key generation takes place when either the end of the parameter file
	is reached, the next @samp{Key-Type} parameter is encountered or at the
	control statement @samp{%commit} is encountered.
	@end itemize

	@noindent
	Control statements:

	@table @asis

	@item %echo @var{text}
	Print @var{text} as diagnostic.

	@item %dry-run
	Suppress actual key generation (useful for syntax checking).

	@item %commit
	Perform the key generation. Note that an implicit commit is done at
	the next @asis{Key-Type} parameter.

	@c %certfile <filename>
	@c [Not yet implemented!]
	@c Do not write the certificate to the keyDB but to <filename>.
	@c This must be given before the first
	@c commit to take place, duplicate specification of the same filename
	@c is ignored, the last filename before a commit is used.
	@c The filename is used until a new filename is used (at commit points)
	@c and all keys are written to that file. If a new filename is given,
	@c this file is created (and overwrites an existing one).
	@c Both control statements must be given.
	@end table

	@noindent
	General Parameters:

	@table @asis

	@item Key-Type: @var{algo}
	Starts a new parameter block by giving the type of the primary
	key. The algorithm must be capable of signing. This is a required
	parameter. The only supported value for @var{algo} is @samp{rsa}.

	@item Key-Length: @var{nbits}
	The requested length of a generated key in bits. Defaults to 3072.

	@item Key-Grip: @var{hexstring}
	This is optional and used to generate a CSR or certificate for an
	already existing key. Key-Length will be ignored when given.

	@item Key-Usage: @var{usage-list}
	Space or comma delimited list of key usage, allowed values are
	@samp{encrypt}, @samp{sign} and @samp{cert}. This is used to generate
	the keyUsage extension. Please make sure that the algorithm is
	capable of this usage. Default is to allow encrypt and sign.

	@item Name-DN: @var{subject-name}
	This is the Distinguished Name (DN) of the subject in RFC-2253 format.

	@item Name-Email: @var{string}
	This is an email address for the altSubjectName. This parameter is
	optional but may occur several times to add several email addresses to
	a certificate.

	@item Name-DNS: @var{string}
	The is an DNS name for the altSubjectName. This parameter is optional
	but may occur several times to add several DNS names to a certificate.

	@item Name-URI: @var{string}
	This is an URI for the altSubjectName. This parameter is optional but
	may occur several times to add several URIs to a certificate.
	@end table

	@noindent
	Additional parameters used to create a certificate (in contrast to a
	certificate signing request):

	@table @asis

	@item Serial: @var{sn}
	If this parameter is given an X.509 certificate will be generated.
	@var{sn} is expected to be a hex string representing an unsigned
	integer of arbitrary length. The special value @samp{random} can be
	used to create a 64 bit random serial number.

	@item Issuer-DN: @var{issuer-name}
	This is the DN name of the issuer in RFC-2253 format. If it is not set
	it will default to the subject DN and a special GnuPG extension will
	be included in the certificate to mark it as a standalone certificate.

	@item Creation-Date: @var{iso-date}
	@itemx Not-Before: @var{iso-date}
	Set the notBefore date of the certificate. Either a date like
	@samp{1986-04-26} or @samp{1986-04-26 12:00} or a standard ISO
	timestamp like @samp{19860426T042640} may be used. The time is
	considered to be UTC. If it is not given the current date is used.

	@item Expire-Date: @var{iso-date}
	@itemx Not-After: @var{iso-date}
	Set the notAfter date of the certificate. Either a date like
	@samp{2063-04-05} or @samp{2063-04-05 17:00} or a standard ISO
	timestamp like @samp{20630405T170000} may be used. The time is
	considered to be UTC. If it is not given a default value in the not
	too far future is used.

	@item Signing-Key: @var{keygrip}
	This gives the keygrip of the key used to sign the certificate. If it
	is not given a self-signed certificate will be created. For
	compatibility with future versions, it is suggested to prefix the
	keygrip with a @samp{&}.

	@item Hash-Algo: @var{hash-algo}
	Use @var{hash-algo} for this CSR or certificate. The supported hash
	algorithms are: @samp{sha1}, @samp{sha256}, @samp{sha384} and
	@samp{sha512}; they may also be specified with uppercase letters. The
	default is @samp{sha256}.

	@end table

	@c *******************************************
	@c ************* ***************
	@c ************* ASSSUAN ***************
	@c ************* ***************
	@c *******************************************
	@node GPGSM Protocol
	@section The Protocol the Server Mode Uses

	Description of the protocol used to access @command{GPGSM}.
	@command{GPGSM} does implement the Assuan protocol and in addition
	provides a regular command line interface which exhibits a full client
	to this protocol (but uses internal linking). To start
	@command{gpgsm} as a server the command line the option
	@code{--server} must be used. Additional options are provided to
	select the communication method (i.e. the name of the socket).

	We assume that the connection has already been established; see the
	Assuan manual for details.

	@menu
	* GPGSM ENCRYPT:: Encrypting a message.
	* GPGSM DECRYPT:: Decrypting a message.
	* GPGSM SIGN:: Signing a message.
	* GPGSM VERIFY:: Verifying a message.
	* GPGSM GENKEY:: Generating a key.
	* GPGSM LISTKEYS:: List available keys.
	* GPGSM EXPORT:: Export certificates.
	* GPGSM IMPORT:: Import certificates.
	* GPGSM DELETE:: Delete certificates.
	* GPGSM GETAUDITLOG:: Retrieve an audit log.
	* GPGSM GETINFO:: Information about the process
	* GPGSM OPTION:: Session options.
	@end menu


	@node GPGSM ENCRYPT
	@subsection Encrypting a Message

	Before encryption can be done the recipient must be set using the
	command:

	@example
	RECIPIENT @var{userID}
	@end example

	Set the recipient for the encryption. @var{userID} should be the
	internal representation of the key; the server may accept any other way
	of specification. If this is a valid and trusted recipient the server
	does respond with OK, otherwise the return is an ERR with the reason why
	the recipient cannot be used, the encryption will then not be done for
	this recipient. If the policy is not to encrypt at all if not all
	recipients are valid, the client has to take care of this. All
	@code{RECIPIENT} commands are cumulative until a @code{RESET} or an
	successful @code{ENCRYPT} command.

	@example
	INPUT FD[=@var{n}] [--armor\|--base64\|--binary]
	@end example

	Set the file descriptor for the message to be encrypted to @var{n}.
	Obviously the pipe must be open at that point, the server establishes
	its own end. If the server returns an error the client should consider
	this session failed. If @var{n} is not given, this commands uses the
	last file descriptor passed to the application.
	@xref{fun-assuan_sendfd, ,the assuan_sendfd function,assuan,the Libassuan
	manual}, on how to do descriptor passing.

	The @code{--armor} option may be used to advice the server that the
	input data is in @acronym{PEM} format, @code{--base64} advices that a
	raw base-64 encoding is used, @code{--binary} advices of raw binary
	input (@acronym{BER}). If none of these options is used, the server
	tries to figure out the used encoding, but this may not always be
	correct.

	@example
	OUTPUT FD[=@var{n}] [--armor\|--base64]
	@end example

	Set the file descriptor to be used for the output (i.e. the encrypted
	message). Obviously the pipe must be open at that point, the server
	establishes its own end. If the server returns an error the client
	should consider this session failed.

	The option @option{--armor} encodes the output in @acronym{PEM} format, the
	@option{--base64} option applies just a base-64 encoding. No option
	creates binary output (@acronym{BER}).

	The actual encryption is done using the command

	@example
	ENCRYPT
	@end example

	It takes the plaintext from the @code{INPUT} command, writes to the
	ciphertext to the file descriptor set with the @code{OUTPUT} command,
	take the recipients from all the recipients set so far. If this command
	fails the clients should try to delete all output currently done or
	otherwise mark it as invalid. @command{GPGSM} does ensure that there
	will not be any
	security problem with leftover data on the output in this case.

	This command should in general not fail, as all necessary checks have
	been done while setting the recipients. The input and output pipes are
	closed.


	@node GPGSM DECRYPT
	@subsection Decrypting a message

	Input and output FDs are set the same way as in encryption, but
	@code{INPUT} refers to the ciphertext and @code{OUTPUT} to the plaintext. There
	is no need to set recipients. @command{GPGSM} automatically strips any
	@acronym{S/MIME} headers from the input, so it is valid to pass an
	entire MIME part to the INPUT pipe.

	The decryption is done by using the command

	@example
	DECRYPT
	@end example

	It performs the decrypt operation after doing some check on the internal
	state (e.g. that all needed data has been set). Because it utilizes
	the GPG-Agent for the session key decryption, there is no need to ask
	the client for a protecting passphrase - GpgAgent takes care of this by
	requesting this from the user.


	@node GPGSM SIGN
	@subsection Signing a Message

	Signing is usually done with these commands:

	@example
	INPUT FD[=@var{n}] [--armor\|--base64\|--binary]
	@end example

	This tells @command{GPGSM} to read the data to sign from file descriptor @var{n}.

	@example
	OUTPUT FD[=@var{m}] [--armor\|--base64]
	@end example

	Write the output to file descriptor @var{m}. If a detached signature is
	requested, only the signature is written.

	@example
	SIGN [--detached]
	@end example

	Sign the data set with the @code{INPUT} command and write it to the sink set by
	@code{OUTPUT}. With @code{--detached}, a detached signature is created
	(surprise).

	The key used for signing is the default one or the one specified in
	the configuration file. To get finer control over the keys, it is
	possible to use the command

	@example
	SIGNER @var{userID}
	@end example

	to set the signer's key. @var{userID} should be the
	internal representation of the key; the server may accept any other way
	of specification. If this is a valid and trusted recipient the server
	does respond with OK, otherwise the return is an ERR with the reason why
	the key cannot be used, the signature will then not be created using
	this key. If the policy is not to sign at all if not all
	keys are valid, the client has to take care of this. All
	@code{SIGNER} commands are cumulative until a @code{RESET} is done.
	Note that a @code{SIGN} does not reset this list of signers which is in
	contrast to the @code{RECIPIENT} command.


	@node GPGSM VERIFY
	@subsection Verifying a Message

	To verify a message the command:

	@example
	VERIFY
	@end example

	is used. It does a verify operation on the message send to the input FD.
	The result is written out using status lines. If an output FD was
	given, the signed text will be written to that. If the signature is a
	detached one, the server will inquire about the signed material and the
	client must provide it.

	@node GPGSM GENKEY
	@subsection Generating a Key

	This is used to generate a new keypair, store the secret part in the
	@acronym{PSE} and the public key in the key database. We will probably
	add optional commands to allow the client to select whether a hardware
	token is used to store the key. Configuration options to
	@command{GPGSM} can be used to restrict the use of this command.

	@example
	GENKEY
	@end example

	@command{GPGSM} checks whether this command is allowed and then does an
	INQUIRY to get the key parameters, the client should then send the
	key parameters in the native format:

	@example
	S: INQUIRE KEY_PARAM native
	C: D foo:fgfgfg
	C: D bar
	C: END
	@end example

	Please note that the server may send Status info lines while reading the
	data lines from the client. After this the key generation takes place
	and the server eventually does send an ERR or OK response. Status lines
	may be issued as a progress indicator.


	@node GPGSM LISTKEYS
	@subsection List available keys
	@anchor{gpgsm-cmd listkeys}

	To list the keys in the internal database or using an external key
	provider, the command:

	@example
	LISTKEYS @var{pattern}
	@end example

	is used. To allow multiple patterns (which are ORed during the search)
	quoting is required: Spaces are to be translated into "+" or into "%20";
	in turn this requires that the usual escape quoting rules are done.

	@example
	LISTSECRETKEYS @var{pattern}
	@end example

	Lists only the keys where a secret key is available.

	The list commands are affected by the option

	@example
	OPTION list-mode=@var{mode}
	@end example

	where mode may be:
	@table @code
	@item 0
	Use default (which is usually the same as 1).
	@item 1
	List only the internal keys.
	@item 2
	List only the external keys.
	@item 3
	List internal and external keys.
	@end table

	Note that options are valid for the entire session.


	@node GPGSM EXPORT
	@subsection Export certificates

	To export certificate from the internal key database the command:

	@example
	EXPORT [--data [--armor] [--base64]] [--] @var{pattern}
	@end example

	is used. To allow multiple patterns (which are ORed) quoting is
	required: Spaces are to be translated into "+" or into "%20"; in turn
	this requires that the usual escape quoting rules are done.

	If the @option{--data} option has not been given, the format of the
	output depends on what was set with the @code{OUTPUT} command. When using
	@acronym{PEM} encoding a few informational lines are prepended.

	If the @option{--data} has been given, a target set via @code{OUTPUT} is
	ignored and the data is returned inline using standard
	@code{D}-lines. This avoids the need for an extra file descriptor. In
	this case the options @option{--armor} and @option{--base64} may be used
	in the same way as with the @code{OUTPUT} command.


	@node GPGSM IMPORT
	@subsection Import certificates

	To import certificates into the internal key database, the command

	@example
	IMPORT [--re-import]
	@end example

	is used. The data is expected on the file descriptor set with the
	@code{INPUT} command. Certain checks are performed on the
	certificate. Note that the code will also handle PKCS#12 files and
	import private keys; a helper program is used for that.

	With the option @option{--re-import} the input data is expected to a be
	a linefeed separated list of fingerprints. The command will re-import
	the corresponding certificates; that is they are made permanent by
	removing their ephemeral flag.


	@node GPGSM DELETE
	@subsection Delete certificates

	To delete a certificate the command

	@example
	DELKEYS @var{pattern}
	@end example

	is used. To allow multiple patterns (which are ORed) quoting is
	required: Spaces are to be translated into "+" or into "%20"; in turn
	this requires that the usual escape quoting rules are done.

	The certificates must be specified unambiguously otherwise an error is
	returned.

	@node GPGSM GETAUDITLOG
	@subsection Retrieve an audit log
	@anchor{gpgsm-cmd getauditlog}

	This command is used to retrieve an audit log.

	@example
	GETAUDITLOG [--data] [--html]
	@end example

	If @option{--data} is used, the audit log is send using D-lines
	instead of being sent to the file descriptor given by an @code{OUTPUT}
	command. If @option{--html} is used, the output is formatted as an
	XHTML block. This is designed to be incorporated into a HTML
	document.


	@node GPGSM GETINFO
	@subsection Return information about the process

	This is a multipurpose function to return a variety of information.

	@example
	GETINFO @var{what}
	@end example

	The value of @var{what} specifies the kind of information returned:
	@table @code
	@item version
	Return the version of the program.
	@item pid
	Return the process id of the process.
	@item agent-check
	Return OK if the agent is running.
	@item cmd_has_option @var{cmd} @var{opt}
	Return OK if the command @var{cmd} implements the option @var{opt}.
	The leading two dashes usually used with @var{opt} shall not be given.
	@item offline
	Return OK if the connection is in offline mode. This may be either
	due to a @code{OPTION offline=1} or due to @command{gpgsm} being
	started with option @option{--disable-dirmngr}.
	@end table

	@node GPGSM OPTION
	@subsection Session options

	The standard Assuan option handler supports these options.

	@example
	OPTION @var{name}[=@var{value}]
	@end example

	These @var{name}s are recognized:

	@table @code

	@item putenv
	Change the session's environment to be passed via gpg-agent to
	Pinentry. @var{value} is a string of the form
	@code{<KEY>[=[<STRING>]]}. If only @code{<KEY>} is given the
	environment variable @code{<KEY>} is removed from the session
	environment, if @code{<KEY>=} is given that environment variable is
	set to the empty string, and if @code{<STRING>} is given it is set to
	that string.

	@item display
	@efindex DISPLAY
	Set the session environment variable @code{DISPLAY} is set to @var{value}.
	@item ttyname
	@efindex GPG_TTY
	Set the session environment variable @code{GPG_TTY} is set to @var{value}.
	@item ttytype
	@efindex TERM
	Set the session environment variable @code{TERM} is set to @var{value}.
	@item lc-ctype
	@efindex LC_CTYPE
	Set the session environment variable @code{LC_CTYPE} is set to @var{value}.
	@item lc-messages
	@efindex LC_MESSAGES
	Set the session environment variable @code{LC_MESSAGES} is set to @var{value}.
	@item xauthority
	@efindex XAUTHORITY
	Set the session environment variable @code{XAUTHORITY} is set to @var{value}.
	@item pinentry-user-data
	@efindex PINENTRY_USER_DATA
	Set the session environment variable @code{PINENTRY_USER_DATA} is set
	to @var{value}.

	@item include-certs
	This option overrides the command line option
	@option{--include-certs}. A @var{value} of -2 includes all
	certificates except for the root certificate, -1 includes all
	certificates, 0 does not include any certificates, 1 includes only the
	signers certificate and all other positive values include up to
	@var{value} certificates starting with the signer cert.

	@item list-mode
	@xref{gpgsm-cmd listkeys}.

	@item list-to-output
	If @var{value} is true the output of the list commands
	(@pxref{gpgsm-cmd listkeys}) is written to the file descriptor set
	with the last @code{OUTPUT} command. If @var{value} is false the output is
	written via data lines; this is the default.

	@item with-validation
	If @var{value} is true for each listed certificate the validation
	status is printed. This may result in the download of a CRL or the
	user being asked about the trustworthiness of a root certificate. The
	default is given by a command line option (@pxref{gpgsm-option
	--with-validation}).


	@item with-secret
	If @var{value} is true certificates with a corresponding private key
	are marked by the list commands.

	@item validation-model
	This option overrides the command line option
	@option{validation-model} for the session.
	(@xref{gpgsm-option --validation-model}.)

	@item with-key-data
	This option globally enables the command line option
	@option{--with-key-data}. (@xref{gpgsm-option --with-key-data}.)

	@item enable-audit-log
	If @var{value} is true data to write an audit log is gathered.
	(@xref{gpgsm-cmd getauditlog}.)

	@item allow-pinentry-notify
	If this option is used notifications about the launch of a Pinentry
	are passed back to the client.

	@item with-ephemeral-keys
	If @var{value} is true ephemeral certificates are included in the
	output of the list commands.

	@item no-encrypt-to
	If this option is used all keys set by the command line option
	@option{--encrypt-to} are ignored.

	@item offline
	If @var{value} is true or @var{value} is not given all network access
	is disabled for this session. This is the same as the command line
	option @option{--disable-dirmngr}.

	@end table

	@mansect see also
	@ifset isman
	@command{gpg2}(1),
	@command{gpg-agent}(1)
	@end ifset
	@include see-also-note.texi
	diff --git a/sm/certchain.c b/sm/certchain.c
	index 51dc8f8ef..5f8320231 100644
	--- a/sm/certchain.c
	+++ b/sm/certchain.c
	@@ -1,2375 +1,2380 @@
	/* certchain.c - certificate chain validation
	* Copyright (C) 2001, 2002, 2003, 2004, 2005,
	* 2006, 2007, 2008, 2011 Free Software Foundation, Inc.
	*
	* 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
	* the Free Software Foundation; either version 3 of the License, or
	* (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
	* along with this program; if not, see <https://www.gnu.org/licenses/>.
	*/

	#include <config.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <errno.h>
	#include <unistd.h>
	#include <time.h>
	#include <stdarg.h>
	#include <assert.h>

	#include "gpgsm.h"
	#include <gcrypt.h>
	#include <ksba.h>

	#include "keydb.h"
	#include "../kbx/keybox.h" /* for KEYBOX_FLAG_* */
	#include "../common/i18n.h"
	#include "../common/tlv.h"


	/* The OID for the authorityInfoAccess's caIssuers. */
	static const char oidstr_caIssuers[] = "1.3.6.1.5.5.7.48.2";


	/* Object to keep track of certain root certificates. */
	struct marktrusted_info_s
	{
	struct marktrusted_info_s *next;
	unsigned char fpr[20];
	};
	static struct marktrusted_info_s *marktrusted_info;


	/* While running the validation function we want to keep track of the
	certificates in the chain. This type is used for that. */
	struct chain_item_s
	{
	struct chain_item_s *next;
	ksba_cert_t cert; /* The certificate. */
	int is_root; /* The certificate is the root certificate. */
	};
	typedef struct chain_item_s *chain_item_t;


	static int is_root_cert (ksba_cert_t cert,
	const char issuerdn, const char subjectdn);
	static int get_regtp_ca_info (ctrl_t ctrl, ksba_cert_t cert, int *chainlen);


	/* This function returns true if we already asked during this session
	whether the root certificate CERT shall be marked as trusted. */
	static int
	already_asked_marktrusted (ksba_cert_t cert)
	{
	unsigned char fpr[20];
	struct marktrusted_info_s *r;

	gpgsm_get_fingerprint (cert, GCRY_MD_SHA1, fpr, NULL);
	/* No context switches in the loop! */
	for (r=marktrusted_info; r; r= r->next)
	if (!memcmp (r->fpr, fpr, 20))
	return 1;
	return 0;
	}

	/* Flag certificate CERT as already asked whether it shall be marked
	as trusted. */
	static void
	set_already_asked_marktrusted (ksba_cert_t cert)
	{
	unsigned char fpr[20];
	struct marktrusted_info_s *r;

	gpgsm_get_fingerprint (cert, GCRY_MD_SHA1, fpr, NULL);
	for (r=marktrusted_info; r; r= r->next)
	if (!memcmp (r->fpr, fpr, 20))
	return; /* Already marked. */
	r = xtrycalloc (1, sizeof *r);
	if (!r)
	return;
	memcpy (r->fpr, fpr, 20);
	r->next = marktrusted_info;
	marktrusted_info = r;
	}

	/* If LISTMODE is true, print FORMAT using LISTMODE to FP. If
	LISTMODE is false, use the string to print an log_info or, if
	IS_ERROR is true, and log_error. */
	static void
	do_list (int is_error, int listmode, estream_t fp, const char *format, ...)
	{
	va_list arg_ptr;

	va_start (arg_ptr, format) ;
	if (listmode)
	{
	if (fp)
	{
	es_fputs (" [", fp);
	es_vfprintf (fp, format, arg_ptr);
	es_fputs ("]\n", fp);
	}
	}
	else
	{
	log_logv (is_error? GPGRT_LOG_ERROR: GPGRT_LOG_INFO, format, arg_ptr);
	log_printf ("\n");
	}
	va_end (arg_ptr);
	}

	/* Return 0 if A and B are equal. */
	static int
	compare_certs (ksba_cert_t a, ksba_cert_t b)
	{
	const unsigned char img_a, img_b;
	size_t len_a, len_b;

	img_a = ksba_cert_get_image (a, &len_a);
	if (!img_a)
	return 1;
	img_b = ksba_cert_get_image (b, &len_b);
	if (!img_b)
	return 1;
	return !(len_a == len_b && !memcmp (img_a, img_b, len_a));
	}


	/* Return true if CERT has the validityModel extensions and defines
	the use of the chain model. */
	static int
	has_validation_model_chain (ksba_cert_t cert, int listmode, estream_t listfp)
	{
	gpg_error_t err;
	int idx, yes;
	const char *oid;
	size_t off, derlen, objlen, hdrlen;
	const unsigned char *der;
	int class, tag, constructed, ndef;
	char *oidbuf;

	for (idx=0; !(err=ksba_cert_get_extension (cert, idx,
	&oid, NULL, &off, &derlen));idx++)
	if (!strcmp (oid, "1.3.6.1.4.1.8301.3.5") )
	break;
	if (err)
	return 0; /* Not found. */
	der = ksba_cert_get_image (cert, NULL);
	if (!der)
	{
	err = gpg_error (GPG_ERR_INV_OBJ); /* Oops */
	goto leave;
	}
	der += off;

	err = parse_ber_header (&der, &derlen, &class, &tag, &constructed,
	&ndef, &objlen, &hdrlen);
	if (!err && (objlen > derlen \|\| tag != TAG_SEQUENCE))
	err = gpg_error (GPG_ERR_INV_OBJ);
	if (err)
	goto leave;
	derlen = objlen;
	err = parse_ber_header (&der, &derlen, &class, &tag, &constructed,
	&ndef, &objlen, &hdrlen);
	if (!err && (objlen > derlen \|\| tag != TAG_OBJECT_ID))
	err = gpg_error (GPG_ERR_INV_OBJ);
	if (err)
	goto leave;
	oidbuf = ksba_oid_to_str (der, objlen);
	if (!oidbuf)
	{
	err = gpg_error_from_syserror ();
	goto leave;
	}

	if (opt.verbose)
	do_list (0, listmode, listfp,
	_("validation model requested by certificate: %s"),
	!strcmp (oidbuf, "1.3.6.1.4.1.8301.3.5.1")? _("chain") :
	!strcmp (oidbuf, "1.3.6.1.4.1.8301.3.5.2")? _("shell") :
	/* */ oidbuf);
	yes = !strcmp (oidbuf, "1.3.6.1.4.1.8301.3.5.1");
	ksba_free (oidbuf);
	return yes;


	leave:
	log_error ("error parsing validityModel: %s\n", gpg_strerror (err));
	return 0;
	}



	static int
	unknown_criticals (ksba_cert_t cert, int listmode, estream_t fp)
	{
	static const char *known[] = {
	"2.5.29.15", /* keyUsage */
	"2.5.29.17", /* subjectAltName
	Japanese DoCoMo certs mark them as critical. PKIX
	only requires them as critical if subjectName is
	empty. I don't know whether our code gracefully
	handles such empry subjectNames but that is
	another story. */
	"2.5.29.19", /* basic Constraints */
	"2.5.29.32", /* certificatePolicies */
	"2.5.29.37", /* extendedKeyUsage - handled by certlist.c */
	"1.3.6.1.4.1.8301.3.5", /* validityModel - handled here. */
	NULL
	};
	int rc = 0, i, idx, crit;
	const char *oid;
	gpg_error_t err;
	int unsupported;
	strlist_t sl;

	for (idx=0; !(err=ksba_cert_get_extension (cert, idx,
	&oid, &crit, NULL, NULL));idx++)
	{
	if (!crit)
	continue;
	for (i=0; known[i] && strcmp (known[i],oid); i++)
	;
	unsupported = !known[i];

	/* If this critical extension is not supported. Check the list
	of to be ignored extensions to see whether we claim that it
	is supported. */
	if (unsupported && opt.ignored_cert_extensions)
	{
	for (sl=opt.ignored_cert_extensions;
	sl && strcmp (sl->d, oid); sl = sl->next)
	;
	if (sl)
	unsupported = 0;
	}
	if (unsupported)
	{
	do_list (1, listmode, fp,
	_("critical certificate extension %s is not supported"),
	oid);
	rc = gpg_error (GPG_ERR_UNSUPPORTED_CERT);
	}
	}
	/* We ignore the error codes EOF as well as no-value. The later will
	occur for certificates with no extensions at all. */
	if (err
	&& gpg_err_code (err) != GPG_ERR_EOF
	&& gpg_err_code (err) != GPG_ERR_NO_VALUE)
	rc = err;

	return rc;
	}


	/* Check whether CERT is an allowed certificate. This requires that
	CERT matches all requirements for such a CA, i.e. the
	BasicConstraints extension. The function returns 0 on success and
	the allowed length of the chain at CHAINLEN. */
	static int
	allowed_ca (ctrl_t ctrl,
	ksba_cert_t cert, int *chainlen, int listmode, estream_t fp)
	{
	gpg_error_t err;
	int flag;

	err = ksba_cert_is_ca (cert, &flag, chainlen);
	if (err)
	return err;
	if (!flag)
	{
	if (get_regtp_ca_info (ctrl, cert, chainlen))
	{
	/* Note that dirmngr takes a different way to cope with such
	certs. */
	return 0; /* RegTP issued certificate. */
	}

	do_list (1, listmode, fp,_("issuer certificate is not marked as a CA"));
	return gpg_error (GPG_ERR_BAD_CA_CERT);
	}
	return 0;
	}


	static int
	check_cert_policy (ksba_cert_t cert, int listmode, estream_t fplist)
	{
	gpg_error_t err;
	char *policies;
	FILE *fp;
	int any_critical;

	err = ksba_cert_get_cert_policies (cert, &policies);
	if (gpg_err_code (err) == GPG_ERR_NO_DATA)
	return 0; /* No policy given. */
	if (err)
	return err;

	/* STRING is a line delimited list of certificate policies as stored
	in the certificate. The line itself is colon delimited where the
	first field is the OID of the policy and the second field either
	N or C for normal or critical extension */

	if (opt.verbose > 1 && !listmode)
	log_info ("certificate's policy list: %s\n", policies);

	/* The check is very minimal but won't give false positives */
	any_critical = !!strstr (policies, ":C");

	if (!opt.policy_file)
	{
	xfree (policies);
	if (any_critical)
	{
	do_list (1, listmode, fplist,
	_("critical marked policy without configured policies"));
	return gpg_error (GPG_ERR_NO_POLICY_MATCH);
	}
	return 0;
	}

	fp = fopen (opt.policy_file, "r");
	if (!fp)
	{
	if (opt.verbose \|\| errno != ENOENT)
	log_info (_("failed to open '%s': %s\n"),
	opt.policy_file, strerror (errno));
	xfree (policies);
	/* With no critical policies this is only a warning */
	if (!any_critical)
	{
	if (!opt.quiet)
	do_list (0, listmode, fplist,
	_("Note: non-critical certificate policy not allowed"));
	return 0;
	}
	do_list (1, listmode, fplist,
	_("certificate policy not allowed"));
	return gpg_error (GPG_ERR_NO_POLICY_MATCH);
	}

	for (;;)
	{
	int c;
	char *p, line[256];
	char haystack, allowed;

	/* read line */
	do
	{
	if (!fgets (line, DIM(line)-1, fp) )
	{
	gpg_error_t tmperr = gpg_error (gpg_err_code_from_errno (errno));

	xfree (policies);
	if (feof (fp))
	{
	fclose (fp);
	/* With no critical policies this is only a warning */
	if (!any_critical)
	{
	do_list (0, listmode, fplist,
	_("Note: non-critical certificate policy not allowed"));
	return 0;
	}
	do_list (1, listmode, fplist,
	_("certificate policy not allowed"));
	return gpg_error (GPG_ERR_NO_POLICY_MATCH);
	}
	fclose (fp);
	return tmperr;
	}

	if (!*line \|\| line[strlen(line)-1] != '\n')
	{
	/* eat until end of line */
	while ( (c=getc (fp)) != EOF && c != '\n')
	;
	fclose (fp);
	xfree (policies);
	return gpg_error (*line? GPG_ERR_LINE_TOO_LONG
	: GPG_ERR_INCOMPLETE_LINE);
	}

	/* Allow for empty lines and spaces */
	for (p=line; spacep (p); p++)
	;
	}
	while (!p \|\| p == '\n' \|\| *p == '#');

	/* Parse line. Note that the line has always a LF and spacep
	does not consider a LF a space. Thus strpbrk will always
	succeed. */
	for (allowed=line; spacep (allowed); allowed++)
	;
	p = strpbrk (allowed, " :\n");
	if (!*p \|\| p == allowed)
	{
	fclose (fp);
	xfree (policies);
	return gpg_error (GPG_ERR_CONFIGURATION);
	}
	p = 0; / strip the rest of the line */
	/* See whether we find ALLOWED (which is an OID) in POLICIES */
	for (haystack=policies; (p=strstr (haystack, allowed)); haystack = p+1)
	{
	if ( !(p == policies \|\| p[-1] == '\n') )
	continue; /* Does not match the begin of a line. */
	if (p[strlen (allowed)] != ':')
	continue; /* The length does not match. */
	/* Yep - it does match so return okay. */
	fclose (fp);
	xfree (policies);
	return 0;
	}
	}
	}


	/* Helper function for find_up. This resets the key handle and search
	for an issuer ISSUER with a subjectKeyIdentifier of KEYID. Returns
	0 on success or -1 when not found. */
	static int
	find_up_search_by_keyid (ctrl_t ctrl, KEYDB_HANDLE kh,
	const char *issuer, ksba_sexp_t keyid)
	{
	int rc;
	ksba_cert_t cert = NULL;
	ksba_sexp_t subj = NULL;
	ksba_isotime_t not_before, not_after, last_not_before, ne_last_not_before;
	ksba_cert_t found_cert = NULL;
	ksba_cert_t ne_found_cert = NULL;

	keydb_search_reset (kh);
	while (!(rc = keydb_search_subject (ctrl, kh, issuer)))
	{
	ksba_cert_release (cert); cert = NULL;
	rc = keydb_get_cert (kh, &cert);
	if (rc)
	{
	log_error ("keydb_get_cert() failed: rc=%d\n", rc);
	rc = -1;
	goto leave;
	}
	xfree (subj);
	if (!ksba_cert_get_subj_key_id (cert, NULL, &subj))
	{
	if (!cmp_simple_canon_sexp (keyid, subj))
	{
	/* Found matching cert. */
	rc = ksba_cert_get_validity (cert, 0, not_before);
	if (!rc)
	rc = ksba_cert_get_validity (cert, 1, not_after);
	if (rc)
	{
	log_error ("keydb_get_validity() failed: rc=%d\n", rc);
	rc = -1;
	goto leave;
	}

	if (!found_cert
	\|\| strcmp (last_not_before, not_before) < 0)
	{
	/* This certificate is the first one found or newer
	* than the previous one. This copes with
	* re-issuing CA certificates while keeping the same
	* key information. */
	gnupg_copy_time (last_not_before, not_before);
	ksba_cert_release (found_cert);
	ksba_cert_ref ((found_cert = cert));
	keydb_push_found_state (kh);
	}

	if (*not_after && strcmp (ctrl->current_time, not_after) > 0 )
	; /* CERT has expired - don't consider it. */
	else if (!ne_found_cert
	\|\| strcmp (ne_last_not_before, not_before) < 0)
	{
	/* This certificate is the first non-expired one
	* found or newer than the previous non-expired one. */
	gnupg_copy_time (ne_last_not_before, not_before);
	ksba_cert_release (ne_found_cert);
	ksba_cert_ref ((ne_found_cert = cert));
	}
	}
	}
	}

	if (!found_cert)
	goto leave;

	/* Take the last saved one. Note that push/pop_found_state are
	* misnomers because there is no stack of states. Renaming them to
	* save/restore_found_state would be better. */
	keydb_pop_found_state (kh);
	rc = 0; /* Ignore EOF or other error after the first cert. */

	/* We need to consider some corner cases. It is possible that we
	* have a long term certificate (e.g. valid from 2008 to 2033) as
	* well as a re-issued (i.e. using the same key material) short term
	* certificate (say from 2016 to 2019). Using the short term
	* certificate is the proper solution. But we need to take care if
	* there is no re-issued new short term certificate (e.g. from 2020
	* to 2023) available. In that case it is better to use the long
	* term certificate which is still valid. The code may run into
	* minor problems in the case of the chain validation mode. Given
	* that this corner case is due to non-diligent PKI management we
	* ignore this problem. */

	/* The most common case is that the found certificate is not expired
	* and thus identical to the one found from the list of non-expired
	* certs. We can stop here. */
	if (found_cert == ne_found_cert)
	goto leave;
	/* If we do not have a non expired certificate the actual cert is
	* expired and we can also stop here. */
	if (!ne_found_cert)
	goto leave;
	/* Now we need to see whether the found certificate is expired and
	* only in this case we return the certificate found in the list of
	* non-expired certs. */
	rc = ksba_cert_get_validity (found_cert, 1, not_after);
	if (rc)
	{
	log_error ("keydb_get_validity() failed: rc=%d\n", rc);
	rc = -1;
	goto leave;
	}
	if (*not_after && strcmp (ctrl->current_time, not_after) > 0 )
	{ /* CERT has expired. Use the NE_FOUND_CERT. Because we have no
	* found state for this we need to search for it again. */
	unsigned char fpr[20];

	gpgsm_get_fingerprint (ne_found_cert, GCRY_MD_SHA1, fpr, NULL);
	keydb_search_reset (kh);
	rc = keydb_search_fpr (ctrl, kh, fpr);
	if (rc)
	{
	log_error ("keydb_search_fpr() failed: rc=%d\n", rc);
	rc = -1;
	goto leave;
	}
	/* Ready. The NE_FOUND_CERT is availabale via keydb_get_cert. */
	}

	leave:
	ksba_cert_release (found_cert);
	ksba_cert_release (ne_found_cert);
	ksba_cert_release (cert);
	xfree (subj);
	return rc? -1:0;
	}


	struct find_up_store_certs_s
	{
	ctrl_t ctrl;
	int count;
	unsigned int want_fpr:1;
	unsigned int got_fpr:1;
	unsigned char fpr[20];
	};

	static void
	find_up_store_certs_cb (void *cb_value, ksba_cert_t cert)
	{
	struct find_up_store_certs_s *parm = cb_value;

	if (keydb_store_cert (parm->ctrl, cert, 1, NULL))
	log_error ("error storing issuer certificate as ephemeral\n");
	else if (parm->want_fpr && !parm->got_fpr)
	{
	if (!gpgsm_get_fingerprint (cert, 0, parm->fpr, NULL))
	log_error (_("failed to get the fingerprint\n"));
	else
	parm->got_fpr = 1;
	}
	parm->count++;
	}


	/* Helper for find_up(). Locate the certificate for ISSUER using an
	external lookup. KH is the keydb context we are currently using.
	On success 0 is returned and the certificate may be retrieved from
	the keydb using keydb_get_cert(). KEYID is the keyIdentifier from
	the AKI or NULL. */
	static int
	find_up_external (ctrl_t ctrl, KEYDB_HANDLE kh,
	const char *issuer, ksba_sexp_t keyid)
	{
	int rc;
	strlist_t names = NULL;
	struct find_up_store_certs_s find_up_store_certs_parm;
	char *pattern;
	const char *s;

	find_up_store_certs_parm.ctrl = ctrl;
	find_up_store_certs_parm.want_fpr = 0;
	find_up_store_certs_parm.got_fpr = 0;
	find_up_store_certs_parm.count = 0;

	if (opt.verbose)
	log_info (_("looking up issuer at external location\n"));
	/* The Dirmngr process is confused about unknown attributes. As a
	quick and ugly hack we locate the CN and use the issuer string
	starting at this attribite. Fixme: we should have far better
	parsing for external lookups in the Dirmngr. */
	s = strstr (issuer, "CN=");
	if (!s \|\| s == issuer \|\| s[-1] != ',')
	s = issuer;
	pattern = xtrymalloc (strlen (s)+2);
	if (!pattern)
	return gpg_error_from_syserror ();
	strcpy (stpcpy (pattern, "/"), s);
	add_to_strlist (&names, pattern);
	xfree (pattern);

	rc = gpgsm_dirmngr_lookup (ctrl, names, NULL, 0, find_up_store_certs_cb,
	&find_up_store_certs_parm);
	free_strlist (names);

	if (opt.verbose)
	log_info (_("number of issuers matching: %d\n"),
	find_up_store_certs_parm.count);
	if (rc)
	{
	log_error ("external key lookup failed: %s\n", gpg_strerror (rc));
	rc = -1;
	}
	else if (!find_up_store_certs_parm.count)
	rc = -1;
	else
	{
	int old;
	/* The issuers are currently stored in the ephemeral key DB, so
	we temporary switch to ephemeral mode. */
	old = keydb_set_ephemeral (kh, 1);
	if (keyid)
	rc = find_up_search_by_keyid (ctrl, kh, issuer, keyid);
	else
	{
	keydb_search_reset (kh);
	rc = keydb_search_subject (ctrl, kh, issuer);
	}
	keydb_set_ephemeral (kh, old);
	}
	return rc;
	}


	/* Helper for find_up(). Locate the certificate for CERT using the
	* caIssuer from the authorityInfoAccess. KH is the keydb context we
	* are currently using. On success 0 is returned and the certificate
	* may be retrieved from the keydb using keydb_get_cert(). If no
	* suitable authorityInfoAccess is encoded in the certificate
	* GPG_ERR_NOT_FOUND is returned. */
	static gpg_error_t
	find_up_via_auth_info_access (ctrl_t ctrl, KEYDB_HANDLE kh, ksba_cert_t cert)
	{
	gpg_error_t err;
	struct find_up_store_certs_s find_up_store_certs_parm;
	char url, ldapurl;
	int idx, i;
	char *oid;
	ksba_name_t name;

	find_up_store_certs_parm.ctrl = ctrl;
	find_up_store_certs_parm.want_fpr = 1;
	find_up_store_certs_parm.got_fpr = 0;
	find_up_store_certs_parm.count = 0;

	/* Find suitable URLs; if there is a http scheme we prefer that. */
	url = ldapurl = NULL;
	for (idx=0;
	!url && !(err = ksba_cert_get_authority_info_access (cert, idx,
	&oid, &name));
	idx++)
	{
	if (!strcmp (oid, oidstr_caIssuers))
	{
	for (i=0; !url && ksba_name_enum (name, i); i++)
	{
	char *p = ksba_name_get_uri (name, i);
	if (p)
	{
	if (!strncmp (p, "http:", 5) \|\| !strncmp (p, "https:", 6))
	url = p;
	else if (ldapurl)
	xfree (p); /* We already got one. */
	else if (!strncmp (p, "ldap:",5) \|\| !strncmp (p, "ldaps:",6))
	ldapurl = p;
	}
	else
	xfree (p);
	}
	}
	ksba_name_release (name);
	ksba_free (oid);
	}
	if (err && gpg_err_code (err) != GPG_ERR_EOF)
	{
	log_error (_("can't get authorityInfoAccess: %s\n"), gpg_strerror (err));
	return err;
	}
	if (!url && ldapurl)
	{
	/* No HTTP scheme; fallback to LDAP if available. */
	url = ldapurl;
	ldapurl = NULL;
	}
	xfree (ldapurl);
	if (!url)
	return gpg_error (GPG_ERR_NOT_FOUND);

	if (opt.verbose)
	log_info ("looking up issuer via authorityInfoAccess.caIssuers\n");

	err = gpgsm_dirmngr_lookup (ctrl, NULL, url, 0, find_up_store_certs_cb,
	&find_up_store_certs_parm);

	/* Although we might receive several certificates we use only the
	* first one. Or more exacty the first one for which we retrieved
	* the fingerprint. */
	if (opt.verbose)
	log_info ("number of caIssuers found: %d\n",
	find_up_store_certs_parm.count);
	if (err)
	{
	log_error ("external URL lookup failed: %s\n", gpg_strerror (err));
	err = gpg_error (GPG_ERR_NOT_FOUND);
	}
	else if (!find_up_store_certs_parm.got_fpr)
	err = gpg_error (GPG_ERR_NOT_FOUND);
	else
	{
	int old;
	/* The retrieved certificates are currently stored in the
	* ephemeral key DB, so we temporary switch to ephemeral
	* mode. */
	old = keydb_set_ephemeral (kh, 1);
	keydb_search_reset (kh);
	err = keydb_search_fpr (ctrl, kh, find_up_store_certs_parm.fpr);
	keydb_set_ephemeral (kh, old);
	}

	return err;
	}


	/* Helper for find_up(). Ask the dirmngr for the certificate for
	ISSUER with optional SERIALNO. KH is the keydb context we are
	currently using. With SUBJECT_MODE set, ISSUER is searched as the
	subject. On success 0 is returned and the certificate is available
	in the ephemeral DB. */
	static int
	find_up_dirmngr (ctrl_t ctrl, KEYDB_HANDLE kh,
	ksba_sexp_t serialno, const char *issuer, int subject_mode)
	{
	int rc;
	strlist_t names = NULL;
	struct find_up_store_certs_s find_up_store_certs_parm;
	char *pattern;

	(void)kh;

	find_up_store_certs_parm.ctrl = ctrl;
	find_up_store_certs_parm.count = 0;

	if (opt.verbose)
	log_info (_("looking up issuer from the Dirmngr cache\n"));
	if (subject_mode)
	{
	pattern = xtrymalloc (strlen (issuer)+2);
	if (pattern)
	strcpy (stpcpy (pattern, "/"), issuer);
	}
	else if (serialno)
	pattern = gpgsm_format_sn_issuer (serialno, issuer);
	else
	{
	pattern = xtrymalloc (strlen (issuer)+3);
	if (pattern)
	strcpy (stpcpy (pattern, "#/"), issuer);
	}
	if (!pattern)
	return gpg_error_from_syserror ();
	add_to_strlist (&names, pattern);
	xfree (pattern);

	rc = gpgsm_dirmngr_lookup (ctrl, names, NULL, 1, find_up_store_certs_cb,
	&find_up_store_certs_parm);
	free_strlist (names);

	if (opt.verbose)
	log_info (_("number of matching certificates: %d\n"),
	find_up_store_certs_parm.count);
	if (rc && !opt.quiet)
	log_info (_("dirmngr cache-only key lookup failed: %s\n"),
	gpg_strerror (rc));
	return (!rc && find_up_store_certs_parm.count)? 0 : -1;
	}



	/* Locate issuing certificate for CERT. ISSUER is the name of the
	issuer used as a fallback if the other methods don't work. If
	FIND_NEXT is true, the function shall return the next possible
	issuer. The certificate itself is not directly returned but a
	keydb_get_cert on the keydb context KH will return it. Returns 0
	on success, -1 if not found or an error code. */
	static int
	find_up (ctrl_t ctrl, KEYDB_HANDLE kh,
	ksba_cert_t cert, const char *issuer, int find_next)
	{
	ksba_name_t authid;
	ksba_sexp_t authidno;
	ksba_sexp_t keyid;
	int rc = -1;

	if (DBG_X509)
	log_debug ("looking for parent certificate\n");
	if (!ksba_cert_get_auth_key_id (cert, &keyid, &authid, &authidno))
	{
	const char *s = ksba_name_enum (authid, 0);
	if (s && *authidno)
	{
	rc = keydb_search_issuer_sn (ctrl, kh, s, authidno);
	if (rc)
	keydb_search_reset (kh);

	if (!rc && DBG_X509)
	log_debug (" found via authid and sn+issuer\n");

	/* In case of an error, try to get the certificate from the
	dirmngr. That is done by trying to put that certifcate
	into the ephemeral DB and let the code below do the
	actual retrieve. Thus there is no error checking.
	Skipped in find_next mode as usual. */
	if (rc == -1 && !find_next)
	find_up_dirmngr (ctrl, kh, authidno, s, 0);

	/* In case of an error try the ephemeral DB. We can't do
	that in find_next mode because we can't keep the search
	state then. */
	if (rc == -1 && !find_next)
	{
	int old = keydb_set_ephemeral (kh, 1);
	if (!old)
	{
	rc = keydb_search_issuer_sn (ctrl, kh, s, authidno);
	if (rc)
	keydb_search_reset (kh);

	if (!rc && DBG_X509)
	log_debug (" found via authid and sn+issuer (ephem)\n");
	}
	keydb_set_ephemeral (kh, old);
	}
	if (rc)
	rc = -1; /* Need to make sure to have this error code. */
	}

	if (rc == -1 && keyid && !find_next)
	{
	/* Not found by AKI.issuer_sn. Lets try the AKI.ki
	instead. Loop over all certificates with that issuer as
	subject and stop for the one with a matching
	subjectKeyIdentifier. */
	/* Fixme: Should we also search in the dirmngr? */
	rc = find_up_search_by_keyid (ctrl, kh, issuer, keyid);
	if (!rc && DBG_X509)
	log_debug (" found via authid and keyid\n");
	if (rc)
	{
	int old = keydb_set_ephemeral (kh, 1);
	if (!old)
	rc = find_up_search_by_keyid (ctrl, kh, issuer, keyid);
	if (!rc && DBG_X509)
	log_debug (" found via authid and keyid (ephem)\n");
	keydb_set_ephemeral (kh, old);
	}
	if (rc)
	rc = -1; /* Need to make sure to have this error code. */
	}

	/* If we still didn't found it, try to find it via the subject
	from the dirmngr-cache. */
	if (rc == -1 && !find_next)
	{
	if (!find_up_dirmngr (ctrl, kh, NULL, issuer, 1))
	{
	int old = keydb_set_ephemeral (kh, 1);
	if (keyid)
	rc = find_up_search_by_keyid (ctrl, kh, issuer, keyid);
	else
	{
	keydb_search_reset (kh);
	rc = keydb_search_subject (ctrl, kh, issuer);
	}
	keydb_set_ephemeral (kh, old);
	}
	if (rc)
	rc = -1; /* Need to make sure to have this error code. */

	if (!rc && DBG_X509)
	log_debug (" found via authid and issuer from dirmngr cache\n");
	}

	/* If we still didn't found it, try an external lookup. */
	- if (rc == -1 && opt.auto_issuer_key_retrieve && !find_next)
	+ if (rc == -1 && !find_next && !ctrl->offline)
	{
	- if (!find_up_via_auth_info_access (ctrl, kh, cert))
	+ /* We allow AIA also if CRLs are enabled; both can be used
	+ * as a web bug so it does not make sense to not use AIA if
	+ * CRL checks are enabled. */
	+ if ((opt.auto_issuer_key_retrieve \|\| !opt.no_crl_check)
	+ && !find_up_via_auth_info_access (ctrl, kh, cert))
	{
	if (DBG_X509)
	log_debug (" found via authorityInfoAccess.caIssuers\n");
	rc = 0;
	}
	- else
	+ else if (opt.auto_issuer_key_retrieve)
	{
	rc = find_up_external (ctrl, kh, issuer, keyid);
	if (!rc && DBG_X509)
	log_debug (" found via authid and external lookup\n");
	}
	}


	/* Print a note so that the user does not feel too helpless when
	an issuer certificate was found and gpgsm prints BAD
	signature because it is not the correct one. */
	if (rc == -1 && opt.quiet)
	;
	else if (rc == -1)
	{
	log_info ("%sissuer certificate ", find_next?"next ":"");
	if (keyid)
	{
	log_printf ("{");
	gpgsm_dump_serial (keyid);
	log_printf ("} ");
	}
	if (authidno)
	{
	log_printf ("(#");
	gpgsm_dump_serial (authidno);
	log_printf ("/");
	gpgsm_dump_string (s);
	log_printf (") ");
	}
	log_printf ("not found using authorityKeyIdentifier\n");
	}
	else if (rc)
	log_error ("failed to find authorityKeyIdentifier: rc=%d\n", rc);
	xfree (keyid);
	ksba_name_release (authid);
	xfree (authidno);
	}

	if (rc) /* Not found via authorithyKeyIdentifier, try regular issuer name. */
	rc = keydb_search_subject (ctrl, kh, issuer);
	if (rc == -1 && !find_next)
	{
	int old;

	/* Also try to get it from the Dirmngr cache. The function
	merely puts it into the ephemeral database. */
	find_up_dirmngr (ctrl, kh, NULL, issuer, 0);

	/* Not found, let us see whether we have one in the ephemeral key DB. */
	old = keydb_set_ephemeral (kh, 1);
	if (!old)
	{
	keydb_search_reset (kh);
	rc = keydb_search_subject (ctrl, kh, issuer);
	}
	keydb_set_ephemeral (kh, old);

	if (!rc && DBG_X509)
	log_debug (" found via issuer\n");
	}

	/* Still not found. If enabled, try an external lookup. */
	- if (rc == -1 && opt.auto_issuer_key_retrieve && !find_next)
	+ if (rc == -1 && !find_next && !ctrl->offline)
	{
	- if (!find_up_via_auth_info_access (ctrl, kh, cert))
	+ if ((opt.auto_issuer_key_retrieve \|\| !opt.no_crl_check)
	+ && !find_up_via_auth_info_access (ctrl, kh, cert))
	{
	if (DBG_X509)
	log_debug (" found via authorityInfoAccess.caIssuers\n");
	rc = 0;
	}
	- else
	+ else if (opt.auto_issuer_key_retrieve)
	{
	rc = find_up_external (ctrl, kh, issuer, NULL);
	if (!rc && DBG_X509)
	log_debug (" found via issuer and external lookup\n");
	}
	}

	return rc;
	}


	/* Return the next certificate up in the chain starting at START.
	Returns -1 when there are no more certificates. */
	int
	gpgsm_walk_cert_chain (ctrl_t ctrl, ksba_cert_t start, ksba_cert_t *r_next)
	{
	int rc = 0;
	char *issuer = NULL;
	char *subject = NULL;
	KEYDB_HANDLE kh = keydb_new ();

	*r_next = NULL;
	if (!kh)
	{
	log_error (_("failed to allocate keyDB handle\n"));
	rc = gpg_error (GPG_ERR_GENERAL);
	goto leave;
	}

	issuer = ksba_cert_get_issuer (start, 0);
	subject = ksba_cert_get_subject (start, 0);
	if (!issuer)
	{
	log_error ("no issuer found in certificate\n");
	rc = gpg_error (GPG_ERR_BAD_CERT);
	goto leave;
	}
	if (!subject)
	{
	log_error ("no subject found in certificate\n");
	rc = gpg_error (GPG_ERR_BAD_CERT);
	goto leave;
	}

	if (is_root_cert (start, issuer, subject))
	{
	rc = -1; /* we are at the root */
	goto leave;
	}

	rc = find_up (ctrl, kh, start, issuer, 0);
	if (rc)
	{
	/* It is quite common not to have a certificate, so better don't
	print an error here. */
	if (rc != -1 && opt.verbose > 1)
	log_error ("failed to find issuer's certificate: rc=%d\n", rc);
	rc = gpg_error (GPG_ERR_MISSING_ISSUER_CERT);
	goto leave;
	}

	rc = keydb_get_cert (kh, r_next);
	if (rc)
	{
	log_error ("keydb_get_cert() failed: rc=%d\n", rc);
	rc = gpg_error (GPG_ERR_GENERAL);
	}

	leave:
	xfree (issuer);
	xfree (subject);
	keydb_release (kh);
	return rc;
	}


	/* Helper for gpgsm_is_root_cert. This one is used if the subject and
	issuer DNs are already known. */
	static int
	is_root_cert (ksba_cert_t cert, const char issuerdn, const char subjectdn)
	{
	gpg_error_t err;
	int result = 0;
	ksba_sexp_t serialno;
	ksba_sexp_t ak_keyid;
	ksba_name_t ak_name;
	ksba_sexp_t ak_sn;
	const char *ak_name_str;
	ksba_sexp_t subj_keyid = NULL;

	if (!issuerdn \|\| !subjectdn)
	return 0; /* No. */

	if (strcmp (issuerdn, subjectdn))
	return 0; /* No. */

	err = ksba_cert_get_auth_key_id (cert, &ak_keyid, &ak_name, &ak_sn);
	if (err)
	{
	if (gpg_err_code (err) == GPG_ERR_NO_DATA)
	return 1; /* Yes. Without a authorityKeyIdentifier this needs
	to be the Root certifcate (our trust anchor). */
	log_error ("error getting authorityKeyIdentifier: %s\n",
	gpg_strerror (err));
	return 0; /* Well, it is broken anyway. Return No. */
	}

	serialno = ksba_cert_get_serial (cert);
	if (!serialno)
	{
	log_error ("error getting serialno: %s\n", gpg_strerror (err));
	goto leave;
	}

	/* Check whether the auth name's matches the issuer name+sn. If
	that is the case this is a root certificate. */
	ak_name_str = ksba_name_enum (ak_name, 0);
	if (ak_name_str
	&& !strcmp (ak_name_str, issuerdn)
	&& !cmp_simple_canon_sexp (ak_sn, serialno))
	{
	result = 1; /* Right, CERT is self-signed. */
	goto leave;
	}

	/* Similar for the ak_keyid. */
	if (ak_keyid && !ksba_cert_get_subj_key_id (cert, NULL, &subj_keyid)
	&& !cmp_simple_canon_sexp (ak_keyid, subj_keyid))
	{
	result = 1; /* Right, CERT is self-signed. */
	goto leave;
	}


	leave:
	ksba_free (subj_keyid);
	ksba_free (ak_keyid);
	ksba_name_release (ak_name);
	ksba_free (ak_sn);
	ksba_free (serialno);
	return result;
	}



	/* Check whether the CERT is a root certificate. Returns True if this
	is the case. */
	int
	gpgsm_is_root_cert (ksba_cert_t cert)
	{
	char *issuer;
	char *subject;
	int yes;

	issuer = ksba_cert_get_issuer (cert, 0);
	subject = ksba_cert_get_subject (cert, 0);
	yes = is_root_cert (cert, issuer, subject);
	xfree (issuer);
	xfree (subject);
	return yes;
	}


	/* This is a helper for gpgsm_validate_chain. */
	static gpg_error_t
	is_cert_still_valid (ctrl_t ctrl, int force_ocsp, int lm, estream_t fp,
	ksba_cert_t subject_cert, ksba_cert_t issuer_cert,
	int any_revoked, int any_no_crl, int *any_crl_too_old)
	{
	gpg_error_t err;

	if (ctrl->offline \|\| (opt.no_crl_check && !ctrl->use_ocsp))
	{
	audit_log_ok (ctrl->audit, AUDIT_CRL_CHECK,
	gpg_error (GPG_ERR_NOT_ENABLED));
	return 0;
	}


	if (!(force_ocsp \|\| ctrl->use_ocsp)
	&& !opt.enable_issuer_based_crl_check)
	{
	err = ksba_cert_get_crl_dist_point (subject_cert, 0, NULL, NULL, NULL);
	if (gpg_err_code (err) == GPG_ERR_EOF)
	{
	/* No DP specified in the certificate. Thus the CA does not
	* consider a CRL useful and the user of the certificate
	* also does not consider this to be a critical thing. In
	* this case we can conclude that the certificate shall not
	* be revocable. Note that we reach this point here only if
	* no OCSP responder shall be used. */
	audit_log_ok (ctrl->audit, AUDIT_CRL_CHECK, gpg_error (GPG_ERR_TRUE));
	return 0;
	}
	}

	err = gpgsm_dirmngr_isvalid (ctrl,
	subject_cert, issuer_cert,
	force_ocsp? 2 : !!ctrl->use_ocsp);
	audit_log_ok (ctrl->audit, AUDIT_CRL_CHECK, err);

	if (err)
	{
	if (!lm)
	gpgsm_cert_log_name (NULL, subject_cert);
	switch (gpg_err_code (err))
	{
	case GPG_ERR_CERT_REVOKED:
	do_list (1, lm, fp, _("certificate has been revoked"));
	*any_revoked = 1;
	/* Store that in the keybox so that key listings are able to
	return the revoked flag. We don't care about error,
	though. */
	keydb_set_cert_flags (ctrl, subject_cert, 1, KEYBOX_FLAG_VALIDITY, 0,
	~0, VALIDITY_REVOKED);
	break;

	case GPG_ERR_NO_CRL_KNOWN:
	do_list (1, lm, fp, _("no CRL found for certificate"));
	*any_no_crl = 1;
	break;

	case GPG_ERR_NO_DATA:
	do_list (1, lm, fp, _("the status of the certificate is unknown"));
	*any_no_crl = 1;
	break;

	case GPG_ERR_CRL_TOO_OLD:
	do_list (1, lm, fp, _("the available CRL is too old"));
	if (!lm)
	log_info (_("please make sure that the "
	"\"dirmngr\" is properly installed\n"));
	*any_crl_too_old = 1;
	break;

	default:
	do_list (1, lm, fp, _("checking the CRL failed: %s"),
	gpg_strerror (err));
	return err;
	}
	}
	return 0;
	}


	/* Helper for gpgsm_validate_chain to check the validity period of
	SUBJECT_CERT. The caller needs to pass EXPTIME which will be
	updated to the nearest expiration time seen. A DEPTH of 0 indicates
	the target certificate, -1 the final root certificate and other
	values intermediate certificates. */
	static gpg_error_t
	check_validity_period (ksba_isotime_t current_time,
	ksba_cert_t subject_cert,
	ksba_isotime_t exptime,
	int listmode, estream_t listfp, int depth)
	{
	gpg_error_t err;
	ksba_isotime_t not_before, not_after;

	err = ksba_cert_get_validity (subject_cert, 0, not_before);
	if (!err)
	err = ksba_cert_get_validity (subject_cert, 1, not_after);
	if (err)
	{
	do_list (1, listmode, listfp,
	_("certificate with invalid validity: %s"), gpg_strerror (err));
	return gpg_error (GPG_ERR_BAD_CERT);
	}

	if (*not_after)
	{
	if (!*exptime)
	gnupg_copy_time (exptime, not_after);
	else if (strcmp (not_after, exptime) < 0 )
	gnupg_copy_time (exptime, not_after);
	}

	if (*not_before && strcmp (current_time, not_before) < 0 )
	{
	do_list (1, listmode, listfp,
	depth == 0 ? _("certificate not yet valid") :
	depth == -1 ? _("root certificate not yet valid") :
	/* other */ _("intermediate certificate not yet valid"));
	if (!listmode)
	{
	log_info (" (valid from ");
	dump_isotime (not_before);
	log_printf (")\n");
	}
	return gpg_error (GPG_ERR_CERT_TOO_YOUNG);
	}

	if (*not_after && strcmp (current_time, not_after) > 0 )
	{
	do_list (opt.ignore_expiration?0:1, listmode, listfp,
	depth == 0 ? _("certificate has expired") :
	depth == -1 ? _("root certificate has expired") :
	/* other */ _("intermediate certificate has expired"));
	if (!listmode)
	{
	log_info (" (expired at ");
	dump_isotime (not_after);
	log_printf (")\n");
	}
	if (opt.ignore_expiration)
	log_info ("WARNING: ignoring expiration\n");
	else
	return gpg_error (GPG_ERR_CERT_EXPIRED);
	}

	return 0;
	}

	/* This is a variant of check_validity_period used with the chain
	model. The dextra contraint here is that notBefore and notAfter
	must exists and if the additional argument CHECK_TIME is given this
	time is used to check the validity period of SUBJECT_CERT. */
	static gpg_error_t
	check_validity_period_cm (ksba_isotime_t current_time,
	ksba_isotime_t check_time,
	ksba_cert_t subject_cert,
	ksba_isotime_t exptime,
	int listmode, estream_t listfp, int depth)
	{
	gpg_error_t err;
	ksba_isotime_t not_before, not_after;

	err = ksba_cert_get_validity (subject_cert, 0, not_before);
	if (!err)
	err = ksba_cert_get_validity (subject_cert, 1, not_after);
	if (err)
	{
	do_list (1, listmode, listfp,
	_("certificate with invalid validity: %s"), gpg_strerror (err));
	return gpg_error (GPG_ERR_BAD_CERT);
	}
	if (!not_before \|\| !not_after)
	{
	do_list (1, listmode, listfp,
	_("required certificate attributes missing: %s%s%s"),
	!*not_before? "notBefore":"",
	(!not_before && !not_after)? ", ":"",
	!*not_before? "notAfter":"");
	return gpg_error (GPG_ERR_BAD_CERT);
	}
	if (strcmp (not_before, not_after) > 0 )
	{
	do_list (1, listmode, listfp,
	_("certificate with invalid validity"));
	log_info (" (valid from ");
	dump_isotime (not_before);
	log_printf (" expired at ");
	dump_isotime (not_after);
	log_printf (")\n");
	return gpg_error (GPG_ERR_BAD_CERT);
	}

	if (!*exptime)
	gnupg_copy_time (exptime, not_after);
	else if (strcmp (not_after, exptime) < 0 )
	gnupg_copy_time (exptime, not_after);

	if (strcmp (current_time, not_before) < 0 )
	{
	do_list (1, listmode, listfp,
	depth == 0 ? _("certificate not yet valid") :
	depth == -1 ? _("root certificate not yet valid") :
	/* other */ _("intermediate certificate not yet valid"));
	if (!listmode)
	{
	log_info (" (valid from ");
	dump_isotime (not_before);
	log_printf (")\n");
	}
	return gpg_error (GPG_ERR_CERT_TOO_YOUNG);
	}

	if (*check_time
	&& (strcmp (check_time, not_before) < 0
	\|\| strcmp (check_time, not_after) > 0))
	{
	/* Note that we don't need a case for the root certificate
	because its own consitency has already been checked. */
	do_list(opt.ignore_expiration?0:1, listmode, listfp,
	depth == 0 ?
	_("signature not created during lifetime of certificate") :
	depth == 1 ?
	_("certificate not created during lifetime of issuer") :
	_("intermediate certificate not created during lifetime "
	"of issuer"));
	if (!listmode)
	{
	log_info (depth== 0? _(" ( signature created at ") :
	/* */ _(" (certificate created at ") );
	dump_isotime (check_time);
	log_printf (")\n");
	log_info (depth==0? _(" (certificate valid from ") :
	/* */ _(" ( issuer valid from ") );
	dump_isotime (not_before);
	log_info (" to ");
	dump_isotime (not_after);
	log_printf (")\n");
	}
	if (opt.ignore_expiration)
	log_info ("WARNING: ignoring expiration\n");
	else
	return gpg_error (GPG_ERR_CERT_EXPIRED);
	}

	return 0;
	}



	/* Ask the user whether he wants to mark the certificate CERT trusted.
	Returns true if the CERT is the trusted. We also check whether the
	agent is at all enabled to allow marktrusted and don't call it in
	this session again if it is not. */
	static int
	ask_marktrusted (ctrl_t ctrl, ksba_cert_t cert, int listmode)
	{
	static int no_more_questions;
	int rc;
	char *fpr;
	int success = 0;

	fpr = gpgsm_get_fingerprint_string (cert, GCRY_MD_SHA1);
	log_info (_("fingerprint=%s\n"), fpr? fpr : "?");
	xfree (fpr);

	if (no_more_questions)
	rc = gpg_error (GPG_ERR_NOT_SUPPORTED);
	else
	rc = gpgsm_agent_marktrusted (ctrl, cert);
	if (!rc)
	{
	log_info (_("root certificate has now been marked as trusted\n"));
	success = 1;
	}
	else if (!listmode)
	{
	gpgsm_dump_cert ("issuer", cert);
	log_info ("after checking the fingerprint, you may want "
	"to add it manually to the list of trusted certificates.\n");
	}

	if (gpg_err_code (rc) == GPG_ERR_NOT_SUPPORTED)
	{
	if (!no_more_questions)
	log_info (_("interactive marking as trusted "
	"not enabled in gpg-agent\n"));
	no_more_questions = 1;
	}
	else if (gpg_err_code (rc) == GPG_ERR_CANCELED)
	{
	log_info (_("interactive marking as trusted "
	"disabled for this session\n"));
	no_more_questions = 1;
	}
	else
	set_already_asked_marktrusted (cert);

	return success;
	}




	/* Validate a chain and optionally return the nearest expiration time
	in R_EXPTIME. With LISTMODE set to 1 a special listmode is
	activated where only information about the certificate is printed
	to LISTFP and no output is send to the usual log stream. If
	CHECKTIME_ARG is set, it is used only in the chain model instead of the
	current time.

	Defined flag bits

	VALIDATE_FLAG_NO_DIRMNGR - Do not do any dirmngr isvalid checks.
	VALIDATE_FLAG_CHAIN_MODEL - Check according to chain model.
	VALIDATE_FLAG_STEED - Check according to the STEED model.
	*/
	static int
	do_validate_chain (ctrl_t ctrl, ksba_cert_t cert, ksba_isotime_t checktime_arg,
	ksba_isotime_t r_exptime,
	int listmode, estream_t listfp, unsigned int flags,
	struct rootca_flags_s *rootca_flags)
	{
	int rc = 0, depth, maxdepth;
	char *issuer = NULL;
	char *subject = NULL;
	KEYDB_HANDLE kh = NULL;
	ksba_cert_t subject_cert = NULL, issuer_cert = NULL;
	ksba_isotime_t current_time;
	ksba_isotime_t check_time;
	ksba_isotime_t exptime;
	int any_expired = 0;
	int any_revoked = 0;
	int any_no_crl = 0;
	int any_crl_too_old = 0;
	int any_no_policy_match = 0;
	int is_qualified = -1; /* Indicates whether the certificate stems
	from a qualified root certificate.
	-1 = unknown, 0 = no, 1 = yes. */
	chain_item_t chain = NULL; /* A list of all certificates in the chain. */


	gnupg_get_isotime (current_time);
	gnupg_copy_time (ctrl->current_time, current_time);

	if ( (flags & VALIDATE_FLAG_CHAIN_MODEL) )
	{
	if (!strcmp (checktime_arg, "19700101T000000"))
	{
	do_list (1, listmode, listfp,
	_("WARNING: creation time of signature not known - "
	"assuming current time"));
	gnupg_copy_time (check_time, current_time);
	}
	else
	gnupg_copy_time (check_time, checktime_arg);
	}
	else
	*check_time = 0;

	if (r_exptime)
	*r_exptime = 0;
	*exptime = 0;

	if (opt.no_chain_validation && !listmode)
	{
	log_info ("WARNING: bypassing certificate chain validation\n");
	return 0;
	}

	kh = keydb_new ();
	if (!kh)
	{
	log_error (_("failed to allocate keyDB handle\n"));
	rc = gpg_error (GPG_ERR_GENERAL);
	goto leave;
	}

	if (DBG_X509 && !listmode)
	gpgsm_dump_cert ("target", cert);

	subject_cert = cert;
	ksba_cert_ref (subject_cert);
	maxdepth = 50;
	depth = 0;

	for (;;)
	{
	int is_root;
	gpg_error_t istrusted_rc = -1;

	/* Put the certificate on our list. */
	{
	chain_item_t ci;

	ci = xtrycalloc (1, sizeof *ci);
	if (!ci)
	{
	rc = gpg_error_from_syserror ();
	goto leave;
	}
	ksba_cert_ref (subject_cert);
	ci->cert = subject_cert;
	ci->next = chain;
	chain = ci;
	}

	xfree (issuer);
	xfree (subject);
	issuer = ksba_cert_get_issuer (subject_cert, 0);
	subject = ksba_cert_get_subject (subject_cert, 0);

	if (!issuer)
	{
	do_list (1, listmode, listfp, _("no issuer found in certificate"));
	rc = gpg_error (GPG_ERR_BAD_CERT);
	goto leave;
	}


	/* Is this a self-issued certificate (i.e. the root certificate)? */
	is_root = is_root_cert (subject_cert, issuer, subject);
	if (is_root)
	{
	chain->is_root = 1;
	/* Check early whether the certificate is listed as trusted.
	We used to do this only later but changed it to call the
	check right here so that we can access special flags
	associated with that specific root certificate. */
	if (gpgsm_cert_has_well_known_private_key (subject_cert))
	{
	memset (rootca_flags, 0, sizeof *rootca_flags);
	istrusted_rc = ((flags & VALIDATE_FLAG_STEED)
	? 0 : gpg_error (GPG_ERR_NOT_TRUSTED));
	}
	else
	istrusted_rc = gpgsm_agent_istrusted (ctrl, subject_cert, NULL,
	rootca_flags);
	audit_log_cert (ctrl->audit, AUDIT_ROOT_TRUSTED,
	subject_cert, istrusted_rc);
	/* If the chain model extended attribute is used, make sure
	that our chain model flag is set. */
	if (!(flags & VALIDATE_FLAG_STEED)
	&& has_validation_model_chain (subject_cert, listmode, listfp))
	rootca_flags->chain_model = 1;
	}


	/* Check the validity period. */
	if ( (flags & VALIDATE_FLAG_CHAIN_MODEL) )
	rc = check_validity_period_cm (current_time, check_time, subject_cert,
	exptime, listmode, listfp,
	(depth && is_root)? -1: depth);
	else
	rc = check_validity_period (current_time, subject_cert,
	exptime, listmode, listfp,
	(depth && is_root)? -1: depth);
	if (gpg_err_code (rc) == GPG_ERR_CERT_EXPIRED)
	any_expired = 1;
	else if (rc)
	goto leave;


	/* Assert that we understand all critical extensions. */
	rc = unknown_criticals (subject_cert, listmode, listfp);
	if (rc)
	goto leave;

	/* Do a policy check. */
	if (!opt.no_policy_check)
	{
	rc = check_cert_policy (subject_cert, listmode, listfp);
	if (gpg_err_code (rc) == GPG_ERR_NO_POLICY_MATCH)
	{
	any_no_policy_match = 1;
	rc = 1; /* Be on the safe side and set RC. */
	}
	else if (rc)
	goto leave;
	}


	/* If this is the root certificate we are at the end of the chain. */
	if (is_root)
	{
	if (!istrusted_rc)
	; /* No need to check the certificate for a trusted one. */
	else if (gpgsm_check_cert_sig (subject_cert, subject_cert) )
	{
	/* We only check the signature if the certificate is not
	trusted for better diagnostics. */
	do_list (1, listmode, listfp,
	_("self-signed certificate has a BAD signature"));
	if (DBG_X509)
	{
	gpgsm_dump_cert ("self-signing cert", subject_cert);
	}
	rc = gpg_error (depth? GPG_ERR_BAD_CERT_CHAIN
	: GPG_ERR_BAD_CERT);
	goto leave;
	}
	if (!rootca_flags->relax)
	{
	rc = allowed_ca (ctrl, subject_cert, NULL, listmode, listfp);
	if (rc)
	goto leave;
	}


	/* Set the flag for qualified signatures. This flag is
	deduced from a list of root certificates allowed for
	qualified signatures. */
	if (is_qualified == -1 && !(flags & VALIDATE_FLAG_STEED))
	{
	gpg_error_t err;
	size_t buflen;
	char buf[1];

	if (!ksba_cert_get_user_data (cert, "is_qualified",
	&buf, sizeof (buf),
	&buflen) && buflen)
	{
	/* We already checked this for this certificate,
	thus we simply take it from the user data. */
	is_qualified = !!*buf;
	}
	else
	{
	/* Need to consult the list of root certificates for
	qualified signatures. */
	err = gpgsm_is_in_qualified_list (ctrl, subject_cert, NULL);
	if (!err)
	is_qualified = 1;
	else if ( gpg_err_code (err) == GPG_ERR_NOT_FOUND)
	is_qualified = 0;
	else
	log_error ("checking the list of qualified "
	"root certificates failed: %s\n",
	gpg_strerror (err));
	if ( is_qualified != -1 )
	{
	/* Cache the result but don't care too much
	about an error. */
	buf[0] = !!is_qualified;
	err = ksba_cert_set_user_data (subject_cert,
	"is_qualified", buf, 1);
	if (err)
	log_error ("set_user_data(is_qualified) failed: %s\n",
	gpg_strerror (err));
	}
	}
	}


	/* Act on the check for a trusted root certificates. */
	rc = istrusted_rc;
	if (!rc)
	;
	else if (gpg_err_code (rc) == GPG_ERR_NOT_TRUSTED)
	{
	do_list (0, listmode, listfp,
	_("root certificate is not marked trusted"));
	/* If we already figured out that the certificate is
	expired it does not make much sense to ask the user
	whether they want to trust the root certificate. We
	should do this only if the certificate under question
	will then be usable. If the certificate has a well
	known private key asking the user does not make any
	sense. */
	if ( !any_expired
	&& !gpgsm_cert_has_well_known_private_key (subject_cert)
	&& (!listmode \|\| !already_asked_marktrusted (subject_cert))
	&& ask_marktrusted (ctrl, subject_cert, listmode) )
	rc = 0;
	}
	else
	{
	log_error (_("checking the trust list failed: %s\n"),
	gpg_strerror (rc));
	}

	if (rc)
	goto leave;

	/* Check for revocations etc. */
	if ((flags & VALIDATE_FLAG_NO_DIRMNGR))
	;
	else if ((flags & VALIDATE_FLAG_STEED))
	; /* Fixme: check revocations via DNS. */
	else if (opt.no_trusted_cert_crl_check \|\| rootca_flags->relax)
	;
	else
	rc = is_cert_still_valid (ctrl,
	(flags & VALIDATE_FLAG_CHAIN_MODEL),
	listmode, listfp,
	subject_cert, subject_cert,
	&any_revoked, &any_no_crl,
	&any_crl_too_old);
	if (rc)
	goto leave;

	break; /* Okay: a self-signed certicate is an end-point. */
	} /* End is_root. */


	/* Take care that the chain does not get too long. */
	if ((depth+1) > maxdepth)
	{
	do_list (1, listmode, listfp, _("certificate chain too long\n"));
	rc = gpg_error (GPG_ERR_BAD_CERT_CHAIN);
	goto leave;
	}

	/* Find the next cert up the tree. */
	keydb_search_reset (kh);
	rc = find_up (ctrl, kh, subject_cert, issuer, 0);
	if (rc)
	{
	if (rc == -1)
	{
	do_list (0, listmode, listfp, _("issuer certificate not found"));
	if (!listmode)
	{
	log_info ("issuer certificate: #/");
	gpgsm_dump_string (issuer);
	log_printf ("\n");
	}
	}
	else
	log_error ("failed to find issuer's certificate: rc=%d\n", rc);
	rc = gpg_error (GPG_ERR_MISSING_ISSUER_CERT);
	goto leave;
	}

	ksba_cert_release (issuer_cert); issuer_cert = NULL;
	rc = keydb_get_cert (kh, &issuer_cert);
	if (rc)
	{
	log_error ("keydb_get_cert() failed: rc=%d\n", rc);
	rc = gpg_error (GPG_ERR_GENERAL);
	goto leave;
	}

	try_another_cert:
	if (DBG_X509)
	{
	log_debug ("got issuer's certificate:\n");
	gpgsm_dump_cert ("issuer", issuer_cert);
	}

	rc = gpgsm_check_cert_sig (issuer_cert, subject_cert);
	if (rc)
	{
	do_list (0, listmode, listfp, _("certificate has a BAD signature"));
	if (DBG_X509)
	{
	gpgsm_dump_cert ("signing issuer", issuer_cert);
	gpgsm_dump_cert ("signed subject", subject_cert);
	}
	if (gpg_err_code (rc) == GPG_ERR_BAD_SIGNATURE)
	{
	/* We now try to find other issuer certificates which
	might have been used. This is required because some
	CAs are reusing the issuer and subject DN for new
	root certificates. */
	/* FIXME: Do this only if we don't have an
	AKI.keyIdentifier */
	rc = find_up (ctrl, kh, subject_cert, issuer, 1);
	if (!rc)
	{
	ksba_cert_t tmp_cert;

	rc = keydb_get_cert (kh, &tmp_cert);
	if (rc \|\| !compare_certs (issuer_cert, tmp_cert))
	{
	/* The find next did not work or returned an
	identical certificate. We better stop here
	to avoid infinite checks. */
	/* No need to set RC because it is not used:
	rc = gpg_error (GPG_ERR_BAD_SIGNATURE); */
	ksba_cert_release (tmp_cert);
	}
	else
	{
	do_list (0, listmode, listfp,
	_("found another possible matching "
	"CA certificate - trying again"));
	ksba_cert_release (issuer_cert);
	issuer_cert = tmp_cert;
	goto try_another_cert;
	}
	}
	}

	/* We give a more descriptive error code than the one
	returned from the signature checking. */
	rc = gpg_error (GPG_ERR_BAD_CERT_CHAIN);
	goto leave;
	}

	is_root = gpgsm_is_root_cert (issuer_cert);
	istrusted_rc = -1;


	/* Check that a CA is allowed to issue certificates. */
	{
	int chainlen;

	rc = allowed_ca (ctrl, issuer_cert, &chainlen, listmode, listfp);
	if (rc)
	{
	/* Not allowed. Check whether this is a trusted root
	certificate and whether we allow special exceptions.
	We could carry the result of the test over to the
	regular root check at the top of the loop but for
	clarity we won't do that. Given that the majority of
	certificates carry proper BasicContraints our way of
	overriding an error in the way is justified for
	performance reasons. */
	if (is_root)
	{
	if (gpgsm_cert_has_well_known_private_key (issuer_cert))
	{
	memset (rootca_flags, 0, sizeof *rootca_flags);
	istrusted_rc = ((flags & VALIDATE_FLAG_STEED)
	? 0 : gpg_error (GPG_ERR_NOT_TRUSTED));
	}
	else
	istrusted_rc = gpgsm_agent_istrusted
	(ctrl, issuer_cert, NULL, rootca_flags);

	if (!istrusted_rc && rootca_flags->relax)
	{
	/* Ignore the error due to the relax flag. */
	rc = 0;
	chainlen = -1;
	}
	}
	}
	if (rc)
	goto leave;
	if (chainlen >= 0 && depth > chainlen)
	{
	do_list (1, listmode, listfp,
	_("certificate chain longer than allowed by CA (%d)"),
	chainlen);
	rc = gpg_error (GPG_ERR_BAD_CERT_CHAIN);
	goto leave;
	}
	}

	/* Is the certificate allowed to sign other certificates. */
	if (!listmode)
	{
	rc = gpgsm_cert_use_cert_p (issuer_cert);
	if (rc)
	{
	char numbuf[50];
	sprintf (numbuf, "%d", rc);
	gpgsm_status2 (ctrl, STATUS_ERROR, "certcert.issuer.keyusage",
	numbuf, NULL);
	goto leave;
	}
	}

	/* Check for revocations etc. Note that for a root certificate
	this test is done a second time later. This should eventually
	be fixed. */
	if ((flags & VALIDATE_FLAG_NO_DIRMNGR))
	rc = 0;
	else if ((flags & VALIDATE_FLAG_STEED))
	rc = 0; /* Fixme: XXX */
	else if (is_root && (opt.no_trusted_cert_crl_check
	\|\| (!istrusted_rc && rootca_flags->relax)))
	rc = 0;
	else
	rc = is_cert_still_valid (ctrl,
	(flags & VALIDATE_FLAG_CHAIN_MODEL),
	listmode, listfp,
	subject_cert, issuer_cert,
	&any_revoked, &any_no_crl, &any_crl_too_old);
	if (rc)
	goto leave;


	if (opt.verbose && !listmode)
	log_info (depth == 0 ? _("certificate is good\n") :
	!is_root ? _("intermediate certificate is good\n") :
	/* other */ _("root certificate is good\n"));

	/* Under the chain model the next check time is the creation
	time of the subject certificate. */
	if ( (flags & VALIDATE_FLAG_CHAIN_MODEL) )
	{
	rc = ksba_cert_get_validity (subject_cert, 0, check_time);
	if (rc)
	{
	/* That will never happen as we have already checked
	this above. */
	BUG ();
	}
	}

	/* For the next round the current issuer becomes the new subject. */
	keydb_search_reset (kh);
	ksba_cert_release (subject_cert);
	subject_cert = issuer_cert;
	issuer_cert = NULL;
	depth++;
	} /* End chain traversal. */

	if (!listmode && !opt.quiet)
	{
	if (opt.no_policy_check)
	log_info ("policies not checked due to %s option\n",
	"--disable-policy-checks");
	if (ctrl->offline \|\| (opt.no_crl_check && !ctrl->use_ocsp))
	log_info ("CRLs not checked due to %s option\n",
	ctrl->offline ? "offline" : "--disable-crl-checks");
	}

	if (!rc)
	{ /* If we encountered an error somewhere during the checks, set
	the error code to the most critical one */
	if (any_revoked)
	rc = gpg_error (GPG_ERR_CERT_REVOKED);
	else if (any_expired)
	rc = gpg_error (GPG_ERR_CERT_EXPIRED);
	else if (any_no_crl)
	rc = gpg_error (GPG_ERR_NO_CRL_KNOWN);
	else if (any_crl_too_old)
	rc = gpg_error (GPG_ERR_CRL_TOO_OLD);
	else if (any_no_policy_match)
	rc = gpg_error (GPG_ERR_NO_POLICY_MATCH);
	}

	leave:
	/* If we have traversed a complete chain up to the root we will
	reset the ephemeral flag for all these certificates. This is done
	regardless of any error because those errors may only be
	transient. */
	if (chain && chain->is_root)
	{
	gpg_error_t err;
	chain_item_t ci;

	for (ci = chain; ci; ci = ci->next)
	{
	/* Note that it is possible for the last certificate in the
	chain (i.e. our target certificate) that it has not yet
	been stored in the keybox and thus the flag can't be set.
	We ignore this error because it will later be stored
	anyway. */
	err = keydb_set_cert_flags (ctrl, ci->cert, 1, KEYBOX_FLAG_BLOB, 0,
	KEYBOX_FLAG_BLOB_EPHEMERAL, 0);
	if (!ci->next && gpg_err_code (err) == GPG_ERR_NOT_FOUND)
	;
	else if (err)
	log_error ("clearing ephemeral flag failed: %s\n",
	gpg_strerror (err));
	}
	}

	/* If we have figured something about the qualified signature
	capability of the certificate under question, store the result as
	user data in all certificates of the chain. We do this even if the
	validation itself failed. */
	if (is_qualified != -1 && !(flags & VALIDATE_FLAG_STEED))
	{
	gpg_error_t err;
	chain_item_t ci;
	char buf[1];

	buf[0] = !!is_qualified;

	for (ci = chain; ci; ci = ci->next)
	{
	err = ksba_cert_set_user_data (ci->cert, "is_qualified", buf, 1);
	if (err)
	{
	log_error ("set_user_data(is_qualified) failed: %s\n",
	gpg_strerror (err));
	if (!rc)
	rc = err;
	}
	}
	}

	/* If auditing has been enabled, record what is in the chain. */
	if (ctrl->audit)
	{
	chain_item_t ci;

	audit_log (ctrl->audit, AUDIT_CHAIN_BEGIN);
	for (ci = chain; ci; ci = ci->next)
	{
	audit_log_cert (ctrl->audit,
	ci->is_root? AUDIT_CHAIN_ROOTCERT : AUDIT_CHAIN_CERT,
	ci->cert, 0);
	}
	audit_log (ctrl->audit, AUDIT_CHAIN_END);
	}

	if (r_exptime)
	gnupg_copy_time (r_exptime, exptime);
	xfree (issuer);
	xfree (subject);
	keydb_release (kh);
	while (chain)
	{
	chain_item_t ci_next = chain->next;
	ksba_cert_release (chain->cert);
	xfree (chain);
	chain = ci_next;
	}
	ksba_cert_release (issuer_cert);
	ksba_cert_release (subject_cert);
	return rc;
	}


	/* Validate a certificate chain. For a description see
	do_validate_chain. This function is a wrapper to handle a root
	certificate with the chain_model flag set. If RETFLAGS is not
	NULL, flags indicating now the verification was done are stored
	there. The only defined vits for RETFLAGS are
	VALIDATE_FLAG_CHAIN_MODEL and VALIDATE_FLAG_STEED.

	If you are verifying a signature you should set CHECKTIME to the
	creation time of the signature. If your are verifying a
	certificate, set it nil (i.e. the empty string). If the creation
	date of the signature is not known use the special date
	"19700101T000000" which is treated in a special way here. */
	int
	gpgsm_validate_chain (ctrl_t ctrl, ksba_cert_t cert, ksba_isotime_t checktime,
	ksba_isotime_t r_exptime,
	int listmode, estream_t listfp, unsigned int flags,
	unsigned int *retflags)
	{
	int rc;
	struct rootca_flags_s rootca_flags;
	unsigned int dummy_retflags;

	if (!retflags)
	retflags = &dummy_retflags;

	/* If the session requested a certain validation mode make sure the
	corresponding flags are set. */
	if (ctrl->validation_model == 1)
	flags \|= VALIDATE_FLAG_CHAIN_MODEL;
	else if (ctrl->validation_model == 2)
	flags \|= VALIDATE_FLAG_STEED;

	/* If the chain model was forced, set this immediately into
	RETFLAGS. */
	*retflags = (flags & VALIDATE_FLAG_CHAIN_MODEL);

	memset (&rootca_flags, 0, sizeof rootca_flags);

	rc = do_validate_chain (ctrl, cert, checktime,
	r_exptime, listmode, listfp, flags,
	&rootca_flags);
	if (!rc && (flags & VALIDATE_FLAG_STEED))
	{
	*retflags \|= VALIDATE_FLAG_STEED;
	}
	else if (gpg_err_code (rc) == GPG_ERR_CERT_EXPIRED
	&& !(flags & VALIDATE_FLAG_CHAIN_MODEL)
	&& (rootca_flags.valid && rootca_flags.chain_model))
	{
	do_list (0, listmode, listfp, _("switching to chain model"));
	rc = do_validate_chain (ctrl, cert, checktime,
	r_exptime, listmode, listfp,
	(flags \|= VALIDATE_FLAG_CHAIN_MODEL),
	&rootca_flags);
	*retflags \|= VALIDATE_FLAG_CHAIN_MODEL;
	}

	if (opt.verbose)
	do_list (0, listmode, listfp, _("validation model used: %s"),
	(*retflags & VALIDATE_FLAG_STEED)?
	"steed" :
	(*retflags & VALIDATE_FLAG_CHAIN_MODEL)?
	_("chain"):_("shell"));

	return rc;
	}


	/* Check that the given certificate is valid but DO NOT check any
	constraints. We assume that the issuers certificate is already in
	the DB and that this one is valid; which it should be because it
	has been checked using this function. */
	int
	gpgsm_basic_cert_check (ctrl_t ctrl, ksba_cert_t cert)
	{
	int rc = 0;
	char *issuer = NULL;
	char *subject = NULL;
	KEYDB_HANDLE kh;
	ksba_cert_t issuer_cert = NULL;

	if (opt.no_chain_validation)
	{
	log_info ("WARNING: bypassing basic certificate checks\n");
	return 0;
	}

	kh = keydb_new ();
	if (!kh)
	{
	log_error (_("failed to allocate keyDB handle\n"));
	rc = gpg_error (GPG_ERR_GENERAL);
	goto leave;
	}

	issuer = ksba_cert_get_issuer (cert, 0);
	subject = ksba_cert_get_subject (cert, 0);
	if (!issuer)
	{
	log_error ("no issuer found in certificate\n");
	rc = gpg_error (GPG_ERR_BAD_CERT);
	goto leave;
	}

	if (is_root_cert (cert, issuer, subject))
	{
	rc = gpgsm_check_cert_sig (cert, cert);
	if (rc)
	{
	log_error ("self-signed certificate has a BAD signature: %s\n",
	gpg_strerror (rc));
	if (DBG_X509)
	{
	gpgsm_dump_cert ("self-signing cert", cert);
	}
	rc = gpg_error (GPG_ERR_BAD_CERT);
	goto leave;
	}
	}
	else
	{
	/* Find the next cert up the tree. */
	keydb_search_reset (kh);
	rc = find_up (ctrl, kh, cert, issuer, 0);
	if (rc)
	{
	if (rc == -1)
	{
	log_info ("issuer certificate (#/");
	gpgsm_dump_string (issuer);
	log_printf (") not found\n");
	}
	else
	log_error ("failed to find issuer's certificate: rc=%d\n", rc);
	rc = gpg_error (GPG_ERR_MISSING_ISSUER_CERT);
	goto leave;
	}

	ksba_cert_release (issuer_cert); issuer_cert = NULL;
	rc = keydb_get_cert (kh, &issuer_cert);
	if (rc)
	{
	log_error ("keydb_get_cert() failed: rc=%d\n", rc);
	rc = gpg_error (GPG_ERR_GENERAL);
	goto leave;
	}

	rc = gpgsm_check_cert_sig (issuer_cert, cert);
	if (rc)
	{
	log_error ("certificate has a BAD signature: %s\n",
	gpg_strerror (rc));
	if (DBG_X509)
	{
	gpgsm_dump_cert ("signing issuer", issuer_cert);
	gpgsm_dump_cert ("signed subject", cert);
	}
	rc = gpg_error (GPG_ERR_BAD_CERT);
	goto leave;
	}
	if (opt.verbose)
	log_info (_("certificate is good\n"));
	}

	leave:
	xfree (issuer);
	xfree (subject);
	keydb_release (kh);
	ksba_cert_release (issuer_cert);
	return rc;
	}



	/* Check whether the certificate CERT has been issued by the German
	authority for qualified signature. They do not set the
	basicConstraints and thus we need this workaround. It works by
	looking up the root certificate and checking whether that one is
	listed as a qualified certificate for Germany.

	We also try to cache this data but as long as don't keep a
	reference to the certificate this won't be used.

	Returns: True if CERT is a RegTP issued CA cert (i.e. the root
	certificate itself or one of the CAs). In that case CHAINLEN will
	receive the length of the chain which is either 0 or 1.
	*/
	static int
	get_regtp_ca_info (ctrl_t ctrl, ksba_cert_t cert, int *chainlen)
	{
	gpg_error_t err;
	ksba_cert_t next;
	int rc = 0;
	int i, depth;
	char country[3];
	ksba_cert_t array[4];
	char buf[2];
	size_t buflen;
	int dummy_chainlen;

	if (!chainlen)
	chainlen = &dummy_chainlen;

	*chainlen = 0;
	err = ksba_cert_get_user_data (cert, "regtp_ca_chainlen",
	&buf, sizeof (buf), &buflen);
	if (!err)
	{
	/* Got info. */
	if (buflen < 2 \|\| !*buf)
	return 0; /* Nothing found. */
	*chainlen = buf[1];
	return 1; /* This is a regtp CA. */
	}
	else if (gpg_err_code (err) != GPG_ERR_NOT_FOUND)
	{
	log_error ("ksba_cert_get_user_data(%s) failed: %s\n",
	"regtp_ca_chainlen", gpg_strerror (err));
	return 0; /* Nothing found. */
	}

	/* Need to gather the info. This requires to walk up the chain
	until we have found the root. Because we are only interested in
	German Bundesnetzagentur (former RegTP) derived certificates 3
	levels are enough. (The German signature law demands a 3 tier
	hierarchy; thus there is only one CA between the EE and the Root
	CA.) */
	memset (&array, 0, sizeof array);

	depth = 0;
	ksba_cert_ref (cert);
	array[depth++] = cert;
	ksba_cert_ref (cert);
	while (depth < DIM(array) && !(rc=gpgsm_walk_cert_chain (ctrl, cert, &next)))
	{
	ksba_cert_release (cert);
	ksba_cert_ref (next);
	array[depth++] = next;
	cert = next;
	}
	ksba_cert_release (cert);
	if (rc != -1 \|\| !depth \|\| depth == DIM(array) )
	{
	/* We did not reached the root. */
	goto leave;
	}

	/* If this is a German signature law issued certificate, we store
	additional information. */
	if (!gpgsm_is_in_qualified_list (NULL, array[depth-1], country)
	&& !strcmp (country, "de"))
	{
	/* Setting the pathlen for the root CA and the CA flag for the
	next one is all what we need to do. */
	err = ksba_cert_set_user_data (array[depth-1], "regtp_ca_chainlen",
	"\x01\x01", 2);
	if (!err && depth > 1)
	err = ksba_cert_set_user_data (array[depth-2], "regtp_ca_chainlen",
	"\x01\x00", 2);
	if (err)
	log_error ("ksba_set_user_data(%s) failed: %s\n",
	"regtp_ca_chainlen", gpg_strerror (err));
	for (i=0; i < depth; i++)
	ksba_cert_release (array[i]);
	*chainlen = (depth>1? 0:1);
	return 1;
	}

	leave:
	/* Nothing special with this certificate. Mark the target
	certificate anyway to avoid duplicate lookups. */
	err = ksba_cert_set_user_data (cert, "regtp_ca_chainlen", "", 1);
	if (err)
	log_error ("ksba_set_user_data(%s) failed: %s\n",
	"regtp_ca_chainlen", gpg_strerror (err));
	for (i=0; i < depth; i++)
	ksba_cert_release (array[i]);
	return 0;
	}

File Metadata

Mime Type: text/x-diff
Expires: Mon, Dec 23, 4:50 PM (10 h, 11 m)
Storage Engine: local-disk
Storage Format: Raw Data
Storage Handle: a6/2b/bf0c77889369b259843565a649ff

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions