1 /* 2 * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved. 3 * 4 * Licensed under the OpenSSL license (the "License"). You may not use 5 * this file except in compliance with the License. You can obtain a copy 6 * in the file LICENSE in the source distribution or at 7 * https://www.openssl.org/source/license.html 8 */ 9 10 /* ==================================================================== 11 * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED. 12 * ECDH support in OpenSSL originally developed by 13 * SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project. 14 */ 15 16 module deimos.openssl.x509; 17 18 import core.stdc.time; 19 20 import deimos.openssl._d_util; 21 import deimos.openssl.x509v3 : stack_st_ASN1_OBJECT; 22 23 public import deimos.openssl.e_os2; 24 public import deimos.openssl.types; 25 public import deimos.openssl.symhacks; 26 public import deimos.openssl.buffer; 27 public import deimos.openssl.evp; 28 public import deimos.openssl.bio; 29 public import deimos.openssl.stack; 30 public import deimos.openssl.asn1; 31 public import deimos.openssl.safestack; 32 public import deimos.openssl.ec; 33 34 /* if OPENSSL_API_COMPAT < 0x10100000L */ 35 public import deimos.openssl.rsa; 36 public import deimos.openssl.dsa; 37 public import deimos.openssl.dh; 38 /* endif */ 39 40 public import deimos.openssl.sha; 41 42 extern (C): 43 nothrow: 44 45 enum X509_FILETYPE_PEM = 1; 46 enum X509_FILETYPE_ASN1 = 2; 47 enum X509_FILETYPE_DEFAULT = 3; 48 49 enum X509v3_KU_DIGITAL_SIGNATURE = 0x0080; 50 enum X509v3_KU_NON_REPUDIATION = 0x0040; 51 enum X509v3_KU_KEY_ENCIPHERMENT = 0x0020; 52 enum X509v3_KU_DATA_ENCIPHERMENT = 0x0010; 53 enum X509v3_KU_KEY_AGREEMENT = 0x0008; 54 enum X509v3_KU_KEY_CERT_SIGN = 0x0004; 55 enum X509v3_KU_CRL_SIGN = 0x0002; 56 enum X509v3_KU_ENCIPHER_ONLY = 0x0001; 57 enum X509v3_KU_DECIPHER_ONLY = 0x8000; 58 enum X509v3_KU_UNDEF = 0xffff; 59 60 struct X509_algor_st 61 { 62 ASN1_OBJECT* algorithm; 63 ASN1_TYPE* parameter; 64 } /* X509_ALGOR */ 65 66 /* This is used for a table of trust checking functions */ 67 68 /* standard trust ids */ 69 70 /* Only valid in purpose settings */ 71 72 /* Keep these up to date! */ 73 74 /* trust_flags values */ 75 76 /* No compat trust if self-signed, preempts "DO_SS" */ 77 78 /* Compat trust if no explicit accepted trust EKUs */ 79 80 /* Accept "anyEKU" as a wildcard trust OID */ 81 82 /* check_trust return codes */ 83 84 /* Flags for X509_print_ex() */ 85 struct stack_st_X509_ALGOR; 86 alias X509_ALGORS = stack_st_X509_ALGOR; 87 88 struct X509_val_st 89 { 90 ASN1_TIME* notBefore; 91 ASN1_TIME* notAfter; 92 } 93 94 alias X509_VAL = X509_val_st; 95 struct X509_sig_st; 96 alias X509_SIG = X509_sig_st; 97 struct X509_name_entry_st; 98 alias X509_NAME_ENTRY = X509_name_entry_st; 99 struct stack_st_X509_NAME_ENTRY; 100 alias sk_X509_NAME_ENTRY_compfunc = int function(const(X509_NAME_ENTRY*)* a, const(X509_NAME_ENTRY*)* b); 101 alias sk_X509_NAME_ENTRY_freefunc = void function(X509_NAME_ENTRY* a); 102 alias sk_X509_NAME_ENTRY_copyfunc = X509_name_entry_st* function(const(X509_NAME_ENTRY)* a); 103 int sk_X509_NAME_ENTRY_num(const(stack_st_X509_NAME_ENTRY)* sk); 104 X509_NAME_ENTRY* sk_X509_NAME_ENTRY_value(const(stack_st_X509_NAME_ENTRY)* sk, int idx); 105 stack_st_X509_NAME_ENTRY* sk_X509_NAME_ENTRY_new(sk_X509_NAME_ENTRY_compfunc compare); 106 stack_st_X509_NAME_ENTRY* sk_X509_NAME_ENTRY_new_null(); 107 void sk_X509_NAME_ENTRY_free(stack_st_X509_NAME_ENTRY* sk); 108 void sk_X509_NAME_ENTRY_zero(stack_st_X509_NAME_ENTRY* sk); 109 X509_NAME_ENTRY* sk_X509_NAME_ENTRY_delete(stack_st_X509_NAME_ENTRY* sk, int i); 110 X509_NAME_ENTRY* sk_X509_NAME_ENTRY_delete_ptr(stack_st_X509_NAME_ENTRY* sk, X509_NAME_ENTRY* ptr); 111 int sk_X509_NAME_ENTRY_push(stack_st_X509_NAME_ENTRY* sk, X509_NAME_ENTRY* ptr); 112 int sk_X509_NAME_ENTRY_unshift(stack_st_X509_NAME_ENTRY* sk, X509_NAME_ENTRY* ptr); 113 X509_NAME_ENTRY* sk_X509_NAME_ENTRY_pop(stack_st_X509_NAME_ENTRY* sk); 114 X509_NAME_ENTRY* sk_X509_NAME_ENTRY_shift(stack_st_X509_NAME_ENTRY* sk); 115 void sk_X509_NAME_ENTRY_pop_free(stack_st_X509_NAME_ENTRY* sk, sk_X509_NAME_ENTRY_freefunc freefunc); 116 int sk_X509_NAME_ENTRY_insert(stack_st_X509_NAME_ENTRY* sk, X509_NAME_ENTRY* ptr, int idx); 117 X509_NAME_ENTRY* sk_X509_NAME_ENTRY_set(stack_st_X509_NAME_ENTRY* sk, int idx, X509_NAME_ENTRY* ptr); 118 int sk_X509_NAME_ENTRY_find(stack_st_X509_NAME_ENTRY* sk, X509_NAME_ENTRY* ptr); 119 int sk_X509_NAME_ENTRY_find_ex(stack_st_X509_NAME_ENTRY* sk, X509_NAME_ENTRY* ptr); 120 void sk_X509_NAME_ENTRY_sort(stack_st_X509_NAME_ENTRY* sk); 121 int sk_X509_NAME_ENTRY_is_sorted(const(stack_st_X509_NAME_ENTRY)* sk); 122 stack_st_X509_NAME_ENTRY* sk_X509_NAME_ENTRY_dup(const(stack_st_X509_NAME_ENTRY)* sk); 123 stack_st_X509_NAME_ENTRY* sk_X509_NAME_ENTRY_deep_copy(const(stack_st_X509_NAME_ENTRY)* sk, sk_X509_NAME_ENTRY_copyfunc copyfunc, sk_X509_NAME_ENTRY_freefunc freefunc); 124 sk_X509_NAME_ENTRY_compfunc sk_X509_NAME_ENTRY_set_cmp_func(stack_st_X509_NAME_ENTRY* sk, sk_X509_NAME_ENTRY_compfunc compare); 125 struct stack_st_X509_NAME; 126 alias sk_X509_NAME_compfunc = int function(const(X509_NAME*)* a, const(X509_NAME*)* b); 127 alias sk_X509_NAME_freefunc = void function(X509_NAME* a); 128 alias sk_X509_NAME_copyfunc = X509_name_st* function(const(X509_NAME)* a); 129 int sk_X509_NAME_num(const(stack_st_X509_NAME)* sk); 130 X509_NAME* sk_X509_NAME_value(const(stack_st_X509_NAME)* sk, int idx); 131 stack_st_X509_NAME* sk_X509_NAME_new(sk_X509_NAME_compfunc compare); 132 stack_st_X509_NAME* sk_X509_NAME_new_null(); 133 void sk_X509_NAME_free(stack_st_X509_NAME* sk); 134 void sk_X509_NAME_zero(stack_st_X509_NAME* sk); 135 X509_NAME* sk_X509_NAME_delete(stack_st_X509_NAME* sk, int i); 136 X509_NAME* sk_X509_NAME_delete_ptr(stack_st_X509_NAME* sk, X509_NAME* ptr); 137 int sk_X509_NAME_push(stack_st_X509_NAME* sk, X509_NAME* ptr); 138 int sk_X509_NAME_unshift(stack_st_X509_NAME* sk, X509_NAME* ptr); 139 X509_NAME* sk_X509_NAME_pop(stack_st_X509_NAME* sk); 140 X509_NAME* sk_X509_NAME_shift(stack_st_X509_NAME* sk); 141 void sk_X509_NAME_pop_free(stack_st_X509_NAME* sk, sk_X509_NAME_freefunc freefunc); 142 int sk_X509_NAME_insert(stack_st_X509_NAME* sk, X509_NAME* ptr, int idx); 143 X509_NAME* sk_X509_NAME_set(stack_st_X509_NAME* sk, int idx, X509_NAME* ptr); 144 int sk_X509_NAME_find(stack_st_X509_NAME* sk, X509_NAME* ptr); 145 int sk_X509_NAME_find_ex(stack_st_X509_NAME* sk, X509_NAME* ptr); 146 void sk_X509_NAME_sort(stack_st_X509_NAME* sk); 147 int sk_X509_NAME_is_sorted(const(stack_st_X509_NAME)* sk); 148 stack_st_X509_NAME* sk_X509_NAME_dup(const(stack_st_X509_NAME)* sk); 149 stack_st_X509_NAME* sk_X509_NAME_deep_copy(const(stack_st_X509_NAME)* sk, sk_X509_NAME_copyfunc copyfunc, sk_X509_NAME_freefunc freefunc); 150 sk_X509_NAME_compfunc sk_X509_NAME_set_cmp_func(stack_st_X509_NAME* sk, sk_X509_NAME_compfunc compare); 151 enum X509_EX_V_NETSCAPE_HACK = 0x8000; 152 enum X509_EX_V_INIT = 0x0001; 153 struct X509_extension_st; 154 alias X509_EXTENSION = X509_extension_st; 155 struct stack_st_X509_EXTENSION; 156 alias X509_EXTENSIONS = stack_st_X509_EXTENSION; 157 alias sk_X509_EXTENSION_compfunc = int function(const(X509_EXTENSION*)* a, const(X509_EXTENSION*)* b); 158 alias sk_X509_EXTENSION_freefunc = void function(X509_EXTENSION* a); 159 alias sk_X509_EXTENSION_copyfunc = X509_extension_st* function(const(X509_EXTENSION)* a); 160 int sk_X509_EXTENSION_num(const(stack_st_X509_EXTENSION)* sk); 161 X509_EXTENSION* sk_X509_EXTENSION_value(const(stack_st_X509_EXTENSION)* sk, int idx); 162 stack_st_X509_EXTENSION* sk_X509_EXTENSION_new(sk_X509_EXTENSION_compfunc compare); 163 stack_st_X509_EXTENSION* sk_X509_EXTENSION_new_null(); 164 void sk_X509_EXTENSION_free(stack_st_X509_EXTENSION* sk); 165 void sk_X509_EXTENSION_zero(stack_st_X509_EXTENSION* sk); 166 X509_EXTENSION* sk_X509_EXTENSION_delete(stack_st_X509_EXTENSION* sk, int i); 167 X509_EXTENSION* sk_X509_EXTENSION_delete_ptr(stack_st_X509_EXTENSION* sk, X509_EXTENSION* ptr); 168 int sk_X509_EXTENSION_push(stack_st_X509_EXTENSION* sk, X509_EXTENSION* ptr); 169 int sk_X509_EXTENSION_unshift(stack_st_X509_EXTENSION* sk, X509_EXTENSION* ptr); 170 X509_EXTENSION* sk_X509_EXTENSION_pop(stack_st_X509_EXTENSION* sk); 171 X509_EXTENSION* sk_X509_EXTENSION_shift(stack_st_X509_EXTENSION* sk); 172 void sk_X509_EXTENSION_pop_free(stack_st_X509_EXTENSION* sk, sk_X509_EXTENSION_freefunc freefunc); 173 int sk_X509_EXTENSION_insert(stack_st_X509_EXTENSION* sk, X509_EXTENSION* ptr, int idx); 174 X509_EXTENSION* sk_X509_EXTENSION_set(stack_st_X509_EXTENSION* sk, int idx, X509_EXTENSION* ptr); 175 int sk_X509_EXTENSION_find(stack_st_X509_EXTENSION* sk, X509_EXTENSION* ptr); 176 int sk_X509_EXTENSION_find_ex(stack_st_X509_EXTENSION* sk, X509_EXTENSION* ptr); 177 void sk_X509_EXTENSION_sort(stack_st_X509_EXTENSION* sk); 178 int sk_X509_EXTENSION_is_sorted(const(stack_st_X509_EXTENSION)* sk); 179 stack_st_X509_EXTENSION* sk_X509_EXTENSION_dup(const(stack_st_X509_EXTENSION)* sk); 180 stack_st_X509_EXTENSION* sk_X509_EXTENSION_deep_copy(const(stack_st_X509_EXTENSION)* sk, sk_X509_EXTENSION_copyfunc copyfunc, sk_X509_EXTENSION_freefunc freefunc); 181 sk_X509_EXTENSION_compfunc sk_X509_EXTENSION_set_cmp_func(stack_st_X509_EXTENSION* sk, sk_X509_EXTENSION_compfunc compare); 182 struct x509_attributes_st; 183 alias X509_ATTRIBUTE = x509_attributes_st; 184 struct stack_st_X509_ATTRIBUTE; 185 alias sk_X509_ATTRIBUTE_compfunc = int function(const(X509_ATTRIBUTE*)* a, const(X509_ATTRIBUTE*)* b); 186 alias sk_X509_ATTRIBUTE_freefunc = void function(X509_ATTRIBUTE* a); 187 alias sk_X509_ATTRIBUTE_copyfunc = x509_attributes_st* function(const(X509_ATTRIBUTE)* a); 188 int sk_X509_ATTRIBUTE_num(const(stack_st_X509_ATTRIBUTE)* sk); 189 X509_ATTRIBUTE* sk_X509_ATTRIBUTE_value(const(stack_st_X509_ATTRIBUTE)* sk, int idx); 190 stack_st_X509_ATTRIBUTE* sk_X509_ATTRIBUTE_new(sk_X509_ATTRIBUTE_compfunc compare); 191 stack_st_X509_ATTRIBUTE* sk_X509_ATTRIBUTE_new_null(); 192 void sk_X509_ATTRIBUTE_free(stack_st_X509_ATTRIBUTE* sk); 193 void sk_X509_ATTRIBUTE_zero(stack_st_X509_ATTRIBUTE* sk); 194 X509_ATTRIBUTE* sk_X509_ATTRIBUTE_delete(stack_st_X509_ATTRIBUTE* sk, int i); 195 X509_ATTRIBUTE* sk_X509_ATTRIBUTE_delete_ptr(stack_st_X509_ATTRIBUTE* sk, X509_ATTRIBUTE* ptr); 196 int sk_X509_ATTRIBUTE_push(stack_st_X509_ATTRIBUTE* sk, X509_ATTRIBUTE* ptr); 197 int sk_X509_ATTRIBUTE_unshift(stack_st_X509_ATTRIBUTE* sk, X509_ATTRIBUTE* ptr); 198 X509_ATTRIBUTE* sk_X509_ATTRIBUTE_pop(stack_st_X509_ATTRIBUTE* sk); 199 X509_ATTRIBUTE* sk_X509_ATTRIBUTE_shift(stack_st_X509_ATTRIBUTE* sk); 200 void sk_X509_ATTRIBUTE_pop_free(stack_st_X509_ATTRIBUTE* sk, sk_X509_ATTRIBUTE_freefunc freefunc); 201 int sk_X509_ATTRIBUTE_insert(stack_st_X509_ATTRIBUTE* sk, X509_ATTRIBUTE* ptr, int idx); 202 X509_ATTRIBUTE* sk_X509_ATTRIBUTE_set(stack_st_X509_ATTRIBUTE* sk, int idx, X509_ATTRIBUTE* ptr); 203 int sk_X509_ATTRIBUTE_find(stack_st_X509_ATTRIBUTE* sk, X509_ATTRIBUTE* ptr); 204 int sk_X509_ATTRIBUTE_find_ex(stack_st_X509_ATTRIBUTE* sk, X509_ATTRIBUTE* ptr); 205 void sk_X509_ATTRIBUTE_sort(stack_st_X509_ATTRIBUTE* sk); 206 int sk_X509_ATTRIBUTE_is_sorted(const(stack_st_X509_ATTRIBUTE)* sk); 207 stack_st_X509_ATTRIBUTE* sk_X509_ATTRIBUTE_dup(const(stack_st_X509_ATTRIBUTE)* sk); 208 stack_st_X509_ATTRIBUTE* sk_X509_ATTRIBUTE_deep_copy(const(stack_st_X509_ATTRIBUTE)* sk, sk_X509_ATTRIBUTE_copyfunc copyfunc, sk_X509_ATTRIBUTE_freefunc freefunc); 209 sk_X509_ATTRIBUTE_compfunc sk_X509_ATTRIBUTE_set_cmp_func(stack_st_X509_ATTRIBUTE* sk, sk_X509_ATTRIBUTE_compfunc compare); 210 struct X509_req_info_st; 211 alias X509_REQ_INFO = X509_req_info_st; 212 struct X509_req_st; 213 alias X509_REQ = X509_req_st; 214 struct x509_cert_aux_st; 215 alias X509_CERT_AUX = x509_cert_aux_st; 216 struct x509_cinf_st; 217 alias X509_CINF = x509_cinf_st; 218 struct stack_st_X509; 219 alias sk_X509_compfunc = int function(const(X509*)* a, const(X509*)* b); 220 alias sk_X509_freefunc = void function(X509* a); 221 alias sk_X509_copyfunc = x509_st* function(const(X509)* a); 222 int sk_X509_num(const(stack_st_X509)* sk); 223 X509* sk_X509_value(const(stack_st_X509)* sk, int idx); 224 stack_st_X509* sk_X509_new(sk_X509_compfunc compare); 225 stack_st_X509* sk_X509_new_null(); 226 void sk_X509_free(stack_st_X509* sk); 227 void sk_X509_zero(stack_st_X509* sk); 228 X509* sk_X509_delete(stack_st_X509* sk, int i); 229 X509* sk_X509_delete_ptr(stack_st_X509* sk, X509* ptr); 230 int sk_X509_push(stack_st_X509* sk, X509* ptr); 231 int sk_X509_unshift(stack_st_X509* sk, X509* ptr); 232 X509* sk_X509_pop(stack_st_X509* sk); 233 X509* sk_X509_shift(stack_st_X509* sk); 234 void sk_X509_pop_free(stack_st_X509* sk, sk_X509_freefunc freefunc); 235 int sk_X509_insert(stack_st_X509* sk, X509* ptr, int idx); 236 X509* sk_X509_set(stack_st_X509* sk, int idx, X509* ptr); 237 int sk_X509_find(stack_st_X509* sk, X509* ptr); 238 int sk_X509_find_ex(stack_st_X509* sk, X509* ptr); 239 void sk_X509_sort(stack_st_X509* sk); 240 int sk_X509_is_sorted(const(stack_st_X509)* sk); 241 stack_st_X509* sk_X509_dup(const(stack_st_X509)* sk); 242 stack_st_X509* sk_X509_deep_copy(const(stack_st_X509)* sk, sk_X509_copyfunc copyfunc, sk_X509_freefunc freefunc); 243 sk_X509_compfunc sk_X509_set_cmp_func(stack_st_X509* sk, sk_X509_compfunc compare); 244 245 struct x509_trust_st 246 { 247 int trust; 248 int flags; 249 int function(x509_trust_st*, X509*, int) check_trust; 250 char* name; 251 int arg1; 252 void* arg2; 253 } 254 255 alias X509_TRUST = x509_trust_st; 256 struct stack_st_X509_TRUST; 257 alias sk_X509_TRUST_compfunc = int function(const(X509_TRUST*)* a, const(X509_TRUST*)* b); 258 alias sk_X509_TRUST_freefunc = void function(X509_TRUST* a); 259 alias sk_X509_TRUST_copyfunc = x509_trust_st* function(const(X509_TRUST)* a); 260 int sk_X509_TRUST_num(const(stack_st_X509_TRUST)* sk); 261 X509_TRUST* sk_X509_TRUST_value(const(stack_st_X509_TRUST)* sk, int idx); 262 stack_st_X509_TRUST* sk_X509_TRUST_new(sk_X509_TRUST_compfunc compare); 263 stack_st_X509_TRUST* sk_X509_TRUST_new_null(); 264 void sk_X509_TRUST_free(stack_st_X509_TRUST* sk); 265 void sk_X509_TRUST_zero(stack_st_X509_TRUST* sk); 266 X509_TRUST* sk_X509_TRUST_delete(stack_st_X509_TRUST* sk, int i); 267 X509_TRUST* sk_X509_TRUST_delete_ptr(stack_st_X509_TRUST* sk, X509_TRUST* ptr); 268 int sk_X509_TRUST_push(stack_st_X509_TRUST* sk, X509_TRUST* ptr); 269 int sk_X509_TRUST_unshift(stack_st_X509_TRUST* sk, X509_TRUST* ptr); 270 X509_TRUST* sk_X509_TRUST_pop(stack_st_X509_TRUST* sk); 271 X509_TRUST* sk_X509_TRUST_shift(stack_st_X509_TRUST* sk); 272 void sk_X509_TRUST_pop_free(stack_st_X509_TRUST* sk, sk_X509_TRUST_freefunc freefunc); 273 int sk_X509_TRUST_insert(stack_st_X509_TRUST* sk, X509_TRUST* ptr, int idx); 274 X509_TRUST* sk_X509_TRUST_set(stack_st_X509_TRUST* sk, int idx, X509_TRUST* ptr); 275 int sk_X509_TRUST_find(stack_st_X509_TRUST* sk, X509_TRUST* ptr); 276 int sk_X509_TRUST_find_ex(stack_st_X509_TRUST* sk, X509_TRUST* ptr); 277 void sk_X509_TRUST_sort(stack_st_X509_TRUST* sk); 278 int sk_X509_TRUST_is_sorted(const(stack_st_X509_TRUST)* sk); 279 stack_st_X509_TRUST* sk_X509_TRUST_dup(const(stack_st_X509_TRUST)* sk); 280 stack_st_X509_TRUST* sk_X509_TRUST_deep_copy(const(stack_st_X509_TRUST)* sk, sk_X509_TRUST_copyfunc copyfunc, sk_X509_TRUST_freefunc freefunc); 281 sk_X509_TRUST_compfunc sk_X509_TRUST_set_cmp_func(stack_st_X509_TRUST* sk, sk_X509_TRUST_compfunc compare); 282 enum X509_TRUST_DEFAULT = 0; 283 enum X509_TRUST_COMPAT = 1; 284 enum X509_TRUST_SSL_CLIENT = 2; 285 enum X509_TRUST_SSL_SERVER = 3; 286 enum X509_TRUST_EMAIL = 4; 287 enum X509_TRUST_OBJECT_SIGN = 5; 288 enum X509_TRUST_OCSP_SIGN = 6; 289 enum X509_TRUST_OCSP_REQUEST = 7; 290 enum X509_TRUST_TSA = 8; 291 enum X509_TRUST_MIN = 1; 292 enum X509_TRUST_MAX = 8; 293 enum X509_TRUST_DYNAMIC = 1U << 0; 294 enum X509_TRUST_DYNAMIC_NAME = 1U << 1; 295 enum X509_TRUST_NO_SS_COMPAT = 1U << 2; 296 enum X509_TRUST_DO_SS_COMPAT = 1U << 3; 297 enum X509_TRUST_OK_ANY_EKU = 1U << 4; 298 enum X509_TRUST_TRUSTED = 1; 299 enum X509_TRUST_REJECTED = 2; 300 enum X509_TRUST_UNTRUSTED = 3; 301 302 enum X509_FLAG_COMPAT = 0; 303 enum X509_FLAG_NO_HEADER = 1L; 304 enum X509_FLAG_NO_VERSION = 1L << 1; 305 enum X509_FLAG_NO_SERIAL = 1L << 2; 306 enum X509_FLAG_NO_SIGNAME = 1L << 3; 307 enum X509_FLAG_NO_ISSUER = 1L << 4; 308 enum X509_FLAG_NO_VALIDITY = 1L << 5; 309 enum X509_FLAG_NO_SUBJECT = 1L << 6; 310 enum X509_FLAG_NO_PUBKEY = 1L << 7; 311 enum X509_FLAG_NO_EXTENSIONS = 1L << 8; 312 enum X509_FLAG_NO_SIGDUMP = 1L << 9; 313 enum X509_FLAG_NO_AUX = 1L << 10; 314 enum X509_FLAG_NO_ATTRIBUTES = 1L << 11; 315 enum X509_FLAG_NO_IDS = 1L << 12; 316 317 /* Flags specific to X509_NAME_print_ex() */ 318 319 /* The field separator information */ 320 321 enum XN_FLAG_SEP_MASK = 0xf << 16; 322 323 enum XN_FLAG_COMPAT = 0; /* Traditional; use old X509_NAME_print */ 324 enum XN_FLAG_SEP_COMMA_PLUS = 1 << 16; /* RFC2253 ,+ */ 325 enum XN_FLAG_SEP_CPLUS_SPC = 2 << 16; /* ,+ spaced: more readable */ 326 enum XN_FLAG_SEP_SPLUS_SPC = 3 << 16; /* ;+ spaced */ 327 enum XN_FLAG_SEP_MULTILINE = 4 << 16; /* One line per field */ 328 329 enum XN_FLAG_DN_REV = 1 << 20; /* Reverse DN order */ 330 331 /* How the field name is shown */ 332 333 enum XN_FLAG_FN_MASK = 0x3 << 21; 334 335 enum XN_FLAG_FN_SN = 0; /* Object short name */ 336 enum XN_FLAG_FN_LN = 1 << 21; /* Object long name */ 337 enum XN_FLAG_FN_OID = 2 << 21; /* Always use OIDs */ 338 enum XN_FLAG_FN_NONE = 3 << 21; /* No field names */ 339 340 enum XN_FLAG_SPC_EQ = 1 << 23; /* Put spaces round '=' */ 341 342 /* 343 * This determines if we dump fields we don't recognise: RFC2253 requires 344 * this. 345 */ 346 347 enum XN_FLAG_DUMP_UNKNOWN_FIELDS = 1 << 24; 348 349 enum XN_FLAG_FN_ALIGN = 1 << 25; /* Align field names to 20 350 * characters */ 351 352 /* Complete set of RFC2253 flags */ 353 354 enum XN_FLAG_RFC2253 = ASN1_STRFLGS_RFC2253 | XN_FLAG_SEP_COMMA_PLUS | XN_FLAG_DN_REV | XN_FLAG_FN_SN | XN_FLAG_DUMP_UNKNOWN_FIELDS; 355 356 /* readable oneline form */ 357 358 enum XN_FLAG_ONELINE = ASN1_STRFLGS_RFC2253 | ASN1_STRFLGS_ESC_QUOTE | XN_FLAG_SEP_CPLUS_SPC | XN_FLAG_SPC_EQ | XN_FLAG_FN_SN; 359 360 /* readable multiline form */ 361 362 enum XN_FLAG_MULTILINE = ASN1_STRFLGS_ESC_CTRL | ASN1_STRFLGS_ESC_MSB | XN_FLAG_SEP_MULTILINE | XN_FLAG_SPC_EQ | XN_FLAG_FN_LN | XN_FLAG_FN_ALIGN; 363 364 struct stack_st_X509_REVOKED; 365 alias sk_X509_REVOKED_compfunc = int function(const(X509_REVOKED*)* a, const(X509_REVOKED*)* b); 366 alias sk_X509_REVOKED_freefunc = void function(X509_REVOKED* a); 367 alias sk_X509_REVOKED_copyfunc = x509_revoked_st* function(const(X509_REVOKED)* a); 368 int sk_X509_REVOKED_num(const(stack_st_X509_REVOKED)* sk); 369 X509_REVOKED* sk_X509_REVOKED_value(const(stack_st_X509_REVOKED)* sk, int idx); 370 stack_st_X509_REVOKED* sk_X509_REVOKED_new(sk_X509_REVOKED_compfunc compare); 371 stack_st_X509_REVOKED* sk_X509_REVOKED_new_null(); 372 void sk_X509_REVOKED_free(stack_st_X509_REVOKED* sk); 373 void sk_X509_REVOKED_zero(stack_st_X509_REVOKED* sk); 374 X509_REVOKED* sk_X509_REVOKED_delete(stack_st_X509_REVOKED* sk, int i); 375 X509_REVOKED* sk_X509_REVOKED_delete_ptr(stack_st_X509_REVOKED* sk, X509_REVOKED* ptr); 376 int sk_X509_REVOKED_push(stack_st_X509_REVOKED* sk, X509_REVOKED* ptr); 377 int sk_X509_REVOKED_unshift(stack_st_X509_REVOKED* sk, X509_REVOKED* ptr); 378 X509_REVOKED* sk_X509_REVOKED_pop(stack_st_X509_REVOKED* sk); 379 X509_REVOKED* sk_X509_REVOKED_shift(stack_st_X509_REVOKED* sk); 380 void sk_X509_REVOKED_pop_free(stack_st_X509_REVOKED* sk, sk_X509_REVOKED_freefunc freefunc); 381 int sk_X509_REVOKED_insert(stack_st_X509_REVOKED* sk, X509_REVOKED* ptr, int idx); 382 X509_REVOKED* sk_X509_REVOKED_set(stack_st_X509_REVOKED* sk, int idx, X509_REVOKED* ptr); 383 int sk_X509_REVOKED_find(stack_st_X509_REVOKED* sk, X509_REVOKED* ptr); 384 int sk_X509_REVOKED_find_ex(stack_st_X509_REVOKED* sk, X509_REVOKED* ptr); 385 void sk_X509_REVOKED_sort(stack_st_X509_REVOKED* sk); 386 int sk_X509_REVOKED_is_sorted(const(stack_st_X509_REVOKED)* sk); 387 stack_st_X509_REVOKED* sk_X509_REVOKED_dup(const(stack_st_X509_REVOKED)* sk); 388 stack_st_X509_REVOKED* sk_X509_REVOKED_deep_copy(const(stack_st_X509_REVOKED)* sk, sk_X509_REVOKED_copyfunc copyfunc, sk_X509_REVOKED_freefunc freefunc); 389 sk_X509_REVOKED_compfunc sk_X509_REVOKED_set_cmp_func(stack_st_X509_REVOKED* sk, sk_X509_REVOKED_compfunc compare); 390 391 struct X509_crl_info_st; 392 alias X509_CRL_INFO = X509_crl_info_st; 393 394 struct stack_st_X509_CRL; 395 alias sk_X509_CRL_compfunc = int function(const(X509_CRL*)* a, const(X509_CRL*)* b); 396 alias sk_X509_CRL_freefunc = void function(X509_CRL* a); 397 alias sk_X509_CRL_copyfunc = X509_crl_st* function(const(X509_CRL)* a); 398 int sk_X509_CRL_num(const(stack_st_X509_CRL)* sk); 399 X509_CRL* sk_X509_CRL_value(const(stack_st_X509_CRL)* sk, int idx); 400 stack_st_X509_CRL* sk_X509_CRL_new(sk_X509_CRL_compfunc compare); 401 stack_st_X509_CRL* sk_X509_CRL_new_null(); 402 void sk_X509_CRL_free(stack_st_X509_CRL* sk); 403 void sk_X509_CRL_zero(stack_st_X509_CRL* sk); 404 X509_CRL* sk_X509_CRL_delete(stack_st_X509_CRL* sk, int i); 405 X509_CRL* sk_X509_CRL_delete_ptr(stack_st_X509_CRL* sk, X509_CRL* ptr); 406 int sk_X509_CRL_push(stack_st_X509_CRL* sk, X509_CRL* ptr); 407 int sk_X509_CRL_unshift(stack_st_X509_CRL* sk, X509_CRL* ptr); 408 X509_CRL* sk_X509_CRL_pop(stack_st_X509_CRL* sk); 409 X509_CRL* sk_X509_CRL_shift(stack_st_X509_CRL* sk); 410 void sk_X509_CRL_pop_free(stack_st_X509_CRL* sk, sk_X509_CRL_freefunc freefunc); 411 int sk_X509_CRL_insert(stack_st_X509_CRL* sk, X509_CRL* ptr, int idx); 412 X509_CRL* sk_X509_CRL_set(stack_st_X509_CRL* sk, int idx, X509_CRL* ptr); 413 int sk_X509_CRL_find(stack_st_X509_CRL* sk, X509_CRL* ptr); 414 int sk_X509_CRL_find_ex(stack_st_X509_CRL* sk, X509_CRL* ptr); 415 void sk_X509_CRL_sort(stack_st_X509_CRL* sk); 416 int sk_X509_CRL_is_sorted(const(stack_st_X509_CRL)* sk); 417 stack_st_X509_CRL* sk_X509_CRL_dup(const(stack_st_X509_CRL)* sk); 418 stack_st_X509_CRL* sk_X509_CRL_deep_copy(const(stack_st_X509_CRL)* sk, sk_X509_CRL_copyfunc copyfunc, sk_X509_CRL_freefunc freefunc); 419 sk_X509_CRL_compfunc sk_X509_CRL_set_cmp_func(stack_st_X509_CRL* sk, sk_X509_CRL_compfunc compare); 420 421 struct private_key_st 422 { 423 int version_; 424 /* The PKCS#8 data types */ 425 X509_ALGOR* enc_algor; 426 ASN1_OCTET_STRING* enc_pkey; /* encrypted pub key */ 427 /* When decrypted, the following will not be NULL */ 428 EVP_PKEY* dec_pkey; 429 /* used to encrypt and decrypt */ 430 int key_length; 431 char* key_data; 432 int key_free; /* true if we should auto free key_data */ 433 /* expanded version of 'enc_algor' */ 434 EVP_CIPHER_INFO cipher; 435 } 436 437 alias X509_PKEY = private_key_st; 438 439 struct X509_info_st 440 { 441 X509* x509; 442 X509_CRL* crl; 443 X509_PKEY* x_pkey; 444 EVP_CIPHER_INFO enc_cipher; 445 int enc_len; 446 char* enc_data; 447 } 448 449 alias X509_INFO = X509_info_st; 450 451 struct stack_st_X509_INFO; 452 alias sk_X509_INFO_compfunc = int function(const(X509_INFO*)* a, const(X509_INFO*)* b); 453 alias sk_X509_INFO_freefunc = void function(X509_INFO* a); 454 alias sk_X509_INFO_copyfunc = X509_info_st* function(const(X509_INFO)* a); 455 int sk_X509_INFO_num(const(stack_st_X509_INFO)* sk); 456 X509_INFO* sk_X509_INFO_value(const(stack_st_X509_INFO)* sk, int idx); 457 stack_st_X509_INFO* sk_X509_INFO_new(sk_X509_INFO_compfunc compare); 458 stack_st_X509_INFO* sk_X509_INFO_new_null(); 459 void sk_X509_INFO_free(stack_st_X509_INFO* sk); 460 void sk_X509_INFO_zero(stack_st_X509_INFO* sk); 461 X509_INFO* sk_X509_INFO_delete(stack_st_X509_INFO* sk, int i); 462 X509_INFO* sk_X509_INFO_delete_ptr(stack_st_X509_INFO* sk, X509_INFO* ptr); 463 int sk_X509_INFO_push(stack_st_X509_INFO* sk, X509_INFO* ptr); 464 int sk_X509_INFO_unshift(stack_st_X509_INFO* sk, X509_INFO* ptr); 465 X509_INFO* sk_X509_INFO_pop(stack_st_X509_INFO* sk); 466 X509_INFO* sk_X509_INFO_shift(stack_st_X509_INFO* sk); 467 void sk_X509_INFO_pop_free(stack_st_X509_INFO* sk, sk_X509_INFO_freefunc freefunc); 468 int sk_X509_INFO_insert(stack_st_X509_INFO* sk, X509_INFO* ptr, int idx); 469 X509_INFO* sk_X509_INFO_set(stack_st_X509_INFO* sk, int idx, X509_INFO* ptr); 470 int sk_X509_INFO_find(stack_st_X509_INFO* sk, X509_INFO* ptr); 471 int sk_X509_INFO_find_ex(stack_st_X509_INFO* sk, X509_INFO* ptr); 472 void sk_X509_INFO_sort(stack_st_X509_INFO* sk); 473 int sk_X509_INFO_is_sorted(const(stack_st_X509_INFO)* sk); 474 stack_st_X509_INFO* sk_X509_INFO_dup(const(stack_st_X509_INFO)* sk); 475 stack_st_X509_INFO* sk_X509_INFO_deep_copy(const(stack_st_X509_INFO)* sk, sk_X509_INFO_copyfunc copyfunc, sk_X509_INFO_freefunc freefunc); 476 sk_X509_INFO_compfunc sk_X509_INFO_set_cmp_func(stack_st_X509_INFO* sk, sk_X509_INFO_compfunc compare); 477 478 /* 479 * The next 2 structures and their 8 routines were sent to me by Pat Richard 480 * <patr@x509.com> and are used to manipulate Netscapes spki structures - 481 * useful if you are writing a CA web page 482 */ 483 struct Netscape_spkac_st 484 { 485 X509_PUBKEY* pubkey; 486 ASN1_IA5STRING* challenge; /* challenge sent in atlas >= PR2 */ 487 } 488 489 alias NETSCAPE_SPKAC = Netscape_spkac_st; 490 491 struct Netscape_spki_st 492 { 493 NETSCAPE_SPKAC* spkac; /* signed public key and challenge */ 494 X509_ALGOR sig_algor; 495 ASN1_BIT_STRING* signature; 496 } 497 498 alias NETSCAPE_SPKI = Netscape_spki_st; 499 500 /* Netscape certificate sequence structure */ 501 struct Netscape_certificate_sequence 502 { 503 ASN1_OBJECT* type; 504 stack_st_X509* certs; 505 } 506 507 alias NETSCAPE_CERT_SEQUENCE = Netscape_certificate_sequence; 508 509 /*- Unused (and iv length is wrong) 510 typedef struct CBCParameter_st 511 { 512 unsigned char iv[8]; 513 } CBC_PARAM; 514 */ 515 516 /* Password based encryption structure */ 517 518 struct PBEPARAM_st 519 { 520 ASN1_OCTET_STRING* salt; 521 ASN1_INTEGER* iter; 522 } 523 524 alias PBEPARAM = PBEPARAM_st; 525 526 /* Password based encryption V2 structures */ 527 528 struct PBE2PARAM_st 529 { 530 X509_ALGOR* keyfunc; 531 X509_ALGOR* encryption; 532 } 533 534 alias PBE2PARAM = PBE2PARAM_st; 535 536 struct PBKDF2PARAM_st 537 { 538 /* Usually OCTET STRING but could be anything */ 539 ASN1_TYPE* salt; 540 ASN1_INTEGER* iter; 541 ASN1_INTEGER* keylength; 542 X509_ALGOR* prf; 543 } 544 545 alias PBKDF2PARAM = PBKDF2PARAM_st; 546 547 public import deimos.openssl.x509_vfy; 548 public import deimos.openssl.pkcs7; 549 550 enum X509_EXT_PACK_UNKNOWN = 1; 551 enum X509_EXT_PACK_STRING = 2; 552 553 alias X509_extract_key = X509_get_pubkey; /*****/ 554 alias X509_REQ_extract_key = X509_REQ_get_pubkey; 555 alias X509_name_cmp = X509_NAME_cmp; 556 557 void X509_CRL_set_default_method(const(X509_CRL_METHOD)* meth); 558 X509_CRL_METHOD* X509_CRL_METHOD_new( 559 int function(X509_CRL* crl) crl_init, 560 int function(X509_CRL* crl) crl_free, 561 int function(X509_CRL* crl, X509_REVOKED** ret, ASN1_INTEGER* ser, X509_NAME* issuer) crl_lookup, 562 int function(X509_CRL* crl, EVP_PKEY* pk) crl_verify); 563 void X509_CRL_METHOD_free(X509_CRL_METHOD* m); 564 565 void X509_CRL_set_meth_data(X509_CRL* crl, void* dat); 566 void* X509_CRL_get_meth_data(X509_CRL* crl); 567 568 const(char)* X509_verify_cert_error_string(c_long n); 569 570 int X509_verify(X509* a, EVP_PKEY* r); 571 572 int X509_REQ_verify(X509_REQ* a, EVP_PKEY* r); 573 int X509_CRL_verify(X509_CRL* a, EVP_PKEY* r); 574 int NETSCAPE_SPKI_verify(NETSCAPE_SPKI* a, EVP_PKEY* r); 575 576 NETSCAPE_SPKI* NETSCAPE_SPKI_b64_decode(const(char)* str, int len); 577 char* NETSCAPE_SPKI_b64_encode(NETSCAPE_SPKI* x); 578 EVP_PKEY* NETSCAPE_SPKI_get_pubkey(NETSCAPE_SPKI* x); 579 int NETSCAPE_SPKI_set_pubkey(NETSCAPE_SPKI* x, EVP_PKEY* pkey); 580 581 int NETSCAPE_SPKI_print(BIO* out_, NETSCAPE_SPKI* spki); 582 583 int X509_signature_dump(BIO* bp, const(ASN1_STRING)* sig, int indent); 584 int X509_signature_print( 585 BIO* bp, 586 const(X509_ALGOR)* alg, 587 const(ASN1_STRING)* sig); 588 589 int X509_sign(X509* x, EVP_PKEY* pkey, const(EVP_MD)* md); 590 int X509_sign_ctx(X509* x, EVP_MD_CTX* ctx); 591 592 version(OPENSSL_NO_OCSP) {} else { 593 int X509_http_nbio(OCSP_REQ_CTX* rctx, X509** pcert); 594 } 595 596 int X509_REQ_sign(X509_REQ* x, EVP_PKEY* pkey, const(EVP_MD)* md); 597 int X509_REQ_sign_ctx(X509_REQ* x, EVP_MD_CTX* ctx); 598 int X509_CRL_sign(X509_CRL* x, EVP_PKEY* pkey, const(EVP_MD)* md); 599 int X509_CRL_sign_ctx(X509_CRL* x, EVP_MD_CTX* ctx); 600 601 version(OPENSSL_NO_OCSP) {} else { 602 int X509_CRL_http_nbio(OCSP_REQ_CTX* rctx, X509_CRL** pcrl); 603 } 604 605 int NETSCAPE_SPKI_sign(NETSCAPE_SPKI* x, EVP_PKEY* pkey, const(EVP_MD)* md); 606 607 int X509_pubkey_digest( 608 const(X509)* data, 609 const(EVP_MD)* type, 610 ubyte* md, 611 uint* len); 612 int X509_digest(const(X509)* data, const(EVP_MD)* type, ubyte* md, uint* len); 613 int X509_CRL_digest( 614 const(X509_CRL)* data, 615 const(EVP_MD)* type, 616 ubyte* md, 617 uint* len); 618 int X509_REQ_digest( 619 const(X509_REQ)* data, 620 const(EVP_MD)* type, 621 ubyte* md, 622 uint* len); 623 int X509_NAME_digest( 624 const(X509_NAME)* data, 625 const(EVP_MD)* type, 626 ubyte* md, 627 uint* len); 628 629 version(OPENSSL_NO_STDIO) {} else { 630 X509* d2i_X509_fp(FILE* fp, X509** x509); 631 int i2d_X509_fp(FILE* fp, X509* x509); 632 X509_CRL* d2i_X509_CRL_fp(FILE* fp, X509_CRL** crl); 633 int i2d_X509_CRL_fp(FILE* fp, X509_CRL* crl); 634 X509_REQ* d2i_X509_REQ_fp(FILE* fp, X509_REQ** req); 635 int i2d_X509_REQ_fp(FILE* fp, X509_REQ* req); 636 637 version(OPENSSL_NO_RSA) {} else { 638 RSA* d2i_RSAPrivateKey_fp(FILE* fp, RSA** rsa); 639 int i2d_RSAPrivateKey_fp(FILE* fp, RSA* rsa); 640 RSA* d2i_RSAPublicKey_fp(FILE* fp, RSA** rsa); 641 int i2d_RSAPublicKey_fp(FILE* fp, RSA* rsa); 642 RSA* d2i_RSA_PUBKEY_fp(FILE* fp, RSA** rsa); 643 int i2d_RSA_PUBKEY_fp(FILE* fp, RSA* rsa); 644 } 645 646 version(OPENSSL_NO_DSA) {} else { 647 DSA* d2i_DSA_PUBKEY_fp(FILE* fp, DSA** dsa); 648 int i2d_DSA_PUBKEY_fp(FILE* fp, DSA* dsa); 649 DSA* d2i_DSAPrivateKey_fp(FILE* fp, DSA** dsa); 650 int i2d_DSAPrivateKey_fp(FILE* fp, DSA* dsa); 651 } 652 653 version(OPENSSL_NO_EC) {} else { 654 EC_KEY* d2i_EC_PUBKEY_fp(FILE* fp, EC_KEY** eckey); 655 int i2d_EC_PUBKEY_fp(FILE* fp, EC_KEY* eckey); 656 EC_KEY* d2i_ECPrivateKey_fp(FILE* fp, EC_KEY** eckey); 657 int i2d_ECPrivateKey_fp(FILE* fp, EC_KEY* eckey); 658 } 659 660 X509_SIG* d2i_PKCS8_fp(FILE* fp, X509_SIG** p8); 661 int i2d_PKCS8_fp(FILE* fp, X509_SIG* p8); 662 PKCS8_PRIV_KEY_INFO* d2i_PKCS8_PRIV_KEY_INFO_fp( 663 FILE* fp, 664 PKCS8_PRIV_KEY_INFO** p8inf); 665 int i2d_PKCS8_PRIV_KEY_INFO_fp(FILE* fp, PKCS8_PRIV_KEY_INFO* p8inf); 666 int i2d_PKCS8PrivateKeyInfo_fp(FILE* fp, EVP_PKEY* key); 667 int i2d_PrivateKey_fp(FILE* fp, EVP_PKEY* pkey); 668 EVP_PKEY* d2i_PrivateKey_fp(FILE* fp, EVP_PKEY** a); 669 int i2d_PUBKEY_fp(FILE* fp, EVP_PKEY* pkey); 670 EVP_PKEY* d2i_PUBKEY_fp(FILE* fp, EVP_PKEY** a); 671 } /+ OPENSSL_NO_STDIO +/ 672 X509* d2i_X509_bio(BIO* bp, X509** x509); 673 int i2d_X509_bio(BIO* bp, X509* x509); 674 X509_CRL* d2i_X509_CRL_bio(BIO* bp, X509_CRL** crl); 675 int i2d_X509_CRL_bio(BIO* bp, X509_CRL* crl); 676 X509_REQ* d2i_X509_REQ_bio(BIO* bp, X509_REQ** req); 677 int i2d_X509_REQ_bio(BIO* bp, X509_REQ* req); 678 679 version(OPENSSL_NO_RSA) {} else { 680 RSA* d2i_RSAPrivateKey_bio(BIO* bp, RSA** rsa); 681 int i2d_RSAPrivateKey_bio(BIO* bp, RSA* rsa); 682 RSA* d2i_RSAPublicKey_bio(BIO* bp, RSA** rsa); 683 int i2d_RSAPublicKey_bio(BIO* bp, RSA* rsa); 684 RSA* d2i_RSA_PUBKEY_bio(BIO* bp, RSA** rsa); 685 int i2d_RSA_PUBKEY_bio(BIO* bp, RSA* rsa); 686 } 687 688 version(OPENSSL_NO_DSA) {} else { 689 DSA* d2i_DSA_PUBKEY_bio(BIO* bp, DSA** dsa); 690 int i2d_DSA_PUBKEY_bio(BIO* bp, DSA* dsa); 691 DSA* d2i_DSAPrivateKey_bio(BIO* bp, DSA** dsa); 692 int i2d_DSAPrivateKey_bio(BIO* bp, DSA* dsa); 693 } 694 695 version(OPENSSL_NO_EC) {} else { 696 EC_KEY* d2i_EC_PUBKEY_bio(BIO* bp, EC_KEY** eckey); 697 int i2d_EC_PUBKEY_bio(BIO* bp, EC_KEY* eckey); 698 EC_KEY* d2i_ECPrivateKey_bio(BIO* bp, EC_KEY** eckey); 699 int i2d_ECPrivateKey_bio(BIO* bp, EC_KEY* eckey); 700 } 701 702 X509_SIG* d2i_PKCS8_bio(BIO* bp, X509_SIG** p8); 703 int i2d_PKCS8_bio(BIO* bp, X509_SIG* p8); 704 PKCS8_PRIV_KEY_INFO* d2i_PKCS8_PRIV_KEY_INFO_bio( 705 BIO* bp, 706 PKCS8_PRIV_KEY_INFO** p8inf); 707 int i2d_PKCS8_PRIV_KEY_INFO_bio(BIO* bp, PKCS8_PRIV_KEY_INFO* p8inf); 708 int i2d_PKCS8PrivateKeyInfo_bio(BIO* bp, EVP_PKEY* key); 709 int i2d_PrivateKey_bio(BIO* bp, EVP_PKEY* pkey); 710 EVP_PKEY* d2i_PrivateKey_bio(BIO* bp, EVP_PKEY** a); 711 int i2d_PUBKEY_bio(BIO* bp, EVP_PKEY* pkey); 712 EVP_PKEY* d2i_PUBKEY_bio(BIO* bp, EVP_PKEY** a); 713 714 X509* X509_dup(X509* x509); 715 X509_ATTRIBUTE* X509_ATTRIBUTE_dup(X509_ATTRIBUTE* xa); 716 X509_EXTENSION* X509_EXTENSION_dup(X509_EXTENSION* ex); 717 X509_CRL* X509_CRL_dup(X509_CRL* crl); 718 X509_REVOKED* X509_REVOKED_dup(X509_REVOKED* rev); 719 X509_REQ* X509_REQ_dup(X509_REQ* req); 720 X509_ALGOR* X509_ALGOR_dup(X509_ALGOR* xn); 721 int X509_ALGOR_set0(X509_ALGOR* alg, ASN1_OBJECT* aobj, int ptype, void* pval); 722 void X509_ALGOR_get0( 723 const(ASN1_OBJECT*)* paobj, 724 int* pptype, 725 const(void*)* ppval, 726 const(X509_ALGOR)* algor); 727 void X509_ALGOR_set_md(X509_ALGOR* alg, const(EVP_MD)* md); 728 int X509_ALGOR_cmp(const(X509_ALGOR)* a, const(X509_ALGOR)* b); 729 730 X509_NAME* X509_NAME_dup(X509_NAME* xn); 731 X509_NAME_ENTRY* X509_NAME_ENTRY_dup(X509_NAME_ENTRY* ne); 732 733 int X509_cmp_time(const(ASN1_TIME)* s, time_t* t); 734 int X509_cmp_current_time(const(ASN1_TIME)* s); 735 ASN1_TIME* X509_time_adj(ASN1_TIME* s, c_long adj, time_t* t); 736 ASN1_TIME* X509_time_adj_ex( 737 ASN1_TIME* s, 738 int offset_day, 739 c_long offset_sec, 740 time_t* t); 741 ASN1_TIME* X509_gmtime_adj(ASN1_TIME* s, c_long adj); 742 743 const(char)* X509_get_default_cert_area(); 744 const(char)* X509_get_default_cert_dir(); 745 const(char)* X509_get_default_cert_file(); 746 const(char)* X509_get_default_cert_dir_env(); 747 const(char)* X509_get_default_cert_file_env(); 748 const(char)* X509_get_default_private_dir(); 749 750 X509_REQ* X509_to_X509_REQ(X509* x, EVP_PKEY* pkey, const(EVP_MD)* md); 751 X509* X509_REQ_to_X509(X509_REQ* r, int days, EVP_PKEY* pkey); 752 753 X509_ALGOR* X509_ALGOR_new(); 754 void X509_ALGOR_free(X509_ALGOR* a); 755 X509_ALGOR* d2i_X509_ALGOR(X509_ALGOR** a, const(ubyte*)* in_, c_long len); 756 int i2d_X509_ALGOR(X509_ALGOR* a, ubyte** out_); 757 extern __gshared const ASN1_ITEM X509_ALGOR_it; 758 X509_ALGORS* d2i_X509_ALGORS(X509_ALGORS** a, const(ubyte*)* in_, c_long len); 759 int i2d_X509_ALGORS(X509_ALGORS* a, ubyte** out_); 760 extern __gshared const ASN1_ITEM X509_ALGORS_it; 761 X509_VAL* X509_VAL_new(); 762 void X509_VAL_free(X509_VAL* a); 763 X509_VAL* d2i_X509_VAL(X509_VAL** a, const(ubyte*)* in_, c_long len); 764 int i2d_X509_VAL(X509_VAL* a, ubyte** out_); 765 extern __gshared const ASN1_ITEM X509_VAL_it; 766 767 X509_PUBKEY* X509_PUBKEY_new(); 768 void X509_PUBKEY_free(X509_PUBKEY* a); 769 X509_PUBKEY* d2i_X509_PUBKEY(X509_PUBKEY** a, const(ubyte*)* in_, c_long len); 770 int i2d_X509_PUBKEY(X509_PUBKEY* a, ubyte** out_); 771 extern __gshared const ASN1_ITEM X509_PUBKEY_it; 772 773 int X509_PUBKEY_set(X509_PUBKEY** x, EVP_PKEY* pkey); 774 EVP_PKEY* X509_PUBKEY_get0(X509_PUBKEY* key); 775 EVP_PKEY* X509_PUBKEY_get(X509_PUBKEY* key); 776 int X509_get_pubkey_parameters(EVP_PKEY* pkey, stack_st_X509* chain); 777 c_long X509_get_pathlen(X509* x); 778 int i2d_PUBKEY(EVP_PKEY* a, ubyte** pp); 779 EVP_PKEY* d2i_PUBKEY(EVP_PKEY** a, const(ubyte*)* pp, c_long length); 780 781 version(OPENSSL_NO_RSA) {} else { 782 int i2d_RSA_PUBKEY(RSA* a, ubyte** pp); 783 RSA* d2i_RSA_PUBKEY(RSA** a, const(ubyte*)* pp, c_long length); 784 } 785 786 version(OPENSSL_NO_DSA) {} else { 787 int i2d_DSA_PUBKEY(DSA* a, ubyte** pp); 788 DSA* d2i_DSA_PUBKEY(DSA** a, const(ubyte*)* pp, c_long length); 789 } 790 791 version(OPENSSL_NO_EC) {} else { 792 int i2d_EC_PUBKEY(EC_KEY* a, ubyte** pp); 793 EC_KEY* d2i_EC_PUBKEY(EC_KEY** a, const(ubyte*)* pp, c_long length); 794 } 795 796 X509_SIG* X509_SIG_new(); 797 void X509_SIG_free(X509_SIG* a); 798 X509_SIG* d2i_X509_SIG(X509_SIG** a, const(ubyte*)* in_, c_long len); 799 int i2d_X509_SIG(X509_SIG* a, ubyte** out_); 800 extern __gshared const ASN1_ITEM X509_SIG_it; 801 void X509_SIG_get0( 802 const(X509_SIG)* sig, 803 const(X509_ALGOR*)* palg, 804 const(ASN1_OCTET_STRING*)* pdigest); 805 void X509_SIG_getm( 806 X509_SIG* sig, 807 X509_ALGOR** palg, 808 ASN1_OCTET_STRING** pdigest); 809 810 X509_REQ_INFO* X509_REQ_INFO_new(); 811 void X509_REQ_INFO_free(X509_REQ_INFO* a); 812 X509_REQ_INFO* d2i_X509_REQ_INFO(X509_REQ_INFO** a, const(ubyte*)* in_, c_long len); 813 int i2d_X509_REQ_INFO(X509_REQ_INFO* a, ubyte** out_); 814 extern __gshared const ASN1_ITEM X509_REQ_INFO_it; 815 X509_REQ* X509_REQ_new(); 816 void X509_REQ_free(X509_REQ* a); 817 X509_REQ* d2i_X509_REQ(X509_REQ** a, const(ubyte*)* in_, c_long len); 818 int i2d_X509_REQ(X509_REQ* a, ubyte** out_); 819 extern __gshared const ASN1_ITEM X509_REQ_it; 820 821 X509_ATTRIBUTE* X509_ATTRIBUTE_new(); 822 void X509_ATTRIBUTE_free(X509_ATTRIBUTE* a); 823 X509_ATTRIBUTE* d2i_X509_ATTRIBUTE(X509_ATTRIBUTE** a, const(ubyte*)* in_, c_long len); 824 int i2d_X509_ATTRIBUTE(X509_ATTRIBUTE* a, ubyte** out_); 825 extern __gshared const ASN1_ITEM X509_ATTRIBUTE_it; 826 X509_ATTRIBUTE* X509_ATTRIBUTE_create(int nid, int atrtype, void* value); 827 828 X509_EXTENSION* X509_EXTENSION_new(); 829 void X509_EXTENSION_free(X509_EXTENSION* a); 830 X509_EXTENSION* d2i_X509_EXTENSION(X509_EXTENSION** a, const(ubyte*)* in_, c_long len); 831 int i2d_X509_EXTENSION(X509_EXTENSION* a, ubyte** out_); 832 extern __gshared const ASN1_ITEM X509_EXTENSION_it; 833 X509_EXTENSIONS* d2i_X509_EXTENSIONS(X509_EXTENSIONS** a, const(ubyte*)* in_, c_long len); 834 int i2d_X509_EXTENSIONS(X509_EXTENSIONS* a, ubyte** out_); 835 extern __gshared const ASN1_ITEM X509_EXTENSIONS_it; 836 837 X509_NAME_ENTRY* X509_NAME_ENTRY_new(); 838 void X509_NAME_ENTRY_free(X509_NAME_ENTRY* a); 839 X509_NAME_ENTRY* d2i_X509_NAME_ENTRY(X509_NAME_ENTRY** a, const(ubyte*)* in_, c_long len); 840 int i2d_X509_NAME_ENTRY(X509_NAME_ENTRY* a, ubyte** out_); 841 extern __gshared const ASN1_ITEM X509_NAME_ENTRY_it; 842 843 X509_NAME* X509_NAME_new(); 844 void X509_NAME_free(X509_NAME* a); 845 X509_NAME* d2i_X509_NAME(X509_NAME** a, const(ubyte*)* in_, c_long len); 846 int i2d_X509_NAME(X509_NAME* a, ubyte** out_); 847 extern __gshared const ASN1_ITEM X509_NAME_it; 848 849 int X509_NAME_set(X509_NAME** xn, X509_NAME* name); 850 851 X509_CINF* X509_CINF_new(); 852 void X509_CINF_free(X509_CINF* a); 853 X509_CINF* d2i_X509_CINF(X509_CINF** a, const(ubyte*)* in_, c_long len); 854 int i2d_X509_CINF(X509_CINF* a, ubyte** out_); 855 extern __gshared const ASN1_ITEM X509_CINF_it; 856 857 X509* X509_new(); 858 void X509_free(X509* a); 859 X509* d2i_X509(X509** a, const(ubyte*)* in_, c_long len); 860 int i2d_X509(X509* a, ubyte** out_); 861 extern __gshared const ASN1_ITEM X509_it; 862 X509_CERT_AUX* X509_CERT_AUX_new(); 863 void X509_CERT_AUX_free(X509_CERT_AUX* a); 864 X509_CERT_AUX* d2i_X509_CERT_AUX(X509_CERT_AUX** a, const(ubyte*)* in_, c_long len); 865 int i2d_X509_CERT_AUX(X509_CERT_AUX* a, ubyte** out_); 866 extern __gshared const ASN1_ITEM X509_CERT_AUX_it; 867 868 static if (OPENSSL_VERSION_BEFORE(1, 1, 0)) 869 { 870 int X509_get_ex_new_index(c_long argl, void* argp, CRYPTO_EX_new* new_func, 871 CRYPTO_EX_dup* dup_func, CRYPTO_EX_free* free_func); 872 } 873 else 874 { 875 extern (D) auto X509_get_ex_new_index () (c_long l, void* p, CRYPTO_EX_new* newf, 876 CRYPTO_EX_dup* dupf, CRYPTO_EX_free* freef) 877 { 878 return CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_X509, l, p, newf, dupf, freef); 879 } 880 } 881 882 int X509_set_ex_data(X509* r, int idx, void* arg); 883 void* X509_get_ex_data(X509* r, int idx); 884 int i2d_X509_AUX(X509* a, ubyte** pp); 885 X509* d2i_X509_AUX(X509** a, const(ubyte*)* pp, c_long length); 886 887 int i2d_re_X509_tbs(X509* x, ubyte** pp); 888 889 void X509_get0_signature( 890 const(ASN1_BIT_STRING*)* psig, 891 const(X509_ALGOR*)* palg, 892 const(X509)* x); 893 int X509_get_signature_nid(const(X509)* x); 894 895 int X509_trusted(const(X509)* x); 896 int X509_alias_set1(X509* x, const(ubyte)* name, int len); 897 int X509_keyid_set1(X509* x, const(ubyte)* id, int len); 898 ubyte* X509_alias_get0(X509* x, int* len); 899 ubyte* X509_keyid_get0(X509* x, int* len); 900 int function(int, X509*, int, int function(int, X509*, int) trust) X509_TRUST_set_default( 901 int, 902 X509*, 903 int, 904 int function(int, X509*, int) trust); 905 int X509_TRUST_set(int* t, int trust); 906 int X509_add1_trust_object(X509* x, const(ASN1_OBJECT)* obj); 907 int X509_add1_reject_object(X509* x, const(ASN1_OBJECT)* obj); 908 void X509_trust_clear(X509* x); 909 void X509_reject_clear(X509* x); 910 911 stack_st_ASN1_OBJECT* X509_get0_trust_objects(X509* x); 912 stack_st_ASN1_OBJECT* X509_get0_reject_objects(X509* x); 913 914 X509_REVOKED* X509_REVOKED_new(); 915 void X509_REVOKED_free(X509_REVOKED* a); 916 X509_REVOKED* d2i_X509_REVOKED(X509_REVOKED** a, const(ubyte*)* in_, c_long len); 917 int i2d_X509_REVOKED(X509_REVOKED* a, ubyte** out_); 918 extern __gshared const ASN1_ITEM X509_REVOKED_it; 919 X509_CRL_INFO* X509_CRL_INFO_new(); 920 void X509_CRL_INFO_free(X509_CRL_INFO* a); 921 X509_CRL_INFO* d2i_X509_CRL_INFO(X509_CRL_INFO** a, const(ubyte*)* in_, c_long len); 922 int i2d_X509_CRL_INFO(X509_CRL_INFO* a, ubyte** out_); 923 extern __gshared const ASN1_ITEM X509_CRL_INFO_it; 924 X509_CRL* X509_CRL_new(); 925 void X509_CRL_free(X509_CRL* a); 926 X509_CRL* d2i_X509_CRL(X509_CRL** a, const(ubyte*)* in_, c_long len); 927 int i2d_X509_CRL(X509_CRL* a, ubyte** out_); 928 extern __gshared const ASN1_ITEM X509_CRL_it; 929 930 int X509_CRL_add0_revoked(X509_CRL* crl, X509_REVOKED* rev); 931 int X509_CRL_get0_by_serial( 932 X509_CRL* crl, 933 X509_REVOKED** ret, 934 ASN1_INTEGER* serial); 935 int X509_CRL_get0_by_cert(X509_CRL* crl, X509_REVOKED** ret, X509* x); 936 937 X509_PKEY* X509_PKEY_new(); 938 void X509_PKEY_free(X509_PKEY* a); 939 940 NETSCAPE_SPKI* NETSCAPE_SPKI_new(); 941 void NETSCAPE_SPKI_free(NETSCAPE_SPKI* a); 942 NETSCAPE_SPKI* d2i_NETSCAPE_SPKI(NETSCAPE_SPKI** a, const(ubyte*)* in_, c_long len); 943 int i2d_NETSCAPE_SPKI(NETSCAPE_SPKI* a, ubyte** out_); 944 extern __gshared const ASN1_ITEM NETSCAPE_SPKI_it; 945 NETSCAPE_SPKAC* NETSCAPE_SPKAC_new(); 946 void NETSCAPE_SPKAC_free(NETSCAPE_SPKAC* a); 947 NETSCAPE_SPKAC* d2i_NETSCAPE_SPKAC(NETSCAPE_SPKAC** a, const(ubyte*)* in_, c_long len); 948 int i2d_NETSCAPE_SPKAC(NETSCAPE_SPKAC* a, ubyte** out_); 949 extern __gshared const ASN1_ITEM NETSCAPE_SPKAC_it; 950 NETSCAPE_CERT_SEQUENCE* NETSCAPE_CERT_SEQUENCE_new(); 951 void NETSCAPE_CERT_SEQUENCE_free(NETSCAPE_CERT_SEQUENCE* a); 952 NETSCAPE_CERT_SEQUENCE* d2i_NETSCAPE_CERT_SEQUENCE(NETSCAPE_CERT_SEQUENCE** a, const(ubyte*)* in_, c_long len); 953 int i2d_NETSCAPE_CERT_SEQUENCE(NETSCAPE_CERT_SEQUENCE* a, ubyte** out_); 954 extern __gshared const ASN1_ITEM NETSCAPE_CERT_SEQUENCE_it; 955 956 X509_INFO* X509_INFO_new(); 957 void X509_INFO_free(X509_INFO* a); 958 char* X509_NAME_oneline(const(X509_NAME)* a, char* buf, int size); 959 960 int ASN1_verify( 961 int function() i2d, 962 X509_ALGOR* algor1, 963 ASN1_BIT_STRING* signature, 964 char* data, 965 EVP_PKEY* pkey); 966 967 int ASN1_digest( 968 int function() i2d, 969 const(EVP_MD)* type, 970 char* data, 971 ubyte* md, 972 uint* len); 973 974 int ASN1_sign( 975 int function() i2d, 976 X509_ALGOR* algor1, 977 X509_ALGOR* algor2, 978 ASN1_BIT_STRING* signature, 979 char* data, 980 EVP_PKEY* pkey, 981 const(EVP_MD)* type); 982 983 int ASN1_item_digest( 984 const(ASN1_ITEM)* it, 985 const(EVP_MD)* type, 986 void* data, 987 ubyte* md, 988 uint* len); 989 990 int ASN1_item_verify( 991 const(ASN1_ITEM)* it, 992 X509_ALGOR* algor1, 993 ASN1_BIT_STRING* signature, 994 void* data, 995 EVP_PKEY* pkey); 996 997 int ASN1_item_sign( 998 const(ASN1_ITEM)* it, 999 X509_ALGOR* algor1, 1000 X509_ALGOR* algor2, 1001 ASN1_BIT_STRING* signature, 1002 void* data, 1003 EVP_PKEY* pkey, 1004 const(EVP_MD)* type); 1005 int ASN1_item_sign_ctx( 1006 const(ASN1_ITEM)* it, 1007 X509_ALGOR* algor1, 1008 X509_ALGOR* algor2, 1009 ASN1_BIT_STRING* signature, 1010 void* asn, 1011 EVP_MD_CTX* ctx); 1012 1013 c_long X509_get_version(const(X509)* x); 1014 int X509_set_version(X509* x, c_long version_); 1015 int X509_set_serialNumber(X509* x, ASN1_INTEGER* serial); 1016 ASN1_INTEGER* X509_get_serialNumber(X509* x); 1017 const(ASN1_INTEGER)* X509_get0_serialNumber(const(X509)* x); 1018 int X509_set_issuer_name(X509* x, X509_NAME* name); 1019 X509_NAME* X509_get_issuer_name(const(X509)* a); 1020 int X509_set_subject_name(X509* x, X509_NAME* name); 1021 X509_NAME* X509_get_subject_name(const(X509)* a); 1022 const(ASN1_TIME)* X509_get0_notBefore(const(X509)* x); 1023 ASN1_TIME* X509_getm_notBefore(const(X509)* x); 1024 int X509_set1_notBefore(X509* x, const(ASN1_TIME)* tm); 1025 const(ASN1_TIME)* X509_get0_notAfter(const(X509)* x); 1026 ASN1_TIME* X509_getm_notAfter(const(X509)* x); 1027 int X509_set1_notAfter(X509* x, const(ASN1_TIME)* tm); 1028 int X509_set_pubkey(X509* x, EVP_PKEY* pkey); 1029 int X509_up_ref(X509* x); 1030 int X509_get_signature_type(const(X509)* x); 1031 1032 alias X509_get_notBefore = X509_getm_notBefore; 1033 alias X509_get_notAfter = X509_getm_notAfter; 1034 alias X509_set_notBefore = X509_set1_notBefore; 1035 alias X509_set_notAfter = X509_set1_notAfter; 1036 1037 /* 1038 * This one is only used so that a binary form can output, as in 1039 * i2d_X509_NAME(X509_get_X509_PUBKEY(x), &buf) 1040 */ 1041 X509_PUBKEY* X509_get_X509_PUBKEY(const(X509)* x); 1042 const(stack_st_X509_EXTENSION)* X509_get0_extensions(const(X509)* x); 1043 void X509_get0_uids( 1044 const(X509)* x, 1045 const(ASN1_BIT_STRING*)* piuid, 1046 const(ASN1_BIT_STRING*)* psuid); 1047 const(X509_ALGOR)* X509_get0_tbs_sigalg(const(X509)* x); 1048 1049 EVP_PKEY* X509_get0_pubkey(const(X509)* x); 1050 EVP_PKEY* X509_get_pubkey(X509* x); 1051 ASN1_BIT_STRING* X509_get0_pubkey_bitstr(const(X509)* x); 1052 int X509_certificate_type(const(X509)* x, const(EVP_PKEY)* pubkey); 1053 1054 c_long X509_REQ_get_version(const(X509_REQ)* req); 1055 int X509_REQ_set_version(X509_REQ* x, c_long version_); 1056 X509_NAME* X509_REQ_get_subject_name(const(X509_REQ)* req); 1057 int X509_REQ_set_subject_name(X509_REQ* req, X509_NAME* name); 1058 void X509_REQ_get0_signature( 1059 const(X509_REQ)* req, 1060 const(ASN1_BIT_STRING*)* psig, 1061 const(X509_ALGOR*)* palg); 1062 int X509_REQ_get_signature_nid(const(X509_REQ)* req); 1063 int i2d_re_X509_REQ_tbs(X509_REQ* req, ubyte** pp); 1064 int X509_REQ_set_pubkey(X509_REQ* x, EVP_PKEY* pkey); 1065 EVP_PKEY* X509_REQ_get_pubkey(X509_REQ* req); 1066 EVP_PKEY* X509_REQ_get0_pubkey(X509_REQ* req); 1067 X509_PUBKEY* X509_REQ_get_X509_PUBKEY(X509_REQ* req); 1068 int X509_REQ_extension_nid(int nid); 1069 int* X509_REQ_get_extension_nids(); 1070 void X509_REQ_set_extension_nids(int* nids); 1071 stack_st_X509_EXTENSION* X509_REQ_get_extensions(X509_REQ* req); 1072 int X509_REQ_add_extensions_nid( 1073 X509_REQ* req, 1074 stack_st_X509_EXTENSION* exts, 1075 int nid); 1076 int X509_REQ_add_extensions(X509_REQ* req, stack_st_X509_EXTENSION* exts); 1077 int X509_REQ_get_attr_count(const(X509_REQ)* req); 1078 int X509_REQ_get_attr_by_NID(const(X509_REQ)* req, int nid, int lastpos); 1079 int X509_REQ_get_attr_by_OBJ( 1080 const(X509_REQ)* req, 1081 const(ASN1_OBJECT)* obj, 1082 int lastpos); 1083 X509_ATTRIBUTE* X509_REQ_get_attr(const(X509_REQ)* req, int loc); 1084 X509_ATTRIBUTE* X509_REQ_delete_attr(X509_REQ* req, int loc); 1085 int X509_REQ_add1_attr(X509_REQ* req, X509_ATTRIBUTE* attr); 1086 int X509_REQ_add1_attr_by_OBJ( 1087 X509_REQ* req, 1088 const(ASN1_OBJECT)* obj, 1089 int type, 1090 const(ubyte)* bytes, 1091 int len); 1092 int X509_REQ_add1_attr_by_NID( 1093 X509_REQ* req, 1094 int nid, 1095 int type, 1096 const(ubyte)* bytes, 1097 int len); 1098 int X509_REQ_add1_attr_by_txt( 1099 X509_REQ* req, 1100 const(char)* attrname, 1101 int type, 1102 const(ubyte)* bytes, 1103 int len); 1104 1105 int X509_CRL_set_version(X509_CRL* x, c_long version_); 1106 int X509_CRL_set_issuer_name(X509_CRL* x, X509_NAME* name); 1107 int X509_CRL_set1_lastUpdate(X509_CRL* x, const(ASN1_TIME)* tm); 1108 int X509_CRL_set1_nextUpdate(X509_CRL* x, const(ASN1_TIME)* tm); 1109 int X509_CRL_sort(X509_CRL* crl); 1110 int X509_CRL_up_ref(X509_CRL* crl); 1111 1112 alias X509_CRL_set_lastUpdate = X509_CRL_set1_lastUpdate; 1113 alias X509_CRL_set_nextUpdate = X509_CRL_set1_nextUpdate; 1114 1115 c_long X509_CRL_get_version(const(X509_CRL)* crl); 1116 const(ASN1_TIME)* X509_CRL_get0_lastUpdate(const(X509_CRL)* crl); 1117 const(ASN1_TIME)* X509_CRL_get0_nextUpdate(const(X509_CRL)* crl); 1118 ASN1_TIME* X509_CRL_get_lastUpdate(X509_CRL* crl); 1119 ASN1_TIME* X509_CRL_get_nextUpdate(X509_CRL* crl); 1120 X509_NAME* X509_CRL_get_issuer(const(X509_CRL)* crl); 1121 const(stack_st_X509_EXTENSION)* X509_CRL_get0_extensions(const(X509_CRL)* crl); 1122 stack_st_X509_REVOKED* X509_CRL_get_REVOKED(X509_CRL* crl); 1123 void X509_CRL_get0_signature( 1124 const(X509_CRL)* crl, 1125 const(ASN1_BIT_STRING*)* psig, 1126 const(X509_ALGOR*)* palg); 1127 int X509_CRL_get_signature_nid(const(X509_CRL)* crl); 1128 int i2d_re_X509_CRL_tbs(X509_CRL* req, ubyte** pp); 1129 1130 const(ASN1_INTEGER)* X509_REVOKED_get0_serialNumber(const(X509_REVOKED)* x); 1131 int X509_REVOKED_set_serialNumber(X509_REVOKED* x, ASN1_INTEGER* serial); 1132 const(ASN1_TIME)* X509_REVOKED_get0_revocationDate(const(X509_REVOKED)* x); 1133 int X509_REVOKED_set_revocationDate(X509_REVOKED* r, ASN1_TIME* tm); 1134 const(stack_st_X509_EXTENSION)* X509_REVOKED_get0_extensions( 1135 const(X509_REVOKED)* r); 1136 1137 X509_CRL* X509_CRL_diff( 1138 X509_CRL* base, 1139 X509_CRL* newer, 1140 EVP_PKEY* skey, 1141 const(EVP_MD)* md, 1142 uint flags); 1143 1144 int X509_REQ_check_private_key(X509_REQ* x509, EVP_PKEY* pkey); 1145 1146 int X509_check_private_key(const(X509)* x509, const(EVP_PKEY)* pkey); 1147 int X509_chain_check_suiteb( 1148 int* perror_depth, 1149 X509* x, 1150 stack_st_X509* chain, 1151 c_ulong flags); 1152 int X509_CRL_check_suiteb(X509_CRL* crl, EVP_PKEY* pk, c_ulong flags); 1153 stack_st_X509* X509_chain_up_ref(stack_st_X509* chain); 1154 1155 int X509_issuer_and_serial_cmp(const(X509)* a, const(X509)* b); 1156 c_ulong X509_issuer_and_serial_hash(X509* a); 1157 1158 int X509_issuer_name_cmp(const(X509)* a, const(X509)* b); 1159 c_ulong X509_issuer_name_hash(X509* a); 1160 1161 int X509_subject_name_cmp(const(X509)* a, const(X509)* b); 1162 c_ulong X509_subject_name_hash(X509* x); 1163 1164 version(OPENSSL_NO_MD5) {} else { 1165 c_ulong X509_issuer_name_hash_old(X509* a); 1166 c_ulong X509_subject_name_hash_old(X509* x); 1167 } 1168 1169 int X509_cmp(const(X509)* a, const(X509)* b); 1170 int X509_NAME_cmp(const(X509_NAME)* a, const(X509_NAME)* b); 1171 c_ulong X509_NAME_hash(X509_NAME* x); 1172 c_ulong X509_NAME_hash_old(X509_NAME* x); 1173 1174 int X509_CRL_cmp(const(X509_CRL)* a, const(X509_CRL)* b); 1175 int X509_CRL_match(const(X509_CRL)* a, const(X509_CRL)* b); 1176 int X509_aux_print(BIO* out_, X509* x, int indent); 1177 1178 version(OPENSSL_NO_STDIO) {} else { 1179 int X509_print_ex_fp(FILE* bp, X509* x, c_ulong nmflag, c_ulong cflag); 1180 int X509_print_fp(FILE* bp, X509* x); 1181 int X509_CRL_print_fp(FILE* bp, X509_CRL* x); 1182 int X509_REQ_print_fp(FILE* bp, X509_REQ* req); 1183 int X509_NAME_print_ex_fp( 1184 FILE* fp, 1185 const(X509_NAME)* nm, 1186 int indent, 1187 c_ulong flags); 1188 } 1189 1190 int X509_NAME_print(BIO* bp, const(X509_NAME)* name, int obase); 1191 int X509_NAME_print_ex( 1192 BIO* out_, 1193 const(X509_NAME)* nm, 1194 int indent, 1195 c_ulong flags); 1196 int X509_print_ex(BIO* bp, X509* x, c_ulong nmflag, c_ulong cflag); 1197 int X509_print(BIO* bp, X509* x); 1198 int X509_ocspid_print(BIO* bp, X509* x); 1199 int X509_CRL_print(BIO* bp, X509_CRL* x); 1200 int X509_REQ_print_ex(BIO* bp, X509_REQ* x, c_ulong nmflag, c_ulong cflag); 1201 int X509_REQ_print(BIO* bp, X509_REQ* req); 1202 1203 int X509_NAME_entry_count(const(X509_NAME)* name); 1204 int X509_NAME_get_text_by_NID(X509_NAME* name, int nid, char* buf, int len); 1205 int X509_NAME_get_text_by_OBJ( 1206 X509_NAME* name, 1207 const(ASN1_OBJECT)* obj, 1208 char* buf, 1209 int len); 1210 1211 /* 1212 * NOTE: you should be passing -1, not 0 as lastpos. The functions that use 1213 * lastpos, search after that position on. 1214 */ 1215 int X509_NAME_get_index_by_NID(X509_NAME* name, int nid, int lastpos); 1216 int X509_NAME_get_index_by_OBJ( 1217 X509_NAME* name, 1218 const(ASN1_OBJECT)* obj, 1219 int lastpos); 1220 X509_NAME_ENTRY* X509_NAME_get_entry(const(X509_NAME)* name, int loc); 1221 X509_NAME_ENTRY* X509_NAME_delete_entry(X509_NAME* name, int loc); 1222 int X509_NAME_add_entry( 1223 X509_NAME* name, 1224 const(X509_NAME_ENTRY)* ne, 1225 int loc, 1226 int set); 1227 int X509_NAME_add_entry_by_OBJ( 1228 X509_NAME* name, 1229 const(ASN1_OBJECT)* obj, 1230 int type, 1231 const(ubyte)* bytes, 1232 int len, 1233 int loc, 1234 int set); 1235 int X509_NAME_add_entry_by_NID( 1236 X509_NAME* name, 1237 int nid, 1238 int type, 1239 const(ubyte)* bytes, 1240 int len, 1241 int loc, 1242 int set); 1243 X509_NAME_ENTRY* X509_NAME_ENTRY_create_by_txt( 1244 X509_NAME_ENTRY** ne, 1245 const(char)* field, 1246 int type, 1247 const(ubyte)* bytes, 1248 int len); 1249 X509_NAME_ENTRY* X509_NAME_ENTRY_create_by_NID( 1250 X509_NAME_ENTRY** ne, 1251 int nid, 1252 int type, 1253 const(ubyte)* bytes, 1254 int len); 1255 int X509_NAME_add_entry_by_txt( 1256 X509_NAME* name, 1257 const(char)* field, 1258 int type, 1259 const(ubyte)* bytes, 1260 int len, 1261 int loc, 1262 int set); 1263 X509_NAME_ENTRY* X509_NAME_ENTRY_create_by_OBJ( 1264 X509_NAME_ENTRY** ne, 1265 const(ASN1_OBJECT)* obj, 1266 int type, 1267 const(ubyte)* bytes, 1268 int len); 1269 int X509_NAME_ENTRY_set_object(X509_NAME_ENTRY* ne, const(ASN1_OBJECT)* obj); 1270 int X509_NAME_ENTRY_set_data( 1271 X509_NAME_ENTRY* ne, 1272 int type, 1273 const(ubyte)* bytes, 1274 int len); 1275 ASN1_OBJECT* X509_NAME_ENTRY_get_object(const(X509_NAME_ENTRY)* ne); 1276 ASN1_STRING* X509_NAME_ENTRY_get_data(const(X509_NAME_ENTRY)* ne); 1277 int X509_NAME_ENTRY_set(const(X509_NAME_ENTRY)* ne); 1278 1279 int X509_NAME_get0_der(X509_NAME* nm, const(ubyte*)* pder, size_t* pderlen); 1280 1281 int X509v3_get_ext_count(const(stack_st_X509_EXTENSION)* x); 1282 int X509v3_get_ext_by_NID( 1283 const(stack_st_X509_EXTENSION)* x, 1284 int nid, 1285 int lastpos); 1286 int X509v3_get_ext_by_OBJ( 1287 const(stack_st_X509_EXTENSION)* x, 1288 const(ASN1_OBJECT)* obj, 1289 int lastpos); 1290 int X509v3_get_ext_by_critical( 1291 const(stack_st_X509_EXTENSION)* x, 1292 int crit, 1293 int lastpos); 1294 X509_EXTENSION* X509v3_get_ext(const(stack_st_X509_EXTENSION)* x, int loc); 1295 X509_EXTENSION* X509v3_delete_ext(stack_st_X509_EXTENSION* x, int loc); 1296 stack_st_X509_EXTENSION* X509v3_add_ext( 1297 stack_st_X509_EXTENSION** x, 1298 X509_EXTENSION* ex, 1299 int loc); 1300 1301 int X509_get_ext_count(const(X509)* x); 1302 int X509_get_ext_by_NID(const(X509)* x, int nid, int lastpos); 1303 int X509_get_ext_by_OBJ(const(X509)* x, const(ASN1_OBJECT)* obj, int lastpos); 1304 int X509_get_ext_by_critical(const(X509)* x, int crit, int lastpos); 1305 X509_EXTENSION* X509_get_ext(const(X509)* x, int loc); 1306 X509_EXTENSION* X509_delete_ext(X509* x, int loc); 1307 int X509_add_ext(X509* x, X509_EXTENSION* ex, int loc); 1308 void* X509_get_ext_d2i(const(X509)* x, int nid, int* crit, int* idx); 1309 int X509_add1_ext_i2d(X509* x, int nid, void* value, int crit, c_ulong flags); 1310 1311 int X509_CRL_get_ext_count(const(X509_CRL)* x); 1312 int X509_CRL_get_ext_by_NID(const(X509_CRL)* x, int nid, int lastpos); 1313 int X509_CRL_get_ext_by_OBJ( 1314 const(X509_CRL)* x, 1315 const(ASN1_OBJECT)* obj, 1316 int lastpos); 1317 int X509_CRL_get_ext_by_critical(const(X509_CRL)* x, int crit, int lastpos); 1318 X509_EXTENSION* X509_CRL_get_ext(const(X509_CRL)* x, int loc); 1319 X509_EXTENSION* X509_CRL_delete_ext(X509_CRL* x, int loc); 1320 int X509_CRL_add_ext(X509_CRL* x, X509_EXTENSION* ex, int loc); 1321 void* X509_CRL_get_ext_d2i(const(X509_CRL)* x, int nid, int* crit, int* idx); 1322 int X509_CRL_add1_ext_i2d( 1323 X509_CRL* x, 1324 int nid, 1325 void* value, 1326 int crit, 1327 c_ulong flags); 1328 1329 int X509_REVOKED_get_ext_count(const(X509_REVOKED)* x); 1330 int X509_REVOKED_get_ext_by_NID(const(X509_REVOKED)* x, int nid, int lastpos); 1331 int X509_REVOKED_get_ext_by_OBJ( 1332 const(X509_REVOKED)* x, 1333 const(ASN1_OBJECT)* obj, 1334 int lastpos); 1335 int X509_REVOKED_get_ext_by_critical( 1336 const(X509_REVOKED)* x, 1337 int crit, 1338 int lastpos); 1339 X509_EXTENSION* X509_REVOKED_get_ext(const(X509_REVOKED)* x, int loc); 1340 X509_EXTENSION* X509_REVOKED_delete_ext(X509_REVOKED* x, int loc); 1341 int X509_REVOKED_add_ext(X509_REVOKED* x, X509_EXTENSION* ex, int loc); 1342 void* X509_REVOKED_get_ext_d2i( 1343 const(X509_REVOKED)* x, 1344 int nid, 1345 int* crit, 1346 int* idx); 1347 int X509_REVOKED_add1_ext_i2d( 1348 X509_REVOKED* x, 1349 int nid, 1350 void* value, 1351 int crit, 1352 c_ulong flags); 1353 1354 X509_EXTENSION* X509_EXTENSION_create_by_NID( 1355 X509_EXTENSION** ex, 1356 int nid, 1357 int crit, 1358 ASN1_OCTET_STRING* data); 1359 X509_EXTENSION* X509_EXTENSION_create_by_OBJ( 1360 X509_EXTENSION** ex, 1361 const(ASN1_OBJECT)* obj, 1362 int crit, 1363 ASN1_OCTET_STRING* data); 1364 int X509_EXTENSION_set_object(X509_EXTENSION* ex, const(ASN1_OBJECT)* obj); 1365 int X509_EXTENSION_set_critical(X509_EXTENSION* ex, int crit); 1366 int X509_EXTENSION_set_data(X509_EXTENSION* ex, ASN1_OCTET_STRING* data); 1367 ASN1_OBJECT* X509_EXTENSION_get_object(X509_EXTENSION* ex); 1368 ASN1_OCTET_STRING* X509_EXTENSION_get_data(X509_EXTENSION* ne); 1369 int X509_EXTENSION_get_critical(const(X509_EXTENSION)* ex); 1370 1371 int X509at_get_attr_count(const(stack_st_X509_ATTRIBUTE)* x); 1372 int X509at_get_attr_by_NID( 1373 const(stack_st_X509_ATTRIBUTE)* x, 1374 int nid, 1375 int lastpos); 1376 int X509at_get_attr_by_OBJ( 1377 const(stack_st_X509_ATTRIBUTE)* sk, 1378 const(ASN1_OBJECT)* obj, 1379 int lastpos); 1380 X509_ATTRIBUTE* X509at_get_attr(const(stack_st_X509_ATTRIBUTE)* x, int loc); 1381 X509_ATTRIBUTE* X509at_delete_attr(stack_st_X509_ATTRIBUTE* x, int loc); 1382 stack_st_X509_ATTRIBUTE* X509at_add1_attr( 1383 stack_st_X509_ATTRIBUTE** x, 1384 X509_ATTRIBUTE* attr); 1385 stack_st_X509_ATTRIBUTE* X509at_add1_attr_by_OBJ( 1386 stack_st_X509_ATTRIBUTE** x, 1387 const(ASN1_OBJECT)* obj, 1388 int type, 1389 const(ubyte)* bytes, 1390 int len); 1391 stack_st_X509_ATTRIBUTE* X509at_add1_attr_by_NID( 1392 stack_st_X509_ATTRIBUTE** x, 1393 int nid, 1394 int type, 1395 const(ubyte)* bytes, 1396 int len); 1397 stack_st_X509_ATTRIBUTE* X509at_add1_attr_by_txt( 1398 stack_st_X509_ATTRIBUTE** x, 1399 const(char)* attrname, 1400 int type, 1401 const(ubyte)* bytes, 1402 int len); 1403 void* X509at_get0_data_by_OBJ( 1404 stack_st_X509_ATTRIBUTE* x, 1405 const(ASN1_OBJECT)* obj, 1406 int lastpos, 1407 int type); 1408 X509_ATTRIBUTE* X509_ATTRIBUTE_create_by_NID( 1409 X509_ATTRIBUTE** attr, 1410 int nid, 1411 int atrtype, 1412 const(void)* data, 1413 int len); 1414 X509_ATTRIBUTE* X509_ATTRIBUTE_create_by_OBJ( 1415 X509_ATTRIBUTE** attr, 1416 const(ASN1_OBJECT)* obj, 1417 int atrtype, 1418 const(void)* data, 1419 int len); 1420 X509_ATTRIBUTE* X509_ATTRIBUTE_create_by_txt( 1421 X509_ATTRIBUTE** attr, 1422 const(char)* atrname, 1423 int type, 1424 const(ubyte)* bytes, 1425 int len); 1426 int X509_ATTRIBUTE_set1_object(X509_ATTRIBUTE* attr, const(ASN1_OBJECT)* obj); 1427 int X509_ATTRIBUTE_set1_data( 1428 X509_ATTRIBUTE* attr, 1429 int attrtype, 1430 const(void)* data, 1431 int len); 1432 void* X509_ATTRIBUTE_get0_data( 1433 X509_ATTRIBUTE* attr, 1434 int idx, 1435 int atrtype, 1436 void* data); 1437 int X509_ATTRIBUTE_count(const(X509_ATTRIBUTE)* attr); 1438 ASN1_OBJECT* X509_ATTRIBUTE_get0_object(X509_ATTRIBUTE* attr); 1439 ASN1_TYPE* X509_ATTRIBUTE_get0_type(X509_ATTRIBUTE* attr, int idx); 1440 1441 int EVP_PKEY_get_attr_count(const(EVP_PKEY)* key); 1442 int EVP_PKEY_get_attr_by_NID(const(EVP_PKEY)* key, int nid, int lastpos); 1443 int EVP_PKEY_get_attr_by_OBJ( 1444 const(EVP_PKEY)* key, 1445 const(ASN1_OBJECT)* obj, 1446 int lastpos); 1447 X509_ATTRIBUTE* EVP_PKEY_get_attr(const(EVP_PKEY)* key, int loc); 1448 X509_ATTRIBUTE* EVP_PKEY_delete_attr(EVP_PKEY* key, int loc); 1449 int EVP_PKEY_add1_attr(EVP_PKEY* key, X509_ATTRIBUTE* attr); 1450 int EVP_PKEY_add1_attr_by_OBJ( 1451 EVP_PKEY* key, 1452 const(ASN1_OBJECT)* obj, 1453 int type, 1454 const(ubyte)* bytes, 1455 int len); 1456 int EVP_PKEY_add1_attr_by_NID( 1457 EVP_PKEY* key, 1458 int nid, 1459 int type, 1460 const(ubyte)* bytes, 1461 int len); 1462 int EVP_PKEY_add1_attr_by_txt( 1463 EVP_PKEY* key, 1464 const(char)* attrname, 1465 int type, 1466 const(ubyte)* bytes, 1467 int len); 1468 1469 int X509_verify_cert(X509_STORE_CTX* ctx); 1470 1471 /* lookup a cert from a X509 STACK */ 1472 X509* X509_find_by_issuer_and_serial( 1473 stack_st_X509* sk, 1474 X509_NAME* name, 1475 ASN1_INTEGER* serial); 1476 X509* X509_find_by_subject(stack_st_X509* sk, X509_NAME* name); 1477 1478 PBEPARAM* PBEPARAM_new(); 1479 void PBEPARAM_free(PBEPARAM* a); 1480 PBEPARAM* d2i_PBEPARAM(PBEPARAM** a, const(ubyte*)* in_, c_long len); 1481 int i2d_PBEPARAM(PBEPARAM* a, ubyte** out_); 1482 extern __gshared const ASN1_ITEM PBEPARAM_it; 1483 PBE2PARAM* PBE2PARAM_new(); 1484 void PBE2PARAM_free(PBE2PARAM* a); 1485 PBE2PARAM* d2i_PBE2PARAM(PBE2PARAM** a, const(ubyte*)* in_, c_long len); 1486 int i2d_PBE2PARAM(PBE2PARAM* a, ubyte** out_); 1487 extern __gshared const ASN1_ITEM PBE2PARAM_it; 1488 PBKDF2PARAM* PBKDF2PARAM_new(); 1489 void PBKDF2PARAM_free(PBKDF2PARAM* a); 1490 PBKDF2PARAM* d2i_PBKDF2PARAM(PBKDF2PARAM** a, const(ubyte*)* in_, c_long len); 1491 int i2d_PBKDF2PARAM(PBKDF2PARAM* a, ubyte** out_); 1492 extern __gshared const ASN1_ITEM PBKDF2PARAM_it; 1493 1494 int PKCS5_pbe_set0_algor( 1495 X509_ALGOR* algor, 1496 int alg, 1497 int iter, 1498 const(ubyte)* salt, 1499 int saltlen); 1500 1501 X509_ALGOR* PKCS5_pbe_set(int alg, int iter, const(ubyte)* salt, int saltlen); 1502 X509_ALGOR* PKCS5_pbe2_set( 1503 const(EVP_CIPHER)* cipher, 1504 int iter, 1505 ubyte* salt, 1506 int saltlen); 1507 X509_ALGOR* PKCS5_pbe2_set_iv( 1508 const(EVP_CIPHER)* cipher, 1509 int iter, 1510 ubyte* salt, 1511 int saltlen, 1512 ubyte* aiv, 1513 int prf_nid); 1514 1515 version(OPENSSL_NO_SCRYPT) {} else { 1516 X509_ALGOR* PKCS5_pbe2_set_scrypt( 1517 const(EVP_CIPHER)* cipher, 1518 const(ubyte)* salt, 1519 int saltlen, 1520 ubyte* aiv, 1521 ulong N, 1522 ulong r, 1523 ulong p); 1524 } 1525 1526 X509_ALGOR* PKCS5_pbkdf2_set( 1527 int iter, 1528 ubyte* salt, 1529 int saltlen, 1530 int prf_nid, 1531 int keylen); 1532 1533 /* PKCS#8 utilities */ 1534 1535 PKCS8_PRIV_KEY_INFO* PKCS8_PRIV_KEY_INFO_new(); 1536 void PKCS8_PRIV_KEY_INFO_free(PKCS8_PRIV_KEY_INFO* a); 1537 PKCS8_PRIV_KEY_INFO* d2i_PKCS8_PRIV_KEY_INFO(PKCS8_PRIV_KEY_INFO** a, const(ubyte*)* in_, c_long len); 1538 int i2d_PKCS8_PRIV_KEY_INFO(PKCS8_PRIV_KEY_INFO* a, ubyte** out_); 1539 extern __gshared const ASN1_ITEM PKCS8_PRIV_KEY_INFO_it; 1540 1541 EVP_PKEY* EVP_PKCS82PKEY(const(PKCS8_PRIV_KEY_INFO)* p8); 1542 PKCS8_PRIV_KEY_INFO* EVP_PKEY2PKCS8(EVP_PKEY* pkey); 1543 1544 int PKCS8_pkey_set0( 1545 PKCS8_PRIV_KEY_INFO* priv, 1546 ASN1_OBJECT* aobj, 1547 int version_, 1548 int ptype, 1549 void* pval, 1550 ubyte* penc, 1551 int penclen); 1552 int PKCS8_pkey_get0( 1553 const(ASN1_OBJECT*)* ppkalg, 1554 const(ubyte*)* pk, 1555 int* ppklen, 1556 const(X509_ALGOR*)* pa, 1557 const(PKCS8_PRIV_KEY_INFO)* p8); 1558 1559 const(stack_st_X509_ATTRIBUTE)* PKCS8_pkey_get0_attrs( 1560 const(PKCS8_PRIV_KEY_INFO)* p8); 1561 int PKCS8_pkey_add1_attr_by_NID( 1562 PKCS8_PRIV_KEY_INFO* p8, 1563 int nid, 1564 int type, 1565 const(ubyte)* bytes, 1566 int len); 1567 1568 int X509_PUBKEY_set0_param( 1569 X509_PUBKEY* pub, 1570 ASN1_OBJECT* aobj, 1571 int ptype, 1572 void* pval, 1573 ubyte* penc, 1574 int penclen); 1575 int X509_PUBKEY_get0_param( 1576 ASN1_OBJECT** ppkalg, 1577 const(ubyte*)* pk, 1578 int* ppklen, 1579 X509_ALGOR** pa, 1580 X509_PUBKEY* pub); 1581 1582 int X509_check_trust(X509* x, int id, int flags); 1583 int X509_TRUST_get_count(); 1584 X509_TRUST* X509_TRUST_get0(int idx); 1585 int X509_TRUST_get_by_id(int id); 1586 int X509_TRUST_add( 1587 int id, 1588 int flags, 1589 int function(X509_TRUST*, X509*, int) ck, 1590 const(char)* name, 1591 int arg1, 1592 void* arg2); 1593 void X509_TRUST_cleanup(); 1594 int X509_TRUST_get_flags(const(X509_TRUST)* xp); 1595 char* X509_TRUST_get0_name(const(X509_TRUST)* xp); 1596 int X509_TRUST_get_trust(const(X509_TRUST)* xp); 1597 1598 /* BEGIN ERROR CODES */ 1599 /* 1600 * The following lines are auto generated by the script mkerr.pl. Any changes 1601 * made after this point may be overwritten when the script is next run. 1602 */ 1603 1604 int ERR_load_X509_strings(); 1605 1606 /* Error codes for the X509 functions. */ 1607 1608 /* Function codes. */ 1609 enum X509_F_ADD_CERT_DIR = 100; 1610 enum X509_F_BUILD_CHAIN = 106; 1611 enum X509_F_BY_FILE_CTRL = 101; 1612 enum X509_F_CHECK_NAME_CONSTRAINTS = 149; 1613 enum X509_F_CHECK_POLICY = 145; 1614 enum X509_F_DANE_I2D = 107; 1615 enum X509_F_DIR_CTRL = 102; 1616 enum X509_F_GET_CERT_BY_SUBJECT = 103; 1617 enum X509_F_NETSCAPE_SPKI_B64_DECODE = 129; 1618 enum X509_F_NETSCAPE_SPKI_B64_ENCODE = 130; 1619 enum X509_F_X509AT_ADD1_ATTR = 135; 1620 enum X509_F_X509V3_ADD_EXT = 104; 1621 enum X509_F_X509_ATTRIBUTE_CREATE_BY_NID = 136; 1622 enum X509_F_X509_ATTRIBUTE_CREATE_BY_OBJ = 137; 1623 enum X509_F_X509_ATTRIBUTE_CREATE_BY_TXT = 140; 1624 enum X509_F_X509_ATTRIBUTE_GET0_DATA = 139; 1625 enum X509_F_X509_ATTRIBUTE_SET1_DATA = 138; 1626 enum X509_F_X509_CHECK_PRIVATE_KEY = 128; 1627 enum X509_F_X509_CRL_DIFF = 105; 1628 enum X509_F_X509_CRL_PRINT_FP = 147; 1629 enum X509_F_X509_EXTENSION_CREATE_BY_NID = 108; 1630 enum X509_F_X509_EXTENSION_CREATE_BY_OBJ = 109; 1631 enum X509_F_X509_GET_PUBKEY_PARAMETERS = 110; 1632 enum X509_F_X509_LOAD_CERT_CRL_FILE = 132; 1633 enum X509_F_X509_LOAD_CERT_FILE = 111; 1634 enum X509_F_X509_LOAD_CRL_FILE = 112; 1635 enum X509_F_X509_NAME_ADD_ENTRY = 113; 1636 enum X509_F_X509_NAME_ENTRY_CREATE_BY_NID = 114; 1637 enum X509_F_X509_NAME_ENTRY_CREATE_BY_TXT = 131; 1638 enum X509_F_X509_NAME_ENTRY_SET_OBJECT = 115; 1639 enum X509_F_X509_NAME_ONELINE = 116; 1640 enum X509_F_X509_NAME_PRINT = 117; 1641 enum X509_F_X509_OBJECT_NEW = 150; 1642 enum X509_F_X509_PRINT_EX_FP = 118; 1643 enum X509_F_X509_PUBKEY_DECODE = 148; 1644 enum X509_F_X509_PUBKEY_GET0 = 119; 1645 enum X509_F_X509_PUBKEY_SET = 120; 1646 enum X509_F_X509_REQ_CHECK_PRIVATE_KEY = 144; 1647 enum X509_F_X509_REQ_PRINT_EX = 121; 1648 enum X509_F_X509_REQ_PRINT_FP = 122; 1649 enum X509_F_X509_REQ_TO_X509 = 123; 1650 enum X509_F_X509_STORE_ADD_CERT = 124; 1651 enum X509_F_X509_STORE_ADD_CRL = 125; 1652 enum X509_F_X509_STORE_CTX_GET1_ISSUER = 146; 1653 enum X509_F_X509_STORE_CTX_INIT = 143; 1654 enum X509_F_X509_STORE_CTX_NEW = 142; 1655 enum X509_F_X509_STORE_CTX_PURPOSE_INHERIT = 134; 1656 enum X509_F_X509_TO_X509_REQ = 126; 1657 enum X509_F_X509_TRUST_ADD = 133; 1658 enum X509_F_X509_TRUST_SET = 141; 1659 enum X509_F_X509_VERIFY_CERT = 127; 1660 1661 /* Reason codes. */ 1662 enum X509_R_AKID_MISMATCH = 110; 1663 enum X509_R_BAD_SELECTOR = 133; 1664 enum X509_R_BAD_X509_FILETYPE = 100; 1665 enum X509_R_BASE64_DECODE_ERROR = 118; 1666 enum X509_R_CANT_CHECK_DH_KEY = 114; 1667 enum X509_R_CERT_ALREADY_IN_HASH_TABLE = 101; 1668 enum X509_R_CRL_ALREADY_DELTA = 127; 1669 enum X509_R_CRL_VERIFY_FAILURE = 131; 1670 enum X509_R_IDP_MISMATCH = 128; 1671 enum X509_R_INVALID_DIRECTORY = 113; 1672 enum X509_R_INVALID_FIELD_NAME = 119; 1673 enum X509_R_INVALID_TRUST = 123; 1674 enum X509_R_ISSUER_MISMATCH = 129; 1675 enum X509_R_KEY_TYPE_MISMATCH = 115; 1676 enum X509_R_KEY_VALUES_MISMATCH = 116; 1677 enum X509_R_LOADING_CERT_DIR = 103; 1678 enum X509_R_LOADING_DEFAULTS = 104; 1679 enum X509_R_METHOD_NOT_SUPPORTED = 124; 1680 enum X509_R_NAME_TOO_LONG = 134; 1681 enum X509_R_NEWER_CRL_NOT_NEWER = 132; 1682 enum X509_R_NO_CERT_SET_FOR_US_TO_VERIFY = 105; 1683 enum X509_R_NO_CRL_NUMBER = 130; 1684 enum X509_R_PUBLIC_KEY_DECODE_ERROR = 125; 1685 enum X509_R_PUBLIC_KEY_ENCODE_ERROR = 126; 1686 enum X509_R_SHOULD_RETRY = 106; 1687 enum X509_R_UNABLE_TO_FIND_PARAMETERS_IN_CHAIN = 107; 1688 enum X509_R_UNABLE_TO_GET_CERTS_PUBLIC_KEY = 108; 1689 enum X509_R_UNKNOWN_KEY_TYPE = 117; 1690 enum X509_R_UNKNOWN_NID = 109; 1691 enum X509_R_UNKNOWN_PURPOSE_ID = 121; 1692 enum X509_R_UNKNOWN_TRUST_ID = 120; 1693 enum X509_R_UNSUPPORTED_ALGORITHM = 111; 1694 enum X509_R_WRONG_LOOKUP_TYPE = 112; 1695 enum X509_R_WRONG_TYPE = 122;