1 /* crypto/x509/x509_vfy.h */ 2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) 3 * All rights reserved. 4 * 5 * This package is an SSL implementation written 6 * by Eric Young (eay@cryptsoft.com). 7 * The implementation was written so as to conform with Netscapes SSL. 8 * 9 * This library is free for commercial and non-commercial use as long as 10 * the following conditions are aheared to. The following conditions 11 * apply to all code found in this distribution, be it the RC4, RSA, 12 * lhash, DES, etc., code; not just the SSL code. The SSL documentation 13 * included with this distribution is covered by the same copyright terms 14 * except that the holder is Tim Hudson (tjh@cryptsoft.com). 15 * 16 * Copyright remains Eric Young's, and as such any Copyright notices in 17 * the code are not to be removed. 18 * If this package is used in a product, Eric Young should be given attribution 19 * as the author of the parts of the library used. 20 * This can be in the form of a textual message at program startup or 21 * in documentation (online or textual) provided with the package. 22 * 23 * Redistribution and use in source and binary forms, with or without 24 * modification, are permitted provided that the following conditions 25 * are met: 26 * 1. Redistributions of source code must retain the copyright 27 * notice, this list of conditions and the following disclaimer. 28 * 2. Redistributions in binary form must reproduce the above copyright 29 * notice, this list of conditions and the following disclaimer in the 30 * documentation and/or other materials provided with the distribution. 31 * 3. All advertising materials mentioning features or use of this software 32 * must display the following acknowledgement: 33 * "This product includes cryptographic software written by 34 * Eric Young (eay@cryptsoft.com)" 35 * The word 'cryptographic' can be left out if the rouines from the library 36 * being used are not cryptographic related :-). 37 * 4. If you include any Windows specific code (or a derivative thereof) from 38 * the apps directory (application code) you must include an acknowledgement: 39 * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" 40 * 41 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND 42 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 43 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 44 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 45 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 46 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 47 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 48 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 49 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 50 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 51 * SUCH DAMAGE. 52 * 53 * The licence and distribution terms for any publically available version or 54 * derivative of this code cannot be changed. i.e. this code cannot simply be 55 * copied and put under another distribution licence 56 * [including the GNU Public Licence.] 57 */ 58 59 // #ifndef HEADER_X509_H 60 // public import deimos.openssl.x509; 61 // /* openssl/x509.h ends up #include-ing this file at about the only 62 // * appropriate moment. */ 63 // #endif 64 65 module deimos.openssl.x509_vfy; 66 67 import deimos.openssl._d_util; 68 69 import core.stdc.time; 70 import deimos.openssl.asn1; // Needed for ASN1_OBJECT. 71 import deimos.openssl.x509v3; // Needed for POLICYQUALINFO. 72 73 public import deimos.openssl.opensslconf; 74 version(OPENSSL_NO_LHASH) {} else { 75 public import deimos.openssl.lhash; 76 } 77 public import deimos.openssl.bio; 78 public import deimos.openssl.crypto; 79 public import deimos.openssl.symhacks; 80 81 extern (C): 82 nothrow: 83 84 version (none) { 85 /* Outer object */ 86 struct x509_hash_dir_st { 87 int num_dirs; 88 char** dirs; 89 int* dirs_type; 90 int num_dirs_alloced; 91 } 92 alias x509_hash_dir_st X509_HASH_DIR_CTX; 93 } 94 95 struct x509_file_st { 96 int num_paths; /* number of paths to files or directories */ 97 int num_alloced; 98 char** paths; /* the list of paths or directories */ 99 int* path_type; 100 } 101 alias x509_file_st X509_CERT_FILE_CTX; 102 103 /*******************************/ 104 /* 105 SSL_CTX -> X509_STORE 106 -> X509_LOOKUP 107 ->X509_LOOKUP_METHOD 108 -> X509_LOOKUP 109 ->X509_LOOKUP_METHOD 110 111 SSL -> X509_STORE_CTX 112 ->X509_STORE 113 114 The X509_STORE holds the tables etc for verification stuff. 115 A X509_STORE_CTX is used while validating a single certificate. 116 The X509_STORE has X509_LOOKUPs for looking up certs. 117 The X509_STORE then calls a function to actually verify the 118 certificate chain. 119 */ 120 121 enum X509_LU_RETRY = -1; 122 enum X509_LU_FAIL = 0; 123 enum X509_LU_X509 = 1; 124 enum X509_LU_CRL = 2; 125 enum X509_LU_PKEY = 3; 126 127 struct x509_object_st 128 { 129 /* one of the above types */ 130 int type; 131 union data_ { 132 char* ptr; 133 X509* x509; 134 X509_CRL* crl; 135 EVP_PKEY* pkey; 136 } 137 data_ data; 138 } 139 alias x509_object_st X509_OBJECT; 140 141 alias x509_lookup_st X509_LOOKUP; 142 143 /+mixin DECLARE_STACK_OF!(X509_LOOKUP);+/ 144 /+mixin DECLARE_STACK_OF!(X509_OBJECT);+/ 145 146 /* This is a static that defines the function interface */ 147 struct x509_lookup_method_st { 148 const(char)* name; 149 ExternC!(int function(X509_LOOKUP* ctx)) new_item; 150 ExternC!(void function(X509_LOOKUP* ctx)) free; 151 ExternC!(int function(X509_LOOKUP* ctx)) init_; 152 ExternC!(int function(X509_LOOKUP* ctx)) shutdown; 153 ExternC!(int function(X509_LOOKUP* ctx,int cmd,const(char)* argc,c_long argl, 154 char** ret)) ctrl; 155 ExternC!(int function(X509_LOOKUP* ctx,int type,X509_NAME* name, 156 X509_OBJECT* ret)) get_by_subject; 157 ExternC!(int function(X509_LOOKUP* ctx,int type,X509_NAME* name, 158 ASN1_INTEGER* serial,X509_OBJECT* ret)) get_by_issuer_serial; 159 ExternC!(int function(X509_LOOKUP* ctx,int type, 160 ubyte* bytes,int len, 161 X509_OBJECT* ret)) get_by_fingerprint; 162 ExternC!(int function(X509_LOOKUP* ctx,int type,char* str,int len, 163 X509_OBJECT* ret)) get_by_alias; 164 } 165 alias x509_lookup_method_st X509_LOOKUP_METHOD; 166 167 /* This structure hold all parameters associated with a verify operation 168 * by including an X509_VERIFY_PARAM structure in related structures the 169 * parameters used can be customized 170 */ 171 172 struct X509_VERIFY_PARAM_st { 173 char* name; 174 time_t check_time; /* Time to use */ 175 c_ulong inh_flags; /* Inheritance flags */ 176 c_ulong flags; /* Various verify flags */ 177 int purpose; /* purpose to check untrusted certificates */ 178 int trust; /* trust setting to check */ 179 int depth; /* Verify depth */ 180 STACK_OF!(ASN1_OBJECT) *policies; /* Permissible policies */ 181 } 182 alias X509_VERIFY_PARAM_st X509_VERIFY_PARAM; 183 184 /+mixin DECLARE_STACK_OF!(X509_VERIFY_PARAM);+/ 185 186 /* This is used to hold everything. It is used for all certificate 187 * validation. Once we have a certificate chain, the 'verify' 188 * function is then called to actually check the cert chain. */ 189 struct x509_store_st 190 { 191 /* The following is a cache of trusted certs */ 192 int cache; /* if true, stash any hits */ 193 STACK_OF!(X509_OBJECT) *objs; /* Cache of all objects */ 194 195 /* These are external lookup methods */ 196 STACK_OF!(X509_LOOKUP) *get_cert_methods; 197 198 X509_VERIFY_PARAM* param; 199 200 /* Callbacks for various operations */ 201 ExternC!(int function(X509_STORE_CTX* ctx)) verify; /* called to verify a certificate */ 202 ExternC!(int function(int ok,X509_STORE_CTX* ctx)) verify_cb; /* error callback */ 203 ExternC!(int function(X509** issuer, X509_STORE_CTX* ctx, X509* x)) get_issuer; /* get issuers cert from ctx */ 204 ExternC!(int function(X509_STORE_CTX* ctx, X509* x, X509* issuer)) check_issued; /* check issued */ 205 ExternC!(int function(X509_STORE_CTX* ctx)) check_revocation; /* Check revocation status of chain */ 206 ExternC!(int function(X509_STORE_CTX* ctx, X509_CRL** crl, X509* x)) get_crl; /* retrieve CRL */ 207 ExternC!(int function(X509_STORE_CTX* ctx, X509_CRL* crl)) check_crl; /* Check CRL validity */ 208 ExternC!(int function(X509_STORE_CTX* ctx, X509_CRL* crl, X509* x)) cert_crl; /* Check certificate against CRL */ 209 ExternC!(STACK_OF!(X509)* function(X509_STORE_CTX* ctx, X509_NAME* nm)) lookup_certs; 210 ExternC!(STACK_OF!(X509_CRL)* function(X509_STORE_CTX* ctx, X509_NAME* nm)) lookup_crls; 211 ExternC!(int function(X509_STORE_CTX* ctx)) cleanup; 212 213 CRYPTO_EX_DATA ex_data; 214 int references; 215 } /* X509_STORE */; 216 217 int X509_STORE_set_depth(X509_STORE* store, int depth); 218 219 auto X509_STORE_set_verify_cb_func()(X509_STORE_CTX* ctx, typeof(X509_STORE_CTX.init.verify_cb) func) { ctx.verify_cb = func; } 220 auto X509_STORE_set_verify_func()(X509_STORE_CTX* ctx, typeof(X509_STORE_CTX.init.verify) func) { ctx.verify = func; } 221 222 /* This is the functions plus an instance of the local variables. */ 223 struct x509_lookup_st 224 { 225 int init_; /* have we been started */ 226 int skip; /* don't use us. */ 227 X509_LOOKUP_METHOD* method; /* the functions */ 228 char* method_data; /* method data */ 229 230 X509_STORE* store_ctx; /* who owns us */ 231 } /* X509_LOOKUP */; 232 233 /* This is a used when verifying cert chains. Since the 234 * gathering of the cert chain can take some time (and have to be 235 * 'retried', this needs to be kept and passed around. */ 236 struct x509_store_ctx_st 237 { 238 X509_STORE* ctx; 239 int current_method; /* used when looking up certs */ 240 241 /* The following are set by the caller */ 242 X509* cert; /* The cert to check */ 243 STACK_OF!(X509) *untrusted; /* chain of X509s - untrusted - passed in */ 244 STACK_OF!(X509_CRL) *crls; /* set of CRLs passed in */ 245 246 X509_VERIFY_PARAM* param; 247 void* other_ctx; /* Other info for use with get_issuer() */ 248 249 /* Callbacks for various operations */ 250 ExternC!(int function(X509_STORE_CTX* ctx)) verify; /* called to verify a certificate */ 251 ExternC!(int function(int ok,X509_STORE_CTX* ctx)) verify_cb; /* error callback */ 252 ExternC!(int function(X509** issuer, X509_STORE_CTX* ctx, X509* x)) get_issuer; /* get issuers cert from ctx */ 253 ExternC!(int function(X509_STORE_CTX* ctx, X509* x, X509* issuer)) check_issued; /* check issued */ 254 ExternC!(int function(X509_STORE_CTX* ctx)) check_revocation; /* Check revocation status of chain */ 255 ExternC!(int function(X509_STORE_CTX* ctx, X509_CRL** crl, X509* x)) get_crl; /* retrieve CRL */ 256 ExternC!(int function(X509_STORE_CTX* ctx, X509_CRL* crl)) check_crl; /* Check CRL validity */ 257 ExternC!(int function(X509_STORE_CTX* ctx, X509_CRL* crl, X509* x)) cert_crl; /* Check certificate against CRL */ 258 ExternC!(int function(X509_STORE_CTX* ctx)) check_policy; 259 ExternC!(STACK_OF!(X509)* function(X509_STORE_CTX* ctx, X509_NAME* nm)) lookup_certs; 260 ExternC!(STACK_OF!(X509_CRL)* function(X509_STORE_CTX* ctx, X509_NAME* nm)) lookup_crls; 261 ExternC!(int function(X509_STORE_CTX* ctx)) cleanup; 262 263 /* The following is built up */ 264 int valid; /* if 0, rebuild chain */ 265 int last_untrusted; /* index of last untrusted cert */ 266 STACK_OF!(X509) *chain; /* chain of X509s - built up and trusted */ 267 X509_POLICY_TREE* tree; /* Valid policy tree */ 268 269 int explicit_policy; /* Require explicit policy value */ 270 271 /* When something goes wrong, this is why */ 272 int error_depth; 273 int error; 274 X509* current_cert; 275 X509* current_issuer; /* cert currently being tested as valid issuer */ 276 X509_CRL* current_crl; /* current CRL */ 277 278 int current_crl_score; /* score of current CRL */ 279 uint current_reasons; /* Reason mask */ 280 281 X509_STORE_CTX* parent; /* For CRL path validation: parent context */ 282 283 CRYPTO_EX_DATA ex_data; 284 } /* X509_STORE_CTX */; 285 286 void X509_STORE_CTX_set_depth(X509_STORE_CTX* ctx, int depth); 287 288 auto X509_STORE_CTX_set_app_data()(X509_STORE_CTX* ctx, void* data) { 289 return X509_STORE_CTX_set_ex_data(ctx,0,data); 290 } 291 292 auto X509_STORE_CTX_get_app_data()(X509_STORE_CTX* ctx) { 293 return X509_STORE_CTX_get_ex_data(ctx,0); 294 } 295 296 enum X509_L_FILE_LOAD = 1; 297 enum X509_L_ADD_DIR = 2; 298 299 auto X509_LOOKUP_load_file()(X509_LOOKUP* x,const(char)* name, c_long type) { 300 return X509_LOOKUP_ctrl((x),X509_L_FILE_LOAD,(name),(type),null); 301 } 302 303 304 auto X509_LOOKUP_add_dir()(X509_LOOKUP* x,const(char)* name, c_long type) { 305 return X509_LOOKUP_ctrl((x),X509_L_ADD_DIR,(name),(type),null); 306 } 307 308 enum X509_V_OK = 0; 309 /* illegal error (for uninitialized values, to avoid X509_V_OK): 1 */ 310 311 enum X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT = 2; 312 enum X509_V_ERR_UNABLE_TO_GET_CRL = 3; 313 enum X509_V_ERR_UNABLE_TO_DECRYPT_CERT_SIGNATURE = 4; 314 enum X509_V_ERR_UNABLE_TO_DECRYPT_CRL_SIGNATURE = 5; 315 enum X509_V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY = 6; 316 enum X509_V_ERR_CERT_SIGNATURE_FAILURE = 7; 317 enum X509_V_ERR_CRL_SIGNATURE_FAILURE = 8; 318 enum X509_V_ERR_CERT_NOT_YET_VALID = 9; 319 enum X509_V_ERR_CERT_HAS_EXPIRED = 10; 320 enum X509_V_ERR_CRL_NOT_YET_VALID = 11; 321 enum X509_V_ERR_CRL_HAS_EXPIRED = 12; 322 enum X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD = 13; 323 enum X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD = 14; 324 enum X509_V_ERR_ERROR_IN_CRL_LAST_UPDATE_FIELD = 15; 325 enum X509_V_ERR_ERROR_IN_CRL_NEXT_UPDATE_FIELD = 16; 326 enum X509_V_ERR_OUT_OF_MEM = 17; 327 enum X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT = 18; 328 enum X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN = 19; 329 enum X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY = 20; 330 enum X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE = 21; 331 enum X509_V_ERR_CERT_CHAIN_TOO_LONG = 22; 332 enum X509_V_ERR_CERT_REVOKED = 23; 333 enum X509_V_ERR_INVALID_CA = 24; 334 enum X509_V_ERR_PATH_LENGTH_EXCEEDED = 25; 335 enum X509_V_ERR_INVALID_PURPOSE = 26; 336 enum X509_V_ERR_CERT_UNTRUSTED = 27; 337 enum X509_V_ERR_CERT_REJECTED = 28; 338 /* These are 'informational' when looking for issuer cert */ 339 enum X509_V_ERR_SUBJECT_ISSUER_MISMATCH = 29; 340 enum X509_V_ERR_AKID_SKID_MISMATCH = 30; 341 enum X509_V_ERR_AKID_ISSUER_SERIAL_MISMATCH = 31; 342 enum X509_V_ERR_KEYUSAGE_NO_CERTSIGN = 32; 343 344 enum X509_V_ERR_UNABLE_TO_GET_CRL_ISSUER = 33; 345 enum X509_V_ERR_UNHANDLED_CRITICAL_EXTENSION = 34; 346 enum X509_V_ERR_KEYUSAGE_NO_CRL_SIGN = 35; 347 enum X509_V_ERR_UNHANDLED_CRITICAL_CRL_EXTENSION = 36; 348 enum X509_V_ERR_INVALID_NON_CA = 37; 349 enum X509_V_ERR_PROXY_PATH_LENGTH_EXCEEDED = 38; 350 enum X509_V_ERR_KEYUSAGE_NO_DIGITAL_SIGNATURE = 39; 351 enum X509_V_ERR_PROXY_CERTIFICATES_NOT_ALLOWED = 40; 352 353 enum X509_V_ERR_INVALID_EXTENSION = 41; 354 enum X509_V_ERR_INVALID_POLICY_EXTENSION = 42; 355 enum X509_V_ERR_NO_EXPLICIT_POLICY = 43; 356 enum X509_V_ERR_DIFFERENT_CRL_SCOPE = 44; 357 enum X509_V_ERR_UNSUPPORTED_EXTENSION_FEATURE = 45; 358 359 enum X509_V_ERR_UNNESTED_RESOURCE = 46; 360 361 enum X509_V_ERR_PERMITTED_VIOLATION = 47; 362 enum X509_V_ERR_EXCLUDED_VIOLATION = 48; 363 enum X509_V_ERR_SUBTREE_MINMAX = 49; 364 enum X509_V_ERR_UNSUPPORTED_CONSTRAINT_TYPE = 51; 365 enum X509_V_ERR_UNSUPPORTED_CONSTRAINT_SYNTAX = 52; 366 enum X509_V_ERR_UNSUPPORTED_NAME_SYNTAX = 53; 367 enum X509_V_ERR_CRL_PATH_VALIDATION_ERROR = 54; 368 369 /* The application is not happy */ 370 enum X509_V_ERR_APPLICATION_VERIFICATION = 50; 371 372 /* Certificate verify flags */ 373 374 /* Send issuer+subject checks to verify_cb */ 375 enum X509_V_FLAG_CB_ISSUER_CHECK = 0x1; 376 /* Use check time instead of current time */ 377 enum X509_V_FLAG_USE_CHECK_TIME = 0x2; 378 /* Lookup CRLs */ 379 enum X509_V_FLAG_CRL_CHECK = 0x4; 380 /* Lookup CRLs for whole chain */ 381 enum X509_V_FLAG_CRL_CHECK_ALL = 0x8; 382 /* Ignore unhandled critical extensions */ 383 enum X509_V_FLAG_IGNORE_CRITICAL = 0x10; 384 /* Disable workarounds for broken certificates */ 385 enum X509_V_FLAG_X509_STRICT = 0x20; 386 /* Enable proxy certificate validation */ 387 enum X509_V_FLAG_ALLOW_PROXY_CERTS = 0x40; 388 /* Enable policy checking */ 389 enum X509_V_FLAG_POLICY_CHECK = 0x80; 390 /* Policy variable require-explicit-policy */ 391 enum X509_V_FLAG_EXPLICIT_POLICY = 0x100; 392 /* Policy variable inhibit-any-policy */ 393 enum X509_V_FLAG_INHIBIT_ANY = 0x200; 394 /* Policy variable inhibit-policy-mapping */ 395 enum X509_V_FLAG_INHIBIT_MAP = 0x400; 396 /* Notify callback that policy is OK */ 397 enum X509_V_FLAG_NOTIFY_POLICY = 0x800; 398 /* Extended CRL features such as indirect CRLs, alternate CRL signing keys */ 399 enum X509_V_FLAG_EXTENDED_CRL_SUPPORT = 0x1000; 400 /* Delta CRL support */ 401 enum X509_V_FLAG_USE_DELTAS = 0x2000; 402 /* Check selfsigned CA signature */ 403 enum X509_V_FLAG_CHECK_SS_SIGNATURE = 0x4000; 404 405 406 enum X509_VP_FLAG_DEFAULT = 0x1; 407 enum X509_VP_FLAG_OVERWRITE = 0x2; 408 enum X509_VP_FLAG_RESET_FLAGS = 0x4; 409 enum X509_VP_FLAG_LOCKED = 0x8; 410 enum X509_VP_FLAG_ONCE = 0x10; 411 412 /* Internal use: mask of policy related options */ 413 enum X509_V_FLAG_POLICY_MASK = (X509_V_FLAG_POLICY_CHECK 414 | X509_V_FLAG_EXPLICIT_POLICY 415 | X509_V_FLAG_INHIBIT_ANY 416 | X509_V_FLAG_INHIBIT_MAP); 417 418 int X509_OBJECT_idx_by_subject(STACK_OF!(X509_OBJECT) *h, int type, 419 X509_NAME* name); 420 X509_OBJECT* X509_OBJECT_retrieve_by_subject(STACK_OF!(X509_OBJECT) *h,int type,X509_NAME* name); 421 X509_OBJECT* X509_OBJECT_retrieve_match(STACK_OF!(X509_OBJECT) *h, X509_OBJECT* x); 422 void X509_OBJECT_up_ref_count(X509_OBJECT* a); 423 void X509_OBJECT_free_contents(X509_OBJECT* a); 424 X509_STORE* X509_STORE_new(); 425 void X509_STORE_free(X509_STORE* v); 426 427 STACK_OF!(X509)* X509_STORE_get1_certs(X509_STORE_CTX* st, X509_NAME* nm); 428 STACK_OF!(X509_CRL)* X509_STORE_get1_crls(X509_STORE_CTX* st, X509_NAME* nm); 429 int X509_STORE_set_flags(X509_STORE* ctx, c_ulong flags); 430 int X509_STORE_set_purpose(X509_STORE* ctx, int purpose); 431 int X509_STORE_set_trust(X509_STORE* ctx, int trust); 432 int X509_STORE_set1_param(X509_STORE* ctx, X509_VERIFY_PARAM* pm); 433 434 void X509_STORE_set_verify_cb(X509_STORE* ctx, 435 ExternC!(int function(int, X509_STORE_CTX*)) verify_cb); 436 437 X509_STORE_CTX* X509_STORE_CTX_new(); 438 439 int X509_STORE_CTX_get1_issuer(X509** issuer, X509_STORE_CTX* ctx, X509* x); 440 441 void X509_STORE_CTX_free(X509_STORE_CTX* ctx); 442 int X509_STORE_CTX_init(X509_STORE_CTX* ctx, X509_STORE* store, 443 X509* x509, STACK_OF!(X509) *chain); 444 void X509_STORE_CTX_trusted_stack(X509_STORE_CTX* ctx, STACK_OF!(X509) *sk); 445 void X509_STORE_CTX_cleanup(X509_STORE_CTX* ctx); 446 447 X509_LOOKUP* X509_STORE_add_lookup(X509_STORE* v, X509_LOOKUP_METHOD* m); 448 449 X509_LOOKUP_METHOD* X509_LOOKUP_hash_dir(); 450 X509_LOOKUP_METHOD* X509_LOOKUP_file(); 451 452 int X509_STORE_add_cert(X509_STORE* ctx, X509* x); 453 int X509_STORE_add_crl(X509_STORE* ctx, X509_CRL* x); 454 455 int X509_STORE_get_by_subject(X509_STORE_CTX* vs,int type,X509_NAME* name, 456 X509_OBJECT* ret); 457 458 int X509_LOOKUP_ctrl(X509_LOOKUP* ctx, int cmd, const(char)* argc, 459 c_long argl, char** ret); 460 461 version(OPENSSL_NO_STDIO) {} else { 462 int X509_load_cert_file(X509_LOOKUP* ctx, const(char)* file, int type); 463 int X509_load_crl_file(X509_LOOKUP* ctx, const(char)* file, int type); 464 int X509_load_cert_crl_file(X509_LOOKUP* ctx, const(char)* file, int type); 465 } 466 467 468 X509_LOOKUP* X509_LOOKUP_new(X509_LOOKUP_METHOD* method); 469 void X509_LOOKUP_free(X509_LOOKUP* ctx); 470 int X509_LOOKUP_init(X509_LOOKUP* ctx); 471 int X509_LOOKUP_by_subject(X509_LOOKUP* ctx, int type, X509_NAME* name, 472 X509_OBJECT* ret); 473 int X509_LOOKUP_by_issuer_serial(X509_LOOKUP* ctx, int type, X509_NAME* name, 474 ASN1_INTEGER* serial, X509_OBJECT* ret); 475 int X509_LOOKUP_by_fingerprint(X509_LOOKUP* ctx, int type, 476 ubyte* bytes, int len, X509_OBJECT* ret); 477 int X509_LOOKUP_by_alias(X509_LOOKUP* ctx, int type, char* str, 478 int len, X509_OBJECT* ret); 479 int X509_LOOKUP_shutdown(X509_LOOKUP* ctx); 480 481 version(OPENSSL_NO_STDIO) {} else { 482 int X509_STORE_load_locations (X509_STORE* ctx, 483 const(char)* file, const(char)* dir); 484 int X509_STORE_set_default_paths(X509_STORE* ctx); 485 } 486 487 int X509_STORE_CTX_get_ex_new_index(c_long argl, void* argp, CRYPTO_EX_new* new_func, 488 CRYPTO_EX_dup* dup_func, CRYPTO_EX_free* free_func); 489 int X509_STORE_CTX_set_ex_data(X509_STORE_CTX* ctx,int idx,void* data); 490 void* X509_STORE_CTX_get_ex_data(X509_STORE_CTX* ctx,int idx); 491 int X509_STORE_CTX_get_error(X509_STORE_CTX* ctx); 492 void X509_STORE_CTX_set_error(X509_STORE_CTX* ctx,int s); 493 int X509_STORE_CTX_get_error_depth(X509_STORE_CTX* ctx); 494 X509* X509_STORE_CTX_get_current_cert(X509_STORE_CTX* ctx); 495 X509* X509_STORE_CTX_get0_current_issuer(X509_STORE_CTX* ctx); 496 X509_CRL* X509_STORE_CTX_get0_current_crl(X509_STORE_CTX* ctx); 497 X509_STORE_CTX* X509_STORE_CTX_get0_parent_ctx(X509_STORE_CTX* ctx); 498 STACK_OF!(X509) *X509_STORE_CTX_get_chain(X509_STORE_CTX* ctx); 499 STACK_OF!(X509) *X509_STORE_CTX_get1_chain(X509_STORE_CTX* ctx); 500 void X509_STORE_CTX_set_cert(X509_STORE_CTX* c,X509* x); 501 void X509_STORE_CTX_set_chain(X509_STORE_CTX* c,STACK_OF!(X509) *sk); 502 void X509_STORE_CTX_set0_crls(X509_STORE_CTX* c,STACK_OF!(X509_CRL) *sk); 503 int X509_STORE_CTX_set_purpose(X509_STORE_CTX* ctx, int purpose); 504 int X509_STORE_CTX_set_trust(X509_STORE_CTX* ctx, int trust); 505 int X509_STORE_CTX_purpose_inherit(X509_STORE_CTX* ctx, int def_purpose, 506 int purpose, int trust); 507 void X509_STORE_CTX_set_flags(X509_STORE_CTX* ctx, c_ulong flags); 508 void X509_STORE_CTX_set_time(X509_STORE_CTX* ctx, c_ulong flags, 509 time_t t); 510 void X509_STORE_CTX_set_verify_cb(X509_STORE_CTX* ctx, 511 ExternC!(int function(int, X509_STORE_CTX*)) verify_cb); 512 513 X509_POLICY_TREE* X509_STORE_CTX_get0_policy_tree(X509_STORE_CTX* ctx); 514 int X509_STORE_CTX_get_explicit_policy(X509_STORE_CTX* ctx); 515 516 X509_VERIFY_PARAM* X509_STORE_CTX_get0_param(X509_STORE_CTX* ctx); 517 void X509_STORE_CTX_set0_param(X509_STORE_CTX* ctx, X509_VERIFY_PARAM* param); 518 int X509_STORE_CTX_set_default(X509_STORE_CTX* ctx, const(char)* name); 519 520 /* X509_VERIFY_PARAM functions */ 521 522 X509_VERIFY_PARAM* X509_VERIFY_PARAM_new(); 523 void X509_VERIFY_PARAM_free(X509_VERIFY_PARAM* param); 524 int X509_VERIFY_PARAM_inherit(X509_VERIFY_PARAM* to, 525 const(X509_VERIFY_PARAM)* from); 526 int X509_VERIFY_PARAM_set1(X509_VERIFY_PARAM* to, 527 const(X509_VERIFY_PARAM)* from); 528 int X509_VERIFY_PARAM_set1_name(X509_VERIFY_PARAM* param, const(char)* name); 529 int X509_VERIFY_PARAM_set_flags(X509_VERIFY_PARAM* param, c_ulong flags); 530 int X509_VERIFY_PARAM_clear_flags(X509_VERIFY_PARAM* param, 531 c_ulong flags); 532 c_ulong X509_VERIFY_PARAM_get_flags(X509_VERIFY_PARAM* param); 533 int X509_VERIFY_PARAM_set_purpose(X509_VERIFY_PARAM* param, int purpose); 534 int X509_VERIFY_PARAM_set_trust(X509_VERIFY_PARAM* param, int trust); 535 void X509_VERIFY_PARAM_set_depth(X509_VERIFY_PARAM* param, int depth); 536 void X509_VERIFY_PARAM_set_time(X509_VERIFY_PARAM* param, time_t t); 537 int X509_VERIFY_PARAM_add0_policy(X509_VERIFY_PARAM* param, 538 ASN1_OBJECT* policy); 539 int X509_VERIFY_PARAM_set1_policies(X509_VERIFY_PARAM* param, 540 STACK_OF!(ASN1_OBJECT) *policies); 541 int X509_VERIFY_PARAM_get_depth(const(X509_VERIFY_PARAM)* param); 542 543 int X509_VERIFY_PARAM_add0_table(X509_VERIFY_PARAM* param); 544 const(X509_VERIFY_PARAM)* X509_VERIFY_PARAM_lookup(const(char)* name); 545 void X509_VERIFY_PARAM_table_cleanup(); 546 547 int X509_policy_check(X509_POLICY_TREE** ptree, int* pexplicit_policy, 548 STACK_OF!(X509) *certs, 549 STACK_OF!(ASN1_OBJECT) *policy_oids, 550 uint flags); 551 552 void X509_policy_tree_free(X509_POLICY_TREE* tree); 553 554 int X509_policy_tree_level_count(const(X509_POLICY_TREE)* tree); 555 X509_POLICY_LEVEL* 556 X509_policy_tree_get0_level(const(X509_POLICY_TREE)* tree, int i); 557 558 STACK_OF!(X509_POLICY_NODE) * 559 X509_policy_tree_get0_policies(const(X509_POLICY_TREE)* tree); 560 561 STACK_OF!(X509_POLICY_NODE) * 562 X509_policy_tree_get0_user_policies(const(X509_POLICY_TREE)* tree); 563 564 int X509_policy_level_node_count(X509_POLICY_LEVEL* level); 565 566 X509_POLICY_NODE* X509_policy_level_get0_node(X509_POLICY_LEVEL* level, int i); 567 568 const(ASN1_OBJECT)* X509_policy_node_get0_policy(const(X509_POLICY_NODE)* node); 569 570 STACK_OF!(POLICYQUALINFO) * 571 X509_policy_node_get0_qualifiers(const(X509_POLICY_NODE)* node); 572 const(X509_POLICY_NODE)* 573 X509_policy_node_get0_parent(const(X509_POLICY_NODE)* node);