1X509_VERIFY_PARAM_SET_FLAGS(3ossl)  OpenSSL X509_VERIFY_PARAM_SET_FLAGS(3ossl)
2
3
4

NAME

6       X509_VERIFY_PARAM_set_flags, X509_VERIFY_PARAM_clear_flags,
7       X509_VERIFY_PARAM_get_flags, X509_VERIFY_PARAM_set_purpose,
8       X509_VERIFY_PARAM_get_inh_flags, X509_VERIFY_PARAM_set_inh_flags,
9       X509_VERIFY_PARAM_set_trust, X509_VERIFY_PARAM_set_depth,
10       X509_VERIFY_PARAM_get_depth, X509_VERIFY_PARAM_set_auth_level,
11       X509_VERIFY_PARAM_get_auth_level, X509_VERIFY_PARAM_set_time,
12       X509_VERIFY_PARAM_get_time, X509_VERIFY_PARAM_add0_policy,
13       X509_VERIFY_PARAM_set1_policies, X509_VERIFY_PARAM_get0_host,
14       X509_VERIFY_PARAM_set1_host, X509_VERIFY_PARAM_add1_host,
15       X509_VERIFY_PARAM_set_hostflags, X509_VERIFY_PARAM_get_hostflags,
16       X509_VERIFY_PARAM_get0_peername, X509_VERIFY_PARAM_get0_email,
17       X509_VERIFY_PARAM_set1_email, X509_VERIFY_PARAM_set1_ip,
18       X509_VERIFY_PARAM_get1_ip_asc, X509_VERIFY_PARAM_set1_ip_asc - X509
19       verification parameters
20

SYNOPSIS

22        #include <openssl/x509_vfy.h>
23
24        int X509_VERIFY_PARAM_set_flags(X509_VERIFY_PARAM *param,
25                                        unsigned long flags);
26        int X509_VERIFY_PARAM_clear_flags(X509_VERIFY_PARAM *param,
27                                          unsigned long flags);
28        unsigned long X509_VERIFY_PARAM_get_flags(const X509_VERIFY_PARAM *param);
29
30        int X509_VERIFY_PARAM_set_inh_flags(X509_VERIFY_PARAM *param,
31                                            uint32_t flags);
32        uint32_t X509_VERIFY_PARAM_get_inh_flags(const X509_VERIFY_PARAM *param);
33
34        int X509_VERIFY_PARAM_set_purpose(X509_VERIFY_PARAM *param, int purpose);
35        int X509_VERIFY_PARAM_set_trust(X509_VERIFY_PARAM *param, int trust);
36
37        void X509_VERIFY_PARAM_set_time(X509_VERIFY_PARAM *param, time_t t);
38        time_t X509_VERIFY_PARAM_get_time(const X509_VERIFY_PARAM *param);
39
40        int X509_VERIFY_PARAM_add0_policy(X509_VERIFY_PARAM *param,
41                                          ASN1_OBJECT *policy);
42        int X509_VERIFY_PARAM_set1_policies(X509_VERIFY_PARAM *param,
43                                            STACK_OF(ASN1_OBJECT) *policies);
44
45        void X509_VERIFY_PARAM_set_depth(X509_VERIFY_PARAM *param, int depth);
46        int X509_VERIFY_PARAM_get_depth(const X509_VERIFY_PARAM *param);
47
48        void X509_VERIFY_PARAM_set_auth_level(X509_VERIFY_PARAM *param,
49                                              int auth_level);
50        int X509_VERIFY_PARAM_get_auth_level(const X509_VERIFY_PARAM *param);
51
52        char *X509_VERIFY_PARAM_get0_host(X509_VERIFY_PARAM *param, int n);
53        int X509_VERIFY_PARAM_set1_host(X509_VERIFY_PARAM *param,
54                                        const char *name, size_t namelen);
55        int X509_VERIFY_PARAM_add1_host(X509_VERIFY_PARAM *param,
56                                        const char *name, size_t namelen);
57        void X509_VERIFY_PARAM_set_hostflags(X509_VERIFY_PARAM *param,
58                                             unsigned int flags);
59        unsigned int X509_VERIFY_PARAM_get_hostflags(const X509_VERIFY_PARAM *param);
60        char *X509_VERIFY_PARAM_get0_peername(const X509_VERIFY_PARAM *param);
61        char *X509_VERIFY_PARAM_get0_email(X509_VERIFY_PARAM *param);
62        int X509_VERIFY_PARAM_set1_email(X509_VERIFY_PARAM *param,
63                                         const char *email, size_t emaillen);
64        char *X509_VERIFY_PARAM_get1_ip_asc(X509_VERIFY_PARAM *param);
65        int X509_VERIFY_PARAM_set1_ip(X509_VERIFY_PARAM *param,
66                                      const unsigned char *ip, size_t iplen);
67        int X509_VERIFY_PARAM_set1_ip_asc(X509_VERIFY_PARAM *param, const char *ipasc);
68

DESCRIPTION

70       These functions manipulate the X509_VERIFY_PARAM structure associated
71       with a certificate verification operation.
72
73       The X509_VERIFY_PARAM_set_flags() function sets the flags in param by
74       oring it with flags. See "VERIFICATION FLAGS" for a complete
75       description of values the flags parameter can take.
76
77       X509_VERIFY_PARAM_get_flags() returns the flags in param.
78
79       X509_VERIFY_PARAM_get_inh_flags() returns the inheritance flags in
80       param which specifies how verification flags are copied from one
81       structure to another. X509_VERIFY_PARAM_set_inh_flags() sets the
82       inheritance flags.  See the INHERITANCE FLAGS section for a description
83       of these bits.
84
85       X509_VERIFY_PARAM_clear_flags() clears the flags flags in param.
86
87       X509_VERIFY_PARAM_set_purpose() sets the verification purpose in param
88       to purpose. This determines the acceptable purpose of the certificate
89       chain, for example X509_PURPOSE_SSL_CLIENT.
90
91       X509_VERIFY_PARAM_set_trust() sets the trust setting in param to trust.
92
93       X509_VERIFY_PARAM_set_time() sets the verification time in param to t.
94       Normally the current time is used.
95
96       X509_VERIFY_PARAM_add0_policy() enables policy checking (it is disabled
97       by default) and adds policy to the acceptable policy set.
98
99       X509_VERIFY_PARAM_set1_policies() enables policy checking (it is
100       disabled by default) and sets the acceptable policy set to policies.
101       Any existing policy set is cleared. The policies parameter can be NULL
102       to clear an existing policy set.
103
104       X509_VERIFY_PARAM_set_depth() sets the maximum verification depth to
105       depth.  That is the maximum number of intermediate CA certificates that
106       can appear in a chain.  A maximal depth chain contains 2 more
107       certificates than the limit, since neither the end-entity certificate
108       nor the trust-anchor count against this limit.  Thus a depth limit of 0
109       only allows the end-entity certificate to be signed directly by the
110       trust anchor, while with a depth limit of 1 there can be one
111       intermediate CA certificate between the trust anchor and the end-entity
112       certificate.
113
114       X509_VERIFY_PARAM_set_auth_level() sets the authentication security
115       level to auth_level.  The authentication security level determines the
116       acceptable signature and public key strength when verifying certificate
117       chains.  For a certificate chain to validate, the public keys of all
118       the certificates must meet the specified security level.  The signature
119       algorithm security level is not enforced for the chain's trust anchor
120       certificate, which is either directly trusted or validated by means
121       other than its signature.  See SSL_CTX_set_security_level(3) for the
122       definitions of the available levels.  The default security level is -1,
123       or "not set".  At security level 0 or lower all algorithms are
124       acceptable.  Security level 1 requires at least 80-bit-equivalent
125       security and is broadly interoperable, though it will, for example,
126       reject MD5 signatures or RSA keys shorter than 1024 bits.
127
128       X509_VERIFY_PARAM_get0_host() returns the nth expected DNS hostname
129       that has been set using X509_VERIFY_PARAM_set1_host() or
130       X509_VERIFY_PARAM_add1_host().  To obtain all names start with n = 0
131       and increment n as long as no NULL pointer is returned.
132
133       X509_VERIFY_PARAM_set1_host() sets the expected DNS hostname to name
134       clearing any previously specified hostname.  If name is NULL, or empty
135       the list of hostnames is cleared, and name checks are not performed on
136       the peer certificate.  If name is NUL-terminated, namelen may be zero,
137       otherwise namelen must be set to the length of name.
138
139       When a hostname is specified, certificate verification automatically
140       invokes X509_check_host(3) with flags equal to the flags argument given
141       to X509_VERIFY_PARAM_set_hostflags() (default zero).  Applications are
142       strongly advised to use this interface in preference to explicitly
143       calling X509_check_host(3), hostname checks may be out of scope with
144       the DANE-EE(3) certificate usage, and the internal check will be
145       suppressed as appropriate when DANE verification is enabled.
146
147       When the subject CommonName will not be ignored, whether as a result of
148       the X509_CHECK_FLAG_ALWAYS_CHECK_SUBJECT host flag, or because no DNS
149       subject alternative names are present in the certificate, any DNS name
150       constraints in issuer certificates apply to the subject CommonName as
151       well as the subject alternative name extension.
152
153       When the subject CommonName will be ignored, whether as a result of the
154       X509_CHECK_FLAG_NEVER_CHECK_SUBJECT host flag, or because some DNS
155       subject alternative names are present in the certificate, DNS name
156       constraints in issuer certificates will not be applied to the subject
157       DN.  As described in X509_check_host(3) the
158       X509_CHECK_FLAG_NEVER_CHECK_SUBJECT flag takes precedence over the
159       X509_CHECK_FLAG_ALWAYS_CHECK_SUBJECT flag.
160
161       X509_VERIFY_PARAM_get_hostflags() returns any host flags previously set
162       via a call to X509_VERIFY_PARAM_set_hostflags().
163
164       X509_VERIFY_PARAM_add1_host() adds name as an additional reference
165       identifier that can match the peer's certificate.  Any previous names
166       set via X509_VERIFY_PARAM_set1_host() or X509_VERIFY_PARAM_add1_host()
167       are retained, no change is made if name is NULL or empty.  When
168       multiple names are configured, the peer is considered verified when any
169       name matches.
170
171       X509_VERIFY_PARAM_get0_peername() returns the DNS hostname or subject
172       CommonName from the peer certificate that matched one of the reference
173       identifiers.  When wildcard matching is not disabled, or when a
174       reference identifier specifies a parent domain (starts with ".")
175       rather than a hostname, the peer name may be a wildcard name or a sub-
176       domain of the reference identifier respectively.  The return string is
177       allocated by the library and is no longer valid once the associated
178       param argument is freed.  Applications must not free the return value.
179
180       X509_VERIFY_PARAM_get0_email() returns the expected RFC822 email
181       address.
182
183       X509_VERIFY_PARAM_set1_email() sets the expected RFC822 email address
184       to email.  If email is NUL-terminated, emaillen may be zero, otherwise
185       emaillen must be set to the length of email.  When an email address is
186       specified, certificate verification automatically invokes
187       X509_check_email(3).
188
189       X509_VERIFY_PARAM_get1_ip_asc() returns the expected IP address as a
190       string.  The caller is responsible for freeing it.
191
192       X509_VERIFY_PARAM_set1_ip() sets the expected IP address to ip.  The ip
193       argument is in binary format, in network byte-order and iplen must be
194       set to 4 for IPv4 and 16 for IPv6.  When an IP address is specified,
195       certificate verification automatically invokes X509_check_ip(3).
196
197       X509_VERIFY_PARAM_set1_ip_asc() sets the expected IP address to ipasc.
198       The ipasc argument is a NUL-terminal ASCII string: dotted decimal quad
199       for IPv4 and colon-separated hexadecimal for IPv6.  The condensed "::"
200       notation is supported for IPv6 addresses.
201

RETURN VALUES

203       X509_VERIFY_PARAM_set_flags(), X509_VERIFY_PARAM_clear_flags(),
204       X509_VERIFY_PARAM_set_inh_flags(), X509_VERIFY_PARAM_set_purpose(),
205       X509_VERIFY_PARAM_set_trust(), X509_VERIFY_PARAM_add0_policy()
206       X509_VERIFY_PARAM_set1_policies(), X509_VERIFY_PARAM_set1_host(),
207       X509_VERIFY_PARAM_add1_host(), X509_VERIFY_PARAM_set1_email(),
208       X509_VERIFY_PARAM_set1_ip() and X509_VERIFY_PARAM_set1_ip_asc() return
209       1 for success and 0 for failure.
210
211       X509_VERIFY_PARAM_get0_host(), X509_VERIFY_PARAM_get0_email(), and
212       X509_VERIFY_PARAM_get1_ip_asc(), return the string pointers pecified
213       above or NULL if the respective value has not been set or on error.
214
215       X509_VERIFY_PARAM_get_flags() returns the current verification flags.
216
217       X509_VERIFY_PARAM_get_hostflags() returns any current host flags.
218
219       X509_VERIFY_PARAM_get_inh_flags() returns the current inheritance
220       flags.
221
222       X509_VERIFY_PARAM_set_time() and X509_VERIFY_PARAM_set_depth() do not
223       return values.
224
225       X509_VERIFY_PARAM_get_depth() returns the current verification depth.
226
227       X509_VERIFY_PARAM_get_auth_level() returns the current authentication
228       security level.
229

VERIFICATION FLAGS

231       The verification flags consists of zero or more of the following flags
232       ored together.
233
234       X509_V_FLAG_CRL_CHECK enables CRL checking for the certificate chain
235       leaf certificate. An error occurs if a suitable CRL cannot be found.
236
237       X509_V_FLAG_CRL_CHECK_ALL enables CRL checking for the entire
238       certificate chain.
239
240       X509_V_FLAG_IGNORE_CRITICAL disables critical extension checking. By
241       default any unhandled critical extensions in certificates or (if
242       checked) CRLs result in a fatal error. If this flag is set unhandled
243       critical extensions are ignored. WARNING setting this option for
244       anything other than debugging purposes can be a security risk. Finer
245       control over which extensions are supported can be performed in the
246       verification callback.
247
248       The X509_V_FLAG_X509_STRICT flag disables workarounds for some broken
249       certificates and makes the verification strictly apply X509 rules.
250
251       X509_V_FLAG_ALLOW_PROXY_CERTS enables proxy certificate verification.
252
253       X509_V_FLAG_POLICY_CHECK enables certificate policy checking, by
254       default no policy checking is performed. Additional information is sent
255       to the verification callback relating to policy checking.
256
257       X509_V_FLAG_EXPLICIT_POLICY, X509_V_FLAG_INHIBIT_ANY and
258       X509_V_FLAG_INHIBIT_MAP set the require explicit policy, inhibit any
259       policy and inhibit policy mapping flags respectively as defined in
260       RFC3280. Policy checking is automatically enabled if any of these flags
261       are set.
262
263       If X509_V_FLAG_NOTIFY_POLICY is set and the policy checking is
264       successful a special status code is set to the verification callback.
265       This permits it to examine the valid policy tree and perform additional
266       checks or simply log it for debugging purposes.
267
268       By default some additional features such as indirect CRLs and CRLs
269       signed by different keys are disabled. If
270       X509_V_FLAG_EXTENDED_CRL_SUPPORT is set they are enabled.
271
272       If X509_V_FLAG_USE_DELTAS is set delta CRLs (if present) are used to
273       determine certificate status. If not set deltas are ignored.
274
275       X509_V_FLAG_CHECK_SS_SIGNATURE requests checking the signature of the
276       last certificate in a chain if the certificate is supposedly self-
277       signed.  This is prohibited and will result in an error if it is a non-
278       conforming CA certificate with key usage restrictions not including the
279       keyCertSign bit.  By default this check is disabled because it doesn't
280       add any additional security but in some cases applications might want
281       to check the signature anyway. A side effect of not checking the self-
282       signature of such a certificate is that disabled or unsupported message
283       digests used for the signature are not treated as fatal errors.
284
285       When X509_V_FLAG_TRUSTED_FIRST is set, which is always the case since
286       OpenSSL 1.1.0, construction of the certificate chain in
287       X509_verify_cert(3) searches the trust store for issuer certificates
288       before searching the provided untrusted certificates.  Local issuer
289       certificates are often more likely to satisfy local security
290       requirements and lead to a locally trusted root.  This is especially
291       important when some certificates in the trust store have explicit trust
292       settings (see "TRUST SETTINGS" in openssl-x509(1)).
293
294       The X509_V_FLAG_NO_ALT_CHAINS flag could have been used before OpenSSL
295       1.1.0 to suppress checking for alternative chains.  By default, unless
296       X509_V_FLAG_TRUSTED_FIRST is set, when building a certificate chain, if
297       the first certificate chain found is not trusted, then OpenSSL will
298       attempt to replace untrusted certificates supplied by the peer with
299       certificates from the trust store to see if an alternative chain can be
300       found that is trusted.  As of OpenSSL 1.1.0, with
301       X509_V_FLAG_TRUSTED_FIRST always set, this option has no effect.
302
303       The X509_V_FLAG_PARTIAL_CHAIN flag causes non-self-signed certificates
304       in the trust store to be treated as trust anchors, in the same way as
305       self-signed root CA certificates.  This makes it possible to trust
306       self-issued certificates as well as certificates issued by an
307       intermediate CA without having to trust their ancestor root CA.  With
308       OpenSSL 1.1.0 and later and X509_V_FLAG_PARTIAL_CHAIN set, chain
309       construction stops as soon as the first certificate contained in the
310       trust store is added to the chain, whether that certificate is a self-
311       signed "root" certificate or a not self-signed "intermediate" or self-
312       issued certificate.  Thus, when an intermediate certificate is found in
313       the trust store, the verified chain passed to callbacks may be shorter
314       than it otherwise would be without the X509_V_FLAG_PARTIAL_CHAIN flag.
315
316       The X509_V_FLAG_NO_CHECK_TIME flag suppresses checking the validity
317       period of certificates and CRLs against the current time. If
318       X509_VERIFY_PARAM_set_time() is used to specify a verification time,
319       the check is not suppressed.
320

INHERITANCE FLAGS

322       These flags specify how parameters are "inherited" from one structure
323       to another.
324
325       If X509_VP_FLAG_ONCE is set then the current setting is zeroed after
326       the next call.
327
328       If X509_VP_FLAG_LOCKED is set then no values are copied.  This
329       overrides all of the following flags.
330
331       If X509_VP_FLAG_DEFAULT is set then anything set in the source is
332       copied to the destination. Effectively the values in "to" become
333       default values which will be used only if nothing new is set in "from".
334       This is the default.
335
336       If X509_VP_FLAG_OVERWRITE is set then all value are copied across
337       whether they are set or not. Flags is still Ored though.
338
339       If X509_VP_FLAG_RESET_FLAGS is set then the flags value is copied
340       instead of ORed.
341

NOTES

343       The above functions should be used to manipulate verification
344       parameters instead of functions which work in specific structures such
345       as X509_STORE_CTX_set_flags() which are likely to be deprecated in a
346       future release.
347

BUGS

349       Delta CRL checking is currently primitive. Only a single delta can be
350       used and (partly due to limitations of X509_STORE) constructed CRLs are
351       not maintained.
352
353       If CRLs checking is enable CRLs are expected to be available in the
354       corresponding X509_STORE structure. No attempt is made to download CRLs
355       from the CRL distribution points extension.
356

EXAMPLES

358       Enable CRL checking when performing certificate verification during SSL
359       connections associated with an SSL_CTX structure ctx:
360
361        X509_VERIFY_PARAM *param;
362
363        param = X509_VERIFY_PARAM_new();
364        X509_VERIFY_PARAM_set_flags(param, X509_V_FLAG_CRL_CHECK);
365        SSL_CTX_set1_param(ctx, param);
366        X509_VERIFY_PARAM_free(param);
367

SEE ALSO

369       X509_verify_cert(3), X509_check_host(3), X509_check_email(3),
370       X509_check_ip(3), openssl-x509(1)
371

HISTORY

373       The X509_V_FLAG_NO_ALT_CHAINS flag was added in OpenSSL 1.1.0.  The
374       flag X509_V_FLAG_CB_ISSUER_CHECK was deprecated in OpenSSL 1.1.0 and
375       has no effect.
376
377       The X509_VERIFY_PARAM_get_hostflags() function was added in OpenSSL
378       1.1.0i.
379
380       The X509_VERIFY_PARAM_get0_host(), X509_VERIFY_PARAM_get0_email(), and
381       X509_VERIFY_PARAM_get1_ip_asc() functions were added in OpenSSL 3.0.
382
384       Copyright 2009-2022 The OpenSSL Project Authors. All Rights Reserved.
385
386       Licensed under the Apache License 2.0 (the "License").  You may not use
387       this file except in compliance with the License.  You can obtain a copy
388       in the file LICENSE in the source distribution or at
389       <https://www.openssl.org/source/license.html>.
390
391
392
3933.0.5                             2022-11-01X509_VERIFY_PARAM_SET_FLAGS(3ossl)
Impressum