diff --git a/itrustee_sdk.spec b/itrustee_sdk.spec index 2229adb5557a591782c9c98e0ff2ed2066f0a638..5600d3592ca0a8c693dc7de32a9e15b88a73db0a 100644 --- a/itrustee_sdk.spec +++ b/itrustee_sdk.spec @@ -1,6 +1,6 @@ Name: itrustee_sdk Version: 0.1.0 -Release: 8 +Release: 9 Summary: Confidential computing framework for developing TA on itrustee OS ExclusiveArch: aarch64 @@ -11,6 +11,7 @@ Source0: https://gitee.com/openeuler/itrustee_sdk/repository/archive/v%{version} Patch0: 0001-add-Makefile-to-create-libteec_adaptor.so.patch Patch1: 0002-add-ftrapv-strip-and-FS-as-the-compiling-flags.patch Patch2: 0003-no-copy-shared-memory.patch +Patch3: support-part-openssl-headers.patch Provides: libteec_adaptor.so()(64bit) %define debug_package %{nil} @@ -53,6 +54,9 @@ strip %{buildroot}/lib64/*.so /lib64/libteec_adaptor.so %changelog +* Tue Apr 11 2023 houmingyong - 0.1.0-9 +- DESC:add ta openssl headers + * Tue Nov 22 2022 gaoyusong - 0.1.0-8 - DESC:fix error source pkg diff --git a/support-part-openssl-headers.patch b/support-part-openssl-headers.patch new file mode 100644 index 0000000000000000000000000000000000000000..b58b6937ff6a1380891b151f7c08454585f5a461 --- /dev/null +++ b/support-part-openssl-headers.patch @@ -0,0 +1,20939 @@ +From 923bb01b490ca899956403af837b81834e237b46 Mon Sep 17 00:00:00 2001 +From: houmingyong +Date: Tue, 28 Feb 2023 15:27:07 +0800 +Subject: [PATCH] support part openssl headers + +--- + include/TA/openssl/crypto/asn1.h | 116 + + include/TA/openssl/crypto/bn.h | 95 + + include/TA/openssl/crypto/ec.h | 59 + + include/TA/openssl/crypto/err.h | 19 + + include/TA/openssl/internal/bio.h | 39 + + include/TA/openssl/openssl/asn1.h | 891 ++++ + include/TA/openssl/openssl/asn1err.h | 256 ++ + include/TA/openssl/openssl/asn1t.h | 962 ++++ + include/TA/openssl/openssl/bio.h | 813 ++++ + include/TA/openssl/openssl/bioerr.h | 124 + + include/TA/openssl/openssl/bn.h | 658 +++ + include/TA/openssl/openssl/bnerr.h | 101 + + include/TA/openssl/openssl/buffer.h | 56 + + include/TA/openssl/openssl/buffererr.h | 34 + + include/TA/openssl/openssl/cmac.h | 41 + + include/TA/openssl/openssl/crypto.h | 501 ++ + include/TA/openssl/openssl/cryptoerr.h | 57 + + include/TA/openssl/openssl/dh.h | 342 ++ + include/TA/openssl/openssl/dsa.h | 248 + + include/TA/openssl/openssl/e_os2.h | 307 ++ + include/TA/openssl/openssl/ec.h | 1483 ++++++ + include/TA/openssl/openssl/ecdsa.h | 19 + + include/TA/openssl/openssl/ecerr.h | 282 ++ + include/TA/openssl/openssl/err.h | 286 ++ + include/TA/openssl/openssl/evp.h | 1683 +++++++ + include/TA/openssl/openssl/evperr.h | 206 + + include/TA/openssl/openssl/hmac.h | 51 + + include/TA/openssl/openssl/kdf.h | 96 + + include/TA/openssl/openssl/kdferr.h | 55 + + include/TA/openssl/openssl/lhash.h | 240 + + include/TA/openssl/openssl/obj_mac.h | 5303 ++++++++++++++++++++++ + include/TA/openssl/openssl/objects.h | 173 + + include/TA/openssl/openssl/objectserr.h | 42 + + include/TA/openssl/openssl/opensslconf.h | 365 ++ + include/TA/openssl/openssl/opensslv.h | 100 + + include/TA/openssl/openssl/ossl_typ.h | 200 + + include/TA/openssl/openssl/pem.h | 389 ++ + include/TA/openssl/openssl/pemerr.h | 105 + + include/TA/openssl/openssl/pkcs7.h | 457 ++ + include/TA/openssl/openssl/pkcs7err.h | 118 + + include/TA/openssl/openssl/rand.h | 87 + + include/TA/openssl/openssl/randerr.h | 94 + + include/TA/openssl/openssl/rsa.h | 518 +++ + include/TA/openssl/openssl/rsaerr.h | 174 + + include/TA/openssl/openssl/safestack.h | 207 + + include/TA/openssl/openssl/sha.h | 116 + + include/TA/openssl/openssl/stack.h | 83 + + include/TA/openssl/openssl/symhacks.h | 37 + + include/TA/openssl/openssl/x509.h | 1065 +++++ + include/TA/openssl/openssl/x509_vfy.h | 633 +++ + include/TA/openssl/openssl/x509err.h | 134 + + 51 files changed, 20520 insertions(+) + create mode 100644 include/TA/openssl/crypto/asn1.h + create mode 100644 include/TA/openssl/crypto/bn.h + create mode 100644 include/TA/openssl/crypto/ec.h + create mode 100644 include/TA/openssl/crypto/err.h + create mode 100644 include/TA/openssl/internal/bio.h + create mode 100644 include/TA/openssl/openssl/asn1.h + create mode 100644 include/TA/openssl/openssl/asn1err.h + create mode 100644 include/TA/openssl/openssl/asn1t.h + create mode 100644 include/TA/openssl/openssl/bio.h + create mode 100644 include/TA/openssl/openssl/bioerr.h + create mode 100644 include/TA/openssl/openssl/bn.h + create mode 100644 include/TA/openssl/openssl/bnerr.h + create mode 100644 include/TA/openssl/openssl/buffer.h + create mode 100644 include/TA/openssl/openssl/buffererr.h + create mode 100644 include/TA/openssl/openssl/cmac.h + create mode 100644 include/TA/openssl/openssl/crypto.h + create mode 100644 include/TA/openssl/openssl/cryptoerr.h + create mode 100644 include/TA/openssl/openssl/dh.h + create mode 100644 include/TA/openssl/openssl/dsa.h + create mode 100644 include/TA/openssl/openssl/e_os2.h + create mode 100644 include/TA/openssl/openssl/ec.h + create mode 100644 include/TA/openssl/openssl/ecdsa.h + create mode 100644 include/TA/openssl/openssl/ecerr.h + create mode 100644 include/TA/openssl/openssl/err.h + create mode 100644 include/TA/openssl/openssl/evp.h + create mode 100644 include/TA/openssl/openssl/evperr.h + create mode 100644 include/TA/openssl/openssl/hmac.h + create mode 100644 include/TA/openssl/openssl/kdf.h + create mode 100644 include/TA/openssl/openssl/kdferr.h + create mode 100644 include/TA/openssl/openssl/lhash.h + create mode 100644 include/TA/openssl/openssl/obj_mac.h + create mode 100644 include/TA/openssl/openssl/objects.h + create mode 100644 include/TA/openssl/openssl/objectserr.h + create mode 100644 include/TA/openssl/openssl/opensslconf.h + create mode 100644 include/TA/openssl/openssl/opensslv.h + create mode 100644 include/TA/openssl/openssl/ossl_typ.h + create mode 100644 include/TA/openssl/openssl/pem.h + create mode 100644 include/TA/openssl/openssl/pemerr.h + create mode 100644 include/TA/openssl/openssl/pkcs7.h + create mode 100644 include/TA/openssl/openssl/pkcs7err.h + create mode 100644 include/TA/openssl/openssl/rand.h + create mode 100644 include/TA/openssl/openssl/randerr.h + create mode 100644 include/TA/openssl/openssl/rsa.h + create mode 100644 include/TA/openssl/openssl/rsaerr.h + create mode 100644 include/TA/openssl/openssl/safestack.h + create mode 100644 include/TA/openssl/openssl/sha.h + create mode 100644 include/TA/openssl/openssl/stack.h + create mode 100644 include/TA/openssl/openssl/symhacks.h + create mode 100644 include/TA/openssl/openssl/x509.h + create mode 100644 include/TA/openssl/openssl/x509_vfy.h + create mode 100644 include/TA/openssl/openssl/x509err.h + +diff --git a/include/TA/openssl/crypto/asn1.h b/include/TA/openssl/crypto/asn1.h +new file mode 100644 +index 0000000..9c28a7d +--- /dev/null ++++ b/include/TA/openssl/crypto/asn1.h +@@ -0,0 +1,116 @@ ++/* ++ * Copyright 2015-2018 The OpenSSL Project Authors. All Rights Reserved. ++ * ++ * Licensed under the OpenSSL license (the "License"). You may not use ++ * this file except in compliance with the License. You can obtain a copy ++ * in the file LICENSE in the source distribution or at ++ * https://www.openssl.org/source/license.html ++ */ ++ ++/* Internal ASN1 structures and functions: not for application use */ ++ ++/* ASN1 public key method structure */ ++ ++struct evp_pkey_asn1_method_st { ++ int pkey_id; ++ int pkey_base_id; ++ unsigned long pkey_flags; ++ char *pem_str; ++ char *info; ++ int (*pub_decode) (EVP_PKEY *pk, X509_PUBKEY *pub); ++ int (*pub_encode) (X509_PUBKEY *pub, const EVP_PKEY *pk); ++ int (*pub_cmp) (const EVP_PKEY *a, const EVP_PKEY *b); ++ int (*pub_print) (BIO *out, const EVP_PKEY *pkey, int indent, ++ ASN1_PCTX *pctx); ++ int (*priv_decode) (EVP_PKEY *pk, const PKCS8_PRIV_KEY_INFO *p8inf); ++ int (*priv_encode) (PKCS8_PRIV_KEY_INFO *p8, const EVP_PKEY *pk); ++ int (*priv_print) (BIO *out, const EVP_PKEY *pkey, int indent, ++ ASN1_PCTX *pctx); ++ int (*pkey_size) (const EVP_PKEY *pk); ++ int (*pkey_bits) (const EVP_PKEY *pk); ++ int (*pkey_security_bits) (const EVP_PKEY *pk); ++ int (*param_decode) (EVP_PKEY *pkey, ++ const unsigned char **pder, int derlen); ++ int (*param_encode) (const EVP_PKEY *pkey, unsigned char **pder); ++ int (*param_missing) (const EVP_PKEY *pk); ++ int (*param_copy) (EVP_PKEY *to, const EVP_PKEY *from); ++ int (*param_cmp) (const EVP_PKEY *a, const EVP_PKEY *b); ++ int (*param_print) (BIO *out, const EVP_PKEY *pkey, int indent, ++ ASN1_PCTX *pctx); ++ int (*sig_print) (BIO *out, ++ const X509_ALGOR *sigalg, const ASN1_STRING *sig, ++ int indent, ASN1_PCTX *pctx); ++ void (*pkey_free) (EVP_PKEY *pkey); ++ int (*pkey_ctrl) (EVP_PKEY *pkey, int op, long arg1, void *arg2); ++ /* Legacy functions for old PEM */ ++ int (*old_priv_decode) (EVP_PKEY *pkey, ++ const unsigned char **pder, int derlen); ++ int (*old_priv_encode) (const EVP_PKEY *pkey, unsigned char **pder); ++ /* Custom ASN1 signature verification */ ++ int (*item_verify) (EVP_MD_CTX *ctx, const ASN1_ITEM *it, void *asn, ++ X509_ALGOR *a, ASN1_BIT_STRING *sig, EVP_PKEY *pkey); ++ int (*item_sign) (EVP_MD_CTX *ctx, const ASN1_ITEM *it, void *asn, ++ X509_ALGOR *alg1, X509_ALGOR *alg2, ++ ASN1_BIT_STRING *sig); ++ int (*siginf_set) (X509_SIG_INFO *siginf, const X509_ALGOR *alg, ++ const ASN1_STRING *sig); ++ /* Check */ ++ int (*pkey_check) (const EVP_PKEY *pk); ++ int (*pkey_public_check) (const EVP_PKEY *pk); ++ int (*pkey_param_check) (const EVP_PKEY *pk); ++ /* Get/set raw private/public key data */ ++ int (*set_priv_key) (EVP_PKEY *pk, const unsigned char *priv, size_t len); ++ int (*set_pub_key) (EVP_PKEY *pk, const unsigned char *pub, size_t len); ++ int (*get_priv_key) (const EVP_PKEY *pk, unsigned char *priv, size_t *len); ++ int (*get_pub_key) (const EVP_PKEY *pk, unsigned char *pub, size_t *len); ++} /* EVP_PKEY_ASN1_METHOD */ ; ++ ++DEFINE_STACK_OF_CONST(EVP_PKEY_ASN1_METHOD) ++ ++extern const EVP_PKEY_ASN1_METHOD cmac_asn1_meth; ++extern const EVP_PKEY_ASN1_METHOD dh_asn1_meth; ++extern const EVP_PKEY_ASN1_METHOD dhx_asn1_meth; ++extern const EVP_PKEY_ASN1_METHOD dsa_asn1_meths[5]; ++extern const EVP_PKEY_ASN1_METHOD eckey_asn1_meth; ++extern const EVP_PKEY_ASN1_METHOD ecx25519_asn1_meth; ++extern const EVP_PKEY_ASN1_METHOD ecx448_asn1_meth; ++extern const EVP_PKEY_ASN1_METHOD ed25519_asn1_meth; ++extern const EVP_PKEY_ASN1_METHOD ed448_asn1_meth; ++extern const EVP_PKEY_ASN1_METHOD sm2_asn1_meth; ++extern const EVP_PKEY_ASN1_METHOD poly1305_asn1_meth; ++ ++extern const EVP_PKEY_ASN1_METHOD hmac_asn1_meth; ++extern const EVP_PKEY_ASN1_METHOD rsa_asn1_meths[2]; ++extern const EVP_PKEY_ASN1_METHOD rsa_pss_asn1_meth; ++extern const EVP_PKEY_ASN1_METHOD siphash_asn1_meth; ++ ++/* ++ * These are used internally in the ASN1_OBJECT to keep track of whether the ++ * names and data need to be free()ed ++ */ ++# define ASN1_OBJECT_FLAG_DYNAMIC 0x01/* internal use */ ++# define ASN1_OBJECT_FLAG_CRITICAL 0x02/* critical x509v3 object id */ ++# define ASN1_OBJECT_FLAG_DYNAMIC_STRINGS 0x04/* internal use */ ++# define ASN1_OBJECT_FLAG_DYNAMIC_DATA 0x08/* internal use */ ++#ifndef OPENSSL_NO_CRL_MEMPOOL ++# define ASN1_OBJECT_FLAG_MEMPOOL 0x1000/* internal use*/ ++#endif ++struct asn1_object_st { ++ const char *sn, *ln; ++ int nid; ++ int length; ++ const unsigned char *data; /* data remains const after init */ ++ int flags; /* Should we free this one */ ++}; ++ ++/* ASN1 print context structure */ ++ ++struct asn1_pctx_st { ++ unsigned long flags; ++ unsigned long nm_flags; ++ unsigned long cert_flags; ++ unsigned long oid_flags; ++ unsigned long str_flags; ++} /* ASN1_PCTX */ ; ++ ++int asn1_d2i_read_bio(BIO *in, BUF_MEM **pb); +diff --git a/include/TA/openssl/crypto/bn.h b/include/TA/openssl/crypto/bn.h +new file mode 100644 +index 0000000..b5f36fb +--- /dev/null ++++ b/include/TA/openssl/crypto/bn.h +@@ -0,0 +1,95 @@ ++/* ++ * Copyright 2014-2018 The OpenSSL Project Authors. All Rights Reserved. ++ * ++ * Licensed under the OpenSSL license (the "License"). You may not use ++ * this file except in compliance with the License. You can obtain a copy ++ * in the file LICENSE in the source distribution or at ++ * https://www.openssl.org/source/license.html ++ */ ++ ++#ifndef OSSL_CRYPTO_BN_H ++# define OSSL_CRYPTO_BN_H ++ ++# include ++# include ++ ++BIGNUM *bn_wexpand(BIGNUM *a, int words); ++BIGNUM *bn_expand2(BIGNUM *a, int words); ++ ++void bn_correct_top(BIGNUM *a); ++ ++/* ++ * Determine the modified width-(w+1) Non-Adjacent Form (wNAF) of 'scalar'. ++ * This is an array r[] of values that are either zero or odd with an ++ * absolute value less than 2^w satisfying scalar = \sum_j r[j]*2^j where at ++ * most one of any w+1 consecutive digits is non-zero with the exception that ++ * the most significant digit may be only w-1 zeros away from that next ++ * non-zero digit. ++ */ ++signed char *bn_compute_wNAF(const BIGNUM *scalar, int w, size_t *ret_len); ++ ++int bn_get_top(const BIGNUM *a); ++ ++int bn_get_dmax(const BIGNUM *a); ++ ++/* Set all words to zero */ ++void bn_set_all_zero(BIGNUM *a); ++ ++/* ++ * Copy the internal BIGNUM words into out which holds size elements (and size ++ * must be bigger than top) ++ */ ++int bn_copy_words(BN_ULONG *out, const BIGNUM *in, int size); ++ ++BN_ULONG *bn_get_words(const BIGNUM *a); ++ ++/* ++ * Set the internal data words in a to point to words which contains size ++ * elements. The BN_FLG_STATIC_DATA flag is set ++ */ ++void bn_set_static_words(BIGNUM *a, const BN_ULONG *words, int size); ++ ++/* ++ * Copy words into the BIGNUM |a|, reallocating space as necessary. ++ * The negative flag of |a| is not modified. ++ * Returns 1 on success and 0 on failure. ++ */ ++/* ++ * |num_words| is int because bn_expand2 takes an int. This is an internal ++ * function so we simply trust callers not to pass negative values. ++ */ ++int bn_set_words(BIGNUM *a, const BN_ULONG *words, int num_words); ++ ++/* ++ * Some BIGNUM functions assume most significant limb to be non-zero, which ++ * is customarily arranged by bn_correct_top. Output from below functions ++ * is not processed with bn_correct_top, and for this reason it may not be ++ * returned out of public API. It may only be passed internally into other ++ * functions known to support non-minimal or zero-padded BIGNUMs. Even ++ * though the goal is to facilitate constant-time-ness, not each subroutine ++ * is constant-time by itself. They all have pre-conditions, consult source ++ * code... ++ */ ++int bn_mul_mont_fixed_top(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, ++ BN_MONT_CTX *mont, BN_CTX *ctx); ++int bn_to_mont_fixed_top(BIGNUM *r, const BIGNUM *a, BN_MONT_CTX *mont, ++ BN_CTX *ctx); ++int bn_from_mont_fixed_top(BIGNUM *r, const BIGNUM *a, BN_MONT_CTX *mont, ++ BN_CTX *ctx); ++int bn_mod_add_fixed_top(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, ++ const BIGNUM *m); ++int bn_mod_sub_fixed_top(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, ++ const BIGNUM *m); ++int bn_mul_fixed_top(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx); ++int bn_sqr_fixed_top(BIGNUM *r, const BIGNUM *a, BN_CTX *ctx); ++int bn_lshift_fixed_top(BIGNUM *r, const BIGNUM *a, int n); ++int bn_rshift_fixed_top(BIGNUM *r, const BIGNUM *a, int n); ++int bn_div_fixed_top(BIGNUM *dv, BIGNUM *rem, const BIGNUM *m, ++ const BIGNUM *d, BN_CTX *ctx); ++int ossl_bn_rsa_do_unblind(const BIGNUM *intermediate, ++ const BN_BLINDING *blinding, ++ const BIGNUM *possible_arg2, ++ const BIGNUM *to_mod, BN_CTX *ctx, ++ unsigned char *buf, int num); ++ ++#endif +diff --git a/include/TA/openssl/crypto/ec.h b/include/TA/openssl/crypto/ec.h +new file mode 100644 +index 0000000..184c5c1 +--- /dev/null ++++ b/include/TA/openssl/crypto/ec.h +@@ -0,0 +1,59 @@ ++/* ++ * Copyright 2018 The OpenSSL Project Authors. All Rights Reserved. ++ * ++ * Licensed under the OpenSSL license (the "License"). You may not use ++ * this file except in compliance with the License. You can obtain a copy ++ * in the file LICENSE in the source distribution or at ++ * https://www.openssl.org/source/license.html ++ */ ++ ++/* Internal EC functions for other submodules: not for application use */ ++ ++#ifndef OSSL_CRYPTO_EC_H ++# define OSSL_CRYPTO_EC_H ++# include ++ ++# ifndef OPENSSL_NO_EC ++ ++# include ++ ++/*- ++ * Computes the multiplicative inverse of x in the range ++ * [1,EC_GROUP::order), where EC_GROUP::order is the cardinality of the ++ * subgroup generated by the generator G: ++ * ++ * res := x^(-1) (mod EC_GROUP::order). ++ * ++ * This function expects the following two conditions to hold: ++ * - the EC_GROUP order is prime, and ++ * - x is included in the range [1, EC_GROUP::order). ++ * ++ * This function returns 1 on success, 0 on error. ++ * ++ * If the EC_GROUP order is even, this function explicitly returns 0 as ++ * an error. ++ * In case any of the two conditions stated above is not satisfied, ++ * the correctness of its output is not guaranteed, even if the return ++ * value could still be 1 (as primality testing and a conditional modular ++ * reduction round on the input can be omitted by the underlying ++ * implementations for better SCA properties on regular input values). ++ */ ++__owur int ec_group_do_inverse_ord(const EC_GROUP *group, BIGNUM *res, ++ const BIGNUM *x, BN_CTX *ctx); ++ ++/*- ++ * ECDH Key Derivation Function as defined in ANSI X9.63 ++ */ ++int ecdh_KDF_X9_63(unsigned char *out, size_t outlen, ++ const unsigned char *Z, size_t Zlen, ++ const unsigned char *sinfo, size_t sinfolen, ++ const EVP_MD *md); ++ ++/*- ++ * Checking for Elliptic Curve types that do not support signatures for fips 140-3 ++ */ ++#ifndef OPENSSL_NO_FIPS ++int fips_check_ecdsa_curve_type(int nid); ++#endif ++# endif /* OPENSSL_NO_EC */ ++#endif +diff --git a/include/TA/openssl/crypto/err.h b/include/TA/openssl/crypto/err.h +new file mode 100644 +index 0000000..8ab0e5b +--- /dev/null ++++ b/include/TA/openssl/crypto/err.h +@@ -0,0 +1,19 @@ ++/* ++ * Copyright 2016-2018 The OpenSSL Project Authors. All Rights Reserved. ++ * ++ * Licensed under the OpenSSL license (the "License"). You may not use ++ * this file except in compliance with the License. You can obtain a copy ++ * in the file LICENSE in the source distribution or at ++ * https://www.openssl.org/source/license.html ++ */ ++ ++#ifndef OSSL_CRYPTO_ERR_H ++# define OSSL_CRYPTO_ERR_H ++ ++int err_load_crypto_strings_int(void); ++void err_cleanup(void); ++void err_delete_thread_state(void); ++int err_shelve_state(void **); ++void err_unshelve_state(void *); ++ ++#endif +diff --git a/include/TA/openssl/internal/bio.h b/include/TA/openssl/internal/bio.h +new file mode 100644 +index 0000000..51b991d +--- /dev/null ++++ b/include/TA/openssl/internal/bio.h +@@ -0,0 +1,39 @@ ++/* ++ * Copyright 2016-2018 The OpenSSL Project Authors. All Rights Reserved. ++ * ++ * Licensed under the OpenSSL license (the "License"). You may not use ++ * this file except in compliance with the License. You can obtain a copy ++ * in the file LICENSE in the source distribution or at ++ * https://www.openssl.org/source/license.html ++ */ ++ ++#include ++ ++struct bio_method_st { ++ int type; ++ char *name; ++ int (*bwrite) (BIO *, const char *, size_t, size_t *); ++ int (*bwrite_old) (BIO *, const char *, int); ++ int (*bread) (BIO *, char *, size_t, size_t *); ++ int (*bread_old) (BIO *, char *, int); ++ int (*bputs) (BIO *, const char *); ++ int (*bgets) (BIO *, char *, int); ++ long (*ctrl) (BIO *, int, long, void *); ++ int (*create) (BIO *); ++ int (*destroy) (BIO *); ++ long (*callback_ctrl) (BIO *, int, BIO_info_cb *); ++}; ++ ++void bio_free_ex_data(BIO *bio); ++void bio_cleanup(void); ++ ++#ifndef OPENSSL_NO_DTO ++#define BIO_set_dto_key(b, keyblob, type) \ ++ BIO_ctrl(b, BIO_CTRL_SET_DTO_KEY, type, keyblob) ++ ++#define BIO_set_dto_epoch_sequence(b, keyblob) \ ++ BIO_ctrl(b, BIO_CTRL_SET_DTO_EPOCH_SEQUENCE, 0, keyblob) ++#endif ++/* Old style to new style BIO_METHOD conversion functions */ ++int bwrite_conv(BIO *bio, const char *data, size_t datal, size_t *written); ++int bread_conv(BIO *bio, char *data, size_t datal, size_t *read); +diff --git a/include/TA/openssl/openssl/asn1.h b/include/TA/openssl/openssl/asn1.h +new file mode 100644 +index 0000000..fbf8373 +--- /dev/null ++++ b/include/TA/openssl/openssl/asn1.h +@@ -0,0 +1,891 @@ ++/* ++ * Copyright 1995-2017 The OpenSSL Project Authors. All Rights Reserved. ++ * ++ * Licensed under the OpenSSL license (the "License"). You may not use ++ * this file except in compliance with the License. You can obtain a copy ++ * in the file LICENSE in the source distribution or at ++ * https://www.openssl.org/source/license.html ++ */ ++ ++#ifndef HEADER_ASN1_H ++# define HEADER_ASN1_H ++ ++# include ++# include ++# include ++# include ++# include ++# include ++# include ++ ++# include ++# if OPENSSL_API_COMPAT < 0x10100000L ++# include ++# endif ++ ++# ifdef OPENSSL_BUILD_SHLIBCRYPTO ++# undef OPENSSL_EXTERN ++# define OPENSSL_EXTERN OPENSSL_EXPORT ++# endif ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++# define V_ASN1_UNIVERSAL 0x00 ++# define V_ASN1_APPLICATION 0x40 ++# define V_ASN1_CONTEXT_SPECIFIC 0x80 ++# define V_ASN1_PRIVATE 0xc0 ++ ++# define V_ASN1_CONSTRUCTED 0x20 ++# define V_ASN1_PRIMITIVE_TAG 0x1f ++# define V_ASN1_PRIMATIVE_TAG /*compat*/ V_ASN1_PRIMITIVE_TAG ++ ++# define V_ASN1_APP_CHOOSE -2/* let the recipient choose */ ++# define V_ASN1_OTHER -3/* used in ASN1_TYPE */ ++# define V_ASN1_ANY -4/* used in ASN1 template code */ ++ ++# define V_ASN1_UNDEF -1 ++/* ASN.1 tag values */ ++# define V_ASN1_EOC 0 ++# define V_ASN1_BOOLEAN 1 /**/ ++# define V_ASN1_INTEGER 2 ++# define V_ASN1_BIT_STRING 3 ++# define V_ASN1_OCTET_STRING 4 ++# define V_ASN1_NULL 5 ++# define V_ASN1_OBJECT 6 ++# define V_ASN1_OBJECT_DESCRIPTOR 7 ++# define V_ASN1_EXTERNAL 8 ++# define V_ASN1_REAL 9 ++# define V_ASN1_ENUMERATED 10 ++# define V_ASN1_UTF8STRING 12 ++# define V_ASN1_SEQUENCE 16 ++# define V_ASN1_SET 17 ++# define V_ASN1_NUMERICSTRING 18 /**/ ++# define V_ASN1_PRINTABLESTRING 19 ++# define V_ASN1_T61STRING 20 ++# define V_ASN1_TELETEXSTRING 20/* alias */ ++# define V_ASN1_VIDEOTEXSTRING 21 /**/ ++# define V_ASN1_IA5STRING 22 ++# define V_ASN1_UTCTIME 23 ++# define V_ASN1_GENERALIZEDTIME 24 /**/ ++# define V_ASN1_GRAPHICSTRING 25 /**/ ++# define V_ASN1_ISO64STRING 26 /**/ ++# define V_ASN1_VISIBLESTRING 26/* alias */ ++# define V_ASN1_GENERALSTRING 27 /**/ ++# define V_ASN1_UNIVERSALSTRING 28 /**/ ++# define V_ASN1_BMPSTRING 30 ++ ++/* ++ * NB the constants below are used internally by ASN1_INTEGER ++ * and ASN1_ENUMERATED to indicate the sign. They are *not* on ++ * the wire tag values. ++ */ ++ ++# define V_ASN1_NEG 0x100 ++# define V_ASN1_NEG_INTEGER (2 | V_ASN1_NEG) ++# define V_ASN1_NEG_ENUMERATED (10 | V_ASN1_NEG) ++ ++/* For use with d2i_ASN1_type_bytes() */ ++# define B_ASN1_NUMERICSTRING 0x0001 ++# define B_ASN1_PRINTABLESTRING 0x0002 ++# define B_ASN1_T61STRING 0x0004 ++# define B_ASN1_TELETEXSTRING 0x0004 ++# define B_ASN1_VIDEOTEXSTRING 0x0008 ++# define B_ASN1_IA5STRING 0x0010 ++# define B_ASN1_GRAPHICSTRING 0x0020 ++# define B_ASN1_ISO64STRING 0x0040 ++# define B_ASN1_VISIBLESTRING 0x0040 ++# define B_ASN1_GENERALSTRING 0x0080 ++# define B_ASN1_UNIVERSALSTRING 0x0100 ++# define B_ASN1_OCTET_STRING 0x0200 ++# define B_ASN1_BIT_STRING 0x0400 ++# define B_ASN1_BMPSTRING 0x0800 ++# define B_ASN1_UNKNOWN 0x1000 ++# define B_ASN1_UTF8STRING 0x2000 ++# define B_ASN1_UTCTIME 0x4000 ++# define B_ASN1_GENERALIZEDTIME 0x8000 ++# define B_ASN1_SEQUENCE 0x10000 ++/* For use with ASN1_mbstring_copy() */ ++# define MBSTRING_FLAG 0x1000 ++# define MBSTRING_UTF8 (MBSTRING_FLAG) ++# define MBSTRING_ASC (MBSTRING_FLAG|1) ++# define MBSTRING_BMP (MBSTRING_FLAG|2) ++# define MBSTRING_UNIV (MBSTRING_FLAG|4) ++# define SMIME_OLDMIME 0x400 ++# define SMIME_CRLFEOL 0x800 ++# define SMIME_STREAM 0x1000 ++ struct X509_algor_st; ++DEFINE_STACK_OF(X509_ALGOR) ++ ++# define ASN1_STRING_FLAG_BITS_LEFT 0x08/* Set if 0x07 has bits left value */ ++/* ++ * This indicates that the ASN1_STRING is not a real value but just a place ++ * holder for the location where indefinite length constructed data should be ++ * inserted in the memory buffer ++ */ ++# define ASN1_STRING_FLAG_NDEF 0x010 ++ ++/* ++ * This flag is used by the CMS code to indicate that a string is not ++ * complete and is a place holder for content when it had all been accessed. ++ * The flag will be reset when content has been written to it. ++ */ ++ ++# define ASN1_STRING_FLAG_CONT 0x020 ++/* ++ * This flag is used by ASN1 code to indicate an ASN1_STRING is an MSTRING ++ * type. ++ */ ++# define ASN1_STRING_FLAG_MSTRING 0x040 ++/* String is embedded and only content should be freed */ ++# define ASN1_STRING_FLAG_EMBED 0x080 ++/* String should be parsed in RFC 5280's time format */ ++# define ASN1_STRING_FLAG_X509_TIME 0x100 ++/* This is the base type that holds just about everything :-) */ ++struct asn1_string_st { ++ int length; ++ int type; ++ unsigned char *data; ++ /* ++ * The value of the following field depends on the type being held. It ++ * is mostly being used for BIT_STRING so if the input data has a ++ * non-zero 'unused bits' value, it will be handled correctly ++ */ ++ long flags; ++}; ++ ++/* ++ * ASN1_ENCODING structure: this is used to save the received encoding of an ++ * ASN1 type. This is useful to get round problems with invalid encodings ++ * which can break signatures. ++ */ ++ ++typedef struct ASN1_ENCODING_st { ++ unsigned char *enc; /* DER encoding */ ++ long len; /* Length of encoding */ ++ int modified; /* set to 1 if 'enc' is invalid */ ++} ASN1_ENCODING; ++ ++/* Used with ASN1 LONG type: if a long is set to this it is omitted */ ++# define ASN1_LONG_UNDEF 0x7fffffffL ++ ++# define STABLE_FLAGS_MALLOC 0x01 ++/* ++ * A zero passed to ASN1_STRING_TABLE_new_add for the flags is interpreted ++ * as "don't change" and STABLE_FLAGS_MALLOC is always set. By setting ++ * STABLE_FLAGS_MALLOC only we can clear the existing value. Use the alias ++ * STABLE_FLAGS_CLEAR to reflect this. ++ */ ++# define STABLE_FLAGS_CLEAR STABLE_FLAGS_MALLOC ++# define STABLE_NO_MASK 0x02 ++# define DIRSTRING_TYPE \ ++ (B_ASN1_PRINTABLESTRING|B_ASN1_T61STRING|B_ASN1_BMPSTRING|B_ASN1_UTF8STRING) ++# define PKCS9STRING_TYPE (DIRSTRING_TYPE|B_ASN1_IA5STRING) ++ ++typedef struct asn1_string_table_st { ++ int nid; ++ long minsize; ++ long maxsize; ++ unsigned long mask; ++ unsigned long flags; ++} ASN1_STRING_TABLE; ++ ++DEFINE_STACK_OF(ASN1_STRING_TABLE) ++ ++/* size limits: this stuff is taken straight from RFC2459 */ ++ ++# define ub_name 32768 ++# define ub_common_name 64 ++# define ub_locality_name 128 ++# define ub_state_name 128 ++# define ub_organization_name 64 ++# define ub_organization_unit_name 64 ++# define ub_title 64 ++# define ub_email_address 128 ++ ++/* ++ * Declarations for template structures: for full definitions see asn1t.h ++ */ ++typedef struct ASN1_TEMPLATE_st ASN1_TEMPLATE; ++typedef struct ASN1_TLC_st ASN1_TLC; ++/* This is just an opaque pointer */ ++typedef struct ASN1_VALUE_st ASN1_VALUE; ++ ++/* Declare ASN1 functions: the implement macro in in asn1t.h */ ++ ++# define DECLARE_ASN1_FUNCTIONS(type) DECLARE_ASN1_FUNCTIONS_name(type, type) ++ ++# define DECLARE_ASN1_ALLOC_FUNCTIONS(type) \ ++ DECLARE_ASN1_ALLOC_FUNCTIONS_name(type, type) ++ ++# define DECLARE_ASN1_FUNCTIONS_name(type, name) \ ++ DECLARE_ASN1_ALLOC_FUNCTIONS_name(type, name) \ ++ DECLARE_ASN1_ENCODE_FUNCTIONS(type, name, name) ++ ++# define DECLARE_ASN1_FUNCTIONS_fname(type, itname, name) \ ++ DECLARE_ASN1_ALLOC_FUNCTIONS_name(type, name) \ ++ DECLARE_ASN1_ENCODE_FUNCTIONS(type, itname, name) ++ ++# define DECLARE_ASN1_ENCODE_FUNCTIONS(type, itname, name) \ ++ type *d2i_##name(type **a, const unsigned char **in, long len); \ ++ int i2d_##name(type *a, unsigned char **out); \ ++ DECLARE_ASN1_ITEM(itname) ++ ++# define DECLARE_ASN1_ENCODE_FUNCTIONS_const(type, name) \ ++ type *d2i_##name(type **a, const unsigned char **in, long len); \ ++ int i2d_##name(const type *a, unsigned char **out); \ ++ DECLARE_ASN1_ITEM(name) ++ ++# define DECLARE_ASN1_NDEF_FUNCTION(name) \ ++ int i2d_##name##_NDEF(name *a, unsigned char **out); ++ ++# define DECLARE_ASN1_FUNCTIONS_const(name) \ ++ DECLARE_ASN1_ALLOC_FUNCTIONS(name) \ ++ DECLARE_ASN1_ENCODE_FUNCTIONS_const(name, name) ++ ++# define DECLARE_ASN1_ALLOC_FUNCTIONS_name(type, name) \ ++ type *name##_new(void); \ ++ void name##_free(type *a); ++ ++# define DECLARE_ASN1_DUP_FUNCTION(type) \ ++ DECLARE_ASN1_DUP_FUNCTION_name(type, type) ++ ++# define DECLARE_ASN1_DUP_FUNCTION_name(type, name) \ ++ type *name##_dup(type *a); ++ ++# define DECLARE_ASN1_PRINT_FUNCTION(stname) \ ++ DECLARE_ASN1_PRINT_FUNCTION_fname(stname, stname) ++ ++# define DECLARE_ASN1_PRINT_FUNCTION_fname(stname, fname) \ ++ int fname##_print_ctx(BIO *out, stname *x, int indent, \ ++ const ASN1_PCTX *pctx); ++ ++# define D2I_OF(type) type *(*)(type **,const unsigned char **,long) ++# define I2D_OF(type) int (*)(type *,unsigned char **) ++# define I2D_OF_const(type) int (*)(const type *,unsigned char **) ++ ++# define CHECKED_D2I_OF(type, d2i) \ ++ ((d2i_of_void*) (1 ? d2i : ((D2I_OF(type))0))) ++# define CHECKED_I2D_OF(type, i2d) \ ++ ((i2d_of_void*) (1 ? i2d : ((I2D_OF(type))0))) ++# define CHECKED_NEW_OF(type, xnew) \ ++ ((void *(*)(void)) (1 ? xnew : ((type *(*)(void))0))) ++# define CHECKED_PTR_OF(type, p) \ ++ ((void*) (1 ? p : (type*)0)) ++# define CHECKED_PPTR_OF(type, p) \ ++ ((void**) (1 ? p : (type**)0)) ++ ++# define TYPEDEF_D2I_OF(type) typedef type *d2i_of_##type(type **,const unsigned char **,long) ++# define TYPEDEF_I2D_OF(type) typedef int i2d_of_##type(type *,unsigned char **) ++# define TYPEDEF_D2I2D_OF(type) TYPEDEF_D2I_OF(type); TYPEDEF_I2D_OF(type) ++ ++TYPEDEF_D2I2D_OF(void); ++ ++/*- ++ * The following macros and typedefs allow an ASN1_ITEM ++ * to be embedded in a structure and referenced. Since ++ * the ASN1_ITEM pointers need to be globally accessible ++ * (possibly from shared libraries) they may exist in ++ * different forms. On platforms that support it the ++ * ASN1_ITEM structure itself will be globally exported. ++ * Other platforms will export a function that returns ++ * an ASN1_ITEM pointer. ++ * ++ * To handle both cases transparently the macros below ++ * should be used instead of hard coding an ASN1_ITEM ++ * pointer in a structure. ++ * ++ * The structure will look like this: ++ * ++ * typedef struct SOMETHING_st { ++ * ... ++ * ASN1_ITEM_EXP *iptr; ++ * ... ++ * } SOMETHING; ++ * ++ * It would be initialised as e.g.: ++ * ++ * SOMETHING somevar = {...,ASN1_ITEM_ref(X509),...}; ++ * ++ * and the actual pointer extracted with: ++ * ++ * const ASN1_ITEM *it = ASN1_ITEM_ptr(somevar.iptr); ++ * ++ * Finally an ASN1_ITEM pointer can be extracted from an ++ * appropriate reference with: ASN1_ITEM_rptr(X509). This ++ * would be used when a function takes an ASN1_ITEM * argument. ++ * ++ */ ++ ++# ifndef OPENSSL_EXPORT_VAR_AS_FUNCTION ++ ++/* ASN1_ITEM pointer exported type */ ++typedef const ASN1_ITEM ASN1_ITEM_EXP; ++ ++/* Macro to obtain ASN1_ITEM pointer from exported type */ ++# define ASN1_ITEM_ptr(iptr) (iptr) ++ ++/* Macro to include ASN1_ITEM pointer from base type */ ++# define ASN1_ITEM_ref(iptr) (&(iptr##_it)) ++ ++# define ASN1_ITEM_rptr(ref) (&(ref##_it)) ++ ++# define DECLARE_ASN1_ITEM(name) \ ++ OPENSSL_EXTERN const ASN1_ITEM name##_it; ++ ++# else ++ ++/* ++ * Platforms that can't easily handle shared global variables are declared as ++ * functions returning ASN1_ITEM pointers. ++ */ ++ ++/* ASN1_ITEM pointer exported type */ ++typedef const ASN1_ITEM *ASN1_ITEM_EXP (void); ++ ++/* Macro to obtain ASN1_ITEM pointer from exported type */ ++# define ASN1_ITEM_ptr(iptr) (iptr()) ++ ++/* Macro to include ASN1_ITEM pointer from base type */ ++# define ASN1_ITEM_ref(iptr) (iptr##_it) ++ ++# define ASN1_ITEM_rptr(ref) (ref##_it()) ++ ++# define DECLARE_ASN1_ITEM(name) \ ++ const ASN1_ITEM * name##_it(void); ++ ++# endif ++ ++/* Parameters used by ASN1_STRING_print_ex() */ ++ ++/* ++ * These determine which characters to escape: RFC2253 special characters, ++ * control characters and MSB set characters ++ */ ++ ++# define ASN1_STRFLGS_ESC_2253 1 ++# define ASN1_STRFLGS_ESC_CTRL 2 ++# define ASN1_STRFLGS_ESC_MSB 4 ++ ++/* ++ * This flag determines how we do escaping: normally RC2253 backslash only, ++ * set this to use backslash and quote. ++ */ ++ ++# define ASN1_STRFLGS_ESC_QUOTE 8 ++ ++/* These three flags are internal use only. */ ++ ++/* Character is a valid PrintableString character */ ++# define CHARTYPE_PRINTABLESTRING 0x10 ++/* Character needs escaping if it is the first character */ ++# define CHARTYPE_FIRST_ESC_2253 0x20 ++/* Character needs escaping if it is the last character */ ++# define CHARTYPE_LAST_ESC_2253 0x40 ++ ++/* ++ * NB the internal flags are safely reused below by flags handled at the top ++ * level. ++ */ ++ ++/* ++ * If this is set we convert all character strings to UTF8 first ++ */ ++ ++# define ASN1_STRFLGS_UTF8_CONVERT 0x10 ++ ++/* ++ * If this is set we don't attempt to interpret content: just assume all ++ * strings are 1 byte per character. This will produce some pretty odd ++ * looking output! ++ */ ++ ++# define ASN1_STRFLGS_IGNORE_TYPE 0x20 ++ ++/* If this is set we include the string type in the output */ ++# define ASN1_STRFLGS_SHOW_TYPE 0x40 ++ ++/* ++ * This determines which strings to display and which to 'dump' (hex dump of ++ * content octets or DER encoding). We can only dump non character strings or ++ * everything. If we don't dump 'unknown' they are interpreted as character ++ * strings with 1 octet per character and are subject to the usual escaping ++ * options. ++ */ ++ ++# define ASN1_STRFLGS_DUMP_ALL 0x80 ++# define ASN1_STRFLGS_DUMP_UNKNOWN 0x100 ++ ++/* ++ * These determine what 'dumping' does, we can dump the content octets or the ++ * DER encoding: both use the RFC2253 #XXXXX notation. ++ */ ++ ++# define ASN1_STRFLGS_DUMP_DER 0x200 ++ ++/* ++ * This flag specifies that RC2254 escaping shall be performed. ++ */ ++#define ASN1_STRFLGS_ESC_2254 0x400 ++ ++/* ++ * All the string flags consistent with RFC2253, escaping control characters ++ * isn't essential in RFC2253 but it is advisable anyway. ++ */ ++ ++# define ASN1_STRFLGS_RFC2253 (ASN1_STRFLGS_ESC_2253 | \ ++ ASN1_STRFLGS_ESC_CTRL | \ ++ ASN1_STRFLGS_ESC_MSB | \ ++ ASN1_STRFLGS_UTF8_CONVERT | \ ++ ASN1_STRFLGS_DUMP_UNKNOWN | \ ++ ASN1_STRFLGS_DUMP_DER) ++ ++DEFINE_STACK_OF(ASN1_INTEGER) ++ ++DEFINE_STACK_OF(ASN1_GENERALSTRING) ++ ++DEFINE_STACK_OF(ASN1_UTF8STRING) ++ ++typedef struct asn1_type_st { ++ int type; ++ union { ++ char *ptr; ++ ASN1_BOOLEAN boolean; ++ ASN1_STRING *asn1_string; ++ ASN1_OBJECT *object; ++ ASN1_INTEGER *integer; ++ ASN1_ENUMERATED *enumerated; ++ ASN1_BIT_STRING *bit_string; ++ ASN1_OCTET_STRING *octet_string; ++ ASN1_PRINTABLESTRING *printablestring; ++ ASN1_T61STRING *t61string; ++ ASN1_IA5STRING *ia5string; ++ ASN1_GENERALSTRING *generalstring; ++ ASN1_BMPSTRING *bmpstring; ++ ASN1_UNIVERSALSTRING *universalstring; ++ ASN1_UTCTIME *utctime; ++ ASN1_GENERALIZEDTIME *generalizedtime; ++ ASN1_VISIBLESTRING *visiblestring; ++ ASN1_UTF8STRING *utf8string; ++ /* ++ * set and sequence are left complete and still contain the set or ++ * sequence bytes ++ */ ++ ASN1_STRING *set; ++ ASN1_STRING *sequence; ++ ASN1_VALUE *asn1_value; ++ } value; ++} ASN1_TYPE; ++ ++DEFINE_STACK_OF(ASN1_TYPE) ++ ++typedef STACK_OF(ASN1_TYPE) ASN1_SEQUENCE_ANY; ++ ++DECLARE_ASN1_ENCODE_FUNCTIONS_const(ASN1_SEQUENCE_ANY, ASN1_SEQUENCE_ANY) ++DECLARE_ASN1_ENCODE_FUNCTIONS_const(ASN1_SEQUENCE_ANY, ASN1_SET_ANY) ++ ++/* This is used to contain a list of bit names */ ++typedef struct BIT_STRING_BITNAME_st { ++ int bitnum; ++ const char *lname; ++ const char *sname; ++} BIT_STRING_BITNAME; ++ ++# define B_ASN1_TIME \ ++ B_ASN1_UTCTIME | \ ++ B_ASN1_GENERALIZEDTIME ++ ++# define B_ASN1_PRINTABLE \ ++ B_ASN1_NUMERICSTRING| \ ++ B_ASN1_PRINTABLESTRING| \ ++ B_ASN1_T61STRING| \ ++ B_ASN1_IA5STRING| \ ++ B_ASN1_BIT_STRING| \ ++ B_ASN1_UNIVERSALSTRING|\ ++ B_ASN1_BMPSTRING|\ ++ B_ASN1_UTF8STRING|\ ++ B_ASN1_SEQUENCE|\ ++ B_ASN1_UNKNOWN ++ ++# define B_ASN1_DIRECTORYSTRING \ ++ B_ASN1_PRINTABLESTRING| \ ++ B_ASN1_TELETEXSTRING|\ ++ B_ASN1_BMPSTRING|\ ++ B_ASN1_UNIVERSALSTRING|\ ++ B_ASN1_UTF8STRING ++ ++# define B_ASN1_DISPLAYTEXT \ ++ B_ASN1_IA5STRING| \ ++ B_ASN1_VISIBLESTRING| \ ++ B_ASN1_BMPSTRING|\ ++ B_ASN1_UTF8STRING ++ ++DECLARE_ASN1_FUNCTIONS_fname(ASN1_TYPE, ASN1_ANY, ASN1_TYPE) ++ ++int ASN1_TYPE_get(const ASN1_TYPE *a); ++void ASN1_TYPE_set(ASN1_TYPE *a, int type, void *value); ++int ASN1_TYPE_set1(ASN1_TYPE *a, int type, const void *value); ++int ASN1_TYPE_cmp(const ASN1_TYPE *a, const ASN1_TYPE *b); ++ ++ASN1_TYPE *ASN1_TYPE_pack_sequence(const ASN1_ITEM *it, void *s, ASN1_TYPE **t); ++void *ASN1_TYPE_unpack_sequence(const ASN1_ITEM *it, const ASN1_TYPE *t); ++ ++ASN1_OBJECT *ASN1_OBJECT_new(void); ++void ASN1_OBJECT_free(ASN1_OBJECT *a); ++int i2d_ASN1_OBJECT(const ASN1_OBJECT *a, unsigned char **pp); ++ASN1_OBJECT *d2i_ASN1_OBJECT(ASN1_OBJECT **a, const unsigned char **pp, ++ long length); ++ ++DECLARE_ASN1_ITEM(ASN1_OBJECT) ++ ++DEFINE_STACK_OF(ASN1_OBJECT) ++ ++ASN1_STRING *ASN1_STRING_new(void); ++void ASN1_STRING_free(ASN1_STRING *a); ++void ASN1_STRING_clear_free(ASN1_STRING *a); ++int ASN1_STRING_copy(ASN1_STRING *dst, const ASN1_STRING *str); ++ASN1_STRING *ASN1_STRING_dup(const ASN1_STRING *a); ++ASN1_STRING *ASN1_STRING_type_new(int type); ++int ASN1_STRING_cmp(const ASN1_STRING *a, const ASN1_STRING *b); ++ /* ++ * Since this is used to store all sorts of things, via macros, for now, ++ * make its data void * ++ */ ++int ASN1_STRING_set(ASN1_STRING *str, const void *data, int len); ++void ASN1_STRING_set0(ASN1_STRING *str, void *data, int len); ++int ASN1_STRING_length(const ASN1_STRING *x); ++void ASN1_STRING_length_set(ASN1_STRING *x, int n); ++int ASN1_STRING_type(const ASN1_STRING *x); ++DEPRECATEDIN_1_1_0(unsigned char *ASN1_STRING_data(ASN1_STRING *x)) ++const unsigned char *ASN1_STRING_get0_data(const ASN1_STRING *x); ++ ++DECLARE_ASN1_FUNCTIONS(ASN1_BIT_STRING) ++int ASN1_BIT_STRING_set(ASN1_BIT_STRING *a, unsigned char *d, int length); ++int ASN1_BIT_STRING_set_bit(ASN1_BIT_STRING *a, int n, int value); ++int ASN1_BIT_STRING_get_bit(const ASN1_BIT_STRING *a, int n); ++int ASN1_BIT_STRING_check(const ASN1_BIT_STRING *a, ++ const unsigned char *flags, int flags_len); ++ ++int ASN1_BIT_STRING_name_print(BIO *out, ASN1_BIT_STRING *bs, ++ BIT_STRING_BITNAME *tbl, int indent); ++int ASN1_BIT_STRING_num_asc(const char *name, BIT_STRING_BITNAME *tbl); ++int ASN1_BIT_STRING_set_asc(ASN1_BIT_STRING *bs, const char *name, int value, ++ BIT_STRING_BITNAME *tbl); ++ ++DECLARE_ASN1_FUNCTIONS(ASN1_INTEGER) ++ASN1_INTEGER *d2i_ASN1_UINTEGER(ASN1_INTEGER **a, const unsigned char **pp, ++ long length); ++ASN1_INTEGER *ASN1_INTEGER_dup(const ASN1_INTEGER *x); ++int ASN1_INTEGER_cmp(const ASN1_INTEGER *x, const ASN1_INTEGER *y); ++ ++DECLARE_ASN1_FUNCTIONS(ASN1_ENUMERATED) ++ ++int ASN1_UTCTIME_check(const ASN1_UTCTIME *a); ++ASN1_UTCTIME *ASN1_UTCTIME_set(ASN1_UTCTIME *s, time_t t); ++ASN1_UTCTIME *ASN1_UTCTIME_adj(ASN1_UTCTIME *s, time_t t, ++ int offset_day, long offset_sec); ++int ASN1_UTCTIME_set_string(ASN1_UTCTIME *s, const char *str); ++int ASN1_UTCTIME_cmp_time_t(const ASN1_UTCTIME *s, time_t t); ++ ++int ASN1_GENERALIZEDTIME_check(const ASN1_GENERALIZEDTIME *a); ++ASN1_GENERALIZEDTIME *ASN1_GENERALIZEDTIME_set(ASN1_GENERALIZEDTIME *s, ++ time_t t); ++ASN1_GENERALIZEDTIME *ASN1_GENERALIZEDTIME_adj(ASN1_GENERALIZEDTIME *s, ++ time_t t, int offset_day, ++ long offset_sec); ++int ASN1_GENERALIZEDTIME_set_string(ASN1_GENERALIZEDTIME *s, const char *str); ++ ++int ASN1_TIME_diff(int *pday, int *psec, ++ const ASN1_TIME *from, const ASN1_TIME *to); ++ ++DECLARE_ASN1_FUNCTIONS(ASN1_OCTET_STRING) ++ASN1_OCTET_STRING *ASN1_OCTET_STRING_dup(const ASN1_OCTET_STRING *a); ++int ASN1_OCTET_STRING_cmp(const ASN1_OCTET_STRING *a, ++ const ASN1_OCTET_STRING *b); ++int ASN1_OCTET_STRING_set(ASN1_OCTET_STRING *str, const unsigned char *data, ++ int len); ++ ++DECLARE_ASN1_FUNCTIONS(ASN1_VISIBLESTRING) ++DECLARE_ASN1_FUNCTIONS(ASN1_UNIVERSALSTRING) ++DECLARE_ASN1_FUNCTIONS(ASN1_UTF8STRING) ++DECLARE_ASN1_FUNCTIONS(ASN1_NULL) ++DECLARE_ASN1_FUNCTIONS(ASN1_BMPSTRING) ++ ++int UTF8_getc(const unsigned char *str, int len, unsigned long *val); ++int UTF8_putc(unsigned char *str, int len, unsigned long value); ++ ++DECLARE_ASN1_FUNCTIONS_name(ASN1_STRING, ASN1_PRINTABLE) ++ ++DECLARE_ASN1_FUNCTIONS_name(ASN1_STRING, DIRECTORYSTRING) ++DECLARE_ASN1_FUNCTIONS_name(ASN1_STRING, DISPLAYTEXT) ++DECLARE_ASN1_FUNCTIONS(ASN1_PRINTABLESTRING) ++DECLARE_ASN1_FUNCTIONS(ASN1_T61STRING) ++DECLARE_ASN1_FUNCTIONS(ASN1_IA5STRING) ++DECLARE_ASN1_FUNCTIONS(ASN1_GENERALSTRING) ++DECLARE_ASN1_FUNCTIONS(ASN1_UTCTIME) ++DECLARE_ASN1_FUNCTIONS(ASN1_GENERALIZEDTIME) ++DECLARE_ASN1_FUNCTIONS(ASN1_TIME) ++ ++DECLARE_ASN1_ITEM(ASN1_OCTET_STRING_NDEF) ++ ++ASN1_TIME *ASN1_TIME_set(ASN1_TIME *s, time_t t); ++ASN1_TIME *ASN1_TIME_adj(ASN1_TIME *s, time_t t, ++ int offset_day, long offset_sec); ++int ASN1_TIME_check(const ASN1_TIME *t); ++ASN1_GENERALIZEDTIME *ASN1_TIME_to_generalizedtime(const ASN1_TIME *t, ++ ASN1_GENERALIZEDTIME **out); ++int ASN1_TIME_set_string(ASN1_TIME *s, const char *str); ++int ASN1_TIME_set_string_X509(ASN1_TIME *s, const char *str); ++int ASN1_TIME_to_tm(const ASN1_TIME *s, struct tm *tm); ++int ASN1_TIME_normalize(ASN1_TIME *s); ++int ASN1_TIME_cmp_time_t(const ASN1_TIME *s, time_t t); ++int ASN1_TIME_compare(const ASN1_TIME *a, const ASN1_TIME *b); ++ ++int i2a_ASN1_INTEGER(BIO *bp, const ASN1_INTEGER *a); ++int a2i_ASN1_INTEGER(BIO *bp, ASN1_INTEGER *bs, char *buf, int size); ++int i2a_ASN1_ENUMERATED(BIO *bp, const ASN1_ENUMERATED *a); ++int a2i_ASN1_ENUMERATED(BIO *bp, ASN1_ENUMERATED *bs, char *buf, int size); ++int i2a_ASN1_OBJECT(BIO *bp, const ASN1_OBJECT *a); ++int a2i_ASN1_STRING(BIO *bp, ASN1_STRING *bs, char *buf, int size); ++int i2a_ASN1_STRING(BIO *bp, const ASN1_STRING *a, int type); ++int i2t_ASN1_OBJECT(char *buf, int buf_len, const ASN1_OBJECT *a); ++ ++int a2d_ASN1_OBJECT(unsigned char *out, int olen, const char *buf, int num); ++ASN1_OBJECT *ASN1_OBJECT_create(int nid, unsigned char *data, int len, ++ const char *sn, const char *ln); ++ ++int ASN1_INTEGER_get_int64(int64_t *pr, const ASN1_INTEGER *a); ++int ASN1_INTEGER_set_int64(ASN1_INTEGER *a, int64_t r); ++int ASN1_INTEGER_get_uint64(uint64_t *pr, const ASN1_INTEGER *a); ++int ASN1_INTEGER_set_uint64(ASN1_INTEGER *a, uint64_t r); ++ ++int ASN1_INTEGER_set(ASN1_INTEGER *a, long v); ++long ASN1_INTEGER_get(const ASN1_INTEGER *a); ++ASN1_INTEGER *BN_to_ASN1_INTEGER(const BIGNUM *bn, ASN1_INTEGER *ai); ++BIGNUM *ASN1_INTEGER_to_BN(const ASN1_INTEGER *ai, BIGNUM *bn); ++ ++int ASN1_ENUMERATED_get_int64(int64_t *pr, const ASN1_ENUMERATED *a); ++int ASN1_ENUMERATED_set_int64(ASN1_ENUMERATED *a, int64_t r); ++ ++int ASN1_ENUMERATED_set(ASN1_ENUMERATED *a, long v); ++long ASN1_ENUMERATED_get(const ASN1_ENUMERATED *a); ++ASN1_ENUMERATED *BN_to_ASN1_ENUMERATED(const BIGNUM *bn, ASN1_ENUMERATED *ai); ++BIGNUM *ASN1_ENUMERATED_to_BN(const ASN1_ENUMERATED *ai, BIGNUM *bn); ++ ++/* General */ ++/* given a string, return the correct type, max is the maximum length */ ++int ASN1_PRINTABLE_type(const unsigned char *s, int max); ++ ++unsigned long ASN1_tag2bit(int tag); ++ ++/* SPECIALS */ ++int ASN1_get_object(const unsigned char **pp, long *plength, int *ptag, ++ int *pclass, long omax); ++int ASN1_check_infinite_end(unsigned char **p, long len); ++int ASN1_const_check_infinite_end(const unsigned char **p, long len); ++void ASN1_put_object(unsigned char **pp, int constructed, int length, ++ int tag, int xclass); ++int ASN1_put_eoc(unsigned char **pp); ++int ASN1_object_size(int constructed, int length, int tag); ++ ++/* Used to implement other functions */ ++void *ASN1_dup(i2d_of_void *i2d, d2i_of_void *d2i, void *x); ++ ++# define ASN1_dup_of(type,i2d,d2i,x) \ ++ ((type*)ASN1_dup(CHECKED_I2D_OF(type, i2d), \ ++ CHECKED_D2I_OF(type, d2i), \ ++ CHECKED_PTR_OF(type, x))) ++ ++# define ASN1_dup_of_const(type,i2d,d2i,x) \ ++ ((type*)ASN1_dup(CHECKED_I2D_OF(const type, i2d), \ ++ CHECKED_D2I_OF(type, d2i), \ ++ CHECKED_PTR_OF(const type, x))) ++ ++void *ASN1_item_dup(const ASN1_ITEM *it, void *x); ++ ++/* ASN1 alloc/free macros for when a type is only used internally */ ++ ++# define M_ASN1_new_of(type) (type *)ASN1_item_new(ASN1_ITEM_rptr(type)) ++# define M_ASN1_free_of(x, type) \ ++ ASN1_item_free(CHECKED_PTR_OF(type, x), ASN1_ITEM_rptr(type)) ++ ++# ifndef OPENSSL_NO_STDIO ++void *ASN1_d2i_fp(void *(*xnew) (void), d2i_of_void *d2i, FILE *in, void **x); ++ ++# define ASN1_d2i_fp_of(type,xnew,d2i,in,x) \ ++ ((type*)ASN1_d2i_fp(CHECKED_NEW_OF(type, xnew), \ ++ CHECKED_D2I_OF(type, d2i), \ ++ in, \ ++ CHECKED_PPTR_OF(type, x))) ++ ++void *ASN1_item_d2i_fp(const ASN1_ITEM *it, FILE *in, void *x); ++int ASN1_i2d_fp(i2d_of_void *i2d, FILE *out, void *x); ++ ++# define ASN1_i2d_fp_of(type,i2d,out,x) \ ++ (ASN1_i2d_fp(CHECKED_I2D_OF(type, i2d), \ ++ out, \ ++ CHECKED_PTR_OF(type, x))) ++ ++# define ASN1_i2d_fp_of_const(type,i2d,out,x) \ ++ (ASN1_i2d_fp(CHECKED_I2D_OF(const type, i2d), \ ++ out, \ ++ CHECKED_PTR_OF(const type, x))) ++ ++int ASN1_item_i2d_fp(const ASN1_ITEM *it, FILE *out, void *x); ++int ASN1_STRING_print_ex_fp(FILE *fp, const ASN1_STRING *str, unsigned long flags); ++# endif ++ ++int ASN1_STRING_to_UTF8(unsigned char **out, const ASN1_STRING *in); ++ ++void *ASN1_d2i_bio(void *(*xnew) (void), d2i_of_void *d2i, BIO *in, void **x); ++ ++# define ASN1_d2i_bio_of(type,xnew,d2i,in,x) \ ++ ((type*)ASN1_d2i_bio( CHECKED_NEW_OF(type, xnew), \ ++ CHECKED_D2I_OF(type, d2i), \ ++ in, \ ++ CHECKED_PPTR_OF(type, x))) ++ ++void *ASN1_item_d2i_bio(const ASN1_ITEM *it, BIO *in, void *x); ++int ASN1_i2d_bio(i2d_of_void *i2d, BIO *out, unsigned char *x); ++ ++# define ASN1_i2d_bio_of(type,i2d,out,x) \ ++ (ASN1_i2d_bio(CHECKED_I2D_OF(type, i2d), \ ++ out, \ ++ CHECKED_PTR_OF(type, x))) ++ ++# define ASN1_i2d_bio_of_const(type,i2d,out,x) \ ++ (ASN1_i2d_bio(CHECKED_I2D_OF(const type, i2d), \ ++ out, \ ++ CHECKED_PTR_OF(const type, x))) ++ ++int ASN1_item_i2d_bio(const ASN1_ITEM *it, BIO *out, void *x); ++int ASN1_UTCTIME_print(BIO *fp, const ASN1_UTCTIME *a); ++int ASN1_GENERALIZEDTIME_print(BIO *fp, const ASN1_GENERALIZEDTIME *a); ++int ASN1_TIME_print(BIO *fp, const ASN1_TIME *a); ++int ASN1_STRING_print(BIO *bp, const ASN1_STRING *v); ++int ASN1_STRING_print_ex(BIO *out, const ASN1_STRING *str, unsigned long flags); ++int ASN1_buf_print(BIO *bp, const unsigned char *buf, size_t buflen, int off); ++int ASN1_bn_print(BIO *bp, const char *number, const BIGNUM *num, ++ unsigned char *buf, int off); ++int ASN1_parse(BIO *bp, const unsigned char *pp, long len, int indent); ++int ASN1_parse_dump(BIO *bp, const unsigned char *pp, long len, int indent, ++ int dump); ++const char *ASN1_tag2str(int tag); ++ ++/* Used to load and write Netscape format cert */ ++ ++int ASN1_UNIVERSALSTRING_to_string(ASN1_UNIVERSALSTRING *s); ++ ++int ASN1_TYPE_set_octetstring(ASN1_TYPE *a, unsigned char *data, int len); ++int ASN1_TYPE_get_octetstring(const ASN1_TYPE *a, unsigned char *data, int max_len); ++int ASN1_TYPE_set_int_octetstring(ASN1_TYPE *a, long num, ++ unsigned char *data, int len); ++int ASN1_TYPE_get_int_octetstring(const ASN1_TYPE *a, long *num, ++ unsigned char *data, int max_len); ++ ++void *ASN1_item_unpack(const ASN1_STRING *oct, const ASN1_ITEM *it); ++ ++ASN1_STRING *ASN1_item_pack(void *obj, const ASN1_ITEM *it, ++ ASN1_OCTET_STRING **oct); ++ ++void ASN1_STRING_set_default_mask(unsigned long mask); ++int ASN1_STRING_set_default_mask_asc(const char *p); ++unsigned long ASN1_STRING_get_default_mask(void); ++int ASN1_mbstring_copy(ASN1_STRING **out, const unsigned char *in, int len, ++ int inform, unsigned long mask); ++int ASN1_mbstring_ncopy(ASN1_STRING **out, const unsigned char *in, int len, ++ int inform, unsigned long mask, ++ long minsize, long maxsize); ++ ++ASN1_STRING *ASN1_STRING_set_by_NID(ASN1_STRING **out, ++ const unsigned char *in, int inlen, ++ int inform, int nid); ++ASN1_STRING_TABLE *ASN1_STRING_TABLE_get(int nid); ++int ASN1_STRING_TABLE_add(int, long, long, unsigned long, unsigned long); ++void ASN1_STRING_TABLE_cleanup(void); ++ ++/* ASN1 template functions */ ++ ++/* Old API compatible functions */ ++ASN1_VALUE *ASN1_item_new(const ASN1_ITEM *it); ++void ASN1_item_free(ASN1_VALUE *val, const ASN1_ITEM *it); ++ASN1_VALUE *ASN1_item_d2i(ASN1_VALUE **val, const unsigned char **in, ++ long len, const ASN1_ITEM *it); ++int ASN1_item_i2d(ASN1_VALUE *val, unsigned char **out, const ASN1_ITEM *it); ++int ASN1_item_ndef_i2d(ASN1_VALUE *val, unsigned char **out, ++ const ASN1_ITEM *it); ++ ++void ASN1_add_oid_module(void); ++void ASN1_add_stable_module(void); ++ ++ASN1_TYPE *ASN1_generate_nconf(const char *str, CONF *nconf); ++ASN1_TYPE *ASN1_generate_v3(const char *str, X509V3_CTX *cnf); ++int ASN1_str2mask(const char *str, unsigned long *pmask); ++ ++/* ASN1 Print flags */ ++ ++/* Indicate missing OPTIONAL fields */ ++# define ASN1_PCTX_FLAGS_SHOW_ABSENT 0x001 ++/* Mark start and end of SEQUENCE */ ++# define ASN1_PCTX_FLAGS_SHOW_SEQUENCE 0x002 ++/* Mark start and end of SEQUENCE/SET OF */ ++# define ASN1_PCTX_FLAGS_SHOW_SSOF 0x004 ++/* Show the ASN1 type of primitives */ ++# define ASN1_PCTX_FLAGS_SHOW_TYPE 0x008 ++/* Don't show ASN1 type of ANY */ ++# define ASN1_PCTX_FLAGS_NO_ANY_TYPE 0x010 ++/* Don't show ASN1 type of MSTRINGs */ ++# define ASN1_PCTX_FLAGS_NO_MSTRING_TYPE 0x020 ++/* Don't show field names in SEQUENCE */ ++# define ASN1_PCTX_FLAGS_NO_FIELD_NAME 0x040 ++/* Show structure names of each SEQUENCE field */ ++# define ASN1_PCTX_FLAGS_SHOW_FIELD_STRUCT_NAME 0x080 ++/* Don't show structure name even at top level */ ++# define ASN1_PCTX_FLAGS_NO_STRUCT_NAME 0x100 ++ ++int ASN1_item_print(BIO *out, ASN1_VALUE *ifld, int indent, ++ const ASN1_ITEM *it, const ASN1_PCTX *pctx); ++ASN1_PCTX *ASN1_PCTX_new(void); ++void ASN1_PCTX_free(ASN1_PCTX *p); ++unsigned long ASN1_PCTX_get_flags(const ASN1_PCTX *p); ++void ASN1_PCTX_set_flags(ASN1_PCTX *p, unsigned long flags); ++unsigned long ASN1_PCTX_get_nm_flags(const ASN1_PCTX *p); ++void ASN1_PCTX_set_nm_flags(ASN1_PCTX *p, unsigned long flags); ++unsigned long ASN1_PCTX_get_cert_flags(const ASN1_PCTX *p); ++void ASN1_PCTX_set_cert_flags(ASN1_PCTX *p, unsigned long flags); ++unsigned long ASN1_PCTX_get_oid_flags(const ASN1_PCTX *p); ++void ASN1_PCTX_set_oid_flags(ASN1_PCTX *p, unsigned long flags); ++unsigned long ASN1_PCTX_get_str_flags(const ASN1_PCTX *p); ++void ASN1_PCTX_set_str_flags(ASN1_PCTX *p, unsigned long flags); ++ ++ASN1_SCTX *ASN1_SCTX_new(int (*scan_cb) (ASN1_SCTX *ctx)); ++void ASN1_SCTX_free(ASN1_SCTX *p); ++const ASN1_ITEM *ASN1_SCTX_get_item(ASN1_SCTX *p); ++const ASN1_TEMPLATE *ASN1_SCTX_get_template(ASN1_SCTX *p); ++unsigned long ASN1_SCTX_get_flags(ASN1_SCTX *p); ++void ASN1_SCTX_set_app_data(ASN1_SCTX *p, void *data); ++void *ASN1_SCTX_get_app_data(ASN1_SCTX *p); ++ ++const BIO_METHOD *BIO_f_asn1(void); ++ ++BIO *BIO_new_NDEF(BIO *out, ASN1_VALUE *val, const ASN1_ITEM *it); ++ ++int i2d_ASN1_bio_stream(BIO *out, ASN1_VALUE *val, BIO *in, int flags, ++ const ASN1_ITEM *it); ++int PEM_write_bio_ASN1_stream(BIO *out, ASN1_VALUE *val, BIO *in, int flags, ++ const char *hdr, const ASN1_ITEM *it); ++int SMIME_write_ASN1(BIO *bio, ASN1_VALUE *val, BIO *data, int flags, ++ int ctype_nid, int econt_nid, ++ STACK_OF(X509_ALGOR) *mdalgs, const ASN1_ITEM *it); ++ASN1_VALUE *SMIME_read_ASN1(BIO *bio, BIO **bcont, const ASN1_ITEM *it); ++int SMIME_crlf_copy(BIO *in, BIO *out, int flags); ++int SMIME_text(BIO *in, BIO *out); ++ ++const ASN1_ITEM *ASN1_ITEM_lookup(const char *name); ++const ASN1_ITEM *ASN1_ITEM_get(size_t i); ++ ++# ifdef __cplusplus ++} ++# endif ++#endif +diff --git a/include/TA/openssl/openssl/asn1err.h b/include/TA/openssl/openssl/asn1err.h +new file mode 100644 +index 0000000..e1ad1fe +--- /dev/null ++++ b/include/TA/openssl/openssl/asn1err.h +@@ -0,0 +1,256 @@ ++/* ++ * Generated by util/mkerr.pl DO NOT EDIT ++ * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved. ++ * ++ * Licensed under the OpenSSL license (the "License"). You may not use ++ * this file except in compliance with the License. You can obtain a copy ++ * in the file LICENSE in the source distribution or at ++ * https://www.openssl.org/source/license.html ++ */ ++ ++#ifndef HEADER_ASN1ERR_H ++# define HEADER_ASN1ERR_H ++ ++# include ++ ++# ifdef __cplusplus ++extern "C" ++# endif ++int ERR_load_ASN1_strings(void); ++ ++/* ++ * ASN1 function codes. ++ */ ++# define ASN1_F_A2D_ASN1_OBJECT 100 ++# define ASN1_F_A2I_ASN1_INTEGER 102 ++# define ASN1_F_A2I_ASN1_STRING 103 ++# define ASN1_F_APPEND_EXP 176 ++# define ASN1_F_ASN1_BIO_INIT 113 ++# define ASN1_F_ASN1_BIT_STRING_SET_BIT 183 ++# define ASN1_F_ASN1_CB 177 ++# define ASN1_F_ASN1_CHECK_TLEN 104 ++# define ASN1_F_ASN1_COLLECT 106 ++# define ASN1_F_ASN1_D2I_EX_PRIMITIVE 108 ++# define ASN1_F_ASN1_D2I_FP 109 ++# define ASN1_F_ASN1_D2I_READ_BIO 107 ++# define ASN1_F_ASN1_DIGEST 184 ++# define ASN1_F_ASN1_DO_ADB 110 ++# define ASN1_F_ASN1_DO_LOCK 233 ++# define ASN1_F_ASN1_DUP 111 ++# define ASN1_F_ASN1_ENC_SAVE 115 ++# define ASN1_F_ASN1_EX_C2I 204 ++# define ASN1_F_ASN1_FIND_END 190 ++# define ASN1_F_ASN1_GENERALIZEDTIME_ADJ 216 ++# define ASN1_F_ASN1_GENERATE_V3 178 ++# define ASN1_F_ASN1_GET_INT64 224 ++# define ASN1_F_ASN1_GET_OBJECT 114 ++# define ASN1_F_ASN1_GET_UINT64 225 ++# define ASN1_F_ASN1_I2D_BIO 116 ++# define ASN1_F_ASN1_I2D_FP 117 ++# define ASN1_F_ASN1_ITEM_D2I_FP 206 ++# define ASN1_F_ASN1_ITEM_DUP 191 ++# define ASN1_F_ASN1_ITEM_EMBED_D2I 120 ++# define ASN1_F_ASN1_ITEM_EMBED_NEW 121 ++# define ASN1_F_ASN1_ITEM_EX_I2D 144 ++# define ASN1_F_ASN1_ITEM_FLAGS_I2D 118 ++# define ASN1_F_ASN1_ITEM_I2D_BIO 192 ++# define ASN1_F_ASN1_ITEM_I2D_FP 193 ++# define ASN1_F_ASN1_ITEM_PACK 198 ++# define ASN1_F_ASN1_ITEM_SIGN 195 ++# define ASN1_F_ASN1_ITEM_SIGN_CTX 220 ++# define ASN1_F_ASN1_ITEM_UNPACK 199 ++# define ASN1_F_ASN1_ITEM_VERIFY 197 ++# define ASN1_F_ASN1_MBSTRING_NCOPY 122 ++# define ASN1_F_ASN1_OBJECT_NEW 123 ++# define ASN1_F_ASN1_OUTPUT_DATA 214 ++# define ASN1_F_ASN1_PCTX_NEW 205 ++# define ASN1_F_ASN1_PRIMITIVE_NEW 119 ++# define ASN1_F_ASN1_SCTX_NEW 221 ++# define ASN1_F_ASN1_SIGN 128 ++# define ASN1_F_ASN1_STR2TYPE 179 ++# define ASN1_F_ASN1_STRING_GET_INT64 227 ++# define ASN1_F_ASN1_STRING_GET_UINT64 230 ++# define ASN1_F_ASN1_STRING_SET 186 ++# define ASN1_F_ASN1_STRING_TABLE_ADD 129 ++# define ASN1_F_ASN1_STRING_TO_BN 228 ++# define ASN1_F_ASN1_STRING_TYPE_NEW 130 ++# define ASN1_F_ASN1_TEMPLATE_EX_D2I 132 ++# define ASN1_F_ASN1_TEMPLATE_NEW 133 ++# define ASN1_F_ASN1_TEMPLATE_NOEXP_D2I 131 ++# define ASN1_F_ASN1_TIME_ADJ 217 ++# define ASN1_F_ASN1_TYPE_GET_INT_OCTETSTRING 134 ++# define ASN1_F_ASN1_TYPE_GET_OCTETSTRING 135 ++# define ASN1_F_ASN1_UTCTIME_ADJ 218 ++# define ASN1_F_ASN1_VERIFY 137 ++# define ASN1_F_B64_READ_ASN1 209 ++# define ASN1_F_B64_WRITE_ASN1 210 ++# define ASN1_F_BIO_NEW_NDEF 208 ++# define ASN1_F_BITSTR_CB 180 ++# define ASN1_F_BN_TO_ASN1_STRING 229 ++# define ASN1_F_C2I_ASN1_BIT_STRING 189 ++# define ASN1_F_C2I_ASN1_INTEGER 194 ++# define ASN1_F_C2I_ASN1_OBJECT 196 ++# define ASN1_F_C2I_IBUF 226 ++# define ASN1_F_C2I_UINT64_INT 101 ++# define ASN1_F_COLLECT_DATA 140 ++# define ASN1_F_D2I_ASN1_OBJECT 147 ++# define ASN1_F_D2I_ASN1_UINTEGER 150 ++# define ASN1_F_D2I_AUTOPRIVATEKEY 207 ++# define ASN1_F_D2I_PRIVATEKEY 154 ++# define ASN1_F_D2I_PUBLICKEY 155 ++# define ASN1_F_DO_BUF 142 ++# define ASN1_F_DO_CREATE 124 ++# define ASN1_F_DO_DUMP 125 ++# define ASN1_F_DO_TCREATE 222 ++# define ASN1_F_I2A_ASN1_OBJECT 126 ++# define ASN1_F_I2D_ASN1_BIO_STREAM 211 ++# define ASN1_F_I2D_ASN1_OBJECT 143 ++# define ASN1_F_I2D_DSA_PUBKEY 161 ++# define ASN1_F_I2D_EC_PUBKEY 181 ++# define ASN1_F_I2D_PRIVATEKEY 163 ++# define ASN1_F_I2D_PUBLICKEY 164 ++# define ASN1_F_I2D_RSA_PUBKEY 165 ++# define ASN1_F_LONG_C2I 166 ++# define ASN1_F_NDEF_PREFIX 127 ++# define ASN1_F_NDEF_SUFFIX 136 ++# define ASN1_F_OID_MODULE_INIT 174 ++# define ASN1_F_PARSE_TAGGING 182 ++# define ASN1_F_PKCS5_PBE2_SET_IV 167 ++# define ASN1_F_PKCS5_PBE2_SET_SCRYPT 231 ++# define ASN1_F_PKCS5_PBE_SET 202 ++# define ASN1_F_PKCS5_PBE_SET0_ALGOR 215 ++# define ASN1_F_PKCS5_PBKDF2_SET 219 ++# define ASN1_F_PKCS5_SCRYPT_SET 232 ++# define ASN1_F_SMIME_READ_ASN1 212 ++# define ASN1_F_SMIME_TEXT 213 ++# define ASN1_F_STABLE_GET 138 ++# define ASN1_F_STBL_MODULE_INIT 223 ++# define ASN1_F_UINT32_C2I 105 ++# define ASN1_F_UINT32_NEW 139 ++# define ASN1_F_UINT64_C2I 112 ++# define ASN1_F_UINT64_NEW 141 ++# define ASN1_F_X509_CRL_ADD0_REVOKED 169 ++# define ASN1_F_X509_INFO_NEW 170 ++# define ASN1_F_X509_NAME_ENCODE 203 ++# define ASN1_F_X509_NAME_EX_D2I 158 ++# define ASN1_F_X509_NAME_EX_NEW 171 ++# define ASN1_F_X509_PKEY_NEW 173 ++ ++/* ++ * ASN1 reason codes. ++ */ ++# define ASN1_R_ADDING_OBJECT 171 ++# define ASN1_R_ASN1_PARSE_ERROR 203 ++# define ASN1_R_ASN1_SIG_PARSE_ERROR 204 ++# define ASN1_R_AUX_ERROR 100 ++# define ASN1_R_BAD_OBJECT_HEADER 102 ++# define ASN1_R_BAD_TEMPLATE 230 ++# define ASN1_R_BMPSTRING_IS_WRONG_LENGTH 214 ++# define ASN1_R_BN_LIB 105 ++# define ASN1_R_BOOLEAN_IS_WRONG_LENGTH 106 ++# define ASN1_R_BUFFER_TOO_SMALL 107 ++# define ASN1_R_CIPHER_HAS_NO_OBJECT_IDENTIFIER 108 ++# define ASN1_R_CONTEXT_NOT_INITIALISED 217 ++# define ASN1_R_DATA_IS_WRONG 109 ++# define ASN1_R_DECODE_ERROR 110 ++# define ASN1_R_DEPTH_EXCEEDED 174 ++# define ASN1_R_DIGEST_AND_KEY_TYPE_NOT_SUPPORTED 198 ++# define ASN1_R_ENCODE_ERROR 112 ++# define ASN1_R_ERROR_GETTING_TIME 173 ++# define ASN1_R_ERROR_LOADING_SECTION 172 ++# define ASN1_R_ERROR_SETTING_CIPHER_PARAMS 114 ++# define ASN1_R_EXPECTING_AN_INTEGER 115 ++# define ASN1_R_EXPECTING_AN_OBJECT 116 ++# define ASN1_R_EXPLICIT_LENGTH_MISMATCH 119 ++# define ASN1_R_EXPLICIT_TAG_NOT_CONSTRUCTED 120 ++# define ASN1_R_FIELD_MISSING 121 ++# define ASN1_R_FIRST_NUM_TOO_LARGE 122 ++# define ASN1_R_HEADER_TOO_LONG 123 ++# define ASN1_R_ILLEGAL_BITSTRING_FORMAT 175 ++# define ASN1_R_ILLEGAL_BOOLEAN 176 ++# define ASN1_R_ILLEGAL_CHARACTERS 124 ++# define ASN1_R_ILLEGAL_FORMAT 177 ++# define ASN1_R_ILLEGAL_HEX 178 ++# define ASN1_R_ILLEGAL_IMPLICIT_TAG 179 ++# define ASN1_R_ILLEGAL_INTEGER 180 ++# define ASN1_R_ILLEGAL_NEGATIVE_VALUE 226 ++# define ASN1_R_ILLEGAL_NESTED_TAGGING 181 ++# define ASN1_R_ILLEGAL_NULL 125 ++# define ASN1_R_ILLEGAL_NULL_VALUE 182 ++# define ASN1_R_ILLEGAL_OBJECT 183 ++# define ASN1_R_ILLEGAL_OPTIONAL_ANY 126 ++# define ASN1_R_ILLEGAL_OPTIONS_ON_ITEM_TEMPLATE 170 ++# define ASN1_R_ILLEGAL_PADDING 221 ++# define ASN1_R_ILLEGAL_TAGGED_ANY 127 ++# define ASN1_R_ILLEGAL_TIME_VALUE 184 ++# define ASN1_R_ILLEGAL_ZERO_CONTENT 222 ++# define ASN1_R_INTEGER_NOT_ASCII_FORMAT 185 ++# define ASN1_R_INTEGER_TOO_LARGE_FOR_LONG 128 ++# define ASN1_R_INVALID_BIT_STRING_BITS_LEFT 220 ++# define ASN1_R_INVALID_BMPSTRING_LENGTH 129 ++# define ASN1_R_INVALID_DIGIT 130 ++# define ASN1_R_INVALID_MIME_TYPE 205 ++# define ASN1_R_INVALID_MODIFIER 186 ++# define ASN1_R_INVALID_NUMBER 187 ++# define ASN1_R_INVALID_OBJECT_ENCODING 216 ++# define ASN1_R_INVALID_SCRYPT_PARAMETERS 227 ++# define ASN1_R_INVALID_SEPARATOR 131 ++# define ASN1_R_INVALID_STRING_TABLE_VALUE 218 ++# define ASN1_R_INVALID_UNIVERSALSTRING_LENGTH 133 ++# define ASN1_R_INVALID_UTF8STRING 134 ++# define ASN1_R_INVALID_VALUE 219 ++# define ASN1_R_LIST_ERROR 188 ++# define ASN1_R_MIME_NO_CONTENT_TYPE 206 ++# define ASN1_R_MIME_PARSE_ERROR 207 ++# define ASN1_R_MIME_SIG_PARSE_ERROR 208 ++# define ASN1_R_MISSING_EOC 137 ++# define ASN1_R_MISSING_SECOND_NUMBER 138 ++# define ASN1_R_MISSING_VALUE 189 ++# define ASN1_R_MSTRING_NOT_UNIVERSAL 139 ++# define ASN1_R_MSTRING_WRONG_TAG 140 ++# define ASN1_R_NESTED_ASN1_STRING 197 ++# define ASN1_R_NESTED_TOO_DEEP 201 ++# define ASN1_R_NON_HEX_CHARACTERS 141 ++# define ASN1_R_NOT_ASCII_FORMAT 190 ++# define ASN1_R_NOT_ENOUGH_DATA 142 ++# define ASN1_R_NO_CONTENT_TYPE 209 ++# define ASN1_R_NO_MATCHING_CHOICE_TYPE 143 ++# define ASN1_R_NO_MULTIPART_BODY_FAILURE 210 ++# define ASN1_R_NO_MULTIPART_BOUNDARY 211 ++# define ASN1_R_NO_SIG_CONTENT_TYPE 212 ++# define ASN1_R_NULL_IS_WRONG_LENGTH 144 ++# define ASN1_R_OBJECT_NOT_ASCII_FORMAT 191 ++# define ASN1_R_ODD_NUMBER_OF_CHARS 145 ++# define ASN1_R_SECOND_NUMBER_TOO_LARGE 147 ++# define ASN1_R_SEQUENCE_LENGTH_MISMATCH 148 ++# define ASN1_R_SEQUENCE_NOT_CONSTRUCTED 149 ++# define ASN1_R_SEQUENCE_OR_SET_NEEDS_CONFIG 192 ++# define ASN1_R_SHORT_LINE 150 ++# define ASN1_R_SIG_INVALID_MIME_TYPE 213 ++# define ASN1_R_STREAMING_NOT_SUPPORTED 202 ++# define ASN1_R_STRING_TOO_LONG 151 ++# define ASN1_R_STRING_TOO_SHORT 152 ++# define ASN1_R_THE_ASN1_OBJECT_IDENTIFIER_IS_NOT_KNOWN_FOR_THIS_MD 154 ++# define ASN1_R_TIME_NOT_ASCII_FORMAT 193 ++# define ASN1_R_TOO_LARGE 223 ++# define ASN1_R_TOO_LONG 155 ++# define ASN1_R_TOO_SMALL 224 ++# define ASN1_R_TYPE_NOT_CONSTRUCTED 156 ++# define ASN1_R_TYPE_NOT_PRIMITIVE 195 ++# define ASN1_R_UNEXPECTED_EOC 159 ++# define ASN1_R_UNIVERSALSTRING_IS_WRONG_LENGTH 215 ++# define ASN1_R_UNKNOWN_FORMAT 160 ++# define ASN1_R_UNKNOWN_MESSAGE_DIGEST_ALGORITHM 161 ++# define ASN1_R_UNKNOWN_OBJECT_TYPE 162 ++# define ASN1_R_UNKNOWN_PUBLIC_KEY_TYPE 163 ++# define ASN1_R_UNKNOWN_SIGNATURE_ALGORITHM 199 ++# define ASN1_R_UNKNOWN_TAG 194 ++# define ASN1_R_UNSUPPORTED_ANY_DEFINED_BY_TYPE 164 ++# define ASN1_R_UNSUPPORTED_CIPHER 228 ++# define ASN1_R_UNSUPPORTED_PUBLIC_KEY_TYPE 167 ++# define ASN1_R_UNSUPPORTED_TYPE 196 ++# define ASN1_R_WRONG_INTEGER_TYPE 225 ++# define ASN1_R_WRONG_PUBLIC_KEY_TYPE 200 ++# define ASN1_R_WRONG_TAG 168 ++ ++#endif +diff --git a/include/TA/openssl/openssl/asn1t.h b/include/TA/openssl/openssl/asn1t.h +new file mode 100644 +index 0000000..4c326ea +--- /dev/null ++++ b/include/TA/openssl/openssl/asn1t.h +@@ -0,0 +1,962 @@ ++/* ++ * Copyright 2000-2016 The OpenSSL Project Authors. All Rights Reserved. ++ * ++ * Licensed under the OpenSSL license (the "License"). You may not use ++ * this file except in compliance with the License. You can obtain a copy ++ * in the file LICENSE in the source distribution or at ++ * https://www.openssl.org/source/license.html ++ */ ++ ++#ifndef HEADER_ASN1T_H ++# define HEADER_ASN1T_H ++ ++# include ++# include ++# include ++ ++# ifdef OPENSSL_BUILD_SHLIBCRYPTO ++# undef OPENSSL_EXTERN ++# define OPENSSL_EXTERN OPENSSL_EXPORT ++# endif ++ ++/* ASN1 template defines, structures and functions */ ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++# ifndef OPENSSL_EXPORT_VAR_AS_FUNCTION ++ ++/* Macro to obtain ASN1_ADB pointer from a type (only used internally) */ ++# define ASN1_ADB_ptr(iptr) ((const ASN1_ADB *)(iptr)) ++ ++/* Macros for start and end of ASN1_ITEM definition */ ++ ++# define ASN1_ITEM_start(itname) \ ++ const ASN1_ITEM itname##_it = { ++ ++# define static_ASN1_ITEM_start(itname) \ ++ static const ASN1_ITEM itname##_it = { ++ ++# define ASN1_ITEM_end(itname) \ ++ }; ++ ++# else ++ ++/* Macro to obtain ASN1_ADB pointer from a type (only used internally) */ ++# define ASN1_ADB_ptr(iptr) ((const ASN1_ADB *)((iptr)())) ++ ++/* Macros for start and end of ASN1_ITEM definition */ ++ ++# define ASN1_ITEM_start(itname) \ ++ const ASN1_ITEM * itname##_it(void) \ ++ { \ ++ static const ASN1_ITEM local_it = { ++ ++# define static_ASN1_ITEM_start(itname) \ ++ static ASN1_ITEM_start(itname) ++ ++# define ASN1_ITEM_end(itname) \ ++ }; \ ++ return &local_it; \ ++ } ++ ++# endif ++ ++/* Macros to aid ASN1 template writing */ ++ ++# define ASN1_ITEM_TEMPLATE(tname) \ ++ static const ASN1_TEMPLATE tname##_item_tt ++ ++# define ASN1_ITEM_TEMPLATE_END(tname) \ ++ ;\ ++ ASN1_ITEM_start(tname) \ ++ ASN1_ITYPE_PRIMITIVE,\ ++ -1,\ ++ &tname##_item_tt,\ ++ 0,\ ++ NULL,\ ++ 0,\ ++ #tname \ ++ ASN1_ITEM_end(tname) ++# define static_ASN1_ITEM_TEMPLATE_END(tname) \ ++ ;\ ++ static_ASN1_ITEM_start(tname) \ ++ ASN1_ITYPE_PRIMITIVE,\ ++ -1,\ ++ &tname##_item_tt,\ ++ 0,\ ++ NULL,\ ++ 0,\ ++ #tname \ ++ ASN1_ITEM_end(tname) ++ ++/* This is a ASN1 type which just embeds a template */ ++ ++/*- ++ * This pair helps declare a SEQUENCE. We can do: ++ * ++ * ASN1_SEQUENCE(stname) = { ++ * ... SEQUENCE components ... ++ * } ASN1_SEQUENCE_END(stname) ++ * ++ * This will produce an ASN1_ITEM called stname_it ++ * for a structure called stname. ++ * ++ * If you want the same structure but a different ++ * name then use: ++ * ++ * ASN1_SEQUENCE(itname) = { ++ * ... SEQUENCE components ... ++ * } ASN1_SEQUENCE_END_name(stname, itname) ++ * ++ * This will create an item called itname_it using ++ * a structure called stname. ++ */ ++ ++# define ASN1_SEQUENCE(tname) \ ++ static const ASN1_TEMPLATE tname##_seq_tt[] ++ ++# define ASN1_SEQUENCE_END(stname) ASN1_SEQUENCE_END_name(stname, stname) ++ ++# define static_ASN1_SEQUENCE_END(stname) static_ASN1_SEQUENCE_END_name(stname, stname) ++ ++# define ASN1_SEQUENCE_END_name(stname, tname) \ ++ ;\ ++ ASN1_ITEM_start(tname) \ ++ ASN1_ITYPE_SEQUENCE,\ ++ V_ASN1_SEQUENCE,\ ++ tname##_seq_tt,\ ++ sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\ ++ NULL,\ ++ sizeof(stname),\ ++ #tname \ ++ ASN1_ITEM_end(tname) ++ ++# define static_ASN1_SEQUENCE_END_name(stname, tname) \ ++ ;\ ++ static_ASN1_ITEM_start(tname) \ ++ ASN1_ITYPE_SEQUENCE,\ ++ V_ASN1_SEQUENCE,\ ++ tname##_seq_tt,\ ++ sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\ ++ NULL,\ ++ sizeof(stname),\ ++ #stname \ ++ ASN1_ITEM_end(tname) ++ ++# define ASN1_NDEF_SEQUENCE(tname) \ ++ ASN1_SEQUENCE(tname) ++ ++# define ASN1_NDEF_SEQUENCE_cb(tname, cb) \ ++ ASN1_SEQUENCE_cb(tname, cb) ++ ++# define ASN1_SEQUENCE_cb(tname, cb) \ ++ static const ASN1_AUX tname##_aux = {NULL, 0, 0, 0, cb, 0}; \ ++ ASN1_SEQUENCE(tname) ++ ++# define ASN1_BROKEN_SEQUENCE(tname) \ ++ static const ASN1_AUX tname##_aux = {NULL, ASN1_AFLG_BROKEN, 0, 0, 0, 0}; \ ++ ASN1_SEQUENCE(tname) ++ ++# define ASN1_SEQUENCE_ref(tname, cb) \ ++ static const ASN1_AUX tname##_aux = {NULL, ASN1_AFLG_REFCOUNT, offsetof(tname, references), offsetof(tname, lock), cb, 0}; \ ++ ASN1_SEQUENCE(tname) ++ ++# define ASN1_SEQUENCE_enc(tname, enc, cb) \ ++ static const ASN1_AUX tname##_aux = {NULL, ASN1_AFLG_ENCODING, 0, 0, cb, offsetof(tname, enc)}; \ ++ ASN1_SEQUENCE(tname) ++ ++# define ASN1_NDEF_SEQUENCE_END(tname) \ ++ ;\ ++ ASN1_ITEM_start(tname) \ ++ ASN1_ITYPE_NDEF_SEQUENCE,\ ++ V_ASN1_SEQUENCE,\ ++ tname##_seq_tt,\ ++ sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\ ++ NULL,\ ++ sizeof(tname),\ ++ #tname \ ++ ASN1_ITEM_end(tname) ++# define static_ASN1_NDEF_SEQUENCE_END(tname) \ ++ ;\ ++ static_ASN1_ITEM_start(tname) \ ++ ASN1_ITYPE_NDEF_SEQUENCE,\ ++ V_ASN1_SEQUENCE,\ ++ tname##_seq_tt,\ ++ sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\ ++ NULL,\ ++ sizeof(tname),\ ++ #tname \ ++ ASN1_ITEM_end(tname) ++ ++# define ASN1_BROKEN_SEQUENCE_END(stname) ASN1_SEQUENCE_END_ref(stname, stname) ++# define static_ASN1_BROKEN_SEQUENCE_END(stname) \ ++ static_ASN1_SEQUENCE_END_ref(stname, stname) ++ ++# define ASN1_SEQUENCE_END_enc(stname, tname) ASN1_SEQUENCE_END_ref(stname, tname) ++ ++# define ASN1_SEQUENCE_END_cb(stname, tname) ASN1_SEQUENCE_END_ref(stname, tname) ++# define static_ASN1_SEQUENCE_END_cb(stname, tname) static_ASN1_SEQUENCE_END_ref(stname, tname) ++ ++# define ASN1_SEQUENCE_END_ref(stname, tname) \ ++ ;\ ++ ASN1_ITEM_start(tname) \ ++ ASN1_ITYPE_SEQUENCE,\ ++ V_ASN1_SEQUENCE,\ ++ tname##_seq_tt,\ ++ sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\ ++ &tname##_aux,\ ++ sizeof(stname),\ ++ #tname \ ++ ASN1_ITEM_end(tname) ++# define static_ASN1_SEQUENCE_END_ref(stname, tname) \ ++ ;\ ++ static_ASN1_ITEM_start(tname) \ ++ ASN1_ITYPE_SEQUENCE,\ ++ V_ASN1_SEQUENCE,\ ++ tname##_seq_tt,\ ++ sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\ ++ &tname##_aux,\ ++ sizeof(stname),\ ++ #stname \ ++ ASN1_ITEM_end(tname) ++ ++# define ASN1_NDEF_SEQUENCE_END_cb(stname, tname) \ ++ ;\ ++ ASN1_ITEM_start(tname) \ ++ ASN1_ITYPE_NDEF_SEQUENCE,\ ++ V_ASN1_SEQUENCE,\ ++ tname##_seq_tt,\ ++ sizeof(tname##_seq_tt) / sizeof(ASN1_TEMPLATE),\ ++ &tname##_aux,\ ++ sizeof(stname),\ ++ #stname \ ++ ASN1_ITEM_end(tname) ++ ++/*- ++ * This pair helps declare a CHOICE type. We can do: ++ * ++ * ASN1_CHOICE(chname) = { ++ * ... CHOICE options ... ++ * ASN1_CHOICE_END(chname) ++ * ++ * This will produce an ASN1_ITEM called chname_it ++ * for a structure called chname. The structure ++ * definition must look like this: ++ * typedef struct { ++ * int type; ++ * union { ++ * ASN1_SOMETHING *opt1; ++ * ASN1_SOMEOTHER *opt2; ++ * } value; ++ * } chname; ++ * ++ * the name of the selector must be 'type'. ++ * to use an alternative selector name use the ++ * ASN1_CHOICE_END_selector() version. ++ */ ++ ++# define ASN1_CHOICE(tname) \ ++ static const ASN1_TEMPLATE tname##_ch_tt[] ++ ++# define ASN1_CHOICE_cb(tname, cb) \ ++ static const ASN1_AUX tname##_aux = {NULL, 0, 0, 0, cb, 0}; \ ++ ASN1_CHOICE(tname) ++ ++# define ASN1_CHOICE_END(stname) ASN1_CHOICE_END_name(stname, stname) ++ ++# define static_ASN1_CHOICE_END(stname) static_ASN1_CHOICE_END_name(stname, stname) ++ ++# define ASN1_CHOICE_END_name(stname, tname) ASN1_CHOICE_END_selector(stname, tname, type) ++ ++# define static_ASN1_CHOICE_END_name(stname, tname) static_ASN1_CHOICE_END_selector(stname, tname, type) ++ ++# define ASN1_CHOICE_END_selector(stname, tname, selname) \ ++ ;\ ++ ASN1_ITEM_start(tname) \ ++ ASN1_ITYPE_CHOICE,\ ++ offsetof(stname,selname) ,\ ++ tname##_ch_tt,\ ++ sizeof(tname##_ch_tt) / sizeof(ASN1_TEMPLATE),\ ++ NULL,\ ++ sizeof(stname),\ ++ #stname \ ++ ASN1_ITEM_end(tname) ++ ++# define static_ASN1_CHOICE_END_selector(stname, tname, selname) \ ++ ;\ ++ static_ASN1_ITEM_start(tname) \ ++ ASN1_ITYPE_CHOICE,\ ++ offsetof(stname,selname) ,\ ++ tname##_ch_tt,\ ++ sizeof(tname##_ch_tt) / sizeof(ASN1_TEMPLATE),\ ++ NULL,\ ++ sizeof(stname),\ ++ #stname \ ++ ASN1_ITEM_end(tname) ++ ++# define ASN1_CHOICE_END_cb(stname, tname, selname) \ ++ ;\ ++ ASN1_ITEM_start(tname) \ ++ ASN1_ITYPE_CHOICE,\ ++ offsetof(stname,selname) ,\ ++ tname##_ch_tt,\ ++ sizeof(tname##_ch_tt) / sizeof(ASN1_TEMPLATE),\ ++ &tname##_aux,\ ++ sizeof(stname),\ ++ #stname \ ++ ASN1_ITEM_end(tname) ++ ++/* This helps with the template wrapper form of ASN1_ITEM */ ++ ++# define ASN1_EX_TEMPLATE_TYPE(flags, tag, name, type) { \ ++ (flags), (tag), 0,\ ++ #name, ASN1_ITEM_ref(type) } ++ ++/* These help with SEQUENCE or CHOICE components */ ++ ++/* used to declare other types */ ++ ++# define ASN1_EX_TYPE(flags, tag, stname, field, type) { \ ++ (flags), (tag), offsetof(stname, field),\ ++ #field, ASN1_ITEM_ref(type) } ++ ++/* implicit and explicit helper macros */ ++ ++# define ASN1_IMP_EX(stname, field, type, tag, ex) \ ++ ASN1_EX_TYPE(ASN1_TFLG_IMPLICIT | (ex), tag, stname, field, type) ++ ++# define ASN1_EXP_EX(stname, field, type, tag, ex) \ ++ ASN1_EX_TYPE(ASN1_TFLG_EXPLICIT | (ex), tag, stname, field, type) ++ ++/* Any defined by macros: the field used is in the table itself */ ++ ++# ifndef OPENSSL_EXPORT_VAR_AS_FUNCTION ++# define ASN1_ADB_OBJECT(tblname) { ASN1_TFLG_ADB_OID, -1, 0, #tblname, (const ASN1_ITEM *)&(tblname##_adb) } ++# define ASN1_ADB_INTEGER(tblname) { ASN1_TFLG_ADB_INT, -1, 0, #tblname, (const ASN1_ITEM *)&(tblname##_adb) } ++# else ++# define ASN1_ADB_OBJECT(tblname) { ASN1_TFLG_ADB_OID, -1, 0, #tblname, tblname##_adb } ++# define ASN1_ADB_INTEGER(tblname) { ASN1_TFLG_ADB_INT, -1, 0, #tblname, tblname##_adb } ++# endif ++/* Plain simple type */ ++# define ASN1_SIMPLE(stname, field, type) ASN1_EX_TYPE(0,0, stname, field, type) ++/* Embedded simple type */ ++# define ASN1_EMBED(stname, field, type) ASN1_EX_TYPE(ASN1_TFLG_EMBED,0, stname, field, type) ++ ++/* OPTIONAL simple type */ ++# define ASN1_OPT(stname, field, type) ASN1_EX_TYPE(ASN1_TFLG_OPTIONAL, 0, stname, field, type) ++# define ASN1_OPT_EMBED(stname, field, type) ASN1_EX_TYPE(ASN1_TFLG_OPTIONAL|ASN1_TFLG_EMBED, 0, stname, field, type) ++ ++/* IMPLICIT tagged simple type */ ++# define ASN1_IMP(stname, field, type, tag) ASN1_IMP_EX(stname, field, type, tag, 0) ++# define ASN1_IMP_EMBED(stname, field, type, tag) ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_EMBED) ++ ++/* IMPLICIT tagged OPTIONAL simple type */ ++# define ASN1_IMP_OPT(stname, field, type, tag) ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL) ++# define ASN1_IMP_OPT_EMBED(stname, field, type, tag) ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL|ASN1_TFLG_EMBED) ++ ++/* Same as above but EXPLICIT */ ++ ++# define ASN1_EXP(stname, field, type, tag) ASN1_EXP_EX(stname, field, type, tag, 0) ++# define ASN1_EXP_EMBED(stname, field, type, tag) ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_EMBED) ++# define ASN1_EXP_OPT(stname, field, type, tag) ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL) ++# define ASN1_EXP_OPT_EMBED(stname, field, type, tag) ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL|ASN1_TFLG_EMBED) ++ ++/* SEQUENCE OF type */ ++# define ASN1_SEQUENCE_OF(stname, field, type) \ ++ ASN1_EX_TYPE(ASN1_TFLG_SEQUENCE_OF, 0, stname, field, type) ++ ++/* OPTIONAL SEQUENCE OF */ ++# define ASN1_SEQUENCE_OF_OPT(stname, field, type) \ ++ ASN1_EX_TYPE(ASN1_TFLG_SEQUENCE_OF|ASN1_TFLG_OPTIONAL, 0, stname, field, type) ++ ++/* Same as above but for SET OF */ ++ ++# define ASN1_SET_OF(stname, field, type) \ ++ ASN1_EX_TYPE(ASN1_TFLG_SET_OF, 0, stname, field, type) ++ ++# define ASN1_SET_OF_OPT(stname, field, type) \ ++ ASN1_EX_TYPE(ASN1_TFLG_SET_OF|ASN1_TFLG_OPTIONAL, 0, stname, field, type) ++ ++/* Finally compound types of SEQUENCE, SET, IMPLICIT, EXPLICIT and OPTIONAL */ ++ ++# define ASN1_IMP_SET_OF(stname, field, type, tag) \ ++ ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF) ++ ++# define ASN1_EXP_SET_OF(stname, field, type, tag) \ ++ ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF) ++ ++# define ASN1_IMP_SET_OF_OPT(stname, field, type, tag) \ ++ ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF|ASN1_TFLG_OPTIONAL) ++ ++# define ASN1_EXP_SET_OF_OPT(stname, field, type, tag) \ ++ ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SET_OF|ASN1_TFLG_OPTIONAL) ++ ++# define ASN1_IMP_SEQUENCE_OF(stname, field, type, tag) \ ++ ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF) ++ ++# define ASN1_IMP_SEQUENCE_OF_OPT(stname, field, type, tag) \ ++ ASN1_IMP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF|ASN1_TFLG_OPTIONAL) ++ ++# define ASN1_EXP_SEQUENCE_OF(stname, field, type, tag) \ ++ ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF) ++ ++# define ASN1_EXP_SEQUENCE_OF_OPT(stname, field, type, tag) \ ++ ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_SEQUENCE_OF|ASN1_TFLG_OPTIONAL) ++ ++/* EXPLICIT using indefinite length constructed form */ ++# define ASN1_NDEF_EXP(stname, field, type, tag) \ ++ ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_NDEF) ++ ++/* EXPLICIT OPTIONAL using indefinite length constructed form */ ++# define ASN1_NDEF_EXP_OPT(stname, field, type, tag) \ ++ ASN1_EXP_EX(stname, field, type, tag, ASN1_TFLG_OPTIONAL|ASN1_TFLG_NDEF) ++ ++/* Macros for the ASN1_ADB structure */ ++ ++# define ASN1_ADB(name) \ ++ static const ASN1_ADB_TABLE name##_adbtbl[] ++ ++# ifndef OPENSSL_EXPORT_VAR_AS_FUNCTION ++ ++# define ASN1_ADB_END(name, flags, field, adb_cb, def, none) \ ++ ;\ ++ static const ASN1_ADB name##_adb = {\ ++ flags,\ ++ offsetof(name, field),\ ++ adb_cb,\ ++ name##_adbtbl,\ ++ sizeof(name##_adbtbl) / sizeof(ASN1_ADB_TABLE),\ ++ def,\ ++ none\ ++ } ++ ++# else ++ ++# define ASN1_ADB_END(name, flags, field, adb_cb, def, none) \ ++ ;\ ++ static const ASN1_ITEM *name##_adb(void) \ ++ { \ ++ static const ASN1_ADB internal_adb = \ ++ {\ ++ flags,\ ++ offsetof(name, field),\ ++ adb_cb,\ ++ name##_adbtbl,\ ++ sizeof(name##_adbtbl) / sizeof(ASN1_ADB_TABLE),\ ++ def,\ ++ none\ ++ }; \ ++ return (const ASN1_ITEM *) &internal_adb; \ ++ } \ ++ void dummy_function(void) ++ ++# endif ++ ++# define ADB_ENTRY(val, template) {val, template} ++ ++# define ASN1_ADB_TEMPLATE(name) \ ++ static const ASN1_TEMPLATE name##_tt ++ ++/* ++ * This is the ASN1 template structure that defines a wrapper round the ++ * actual type. It determines the actual position of the field in the value ++ * structure, various flags such as OPTIONAL and the field name. ++ */ ++ ++struct ASN1_TEMPLATE_st { ++ unsigned long flags; /* Various flags */ ++ long tag; /* tag, not used if no tagging */ ++ unsigned long offset; /* Offset of this field in structure */ ++ const char *field_name; /* Field name */ ++ ASN1_ITEM_EXP *item; /* Relevant ASN1_ITEM or ASN1_ADB */ ++}; ++ ++/* Macro to extract ASN1_ITEM and ASN1_ADB pointer from ASN1_TEMPLATE */ ++ ++# define ASN1_TEMPLATE_item(t) (t->item_ptr) ++# define ASN1_TEMPLATE_adb(t) (t->item_ptr) ++ ++typedef struct ASN1_ADB_TABLE_st ASN1_ADB_TABLE; ++typedef struct ASN1_ADB_st ASN1_ADB; ++ ++struct ASN1_ADB_st { ++ unsigned long flags; /* Various flags */ ++ unsigned long offset; /* Offset of selector field */ ++ int (*adb_cb)(long *psel); /* Application callback */ ++ const ASN1_ADB_TABLE *tbl; /* Table of possible types */ ++ long tblcount; /* Number of entries in tbl */ ++ const ASN1_TEMPLATE *default_tt; /* Type to use if no match */ ++ const ASN1_TEMPLATE *null_tt; /* Type to use if selector is NULL */ ++}; ++ ++struct ASN1_ADB_TABLE_st { ++ long value; /* NID for an object or value for an int */ ++ const ASN1_TEMPLATE tt; /* item for this value */ ++}; ++ ++/* template flags */ ++ ++/* Field is optional */ ++# define ASN1_TFLG_OPTIONAL (0x1) ++ ++/* Field is a SET OF */ ++# define ASN1_TFLG_SET_OF (0x1 << 1) ++ ++/* Field is a SEQUENCE OF */ ++# define ASN1_TFLG_SEQUENCE_OF (0x2 << 1) ++ ++/* ++ * Special case: this refers to a SET OF that will be sorted into DER order ++ * when encoded *and* the corresponding STACK will be modified to match the ++ * new order. ++ */ ++# define ASN1_TFLG_SET_ORDER (0x3 << 1) ++ ++/* Mask for SET OF or SEQUENCE OF */ ++# define ASN1_TFLG_SK_MASK (0x3 << 1) ++ ++/* ++ * These flags mean the tag should be taken from the tag field. If EXPLICIT ++ * then the underlying type is used for the inner tag. ++ */ ++ ++/* IMPLICIT tagging */ ++# define ASN1_TFLG_IMPTAG (0x1 << 3) ++ ++/* EXPLICIT tagging, inner tag from underlying type */ ++# define ASN1_TFLG_EXPTAG (0x2 << 3) ++ ++# define ASN1_TFLG_TAG_MASK (0x3 << 3) ++ ++/* context specific IMPLICIT */ ++# define ASN1_TFLG_IMPLICIT (ASN1_TFLG_IMPTAG|ASN1_TFLG_CONTEXT) ++ ++/* context specific EXPLICIT */ ++# define ASN1_TFLG_EXPLICIT (ASN1_TFLG_EXPTAG|ASN1_TFLG_CONTEXT) ++ ++/* ++ * If tagging is in force these determine the type of tag to use. Otherwise ++ * the tag is determined by the underlying type. These values reflect the ++ * actual octet format. ++ */ ++ ++/* Universal tag */ ++# define ASN1_TFLG_UNIVERSAL (0x0<<6) ++/* Application tag */ ++# define ASN1_TFLG_APPLICATION (0x1<<6) ++/* Context specific tag */ ++# define ASN1_TFLG_CONTEXT (0x2<<6) ++/* Private tag */ ++# define ASN1_TFLG_PRIVATE (0x3<<6) ++ ++# define ASN1_TFLG_TAG_CLASS (0x3<<6) ++ ++/* ++ * These are for ANY DEFINED BY type. In this case the 'item' field points to ++ * an ASN1_ADB structure which contains a table of values to decode the ++ * relevant type ++ */ ++ ++# define ASN1_TFLG_ADB_MASK (0x3<<8) ++ ++# define ASN1_TFLG_ADB_OID (0x1<<8) ++ ++# define ASN1_TFLG_ADB_INT (0x1<<9) ++ ++/* ++ * This flag when present in a SEQUENCE OF, SET OF or EXPLICIT causes ++ * indefinite length constructed encoding to be used if required. ++ */ ++ ++# define ASN1_TFLG_NDEF (0x1<<11) ++ ++/* Field is embedded and not a pointer */ ++# define ASN1_TFLG_EMBED (0x1 << 12) ++ ++/* This is the actual ASN1 item itself */ ++ ++struct ASN1_ITEM_st { ++ char itype; /* The item type, primitive, SEQUENCE, CHOICE ++ * or extern */ ++ long utype; /* underlying type */ ++ const ASN1_TEMPLATE *templates; /* If SEQUENCE or CHOICE this contains ++ * the contents */ ++ long tcount; /* Number of templates if SEQUENCE or CHOICE */ ++ const void *funcs; /* functions that handle this type */ ++ long size; /* Structure size (usually) */ ++ const char *sname; /* Structure name */ ++}; ++ ++/*- ++ * These are values for the itype field and ++ * determine how the type is interpreted. ++ * ++ * For PRIMITIVE types the underlying type ++ * determines the behaviour if items is NULL. ++ * ++ * Otherwise templates must contain a single ++ * template and the type is treated in the ++ * same way as the type specified in the template. ++ * ++ * For SEQUENCE types the templates field points ++ * to the members, the size field is the ++ * structure size. ++ * ++ * For CHOICE types the templates field points ++ * to each possible member (typically a union) ++ * and the 'size' field is the offset of the ++ * selector. ++ * ++ * The 'funcs' field is used for application ++ * specific functions. ++ * ++ * The EXTERN type uses a new style d2i/i2d. ++ * The new style should be used where possible ++ * because it avoids things like the d2i IMPLICIT ++ * hack. ++ * ++ * MSTRING is a multiple string type, it is used ++ * for a CHOICE of character strings where the ++ * actual strings all occupy an ASN1_STRING ++ * structure. In this case the 'utype' field ++ * has a special meaning, it is used as a mask ++ * of acceptable types using the B_ASN1 constants. ++ * ++ * NDEF_SEQUENCE is the same as SEQUENCE except ++ * that it will use indefinite length constructed ++ * encoding if requested. ++ * ++ */ ++ ++# define ASN1_ITYPE_PRIMITIVE 0x0 ++ ++# define ASN1_ITYPE_SEQUENCE 0x1 ++ ++# define ASN1_ITYPE_CHOICE 0x2 ++ ++# define ASN1_ITYPE_EXTERN 0x4 ++ ++# define ASN1_ITYPE_MSTRING 0x5 ++ ++# define ASN1_ITYPE_NDEF_SEQUENCE 0x6 ++ ++/* ++ * Cache for ASN1 tag and length, so we don't keep re-reading it for things ++ * like CHOICE ++ */ ++ ++struct ASN1_TLC_st { ++ char valid; /* Values below are valid */ ++ int ret; /* return value */ ++ long plen; /* length */ ++ int ptag; /* class value */ ++ int pclass; /* class value */ ++ int hdrlen; /* header length */ ++}; ++ ++/* Typedefs for ASN1 function pointers */ ++typedef int ASN1_ex_d2i(ASN1_VALUE **pval, const unsigned char **in, long len, ++ const ASN1_ITEM *it, int tag, int aclass, char opt, ++ ASN1_TLC *ctx); ++ ++typedef int ASN1_ex_i2d(ASN1_VALUE **pval, unsigned char **out, ++ const ASN1_ITEM *it, int tag, int aclass); ++typedef int ASN1_ex_new_func(ASN1_VALUE **pval, const ASN1_ITEM *it); ++typedef void ASN1_ex_free_func(ASN1_VALUE **pval, const ASN1_ITEM *it); ++ ++typedef int ASN1_ex_print_func(BIO *out, ASN1_VALUE **pval, ++ int indent, const char *fname, ++ const ASN1_PCTX *pctx); ++ ++typedef int ASN1_primitive_i2c(ASN1_VALUE **pval, unsigned char *cont, ++ int *putype, const ASN1_ITEM *it); ++typedef int ASN1_primitive_c2i(ASN1_VALUE **pval, const unsigned char *cont, ++ int len, int utype, char *free_cont, ++ const ASN1_ITEM *it); ++typedef int ASN1_primitive_print(BIO *out, ASN1_VALUE **pval, ++ const ASN1_ITEM *it, int indent, ++ const ASN1_PCTX *pctx); ++ ++typedef struct ASN1_EXTERN_FUNCS_st { ++ void *app_data; ++ ASN1_ex_new_func *asn1_ex_new; ++ ASN1_ex_free_func *asn1_ex_free; ++ ASN1_ex_free_func *asn1_ex_clear; ++ ASN1_ex_d2i *asn1_ex_d2i; ++ ASN1_ex_i2d *asn1_ex_i2d; ++ ASN1_ex_print_func *asn1_ex_print; ++} ASN1_EXTERN_FUNCS; ++ ++typedef struct ASN1_PRIMITIVE_FUNCS_st { ++ void *app_data; ++ unsigned long flags; ++ ASN1_ex_new_func *prim_new; ++ ASN1_ex_free_func *prim_free; ++ ASN1_ex_free_func *prim_clear; ++ ASN1_primitive_c2i *prim_c2i; ++ ASN1_primitive_i2c *prim_i2c; ++ ASN1_primitive_print *prim_print; ++} ASN1_PRIMITIVE_FUNCS; ++ ++/* ++ * This is the ASN1_AUX structure: it handles various miscellaneous ++ * requirements. For example the use of reference counts and an informational ++ * callback. The "informational callback" is called at various points during ++ * the ASN1 encoding and decoding. It can be used to provide minor ++ * customisation of the structures used. This is most useful where the ++ * supplied routines *almost* do the right thing but need some extra help at ++ * a few points. If the callback returns zero then it is assumed a fatal ++ * error has occurred and the main operation should be abandoned. If major ++ * changes in the default behaviour are required then an external type is ++ * more appropriate. ++ */ ++ ++typedef int ASN1_aux_cb(int operation, ASN1_VALUE **in, const ASN1_ITEM *it, ++ void *exarg); ++ ++typedef struct ASN1_AUX_st { ++ void *app_data; ++ int flags; ++ int ref_offset; /* Offset of reference value */ ++ int ref_lock; /* Lock type to use */ ++ ASN1_aux_cb *asn1_cb; ++ int enc_offset; /* Offset of ASN1_ENCODING structure */ ++} ASN1_AUX; ++ ++/* For print related callbacks exarg points to this structure */ ++typedef struct ASN1_PRINT_ARG_st { ++ BIO *out; ++ int indent; ++ const ASN1_PCTX *pctx; ++} ASN1_PRINT_ARG; ++ ++/* For streaming related callbacks exarg points to this structure */ ++typedef struct ASN1_STREAM_ARG_st { ++ /* BIO to stream through */ ++ BIO *out; ++ /* BIO with filters appended */ ++ BIO *ndef_bio; ++ /* Streaming I/O boundary */ ++ unsigned char **boundary; ++} ASN1_STREAM_ARG; ++ ++/* Flags in ASN1_AUX */ ++ ++/* Use a reference count */ ++# define ASN1_AFLG_REFCOUNT 1 ++/* Save the encoding of structure (useful for signatures) */ ++# define ASN1_AFLG_ENCODING 2 ++/* The Sequence length is invalid */ ++# define ASN1_AFLG_BROKEN 4 ++ ++/* operation values for asn1_cb */ ++ ++# define ASN1_OP_NEW_PRE 0 ++# define ASN1_OP_NEW_POST 1 ++# define ASN1_OP_FREE_PRE 2 ++# define ASN1_OP_FREE_POST 3 ++# define ASN1_OP_D2I_PRE 4 ++# define ASN1_OP_D2I_POST 5 ++# define ASN1_OP_I2D_PRE 6 ++# define ASN1_OP_I2D_POST 7 ++# define ASN1_OP_PRINT_PRE 8 ++# define ASN1_OP_PRINT_POST 9 ++# define ASN1_OP_STREAM_PRE 10 ++# define ASN1_OP_STREAM_POST 11 ++# define ASN1_OP_DETACHED_PRE 12 ++# define ASN1_OP_DETACHED_POST 13 ++ ++/* Macro to implement a primitive type */ ++# define IMPLEMENT_ASN1_TYPE(stname) IMPLEMENT_ASN1_TYPE_ex(stname, stname, 0) ++# define IMPLEMENT_ASN1_TYPE_ex(itname, vname, ex) \ ++ ASN1_ITEM_start(itname) \ ++ ASN1_ITYPE_PRIMITIVE, V_##vname, NULL, 0, NULL, ex, #itname \ ++ ASN1_ITEM_end(itname) ++ ++/* Macro to implement a multi string type */ ++# define IMPLEMENT_ASN1_MSTRING(itname, mask) \ ++ ASN1_ITEM_start(itname) \ ++ ASN1_ITYPE_MSTRING, mask, NULL, 0, NULL, sizeof(ASN1_STRING), #itname \ ++ ASN1_ITEM_end(itname) ++ ++# define IMPLEMENT_EXTERN_ASN1(sname, tag, fptrs) \ ++ ASN1_ITEM_start(sname) \ ++ ASN1_ITYPE_EXTERN, \ ++ tag, \ ++ NULL, \ ++ 0, \ ++ &fptrs, \ ++ 0, \ ++ #sname \ ++ ASN1_ITEM_end(sname) ++ ++/* Macro to implement standard functions in terms of ASN1_ITEM structures */ ++ ++# define IMPLEMENT_ASN1_FUNCTIONS(stname) IMPLEMENT_ASN1_FUNCTIONS_fname(stname, stname, stname) ++ ++# define IMPLEMENT_ASN1_FUNCTIONS_name(stname, itname) IMPLEMENT_ASN1_FUNCTIONS_fname(stname, itname, itname) ++ ++# define IMPLEMENT_ASN1_FUNCTIONS_ENCODE_name(stname, itname) \ ++ IMPLEMENT_ASN1_FUNCTIONS_ENCODE_fname(stname, itname, itname) ++ ++# define IMPLEMENT_STATIC_ASN1_ALLOC_FUNCTIONS(stname) \ ++ IMPLEMENT_ASN1_ALLOC_FUNCTIONS_pfname(static, stname, stname, stname) ++ ++# define IMPLEMENT_ASN1_ALLOC_FUNCTIONS(stname) \ ++ IMPLEMENT_ASN1_ALLOC_FUNCTIONS_fname(stname, stname, stname) ++ ++# define IMPLEMENT_ASN1_ALLOC_FUNCTIONS_pfname(pre, stname, itname, fname) \ ++ pre stname *fname##_new(void) \ ++ { \ ++ return (stname *)ASN1_item_new(ASN1_ITEM_rptr(itname)); \ ++ } \ ++ pre void fname##_free(stname *a) \ ++ { \ ++ ASN1_item_free((ASN1_VALUE *)a, ASN1_ITEM_rptr(itname)); \ ++ } ++ ++# define IMPLEMENT_ASN1_ALLOC_FUNCTIONS_fname(stname, itname, fname) \ ++ stname *fname##_new(void) \ ++ { \ ++ return (stname *)ASN1_item_new(ASN1_ITEM_rptr(itname)); \ ++ } \ ++ void fname##_free(stname *a) \ ++ { \ ++ ASN1_item_free((ASN1_VALUE *)a, ASN1_ITEM_rptr(itname)); \ ++ } ++ ++# define IMPLEMENT_ASN1_FUNCTIONS_fname(stname, itname, fname) \ ++ IMPLEMENT_ASN1_ENCODE_FUNCTIONS_fname(stname, itname, fname) \ ++ IMPLEMENT_ASN1_ALLOC_FUNCTIONS_fname(stname, itname, fname) ++ ++# define IMPLEMENT_ASN1_ENCODE_FUNCTIONS_fname(stname, itname, fname) \ ++ stname *d2i_##fname(stname **a, const unsigned char **in, long len) \ ++ { \ ++ return (stname *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, ASN1_ITEM_rptr(itname));\ ++ } \ ++ int i2d_##fname(stname *a, unsigned char **out) \ ++ { \ ++ return ASN1_item_i2d((ASN1_VALUE *)a, out, ASN1_ITEM_rptr(itname));\ ++ } ++ ++# define IMPLEMENT_ASN1_NDEF_FUNCTION(stname) \ ++ int i2d_##stname##_NDEF(stname *a, unsigned char **out) \ ++ { \ ++ return ASN1_item_ndef_i2d((ASN1_VALUE *)a, out, ASN1_ITEM_rptr(stname));\ ++ } ++ ++# define IMPLEMENT_STATIC_ASN1_ENCODE_FUNCTIONS(stname) \ ++ static stname *d2i_##stname(stname **a, \ ++ const unsigned char **in, long len) \ ++ { \ ++ return (stname *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, \ ++ ASN1_ITEM_rptr(stname)); \ ++ } \ ++ static int i2d_##stname(stname *a, unsigned char **out) \ ++ { \ ++ return ASN1_item_i2d((ASN1_VALUE *)a, out, \ ++ ASN1_ITEM_rptr(stname)); \ ++ } ++ ++#ifndef OPENSSL_NO_TTO ++# define IMPLEMENT_ASN1_ENCODE_FUNCTIONS(stname) \ ++ static int i2d_##stname(stname *a, unsigned char **out) \ ++ { \ ++ return ASN1_item_i2d((ASN1_VALUE *)a, out, \ ++ ASN1_ITEM_rptr(stname)); \ ++ } ++ ++# define IMPLEMENT_ASN1_DECODE_FUNCTIONS(stname) \ ++ static stname *d2i_##stname(stname **a, \ ++ const unsigned char **in, long len) \ ++ { \ ++ return (stname *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, \ ++ ASN1_ITEM_rptr(stname)); \ ++ } ++#endif ++ ++/* ++ * This includes evil casts to remove const: they will go away when full ASN1 ++ * constification is done. ++ */ ++# define IMPLEMENT_ASN1_ENCODE_FUNCTIONS_const_fname(stname, itname, fname) \ ++ stname *d2i_##fname(stname **a, const unsigned char **in, long len) \ ++ { \ ++ return (stname *)ASN1_item_d2i((ASN1_VALUE **)a, in, len, ASN1_ITEM_rptr(itname));\ ++ } \ ++ int i2d_##fname(const stname *a, unsigned char **out) \ ++ { \ ++ return ASN1_item_i2d((ASN1_VALUE *)a, out, ASN1_ITEM_rptr(itname));\ ++ } ++ ++# define IMPLEMENT_ASN1_DUP_FUNCTION(stname) \ ++ stname * stname##_dup(stname *x) \ ++ { \ ++ return ASN1_item_dup(ASN1_ITEM_rptr(stname), x); \ ++ } ++ ++# define IMPLEMENT_ASN1_PRINT_FUNCTION(stname) \ ++ IMPLEMENT_ASN1_PRINT_FUNCTION_fname(stname, stname, stname) ++ ++# define IMPLEMENT_ASN1_PRINT_FUNCTION_fname(stname, itname, fname) \ ++ int fname##_print_ctx(BIO *out, stname *x, int indent, \ ++ const ASN1_PCTX *pctx) \ ++ { \ ++ return ASN1_item_print(out, (ASN1_VALUE *)x, indent, \ ++ ASN1_ITEM_rptr(itname), pctx); \ ++ } ++ ++# define IMPLEMENT_ASN1_FUNCTIONS_const(name) \ ++ IMPLEMENT_ASN1_FUNCTIONS_const_fname(name, name, name) ++ ++# define IMPLEMENT_ASN1_FUNCTIONS_const_fname(stname, itname, fname) \ ++ IMPLEMENT_ASN1_ENCODE_FUNCTIONS_const_fname(stname, itname, fname) \ ++ IMPLEMENT_ASN1_ALLOC_FUNCTIONS_fname(stname, itname, fname) ++ ++/* external definitions for primitive types */ ++ ++DECLARE_ASN1_ITEM(ASN1_BOOLEAN) ++DECLARE_ASN1_ITEM(ASN1_TBOOLEAN) ++DECLARE_ASN1_ITEM(ASN1_FBOOLEAN) ++DECLARE_ASN1_ITEM(ASN1_SEQUENCE) ++DECLARE_ASN1_ITEM(CBIGNUM) ++DECLARE_ASN1_ITEM(BIGNUM) ++DECLARE_ASN1_ITEM(INT32) ++DECLARE_ASN1_ITEM(ZINT32) ++DECLARE_ASN1_ITEM(UINT32) ++DECLARE_ASN1_ITEM(ZUINT32) ++DECLARE_ASN1_ITEM(INT64) ++DECLARE_ASN1_ITEM(ZINT64) ++DECLARE_ASN1_ITEM(UINT64) ++DECLARE_ASN1_ITEM(ZUINT64) ++ ++# if OPENSSL_API_COMPAT < 0x10200000L ++/* ++ * LONG and ZLONG are strongly discouraged for use as stored data, as the ++ * underlying C type (long) differs in size depending on the architecture. ++ * They are designed with 32-bit longs in mind. ++ */ ++DECLARE_ASN1_ITEM(LONG) ++DECLARE_ASN1_ITEM(ZLONG) ++# endif ++ ++DEFINE_STACK_OF(ASN1_VALUE) ++ ++/* Functions used internally by the ASN1 code */ ++ ++int ASN1_item_ex_new(ASN1_VALUE **pval, const ASN1_ITEM *it); ++void ASN1_item_ex_free(ASN1_VALUE **pval, const ASN1_ITEM *it); ++ ++int ASN1_item_ex_d2i(ASN1_VALUE **pval, const unsigned char **in, long len, ++ const ASN1_ITEM *it, int tag, int aclass, char opt, ++ ASN1_TLC *ctx); ++ ++int ASN1_item_ex_i2d(ASN1_VALUE **pval, unsigned char **out, ++ const ASN1_ITEM *it, int tag, int aclass); ++ ++#ifdef __cplusplus ++} ++#endif ++#endif +diff --git a/include/TA/openssl/openssl/bio.h b/include/TA/openssl/openssl/bio.h +new file mode 100644 +index 0000000..3f68687 +--- /dev/null ++++ b/include/TA/openssl/openssl/bio.h +@@ -0,0 +1,813 @@ ++/* ++ * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved. ++ * ++ * Licensed under the OpenSSL license (the "License"). You may not use ++ * this file except in compliance with the License. You can obtain a copy ++ * in the file LICENSE in the source distribution or at ++ * https://www.openssl.org/source/license.html ++ */ ++ ++#ifndef HEADER_BIO_H ++# define HEADER_BIO_H ++ ++# include ++ ++# ifndef OPENSSL_NO_STDIO ++# include ++# endif ++# include ++ ++# include ++# include ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++/* There are the classes of BIOs */ ++# define BIO_TYPE_DESCRIPTOR 0x0100 /* socket, fd, connect or accept */ ++# define BIO_TYPE_FILTER 0x0200 ++# define BIO_TYPE_SOURCE_SINK 0x0400 ++ ++/* These are the 'types' of BIOs */ ++# define BIO_TYPE_NONE 0 ++# define BIO_TYPE_MEM ( 1|BIO_TYPE_SOURCE_SINK) ++# define BIO_TYPE_FILE ( 2|BIO_TYPE_SOURCE_SINK) ++ ++# define BIO_TYPE_FD ( 4|BIO_TYPE_SOURCE_SINK|BIO_TYPE_DESCRIPTOR) ++# define BIO_TYPE_SOCKET ( 5|BIO_TYPE_SOURCE_SINK|BIO_TYPE_DESCRIPTOR) ++# define BIO_TYPE_NULL ( 6|BIO_TYPE_SOURCE_SINK) ++# define BIO_TYPE_SSL ( 7|BIO_TYPE_FILTER) ++# define BIO_TYPE_MD ( 8|BIO_TYPE_FILTER) ++# define BIO_TYPE_BUFFER ( 9|BIO_TYPE_FILTER) ++# define BIO_TYPE_CIPHER (10|BIO_TYPE_FILTER) ++# define BIO_TYPE_BASE64 (11|BIO_TYPE_FILTER) ++# define BIO_TYPE_CONNECT (12|BIO_TYPE_SOURCE_SINK|BIO_TYPE_DESCRIPTOR) ++# define BIO_TYPE_ACCEPT (13|BIO_TYPE_SOURCE_SINK|BIO_TYPE_DESCRIPTOR) ++ ++# define BIO_TYPE_NBIO_TEST (16|BIO_TYPE_FILTER)/* server proxy BIO */ ++# define BIO_TYPE_NULL_FILTER (17|BIO_TYPE_FILTER) ++# define BIO_TYPE_BIO (19|BIO_TYPE_SOURCE_SINK)/* half a BIO pair */ ++# define BIO_TYPE_LINEBUFFER (20|BIO_TYPE_FILTER) ++# define BIO_TYPE_DGRAM (21|BIO_TYPE_SOURCE_SINK|BIO_TYPE_DESCRIPTOR) ++# define BIO_TYPE_ASN1 (22|BIO_TYPE_FILTER) ++# define BIO_TYPE_COMP (23|BIO_TYPE_FILTER) ++# ifndef OPENSSL_NO_SCTP ++# define BIO_TYPE_DGRAM_SCTP (24|BIO_TYPE_SOURCE_SINK|BIO_TYPE_DESCRIPTOR) ++# endif ++ ++#define BIO_TYPE_START 128 ++ ++/* ++ * BIO_FILENAME_READ|BIO_CLOSE to open or close on free. ++ * BIO_set_fp(in,stdin,BIO_NOCLOSE); ++ */ ++# define BIO_NOCLOSE 0x00 ++# define BIO_CLOSE 0x01 ++ ++/* ++ * These are used in the following macros and are passed to BIO_ctrl() ++ */ ++# define BIO_CTRL_RESET 1/* opt - rewind/zero etc */ ++# define BIO_CTRL_EOF 2/* opt - are we at the eof */ ++# define BIO_CTRL_INFO 3/* opt - extra tit-bits */ ++# define BIO_CTRL_SET 4/* man - set the 'IO' type */ ++# define BIO_CTRL_GET 5/* man - get the 'IO' type */ ++# define BIO_CTRL_PUSH 6/* opt - internal, used to signify change */ ++# define BIO_CTRL_POP 7/* opt - internal, used to signify change */ ++# define BIO_CTRL_GET_CLOSE 8/* man - set the 'close' on free */ ++# define BIO_CTRL_SET_CLOSE 9/* man - set the 'close' on free */ ++# define BIO_CTRL_PENDING 10/* opt - is their more data buffered */ ++# define BIO_CTRL_FLUSH 11/* opt - 'flush' buffered output */ ++# define BIO_CTRL_DUP 12/* man - extra stuff for 'duped' BIO */ ++# define BIO_CTRL_WPENDING 13/* opt - number of bytes still to write */ ++# define BIO_CTRL_SET_CALLBACK 14/* opt - set callback function */ ++# define BIO_CTRL_GET_CALLBACK 15/* opt - set callback function */ ++ ++# define BIO_CTRL_PEEK 29/* BIO_f_buffer special */ ++# define BIO_CTRL_SET_FILENAME 30/* BIO_s_file special */ ++ ++/* dgram BIO stuff */ ++# define BIO_CTRL_DGRAM_CONNECT 31/* BIO dgram special */ ++# define BIO_CTRL_DGRAM_SET_CONNECTED 32/* allow for an externally connected ++ * socket to be passed in */ ++# define BIO_CTRL_DGRAM_SET_RECV_TIMEOUT 33/* setsockopt, essentially */ ++# define BIO_CTRL_DGRAM_GET_RECV_TIMEOUT 34/* getsockopt, essentially */ ++# define BIO_CTRL_DGRAM_SET_SEND_TIMEOUT 35/* setsockopt, essentially */ ++# define BIO_CTRL_DGRAM_GET_SEND_TIMEOUT 36/* getsockopt, essentially */ ++ ++# define BIO_CTRL_DGRAM_GET_RECV_TIMER_EXP 37/* flag whether the last */ ++# define BIO_CTRL_DGRAM_GET_SEND_TIMER_EXP 38/* I/O operation tiemd out */ ++ ++/* #ifdef IP_MTU_DISCOVER */ ++# define BIO_CTRL_DGRAM_MTU_DISCOVER 39/* set DF bit on egress packets */ ++/* #endif */ ++ ++# define BIO_CTRL_DGRAM_QUERY_MTU 40/* as kernel for current MTU */ ++# define BIO_CTRL_DGRAM_GET_FALLBACK_MTU 47 ++# define BIO_CTRL_DGRAM_GET_MTU 41/* get cached value for MTU */ ++# define BIO_CTRL_DGRAM_SET_MTU 42/* set cached value for MTU. ++ * want to use this if asking ++ * the kernel fails */ ++ ++# define BIO_CTRL_DGRAM_MTU_EXCEEDED 43/* check whether the MTU was ++ * exceed in the previous write ++ * operation */ ++ ++# define BIO_CTRL_DGRAM_GET_PEER 46 ++# define BIO_CTRL_DGRAM_SET_PEER 44/* Destination for the data */ ++ ++# define BIO_CTRL_DGRAM_SET_NEXT_TIMEOUT 45/* Next DTLS handshake timeout ++ * to adjust socket timeouts */ ++# define BIO_CTRL_DGRAM_SET_DONT_FRAG 48 ++ ++# define BIO_CTRL_DGRAM_GET_MTU_OVERHEAD 49 ++ ++/* Deliberately outside of OPENSSL_NO_SCTP - used in bss_dgram.c */ ++# define BIO_CTRL_DGRAM_SCTP_SET_IN_HANDSHAKE 50 ++# ifndef OPENSSL_NO_SCTP ++/* SCTP stuff */ ++# define BIO_CTRL_DGRAM_SCTP_ADD_AUTH_KEY 51 ++# define BIO_CTRL_DGRAM_SCTP_NEXT_AUTH_KEY 52 ++# define BIO_CTRL_DGRAM_SCTP_AUTH_CCS_RCVD 53 ++# define BIO_CTRL_DGRAM_SCTP_GET_SNDINFO 60 ++# define BIO_CTRL_DGRAM_SCTP_SET_SNDINFO 61 ++# define BIO_CTRL_DGRAM_SCTP_GET_RCVINFO 62 ++# define BIO_CTRL_DGRAM_SCTP_SET_RCVINFO 63 ++# define BIO_CTRL_DGRAM_SCTP_GET_PRINFO 64 ++# define BIO_CTRL_DGRAM_SCTP_SET_PRINFO 65 ++# define BIO_CTRL_DGRAM_SCTP_SAVE_SHUTDOWN 70 ++# endif ++ ++# define BIO_CTRL_DGRAM_SET_PEEK_MODE 71 ++# define BIO_CTRL_DGRAM_SCTP_WAIT_FOR_DRY 77 ++# define BIO_CTRL_DGRAM_SCTP_MSG_WAITING 78 ++ ++/* Negotiate with the SE (Chen Shengqi) to reserve the value before 1000 for the open-source community, ++ * and use the value after 1000 for Huawei-developed features. */ ++#ifndef OPENSSL_NO_DTO ++/* Export DTLS1.2 key information and epoch commands used by the BIO_set_dto macro */ ++#define BIO_CTRL_SET_DTO_KEY 1001 ++#define BIO_CTRL_SET_DTO_EPOCH_SEQUENCE 1002 ++ ++#endif ++ ++/* modifiers */ ++# define BIO_FP_READ 0x02 ++# define BIO_FP_WRITE 0x04 ++# define BIO_FP_APPEND 0x08 ++# define BIO_FP_TEXT 0x10 ++ ++# define BIO_FLAGS_READ 0x01 ++# define BIO_FLAGS_WRITE 0x02 ++# define BIO_FLAGS_IO_SPECIAL 0x04 ++# define BIO_FLAGS_RWS (BIO_FLAGS_READ|BIO_FLAGS_WRITE|BIO_FLAGS_IO_SPECIAL) ++# define BIO_FLAGS_SHOULD_RETRY 0x08 ++# ifndef BIO_FLAGS_UPLINK ++/* ++ * "UPLINK" flag denotes file descriptors provided by application. It ++ * defaults to 0, as most platforms don't require UPLINK interface. ++ */ ++# define BIO_FLAGS_UPLINK 0 ++# endif ++ ++# define BIO_FLAGS_BASE64_NO_NL 0x100 ++ ++/* ++ * This is used with memory BIOs: ++ * BIO_FLAGS_MEM_RDONLY means we shouldn't free up or change the data in any way; ++ * BIO_FLAGS_NONCLEAR_RST means we shouldn't clear data on reset. ++ */ ++# define BIO_FLAGS_MEM_RDONLY 0x200 ++# define BIO_FLAGS_NONCLEAR_RST 0x400 ++# define BIO_FLAGS_IN_EOF 0x800 ++ ++typedef union bio_addr_st BIO_ADDR; ++typedef struct bio_addrinfo_st BIO_ADDRINFO; ++ ++int BIO_get_new_index(void); ++void BIO_set_flags(BIO *b, int flags); ++int BIO_test_flags(const BIO *b, int flags); ++void BIO_clear_flags(BIO *b, int flags); ++ ++# define BIO_get_flags(b) BIO_test_flags(b, ~(0x0)) ++# define BIO_set_retry_special(b) \ ++ BIO_set_flags(b, (BIO_FLAGS_IO_SPECIAL|BIO_FLAGS_SHOULD_RETRY)) ++# define BIO_set_retry_read(b) \ ++ BIO_set_flags(b, (BIO_FLAGS_READ|BIO_FLAGS_SHOULD_RETRY)) ++# define BIO_set_retry_write(b) \ ++ BIO_set_flags(b, (BIO_FLAGS_WRITE|BIO_FLAGS_SHOULD_RETRY)) ++ ++/* These are normally used internally in BIOs */ ++# define BIO_clear_retry_flags(b) \ ++ BIO_clear_flags(b, (BIO_FLAGS_RWS|BIO_FLAGS_SHOULD_RETRY)) ++# define BIO_get_retry_flags(b) \ ++ BIO_test_flags(b, (BIO_FLAGS_RWS|BIO_FLAGS_SHOULD_RETRY)) ++ ++/* These should be used by the application to tell why we should retry */ ++# define BIO_should_read(a) BIO_test_flags(a, BIO_FLAGS_READ) ++# define BIO_should_write(a) BIO_test_flags(a, BIO_FLAGS_WRITE) ++# define BIO_should_io_special(a) BIO_test_flags(a, BIO_FLAGS_IO_SPECIAL) ++# define BIO_retry_type(a) BIO_test_flags(a, BIO_FLAGS_RWS) ++# define BIO_should_retry(a) BIO_test_flags(a, BIO_FLAGS_SHOULD_RETRY) ++ ++/* ++ * The next three are used in conjunction with the BIO_should_io_special() ++ * condition. After this returns true, BIO *BIO_get_retry_BIO(BIO *bio, int ++ * *reason); will walk the BIO stack and return the 'reason' for the special ++ * and the offending BIO. Given a BIO, BIO_get_retry_reason(bio) will return ++ * the code. ++ */ ++/* ++ * Returned from the SSL bio when the certificate retrieval code had an error ++ */ ++# define BIO_RR_SSL_X509_LOOKUP 0x01 ++/* Returned from the connect BIO when a connect would have blocked */ ++# define BIO_RR_CONNECT 0x02 ++/* Returned from the accept BIO when an accept would have blocked */ ++# define BIO_RR_ACCEPT 0x03 ++ ++/* These are passed by the BIO callback */ ++# define BIO_CB_FREE 0x01 ++# define BIO_CB_READ 0x02 ++# define BIO_CB_WRITE 0x03 ++# define BIO_CB_PUTS 0x04 ++# define BIO_CB_GETS 0x05 ++# define BIO_CB_CTRL 0x06 ++ ++/* ++ * The callback is called before and after the underling operation, The ++ * BIO_CB_RETURN flag indicates if it is after the call ++ */ ++# define BIO_CB_RETURN 0x80 ++# define BIO_CB_return(a) ((a)|BIO_CB_RETURN) ++# define BIO_cb_pre(a) (!((a)&BIO_CB_RETURN)) ++# define BIO_cb_post(a) ((a)&BIO_CB_RETURN) ++ ++typedef long (*BIO_callback_fn)(BIO *b, int oper, const char *argp, int argi, ++ long argl, long ret); ++typedef long (*BIO_callback_fn_ex)(BIO *b, int oper, const char *argp, ++ size_t len, int argi, ++ long argl, int ret, size_t *processed); ++BIO_callback_fn BIO_get_callback(const BIO *b); ++void BIO_set_callback(BIO *b, BIO_callback_fn callback); ++ ++BIO_callback_fn_ex BIO_get_callback_ex(const BIO *b); ++void BIO_set_callback_ex(BIO *b, BIO_callback_fn_ex callback); ++ ++char *BIO_get_callback_arg(const BIO *b); ++void BIO_set_callback_arg(BIO *b, char *arg); ++ ++typedef struct bio_method_st BIO_METHOD; ++ ++const char *BIO_method_name(const BIO *b); ++int BIO_method_type(const BIO *b); ++ ++typedef int BIO_info_cb(BIO *, int, int); ++typedef BIO_info_cb bio_info_cb; /* backward compatibility */ ++ ++DEFINE_STACK_OF(BIO) ++ ++/* Prefix and suffix callback in ASN1 BIO */ ++typedef int asn1_ps_func (BIO *b, unsigned char **pbuf, int *plen, ++ void *parg); ++ ++# ifndef OPENSSL_NO_SCTP ++/* SCTP parameter structs */ ++struct bio_dgram_sctp_sndinfo { ++ uint16_t snd_sid; ++ uint16_t snd_flags; ++ uint32_t snd_ppid; ++ uint32_t snd_context; ++}; ++ ++struct bio_dgram_sctp_rcvinfo { ++ uint16_t rcv_sid; ++ uint16_t rcv_ssn; ++ uint16_t rcv_flags; ++ uint32_t rcv_ppid; ++ uint32_t rcv_tsn; ++ uint32_t rcv_cumtsn; ++ uint32_t rcv_context; ++}; ++ ++struct bio_dgram_sctp_prinfo { ++ uint16_t pr_policy; ++ uint32_t pr_value; ++}; ++# endif ++ ++/* ++ * #define BIO_CONN_get_param_hostname BIO_ctrl ++ */ ++ ++# define BIO_C_SET_CONNECT 100 ++# define BIO_C_DO_STATE_MACHINE 101 ++# define BIO_C_SET_NBIO 102 ++/* # define BIO_C_SET_PROXY_PARAM 103 */ ++# define BIO_C_SET_FD 104 ++# define BIO_C_GET_FD 105 ++# define BIO_C_SET_FILE_PTR 106 ++# define BIO_C_GET_FILE_PTR 107 ++# define BIO_C_SET_FILENAME 108 ++# define BIO_C_SET_SSL 109 ++# define BIO_C_GET_SSL 110 ++# define BIO_C_SET_MD 111 ++# define BIO_C_GET_MD 112 ++# define BIO_C_GET_CIPHER_STATUS 113 ++# define BIO_C_SET_BUF_MEM 114 ++# define BIO_C_GET_BUF_MEM_PTR 115 ++# define BIO_C_GET_BUFF_NUM_LINES 116 ++# define BIO_C_SET_BUFF_SIZE 117 ++# define BIO_C_SET_ACCEPT 118 ++# define BIO_C_SSL_MODE 119 ++# define BIO_C_GET_MD_CTX 120 ++/* # define BIO_C_GET_PROXY_PARAM 121 */ ++# define BIO_C_SET_BUFF_READ_DATA 122/* data to read first */ ++# define BIO_C_GET_CONNECT 123 ++# define BIO_C_GET_ACCEPT 124 ++# define BIO_C_SET_SSL_RENEGOTIATE_BYTES 125 ++# define BIO_C_GET_SSL_NUM_RENEGOTIATES 126 ++# define BIO_C_SET_SSL_RENEGOTIATE_TIMEOUT 127 ++# define BIO_C_FILE_SEEK 128 ++# define BIO_C_GET_CIPHER_CTX 129 ++# define BIO_C_SET_BUF_MEM_EOF_RETURN 130/* return end of input ++ * value */ ++# define BIO_C_SET_BIND_MODE 131 ++# define BIO_C_GET_BIND_MODE 132 ++# define BIO_C_FILE_TELL 133 ++# define BIO_C_GET_SOCKS 134 ++# define BIO_C_SET_SOCKS 135 ++ ++# define BIO_C_SET_WRITE_BUF_SIZE 136/* for BIO_s_bio */ ++# define BIO_C_GET_WRITE_BUF_SIZE 137 ++# define BIO_C_MAKE_BIO_PAIR 138 ++# define BIO_C_DESTROY_BIO_PAIR 139 ++# define BIO_C_GET_WRITE_GUARANTEE 140 ++# define BIO_C_GET_READ_REQUEST 141 ++# define BIO_C_SHUTDOWN_WR 142 ++# define BIO_C_NREAD0 143 ++# define BIO_C_NREAD 144 ++# define BIO_C_NWRITE0 145 ++# define BIO_C_NWRITE 146 ++# define BIO_C_RESET_READ_REQUEST 147 ++# define BIO_C_SET_MD_CTX 148 ++ ++# define BIO_C_SET_PREFIX 149 ++# define BIO_C_GET_PREFIX 150 ++# define BIO_C_SET_SUFFIX 151 ++# define BIO_C_GET_SUFFIX 152 ++ ++# define BIO_C_SET_EX_ARG 153 ++# define BIO_C_GET_EX_ARG 154 ++ ++# define BIO_C_SET_CONNECT_MODE 155 ++ ++# define BIO_set_app_data(s,arg) BIO_set_ex_data(s,0,arg) ++# define BIO_get_app_data(s) BIO_get_ex_data(s,0) ++ ++# define BIO_set_nbio(b,n) BIO_ctrl(b,BIO_C_SET_NBIO,(n),NULL) ++ ++# ifndef OPENSSL_NO_SOCK ++/* IP families we support, for BIO_s_connect() and BIO_s_accept() */ ++/* Note: the underlying operating system may not support some of them */ ++# define BIO_FAMILY_IPV4 4 ++# define BIO_FAMILY_IPV6 6 ++# define BIO_FAMILY_IPANY 256 ++ ++/* BIO_s_connect() */ ++# define BIO_set_conn_hostname(b,name) BIO_ctrl(b,BIO_C_SET_CONNECT,0, \ ++ (char *)(name)) ++# define BIO_set_conn_port(b,port) BIO_ctrl(b,BIO_C_SET_CONNECT,1, \ ++ (char *)(port)) ++# define BIO_set_conn_address(b,addr) BIO_ctrl(b,BIO_C_SET_CONNECT,2, \ ++ (char *)(addr)) ++# define BIO_set_conn_ip_family(b,f) BIO_int_ctrl(b,BIO_C_SET_CONNECT,3,f) ++# define BIO_get_conn_hostname(b) ((const char *)BIO_ptr_ctrl(b,BIO_C_GET_CONNECT,0)) ++# define BIO_get_conn_port(b) ((const char *)BIO_ptr_ctrl(b,BIO_C_GET_CONNECT,1)) ++# define BIO_get_conn_address(b) ((const BIO_ADDR *)BIO_ptr_ctrl(b,BIO_C_GET_CONNECT,2)) ++# define BIO_get_conn_ip_family(b) BIO_ctrl(b,BIO_C_GET_CONNECT,3,NULL) ++# define BIO_set_conn_mode(b,n) BIO_ctrl(b,BIO_C_SET_CONNECT_MODE,(n),NULL) ++ ++/* BIO_s_accept() */ ++# define BIO_set_accept_name(b,name) BIO_ctrl(b,BIO_C_SET_ACCEPT,0, \ ++ (char *)(name)) ++# define BIO_set_accept_port(b,port) BIO_ctrl(b,BIO_C_SET_ACCEPT,1, \ ++ (char *)(port)) ++# define BIO_get_accept_name(b) ((const char *)BIO_ptr_ctrl(b,BIO_C_GET_ACCEPT,0)) ++# define BIO_get_accept_port(b) ((const char *)BIO_ptr_ctrl(b,BIO_C_GET_ACCEPT,1)) ++# define BIO_get_peer_name(b) ((const char *)BIO_ptr_ctrl(b,BIO_C_GET_ACCEPT,2)) ++# define BIO_get_peer_port(b) ((const char *)BIO_ptr_ctrl(b,BIO_C_GET_ACCEPT,3)) ++/* #define BIO_set_nbio(b,n) BIO_ctrl(b,BIO_C_SET_NBIO,(n),NULL) */ ++# define BIO_set_nbio_accept(b,n) BIO_ctrl(b,BIO_C_SET_ACCEPT,2,(n)?(void *)"a":NULL) ++# define BIO_set_accept_bios(b,bio) BIO_ctrl(b,BIO_C_SET_ACCEPT,3, \ ++ (char *)(bio)) ++# define BIO_set_accept_ip_family(b,f) BIO_int_ctrl(b,BIO_C_SET_ACCEPT,4,f) ++# define BIO_get_accept_ip_family(b) BIO_ctrl(b,BIO_C_GET_ACCEPT,4,NULL) ++ ++/* Aliases kept for backward compatibility */ ++# define BIO_BIND_NORMAL 0 ++# define BIO_BIND_REUSEADDR BIO_SOCK_REUSEADDR ++# define BIO_BIND_REUSEADDR_IF_UNUSED BIO_SOCK_REUSEADDR ++# define BIO_set_bind_mode(b,mode) BIO_ctrl(b,BIO_C_SET_BIND_MODE,mode,NULL) ++# define BIO_get_bind_mode(b) BIO_ctrl(b,BIO_C_GET_BIND_MODE,0,NULL) ++ ++/* BIO_s_accept() and BIO_s_connect() */ ++# define BIO_do_connect(b) BIO_do_handshake(b) ++# define BIO_do_accept(b) BIO_do_handshake(b) ++# endif /* OPENSSL_NO_SOCK */ ++ ++# define BIO_do_handshake(b) BIO_ctrl(b,BIO_C_DO_STATE_MACHINE,0,NULL) ++ ++/* BIO_s_datagram(), BIO_s_fd(), BIO_s_socket(), BIO_s_accept() and BIO_s_connect() */ ++# define BIO_set_fd(b,fd,c) BIO_int_ctrl(b,BIO_C_SET_FD,c,fd) ++# define BIO_get_fd(b,c) BIO_ctrl(b,BIO_C_GET_FD,0,(char *)(c)) ++ ++/* BIO_s_file() */ ++# define BIO_set_fp(b,fp,c) BIO_ctrl(b,BIO_C_SET_FILE_PTR,c,(char *)(fp)) ++# define BIO_get_fp(b,fpp) BIO_ctrl(b,BIO_C_GET_FILE_PTR,0,(char *)(fpp)) ++ ++/* BIO_s_fd() and BIO_s_file() */ ++# define BIO_seek(b,ofs) (int)BIO_ctrl(b,BIO_C_FILE_SEEK,ofs,NULL) ++# define BIO_tell(b) (int)BIO_ctrl(b,BIO_C_FILE_TELL,0,NULL) ++ ++/* ++ * name is cast to lose const, but might be better to route through a ++ * function so we can do it safely ++ */ ++# ifdef CONST_STRICT ++/* ++ * If you are wondering why this isn't defined, its because CONST_STRICT is ++ * purely a compile-time kludge to allow const to be checked. ++ */ ++int BIO_read_filename(BIO *b, const char *name); ++# else ++# define BIO_read_filename(b,name) (int)BIO_ctrl(b,BIO_C_SET_FILENAME, \ ++ BIO_CLOSE|BIO_FP_READ,(char *)(name)) ++# endif ++# define BIO_write_filename(b,name) (int)BIO_ctrl(b,BIO_C_SET_FILENAME, \ ++ BIO_CLOSE|BIO_FP_WRITE,name) ++# define BIO_append_filename(b,name) (int)BIO_ctrl(b,BIO_C_SET_FILENAME, \ ++ BIO_CLOSE|BIO_FP_APPEND,name) ++# define BIO_rw_filename(b,name) (int)BIO_ctrl(b,BIO_C_SET_FILENAME, \ ++ BIO_CLOSE|BIO_FP_READ|BIO_FP_WRITE,name) ++ ++/* ++ * WARNING WARNING, this ups the reference count on the read bio of the SSL ++ * structure. This is because the ssl read BIO is now pointed to by the ++ * next_bio field in the bio. So when you free the BIO, make sure you are ++ * doing a BIO_free_all() to catch the underlying BIO. ++ */ ++# define BIO_set_ssl(b,ssl,c) BIO_ctrl(b,BIO_C_SET_SSL,c,(char *)(ssl)) ++# define BIO_get_ssl(b,sslp) BIO_ctrl(b,BIO_C_GET_SSL,0,(char *)(sslp)) ++# define BIO_set_ssl_mode(b,client) BIO_ctrl(b,BIO_C_SSL_MODE,client,NULL) ++# define BIO_set_ssl_renegotiate_bytes(b,num) \ ++ BIO_ctrl(b,BIO_C_SET_SSL_RENEGOTIATE_BYTES,num,NULL) ++# define BIO_get_num_renegotiates(b) \ ++ BIO_ctrl(b,BIO_C_GET_SSL_NUM_RENEGOTIATES,0,NULL) ++# define BIO_set_ssl_renegotiate_timeout(b,seconds) \ ++ BIO_ctrl(b,BIO_C_SET_SSL_RENEGOTIATE_TIMEOUT,seconds,NULL) ++ ++/* defined in evp.h */ ++/* #define BIO_set_md(b,md) BIO_ctrl(b,BIO_C_SET_MD,1,(char *)(md)) */ ++ ++# define BIO_get_mem_data(b,pp) BIO_ctrl(b,BIO_CTRL_INFO,0,(char *)(pp)) ++# define BIO_set_mem_buf(b,bm,c) BIO_ctrl(b,BIO_C_SET_BUF_MEM,c,(char *)(bm)) ++# define BIO_get_mem_ptr(b,pp) BIO_ctrl(b,BIO_C_GET_BUF_MEM_PTR,0, \ ++ (char *)(pp)) ++# define BIO_set_mem_eof_return(b,v) \ ++ BIO_ctrl(b,BIO_C_SET_BUF_MEM_EOF_RETURN,v,NULL) ++ ++/* For the BIO_f_buffer() type */ ++# define BIO_get_buffer_num_lines(b) BIO_ctrl(b,BIO_C_GET_BUFF_NUM_LINES,0,NULL) ++# define BIO_set_buffer_size(b,size) BIO_ctrl(b,BIO_C_SET_BUFF_SIZE,size,NULL) ++# define BIO_set_read_buffer_size(b,size) BIO_int_ctrl(b,BIO_C_SET_BUFF_SIZE,size,0) ++# define BIO_set_write_buffer_size(b,size) BIO_int_ctrl(b,BIO_C_SET_BUFF_SIZE,size,1) ++# define BIO_set_buffer_read_data(b,buf,num) BIO_ctrl(b,BIO_C_SET_BUFF_READ_DATA,num,buf) ++ ++/* Don't use the next one unless you know what you are doing :-) */ ++# define BIO_dup_state(b,ret) BIO_ctrl(b,BIO_CTRL_DUP,0,(char *)(ret)) ++ ++# define BIO_reset(b) (int)BIO_ctrl(b,BIO_CTRL_RESET,0,NULL) ++# define BIO_eof(b) (int)BIO_ctrl(b,BIO_CTRL_EOF,0,NULL) ++# define BIO_set_close(b,c) (int)BIO_ctrl(b,BIO_CTRL_SET_CLOSE,(c),NULL) ++# define BIO_get_close(b) (int)BIO_ctrl(b,BIO_CTRL_GET_CLOSE,0,NULL) ++# define BIO_pending(b) (int)BIO_ctrl(b,BIO_CTRL_PENDING,0,NULL) ++# define BIO_wpending(b) (int)BIO_ctrl(b,BIO_CTRL_WPENDING,0,NULL) ++/* ...pending macros have inappropriate return type */ ++size_t BIO_ctrl_pending(BIO *b); ++size_t BIO_ctrl_wpending(BIO *b); ++# define BIO_flush(b) (int)BIO_ctrl(b,BIO_CTRL_FLUSH,0,NULL) ++# define BIO_get_info_callback(b,cbp) (int)BIO_ctrl(b,BIO_CTRL_GET_CALLBACK,0, \ ++ cbp) ++# define BIO_set_info_callback(b,cb) (int)BIO_callback_ctrl(b,BIO_CTRL_SET_CALLBACK,cb) ++ ++/* For the BIO_f_buffer() type */ ++# define BIO_buffer_get_num_lines(b) BIO_ctrl(b,BIO_CTRL_GET,0,NULL) ++# define BIO_buffer_peek(b,s,l) BIO_ctrl(b,BIO_CTRL_PEEK,(l),(s)) ++ ++/* For BIO_s_bio() */ ++# define BIO_set_write_buf_size(b,size) (int)BIO_ctrl(b,BIO_C_SET_WRITE_BUF_SIZE,size,NULL) ++# define BIO_get_write_buf_size(b,size) (size_t)BIO_ctrl(b,BIO_C_GET_WRITE_BUF_SIZE,size,NULL) ++# define BIO_make_bio_pair(b1,b2) (int)BIO_ctrl(b1,BIO_C_MAKE_BIO_PAIR,0,b2) ++# define BIO_destroy_bio_pair(b) (int)BIO_ctrl(b,BIO_C_DESTROY_BIO_PAIR,0,NULL) ++# define BIO_shutdown_wr(b) (int)BIO_ctrl(b, BIO_C_SHUTDOWN_WR, 0, NULL) ++/* macros with inappropriate type -- but ...pending macros use int too: */ ++# define BIO_get_write_guarantee(b) (int)BIO_ctrl(b,BIO_C_GET_WRITE_GUARANTEE,0,NULL) ++# define BIO_get_read_request(b) (int)BIO_ctrl(b,BIO_C_GET_READ_REQUEST,0,NULL) ++size_t BIO_ctrl_get_write_guarantee(BIO *b); ++size_t BIO_ctrl_get_read_request(BIO *b); ++int BIO_ctrl_reset_read_request(BIO *b); ++ ++/* ctrl macros for dgram */ ++# define BIO_ctrl_dgram_connect(b,peer) \ ++ (int)BIO_ctrl(b,BIO_CTRL_DGRAM_CONNECT,0, (char *)(peer)) ++# define BIO_ctrl_set_connected(b,peer) \ ++ (int)BIO_ctrl(b, BIO_CTRL_DGRAM_SET_CONNECTED, 0, (char *)(peer)) ++# define BIO_dgram_recv_timedout(b) \ ++ (int)BIO_ctrl(b, BIO_CTRL_DGRAM_GET_RECV_TIMER_EXP, 0, NULL) ++# define BIO_dgram_send_timedout(b) \ ++ (int)BIO_ctrl(b, BIO_CTRL_DGRAM_GET_SEND_TIMER_EXP, 0, NULL) ++# define BIO_dgram_get_peer(b,peer) \ ++ (int)BIO_ctrl(b, BIO_CTRL_DGRAM_GET_PEER, 0, (char *)(peer)) ++# define BIO_dgram_set_peer(b,peer) \ ++ (int)BIO_ctrl(b, BIO_CTRL_DGRAM_SET_PEER, 0, (char *)(peer)) ++# define BIO_dgram_get_mtu_overhead(b) \ ++ (unsigned int)BIO_ctrl((b), BIO_CTRL_DGRAM_GET_MTU_OVERHEAD, 0, NULL) ++ ++#define BIO_get_ex_new_index(l, p, newf, dupf, freef) \ ++ CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_BIO, l, p, newf, dupf, freef) ++int BIO_set_ex_data(BIO *bio, int idx, void *data); ++void *BIO_get_ex_data(BIO *bio, int idx); ++uint64_t BIO_number_read(BIO *bio); ++uint64_t BIO_number_written(BIO *bio); ++ ++/* For BIO_f_asn1() */ ++int BIO_asn1_set_prefix(BIO *b, asn1_ps_func *prefix, ++ asn1_ps_func *prefix_free); ++int BIO_asn1_get_prefix(BIO *b, asn1_ps_func **pprefix, ++ asn1_ps_func **pprefix_free); ++int BIO_asn1_set_suffix(BIO *b, asn1_ps_func *suffix, ++ asn1_ps_func *suffix_free); ++int BIO_asn1_get_suffix(BIO *b, asn1_ps_func **psuffix, ++ asn1_ps_func **psuffix_free); ++ ++const BIO_METHOD *BIO_s_file(void); ++BIO *BIO_new_file(const char *filename, const char *mode); ++# ifndef OPENSSL_NO_STDIO ++BIO *BIO_new_fp(FILE *stream, int close_flag); ++# endif ++BIO *BIO_new(const BIO_METHOD *type); ++int BIO_free(BIO *a); ++void BIO_set_data(BIO *a, void *ptr); ++void *BIO_get_data(BIO *a); ++void BIO_set_init(BIO *a, int init); ++int BIO_get_init(BIO *a); ++void BIO_set_num(BIO *a, int num); ++int BIO_get_num(BIO *a); ++void BIO_set_shutdown(BIO *a, int shut); ++int BIO_get_shutdown(BIO *a); ++void BIO_vfree(BIO *a); ++int BIO_up_ref(BIO *a); ++int BIO_read(BIO *b, void *data, int dlen); ++int BIO_read_ex(BIO *b, void *data, size_t dlen, size_t *readbytes); ++int BIO_gets(BIO *bp, char *buf, int size); ++int BIO_write(BIO *b, const void *data, int dlen); ++int BIO_write_ex(BIO *b, const void *data, size_t dlen, size_t *written); ++int BIO_puts(BIO *bp, const char *buf); ++int BIO_indent(BIO *b, int indent, int max); ++long BIO_ctrl(BIO *bp, int cmd, long larg, void *parg); ++long BIO_callback_ctrl(BIO *b, int cmd, BIO_info_cb *fp); ++void *BIO_ptr_ctrl(BIO *bp, int cmd, long larg); ++long BIO_int_ctrl(BIO *bp, int cmd, long larg, int iarg); ++BIO *BIO_push(BIO *b, BIO *append); ++BIO *BIO_pop(BIO *b); ++void BIO_free_all(BIO *a); ++BIO *BIO_find_type(BIO *b, int bio_type); ++BIO *BIO_next(BIO *b); ++void BIO_set_next(BIO *b, BIO *next); ++BIO *BIO_get_retry_BIO(BIO *bio, int *reason); ++int BIO_get_retry_reason(BIO *bio); ++void BIO_set_retry_reason(BIO *bio, int reason); ++BIO *BIO_dup_chain(BIO *in); ++ ++int BIO_nread0(BIO *bio, char **buf); ++int BIO_nread(BIO *bio, char **buf, int num); ++int BIO_nwrite0(BIO *bio, char **buf); ++int BIO_nwrite(BIO *bio, char **buf, int num); ++ ++long BIO_debug_callback(BIO *bio, int cmd, const char *argp, int argi, ++ long argl, long ret); ++ ++const BIO_METHOD *BIO_s_mem(void); ++const BIO_METHOD *BIO_s_secmem(void); ++BIO *BIO_new_mem_buf(const void *buf, int len); ++# ifndef OPENSSL_NO_SOCK ++const BIO_METHOD *BIO_s_socket(void); ++const BIO_METHOD *BIO_s_connect(void); ++const BIO_METHOD *BIO_s_accept(void); ++# endif ++const BIO_METHOD *BIO_s_fd(void); ++const BIO_METHOD *BIO_s_log(void); ++const BIO_METHOD *BIO_s_bio(void); ++const BIO_METHOD *BIO_s_null(void); ++const BIO_METHOD *BIO_f_null(void); ++const BIO_METHOD *BIO_f_buffer(void); ++const BIO_METHOD *BIO_f_linebuffer(void); ++const BIO_METHOD *BIO_f_nbio_test(void); ++# ifndef OPENSSL_NO_DGRAM ++const BIO_METHOD *BIO_s_datagram(void); ++int BIO_dgram_non_fatal_error(int error); ++BIO *BIO_new_dgram(int fd, int close_flag); ++# ifndef OPENSSL_NO_SCTP ++const BIO_METHOD *BIO_s_datagram_sctp(void); ++BIO *BIO_new_dgram_sctp(int fd, int close_flag); ++int BIO_dgram_is_sctp(BIO *bio); ++int BIO_dgram_sctp_notification_cb(BIO *b, ++ void (*handle_notifications) (BIO *bio, ++ void *context, ++ void *buf), ++ void *context); ++int BIO_dgram_sctp_wait_for_dry(BIO *b); ++int BIO_dgram_sctp_msg_waiting(BIO *b); ++# endif ++# endif ++ ++# ifndef OPENSSL_NO_SOCK ++int BIO_sock_should_retry(int i); ++int BIO_sock_non_fatal_error(int error); ++# endif ++ ++int BIO_fd_should_retry(int i); ++int BIO_fd_non_fatal_error(int error); ++int BIO_dump_cb(int (*cb) (const void *data, size_t len, void *u), ++ void *u, const char *s, int len); ++int BIO_dump_indent_cb(int (*cb) (const void *data, size_t len, void *u), ++ void *u, const char *s, int len, int indent); ++int BIO_dump(BIO *b, const char *bytes, int len); ++int BIO_dump_indent(BIO *b, const char *bytes, int len, int indent); ++# ifndef OPENSSL_NO_STDIO ++int BIO_dump_fp(FILE *fp, const char *s, int len); ++int BIO_dump_indent_fp(FILE *fp, const char *s, int len, int indent); ++# endif ++int BIO_hex_string(BIO *out, int indent, int width, unsigned char *data, ++ int datalen); ++ ++# ifndef OPENSSL_NO_SOCK ++BIO_ADDR *BIO_ADDR_new(void); ++int BIO_ADDR_rawmake(BIO_ADDR *ap, int family, ++ const void *where, size_t wherelen, unsigned short port); ++void BIO_ADDR_free(BIO_ADDR *); ++void BIO_ADDR_clear(BIO_ADDR *ap); ++int BIO_ADDR_family(const BIO_ADDR *ap); ++int BIO_ADDR_rawaddress(const BIO_ADDR *ap, void *p, size_t *l); ++unsigned short BIO_ADDR_rawport(const BIO_ADDR *ap); ++char *BIO_ADDR_hostname_string(const BIO_ADDR *ap, int numeric); ++char *BIO_ADDR_service_string(const BIO_ADDR *ap, int numeric); ++char *BIO_ADDR_path_string(const BIO_ADDR *ap); ++ ++const BIO_ADDRINFO *BIO_ADDRINFO_next(const BIO_ADDRINFO *bai); ++int BIO_ADDRINFO_family(const BIO_ADDRINFO *bai); ++int BIO_ADDRINFO_socktype(const BIO_ADDRINFO *bai); ++int BIO_ADDRINFO_protocol(const BIO_ADDRINFO *bai); ++const BIO_ADDR *BIO_ADDRINFO_address(const BIO_ADDRINFO *bai); ++void BIO_ADDRINFO_free(BIO_ADDRINFO *bai); ++ ++enum BIO_hostserv_priorities { ++ BIO_PARSE_PRIO_HOST, BIO_PARSE_PRIO_SERV ++}; ++int BIO_parse_hostserv(const char *hostserv, char **host, char **service, ++ enum BIO_hostserv_priorities hostserv_prio); ++enum BIO_lookup_type { ++ BIO_LOOKUP_CLIENT, BIO_LOOKUP_SERVER ++}; ++int BIO_lookup(const char *host, const char *service, ++ enum BIO_lookup_type lookup_type, ++ int family, int socktype, BIO_ADDRINFO **res); ++int BIO_lookup_ex(const char *host, const char *service, ++ int lookup_type, int family, int socktype, int protocol, ++ BIO_ADDRINFO **res); ++int BIO_sock_error(int sock); ++int BIO_socket_ioctl(int fd, long type, void *arg); ++int BIO_socket_nbio(int fd, int mode); ++int BIO_sock_init(void); ++# if OPENSSL_API_COMPAT < 0x10100000L ++# define BIO_sock_cleanup() while(0) continue ++# endif ++int BIO_set_tcp_ndelay(int sock, int turn_on); ++ ++DEPRECATEDIN_1_1_0(struct hostent *BIO_gethostbyname(const char *name)) ++DEPRECATEDIN_1_1_0(int BIO_get_port(const char *str, unsigned short *port_ptr)) ++DEPRECATEDIN_1_1_0(int BIO_get_host_ip(const char *str, unsigned char *ip)) ++DEPRECATEDIN_1_1_0(int BIO_get_accept_socket(char *host_port, int mode)) ++DEPRECATEDIN_1_1_0(int BIO_accept(int sock, char **ip_port)) ++ ++union BIO_sock_info_u { ++ BIO_ADDR *addr; ++}; ++enum BIO_sock_info_type { ++ BIO_SOCK_INFO_ADDRESS ++}; ++int BIO_sock_info(int sock, ++ enum BIO_sock_info_type type, union BIO_sock_info_u *info); ++ ++# define BIO_SOCK_REUSEADDR 0x01 ++# define BIO_SOCK_V6_ONLY 0x02 ++# define BIO_SOCK_KEEPALIVE 0x04 ++# define BIO_SOCK_NONBLOCK 0x08 ++# define BIO_SOCK_NODELAY 0x10 ++ ++int BIO_socket(int domain, int socktype, int protocol, int options); ++int BIO_connect(int sock, const BIO_ADDR *addr, int options); ++int BIO_bind(int sock, const BIO_ADDR *addr, int options); ++int BIO_listen(int sock, const BIO_ADDR *addr, int options); ++int BIO_accept_ex(int accept_sock, BIO_ADDR *addr, int options); ++int BIO_closesocket(int sock); ++ ++BIO *BIO_new_socket(int sock, int close_flag); ++BIO *BIO_new_connect(const char *host_port); ++BIO *BIO_new_accept(const char *host_port); ++# endif /* OPENSSL_NO_SOCK*/ ++ ++BIO *BIO_new_fd(int fd, int close_flag); ++ ++int BIO_new_bio_pair(BIO **bio1, size_t writebuf1, ++ BIO **bio2, size_t writebuf2); ++/* ++ * If successful, returns 1 and in *bio1, *bio2 two BIO pair endpoints. ++ * Otherwise returns 0 and sets *bio1 and *bio2 to NULL. Size 0 uses default ++ * value. ++ */ ++ ++void BIO_copy_next_retry(BIO *b); ++ ++/* ++ * long BIO_ghbn_ctrl(int cmd,int iarg,char *parg); ++ */ ++ ++# define ossl_bio__attr__(x) ++# if defined(__GNUC__) && defined(__STDC_VERSION__) \ ++ && !defined(__APPLE__) ++ /* ++ * Because we support the 'z' modifier, which made its appearance in C99, ++ * we can't use __attribute__ with pre C99 dialects. ++ */ ++# if __STDC_VERSION__ >= 199901L ++# undef ossl_bio__attr__ ++# define ossl_bio__attr__ __attribute__ ++# if __GNUC__*10 + __GNUC_MINOR__ >= 44 ++# define ossl_bio__printf__ __gnu_printf__ ++# else ++# define ossl_bio__printf__ __printf__ ++# endif ++# endif ++# endif ++int BIO_printf(BIO *bio, const char *format, ...) ++ossl_bio__attr__((__format__(ossl_bio__printf__, 2, 3))); ++int BIO_vprintf(BIO *bio, const char *format, va_list args) ++ossl_bio__attr__((__format__(ossl_bio__printf__, 2, 0))); ++int BIO_snprintf(char *buf, size_t n, const char *format, ...) ++ossl_bio__attr__((__format__(ossl_bio__printf__, 3, 4))); ++int BIO_vsnprintf(char *buf, size_t n, const char *format, va_list args) ++ossl_bio__attr__((__format__(ossl_bio__printf__, 3, 0))); ++# undef ossl_bio__attr__ ++# undef ossl_bio__printf__ ++ ++BIO_METHOD *BIO_meth_new(int type, const char *name); ++void BIO_meth_free(BIO_METHOD *biom); ++int (*BIO_meth_get_write(const BIO_METHOD *biom)) (BIO *, const char *, int); ++int (*BIO_meth_get_write_ex(const BIO_METHOD *biom)) (BIO *, const char *, size_t, ++ size_t *); ++int BIO_meth_set_write(BIO_METHOD *biom, ++ int (*write) (BIO *, const char *, int)); ++int BIO_meth_set_write_ex(BIO_METHOD *biom, ++ int (*bwrite) (BIO *, const char *, size_t, size_t *)); ++int (*BIO_meth_get_read(const BIO_METHOD *biom)) (BIO *, char *, int); ++int (*BIO_meth_get_read_ex(const BIO_METHOD *biom)) (BIO *, char *, size_t, size_t *); ++int BIO_meth_set_read(BIO_METHOD *biom, ++ int (*read) (BIO *, char *, int)); ++int BIO_meth_set_read_ex(BIO_METHOD *biom, ++ int (*bread) (BIO *, char *, size_t, size_t *)); ++int (*BIO_meth_get_puts(const BIO_METHOD *biom)) (BIO *, const char *); ++int BIO_meth_set_puts(BIO_METHOD *biom, ++ int (*puts) (BIO *, const char *)); ++int (*BIO_meth_get_gets(const BIO_METHOD *biom)) (BIO *, char *, int); ++int BIO_meth_set_gets(BIO_METHOD *biom, ++ int (*gets) (BIO *, char *, int)); ++long (*BIO_meth_get_ctrl(const BIO_METHOD *biom)) (BIO *, int, long, void *); ++int BIO_meth_set_ctrl(BIO_METHOD *biom, ++ long (*ctrl) (BIO *, int, long, void *)); ++int (*BIO_meth_get_create(const BIO_METHOD *bion)) (BIO *); ++int BIO_meth_set_create(BIO_METHOD *biom, int (*create) (BIO *)); ++int (*BIO_meth_get_destroy(const BIO_METHOD *biom)) (BIO *); ++int BIO_meth_set_destroy(BIO_METHOD *biom, int (*destroy) (BIO *)); ++long (*BIO_meth_get_callback_ctrl(const BIO_METHOD *biom)) ++ (BIO *, int, BIO_info_cb *); ++int BIO_meth_set_callback_ctrl(BIO_METHOD *biom, ++ long (*callback_ctrl) (BIO *, int, ++ BIO_info_cb *)); ++ ++# ifdef __cplusplus ++} ++# endif ++#endif +diff --git a/include/TA/openssl/openssl/bioerr.h b/include/TA/openssl/openssl/bioerr.h +new file mode 100644 +index 0000000..46e2c96 +--- /dev/null ++++ b/include/TA/openssl/openssl/bioerr.h +@@ -0,0 +1,124 @@ ++/* ++ * Generated by util/mkerr.pl DO NOT EDIT ++ * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. ++ * ++ * Licensed under the OpenSSL license (the "License"). You may not use ++ * this file except in compliance with the License. You can obtain a copy ++ * in the file LICENSE in the source distribution or at ++ * https://www.openssl.org/source/license.html ++ */ ++ ++#ifndef HEADER_BIOERR_H ++# define HEADER_BIOERR_H ++ ++# ifndef HEADER_SYMHACKS_H ++# include ++# endif ++ ++# ifdef __cplusplus ++extern "C" ++# endif ++int ERR_load_BIO_strings(void); ++ ++/* ++ * BIO function codes. ++ */ ++# define BIO_F_ACPT_STATE 100 ++# define BIO_F_ADDRINFO_WRAP 148 ++# define BIO_F_ADDR_STRINGS 134 ++# define BIO_F_BIO_ACCEPT 101 ++# define BIO_F_BIO_ACCEPT_EX 137 ++# define BIO_F_BIO_ACCEPT_NEW 152 ++# define BIO_F_BIO_ADDR_NEW 144 ++# define BIO_F_BIO_BIND 147 ++# define BIO_F_BIO_CALLBACK_CTRL 131 ++# define BIO_F_BIO_CONNECT 138 ++# define BIO_F_BIO_CONNECT_NEW 153 ++# define BIO_F_BIO_CTRL 103 ++# define BIO_F_BIO_GETS 104 ++# define BIO_F_BIO_GET_HOST_IP 106 ++# define BIO_F_BIO_GET_NEW_INDEX 102 ++# define BIO_F_BIO_GET_PORT 107 ++# define BIO_F_BIO_LISTEN 139 ++# define BIO_F_BIO_LOOKUP 135 ++# define BIO_F_BIO_LOOKUP_EX 143 ++# define BIO_F_BIO_MAKE_PAIR 121 ++# define BIO_F_BIO_METH_NEW 146 ++# define BIO_F_BIO_NEW 108 ++# define BIO_F_BIO_NEW_DGRAM_SCTP 145 ++# define BIO_F_BIO_NEW_FILE 109 ++# define BIO_F_BIO_NEW_MEM_BUF 126 ++# define BIO_F_BIO_NREAD 123 ++# define BIO_F_BIO_NREAD0 124 ++# define BIO_F_BIO_NWRITE 125 ++# define BIO_F_BIO_NWRITE0 122 ++# define BIO_F_BIO_PARSE_HOSTSERV 136 ++# define BIO_F_BIO_PUTS 110 ++# define BIO_F_BIO_READ 111 ++# define BIO_F_BIO_READ_EX 105 ++# define BIO_F_BIO_READ_INTERN 120 ++# define BIO_F_BIO_SOCKET 140 ++# define BIO_F_BIO_SOCKET_NBIO 142 ++# define BIO_F_BIO_SOCK_INFO 141 ++# define BIO_F_BIO_SOCK_INIT 112 ++# define BIO_F_BIO_WRITE 113 ++# define BIO_F_BIO_WRITE_EX 119 ++# define BIO_F_BIO_WRITE_INTERN 128 ++# define BIO_F_BUFFER_CTRL 114 ++# define BIO_F_CONN_CTRL 127 ++# define BIO_F_CONN_STATE 115 ++# define BIO_F_DGRAM_SCTP_NEW 149 ++# define BIO_F_DGRAM_SCTP_READ 132 ++# define BIO_F_DGRAM_SCTP_WRITE 133 ++# define BIO_F_DOAPR_OUTCH 150 ++# define BIO_F_FILE_CTRL 116 ++# define BIO_F_FILE_READ 130 ++# define BIO_F_LINEBUFFER_CTRL 129 ++# define BIO_F_LINEBUFFER_NEW 151 ++# define BIO_F_MEM_WRITE 117 ++# define BIO_F_NBIOF_NEW 154 ++# define BIO_F_SLG_WRITE 155 ++# define BIO_F_SSL_NEW 118 ++ ++/* ++ * BIO reason codes. ++ */ ++# define BIO_R_ACCEPT_ERROR 100 ++# define BIO_R_ADDRINFO_ADDR_IS_NOT_AF_INET 141 ++# define BIO_R_AMBIGUOUS_HOST_OR_SERVICE 129 ++# define BIO_R_BAD_FOPEN_MODE 101 ++# define BIO_R_BROKEN_PIPE 124 ++# define BIO_R_CONNECT_ERROR 103 ++# define BIO_R_GETHOSTBYNAME_ADDR_IS_NOT_AF_INET 107 ++# define BIO_R_GETSOCKNAME_ERROR 132 ++# define BIO_R_GETSOCKNAME_TRUNCATED_ADDRESS 133 ++# define BIO_R_GETTING_SOCKTYPE 134 ++# define BIO_R_INVALID_ARGUMENT 125 ++# define BIO_R_INVALID_SOCKET 135 ++# define BIO_R_IN_USE 123 ++# define BIO_R_LENGTH_TOO_LONG 102 ++# define BIO_R_LISTEN_V6_ONLY 136 ++# define BIO_R_LOOKUP_RETURNED_NOTHING 142 ++# define BIO_R_MALFORMED_HOST_OR_SERVICE 130 ++# define BIO_R_NBIO_CONNECT_ERROR 110 ++# define BIO_R_NO_ACCEPT_ADDR_OR_SERVICE_SPECIFIED 143 ++# define BIO_R_NO_HOSTNAME_OR_SERVICE_SPECIFIED 144 ++# define BIO_R_NO_PORT_DEFINED 113 ++# define BIO_R_NO_SUCH_FILE 128 ++# define BIO_R_NULL_PARAMETER 115 ++# define BIO_R_UNABLE_TO_BIND_SOCKET 117 ++# define BIO_R_UNABLE_TO_CREATE_SOCKET 118 ++# define BIO_R_UNABLE_TO_KEEPALIVE 137 ++# define BIO_R_UNABLE_TO_LISTEN_SOCKET 119 ++# define BIO_R_UNABLE_TO_NODELAY 138 ++# define BIO_R_UNABLE_TO_REUSEADDR 139 ++# define BIO_R_UNAVAILABLE_IP_FAMILY 145 ++# define BIO_R_UNINITIALIZED 120 ++# define BIO_R_UNKNOWN_INFO_TYPE 140 ++# define BIO_R_UNSUPPORTED_IP_FAMILY 146 ++# define BIO_R_UNSUPPORTED_METHOD 121 ++# define BIO_R_UNSUPPORTED_PROTOCOL_FAMILY 131 ++# define BIO_R_WRITE_TO_READ_ONLY_BIO 126 ++# define BIO_R_WSASTARTUP 122 ++ ++#endif +diff --git a/include/TA/openssl/openssl/bn.h b/include/TA/openssl/openssl/bn.h +new file mode 100644 +index 0000000..51fff4a +--- /dev/null ++++ b/include/TA/openssl/openssl/bn.h +@@ -0,0 +1,658 @@ ++/* ++ * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved. ++ * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved ++ * ++ * Licensed under the OpenSSL license (the "License"). You may not use ++ * this file except in compliance with the License. You can obtain a copy ++ * in the file LICENSE in the source distribution or at ++ * https://www.openssl.org/source/license.html ++ */ ++ ++#ifndef HEADER_BN_H ++# define HEADER_BN_H ++ ++#ifndef VPP_HICRYPTO_COMPILE ++# include ++# ifndef OPENSSL_NO_STDIO ++# include ++# endif ++# include ++# include ++# include ++# include ++#else ++#include ++#include ++#include ++ ++#ifndef OPENSSL_API_COMPAT ++#define OPENSSL_API_COMPAT 0x10100000L ++#endif ++ ++/* Only one for the following should be defined */ ++#cmakedefine SIXTY_FOUR_BIT_LONG ++#cmakedefine SIXTY_FOUR_BIT ++#cmakedefine THIRTY_TWO_BIT ++ ++typedef struct bignum_st BIGNUM; ++typedef struct bignum_ctx BN_CTX; ++typedef struct bn_blinding_st BN_BLINDING; ++typedef struct bn_mont_ctx_st BN_MONT_CTX; ++typedef struct bn_recp_ctx_st BN_RECP_CTX; ++typedef struct bn_gencb_st BN_GENCB; ++#endif ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++#ifdef VPP_HICRYPTO_COMPILE ++# pragma GCC visibility push(default) ++#endif ++/* ++ * 64-bit processor with LP64 ABI ++ */ ++# ifdef SIXTY_FOUR_BIT_LONG ++# define BN_ULONG unsigned long ++# define BN_BYTES 8 ++# endif ++ ++/* ++ * 64-bit processor other than LP64 ABI ++ */ ++# ifdef SIXTY_FOUR_BIT ++# define BN_ULONG unsigned long long ++# define BN_BYTES 8 ++# endif ++ ++# ifdef THIRTY_TWO_BIT ++# define BN_ULONG unsigned int ++# define BN_BYTES 4 ++# endif ++ ++# define BN_BITS2 (BN_BYTES * 8) ++# define BN_BITS (BN_BITS2 * 2) ++# define BN_TBIT ((BN_ULONG)1 << (BN_BITS2 - 1)) ++ ++# define BN_FLG_MALLOCED 0x01 ++# define BN_FLG_STATIC_DATA 0x02 ++ ++/* ++ * avoid leaking exponent information through timing, ++ * BN_mod_exp_mont() will call BN_mod_exp_mont_consttime, ++ * BN_div() will call BN_div_no_branch, ++ * BN_mod_inverse() will call bn_mod_inverse_no_branch. ++ */ ++# define BN_FLG_CONSTTIME 0x04 ++# define BN_FLG_SECURE 0x08 ++ ++# if OPENSSL_API_COMPAT < 0x00908000L ++/* deprecated name for the flag */ ++# define BN_FLG_EXP_CONSTTIME BN_FLG_CONSTTIME ++# define BN_FLG_FREE 0x8000 /* used for debugging */ ++# endif ++ ++void BN_set_flags(BIGNUM *b, int n); ++int BN_get_flags(const BIGNUM *b, int n); ++ ++/* Values for |top| in BN_rand() */ ++#define BN_RAND_TOP_ANY -1 ++#define BN_RAND_TOP_ONE 0 ++#define BN_RAND_TOP_TWO 1 ++ ++/* Values for |bottom| in BN_rand() */ ++#define BN_RAND_BOTTOM_ANY 0 ++#define BN_RAND_BOTTOM_ODD 1 ++ ++/* ++ * get a clone of a BIGNUM with changed flags, for *temporary* use only (the ++ * two BIGNUMs cannot be used in parallel!). Also only for *read only* use. The ++ * value |dest| should be a newly allocated BIGNUM obtained via BN_new() that ++ * has not been otherwise initialised or used. ++ */ ++void BN_with_flags(BIGNUM *dest, const BIGNUM *b, int flags); ++ ++/* Wrapper function to make using BN_GENCB easier */ ++int BN_GENCB_call(BN_GENCB *cb, int a, int b); ++ ++BN_GENCB *BN_GENCB_new(void); ++void BN_GENCB_free(BN_GENCB *cb); ++ ++/* Populate a BN_GENCB structure with an "old"-style callback */ ++void BN_GENCB_set_old(BN_GENCB *gencb, void (*callback) (int, int, void *), ++ void *cb_arg); ++ ++/* Populate a BN_GENCB structure with a "new"-style callback */ ++void BN_GENCB_set(BN_GENCB *gencb, int (*callback) (int, int, BN_GENCB *), ++ void *cb_arg); ++ ++void *BN_GENCB_get_arg(BN_GENCB *cb); ++ ++# define BN_prime_checks 0 /* default: select number of iterations based ++ * on the size of the number */ ++ ++/* ++ * BN_prime_checks_for_size() returns the number of Miller-Rabin iterations ++ * that will be done for checking that a random number is probably prime. The ++ * error rate for accepting a composite number as prime depends on the size of ++ * the prime |b|. The error rates used are for calculating an RSA key with 2 primes, ++ * and so the level is what you would expect for a key of double the size of the ++ * prime. ++ * ++ * This table is generated using the algorithm of FIPS PUB 186-4 ++ * Digital Signature Standard (DSS), section F.1, page 117. ++ * (https://dx.doi.org/10.6028/NIST.FIPS.186-4) ++ * ++ * The following magma script was used to generate the output: ++ * securitybits:=125; ++ * k:=1024; ++ * for t:=1 to 65 do ++ * for M:=3 to Floor(2*Sqrt(k-1)-1) do ++ * S:=0; ++ * // Sum over m ++ * for m:=3 to M do ++ * s:=0; ++ * // Sum over j ++ * for j:=2 to m do ++ * s+:=(RealField(32)!2)^-(j+(k-1)/j); ++ * end for; ++ * S+:=2^(m-(m-1)*t)*s; ++ * end for; ++ * A:=2^(k-2-M*t); ++ * B:=8*(Pi(RealField(32))^2-6)/3*2^(k-2)*S; ++ * pkt:=2.00743*Log(2)*k*2^-k*(A+B); ++ * seclevel:=Floor(-Log(2,pkt)); ++ * if seclevel ge securitybits then ++ * printf "k: %5o, security: %o bits (t: %o, M: %o)\n",k,seclevel,t,M; ++ * break; ++ * end if; ++ * end for; ++ * if seclevel ge securitybits then break; end if; ++ * end for; ++ * ++ * It can be run online at: ++ * http://magma.maths.usyd.edu.au/calc ++ * ++ * And will output: ++ * k: 1024, security: 129 bits (t: 6, M: 23) ++ * ++ * k is the number of bits of the prime, securitybits is the level we want to ++ * reach. ++ * ++ * prime length | RSA key size | # MR tests | security level ++ * -------------+--------------|------------+--------------- ++ * (b) >= 6394 | >= 12788 | 3 | 256 bit ++ * (b) >= 3747 | >= 7494 | 3 | 192 bit ++ * (b) >= 1345 | >= 2690 | 4 | 128 bit ++ * (b) >= 1080 | >= 2160 | 5 | 128 bit ++ * (b) >= 852 | >= 1704 | 5 | 112 bit ++ * (b) >= 476 | >= 952 | 5 | 80 bit ++ * (b) >= 400 | >= 800 | 6 | 80 bit ++ * (b) >= 347 | >= 694 | 7 | 80 bit ++ * (b) >= 308 | >= 616 | 8 | 80 bit ++ * (b) >= 55 | >= 110 | 27 | 64 bit ++ * (b) >= 6 | >= 12 | 34 | 64 bit ++ */ ++ ++# define BN_prime_checks_for_size(b) ((b) >= 3747 ? 3 : \ ++ (b) >= 1345 ? 4 : \ ++ (b) >= 476 ? 5 : \ ++ (b) >= 400 ? 6 : \ ++ (b) >= 347 ? 7 : \ ++ (b) >= 308 ? 8 : \ ++ (b) >= 55 ? 27 : \ ++ /* b >= 6 */ 34) ++ ++# define BN_num_bytes(a) ((BN_num_bits(a)+7)/8) ++ ++int BN_abs_is_word(const BIGNUM *a, const BN_ULONG w); ++int BN_is_zero(const BIGNUM *a); ++int BN_is_one(const BIGNUM *a); ++int BN_is_word(const BIGNUM *a, const BN_ULONG w); ++int BN_is_odd(const BIGNUM *a); ++ ++# define BN_one(a) (BN_set_word((a),1)) ++ ++void BN_zero_ex(BIGNUM *a); ++ ++# if OPENSSL_API_COMPAT >= 0x00908000L ++# define BN_zero(a) BN_zero_ex(a) ++# else ++# define BN_zero(a) (BN_set_word((a),0)) ++# endif ++ ++const BIGNUM *BN_value_one(void); ++char *BN_options(void); ++BN_CTX *BN_CTX_new(void); ++BN_CTX *BN_CTX_secure_new(void); ++void BN_CTX_free(BN_CTX *c); ++void BN_CTX_start(BN_CTX *ctx); ++BIGNUM *BN_CTX_get(BN_CTX *ctx); ++void BN_CTX_end(BN_CTX *ctx); ++int BN_rand(BIGNUM *rnd, int bits, int top, int bottom); ++int BN_priv_rand(BIGNUM *rnd, int bits, int top, int bottom); ++int BN_rand_range(BIGNUM *rnd, const BIGNUM *range); ++int BN_priv_rand_range(BIGNUM *rnd, const BIGNUM *range); ++int BN_pseudo_rand(BIGNUM *rnd, int bits, int top, int bottom); ++int BN_pseudo_rand_range(BIGNUM *rnd, const BIGNUM *range); ++int BN_num_bits(const BIGNUM *a); ++int BN_num_bits_word(BN_ULONG l); ++int BN_security_bits(int L, int N); ++BIGNUM *BN_new(void); ++BIGNUM *BN_secure_new(void); ++void BN_clear_free(BIGNUM *a); ++BIGNUM *BN_copy(BIGNUM *a, const BIGNUM *b); ++void BN_swap(BIGNUM *a, BIGNUM *b); ++BIGNUM *BN_bin2bn(const unsigned char *s, int len, BIGNUM *ret); ++int BN_bn2bin(const BIGNUM *a, unsigned char *to); ++int BN_bn2binpad(const BIGNUM *a, unsigned char *to, int tolen); ++BIGNUM *BN_lebin2bn(const unsigned char *s, int len, BIGNUM *ret); ++int BN_bn2lebinpad(const BIGNUM *a, unsigned char *to, int tolen); ++BIGNUM *BN_mpi2bn(const unsigned char *s, int len, BIGNUM *ret); ++int BN_bn2mpi(const BIGNUM *a, unsigned char *to); ++int BN_sub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b); ++int BN_usub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b); ++int BN_uadd(BIGNUM *r, const BIGNUM *a, const BIGNUM *b); ++int BN_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b); ++int BN_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx); ++int BN_sqr(BIGNUM *r, const BIGNUM *a, BN_CTX *ctx); ++/** BN_set_negative sets sign of a BIGNUM ++ * \param b pointer to the BIGNUM object ++ * \param n 0 if the BIGNUM b should be positive and a value != 0 otherwise ++ */ ++void BN_set_negative(BIGNUM *b, int n); ++/** BN_is_negative returns 1 if the BIGNUM is negative ++ * \param b pointer to the BIGNUM object ++ * \return 1 if a < 0 and 0 otherwise ++ */ ++int BN_is_negative(const BIGNUM *b); ++ ++int BN_div(BIGNUM *dv, BIGNUM *rem, const BIGNUM *m, const BIGNUM *d, ++ BN_CTX *ctx); ++# define BN_mod(rem,m,d,ctx) BN_div(NULL,(rem),(m),(d),(ctx)) ++int BN_nnmod(BIGNUM *r, const BIGNUM *m, const BIGNUM *d, BN_CTX *ctx); ++int BN_mod_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m, ++ BN_CTX *ctx); ++int BN_mod_add_quick(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, ++ const BIGNUM *m); ++int BN_mod_sub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m, ++ BN_CTX *ctx); ++int BN_mod_sub_quick(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, ++ const BIGNUM *m); ++int BN_mod_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m, ++ BN_CTX *ctx); ++int BN_mod_sqr(BIGNUM *r, const BIGNUM *a, const BIGNUM *m, BN_CTX *ctx); ++int BN_mod_lshift1(BIGNUM *r, const BIGNUM *a, const BIGNUM *m, BN_CTX *ctx); ++int BN_mod_lshift1_quick(BIGNUM *r, const BIGNUM *a, const BIGNUM *m); ++int BN_mod_lshift(BIGNUM *r, const BIGNUM *a, int n, const BIGNUM *m, ++ BN_CTX *ctx); ++int BN_mod_lshift_quick(BIGNUM *r, const BIGNUM *a, int n, const BIGNUM *m); ++ ++BN_ULONG BN_mod_word(const BIGNUM *a, BN_ULONG w); ++BN_ULONG BN_div_word(BIGNUM *a, BN_ULONG w); ++int BN_mul_word(BIGNUM *a, BN_ULONG w); ++int BN_add_word(BIGNUM *a, BN_ULONG w); ++int BN_sub_word(BIGNUM *a, BN_ULONG w); ++int BN_set_word(BIGNUM *a, BN_ULONG w); ++BN_ULONG BN_get_word(const BIGNUM *a); ++ ++int BN_cmp(const BIGNUM *a, const BIGNUM *b); ++void BN_free(BIGNUM *a); ++int BN_is_bit_set(const BIGNUM *a, int n); ++int BN_lshift(BIGNUM *r, const BIGNUM *a, int n); ++int BN_lshift1(BIGNUM *r, const BIGNUM *a); ++int BN_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx); ++ ++int BN_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, ++ const BIGNUM *m, BN_CTX *ctx); ++int BN_mod_exp_mont(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, ++ const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx); ++int BN_mod_exp_mont_consttime(BIGNUM *rr, const BIGNUM *a, const BIGNUM *p, ++ const BIGNUM *m, BN_CTX *ctx, ++ BN_MONT_CTX *in_mont); ++int BN_mod_exp_mont_word(BIGNUM *r, BN_ULONG a, const BIGNUM *p, ++ const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx); ++int BN_mod_exp2_mont(BIGNUM *r, const BIGNUM *a1, const BIGNUM *p1, ++ const BIGNUM *a2, const BIGNUM *p2, const BIGNUM *m, ++ BN_CTX *ctx, BN_MONT_CTX *m_ctx); ++int BN_mod_exp_simple(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, ++ const BIGNUM *m, BN_CTX *ctx); ++ ++int BN_mask_bits(BIGNUM *a, int n); ++#ifndef VPP_HICRYPTO_COMPILE ++# ifndef OPENSSL_NO_STDIO ++int BN_print_fp(FILE *fp, const BIGNUM *a); ++# endif ++int BN_print(BIO *bio, const BIGNUM *a); ++#endif ++int BN_reciprocal(BIGNUM *r, const BIGNUM *m, int len, BN_CTX *ctx); ++int BN_rshift(BIGNUM *r, const BIGNUM *a, int n); ++int BN_rshift1(BIGNUM *r, const BIGNUM *a); ++void BN_clear(BIGNUM *a); ++BIGNUM *BN_dup(const BIGNUM *a); ++int BN_ucmp(const BIGNUM *a, const BIGNUM *b); ++int BN_set_bit(BIGNUM *a, int n); ++int BN_clear_bit(BIGNUM *a, int n); ++char *BN_bn2hex(const BIGNUM *a); ++char *BN_bn2dec(const BIGNUM *a); ++int BN_hex2bn(BIGNUM **a, const char *str); ++int BN_dec2bn(BIGNUM **a, const char *str); ++int BN_asc2bn(BIGNUM **a, const char *str); ++int BN_gcd(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx); ++int BN_kronecker(const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx); /* returns ++ * -2 for ++ * error */ ++BIGNUM *BN_mod_inverse(BIGNUM *ret, ++ const BIGNUM *a, const BIGNUM *n, BN_CTX *ctx); ++BIGNUM *BN_mod_sqrt(BIGNUM *ret, ++ const BIGNUM *a, const BIGNUM *n, BN_CTX *ctx); ++ ++void BN_consttime_swap(BN_ULONG swap, BIGNUM *a, BIGNUM *b, int nwords); ++ ++#ifndef VPP_HICRYPTO_COMPILE ++/* Deprecated versions */ ++DEPRECATEDIN_0_9_8(BIGNUM *BN_generate_prime(BIGNUM *ret, int bits, int safe, ++ const BIGNUM *add, ++ const BIGNUM *rem, ++ void (*callback) (int, int, ++ void *), ++ void *cb_arg)) ++DEPRECATEDIN_0_9_8(int ++ BN_is_prime(const BIGNUM *p, int nchecks, ++ void (*callback) (int, int, void *), ++ BN_CTX *ctx, void *cb_arg)) ++DEPRECATEDIN_0_9_8(int ++ BN_is_prime_fasttest(const BIGNUM *p, int nchecks, ++ void (*callback) (int, int, void *), ++ BN_CTX *ctx, void *cb_arg, ++ int do_trial_division)) ++#endif ++/* Newer versions */ ++int BN_generate_prime_ex(BIGNUM *ret, int bits, int safe, const BIGNUM *add, ++ const BIGNUM *rem, BN_GENCB *cb); ++int BN_is_prime_ex(const BIGNUM *p, int nchecks, BN_CTX *ctx, BN_GENCB *cb); ++int BN_is_prime_fasttest_ex(const BIGNUM *p, int nchecks, BN_CTX *ctx, ++ int do_trial_division, BN_GENCB *cb); ++ ++int BN_X931_generate_Xpq(BIGNUM *Xp, BIGNUM *Xq, int nbits, BN_CTX *ctx); ++ ++int BN_X931_derive_prime_ex(BIGNUM *p, BIGNUM *p1, BIGNUM *p2, ++ const BIGNUM *Xp, const BIGNUM *Xp1, ++ const BIGNUM *Xp2, const BIGNUM *e, BN_CTX *ctx, ++ BN_GENCB *cb); ++int BN_X931_generate_prime_ex(BIGNUM *p, BIGNUM *p1, BIGNUM *p2, BIGNUM *Xp1, ++ BIGNUM *Xp2, const BIGNUM *Xp, const BIGNUM *e, ++ BN_CTX *ctx, BN_GENCB *cb); ++ ++BN_MONT_CTX *BN_MONT_CTX_new(void); ++int BN_mod_mul_montgomery(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, ++ BN_MONT_CTX *mont, BN_CTX *ctx); ++int BN_to_montgomery(BIGNUM *r, const BIGNUM *a, BN_MONT_CTX *mont, ++ BN_CTX *ctx); ++int BN_from_montgomery(BIGNUM *r, const BIGNUM *a, BN_MONT_CTX *mont, ++ BN_CTX *ctx); ++void BN_MONT_CTX_free(BN_MONT_CTX *mont); ++int BN_MONT_CTX_set(BN_MONT_CTX *mont, const BIGNUM *mod, BN_CTX *ctx); ++BN_MONT_CTX *BN_MONT_CTX_copy(BN_MONT_CTX *to, BN_MONT_CTX *from); ++#ifndef VPP_HICRYPTO_COMPILE ++BN_MONT_CTX *BN_MONT_CTX_set_locked(BN_MONT_CTX **pmont, CRYPTO_RWLOCK *lock, ++ const BIGNUM *mod, BN_CTX *ctx); ++#else ++BN_MONT_CTX *BN_MONT_CTX_set_locked(BN_MONT_CTX **pmont, CRPT_THREAD_MUTEX *lock, ++ const BIGNUM *mod, BN_CTX *ctx); ++#endif ++/* BN_BLINDING flags */ ++# define BN_BLINDING_NO_UPDATE 0x00000001 ++# define BN_BLINDING_NO_RECREATE 0x00000002 ++ ++BN_BLINDING *BN_BLINDING_new(const BIGNUM *A, const BIGNUM *Ai, BIGNUM *mod); ++void BN_BLINDING_free(BN_BLINDING *b); ++int BN_BLINDING_update(BN_BLINDING *b, BN_CTX *ctx); ++int BN_BLINDING_convert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx); ++int BN_BLINDING_invert(BIGNUM *n, BN_BLINDING *b, BN_CTX *ctx); ++int BN_BLINDING_convert_ex(BIGNUM *n, BIGNUM *r, BN_BLINDING *b, BN_CTX *); ++int BN_BLINDING_invert_ex(BIGNUM *n, const BIGNUM *r, BN_BLINDING *b, ++ BN_CTX *); ++ ++int BN_BLINDING_is_current_thread(BN_BLINDING *b); ++void BN_BLINDING_set_current_thread(BN_BLINDING *b); ++int BN_BLINDING_lock(BN_BLINDING *b); ++int BN_BLINDING_unlock(BN_BLINDING *b); ++ ++unsigned long BN_BLINDING_get_flags(const BN_BLINDING *); ++void BN_BLINDING_set_flags(BN_BLINDING *, unsigned long); ++BN_BLINDING *BN_BLINDING_create_param(BN_BLINDING *b, ++ const BIGNUM *e, BIGNUM *m, BN_CTX *ctx, ++ int (*bn_mod_exp) (BIGNUM *r, ++ const BIGNUM *a, ++ const BIGNUM *p, ++ const BIGNUM *m, ++ BN_CTX *ctx, ++ BN_MONT_CTX *m_ctx), ++ BN_MONT_CTX *m_ctx); ++#ifndef VPP_HICRYPTO_COMPILE ++DEPRECATEDIN_0_9_8(void BN_set_params(int mul, int high, int low, int mont)) ++DEPRECATEDIN_0_9_8(int BN_get_params(int which)) /* 0, mul, 1 high, 2 low, 3 ++ * mont */ ++#endif ++BN_RECP_CTX *BN_RECP_CTX_new(void); ++void BN_RECP_CTX_free(BN_RECP_CTX *recp); ++int BN_RECP_CTX_set(BN_RECP_CTX *recp, const BIGNUM *rdiv, BN_CTX *ctx); ++int BN_mod_mul_reciprocal(BIGNUM *r, const BIGNUM *x, const BIGNUM *y, ++ BN_RECP_CTX *recp, BN_CTX *ctx); ++int BN_mod_exp_recp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, ++ const BIGNUM *m, BN_CTX *ctx); ++int BN_div_recp(BIGNUM *dv, BIGNUM *rem, const BIGNUM *m, ++ BN_RECP_CTX *recp, BN_CTX *ctx); ++ ++# ifndef OPENSSL_NO_EC2M ++ ++/* ++ * Functions for arithmetic over binary polynomials represented by BIGNUMs. ++ * The BIGNUM::neg property of BIGNUMs representing binary polynomials is ++ * ignored. Note that input arguments are not const so that their bit arrays ++ * can be expanded to the appropriate size if needed. ++ */ ++ ++/* ++ * r = a + b ++ */ ++int BN_GF2m_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b); ++# define BN_GF2m_sub(r, a, b) BN_GF2m_add(r, a, b) ++/* ++ * r=a mod p ++ */ ++int BN_GF2m_mod(BIGNUM *r, const BIGNUM *a, const BIGNUM *p); ++/* r = (a * b) mod p */ ++int BN_GF2m_mod_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, ++ const BIGNUM *p, BN_CTX *ctx); ++/* r = (a * a) mod p */ ++int BN_GF2m_mod_sqr(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx); ++/* r = (1 / b) mod p */ ++int BN_GF2m_mod_inv(BIGNUM *r, const BIGNUM *b, const BIGNUM *p, BN_CTX *ctx); ++/* r = (a / b) mod p */ ++int BN_GF2m_mod_div(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, ++ const BIGNUM *p, BN_CTX *ctx); ++/* r = (a ^ b) mod p */ ++int BN_GF2m_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, ++ const BIGNUM *p, BN_CTX *ctx); ++/* r = sqrt(a) mod p */ ++int BN_GF2m_mod_sqrt(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, ++ BN_CTX *ctx); ++/* r^2 + r = a mod p */ ++int BN_GF2m_mod_solve_quad(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, ++ BN_CTX *ctx); ++# define BN_GF2m_cmp(a, b) BN_ucmp((a), (b)) ++/*- ++ * Some functions allow for representation of the irreducible polynomials ++ * as an unsigned int[], say p. The irreducible f(t) is then of the form: ++ * t^p[0] + t^p[1] + ... + t^p[k] ++ * where m = p[0] > p[1] > ... > p[k] = 0. ++ */ ++/* r = a mod p */ ++int BN_GF2m_mod_arr(BIGNUM *r, const BIGNUM *a, const int p[]); ++/* r = (a * b) mod p */ ++int BN_GF2m_mod_mul_arr(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, ++ const int p[], BN_CTX *ctx); ++/* r = (a * a) mod p */ ++int BN_GF2m_mod_sqr_arr(BIGNUM *r, const BIGNUM *a, const int p[], ++ BN_CTX *ctx); ++/* r = (1 / b) mod p */ ++int BN_GF2m_mod_inv_arr(BIGNUM *r, const BIGNUM *b, const int p[], ++ BN_CTX *ctx); ++/* r = (a / b) mod p */ ++int BN_GF2m_mod_div_arr(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, ++ const int p[], BN_CTX *ctx); ++/* r = (a ^ b) mod p */ ++int BN_GF2m_mod_exp_arr(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, ++ const int p[], BN_CTX *ctx); ++/* r = sqrt(a) mod p */ ++int BN_GF2m_mod_sqrt_arr(BIGNUM *r, const BIGNUM *a, ++ const int p[], BN_CTX *ctx); ++/* r^2 + r = a mod p */ ++int BN_GF2m_mod_solve_quad_arr(BIGNUM *r, const BIGNUM *a, ++ const int p[], BN_CTX *ctx); ++int BN_GF2m_poly2arr(const BIGNUM *a, int p[], int max); ++int BN_GF2m_arr2poly(const int p[], BIGNUM *a); ++ ++# endif ++ ++/* ++ * faster mod functions for the 'NIST primes' 0 <= a < p^2 ++ */ ++int BN_nist_mod_192(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx); ++int BN_nist_mod_224(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx); ++int BN_nist_mod_256(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx); ++int BN_nist_mod_384(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx); ++int BN_nist_mod_521(BIGNUM *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx); ++ ++const BIGNUM *BN_get0_nist_prime_192(void); ++const BIGNUM *BN_get0_nist_prime_224(void); ++const BIGNUM *BN_get0_nist_prime_256(void); ++const BIGNUM *BN_get0_nist_prime_384(void); ++const BIGNUM *BN_get0_nist_prime_521(void); ++ ++int (*BN_nist_mod_func(const BIGNUM *p)) (BIGNUM *r, const BIGNUM *a, ++ const BIGNUM *field, BN_CTX *ctx); ++ ++int BN_generate_dsa_nonce(BIGNUM *out, const BIGNUM *range, ++ const BIGNUM *priv, const unsigned char *message, ++ size_t message_len, BN_CTX *ctx); ++ ++/* Primes from RFC 2409 */ ++BIGNUM *BN_get_rfc2409_prime_768(BIGNUM *bn); ++BIGNUM *BN_get_rfc2409_prime_1024(BIGNUM *bn); ++ ++/* Primes from RFC 3526 */ ++BIGNUM *BN_get_rfc3526_prime_1536(BIGNUM *bn); ++BIGNUM *BN_get_rfc3526_prime_2048(BIGNUM *bn); ++BIGNUM *BN_get_rfc3526_prime_3072(BIGNUM *bn); ++BIGNUM *BN_get_rfc3526_prime_4096(BIGNUM *bn); ++BIGNUM *BN_get_rfc3526_prime_6144(BIGNUM *bn); ++BIGNUM *BN_get_rfc3526_prime_8192(BIGNUM *bn); ++ ++# if OPENSSL_API_COMPAT < 0x10100000L ++# define get_rfc2409_prime_768 BN_get_rfc2409_prime_768 ++# define get_rfc2409_prime_1024 BN_get_rfc2409_prime_1024 ++# define get_rfc3526_prime_1536 BN_get_rfc3526_prime_1536 ++# define get_rfc3526_prime_2048 BN_get_rfc3526_prime_2048 ++# define get_rfc3526_prime_3072 BN_get_rfc3526_prime_3072 ++# define get_rfc3526_prime_4096 BN_get_rfc3526_prime_4096 ++# define get_rfc3526_prime_6144 BN_get_rfc3526_prime_6144 ++# define get_rfc3526_prime_8192 BN_get_rfc3526_prime_8192 ++# endif ++ ++int BN_bntest_rand(BIGNUM *rnd, int bits, int top, int bottom); ++ ++#ifdef VPP_HICRYPTO_COMPILE ++/** Internal APIs */ ++BIGNUM *bn_wexpand(BIGNUM *a, int words); ++BIGNUM *bn_expand2(BIGNUM *a, int words); ++ ++void bn_correct_top(BIGNUM *a); ++ ++int bn_get_top(const BIGNUM *a); ++ ++int bn_get_dmax(const BIGNUM *a); ++ ++/* Set all words to zero */ ++void bn_set_all_zero(BIGNUM *a); ++ ++/* ++ * Copy the internal BIGNUM words into out which holds size elements (and size ++ * must be bigger than top) ++ */ ++int bn_copy_words(BN_ULONG *out, const BIGNUM *in, int size); ++ ++BN_ULONG *bn_get_words(const BIGNUM *a); ++ ++/* ++ * Set the internal data words in a to point to words which contains size ++ * elements. The BN_FLG_STATIC_DATA flag is set ++ */ ++void bn_set_static_words(BIGNUM *a, const BN_ULONG *words, int size); ++ ++/* ++ * Copy words into the BIGNUM |a|, reallocating space as necessary. ++ * The negative flag of |a| is not modified. ++ * Returns 1 on success and 0 on failure. ++ */ ++/* ++ * |num_words| is int because bn_expand2 takes an int. This is an internal ++ * function so we simply trust callers not to pass negative values. ++ */ ++int bn_set_words(BIGNUM *a, const BN_ULONG *words, int num_words); ++ ++/* ++ * Some BIGNUM functions assume most significant limb to be non-zero, which ++ * is customarily arranged by bn_correct_top. Output from below functions ++ * is not processed with bn_correct_top, and for this reason it may not be ++ * returned out of public API. It may only be passed internally into other ++ * functions known to support non-minimal or zero-padded BIGNUMs. Even ++ * though the goal is to facilitate constant-time-ness, not each subroutine ++ * is constant-time by itself. They all have pre-conditions, consult source ++ * code... ++ */ ++int bn_mul_mont_fixed_top(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_MONT_CTX *mont, BN_CTX *ctx); ++int bn_to_mont_fixed_top(BIGNUM *r, const BIGNUM *a, BN_MONT_CTX *mont, BN_CTX *ctx); ++int bn_from_mont_fixed_top(BIGNUM *r, const BIGNUM *a, BN_MONT_CTX *mont, BN_CTX *ctx); ++int bn_mod_add_fixed_top(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m); ++int bn_mod_sub_fixed_top(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *m); ++int bn_mul_fixed_top(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx); ++int bn_sqr_fixed_top(BIGNUM *r, const BIGNUM *a, BN_CTX *ctx); ++int bn_lshift_fixed_top(BIGNUM *r, const BIGNUM *a, int n); ++int bn_rshift_fixed_top(BIGNUM *r, const BIGNUM *a, int n); ++int bn_div_fixed_top(BIGNUM *dv, BIGNUM *rem, const BIGNUM *m, const BIGNUM *d, BN_CTX *ctx); ++ ++/* ++ * BN reason codes. ++ */ ++#define BN_R_ARG2_LT_ARG3 100 ++#define BN_R_BAD_RECIPROCAL 101 ++#define BN_R_BIGNUM_TOO_LONG 114 ++#define BN_R_BITS_TOO_SMALL 118 ++#define BN_R_CALLED_WITH_EVEN_MODULUS 102 ++#define BN_R_DIV_BY_ZERO 103 ++#define BN_R_ENCODING_ERROR 104 ++#define BN_R_EXPAND_ON_STATIC_BIGNUM_DATA 105 ++#define BN_R_INPUT_NOT_REDUCED 110 ++#define BN_R_INVALID_LENGTH 106 ++#define BN_R_INVALID_RANGE 115 ++#define BN_R_INVALID_SHIFT 119 ++#define BN_R_NOT_A_SQUARE 111 ++#define BN_R_NOT_INITIALIZED 107 ++#define BN_R_NO_INVERSE 108 ++#define BN_R_NO_SOLUTION 116 ++#define BN_R_NO_SUITABLE_DIGEST 120 ++#define BN_R_PRIVATE_KEY_TOO_LARGE 117 ++#define BN_R_P_IS_NOT_PRIME 112 ++#define BN_R_TOO_MANY_ITERATIONS 113 ++#define BN_R_TOO_MANY_TEMPORARY_VARIABLES 109 ++ ++#pragma GCC visibility pop ++#endif ++ ++# ifdef __cplusplus ++} ++# endif ++#endif +diff --git a/include/TA/openssl/openssl/bnerr.h b/include/TA/openssl/openssl/bnerr.h +new file mode 100644 +index 0000000..a0752ce +--- /dev/null ++++ b/include/TA/openssl/openssl/bnerr.h +@@ -0,0 +1,101 @@ ++/* ++ * Generated by util/mkerr.pl DO NOT EDIT ++ * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. ++ * ++ * Licensed under the OpenSSL license (the "License"). You may not use ++ * this file except in compliance with the License. You can obtain a copy ++ * in the file LICENSE in the source distribution or at ++ * https://www.openssl.org/source/license.html ++ */ ++ ++#ifndef HEADER_BNERR_H ++# define HEADER_BNERR_H ++ ++# ifndef HEADER_SYMHACKS_H ++# include ++# endif ++ ++# ifdef __cplusplus ++extern "C" ++# endif ++int ERR_load_BN_strings(void); ++ ++/* ++ * BN function codes. ++ */ ++# define BN_F_BNRAND 127 ++# define BN_F_BNRAND_RANGE 138 ++# define BN_F_BN_BLINDING_CONVERT_EX 100 ++# define BN_F_BN_BLINDING_CREATE_PARAM 128 ++# define BN_F_BN_BLINDING_INVERT_EX 101 ++# define BN_F_BN_BLINDING_NEW 102 ++# define BN_F_BN_BLINDING_UPDATE 103 ++# define BN_F_BN_BN2DEC 104 ++# define BN_F_BN_BN2HEX 105 ++# define BN_F_BN_COMPUTE_WNAF 142 ++# define BN_F_BN_CTX_GET 116 ++# define BN_F_BN_CTX_NEW 106 ++# define BN_F_BN_CTX_START 129 ++# define BN_F_BN_DIV 107 ++# define BN_F_BN_DIV_RECP 130 ++# define BN_F_BN_EXP 123 ++# define BN_F_BN_EXPAND_INTERNAL 120 ++# define BN_F_BN_GENCB_NEW 143 ++# define BN_F_BN_GENERATE_DSA_NONCE 140 ++# define BN_F_BN_GENERATE_PRIME_EX 141 ++# define BN_F_BN_GF2M_MOD 131 ++# define BN_F_BN_GF2M_MOD_EXP 132 ++# define BN_F_BN_GF2M_MOD_MUL 133 ++# define BN_F_BN_GF2M_MOD_SOLVE_QUAD 134 ++# define BN_F_BN_GF2M_MOD_SOLVE_QUAD_ARR 135 ++# define BN_F_BN_GF2M_MOD_SQR 136 ++# define BN_F_BN_GF2M_MOD_SQRT 137 ++# define BN_F_BN_LSHIFT 145 ++# define BN_F_BN_MOD_EXP2_MONT 118 ++# define BN_F_BN_MOD_EXP_MONT 109 ++# define BN_F_BN_MOD_EXP_MONT_CONSTTIME 124 ++# define BN_F_BN_MOD_EXP_MONT_WORD 117 ++# define BN_F_BN_MOD_EXP_RECP 125 ++# define BN_F_BN_MOD_EXP_SIMPLE 126 ++# define BN_F_BN_MOD_INVERSE 110 ++# define BN_F_BN_MOD_INVERSE_NO_BRANCH 139 ++# define BN_F_BN_MOD_LSHIFT_QUICK 119 ++# define BN_F_BN_MOD_SQRT 121 ++# define BN_F_BN_MONT_CTX_NEW 149 ++# define BN_F_BN_MPI2BN 112 ++# define BN_F_BN_NEW 113 ++# define BN_F_BN_POOL_GET 147 ++# define BN_F_BN_RAND 114 ++# define BN_F_BN_RAND_RANGE 122 ++# define BN_F_BN_RECP_CTX_NEW 150 ++# define BN_F_BN_RSHIFT 146 ++# define BN_F_BN_SET_WORDS 144 ++# define BN_F_BN_STACK_PUSH 148 ++# define BN_F_BN_USUB 115 ++# define BN_F_OSSL_BN_RSA_DO_UNBLIND 151 ++ ++/* ++ * BN reason codes. ++ */ ++# define BN_R_ARG2_LT_ARG3 100 ++# define BN_R_BAD_RECIPROCAL 101 ++# define BN_R_BIGNUM_TOO_LONG 114 ++# define BN_R_BITS_TOO_SMALL 118 ++# define BN_R_CALLED_WITH_EVEN_MODULUS 102 ++# define BN_R_DIV_BY_ZERO 103 ++# define BN_R_ENCODING_ERROR 104 ++# define BN_R_EXPAND_ON_STATIC_BIGNUM_DATA 105 ++# define BN_R_INPUT_NOT_REDUCED 110 ++# define BN_R_INVALID_LENGTH 106 ++# define BN_R_INVALID_RANGE 115 ++# define BN_R_INVALID_SHIFT 119 ++# define BN_R_NOT_A_SQUARE 111 ++# define BN_R_NOT_INITIALIZED 107 ++# define BN_R_NO_INVERSE 108 ++# define BN_R_NO_SOLUTION 116 ++# define BN_R_PRIVATE_KEY_TOO_LARGE 117 ++# define BN_R_P_IS_NOT_PRIME 112 ++# define BN_R_TOO_MANY_ITERATIONS 113 ++# define BN_R_TOO_MANY_TEMPORARY_VARIABLES 109 ++ ++#endif +diff --git a/include/TA/openssl/openssl/buffer.h b/include/TA/openssl/openssl/buffer.h +new file mode 100644 +index 0000000..35a8503 +--- /dev/null ++++ b/include/TA/openssl/openssl/buffer.h +@@ -0,0 +1,56 @@ ++/* ++ * Copyright 1995-2018 The OpenSSL Project Authors. All Rights Reserved. ++ * ++ * Licensed under the OpenSSL license (the "License"). You may not use ++ * this file except in compliance with the License. You can obtain a copy ++ * in the file LICENSE in the source distribution or at ++ * https://www.openssl.org/source/license.html ++ */ ++ ++#ifndef HEADER_BUFFER_H ++# define HEADER_BUFFER_H ++ ++# include ++# ifndef HEADER_CRYPTO_H ++# include ++# endif ++# include ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++# include ++# include ++ ++/* ++ * These names are outdated as of OpenSSL 1.1; a future release ++ * will move them to be deprecated. ++ */ ++# define BUF_strdup(s) OPENSSL_strdup(s) ++# define BUF_strndup(s, size) OPENSSL_strndup(s, size) ++# define BUF_memdup(data, size) OPENSSL_memdup(data, size) ++# define BUF_strlcpy(dst, src, size) OPENSSL_strlcpy(dst, src, size) ++# define BUF_strlcat(dst, src, size) OPENSSL_strlcat(dst, src, size) ++# define BUF_strnlen(str, maxlen) OPENSSL_strnlen(str, maxlen) ++ ++struct buf_mem_st { ++ size_t length; /* current number of bytes */ ++ char *data; ++ size_t max; /* size of buffer */ ++ unsigned long flags; ++}; ++ ++# define BUF_MEM_FLAG_SECURE 0x01 ++ ++BUF_MEM *BUF_MEM_new(void); ++BUF_MEM *BUF_MEM_new_ex(unsigned long flags); ++void BUF_MEM_free(BUF_MEM *a); ++size_t BUF_MEM_grow(BUF_MEM *str, size_t len); ++size_t BUF_MEM_grow_clean(BUF_MEM *str, size_t len); ++void BUF_reverse(unsigned char *out, const unsigned char *in, size_t siz); ++ ++# ifdef __cplusplus ++} ++# endif ++#endif +diff --git a/include/TA/openssl/openssl/buffererr.h b/include/TA/openssl/openssl/buffererr.h +new file mode 100644 +index 0000000..04f6ff7 +--- /dev/null ++++ b/include/TA/openssl/openssl/buffererr.h +@@ -0,0 +1,34 @@ ++/* ++ * Generated by util/mkerr.pl DO NOT EDIT ++ * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. ++ * ++ * Licensed under the OpenSSL license (the "License"). You may not use ++ * this file except in compliance with the License. You can obtain a copy ++ * in the file LICENSE in the source distribution or at ++ * https://www.openssl.org/source/license.html ++ */ ++ ++#ifndef HEADER_BUFERR_H ++# define HEADER_BUFERR_H ++ ++# ifndef HEADER_SYMHACKS_H ++# include ++# endif ++ ++# ifdef __cplusplus ++extern "C" ++# endif ++int ERR_load_BUF_strings(void); ++ ++/* ++ * BUF function codes. ++ */ ++# define BUF_F_BUF_MEM_GROW 100 ++# define BUF_F_BUF_MEM_GROW_CLEAN 105 ++# define BUF_F_BUF_MEM_NEW 101 ++ ++/* ++ * BUF reason codes. ++ */ ++ ++#endif +diff --git a/include/TA/openssl/openssl/cmac.h b/include/TA/openssl/openssl/cmac.h +new file mode 100644 +index 0000000..3535a9a +--- /dev/null ++++ b/include/TA/openssl/openssl/cmac.h +@@ -0,0 +1,41 @@ ++/* ++ * Copyright 2010-2016 The OpenSSL Project Authors. All Rights Reserved. ++ * ++ * Licensed under the OpenSSL license (the "License"). You may not use ++ * this file except in compliance with the License. You can obtain a copy ++ * in the file LICENSE in the source distribution or at ++ * https://www.openssl.org/source/license.html ++ */ ++ ++#ifndef HEADER_CMAC_H ++# define HEADER_CMAC_H ++ ++# ifndef OPENSSL_NO_CMAC ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++# include ++ ++/* Opaque */ ++typedef struct CMAC_CTX_st CMAC_CTX; ++ ++CMAC_CTX *CMAC_CTX_new(void); ++void CMAC_CTX_cleanup(CMAC_CTX *ctx); ++void CMAC_CTX_free(CMAC_CTX *ctx); ++EVP_CIPHER_CTX *CMAC_CTX_get0_cipher_ctx(CMAC_CTX *ctx); ++int CMAC_CTX_copy(CMAC_CTX *out, const CMAC_CTX *in); ++ ++int CMAC_Init(CMAC_CTX *ctx, const void *key, size_t keylen, ++ const EVP_CIPHER *cipher, ENGINE *impl); ++int CMAC_Update(CMAC_CTX *ctx, const void *data, size_t dlen); ++int CMAC_Final(CMAC_CTX *ctx, unsigned char *out, size_t *poutlen); ++int CMAC_resume(CMAC_CTX *ctx); ++ ++#ifdef __cplusplus ++} ++#endif ++ ++# endif ++#endif +diff --git a/include/TA/openssl/openssl/crypto.h b/include/TA/openssl/openssl/crypto.h +new file mode 100644 +index 0000000..2b5c52a +--- /dev/null ++++ b/include/TA/openssl/openssl/crypto.h +@@ -0,0 +1,501 @@ ++/* ++ * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. ++ * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved ++ * ++ * Licensed under the OpenSSL license (the "License"). You may not use ++ * this file except in compliance with the License. You can obtain a copy ++ * in the file LICENSE in the source distribution or at ++ * https://www.openssl.org/source/license.html ++ */ ++ ++#ifndef HEADER_CRYPTO_H ++# define HEADER_CRYPTO_H ++ ++# include ++# include ++ ++# include ++ ++# ifndef OPENSSL_NO_STDIO ++# include ++# endif ++ ++# include ++# include ++# include ++# include ++# include ++ ++# ifdef CHARSET_EBCDIC ++# include ++# endif ++ ++/* ++ * Resolve problems on some operating systems with symbol names that clash ++ * one way or another ++ */ ++# include ++ ++# if OPENSSL_API_COMPAT < 0x10100000L ++# include ++# endif ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++# if OPENSSL_API_COMPAT < 0x10100000L ++# define SSLeay OpenSSL_version_num ++# define SSLeay_version OpenSSL_version ++# define SSLEAY_VERSION_NUMBER OPENSSL_VERSION_NUMBER ++# define SSLEAY_VERSION OPENSSL_VERSION ++# define SSLEAY_CFLAGS OPENSSL_CFLAGS ++# define SSLEAY_BUILT_ON OPENSSL_BUILT_ON ++# define SSLEAY_PLATFORM OPENSSL_PLATFORM ++# define SSLEAY_DIR OPENSSL_DIR ++ ++/* ++ * Old type for allocating dynamic locks. No longer used. Use the new thread ++ * API instead. ++ */ ++typedef struct { ++ int dummy; ++} CRYPTO_dynlock; ++ ++# endif /* OPENSSL_API_COMPAT */ ++ ++typedef void CRYPTO_RWLOCK; ++ ++CRYPTO_RWLOCK *CRYPTO_THREAD_lock_new(void); ++int CRYPTO_THREAD_read_lock(CRYPTO_RWLOCK *lock); ++int CRYPTO_THREAD_write_lock(CRYPTO_RWLOCK *lock); ++int CRYPTO_THREAD_unlock(CRYPTO_RWLOCK *lock); ++void CRYPTO_THREAD_lock_free(CRYPTO_RWLOCK *lock); ++ ++int CRYPTO_atomic_add(int *val, int amount, int *ret, CRYPTO_RWLOCK *lock); ++ ++/* ++ * The following can be used to detect memory leaks in the library. If ++ * used, it turns on malloc checking ++ */ ++# define CRYPTO_MEM_CHECK_OFF 0x0 /* Control only */ ++# define CRYPTO_MEM_CHECK_ON 0x1 /* Control and mode bit */ ++# define CRYPTO_MEM_CHECK_ENABLE 0x2 /* Control and mode bit */ ++# define CRYPTO_MEM_CHECK_DISABLE 0x3 /* Control only */ ++ ++struct crypto_ex_data_st { ++ STACK_OF(void) *sk; ++}; ++DEFINE_STACK_OF(void) ++ ++/* ++ * Per class, we have a STACK of function pointers. ++ */ ++# define CRYPTO_EX_INDEX_SSL 0 ++# define CRYPTO_EX_INDEX_SSL_CTX 1 ++# define CRYPTO_EX_INDEX_SSL_SESSION 2 ++# define CRYPTO_EX_INDEX_X509 3 ++# define CRYPTO_EX_INDEX_X509_STORE 4 ++# define CRYPTO_EX_INDEX_X509_STORE_CTX 5 ++# define CRYPTO_EX_INDEX_DH 6 ++# define CRYPTO_EX_INDEX_DSA 7 ++# define CRYPTO_EX_INDEX_EC_KEY 8 ++# define CRYPTO_EX_INDEX_RSA 9 ++# define CRYPTO_EX_INDEX_ENGINE 10 ++# define CRYPTO_EX_INDEX_UI 11 ++# define CRYPTO_EX_INDEX_BIO 12 ++# define CRYPTO_EX_INDEX_APP 13 ++# define CRYPTO_EX_INDEX_UI_METHOD 14 ++# define CRYPTO_EX_INDEX_DRBG 15 ++# define CRYPTO_EX_INDEX_SM9_KEY 16 ++# define CRYPTO_EX_INDEX__COUNT 17 ++ ++/* No longer needed, so this is a no-op */ ++#define OPENSSL_malloc_init() while(0) continue ++ ++int CRYPTO_mem_ctrl(int mode); ++ ++# define OPENSSL_malloc(num) \ ++ CRYPTO_malloc(num, OPENSSL_FILE, OPENSSL_LINE) ++# define OPENSSL_zalloc(num) \ ++ CRYPTO_zalloc(num, OPENSSL_FILE, OPENSSL_LINE) ++# define OPENSSL_realloc(addr, num) \ ++ CRYPTO_realloc(addr, num, OPENSSL_FILE, OPENSSL_LINE) ++# define OPENSSL_clear_realloc(addr, old_num, num) \ ++ CRYPTO_clear_realloc(addr, old_num, num, OPENSSL_FILE, OPENSSL_LINE) ++# define OPENSSL_clear_free(addr, num) \ ++ CRYPTO_clear_free(addr, num, OPENSSL_FILE, OPENSSL_LINE) ++# define OPENSSL_free(addr) \ ++ CRYPTO_free(addr, OPENSSL_FILE, OPENSSL_LINE) ++# define OPENSSL_memdup(str, s) \ ++ CRYPTO_memdup((str), s, OPENSSL_FILE, OPENSSL_LINE) ++# define OPENSSL_strdup(str) \ ++ CRYPTO_strdup(str, OPENSSL_FILE, OPENSSL_LINE) ++# define OPENSSL_strndup(str, n) \ ++ CRYPTO_strndup(str, n, OPENSSL_FILE, OPENSSL_LINE) ++# define OPENSSL_secure_malloc(num) \ ++ CRYPTO_secure_malloc(num, OPENSSL_FILE, OPENSSL_LINE) ++# define OPENSSL_secure_zalloc(num) \ ++ CRYPTO_secure_zalloc(num, OPENSSL_FILE, OPENSSL_LINE) ++# define OPENSSL_secure_free(addr) \ ++ CRYPTO_secure_free(addr, OPENSSL_FILE, OPENSSL_LINE) ++# define OPENSSL_secure_clear_free(addr, num) \ ++ CRYPTO_secure_clear_free(addr, num, OPENSSL_FILE, OPENSSL_LINE) ++# define OPENSSL_secure_actual_size(ptr) \ ++ CRYPTO_secure_actual_size(ptr) ++ ++size_t OPENSSL_strlcpy(char *dst, const char *src, size_t siz); ++size_t OPENSSL_strlcat(char *dst, const char *src, size_t siz); ++size_t OPENSSL_strnlen(const char *str, size_t maxlen); ++char *OPENSSL_buf2hexstr(const unsigned char *buffer, long len); ++unsigned char *OPENSSL_hexstr2buf(const char *str, long *len); ++int OPENSSL_hexchar2int(unsigned char c); ++ ++# define OPENSSL_MALLOC_MAX_NELEMS(type) (((1U<<(sizeof(int)*8-1))-1)/sizeof(type)) ++ ++unsigned long OpenSSL_version_num(void); ++const char *OpenSSL_version(int type); ++# define OPENSSL_VERSION 0 ++# define OPENSSL_CFLAGS 1 ++# define OPENSSL_BUILT_ON 2 ++# define OPENSSL_PLATFORM 3 ++# define OPENSSL_DIR 4 ++# define OPENSSL_ENGINES_DIR 5 ++ ++int OPENSSL_issetugid(void); ++ ++typedef void CRYPTO_EX_new (void *parent, void *ptr, CRYPTO_EX_DATA *ad, ++ int idx, long argl, void *argp); ++typedef void CRYPTO_EX_free (void *parent, void *ptr, CRYPTO_EX_DATA *ad, ++ int idx, long argl, void *argp); ++typedef int CRYPTO_EX_dup (CRYPTO_EX_DATA *to, const CRYPTO_EX_DATA *from, ++ void *from_d, int idx, long argl, void *argp); ++__owur int CRYPTO_get_ex_new_index(int class_index, long argl, void *argp, ++ CRYPTO_EX_new *new_func, CRYPTO_EX_dup *dup_func, ++ CRYPTO_EX_free *free_func); ++/* No longer use an index. */ ++int CRYPTO_free_ex_index(int class_index, int idx); ++ ++/* ++ * Initialise/duplicate/free CRYPTO_EX_DATA variables corresponding to a ++ * given class (invokes whatever per-class callbacks are applicable) ++ */ ++int CRYPTO_new_ex_data(int class_index, void *obj, CRYPTO_EX_DATA *ad); ++int CRYPTO_dup_ex_data(int class_index, CRYPTO_EX_DATA *to, ++ const CRYPTO_EX_DATA *from); ++ ++void CRYPTO_free_ex_data(int class_index, void *obj, CRYPTO_EX_DATA *ad); ++ ++/* ++ * Get/set data in a CRYPTO_EX_DATA variable corresponding to a particular ++ * index (relative to the class type involved) ++ */ ++int CRYPTO_set_ex_data(CRYPTO_EX_DATA *ad, int idx, void *val); ++void *CRYPTO_get_ex_data(const CRYPTO_EX_DATA *ad, int idx); ++ ++# if OPENSSL_API_COMPAT < 0x10100000L ++/* ++ * This function cleans up all "ex_data" state. It mustn't be called under ++ * potential race-conditions. ++ */ ++# define CRYPTO_cleanup_all_ex_data() while(0) continue ++ ++/* ++ * The old locking functions have been removed completely without compatibility ++ * macros. This is because the old functions either could not properly report ++ * errors, or the returned error values were not clearly documented. ++ * Replacing the locking functions with no-ops would cause race condition ++ * issues in the affected applications. It is far better for them to fail at ++ * compile time. ++ * On the other hand, the locking callbacks are no longer used. Consequently, ++ * the callback management functions can be safely replaced with no-op macros. ++ */ ++# define CRYPTO_num_locks() (1) ++# define CRYPTO_set_locking_callback(func) ++# define CRYPTO_get_locking_callback() (NULL) ++# define CRYPTO_set_add_lock_callback(func) ++# define CRYPTO_get_add_lock_callback() (NULL) ++ ++/* ++ * These defines where used in combination with the old locking callbacks, ++ * they are not called anymore, but old code that's not called might still ++ * use them. ++ */ ++# define CRYPTO_LOCK 1 ++# define CRYPTO_UNLOCK 2 ++# define CRYPTO_READ 4 ++# define CRYPTO_WRITE 8 ++ ++/* This structure is no longer used */ ++typedef struct crypto_threadid_st { ++ int dummy; ++} CRYPTO_THREADID; ++/* Only use CRYPTO_THREADID_set_[numeric|pointer]() within callbacks */ ++# define CRYPTO_THREADID_set_numeric(id, val) ++# define CRYPTO_THREADID_set_pointer(id, ptr) ++# define CRYPTO_THREADID_set_callback(threadid_func) (0) ++# define CRYPTO_THREADID_get_callback() (NULL) ++# define CRYPTO_THREADID_current(id) ++# define CRYPTO_THREADID_cmp(a, b) (-1) ++# define CRYPTO_THREADID_cpy(dest, src) ++# define CRYPTO_THREADID_hash(id) (0UL) ++ ++# if OPENSSL_API_COMPAT < 0x10000000L ++# define CRYPTO_set_id_callback(func) ++# define CRYPTO_get_id_callback() (NULL) ++# define CRYPTO_thread_id() (0UL) ++# endif /* OPENSSL_API_COMPAT < 0x10000000L */ ++ ++# define CRYPTO_set_dynlock_create_callback(dyn_create_function) ++# define CRYPTO_set_dynlock_lock_callback(dyn_lock_function) ++# define CRYPTO_set_dynlock_destroy_callback(dyn_destroy_function) ++# define CRYPTO_get_dynlock_create_callback() (NULL) ++# define CRYPTO_get_dynlock_lock_callback() (NULL) ++# define CRYPTO_get_dynlock_destroy_callback() (NULL) ++# endif /* OPENSSL_API_COMPAT < 0x10100000L */ ++ ++int CRYPTO_set_mem_functions( ++ void *(*m) (size_t, const char *, int), ++ void *(*r) (void *, size_t, const char *, int), ++ void (*f) (void *, const char *, int)); ++int CRYPTO_set_mem_debug(int flag); ++void CRYPTO_get_mem_functions( ++ void *(**m) (size_t, const char *, int), ++ void *(**r) (void *, size_t, const char *, int), ++ void (**f) (void *, const char *, int)); ++ ++void *CRYPTO_malloc(size_t num, const char *file, int line); ++void *CRYPTO_zalloc(size_t num, const char *file, int line); ++void *CRYPTO_memdup(const void *str, size_t siz, const char *file, int line); ++char *CRYPTO_strdup(const char *str, const char *file, int line); ++char *CRYPTO_strndup(const char *str, size_t s, const char *file, int line); ++void CRYPTO_free(void *ptr, const char *file, int line); ++void CRYPTO_clear_free(void *ptr, size_t num, const char *file, int line); ++void *CRYPTO_realloc(void *addr, size_t num, const char *file, int line); ++void *CRYPTO_clear_realloc(void *addr, size_t old_num, size_t num, ++ const char *file, int line); ++ ++int CRYPTO_secure_malloc_init(size_t sz, int minsize); ++int CRYPTO_secure_malloc_done(void); ++void *CRYPTO_secure_malloc(size_t num, const char *file, int line); ++void *CRYPTO_secure_zalloc(size_t num, const char *file, int line); ++void CRYPTO_secure_free(void *ptr, const char *file, int line); ++void CRYPTO_secure_clear_free(void *ptr, size_t num, ++ const char *file, int line); ++int CRYPTO_secure_allocated(const void *ptr); ++int CRYPTO_secure_malloc_initialized(void); ++size_t CRYPTO_secure_actual_size(void *ptr); ++size_t CRYPTO_secure_used(void); ++ ++void OPENSSL_cleanse(void *ptr, size_t len); ++ ++# ifndef OPENSSL_NO_CRYPTO_MDEBUG ++# define OPENSSL_mem_debug_push(info) \ ++ CRYPTO_mem_debug_push(info, OPENSSL_FILE, OPENSSL_LINE) ++# define OPENSSL_mem_debug_pop() \ ++ CRYPTO_mem_debug_pop() ++int CRYPTO_mem_debug_push(const char *info, const char *file, int line); ++int CRYPTO_mem_debug_pop(void); ++void CRYPTO_get_alloc_counts(int *mcount, int *rcount, int *fcount); ++ ++/*- ++ * Debugging functions (enabled by CRYPTO_set_mem_debug(1)) ++ * The flag argument has the following significance: ++ * 0: called before the actual memory allocation has taken place ++ * 1: called after the actual memory allocation has taken place ++ */ ++void CRYPTO_mem_debug_malloc(void *addr, size_t num, int flag, ++ const char *file, int line); ++void CRYPTO_mem_debug_realloc(void *addr1, void *addr2, size_t num, int flag, ++ const char *file, int line); ++void CRYPTO_mem_debug_free(void *addr, int flag, ++ const char *file, int line); ++ ++int CRYPTO_mem_leaks_cb(int (*cb) (const char *str, size_t len, void *u), ++ void *u); ++# ifndef OPENSSL_NO_STDIO ++int CRYPTO_mem_leaks_fp(FILE *); ++# endif ++int CRYPTO_mem_leaks(BIO *bio); ++# endif ++ ++#ifndef OPENSSL_NO_CRL_MEMPOOL ++int CRYPT_init_memory_pool(int pool_size, int max_no_pool); ++#endif ++ ++/* die if we have to */ ++ossl_noreturn void OPENSSL_die(const char *assertion, const char *file, int line); ++# if OPENSSL_API_COMPAT < 0x10100000L ++# define OpenSSLDie(f,l,a) OPENSSL_die((a),(f),(l)) ++# endif ++# define OPENSSL_assert(e) \ ++ (void)((e) ? 0 : (OPENSSL_die("assertion failed: " #e, OPENSSL_FILE, OPENSSL_LINE), 1)) ++ ++#if defined(OPENSSL_SYS_VXWORKS) && defined(OPENSSL_SYS_VXWORKS55) ++int CRYPTO_strncasecmp(unsigned char *a, unsigned char *b, size_t len); ++int CRYPTO_strcasecmp(unsigned char *a, unsigned char *b); ++ ++#define strncasecmp(a,b,len) CRYPTO_strncasecmp((a), (b), (len)) ++#define strcasecmp(a,b) CRYPTO_strcasecmp((a), (b)) ++#endif ++ ++#if !defined(OPENSSL_NO_NDCPP) ++#define NDCPP_MODE_OFF 0 ++#define NDCPP_MODE_ON 1 ++ ++int NDCPP_mode(void); ++int NDCPP_mode_set(int r); ++#endif ++ ++int OPENSSL_isservice(void); ++ ++int FIPS_mode(void); ++int FIPS_mode_set(int r); ++ ++#ifndef OPENSSL_NO_FIPS ++int FIPS_selftest_result(int result); ++#endif ++ ++void OPENSSL_init(void); ++# ifdef OPENSSL_SYS_UNIX ++void OPENSSL_fork_prepare(void); ++void OPENSSL_fork_parent(void); ++void OPENSSL_fork_child(void); ++# endif ++ ++struct tm *OPENSSL_gmtime(const time_t *timer, struct tm *result); ++int OPENSSL_gmtime_adj(struct tm *tm, int offset_day, long offset_sec); ++int OPENSSL_gmtime_diff(int *pday, int *psec, ++ const struct tm *from, const struct tm *to); ++ ++/* ++ * CRYPTO_memcmp returns zero iff the |len| bytes at |a| and |b| are equal. ++ * It takes an amount of time dependent on |len|, but independent of the ++ * contents of |a| and |b|. Unlike memcmp, it cannot be used to put elements ++ * into a defined order as the return value when a != b is undefined, other ++ * than to be non-zero. ++ */ ++int CRYPTO_memcmp(const void * in_a, const void * in_b, size_t len); ++ ++/* Standard initialisation options */ ++# define OPENSSL_INIT_NO_LOAD_CRYPTO_STRINGS 0x00000001L ++# define OPENSSL_INIT_LOAD_CRYPTO_STRINGS 0x00000002L ++# define OPENSSL_INIT_ADD_ALL_CIPHERS 0x00000004L ++# define OPENSSL_INIT_ADD_ALL_DIGESTS 0x00000008L ++# define OPENSSL_INIT_NO_ADD_ALL_CIPHERS 0x00000010L ++# define OPENSSL_INIT_NO_ADD_ALL_DIGESTS 0x00000020L ++# define OPENSSL_INIT_LOAD_CONFIG 0x00000040L ++# define OPENSSL_INIT_NO_LOAD_CONFIG 0x00000080L ++# define OPENSSL_INIT_ASYNC 0x00000100L ++# define OPENSSL_INIT_ENGINE_RDRAND 0x00000200L ++# define OPENSSL_INIT_ENGINE_DYNAMIC 0x00000400L ++# define OPENSSL_INIT_ENGINE_OPENSSL 0x00000800L ++# define OPENSSL_INIT_ENGINE_CRYPTODEV 0x00001000L ++# define OPENSSL_INIT_ENGINE_CAPI 0x00002000L ++# define OPENSSL_INIT_ENGINE_PADLOCK 0x00004000L ++# define OPENSSL_INIT_ENGINE_AFALG 0x00008000L ++/* OPENSSL_INIT_ZLIB 0x00010000L */ ++# define OPENSSL_INIT_ATFORK 0x00020000L ++/* OPENSSL_INIT_BASE_ONLY 0x00040000L */ ++# define OPENSSL_INIT_NO_ATEXIT 0x00080000L ++/* OPENSSL_INIT flag range 0xfff00000 reserved for OPENSSL_init_ssl() */ ++/* Max OPENSSL_INIT flag value is 0x80000000 */ ++ ++/* openssl and dasync not counted as builtin */ ++# define OPENSSL_INIT_ENGINE_ALL_BUILTIN \ ++ (OPENSSL_INIT_ENGINE_RDRAND | OPENSSL_INIT_ENGINE_DYNAMIC \ ++ | OPENSSL_INIT_ENGINE_CRYPTODEV | OPENSSL_INIT_ENGINE_CAPI | \ ++ OPENSSL_INIT_ENGINE_PADLOCK) ++ ++/* Library initialisation functions */ ++void OPENSSL_cleanup(void); ++int OPENSSL_init_crypto(uint64_t opts, const OPENSSL_INIT_SETTINGS *settings); ++int OPENSSL_atexit(void (*handler)(void)); ++void OPENSSL_thread_stop(void); ++ ++/* Low-level control of initialization */ ++OPENSSL_INIT_SETTINGS *OPENSSL_INIT_new(void); ++# ifndef OPENSSL_NO_STDIO ++int OPENSSL_INIT_set_config_filename(OPENSSL_INIT_SETTINGS *settings, ++ const char *config_filename); ++void OPENSSL_INIT_set_config_file_flags(OPENSSL_INIT_SETTINGS *settings, ++ unsigned long flags); ++int OPENSSL_INIT_set_config_appname(OPENSSL_INIT_SETTINGS *settings, ++ const char *config_appname); ++# endif ++void OPENSSL_INIT_free(OPENSSL_INIT_SETTINGS *settings); ++ ++# if defined(OPENSSL_THREADS) && !defined(CRYPTO_TDEBUG) ++# if defined(_WIN32) ++# if defined(BASETYPES) || defined(_WINDEF_H) ++/* application has to include in order to use this */ ++typedef DWORD CRYPTO_THREAD_LOCAL; ++typedef DWORD CRYPTO_THREAD_ID; ++ ++typedef LONG CRYPTO_ONCE; ++# define CRYPTO_ONCE_STATIC_INIT 0 ++# endif ++# else ++# include ++typedef pthread_once_t CRYPTO_ONCE; ++typedef pthread_key_t CRYPTO_THREAD_LOCAL; ++typedef pthread_t CRYPTO_THREAD_ID; ++ ++# define CRYPTO_ONCE_STATIC_INIT PTHREAD_ONCE_INIT ++# endif ++# endif ++ ++# if !defined(CRYPTO_ONCE_STATIC_INIT) ++typedef unsigned int CRYPTO_ONCE; ++typedef unsigned int CRYPTO_THREAD_LOCAL; ++typedef unsigned int CRYPTO_THREAD_ID; ++# define CRYPTO_ONCE_STATIC_INIT 0 ++# endif ++ ++int CRYPTO_THREAD_run_once(CRYPTO_ONCE *once, void (*init)(void)); ++ ++int CRYPTO_THREAD_init_local(CRYPTO_THREAD_LOCAL *key, void (*cleanup)(void *)); ++void *CRYPTO_THREAD_get_local(CRYPTO_THREAD_LOCAL *key); ++int CRYPTO_THREAD_set_local(CRYPTO_THREAD_LOCAL *key, void *val); ++int CRYPTO_THREAD_cleanup_local(CRYPTO_THREAD_LOCAL *key); ++ ++CRYPTO_THREAD_ID CRYPTO_THREAD_get_current_id(void); ++int CRYPTO_THREAD_compare_id(CRYPTO_THREAD_ID a, CRYPTO_THREAD_ID b); ++ ++#ifndef OPENSSL_NO_ALT_MEMORY ++int CRYPTO_set_mem_functions_alt( ++ void *(*m) (size_t, const char *, int), ++ void *(*r) (void *, size_t, const char *, int), ++ void (*f) (void *, const char *, int)); ++ ++void *CRYPTO_malloc_alt(size_t num, const char *file, int line); ++void *CRYPTO_zalloc_alt(size_t num, const char *file, int line); ++void *CRYPTO_realloc_alt(void *addr, size_t num, const char *file, int line); ++void CRYPTO_free_alt(void *ptr, const char *file, int line); ++ ++#define OPENSSL_malloc_alt(num) \ ++ CRYPTO_malloc_alt((num), OPENSSL_FILE, OPENSSL_LINE) ++ ++#define OPENSSL_realloc_alt(num) \ ++ CRYPTO_realloc_alt((num), OPENSSL_FILE, OPENSSL_LINE) ++ ++#define OPENSSL_free_alt(num) \ ++ CRYPTO_free_alt((num), OPENSSL_FILE, OPENSSL_LINE) ++ ++#define OPENSSL_zalloc_alt(num) \ ++ CRYPTO_zalloc_alt(num, OPENSSL_FILE, OPENSSL_LINE) ++ ++#define SSLBUF_malloc(num) OPENSSL_malloc_alt(num) ++#define SSLBUF_free(num) OPENSSL_free_alt(num) ++ ++#else ++ ++#define SSLBUF_malloc(num) OPENSSL_malloc(num) ++#define SSLBUF_free(num) OPENSSL_free(num) ++ ++#endif ++ ++# ifdef __cplusplus ++} ++# endif ++#endif +diff --git a/include/TA/openssl/openssl/cryptoerr.h b/include/TA/openssl/openssl/cryptoerr.h +new file mode 100644 +index 0000000..3db5a4e +--- /dev/null ++++ b/include/TA/openssl/openssl/cryptoerr.h +@@ -0,0 +1,57 @@ ++/* ++ * Generated by util/mkerr.pl DO NOT EDIT ++ * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. ++ * ++ * Licensed under the OpenSSL license (the "License"). You may not use ++ * this file except in compliance with the License. You can obtain a copy ++ * in the file LICENSE in the source distribution or at ++ * https://www.openssl.org/source/license.html ++ */ ++ ++#ifndef HEADER_CRYPTOERR_H ++# define HEADER_CRYPTOERR_H ++ ++# ifndef HEADER_SYMHACKS_H ++# include ++# endif ++ ++# ifdef __cplusplus ++extern "C" ++# endif ++int ERR_load_CRYPTO_strings(void); ++ ++/* ++ * CRYPTO function codes. ++ */ ++# define CRYPTO_F_CMAC_CTX_NEW 120 ++# define CRYPTO_F_CRYPTO_DUP_EX_DATA 110 ++# define CRYPTO_F_CRYPTO_FREE_EX_DATA 111 ++# define CRYPTO_F_CRYPTO_GET_EX_NEW_INDEX 100 ++# define CRYPTO_F_CRYPTO_MEMDUP 115 ++# define CRYPTO_F_CRYPTO_NEW_EX_DATA 112 ++# define CRYPTO_F_CRYPTO_OCB128_COPY_CTX 121 ++# define CRYPTO_F_CRYPTO_OCB128_INIT 122 ++# define CRYPTO_F_CRYPTO_SET_EX_DATA 102 ++# define CRYPTO_F_FIPS_MODE_SET 109 ++# define CRYPTO_F_GET_AND_LOCK 113 ++# define CRYPTO_F_OPENSSL_ATEXIT 114 ++# define CRYPTO_F_OPENSSL_BUF2HEXSTR 117 ++# define CRYPTO_F_OPENSSL_FOPEN 119 ++# define CRYPTO_F_OPENSSL_HEXSTR2BUF 118 ++# define CRYPTO_F_OPENSSL_INIT_CRYPTO 116 ++# define CRYPTO_F_OPENSSL_LH_NEW 126 ++# define CRYPTO_F_OPENSSL_SK_DEEP_COPY 127 ++# define CRYPTO_F_OPENSSL_SK_DUP 128 ++# define CRYPTO_F_PKEY_HMAC_INIT 123 ++# define CRYPTO_F_PKEY_POLY1305_INIT 124 ++# define CRYPTO_F_PKEY_SIPHASH_INIT 125 ++# define CRYPTO_F_SK_RESERVE 129 ++ ++/* ++ * CRYPTO reason codes. ++ */ ++# define CRYPTO_R_FIPS_MODE_NOT_SUPPORTED 101 ++# define CRYPTO_R_ILLEGAL_HEX_DIGIT 102 ++# define CRYPTO_R_ODD_NUMBER_OF_DIGITS 103 ++ ++#endif +diff --git a/include/TA/openssl/openssl/dh.h b/include/TA/openssl/openssl/dh.h +new file mode 100644 +index 0000000..352b37a +--- /dev/null ++++ b/include/TA/openssl/openssl/dh.h +@@ -0,0 +1,342 @@ ++/* ++ * Copyright 1995-2018 The OpenSSL Project Authors. All Rights Reserved. ++ * ++ * Licensed under the OpenSSL license (the "License"). You may not use ++ * this file except in compliance with the License. You can obtain a copy ++ * in the file LICENSE in the source distribution or at ++ * https://www.openssl.org/source/license.html ++ */ ++ ++#ifndef HEADER_DH_H ++# define HEADER_DH_H ++ ++# include ++ ++# ifndef OPENSSL_NO_DH ++# include ++# include ++# include ++# include ++# if OPENSSL_API_COMPAT < 0x10100000L ++# include ++# endif ++# include ++ ++# ifdef __cplusplus ++extern "C" { ++# endif ++ ++# ifndef OPENSSL_DH_MAX_MODULUS_BITS ++# define OPENSSL_DH_MAX_MODULUS_BITS 10000 ++# endif ++ ++# ifndef OPENSSL_NO_FIPS ++ # define OPENSSL_DH_FIPS_MIN_MODULUS_BITS 2048 ++#else ++ # define OPENSSL_DH_FIPS_MIN_MODULUS_BITS 1024 ++#endif ++ ++# define DH_FLAG_CACHE_MONT_P 0x01 ++ ++# if OPENSSL_API_COMPAT < 0x10100000L ++/* ++ * Does nothing. Previously this switched off constant time behaviour. ++ */ ++# define DH_FLAG_NO_EXP_CONSTTIME 0x00 ++# endif ++ ++/* ++ * If this flag is set the DH method is FIPS compliant and can be used in ++ * FIPS mode. This is set in the validated module method. If an application ++ * sets this flag in its own methods it is its responsibility to ensure the ++ * result is compliant. ++ */ ++ ++# define DH_FLAG_FIPS_METHOD 0x0400 ++ ++/* ++ * If this flag is set the operations normally disabled in FIPS mode are ++ * permitted it is then the applications responsibility to ensure that the ++ * usage is compliant. ++ */ ++ ++# define DH_FLAG_NON_FIPS_ALLOW 0x0400 ++ ++/* Already defined in ossl_typ.h */ ++/* typedef struct dh_st DH; */ ++/* typedef struct dh_method DH_METHOD; */ ++ ++DECLARE_ASN1_ITEM(DHparams) ++ ++# define DH_GENERATOR_2 2 ++/* #define DH_GENERATOR_3 3 */ ++# define DH_GENERATOR_5 5 ++ ++/* DH_check error codes */ ++# define DH_CHECK_P_NOT_PRIME 0x01 ++# define DH_CHECK_P_NOT_SAFE_PRIME 0x02 ++# define DH_UNABLE_TO_CHECK_GENERATOR 0x04 ++# define DH_NOT_SUITABLE_GENERATOR 0x08 ++# define DH_CHECK_Q_NOT_PRIME 0x10 ++# define DH_CHECK_INVALID_Q_VALUE 0x20 ++# define DH_CHECK_INVALID_J_VALUE 0x40 ++ ++/* DH_check_pub_key error codes */ ++# define DH_CHECK_PUBKEY_TOO_SMALL 0x01 ++# define DH_CHECK_PUBKEY_TOO_LARGE 0x02 ++# define DH_CHECK_PUBKEY_INVALID 0x04 ++ ++/* ++ * primes p where (p-1)/2 is prime too are called "safe"; we define this for ++ * backward compatibility: ++ */ ++# define DH_CHECK_P_NOT_STRONG_PRIME DH_CHECK_P_NOT_SAFE_PRIME ++ ++# define d2i_DHparams_fp(fp,x) \ ++ (DH *)ASN1_d2i_fp((char *(*)())DH_new, \ ++ (char *(*)())d2i_DHparams, \ ++ (fp), \ ++ (unsigned char **)(x)) ++# define i2d_DHparams_fp(fp,x) \ ++ ASN1_i2d_fp(i2d_DHparams,(fp), (unsigned char *)(x)) ++# define d2i_DHparams_bio(bp,x) \ ++ ASN1_d2i_bio_of(DH, DH_new, d2i_DHparams, bp, x) ++# define i2d_DHparams_bio(bp,x) \ ++ ASN1_i2d_bio_of_const(DH,i2d_DHparams,bp,x) ++ ++# define d2i_DHxparams_fp(fp,x) \ ++ (DH *)ASN1_d2i_fp((char *(*)())DH_new, \ ++ (char *(*)())d2i_DHxparams, \ ++ (fp), \ ++ (unsigned char **)(x)) ++# define i2d_DHxparams_fp(fp,x) \ ++ ASN1_i2d_fp(i2d_DHxparams,(fp), (unsigned char *)(x)) ++# define d2i_DHxparams_bio(bp,x) \ ++ ASN1_d2i_bio_of(DH, DH_new, d2i_DHxparams, bp, x) ++# define i2d_DHxparams_bio(bp,x) \ ++ ASN1_i2d_bio_of_const(DH, i2d_DHxparams, bp, x) ++ ++DH *DHparams_dup(DH *); ++ ++const DH_METHOD *DH_OpenSSL(void); ++ ++void DH_set_default_method(const DH_METHOD *meth); ++const DH_METHOD *DH_get_default_method(void); ++int DH_set_method(DH *dh, const DH_METHOD *meth); ++DH *DH_new_method(ENGINE *engine); ++ ++DH *DH_new(void); ++void DH_free(DH *dh); ++int DH_up_ref(DH *dh); ++int DH_bits(const DH *dh); ++int DH_size(const DH *dh); ++int DH_security_bits(const DH *dh); ++#define DH_get_ex_new_index(l, p, newf, dupf, freef) \ ++ CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_DH, l, p, newf, dupf, freef) ++int DH_set_ex_data(DH *d, int idx, void *arg); ++void *DH_get_ex_data(DH *d, int idx); ++ ++/* Deprecated version */ ++DEPRECATEDIN_0_9_8(DH *DH_generate_parameters(int prime_len, int generator, ++ void (*callback) (int, int, ++ void *), ++ void *cb_arg)) ++ ++/* New version */ ++int DH_generate_parameters_ex(DH *dh, int prime_len, int generator, ++ BN_GENCB *cb); ++ ++int DH_check_params_ex(const DH *dh); ++int DH_check_ex(const DH *dh); ++int DH_check_pub_key_ex(const DH *dh, const BIGNUM *pub_key); ++int DH_check_params(const DH *dh, int *ret); ++int DH_check(const DH *dh, int *codes); ++int DH_check_pub_key(const DH *dh, const BIGNUM *pub_key, int *codes); ++int DH_generate_key(DH *dh); ++int DH_compute_key(unsigned char *key, const BIGNUM *pub_key, DH *dh); ++int DH_compute_key_padded(unsigned char *key, const BIGNUM *pub_key, DH *dh); ++DH *d2i_DHparams(DH **a, const unsigned char **pp, long length); ++int i2d_DHparams(const DH *a, unsigned char **pp); ++DH *d2i_DHxparams(DH **a, const unsigned char **pp, long length); ++int i2d_DHxparams(const DH *a, unsigned char **pp); ++# ifndef OPENSSL_NO_STDIO ++int DHparams_print_fp(FILE *fp, const DH *x); ++# endif ++int DHparams_print(BIO *bp, const DH *x); ++ ++/* RFC 5114 parameters */ ++DH *DH_get_1024_160(void); ++DH *DH_get_2048_224(void); ++DH *DH_get_2048_256(void); ++ ++/* Named parameters, currently RFC7919 */ ++DH *DH_new_by_nid(int nid); ++int DH_get_nid(const DH *dh); ++ ++# ifndef OPENSSL_NO_CMS ++/* RFC2631 KDF */ ++int DH_KDF_X9_42(unsigned char *out, size_t outlen, ++ const unsigned char *Z, size_t Zlen, ++ ASN1_OBJECT *key_oid, ++ const unsigned char *ukm, size_t ukmlen, const EVP_MD *md); ++# endif ++ ++void DH_get0_pqg(const DH *dh, ++ const BIGNUM **p, const BIGNUM **q, const BIGNUM **g); ++int DH_set0_pqg(DH *dh, BIGNUM *p, BIGNUM *q, BIGNUM *g); ++void DH_get0_key(const DH *dh, ++ const BIGNUM **pub_key, const BIGNUM **priv_key); ++int DH_set0_key(DH *dh, BIGNUM *pub_key, BIGNUM *priv_key); ++const BIGNUM *DH_get0_p(const DH *dh); ++const BIGNUM *DH_get0_q(const DH *dh); ++const BIGNUM *DH_get0_g(const DH *dh); ++const BIGNUM *DH_get0_priv_key(const DH *dh); ++const BIGNUM *DH_get0_pub_key(const DH *dh); ++void DH_clear_flags(DH *dh, int flags); ++int DH_test_flags(const DH *dh, int flags); ++void DH_set_flags(DH *dh, int flags); ++ENGINE *DH_get0_engine(DH *d); ++long DH_get_length(const DH *dh); ++int DH_set_length(DH *dh, long length); ++ ++DH_METHOD *DH_meth_new(const char *name, int flags); ++void DH_meth_free(DH_METHOD *dhm); ++DH_METHOD *DH_meth_dup(const DH_METHOD *dhm); ++const char *DH_meth_get0_name(const DH_METHOD *dhm); ++int DH_meth_set1_name(DH_METHOD *dhm, const char *name); ++int DH_meth_get_flags(const DH_METHOD *dhm); ++int DH_meth_set_flags(DH_METHOD *dhm, int flags); ++void *DH_meth_get0_app_data(const DH_METHOD *dhm); ++int DH_meth_set0_app_data(DH_METHOD *dhm, void *app_data); ++int (*DH_meth_get_generate_key(const DH_METHOD *dhm)) (DH *); ++int DH_meth_set_generate_key(DH_METHOD *dhm, int (*generate_key) (DH *)); ++int (*DH_meth_get_compute_key(const DH_METHOD *dhm)) ++ (unsigned char *key, const BIGNUM *pub_key, DH *dh); ++int DH_meth_set_compute_key(DH_METHOD *dhm, ++ int (*compute_key) (unsigned char *key, const BIGNUM *pub_key, DH *dh)); ++int (*DH_meth_get_bn_mod_exp(const DH_METHOD *dhm)) ++ (const DH *, BIGNUM *, const BIGNUM *, const BIGNUM *, const BIGNUM *, ++ BN_CTX *, BN_MONT_CTX *); ++int DH_meth_set_bn_mod_exp(DH_METHOD *dhm, ++ int (*bn_mod_exp) (const DH *, BIGNUM *, const BIGNUM *, const BIGNUM *, ++ const BIGNUM *, BN_CTX *, BN_MONT_CTX *)); ++int (*DH_meth_get_init(const DH_METHOD *dhm))(DH *); ++int DH_meth_set_init(DH_METHOD *dhm, int (*init)(DH *)); ++int (*DH_meth_get_finish(const DH_METHOD *dhm)) (DH *); ++int DH_meth_set_finish(DH_METHOD *dhm, int (*finish) (DH *)); ++int (*DH_meth_get_generate_params(const DH_METHOD *dhm)) ++ (DH *, int, int, BN_GENCB *); ++int DH_meth_set_generate_params(DH_METHOD *dhm, ++ int (*generate_params) (DH *, int, int, BN_GENCB *)); ++ ++# define EVP_PKEY_CTX_set_dh_paramgen_prime_len(ctx, len) \ ++ EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DH, EVP_PKEY_OP_PARAMGEN, \ ++ EVP_PKEY_CTRL_DH_PARAMGEN_PRIME_LEN, len, NULL) ++ ++# define EVP_PKEY_CTX_set_dh_paramgen_subprime_len(ctx, len) \ ++ EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DH, EVP_PKEY_OP_PARAMGEN, \ ++ EVP_PKEY_CTRL_DH_PARAMGEN_SUBPRIME_LEN, len, NULL) ++ ++# define EVP_PKEY_CTX_set_dh_paramgen_type(ctx, typ) \ ++ EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DH, EVP_PKEY_OP_PARAMGEN, \ ++ EVP_PKEY_CTRL_DH_PARAMGEN_TYPE, typ, NULL) ++ ++# define EVP_PKEY_CTX_set_dh_paramgen_generator(ctx, gen) \ ++ EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DH, EVP_PKEY_OP_PARAMGEN, \ ++ EVP_PKEY_CTRL_DH_PARAMGEN_GENERATOR, gen, NULL) ++ ++# define EVP_PKEY_CTX_set_dh_rfc5114(ctx, gen) \ ++ EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DHX, EVP_PKEY_OP_PARAMGEN, \ ++ EVP_PKEY_CTRL_DH_RFC5114, gen, NULL) ++ ++# define EVP_PKEY_CTX_set_dhx_rfc5114(ctx, gen) \ ++ EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DHX, EVP_PKEY_OP_PARAMGEN, \ ++ EVP_PKEY_CTRL_DH_RFC5114, gen, NULL) ++ ++# define EVP_PKEY_CTX_set_dh_nid(ctx, nid) \ ++ EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DH, \ ++ EVP_PKEY_OP_PARAMGEN | EVP_PKEY_OP_KEYGEN, \ ++ EVP_PKEY_CTRL_DH_NID, nid, NULL) ++ ++# define EVP_PKEY_CTX_set_dh_pad(ctx, pad) \ ++ EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DH, EVP_PKEY_OP_DERIVE, \ ++ EVP_PKEY_CTRL_DH_PAD, pad, NULL) ++ ++# define EVP_PKEY_CTX_set_dh_kdf_type(ctx, kdf) \ ++ EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DHX, \ ++ EVP_PKEY_OP_DERIVE, \ ++ EVP_PKEY_CTRL_DH_KDF_TYPE, kdf, NULL) ++ ++# define EVP_PKEY_CTX_get_dh_kdf_type(ctx) \ ++ EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DHX, \ ++ EVP_PKEY_OP_DERIVE, \ ++ EVP_PKEY_CTRL_DH_KDF_TYPE, -2, NULL) ++ ++# define EVP_PKEY_CTX_set0_dh_kdf_oid(ctx, oid) \ ++ EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DHX, \ ++ EVP_PKEY_OP_DERIVE, \ ++ EVP_PKEY_CTRL_DH_KDF_OID, 0, (void *)(oid)) ++ ++# define EVP_PKEY_CTX_get0_dh_kdf_oid(ctx, poid) \ ++ EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DHX, \ ++ EVP_PKEY_OP_DERIVE, \ ++ EVP_PKEY_CTRL_GET_DH_KDF_OID, 0, (void *)(poid)) ++ ++# define EVP_PKEY_CTX_set_dh_kdf_md(ctx, md) \ ++ EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DHX, \ ++ EVP_PKEY_OP_DERIVE, \ ++ EVP_PKEY_CTRL_DH_KDF_MD, 0, (void *)(md)) ++ ++# define EVP_PKEY_CTX_get_dh_kdf_md(ctx, pmd) \ ++ EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DHX, \ ++ EVP_PKEY_OP_DERIVE, \ ++ EVP_PKEY_CTRL_GET_DH_KDF_MD, 0, (void *)(pmd)) ++ ++# define EVP_PKEY_CTX_set_dh_kdf_outlen(ctx, len) \ ++ EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DHX, \ ++ EVP_PKEY_OP_DERIVE, \ ++ EVP_PKEY_CTRL_DH_KDF_OUTLEN, len, NULL) ++ ++# define EVP_PKEY_CTX_get_dh_kdf_outlen(ctx, plen) \ ++ EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DHX, \ ++ EVP_PKEY_OP_DERIVE, \ ++ EVP_PKEY_CTRL_GET_DH_KDF_OUTLEN, 0, (void *)(plen)) ++ ++# define EVP_PKEY_CTX_set0_dh_kdf_ukm(ctx, p, plen) \ ++ EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DHX, \ ++ EVP_PKEY_OP_DERIVE, \ ++ EVP_PKEY_CTRL_DH_KDF_UKM, plen, (void *)(p)) ++ ++# define EVP_PKEY_CTX_get0_dh_kdf_ukm(ctx, p) \ ++ EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DHX, \ ++ EVP_PKEY_OP_DERIVE, \ ++ EVP_PKEY_CTRL_GET_DH_KDF_UKM, 0, (void *)(p)) ++ ++# define EVP_PKEY_CTRL_DH_PARAMGEN_PRIME_LEN (EVP_PKEY_ALG_CTRL + 1) ++# define EVP_PKEY_CTRL_DH_PARAMGEN_GENERATOR (EVP_PKEY_ALG_CTRL + 2) ++# define EVP_PKEY_CTRL_DH_RFC5114 (EVP_PKEY_ALG_CTRL + 3) ++# define EVP_PKEY_CTRL_DH_PARAMGEN_SUBPRIME_LEN (EVP_PKEY_ALG_CTRL + 4) ++# define EVP_PKEY_CTRL_DH_PARAMGEN_TYPE (EVP_PKEY_ALG_CTRL + 5) ++# define EVP_PKEY_CTRL_DH_KDF_TYPE (EVP_PKEY_ALG_CTRL + 6) ++# define EVP_PKEY_CTRL_DH_KDF_MD (EVP_PKEY_ALG_CTRL + 7) ++# define EVP_PKEY_CTRL_GET_DH_KDF_MD (EVP_PKEY_ALG_CTRL + 8) ++# define EVP_PKEY_CTRL_DH_KDF_OUTLEN (EVP_PKEY_ALG_CTRL + 9) ++# define EVP_PKEY_CTRL_GET_DH_KDF_OUTLEN (EVP_PKEY_ALG_CTRL + 10) ++# define EVP_PKEY_CTRL_DH_KDF_UKM (EVP_PKEY_ALG_CTRL + 11) ++# define EVP_PKEY_CTRL_GET_DH_KDF_UKM (EVP_PKEY_ALG_CTRL + 12) ++# define EVP_PKEY_CTRL_DH_KDF_OID (EVP_PKEY_ALG_CTRL + 13) ++# define EVP_PKEY_CTRL_GET_DH_KDF_OID (EVP_PKEY_ALG_CTRL + 14) ++# define EVP_PKEY_CTRL_DH_NID (EVP_PKEY_ALG_CTRL + 15) ++# define EVP_PKEY_CTRL_DH_PAD (EVP_PKEY_ALG_CTRL + 16) ++ ++/* KDF types */ ++# define EVP_PKEY_DH_KDF_NONE 1 ++# ifndef OPENSSL_NO_CMS ++# define EVP_PKEY_DH_KDF_X9_42 2 ++# endif ++ ++# ifdef __cplusplus ++} ++# endif ++# endif ++#endif +diff --git a/include/TA/openssl/openssl/dsa.h b/include/TA/openssl/openssl/dsa.h +new file mode 100644 +index 0000000..741fd4f +--- /dev/null ++++ b/include/TA/openssl/openssl/dsa.h +@@ -0,0 +1,248 @@ ++/* ++ * Copyright 1995-2018 The OpenSSL Project Authors. All Rights Reserved. ++ * ++ * Licensed under the OpenSSL license (the "License"). You may not use ++ * this file except in compliance with the License. You can obtain a copy ++ * in the file LICENSE in the source distribution or at ++ * https://www.openssl.org/source/license.html ++ */ ++ ++#ifndef HEADER_DSA_H ++# define HEADER_DSA_H ++ ++# include ++ ++# ifndef OPENSSL_NO_DSA ++# ifdef __cplusplus ++extern "C" { ++# endif ++# include ++# include ++# include ++# include ++# include ++# if OPENSSL_API_COMPAT < 0x10100000L ++# include ++# endif ++# include ++ ++# ifndef OPENSSL_DSA_MAX_MODULUS_BITS ++# define OPENSSL_DSA_MAX_MODULUS_BITS 10000 ++# endif ++ ++#ifndef OPENSSL_NO_FIPS ++# define OPENSSL_DSA_FIPS_MIN_MODULUS_BITS 2048 ++# define OPENSSL_DSA_FIPS_MIN_MODULUS_BITS_verify 512 ++#else ++# define OPENSSL_DSA_FIPS_MIN_MODULUS_BITS 1024 ++#endif ++ ++# define DSA_FLAG_CACHE_MONT_P 0x01 ++# if OPENSSL_API_COMPAT < 0x10100000L ++/* ++ * Does nothing. Previously this switched off constant time behaviour. ++ */ ++# define DSA_FLAG_NO_EXP_CONSTTIME 0x00 ++# endif ++ ++/* ++ * If this flag is set the DSA method is FIPS compliant and can be used in ++ * FIPS mode. This is set in the validated module method. If an application ++ * sets this flag in its own methods it is its responsibility to ensure the ++ * result is compliant. ++ */ ++ ++# define DSA_FLAG_FIPS_METHOD 0x0400 ++ ++/* ++ * If this flag is set the operations normally disabled in FIPS mode are ++ * permitted it is then the applications responsibility to ensure that the ++ * usage is compliant. ++ */ ++ ++# define DSA_FLAG_NON_FIPS_ALLOW 0x0400 ++# define DSA_FLAG_FIPS_CHECKED 0x0800 ++ ++/* Already defined in ossl_typ.h */ ++/* typedef struct dsa_st DSA; */ ++/* typedef struct dsa_method DSA_METHOD; */ ++ ++typedef struct DSA_SIG_st DSA_SIG; ++ ++# define d2i_DSAparams_fp(fp,x) (DSA *)ASN1_d2i_fp((char *(*)())DSA_new, \ ++ (char *(*)())d2i_DSAparams,(fp),(unsigned char **)(x)) ++# define i2d_DSAparams_fp(fp,x) ASN1_i2d_fp(i2d_DSAparams,(fp), \ ++ (unsigned char *)(x)) ++# define d2i_DSAparams_bio(bp,x) ASN1_d2i_bio_of(DSA,DSA_new,d2i_DSAparams,bp,x) ++# define i2d_DSAparams_bio(bp,x) ASN1_i2d_bio_of_const(DSA,i2d_DSAparams,bp,x) ++ ++DSA *DSAparams_dup(DSA *x); ++DSA_SIG *DSA_SIG_new(void); ++void DSA_SIG_free(DSA_SIG *a); ++int i2d_DSA_SIG(const DSA_SIG *a, unsigned char **pp); ++DSA_SIG *d2i_DSA_SIG(DSA_SIG **v, const unsigned char **pp, long length); ++void DSA_SIG_get0(const DSA_SIG *sig, const BIGNUM **pr, const BIGNUM **ps); ++int DSA_SIG_set0(DSA_SIG *sig, BIGNUM *r, BIGNUM *s); ++ ++DSA_SIG *DSA_do_sign(const unsigned char *dgst, int dlen, DSA *dsa); ++int DSA_do_verify(const unsigned char *dgst, int dgst_len, ++ DSA_SIG *sig, DSA *dsa); ++ ++const DSA_METHOD *DSA_OpenSSL(void); ++ ++void DSA_set_default_method(const DSA_METHOD *); ++const DSA_METHOD *DSA_get_default_method(void); ++int DSA_set_method(DSA *dsa, const DSA_METHOD *); ++const DSA_METHOD *DSA_get_method(DSA *d); ++ ++DSA *DSA_new(void); ++DSA *DSA_new_method(ENGINE *engine); ++void DSA_free(DSA *r); ++/* "up" the DSA object's reference count */ ++int DSA_up_ref(DSA *r); ++int DSA_size(const DSA *); ++int DSA_bits(const DSA *d); ++int DSA_security_bits(const DSA *d); ++ /* next 4 return -1 on error */ ++DEPRECATEDIN_1_2_0(int DSA_sign_setup(DSA *dsa, BN_CTX *ctx_in, BIGNUM **kinvp, BIGNUM **rp)) ++int DSA_sign(int type, const unsigned char *dgst, int dlen, ++ unsigned char *sig, unsigned int *siglen, DSA *dsa); ++int DSA_verify(int type, const unsigned char *dgst, int dgst_len, ++ const unsigned char *sigbuf, int siglen, DSA *dsa); ++#define DSA_get_ex_new_index(l, p, newf, dupf, freef) \ ++ CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_DSA, l, p, newf, dupf, freef) ++int DSA_set_ex_data(DSA *d, int idx, void *arg); ++void *DSA_get_ex_data(DSA *d, int idx); ++ ++DSA *d2i_DSAPublicKey(DSA **a, const unsigned char **pp, long length); ++DSA *d2i_DSAPrivateKey(DSA **a, const unsigned char **pp, long length); ++DSA *d2i_DSAparams(DSA **a, const unsigned char **pp, long length); ++ ++/* Deprecated version */ ++DEPRECATEDIN_0_9_8(DSA *DSA_generate_parameters(int bits, ++ unsigned char *seed, ++ int seed_len, ++ int *counter_ret, ++ unsigned long *h_ret, void ++ (*callback) (int, int, ++ void *), ++ void *cb_arg)) ++ ++/* New version */ ++int DSA_generate_parameters_ex(DSA *dsa, int bits, ++ const unsigned char *seed, int seed_len, ++ int *counter_ret, unsigned long *h_ret, ++ BN_GENCB *cb); ++ ++int DSA_generate_key(DSA *a); ++int i2d_DSAPublicKey(const DSA *a, unsigned char **pp); ++int i2d_DSAPrivateKey(const DSA *a, unsigned char **pp); ++int i2d_DSAparams(const DSA *a, unsigned char **pp); ++ ++int DSAparams_print(BIO *bp, const DSA *x); ++int DSA_print(BIO *bp, const DSA *x, int off); ++# ifndef OPENSSL_NO_STDIO ++int DSAparams_print_fp(FILE *fp, const DSA *x); ++int DSA_print_fp(FILE *bp, const DSA *x, int off); ++# endif ++ ++# define DSS_prime_checks 64 ++/* ++ * Primality test according to FIPS PUB 186-4, Appendix C.3. Since we only ++ * have one value here we set the number of checks to 64 which is the 128 bit ++ * security level that is the highest level and valid for creating a 3072 bit ++ * DSA key. ++ */ ++# define DSA_is_prime(n, callback, cb_arg) \ ++ BN_is_prime(n, DSS_prime_checks, callback, NULL, cb_arg) ++ ++# ifndef OPENSSL_NO_DH ++/* ++ * Convert DSA structure (key or just parameters) into DH structure (be ++ * careful to avoid small subgroup attacks when using this!) ++ */ ++DH *DSA_dup_DH(const DSA *r); ++# endif ++ ++# define EVP_PKEY_CTX_set_dsa_paramgen_bits(ctx, nbits) \ ++ EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DSA, EVP_PKEY_OP_PARAMGEN, \ ++ EVP_PKEY_CTRL_DSA_PARAMGEN_BITS, nbits, NULL) ++# define EVP_PKEY_CTX_set_dsa_paramgen_q_bits(ctx, qbits) \ ++ EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DSA, EVP_PKEY_OP_PARAMGEN, \ ++ EVP_PKEY_CTRL_DSA_PARAMGEN_Q_BITS, qbits, NULL) ++# define EVP_PKEY_CTX_set_dsa_paramgen_md(ctx, md) \ ++ EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DSA, EVP_PKEY_OP_PARAMGEN, \ ++ EVP_PKEY_CTRL_DSA_PARAMGEN_MD, 0, (void *)(md)) ++ ++# define EVP_PKEY_CTRL_DSA_PARAMGEN_BITS (EVP_PKEY_ALG_CTRL + 1) ++# define EVP_PKEY_CTRL_DSA_PARAMGEN_Q_BITS (EVP_PKEY_ALG_CTRL + 2) ++# define EVP_PKEY_CTRL_DSA_PARAMGEN_MD (EVP_PKEY_ALG_CTRL + 3) ++ ++void DSA_get0_pqg(const DSA *d, ++ const BIGNUM **p, const BIGNUM **q, const BIGNUM **g); ++int DSA_set0_pqg(DSA *d, BIGNUM *p, BIGNUM *q, BIGNUM *g); ++void DSA_get0_key(const DSA *d, ++ const BIGNUM **pub_key, const BIGNUM **priv_key); ++int DSA_set0_key(DSA *d, BIGNUM *pub_key, BIGNUM *priv_key); ++const BIGNUM *DSA_get0_p(const DSA *d); ++const BIGNUM *DSA_get0_q(const DSA *d); ++const BIGNUM *DSA_get0_g(const DSA *d); ++const BIGNUM *DSA_get0_pub_key(const DSA *d); ++const BIGNUM *DSA_get0_priv_key(const DSA *d); ++void DSA_clear_flags(DSA *d, int flags); ++int DSA_test_flags(const DSA *d, int flags); ++void DSA_set_flags(DSA *d, int flags); ++ENGINE *DSA_get0_engine(DSA *d); ++ ++DSA_METHOD *DSA_meth_new(const char *name, int flags); ++void DSA_meth_free(DSA_METHOD *dsam); ++DSA_METHOD *DSA_meth_dup(const DSA_METHOD *dsam); ++const char *DSA_meth_get0_name(const DSA_METHOD *dsam); ++int DSA_meth_set1_name(DSA_METHOD *dsam, const char *name); ++int DSA_meth_get_flags(const DSA_METHOD *dsam); ++int DSA_meth_set_flags(DSA_METHOD *dsam, int flags); ++void *DSA_meth_get0_app_data(const DSA_METHOD *dsam); ++int DSA_meth_set0_app_data(DSA_METHOD *dsam, void *app_data); ++DSA_SIG *(*DSA_meth_get_sign(const DSA_METHOD *dsam)) ++ (const unsigned char *, int, DSA *); ++int DSA_meth_set_sign(DSA_METHOD *dsam, ++ DSA_SIG *(*sign) (const unsigned char *, int, DSA *)); ++int (*DSA_meth_get_sign_setup(const DSA_METHOD *dsam)) ++ (DSA *, BN_CTX *, BIGNUM **, BIGNUM **); ++int DSA_meth_set_sign_setup(DSA_METHOD *dsam, ++ int (*sign_setup) (DSA *, BN_CTX *, BIGNUM **, BIGNUM **)); ++int (*DSA_meth_get_verify(const DSA_METHOD *dsam)) ++ (const unsigned char *, int, DSA_SIG *, DSA *); ++int DSA_meth_set_verify(DSA_METHOD *dsam, ++ int (*verify) (const unsigned char *, int, DSA_SIG *, DSA *)); ++int (*DSA_meth_get_mod_exp(const DSA_METHOD *dsam)) ++ (DSA *, BIGNUM *, const BIGNUM *, const BIGNUM *, const BIGNUM *, ++ const BIGNUM *, const BIGNUM *, BN_CTX *, BN_MONT_CTX *); ++int DSA_meth_set_mod_exp(DSA_METHOD *dsam, ++ int (*mod_exp) (DSA *, BIGNUM *, const BIGNUM *, const BIGNUM *, ++ const BIGNUM *, const BIGNUM *, const BIGNUM *, BN_CTX *, ++ BN_MONT_CTX *)); ++int (*DSA_meth_get_bn_mod_exp(const DSA_METHOD *dsam)) ++ (DSA *, BIGNUM *, const BIGNUM *, const BIGNUM *, const BIGNUM *, ++ BN_CTX *, BN_MONT_CTX *); ++int DSA_meth_set_bn_mod_exp(DSA_METHOD *dsam, ++ int (*bn_mod_exp) (DSA *, BIGNUM *, const BIGNUM *, const BIGNUM *, ++ const BIGNUM *, BN_CTX *, BN_MONT_CTX *)); ++int (*DSA_meth_get_init(const DSA_METHOD *dsam))(DSA *); ++int DSA_meth_set_init(DSA_METHOD *dsam, int (*init)(DSA *)); ++int (*DSA_meth_get_finish(const DSA_METHOD *dsam)) (DSA *); ++int DSA_meth_set_finish(DSA_METHOD *dsam, int (*finish) (DSA *)); ++int (*DSA_meth_get_paramgen(const DSA_METHOD *dsam)) ++ (DSA *, int, const unsigned char *, int, int *, unsigned long *, ++ BN_GENCB *); ++int DSA_meth_set_paramgen(DSA_METHOD *dsam, ++ int (*paramgen) (DSA *, int, const unsigned char *, int, int *, ++ unsigned long *, BN_GENCB *)); ++int (*DSA_meth_get_keygen(const DSA_METHOD *dsam)) (DSA *); ++int DSA_meth_set_keygen(DSA_METHOD *dsam, int (*keygen) (DSA *)); ++ ++# ifdef __cplusplus ++} ++# endif ++# endif ++#endif +diff --git a/include/TA/openssl/openssl/e_os2.h b/include/TA/openssl/openssl/e_os2.h +new file mode 100644 +index 0000000..86c201e +--- /dev/null ++++ b/include/TA/openssl/openssl/e_os2.h +@@ -0,0 +1,307 @@ ++/* ++ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved. ++ * ++ * Licensed under the OpenSSL license (the "License"). You may not use ++ * this file except in compliance with the License. You can obtain a copy ++ * in the file LICENSE in the source distribution or at ++ * https://www.openssl.org/source/license.html ++ */ ++ ++#ifndef HEADER_E_OS2_H ++# define HEADER_E_OS2_H ++ ++# include ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++/****************************************************************************** ++ * Detect operating systems. This probably needs completing. ++ * The result is that at least one OPENSSL_SYS_os macro should be defined. ++ * However, if none is defined, Unix is assumed. ++ **/ ++ ++# define OPENSSL_SYS_UNIX ++ ++/* --------------------- Microsoft operating systems ---------------------- */ ++ ++/* ++ * Note that MSDOS actually denotes 32-bit environments running on top of ++ * MS-DOS, such as DJGPP one. ++ */ ++# if defined(OPENSSL_SYS_MSDOS) ++# undef OPENSSL_SYS_UNIX ++# endif ++ ++/* ++ * For 32 bit environment, there seems to be the CygWin environment and then ++ * all the others that try to do the same thing Microsoft does... ++ */ ++/* ++ * UEFI lives here because it might be built with a Microsoft toolchain and ++ * we need to avoid the false positive match on Windows. ++ */ ++# if defined(OPENSSL_SYS_UEFI) || defined(__UBOOT__) ++# undef OPENSSL_SYS_UNIX ++# elif defined(OPENSSL_SYS_UWIN) ++# undef OPENSSL_SYS_UNIX ++# define OPENSSL_SYS_WIN32_UWIN ++# else ++# if defined(__CYGWIN__) || defined(OPENSSL_SYS_CYGWIN) ++# define OPENSSL_SYS_WIN32_CYGWIN ++# else ++# if defined(_WIN32) || defined(OPENSSL_SYS_WIN32) ++# undef OPENSSL_SYS_UNIX ++# if !defined(OPENSSL_SYS_WIN32) ++# define OPENSSL_SYS_WIN32 ++# endif ++# endif ++# if defined(_WIN64) || defined(OPENSSL_SYS_WIN64) ++# undef OPENSSL_SYS_UNIX ++# if !defined(OPENSSL_SYS_WIN64) ++# define OPENSSL_SYS_WIN64 ++# endif ++# endif ++# if defined(OPENSSL_SYS_WINNT) ++# undef OPENSSL_SYS_UNIX ++# endif ++# if defined(OPENSSL_SYS_WINCE) ++# undef OPENSSL_SYS_UNIX ++# endif ++# endif ++# endif ++ ++/* Anything that tries to look like Microsoft is "Windows" */ ++# if defined(OPENSSL_SYS_WIN32) || defined(OPENSSL_SYS_WIN64) || defined(OPENSSL_SYS_WINNT) || defined(OPENSSL_SYS_WINCE) ++# undef OPENSSL_SYS_UNIX ++# define OPENSSL_SYS_WINDOWS ++# ifndef OPENSSL_SYS_MSDOS ++# define OPENSSL_SYS_MSDOS ++# endif ++# endif ++ ++/* ++ * DLL settings. This part is a bit tough, because it's up to the ++ * application implementor how he or she will link the application, so it ++ * requires some macro to be used. ++ */ ++# ifdef OPENSSL_SYS_WINDOWS ++# ifndef OPENSSL_OPT_WINDLL ++# if defined(_WINDLL) /* This is used when building OpenSSL to ++ * indicate that DLL linkage should be used */ ++# define OPENSSL_OPT_WINDLL ++# endif ++# endif ++# endif ++ ++/* ------------------------------- OpenVMS -------------------------------- */ ++# if defined(__VMS) || defined(VMS) || defined(OPENSSL_SYS_VMS) ++# if !defined(OPENSSL_SYS_VMS) ++# undef OPENSSL_SYS_UNIX ++# endif ++# define OPENSSL_SYS_VMS ++# if defined(__DECC) ++# define OPENSSL_SYS_VMS_DECC ++# elif defined(__DECCXX) ++# define OPENSSL_SYS_VMS_DECC ++# define OPENSSL_SYS_VMS_DECCXX ++# else ++# define OPENSSL_SYS_VMS_NODECC ++# endif ++# endif ++ ++/* -------------------------------- Unix ---------------------------------- */ ++# ifdef OPENSSL_SYS_UNIX ++# if defined(linux) || defined(__linux__) && !defined(OPENSSL_SYS_LINUX) ++# define OPENSSL_SYS_LINUX ++# endif ++# if defined(_AIX) && !defined(OPENSSL_SYS_AIX) ++# define OPENSSL_SYS_AIX ++# endif ++# endif ++ ++/* -------------------------------- VOS ----------------------------------- */ ++# if defined(__VOS__) && !defined(OPENSSL_SYS_VOS) ++# define OPENSSL_SYS_VOS ++# ifdef __HPPA__ ++# define OPENSSL_SYS_VOS_HPPA ++# endif ++# ifdef __IA32__ ++# define OPENSSL_SYS_VOS_IA32 ++# endif ++# endif ++ ++/** ++ * That's it for OS-specific stuff ++ *****************************************************************************/ ++ ++/* Specials for I/O an exit */ ++# ifdef OPENSSL_SYS_MSDOS ++# define OPENSSL_UNISTD_IO ++# define OPENSSL_DECLARE_EXIT extern void exit(int); ++# else ++# define OPENSSL_UNISTD_IO OPENSSL_UNISTD ++# define OPENSSL_DECLARE_EXIT /* declared in unistd.h */ ++# endif ++ ++/*- ++ * OPENSSL_EXTERN is normally used to declare a symbol with possible extra ++ * attributes to handle its presence in a shared library. ++ * OPENSSL_EXPORT is used to define a symbol with extra possible attributes ++ * to make it visible in a shared library. ++ * Care needs to be taken when a header file is used both to declare and ++ * define symbols. Basically, for any library that exports some global ++ * variables, the following code must be present in the header file that ++ * declares them, before OPENSSL_EXTERN is used: ++ * ++ * #ifdef SOME_BUILD_FLAG_MACRO ++ * # undef OPENSSL_EXTERN ++ * # define OPENSSL_EXTERN OPENSSL_EXPORT ++ * #endif ++ * ++ * The default is to have OPENSSL_EXPORT and OPENSSL_EXTERN ++ * have some generally sensible values. ++ */ ++ ++# if defined(OPENSSL_SYS_WINDOWS) && defined(OPENSSL_OPT_WINDLL) ++# define OPENSSL_EXPORT extern __declspec(dllexport) ++# define OPENSSL_EXTERN extern __declspec(dllimport) ++# else ++# define OPENSSL_EXPORT extern ++# define OPENSSL_EXTERN extern ++# endif ++ ++/*- ++ * Macros to allow global variables to be reached through function calls when ++ * required (if a shared library version requires it, for example. ++ * The way it's done allows definitions like this: ++ * ++ * // in foobar.c ++ * OPENSSL_IMPLEMENT_GLOBAL(int,foobar,0) ++ * // in foobar.h ++ * OPENSSL_DECLARE_GLOBAL(int,foobar); ++ * #define foobar OPENSSL_GLOBAL_REF(foobar) ++ */ ++# ifdef OPENSSL_EXPORT_VAR_AS_FUNCTION ++# define OPENSSL_IMPLEMENT_GLOBAL(type,name,value) \ ++ type *_shadow_##name(void) \ ++ { static type _hide_##name=value; return &_hide_##name; } ++# define OPENSSL_DECLARE_GLOBAL(type,name) type *_shadow_##name(void) ++# define OPENSSL_GLOBAL_REF(name) (*(_shadow_##name())) ++# else ++# define OPENSSL_IMPLEMENT_GLOBAL(type,name,value) type _shadow_##name=value; ++# define OPENSSL_DECLARE_GLOBAL(type,name) OPENSSL_EXPORT type _shadow_##name ++# define OPENSSL_GLOBAL_REF(name) _shadow_##name ++# endif ++ ++# ifdef _WIN32 ++# ifdef _WIN64 ++# define ossl_ssize_t __int64 ++# define OSSL_SSIZE_MAX _I64_MAX ++# else ++# define ossl_ssize_t int ++# define OSSL_SSIZE_MAX INT_MAX ++# endif ++# endif ++ ++# if defined(OPENSSL_SYS_UEFI) && !defined(ossl_ssize_t) ++# define ossl_ssize_t INTN ++# define OSSL_SSIZE_MAX MAX_INTN ++# endif ++ ++# ifndef ossl_ssize_t ++# define ossl_ssize_t ssize_t ++# if defined(SSIZE_MAX) && !defined(OPENSSL_SYS_VXWORKS) ++# define OSSL_SSIZE_MAX SSIZE_MAX ++# elif defined(_POSIX_SSIZE_MAX) ++# define OSSL_SSIZE_MAX _POSIX_SSIZE_MAX ++# else ++# define OSSL_SSIZE_MAX ((ssize_t)(SIZE_MAX>>1)) ++# endif ++# endif ++ ++# ifdef DEBUG_UNUSED ++# define __owur __attribute__((__warn_unused_result__)) ++# else ++# define __owur ++# endif ++ ++/* Standard integer types */ ++# if defined(OPENSSL_SYS_UEFI) ++typedef INT8 int8_t; ++typedef UINT8 uint8_t; ++typedef INT16 int16_t; ++typedef UINT16 uint16_t; ++typedef INT32 int32_t; ++typedef UINT32 uint32_t; ++typedef INT64 int64_t; ++typedef UINT64 uint64_t; ++# elif !defined(OPENSSL_SYS_VXWORKS) && ((defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || \ ++ defined(__osf__) || defined(__sgi) || defined(__hpux) || \ ++ defined(OPENSSL_SYS_VMS) || defined (__OpenBSD__)) ++# include ++# elif defined(_MSC_VER) && _MSC_VER<1600 ++/* ++ * minimally required typdefs for systems not supporting inttypes.h or ++ * stdint.h: currently just older VC++ ++ */ ++typedef signed char int8_t; ++typedef unsigned char uint8_t; ++typedef short int16_t; ++typedef unsigned short uint16_t; ++typedef int int32_t; ++typedef unsigned int uint32_t; ++typedef __int64 int64_t; ++typedef unsigned __int64 uint64_t; ++# elif defined(OPENSSL_SYS_VXWORKS) && !defined(VPP_CRYPTO_COMPILE) ++# define UINT16_MAX 0xffff ++# define INT16_MAX 0x7fff ++# include ++# else ++# ifndef __NO_STDINTH__ ++# include ++# endif ++# endif ++ ++/* ossl_inline: portable inline definition usable in public headers */ ++# if !defined(inline) && !defined(__cplusplus) ++# if defined(__STDC_VERSION__) && __STDC_VERSION__>=199901L ++ /* just use inline */ ++# define ossl_inline inline ++# elif defined(__GNUC__) && __GNUC__>=2 ++# define ossl_inline __inline__ ++# elif defined(_MSC_VER) ++ /* ++ * Visual Studio: inline is available in C++ only, however ++ * __inline is available for C, see ++ * http://msdn.microsoft.com/en-us/library/z8y1yy88.aspx ++ */ ++# define ossl_inline __inline ++# else ++# define ossl_inline ++# endif ++# else ++# define ossl_inline inline ++# endif ++ ++# if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L && \ ++ !defined(__cplusplus) ++# define ossl_noreturn _Noreturn ++# elif defined(__GNUC__) && __GNUC__ >= 2 ++# define ossl_noreturn __attribute__((noreturn)) ++# else ++# define ossl_noreturn ++# endif ++ ++/* ossl_unused: portable unused attribute for use in public headers */ ++# if defined(__GNUC__) ++# define ossl_unused __attribute__((unused)) ++# else ++# define ossl_unused ++# endif ++ ++#ifdef __cplusplus ++} ++#endif ++#endif +diff --git a/include/TA/openssl/openssl/ec.h b/include/TA/openssl/openssl/ec.h +new file mode 100644 +index 0000000..0c830ab +--- /dev/null ++++ b/include/TA/openssl/openssl/ec.h +@@ -0,0 +1,1483 @@ ++/* ++ * Copyright 2002-2021 The OpenSSL Project Authors. All Rights Reserved. ++ * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved ++ * ++ * Licensed under the OpenSSL license (the "License"). You may not use ++ * this file except in compliance with the License. You can obtain a copy ++ * in the file LICENSE in the source distribution or at ++ * https://www.openssl.org/source/license.html ++ */ ++ ++#ifndef HEADER_EC_H ++# define HEADER_EC_H ++ ++# include ++ ++# ifndef OPENSSL_NO_EC ++# include ++# include ++# if OPENSSL_API_COMPAT < 0x10100000L ++# include ++# endif ++# include ++# ifdef __cplusplus ++extern "C" { ++# endif ++ ++# ifndef OPENSSL_ECC_MAX_FIELD_BITS ++# define OPENSSL_ECC_MAX_FIELD_BITS 661 ++# endif ++ ++/** Enum for the point conversion form as defined in X9.62 (ECDSA) ++ * for the encoding of a elliptic curve point (x,y) */ ++typedef enum { ++ /** the point is encoded as z||x, where the octet z specifies ++ * which solution of the quadratic equation y is */ ++ POINT_CONVERSION_COMPRESSED = 2, ++ /** the point is encoded as z||x||y, where z is the octet 0x04 */ ++ POINT_CONVERSION_UNCOMPRESSED = 4, ++ /** the point is encoded as z||x||y, where the octet z specifies ++ * which solution of the quadratic equation y is */ ++ POINT_CONVERSION_HYBRID = 6 ++} point_conversion_form_t; ++ ++typedef struct ec_method_st EC_METHOD; ++typedef struct ec_group_st EC_GROUP; ++typedef struct ec_point_st EC_POINT; ++typedef struct ecpk_parameters_st ECPKPARAMETERS; ++typedef struct ec_parameters_st ECPARAMETERS; ++ ++/********************************************************************/ ++/* EC_METHODs for curves over GF(p) */ ++/********************************************************************/ ++ ++/** Returns the basic GFp ec methods which provides the basis for the ++ * optimized methods. ++ * \return EC_METHOD object ++ */ ++const EC_METHOD *EC_GFp_simple_method(void); ++ ++/** Returns GFp methods using montgomery multiplication. ++ * \return EC_METHOD object ++ */ ++const EC_METHOD *EC_GFp_mont_method(void); ++ ++/** Returns GFp methods using optimized methods for NIST recommended curves ++ * \return EC_METHOD object ++ */ ++const EC_METHOD *EC_GFp_nist_method(void); ++ ++# ifndef OPENSSL_NO_EC_NISTP_64_GCC_128 ++/** Returns 64-bit optimized methods for nistp224 ++ * \return EC_METHOD object ++ */ ++const EC_METHOD *EC_GFp_nistp224_method(void); ++ ++/** Returns 64-bit optimized methods for nistp256 ++ * \return EC_METHOD object ++ */ ++const EC_METHOD *EC_GFp_nistp256_method(void); ++ ++/** Returns 64-bit optimized methods for nistp521 ++ * \return EC_METHOD object ++ */ ++const EC_METHOD *EC_GFp_nistp521_method(void); ++# endif ++ ++# ifndef OPENSSL_NO_EC2M ++/********************************************************************/ ++/* EC_METHOD for curves over GF(2^m) */ ++/********************************************************************/ ++ ++/** Returns the basic GF2m ec method ++ * \return EC_METHOD object ++ */ ++const EC_METHOD *EC_GF2m_simple_method(void); ++ ++# endif ++ ++/********************************************************************/ ++/* EC_GROUP functions */ ++/********************************************************************/ ++ ++/** Creates a new EC_GROUP object ++ * \param meth EC_METHOD to use ++ * \return newly created EC_GROUP object or NULL in case of an error. ++ */ ++EC_GROUP *EC_GROUP_new(const EC_METHOD *meth); ++ ++/** Frees a EC_GROUP object ++ * \param group EC_GROUP object to be freed. ++ */ ++void EC_GROUP_free(EC_GROUP *group); ++ ++/** Clears and frees a EC_GROUP object ++ * \param group EC_GROUP object to be cleared and freed. ++ */ ++void EC_GROUP_clear_free(EC_GROUP *group); ++ ++/** Copies EC_GROUP objects. Note: both EC_GROUPs must use the same EC_METHOD. ++ * \param dst destination EC_GROUP object ++ * \param src source EC_GROUP object ++ * \return 1 on success and 0 if an error occurred. ++ */ ++int EC_GROUP_copy(EC_GROUP *dst, const EC_GROUP *src); ++ ++/** Creates a new EC_GROUP object and copies the copies the content ++ * form src to the newly created EC_KEY object ++ * \param src source EC_GROUP object ++ * \return newly created EC_GROUP object or NULL in case of an error. ++ */ ++EC_GROUP *EC_GROUP_dup(const EC_GROUP *src); ++ ++/** Returns the EC_METHOD of the EC_GROUP object. ++ * \param group EC_GROUP object ++ * \return EC_METHOD used in this EC_GROUP object. ++ */ ++const EC_METHOD *EC_GROUP_method_of(const EC_GROUP *group); ++ ++/** Returns the field type of the EC_METHOD. ++ * \param meth EC_METHOD object ++ * \return NID of the underlying field type OID. ++ */ ++int EC_METHOD_get_field_type(const EC_METHOD *meth); ++ ++/** Sets the generator and its order/cofactor of a EC_GROUP object. ++ * \param group EC_GROUP object ++ * \param generator EC_POINT object with the generator. ++ * \param order the order of the group generated by the generator. ++ * \param cofactor the index of the sub-group generated by the generator ++ * in the group of all points on the elliptic curve. ++ * \return 1 on success and 0 if an error occurred ++ */ ++int EC_GROUP_set_generator(EC_GROUP *group, const EC_POINT *generator, ++ const BIGNUM *order, const BIGNUM *cofactor); ++ ++/** Returns the generator of a EC_GROUP object. ++ * \param group EC_GROUP object ++ * \return the currently used generator (possibly NULL). ++ */ ++const EC_POINT *EC_GROUP_get0_generator(const EC_GROUP *group); ++ ++/** Returns the montgomery data for order(Generator) ++ * \param group EC_GROUP object ++ * \return the currently used montgomery data (possibly NULL). ++*/ ++BN_MONT_CTX *EC_GROUP_get_mont_data(const EC_GROUP *group); ++ ++/** Gets the order of a EC_GROUP ++ * \param group EC_GROUP object ++ * \param order BIGNUM to which the order is copied ++ * \param ctx unused ++ * \return 1 on success and 0 if an error occurred ++ */ ++int EC_GROUP_get_order(const EC_GROUP *group, BIGNUM *order, BN_CTX *ctx); ++ ++/** Gets the order of an EC_GROUP ++ * \param group EC_GROUP object ++ * \return the group order ++ */ ++const BIGNUM *EC_GROUP_get0_order(const EC_GROUP *group); ++ ++/** Gets the number of bits of the order of an EC_GROUP ++ * \param group EC_GROUP object ++ * \return number of bits of group order. ++ */ ++int EC_GROUP_order_bits(const EC_GROUP *group); ++ ++/** Gets the cofactor of a EC_GROUP ++ * \param group EC_GROUP object ++ * \param cofactor BIGNUM to which the cofactor is copied ++ * \param ctx unused ++ * \return 1 on success and 0 if an error occurred ++ */ ++int EC_GROUP_get_cofactor(const EC_GROUP *group, BIGNUM *cofactor, ++ BN_CTX *ctx); ++ ++/** Gets the cofactor of an EC_GROUP ++ * \param group EC_GROUP object ++ * \return the group cofactor ++ */ ++const BIGNUM *EC_GROUP_get0_cofactor(const EC_GROUP *group); ++ ++/** Sets the name of a EC_GROUP object ++ * \param group EC_GROUP object ++ * \param nid NID of the curve name OID ++ */ ++void EC_GROUP_set_curve_name(EC_GROUP *group, int nid); ++ ++/** Returns the curve name of a EC_GROUP object ++ * \param group EC_GROUP object ++ * \return NID of the curve name OID or 0 if not set. ++ */ ++int EC_GROUP_get_curve_name(const EC_GROUP *group); ++ ++void EC_GROUP_set_asn1_flag(EC_GROUP *group, int flag); ++int EC_GROUP_get_asn1_flag(const EC_GROUP *group); ++ ++void EC_GROUP_set_point_conversion_form(EC_GROUP *group, ++ point_conversion_form_t form); ++point_conversion_form_t EC_GROUP_get_point_conversion_form(const EC_GROUP *); ++ ++unsigned char *EC_GROUP_get0_seed(const EC_GROUP *x); ++size_t EC_GROUP_get_seed_len(const EC_GROUP *); ++size_t EC_GROUP_set_seed(EC_GROUP *, const unsigned char *, size_t len); ++ ++/** Sets the parameters of a ec curve defined by y^2 = x^3 + a*x + b (for GFp) ++ * or y^2 + x*y = x^3 + a*x^2 + b (for GF2m) ++ * \param group EC_GROUP object ++ * \param p BIGNUM with the prime number (GFp) or the polynomial ++ * defining the underlying field (GF2m) ++ * \param a BIGNUM with parameter a of the equation ++ * \param b BIGNUM with parameter b of the equation ++ * \param ctx BN_CTX object (optional) ++ * \return 1 on success and 0 if an error occurred ++ */ ++int EC_GROUP_set_curve(EC_GROUP *group, const BIGNUM *p, const BIGNUM *a, ++ const BIGNUM *b, BN_CTX *ctx); ++ ++/** Gets the parameters of the ec curve defined by y^2 = x^3 + a*x + b (for GFp) ++ * or y^2 + x*y = x^3 + a*x^2 + b (for GF2m) ++ * \param group EC_GROUP object ++ * \param p BIGNUM with the prime number (GFp) or the polynomial ++ * defining the underlying field (GF2m) ++ * \param a BIGNUM for parameter a of the equation ++ * \param b BIGNUM for parameter b of the equation ++ * \param ctx BN_CTX object (optional) ++ * \return 1 on success and 0 if an error occurred ++ */ ++int EC_GROUP_get_curve(const EC_GROUP *group, BIGNUM *p, BIGNUM *a, BIGNUM *b, ++ BN_CTX *ctx); ++ ++/** Sets the parameters of an ec curve. Synonym for EC_GROUP_set_curve ++ * \param group EC_GROUP object ++ * \param p BIGNUM with the prime number (GFp) or the polynomial ++ * defining the underlying field (GF2m) ++ * \param a BIGNUM with parameter a of the equation ++ * \param b BIGNUM with parameter b of the equation ++ * \param ctx BN_CTX object (optional) ++ * \return 1 on success and 0 if an error occurred ++ */ ++DEPRECATEDIN_1_2_0(int EC_GROUP_set_curve_GFp(EC_GROUP *group, const BIGNUM *p, ++ const BIGNUM *a, const BIGNUM *b, ++ BN_CTX *ctx)) ++ ++/** Gets the parameters of an ec curve. Synonym for EC_GROUP_get_curve ++ * \param group EC_GROUP object ++ * \param p BIGNUM with the prime number (GFp) or the polynomial ++ * defining the underlying field (GF2m) ++ * \param a BIGNUM for parameter a of the equation ++ * \param b BIGNUM for parameter b of the equation ++ * \param ctx BN_CTX object (optional) ++ * \return 1 on success and 0 if an error occurred ++ */ ++DEPRECATEDIN_1_2_0(int EC_GROUP_get_curve_GFp(const EC_GROUP *group, BIGNUM *p, ++ BIGNUM *a, BIGNUM *b, ++ BN_CTX *ctx)) ++ ++# ifndef OPENSSL_NO_EC2M ++/** Sets the parameter of an ec curve. Synonym for EC_GROUP_set_curve ++ * \param group EC_GROUP object ++ * \param p BIGNUM with the prime number (GFp) or the polynomial ++ * defining the underlying field (GF2m) ++ * \param a BIGNUM with parameter a of the equation ++ * \param b BIGNUM with parameter b of the equation ++ * \param ctx BN_CTX object (optional) ++ * \return 1 on success and 0 if an error occurred ++ */ ++DEPRECATEDIN_1_2_0(int EC_GROUP_set_curve_GF2m(EC_GROUP *group, const BIGNUM *p, ++ const BIGNUM *a, const BIGNUM *b, ++ BN_CTX *ctx)) ++ ++/** Gets the parameters of an ec curve. Synonym for EC_GROUP_get_curve ++ * \param group EC_GROUP object ++ * \param p BIGNUM with the prime number (GFp) or the polynomial ++ * defining the underlying field (GF2m) ++ * \param a BIGNUM for parameter a of the equation ++ * \param b BIGNUM for parameter b of the equation ++ * \param ctx BN_CTX object (optional) ++ * \return 1 on success and 0 if an error occurred ++ */ ++DEPRECATEDIN_1_2_0(int EC_GROUP_get_curve_GF2m(const EC_GROUP *group, BIGNUM *p, ++ BIGNUM *a, BIGNUM *b, ++ BN_CTX *ctx)) ++# endif ++/** Returns the number of bits needed to represent a field element ++ * \param group EC_GROUP object ++ * \return number of bits needed to represent a field element ++ */ ++int EC_GROUP_get_degree(const EC_GROUP *group); ++ ++/** Checks whether the parameter in the EC_GROUP define a valid ec group ++ * \param group EC_GROUP object ++ * \param ctx BN_CTX object (optional) ++ * \return 1 if group is a valid ec group and 0 otherwise ++ */ ++int EC_GROUP_check(const EC_GROUP *group, BN_CTX *ctx); ++ ++/** Checks whether the discriminant of the elliptic curve is zero or not ++ * \param group EC_GROUP object ++ * \param ctx BN_CTX object (optional) ++ * \return 1 if the discriminant is not zero and 0 otherwise ++ */ ++int EC_GROUP_check_discriminant(const EC_GROUP *group, BN_CTX *ctx); ++ ++/** Compares two EC_GROUP objects ++ * \param a first EC_GROUP object ++ * \param b second EC_GROUP object ++ * \param ctx BN_CTX object (optional) ++ * \return 0 if the groups are equal, 1 if not, or -1 on error ++ */ ++int EC_GROUP_cmp(const EC_GROUP *a, const EC_GROUP *b, BN_CTX *ctx); ++ ++/* ++ * EC_GROUP_new_GF*() calls EC_GROUP_new() and EC_GROUP_set_GF*() after ++ * choosing an appropriate EC_METHOD ++ */ ++ ++/** Creates a new EC_GROUP object with the specified parameters defined ++ * over GFp (defined by the equation y^2 = x^3 + a*x + b) ++ * \param p BIGNUM with the prime number ++ * \param a BIGNUM with the parameter a of the equation ++ * \param b BIGNUM with the parameter b of the equation ++ * \param ctx BN_CTX object (optional) ++ * \return newly created EC_GROUP object with the specified parameters ++ */ ++EC_GROUP *EC_GROUP_new_curve_GFp(const BIGNUM *p, const BIGNUM *a, ++ const BIGNUM *b, BN_CTX *ctx); ++# ifndef OPENSSL_NO_EC2M ++/** Creates a new EC_GROUP object with the specified parameters defined ++ * over GF2m (defined by the equation y^2 + x*y = x^3 + a*x^2 + b) ++ * \param p BIGNUM with the polynomial defining the underlying field ++ * \param a BIGNUM with the parameter a of the equation ++ * \param b BIGNUM with the parameter b of the equation ++ * \param ctx BN_CTX object (optional) ++ * \return newly created EC_GROUP object with the specified parameters ++ */ ++EC_GROUP *EC_GROUP_new_curve_GF2m(const BIGNUM *p, const BIGNUM *a, ++ const BIGNUM *b, BN_CTX *ctx); ++# endif ++ ++/** Creates a EC_GROUP object with a curve specified by a NID ++ * \param nid NID of the OID of the curve name ++ * \return newly created EC_GROUP object with specified curve or NULL ++ * if an error occurred ++ */ ++EC_GROUP *EC_GROUP_new_by_curve_name(int nid); ++ ++/** Creates a new EC_GROUP object from an ECPARAMETERS object ++ * \param params pointer to the ECPARAMETERS object ++ * \return newly created EC_GROUP object with specified curve or NULL ++ * if an error occurred ++ */ ++EC_GROUP *EC_GROUP_new_from_ecparameters(const ECPARAMETERS *params); ++ ++/** Creates an ECPARAMETERS object for the given EC_GROUP object. ++ * \param group pointer to the EC_GROUP object ++ * \param params pointer to an existing ECPARAMETERS object or NULL ++ * \return pointer to the new ECPARAMETERS object or NULL ++ * if an error occurred. ++ */ ++ECPARAMETERS *EC_GROUP_get_ecparameters(const EC_GROUP *group, ++ ECPARAMETERS *params); ++ ++/** Creates a new EC_GROUP object from an ECPKPARAMETERS object ++ * \param params pointer to an existing ECPKPARAMETERS object, or NULL ++ * \return newly created EC_GROUP object with specified curve, or NULL ++ * if an error occurred ++ */ ++EC_GROUP *EC_GROUP_new_from_ecpkparameters(const ECPKPARAMETERS *params); ++ ++/** Creates an ECPKPARAMETERS object for the given EC_GROUP object. ++ * \param group pointer to the EC_GROUP object ++ * \param params pointer to an existing ECPKPARAMETERS object or NULL ++ * \return pointer to the new ECPKPARAMETERS object or NULL ++ * if an error occurred. ++ */ ++ECPKPARAMETERS *EC_GROUP_get_ecpkparameters(const EC_GROUP *group, ++ ECPKPARAMETERS *params); ++ ++/********************************************************************/ ++/* handling of internal curves */ ++/********************************************************************/ ++ ++typedef struct { ++ int nid; ++ const char *comment; ++} EC_builtin_curve; ++ ++/* ++ * EC_builtin_curves(EC_builtin_curve *r, size_t size) returns number of all ++ * available curves or zero if a error occurred. In case r is not zero, ++ * nitems EC_builtin_curve structures are filled with the data of the first ++ * nitems internal groups ++ */ ++size_t EC_get_builtin_curves(EC_builtin_curve *r, size_t nitems); ++ ++const char *EC_curve_nid2nist(int nid); ++int EC_curve_nist2nid(const char *name); ++ ++/********************************************************************/ ++/* EC_POINT functions */ ++/********************************************************************/ ++ ++/** Creates a new EC_POINT object for the specified EC_GROUP ++ * \param group EC_GROUP the underlying EC_GROUP object ++ * \return newly created EC_POINT object or NULL if an error occurred ++ */ ++EC_POINT *EC_POINT_new(const EC_GROUP *group); ++ ++/** Frees a EC_POINT object ++ * \param point EC_POINT object to be freed ++ */ ++void EC_POINT_free(EC_POINT *point); ++ ++/** Clears and frees a EC_POINT object ++ * \param point EC_POINT object to be cleared and freed ++ */ ++void EC_POINT_clear_free(EC_POINT *point); ++ ++/** Copies EC_POINT object ++ * \param dst destination EC_POINT object ++ * \param src source EC_POINT object ++ * \return 1 on success and 0 if an error occurred ++ */ ++int EC_POINT_copy(EC_POINT *dst, const EC_POINT *src); ++ ++/** Creates a new EC_POINT object and copies the content of the supplied ++ * EC_POINT ++ * \param src source EC_POINT object ++ * \param group underlying the EC_GROUP object ++ * \return newly created EC_POINT object or NULL if an error occurred ++ */ ++EC_POINT *EC_POINT_dup(const EC_POINT *src, const EC_GROUP *group); ++ ++/** Returns the EC_METHOD used in EC_POINT object ++ * \param point EC_POINT object ++ * \return the EC_METHOD used ++ */ ++const EC_METHOD *EC_POINT_method_of(const EC_POINT *point); ++ ++/** Sets a point to infinity (neutral element) ++ * \param group underlying EC_GROUP object ++ * \param point EC_POINT to set to infinity ++ * \return 1 on success and 0 if an error occurred ++ */ ++int EC_POINT_set_to_infinity(const EC_GROUP *group, EC_POINT *point); ++ ++/** Sets the jacobian projective coordinates of a EC_POINT over GFp ++ * \param group underlying EC_GROUP object ++ * \param p EC_POINT object ++ * \param x BIGNUM with the x-coordinate ++ * \param y BIGNUM with the y-coordinate ++ * \param z BIGNUM with the z-coordinate ++ * \param ctx BN_CTX object (optional) ++ * \return 1 on success and 0 if an error occurred ++ */ ++int EC_POINT_set_Jprojective_coordinates_GFp(const EC_GROUP *group, ++ EC_POINT *p, const BIGNUM *x, ++ const BIGNUM *y, const BIGNUM *z, ++ BN_CTX *ctx); ++ ++/** Gets the jacobian projective coordinates of a EC_POINT over GFp ++ * \param group underlying EC_GROUP object ++ * \param p EC_POINT object ++ * \param x BIGNUM for the x-coordinate ++ * \param y BIGNUM for the y-coordinate ++ * \param z BIGNUM for the z-coordinate ++ * \param ctx BN_CTX object (optional) ++ * \return 1 on success and 0 if an error occurred ++ */ ++int EC_POINT_get_Jprojective_coordinates_GFp(const EC_GROUP *group, ++ const EC_POINT *p, BIGNUM *x, ++ BIGNUM *y, BIGNUM *z, ++ BN_CTX *ctx); ++ ++/** Sets the affine coordinates of an EC_POINT ++ * \param group underlying EC_GROUP object ++ * \param p EC_POINT object ++ * \param x BIGNUM with the x-coordinate ++ * \param y BIGNUM with the y-coordinate ++ * \param ctx BN_CTX object (optional) ++ * \return 1 on success and 0 if an error occurred ++ */ ++int EC_POINT_set_affine_coordinates(const EC_GROUP *group, EC_POINT *p, ++ const BIGNUM *x, const BIGNUM *y, ++ BN_CTX *ctx); ++ ++/** Gets the affine coordinates of an EC_POINT. ++ * \param group underlying EC_GROUP object ++ * \param p EC_POINT object ++ * \param x BIGNUM for the x-coordinate ++ * \param y BIGNUM for the y-coordinate ++ * \param ctx BN_CTX object (optional) ++ * \return 1 on success and 0 if an error occurred ++ */ ++int EC_POINT_get_affine_coordinates(const EC_GROUP *group, const EC_POINT *p, ++ BIGNUM *x, BIGNUM *y, BN_CTX *ctx); ++ ++/** Sets the affine coordinates of an EC_POINT. A synonym of ++ * EC_POINT_set_affine_coordinates ++ * \param group underlying EC_GROUP object ++ * \param p EC_POINT object ++ * \param x BIGNUM with the x-coordinate ++ * \param y BIGNUM with the y-coordinate ++ * \param ctx BN_CTX object (optional) ++ * \return 1 on success and 0 if an error occurred ++ */ ++DEPRECATEDIN_1_2_0(int EC_POINT_set_affine_coordinates_GFp(const EC_GROUP *group, ++ EC_POINT *p, ++ const BIGNUM *x, ++ const BIGNUM *y, ++ BN_CTX *ctx)) ++ ++/** Gets the affine coordinates of an EC_POINT. A synonym of ++ * EC_POINT_get_affine_coordinates ++ * \param group underlying EC_GROUP object ++ * \param p EC_POINT object ++ * \param x BIGNUM for the x-coordinate ++ * \param y BIGNUM for the y-coordinate ++ * \param ctx BN_CTX object (optional) ++ * \return 1 on success and 0 if an error occurred ++ */ ++DEPRECATEDIN_1_2_0(int EC_POINT_get_affine_coordinates_GFp(const EC_GROUP *group, ++ const EC_POINT *p, ++ BIGNUM *x, ++ BIGNUM *y, ++ BN_CTX *ctx)) ++ ++/** Sets the x9.62 compressed coordinates of a EC_POINT ++ * \param group underlying EC_GROUP object ++ * \param p EC_POINT object ++ * \param x BIGNUM with x-coordinate ++ * \param y_bit integer with the y-Bit (either 0 or 1) ++ * \param ctx BN_CTX object (optional) ++ * \return 1 on success and 0 if an error occurred ++ */ ++int EC_POINT_set_compressed_coordinates(const EC_GROUP *group, EC_POINT *p, ++ const BIGNUM *x, int y_bit, ++ BN_CTX *ctx); ++ ++/** Sets the x9.62 compressed coordinates of a EC_POINT. A synonym of ++ * EC_POINT_set_compressed_coordinates ++ * \param group underlying EC_GROUP object ++ * \param p EC_POINT object ++ * \param x BIGNUM with x-coordinate ++ * \param y_bit integer with the y-Bit (either 0 or 1) ++ * \param ctx BN_CTX object (optional) ++ * \return 1 on success and 0 if an error occurred ++ */ ++DEPRECATEDIN_1_2_0(int EC_POINT_set_compressed_coordinates_GFp(const EC_GROUP *group, ++ EC_POINT *p, ++ const BIGNUM *x, ++ int y_bit, ++ BN_CTX *ctx)) ++# ifndef OPENSSL_NO_EC2M ++/** Sets the affine coordinates of an EC_POINT. A synonym of ++ * EC_POINT_set_affine_coordinates ++ * \param group underlying EC_GROUP object ++ * \param p EC_POINT object ++ * \param x BIGNUM with the x-coordinate ++ * \param y BIGNUM with the y-coordinate ++ * \param ctx BN_CTX object (optional) ++ * \return 1 on success and 0 if an error occurred ++ */ ++DEPRECATEDIN_1_2_0(int EC_POINT_set_affine_coordinates_GF2m(const EC_GROUP *group, ++ EC_POINT *p, ++ const BIGNUM *x, ++ const BIGNUM *y, ++ BN_CTX *ctx)) ++ ++/** Gets the affine coordinates of an EC_POINT. A synonym of ++ * EC_POINT_get_affine_coordinates ++ * \param group underlying EC_GROUP object ++ * \param p EC_POINT object ++ * \param x BIGNUM for the x-coordinate ++ * \param y BIGNUM for the y-coordinate ++ * \param ctx BN_CTX object (optional) ++ * \return 1 on success and 0 if an error occurred ++ */ ++DEPRECATEDIN_1_2_0(int EC_POINT_get_affine_coordinates_GF2m(const EC_GROUP *group, ++ const EC_POINT *p, ++ BIGNUM *x, ++ BIGNUM *y, ++ BN_CTX *ctx)) ++ ++/** Sets the x9.62 compressed coordinates of a EC_POINT. A synonym of ++ * EC_POINT_set_compressed_coordinates ++ * \param group underlying EC_GROUP object ++ * \param p EC_POINT object ++ * \param x BIGNUM with x-coordinate ++ * \param y_bit integer with the y-Bit (either 0 or 1) ++ * \param ctx BN_CTX object (optional) ++ * \return 1 on success and 0 if an error occurred ++ */ ++DEPRECATEDIN_1_2_0(int EC_POINT_set_compressed_coordinates_GF2m(const EC_GROUP *group, ++ EC_POINT *p, ++ const BIGNUM *x, ++ int y_bit, ++ BN_CTX *ctx)) ++# endif ++/** Encodes a EC_POINT object to a octet string ++ * \param group underlying EC_GROUP object ++ * \param p EC_POINT object ++ * \param form point conversion form ++ * \param buf memory buffer for the result. If NULL the function returns ++ * required buffer size. ++ * \param len length of the memory buffer ++ * \param ctx BN_CTX object (optional) ++ * \return the length of the encoded octet string or 0 if an error occurred ++ */ ++size_t EC_POINT_point2oct(const EC_GROUP *group, const EC_POINT *p, ++ point_conversion_form_t form, ++ unsigned char *buf, size_t len, BN_CTX *ctx); ++ ++/** Decodes a EC_POINT from a octet string ++ * \param group underlying EC_GROUP object ++ * \param p EC_POINT object ++ * \param buf memory buffer with the encoded ec point ++ * \param len length of the encoded ec point ++ * \param ctx BN_CTX object (optional) ++ * \return 1 on success and 0 if an error occurred ++ */ ++int EC_POINT_oct2point(const EC_GROUP *group, EC_POINT *p, ++ const unsigned char *buf, size_t len, BN_CTX *ctx); ++ ++/** Encodes an EC_POINT object to an allocated octet string ++ * \param group underlying EC_GROUP object ++ * \param point EC_POINT object ++ * \param form point conversion form ++ * \param pbuf returns pointer to allocated buffer ++ * \param ctx BN_CTX object (optional) ++ * \return the length of the encoded octet string or 0 if an error occurred ++ */ ++size_t EC_POINT_point2buf(const EC_GROUP *group, const EC_POINT *point, ++ point_conversion_form_t form, ++ unsigned char **pbuf, BN_CTX *ctx); ++ ++/* other interfaces to point2oct/oct2point: */ ++BIGNUM *EC_POINT_point2bn(const EC_GROUP *, const EC_POINT *, ++ point_conversion_form_t form, BIGNUM *, BN_CTX *); ++EC_POINT *EC_POINT_bn2point(const EC_GROUP *, const BIGNUM *, ++ EC_POINT *, BN_CTX *); ++char *EC_POINT_point2hex(const EC_GROUP *, const EC_POINT *, ++ point_conversion_form_t form, BN_CTX *); ++EC_POINT *EC_POINT_hex2point(const EC_GROUP *, const char *, ++ EC_POINT *, BN_CTX *); ++ ++/********************************************************************/ ++/* functions for doing EC_POINT arithmetic */ ++/********************************************************************/ ++ ++/** Computes the sum of two EC_POINT ++ * \param group underlying EC_GROUP object ++ * \param r EC_POINT object for the result (r = a + b) ++ * \param a EC_POINT object with the first summand ++ * \param b EC_POINT object with the second summand ++ * \param ctx BN_CTX object (optional) ++ * \return 1 on success and 0 if an error occurred ++ */ ++int EC_POINT_add(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a, ++ const EC_POINT *b, BN_CTX *ctx); ++ ++/** Computes the double of a EC_POINT ++ * \param group underlying EC_GROUP object ++ * \param r EC_POINT object for the result (r = 2 * a) ++ * \param a EC_POINT object ++ * \param ctx BN_CTX object (optional) ++ * \return 1 on success and 0 if an error occurred ++ */ ++int EC_POINT_dbl(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a, ++ BN_CTX *ctx); ++ ++/** Computes the inverse of a EC_POINT ++ * \param group underlying EC_GROUP object ++ * \param a EC_POINT object to be inverted (it's used for the result as well) ++ * \param ctx BN_CTX object (optional) ++ * \return 1 on success and 0 if an error occurred ++ */ ++int EC_POINT_invert(const EC_GROUP *group, EC_POINT *a, BN_CTX *ctx); ++ ++/** Checks whether the point is the neutral element of the group ++ * \param group the underlying EC_GROUP object ++ * \param p EC_POINT object ++ * \return 1 if the point is the neutral element and 0 otherwise ++ */ ++int EC_POINT_is_at_infinity(const EC_GROUP *group, const EC_POINT *p); ++ ++/** Checks whether the point is on the curve ++ * \param group underlying EC_GROUP object ++ * \param point EC_POINT object to check ++ * \param ctx BN_CTX object (optional) ++ * \return 1 if the point is on the curve, 0 if not, or -1 on error ++ */ ++int EC_POINT_is_on_curve(const EC_GROUP *group, const EC_POINT *point, ++ BN_CTX *ctx); ++ ++/** Compares two EC_POINTs ++ * \param group underlying EC_GROUP object ++ * \param a first EC_POINT object ++ * \param b second EC_POINT object ++ * \param ctx BN_CTX object (optional) ++ * \return 1 if the points are not equal, 0 if they are, or -1 on error ++ */ ++int EC_POINT_cmp(const EC_GROUP *group, const EC_POINT *a, const EC_POINT *b, ++ BN_CTX *ctx); ++ ++int EC_POINT_make_affine(const EC_GROUP *group, EC_POINT *point, BN_CTX *ctx); ++int EC_POINTs_make_affine(const EC_GROUP *group, size_t num, ++ EC_POINT *points[], BN_CTX *ctx); ++ ++/** Computes r = generator * n + sum_{i=0}^{num-1} p[i] * m[i] ++ * \param group underlying EC_GROUP object ++ * \param r EC_POINT object for the result ++ * \param n BIGNUM with the multiplier for the group generator (optional) ++ * \param num number further summands ++ * \param p array of size num of EC_POINT objects ++ * \param m array of size num of BIGNUM objects ++ * \param ctx BN_CTX object (optional) ++ * \return 1 on success and 0 if an error occurred ++ */ ++int EC_POINTs_mul(const EC_GROUP *group, EC_POINT *r, const BIGNUM *n, ++ size_t num, const EC_POINT *p[], const BIGNUM *m[], ++ BN_CTX *ctx); ++ ++/** Computes r = generator * n + q * m ++ * \param group underlying EC_GROUP object ++ * \param r EC_POINT object for the result ++ * \param n BIGNUM with the multiplier for the group generator (optional) ++ * \param q EC_POINT object with the first factor of the second summand ++ * \param m BIGNUM with the second factor of the second summand ++ * \param ctx BN_CTX object (optional) ++ * \return 1 on success and 0 if an error occurred ++ */ ++int EC_POINT_mul(const EC_GROUP *group, EC_POINT *r, const BIGNUM *n, ++ const EC_POINT *q, const BIGNUM *m, BN_CTX *ctx); ++ ++/** Stores multiples of generator for faster point multiplication ++ * \param group EC_GROUP object ++ * \param ctx BN_CTX object (optional) ++ * \return 1 on success and 0 if an error occurred ++ */ ++int EC_GROUP_precompute_mult(EC_GROUP *group, BN_CTX *ctx); ++ ++/** Reports whether a precomputation has been done ++ * \param group EC_GROUP object ++ * \return 1 if a pre-computation has been done and 0 otherwise ++ */ ++int EC_GROUP_have_precompute_mult(const EC_GROUP *group); ++ ++/********************************************************************/ ++/* ASN1 stuff */ ++/********************************************************************/ ++ ++DECLARE_ASN1_ITEM(ECPKPARAMETERS) ++DECLARE_ASN1_ALLOC_FUNCTIONS(ECPKPARAMETERS) ++DECLARE_ASN1_ITEM(ECPARAMETERS) ++DECLARE_ASN1_ALLOC_FUNCTIONS(ECPARAMETERS) ++ ++/* ++ * EC_GROUP_get_basis_type() returns the NID of the basis type used to ++ * represent the field elements ++ */ ++int EC_GROUP_get_basis_type(const EC_GROUP *); ++# ifndef OPENSSL_NO_EC2M ++int EC_GROUP_get_trinomial_basis(const EC_GROUP *, unsigned int *k); ++int EC_GROUP_get_pentanomial_basis(const EC_GROUP *, unsigned int *k1, ++ unsigned int *k2, unsigned int *k3); ++# endif ++ ++# define OPENSSL_EC_EXPLICIT_CURVE 0x000 ++# define OPENSSL_EC_NAMED_CURVE 0x001 ++ ++EC_GROUP *d2i_ECPKParameters(EC_GROUP **, const unsigned char **in, long len); ++int i2d_ECPKParameters(const EC_GROUP *, unsigned char **out); ++ ++# define d2i_ECPKParameters_bio(bp,x) \ ++ ASN1_d2i_bio_of(EC_GROUP, NULL, d2i_ECPKParameters, bp, x) ++# define i2d_ECPKParameters_bio(bp,x) \ ++ ASN1_i2d_bio_of_const(EC_GROUP, i2d_ECPKParameters, bp, x) ++# define d2i_ECPKParameters_fp(fp,x) \ ++ (EC_GROUP *)ASN1_d2i_fp(NULL, (d2i_of_void *)d2i_ECPKParameters, (fp), \ ++ (void **)(x)) ++# define i2d_ECPKParameters_fp(fp,x) \ ++ ASN1_i2d_fp((i2d_of_void *)i2d_ECPKParameters, (fp), (void *)(x)) ++ ++int ECPKParameters_print(BIO *bp, const EC_GROUP *x, int off); ++# ifndef OPENSSL_NO_STDIO ++int ECPKParameters_print_fp(FILE *fp, const EC_GROUP *x, int off); ++# endif ++ ++/********************************************************************/ ++/* EC_KEY functions */ ++/********************************************************************/ ++ ++/* some values for the encoding_flag */ ++# define EC_PKEY_NO_PARAMETERS 0x001 ++# define EC_PKEY_NO_PUBKEY 0x002 ++ ++/* some values for the flags field */ ++# define EC_FLAG_NON_FIPS_ALLOW 0x1 ++# define EC_FLAG_FIPS_CHECKED 0x2 ++# define EC_FLAG_COFACTOR_ECDH 0x1000 ++ ++/** Creates a new EC_KEY object. ++ * \return EC_KEY object or NULL if an error occurred. ++ */ ++EC_KEY *EC_KEY_new(void); ++ ++int EC_KEY_get_flags(const EC_KEY *key); ++ ++void EC_KEY_set_flags(EC_KEY *key, int flags); ++ ++void EC_KEY_clear_flags(EC_KEY *key, int flags); ++ ++int EC_KEY_decoded_from_explicit_params(const EC_KEY *key); ++ ++/** Creates a new EC_KEY object using a named curve as underlying ++ * EC_GROUP object. ++ * \param nid NID of the named curve. ++ * \return EC_KEY object or NULL if an error occurred. ++ */ ++EC_KEY *EC_KEY_new_by_curve_name(int nid); ++ ++/** Frees a EC_KEY object. ++ * \param key EC_KEY object to be freed. ++ */ ++void EC_KEY_free(EC_KEY *key); ++ ++/** Copies a EC_KEY object. ++ * \param dst destination EC_KEY object ++ * \param src src EC_KEY object ++ * \return dst or NULL if an error occurred. ++ */ ++EC_KEY *EC_KEY_copy(EC_KEY *dst, const EC_KEY *src); ++ ++/** Creates a new EC_KEY object and copies the content from src to it. ++ * \param src the source EC_KEY object ++ * \return newly created EC_KEY object or NULL if an error occurred. ++ */ ++EC_KEY *EC_KEY_dup(const EC_KEY *src); ++ ++/** Increases the internal reference count of a EC_KEY object. ++ * \param key EC_KEY object ++ * \return 1 on success and 0 if an error occurred. ++ */ ++int EC_KEY_up_ref(EC_KEY *key); ++ ++/** Returns the ENGINE object of a EC_KEY object ++ * \param eckey EC_KEY object ++ * \return the ENGINE object (possibly NULL). ++ */ ++ENGINE *EC_KEY_get0_engine(const EC_KEY *eckey); ++ ++/** Returns the EC_GROUP object of a EC_KEY object ++ * \param key EC_KEY object ++ * \return the EC_GROUP object (possibly NULL). ++ */ ++const EC_GROUP *EC_KEY_get0_group(const EC_KEY *key); ++ ++/** Sets the EC_GROUP of a EC_KEY object. ++ * \param key EC_KEY object ++ * \param group EC_GROUP to use in the EC_KEY object (note: the EC_KEY ++ * object will use an own copy of the EC_GROUP). ++ * \return 1 on success and 0 if an error occurred. ++ */ ++int EC_KEY_set_group(EC_KEY *key, const EC_GROUP *group); ++ ++/** Returns the private key of a EC_KEY object. ++ * \param key EC_KEY object ++ * \return a BIGNUM with the private key (possibly NULL). ++ */ ++const BIGNUM *EC_KEY_get0_private_key(const EC_KEY *key); ++ ++/** Sets the private key of a EC_KEY object. ++ * \param key EC_KEY object ++ * \param prv BIGNUM with the private key (note: the EC_KEY object ++ * will use an own copy of the BIGNUM). ++ * \return 1 on success and 0 if an error occurred. ++ */ ++int EC_KEY_set_private_key(EC_KEY *key, const BIGNUM *prv); ++ ++/** Returns the public key of a EC_KEY object. ++ * \param key the EC_KEY object ++ * \return a EC_POINT object with the public key (possibly NULL) ++ */ ++const EC_POINT *EC_KEY_get0_public_key(const EC_KEY *key); ++ ++/** Sets the public key of a EC_KEY object. ++ * \param key EC_KEY object ++ * \param pub EC_POINT object with the public key (note: the EC_KEY object ++ * will use an own copy of the EC_POINT object). ++ * \return 1 on success and 0 if an error occurred. ++ */ ++int EC_KEY_set_public_key(EC_KEY *key, const EC_POINT *pub); ++ ++unsigned EC_KEY_get_enc_flags(const EC_KEY *key); ++void EC_KEY_set_enc_flags(EC_KEY *eckey, unsigned int flags); ++point_conversion_form_t EC_KEY_get_conv_form(const EC_KEY *key); ++void EC_KEY_set_conv_form(EC_KEY *eckey, point_conversion_form_t cform); ++ ++#define EC_KEY_get_ex_new_index(l, p, newf, dupf, freef) \ ++ CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_EC_KEY, l, p, newf, dupf, freef) ++int EC_KEY_set_ex_data(EC_KEY *key, int idx, void *arg); ++void *EC_KEY_get_ex_data(const EC_KEY *key, int idx); ++ ++/* wrapper functions for the underlying EC_GROUP object */ ++void EC_KEY_set_asn1_flag(EC_KEY *eckey, int asn1_flag); ++ ++/** Creates a table of pre-computed multiples of the generator to ++ * accelerate further EC_KEY operations. ++ * \param key EC_KEY object ++ * \param ctx BN_CTX object (optional) ++ * \return 1 on success and 0 if an error occurred. ++ */ ++int EC_KEY_precompute_mult(EC_KEY *key, BN_CTX *ctx); ++ ++/** Creates a new ec private (and optional a new public) key. ++ * \param key EC_KEY object ++ * \return 1 on success and 0 if an error occurred. ++ */ ++int EC_KEY_generate_key(EC_KEY *key); ++ ++/** Verifies that a private and/or public key is valid. ++ * \param key the EC_KEY object ++ * \return 1 on success and 0 otherwise. ++ */ ++int EC_KEY_check_key(const EC_KEY *key); ++ ++/** Indicates if an EC_KEY can be used for signing. ++ * \param eckey the EC_KEY object ++ * \return 1 if can can sign and 0 otherwise. ++ */ ++int EC_KEY_can_sign(const EC_KEY *eckey); ++ ++/** Sets a public key from affine coordinates performing ++ * necessary NIST PKV tests. ++ * \param key the EC_KEY object ++ * \param x public key x coordinate ++ * \param y public key y coordinate ++ * \return 1 on success and 0 otherwise. ++ */ ++int EC_KEY_set_public_key_affine_coordinates(EC_KEY *key, BIGNUM *x, ++ BIGNUM *y); ++ ++/** Encodes an EC_KEY public key to an allocated octet string ++ * \param key key to encode ++ * \param form point conversion form ++ * \param pbuf returns pointer to allocated buffer ++ * \param ctx BN_CTX object (optional) ++ * \return the length of the encoded octet string or 0 if an error occurred ++ */ ++size_t EC_KEY_key2buf(const EC_KEY *key, point_conversion_form_t form, ++ unsigned char **pbuf, BN_CTX *ctx); ++ ++/** Decodes a EC_KEY public key from a octet string ++ * \param key key to decode ++ * \param buf memory buffer with the encoded ec point ++ * \param len length of the encoded ec point ++ * \param ctx BN_CTX object (optional) ++ * \return 1 on success and 0 if an error occurred ++ */ ++ ++int EC_KEY_oct2key(EC_KEY *key, const unsigned char *buf, size_t len, ++ BN_CTX *ctx); ++ ++/** Decodes an EC_KEY private key from an octet string ++ * \param key key to decode ++ * \param buf memory buffer with the encoded private key ++ * \param len length of the encoded key ++ * \return 1 on success and 0 if an error occurred ++ */ ++ ++int EC_KEY_oct2priv(EC_KEY *key, const unsigned char *buf, size_t len); ++ ++/** Encodes a EC_KEY private key to an octet string ++ * \param key key to encode ++ * \param buf memory buffer for the result. If NULL the function returns ++ * required buffer size. ++ * \param len length of the memory buffer ++ * \return the length of the encoded octet string or 0 if an error occurred ++ */ ++ ++size_t EC_KEY_priv2oct(const EC_KEY *key, unsigned char *buf, size_t len); ++ ++/** Encodes an EC_KEY private key to an allocated octet string ++ * \param eckey key to encode ++ * \param pbuf returns pointer to allocated buffer ++ * \return the length of the encoded octet string or 0 if an error occurred ++ */ ++size_t EC_KEY_priv2buf(const EC_KEY *eckey, unsigned char **pbuf); ++ ++/********************************************************************/ ++/* de- and encoding functions for SEC1 ECPrivateKey */ ++/********************************************************************/ ++ ++/** Decodes a private key from a memory buffer. ++ * \param key a pointer to a EC_KEY object which should be used (or NULL) ++ * \param in pointer to memory with the DER encoded private key ++ * \param len length of the DER encoded private key ++ * \return the decoded private key or NULL if an error occurred. ++ */ ++EC_KEY *d2i_ECPrivateKey(EC_KEY **key, const unsigned char **in, long len); ++ ++/** Encodes a private key object and stores the result in a buffer. ++ * \param key the EC_KEY object to encode ++ * \param out the buffer for the result (if NULL the function returns number ++ * of bytes needed). ++ * \return 1 on success and 0 if an error occurred. ++ */ ++int i2d_ECPrivateKey(EC_KEY *key, unsigned char **out); ++ ++/********************************************************************/ ++/* de- and encoding functions for EC parameters */ ++/********************************************************************/ ++ ++/** Decodes ec parameter from a memory buffer. ++ * \param key a pointer to a EC_KEY object which should be used (or NULL) ++ * \param in pointer to memory with the DER encoded ec parameters ++ * \param len length of the DER encoded ec parameters ++ * \return a EC_KEY object with the decoded parameters or NULL if an error ++ * occurred. ++ */ ++EC_KEY *d2i_ECParameters(EC_KEY **key, const unsigned char **in, long len); ++ ++/** Encodes ec parameter and stores the result in a buffer. ++ * \param key the EC_KEY object with ec parameters to encode ++ * \param out the buffer for the result (if NULL the function returns number ++ * of bytes needed). ++ * \return 1 on success and 0 if an error occurred. ++ */ ++int i2d_ECParameters(EC_KEY *key, unsigned char **out); ++ ++/********************************************************************/ ++/* de- and encoding functions for EC public key */ ++/* (octet string, not DER -- hence 'o2i' and 'i2o') */ ++/********************************************************************/ ++ ++/** Decodes a ec public key from a octet string. ++ * \param key a pointer to a EC_KEY object which should be used ++ * \param in memory buffer with the encoded public key ++ * \param len length of the encoded public key ++ * \return EC_KEY object with decoded public key or NULL if an error ++ * occurred. ++ */ ++EC_KEY *o2i_ECPublicKey(EC_KEY **key, const unsigned char **in, long len); ++ ++/** Encodes a ec public key in an octet string. ++ * \param key the EC_KEY object with the public key ++ * \param out the buffer for the result (if NULL the function returns number ++ * of bytes needed). ++ * \return 1 on success and 0 if an error occurred ++ */ ++int i2o_ECPublicKey(const EC_KEY *key, unsigned char **out); ++ ++/** Prints out the ec parameters on human readable form. ++ * \param bp BIO object to which the information is printed ++ * \param key EC_KEY object ++ * \return 1 on success and 0 if an error occurred ++ */ ++int ECParameters_print(BIO *bp, const EC_KEY *key); ++ ++/** Prints out the contents of a EC_KEY object ++ * \param bp BIO object to which the information is printed ++ * \param key EC_KEY object ++ * \param off line offset ++ * \return 1 on success and 0 if an error occurred ++ */ ++int EC_KEY_print(BIO *bp, const EC_KEY *key, int off); ++ ++# ifndef OPENSSL_NO_STDIO ++/** Prints out the ec parameters on human readable form. ++ * \param fp file descriptor to which the information is printed ++ * \param key EC_KEY object ++ * \return 1 on success and 0 if an error occurred ++ */ ++int ECParameters_print_fp(FILE *fp, const EC_KEY *key); ++ ++/** Prints out the contents of a EC_KEY object ++ * \param fp file descriptor to which the information is printed ++ * \param key EC_KEY object ++ * \param off line offset ++ * \return 1 on success and 0 if an error occurred ++ */ ++int EC_KEY_print_fp(FILE *fp, const EC_KEY *key, int off); ++ ++# endif ++const EC_KEY_METHOD *EC_KEY_get_iso_15946_2_method(void); ++const EC_KEY_METHOD *EC_KEY_OpenSSL(void); ++const EC_KEY_METHOD *EC_KEY_get_default_method(void); ++void EC_KEY_set_default_method(const EC_KEY_METHOD *meth); ++const EC_KEY_METHOD *EC_KEY_get_method(const EC_KEY *key); ++int EC_KEY_set_method(EC_KEY *key, const EC_KEY_METHOD *meth); ++EC_KEY *EC_KEY_new_method(ENGINE *engine); ++ ++/** The old name for ecdh_KDF_X9_63 ++ * The ECDH KDF specification has been mistakingly attributed to ANSI X9.62, ++ * it is actually specified in ANSI X9.63. ++ * This identifier is retained for backwards compatibility ++ */ ++int ECDH_KDF_X9_62(unsigned char *out, size_t outlen, ++ const unsigned char *Z, size_t Zlen, ++ const unsigned char *sinfo, size_t sinfolen, ++ const EVP_MD *md); ++ ++int ECDH_compute_key(void *out, size_t outlen, const EC_POINT *pub_key, ++ const EC_KEY *ecdh, ++ void *(*KDF) (const void *in, size_t inlen, ++ void *out, size_t *outlen)); ++ ++typedef struct ECDSA_SIG_st ECDSA_SIG; ++ ++/** Allocates and initialize a ECDSA_SIG structure ++ * \return pointer to a ECDSA_SIG structure or NULL if an error occurred ++ */ ++ECDSA_SIG *ECDSA_SIG_new(void); ++ ++/** frees a ECDSA_SIG structure ++ * \param sig pointer to the ECDSA_SIG structure ++ */ ++void ECDSA_SIG_free(ECDSA_SIG *sig); ++ ++/** DER encode content of ECDSA_SIG object (note: this function modifies *pp ++ * (*pp += length of the DER encoded signature)). ++ * \param sig pointer to the ECDSA_SIG object ++ * \param pp pointer to a unsigned char pointer for the output or NULL ++ * \return the length of the DER encoded ECDSA_SIG object or a negative value ++ * on error ++ */ ++int i2d_ECDSA_SIG(const ECDSA_SIG *sig, unsigned char **pp); ++ ++/** Decodes a DER encoded ECDSA signature (note: this function changes *pp ++ * (*pp += len)). ++ * \param sig pointer to ECDSA_SIG pointer (may be NULL) ++ * \param pp memory buffer with the DER encoded signature ++ * \param len length of the buffer ++ * \return pointer to the decoded ECDSA_SIG structure (or NULL) ++ */ ++ECDSA_SIG *d2i_ECDSA_SIG(ECDSA_SIG **sig, const unsigned char **pp, long len); ++ ++/** Accessor for r and s fields of ECDSA_SIG ++ * \param sig pointer to ECDSA_SIG structure ++ * \param pr pointer to BIGNUM pointer for r (may be NULL) ++ * \param ps pointer to BIGNUM pointer for s (may be NULL) ++ */ ++void ECDSA_SIG_get0(const ECDSA_SIG *sig, const BIGNUM **pr, const BIGNUM **ps); ++ ++/** Accessor for r field of ECDSA_SIG ++ * \param sig pointer to ECDSA_SIG structure ++ */ ++const BIGNUM *ECDSA_SIG_get0_r(const ECDSA_SIG *sig); ++ ++/** Accessor for s field of ECDSA_SIG ++ * \param sig pointer to ECDSA_SIG structure ++ */ ++const BIGNUM *ECDSA_SIG_get0_s(const ECDSA_SIG *sig); ++ ++/** Setter for r and s fields of ECDSA_SIG ++ * \param sig pointer to ECDSA_SIG structure ++ * \param r pointer to BIGNUM for r (may be NULL) ++ * \param s pointer to BIGNUM for s (may be NULL) ++ */ ++int ECDSA_SIG_set0(ECDSA_SIG *sig, BIGNUM *r, BIGNUM *s); ++ ++/** Computes the ECDSA signature of the given hash value using ++ * the supplied private key and returns the created signature. ++ * \param dgst pointer to the hash value ++ * \param dgst_len length of the hash value ++ * \param eckey EC_KEY object containing a private EC key ++ * \return pointer to a ECDSA_SIG structure or NULL if an error occurred ++ */ ++ECDSA_SIG *ECDSA_do_sign(const unsigned char *dgst, int dgst_len, ++ EC_KEY *eckey); ++ ++/** Computes ECDSA signature of a given hash value using the supplied ++ * private key (note: sig must point to ECDSA_size(eckey) bytes of memory). ++ * \param dgst pointer to the hash value to sign ++ * \param dgstlen length of the hash value ++ * \param kinv BIGNUM with a pre-computed inverse k (optional) ++ * \param rp BIGNUM with a pre-computed rp value (optional), ++ * see ECDSA_sign_setup ++ * \param eckey EC_KEY object containing a private EC key ++ * \return pointer to a ECDSA_SIG structure or NULL if an error occurred ++ */ ++ECDSA_SIG *ECDSA_do_sign_ex(const unsigned char *dgst, int dgstlen, ++ const BIGNUM *kinv, const BIGNUM *rp, ++ EC_KEY *eckey); ++ ++/** Verifies that the supplied signature is a valid ECDSA ++ * signature of the supplied hash value using the supplied public key. ++ * \param dgst pointer to the hash value ++ * \param dgst_len length of the hash value ++ * \param sig ECDSA_SIG structure ++ * \param eckey EC_KEY object containing a public EC key ++ * \return 1 if the signature is valid, 0 if the signature is invalid ++ * and -1 on error ++ */ ++int ECDSA_do_verify(const unsigned char *dgst, int dgst_len, ++ const ECDSA_SIG *sig, EC_KEY *eckey); ++ ++/** Precompute parts of the signing operation ++ * \param eckey EC_KEY object containing a private EC key ++ * \param ctx BN_CTX object (optional) ++ * \param kinv BIGNUM pointer for the inverse of k ++ * \param rp BIGNUM pointer for x coordinate of k * generator ++ * \return 1 on success and 0 otherwise ++ */ ++int ECDSA_sign_setup(EC_KEY *eckey, BN_CTX *ctx, BIGNUM **kinv, BIGNUM **rp); ++ ++/** Computes ECDSA signature of a given hash value using the supplied ++ * private key (note: sig must point to ECDSA_size(eckey) bytes of memory). ++ * \param type this parameter is ignored ++ * \param dgst pointer to the hash value to sign ++ * \param dgstlen length of the hash value ++ * \param sig memory for the DER encoded created signature ++ * \param siglen pointer to the length of the returned signature ++ * \param eckey EC_KEY object containing a private EC key ++ * \return 1 on success and 0 otherwise ++ */ ++int ECDSA_sign(int type, const unsigned char *dgst, int dgstlen, ++ unsigned char *sig, unsigned int *siglen, EC_KEY *eckey); ++ ++/** Computes ECDSA signature of a given hash value using the supplied ++ * private key (note: sig must point to ECDSA_size(eckey) bytes of memory). ++ * \param type this parameter is ignored ++ * \param dgst pointer to the hash value to sign ++ * \param dgstlen length of the hash value ++ * \param sig buffer to hold the DER encoded signature ++ * \param siglen pointer to the length of the returned signature ++ * \param kinv BIGNUM with a pre-computed inverse k (optional) ++ * \param rp BIGNUM with a pre-computed rp value (optional), ++ * see ECDSA_sign_setup ++ * \param eckey EC_KEY object containing a private EC key ++ * \return 1 on success and 0 otherwise ++ */ ++int ECDSA_sign_ex(int type, const unsigned char *dgst, int dgstlen, ++ unsigned char *sig, unsigned int *siglen, ++ const BIGNUM *kinv, const BIGNUM *rp, EC_KEY *eckey); ++ ++/** Verifies that the given signature is valid ECDSA signature ++ * of the supplied hash value using the specified public key. ++ * \param type this parameter is ignored ++ * \param dgst pointer to the hash value ++ * \param dgstlen length of the hash value ++ * \param sig pointer to the DER encoded signature ++ * \param siglen length of the DER encoded signature ++ * \param eckey EC_KEY object containing a public EC key ++ * \return 1 if the signature is valid, 0 if the signature is invalid ++ * and -1 on error ++ */ ++int ECDSA_verify(int type, const unsigned char *dgst, int dgstlen, ++ const unsigned char *sig, int siglen, EC_KEY *eckey); ++ ++/** Returns the maximum length of the DER encoded signature ++ * \param eckey EC_KEY object ++ * \return numbers of bytes required for the DER encoded signature ++ */ ++int ECDSA_size(const EC_KEY *eckey); ++ ++/********************************************************************/ ++/* EC_KEY_METHOD constructors, destructors, writers and accessors */ ++/********************************************************************/ ++ ++EC_KEY_METHOD *EC_KEY_METHOD_new(const EC_KEY_METHOD *meth); ++void EC_KEY_METHOD_free(EC_KEY_METHOD *meth); ++void EC_KEY_METHOD_set_init(EC_KEY_METHOD *meth, ++ int (*init)(EC_KEY *key), ++ void (*finish)(EC_KEY *key), ++ int (*copy)(EC_KEY *dest, const EC_KEY *src), ++ int (*set_group)(EC_KEY *key, const EC_GROUP *grp), ++ int (*set_private)(EC_KEY *key, ++ const BIGNUM *priv_key), ++ int (*set_public)(EC_KEY *key, ++ const EC_POINT *pub_key)); ++ ++void EC_KEY_METHOD_set_keygen(EC_KEY_METHOD *meth, ++ int (*keygen)(EC_KEY *key)); ++ ++void EC_KEY_METHOD_set_compute_key(EC_KEY_METHOD *meth, ++ int (*ckey)(unsigned char **psec, ++ size_t *pseclen, ++ const EC_POINT *pub_key, ++ const EC_KEY *ecdh)); ++ ++void EC_KEY_METHOD_set_sign(EC_KEY_METHOD *meth, ++ int (*sign)(int type, const unsigned char *dgst, ++ int dlen, unsigned char *sig, ++ unsigned int *siglen, ++ const BIGNUM *kinv, const BIGNUM *r, ++ EC_KEY *eckey), ++ int (*sign_setup)(EC_KEY *eckey, BN_CTX *ctx_in, ++ BIGNUM **kinvp, BIGNUM **rp), ++ ECDSA_SIG *(*sign_sig)(const unsigned char *dgst, ++ int dgst_len, ++ const BIGNUM *in_kinv, ++ const BIGNUM *in_r, ++ EC_KEY *eckey)); ++ ++void EC_KEY_METHOD_set_verify(EC_KEY_METHOD *meth, ++ int (*verify)(int type, const unsigned ++ char *dgst, int dgst_len, ++ const unsigned char *sigbuf, ++ int sig_len, EC_KEY *eckey), ++ int (*verify_sig)(const unsigned char *dgst, ++ int dgst_len, ++ const ECDSA_SIG *sig, ++ EC_KEY *eckey)); ++ ++void EC_KEY_METHOD_get_init(const EC_KEY_METHOD *meth, ++ int (**pinit)(EC_KEY *key), ++ void (**pfinish)(EC_KEY *key), ++ int (**pcopy)(EC_KEY *dest, const EC_KEY *src), ++ int (**pset_group)(EC_KEY *key, ++ const EC_GROUP *grp), ++ int (**pset_private)(EC_KEY *key, ++ const BIGNUM *priv_key), ++ int (**pset_public)(EC_KEY *key, ++ const EC_POINT *pub_key)); ++ ++void EC_KEY_METHOD_get_keygen(const EC_KEY_METHOD *meth, ++ int (**pkeygen)(EC_KEY *key)); ++ ++void EC_KEY_METHOD_get_compute_key(const EC_KEY_METHOD *meth, ++ int (**pck)(unsigned char **psec, ++ size_t *pseclen, ++ const EC_POINT *pub_key, ++ const EC_KEY *ecdh)); ++ ++void EC_KEY_METHOD_get_sign(const EC_KEY_METHOD *meth, ++ int (**psign)(int type, const unsigned char *dgst, ++ int dlen, unsigned char *sig, ++ unsigned int *siglen, ++ const BIGNUM *kinv, const BIGNUM *r, ++ EC_KEY *eckey), ++ int (**psign_setup)(EC_KEY *eckey, BN_CTX *ctx_in, ++ BIGNUM **kinvp, BIGNUM **rp), ++ ECDSA_SIG *(**psign_sig)(const unsigned char *dgst, ++ int dgst_len, ++ const BIGNUM *in_kinv, ++ const BIGNUM *in_r, ++ EC_KEY *eckey)); ++ ++void EC_KEY_METHOD_get_verify(const EC_KEY_METHOD *meth, ++ int (**pverify)(int type, const unsigned ++ char *dgst, int dgst_len, ++ const unsigned char *sigbuf, ++ int sig_len, EC_KEY *eckey), ++ int (**pverify_sig)(const unsigned char *dgst, ++ int dgst_len, ++ const ECDSA_SIG *sig, ++ EC_KEY *eckey)); ++ ++# define ECParameters_dup(x) ASN1_dup_of(EC_KEY,i2d_ECParameters,d2i_ECParameters,x) ++ ++# ifndef __cplusplus ++# if defined(__SUNPRO_C) ++# if __SUNPRO_C >= 0x520 ++# pragma error_messages (default,E_ARRAY_OF_INCOMPLETE_NONAME,E_ARRAY_OF_INCOMPLETE) ++# endif ++# endif ++# endif ++ ++# define EVP_PKEY_CTX_set_ec_paramgen_curve_nid(ctx, nid) \ ++ EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_EC, \ ++ EVP_PKEY_OP_PARAMGEN|EVP_PKEY_OP_KEYGEN, \ ++ EVP_PKEY_CTRL_EC_PARAMGEN_CURVE_NID, nid, NULL) ++ ++# define EVP_PKEY_CTX_set_ec_param_enc(ctx, flag) \ ++ EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_EC, \ ++ EVP_PKEY_OP_PARAMGEN|EVP_PKEY_OP_KEYGEN, \ ++ EVP_PKEY_CTRL_EC_PARAM_ENC, flag, NULL) ++ ++# define EVP_PKEY_CTX_set_ecdh_cofactor_mode(ctx, flag) \ ++ EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_EC, \ ++ EVP_PKEY_OP_DERIVE, \ ++ EVP_PKEY_CTRL_EC_ECDH_COFACTOR, flag, NULL) ++ ++# define EVP_PKEY_CTX_get_ecdh_cofactor_mode(ctx) \ ++ EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_EC, \ ++ EVP_PKEY_OP_DERIVE, \ ++ EVP_PKEY_CTRL_EC_ECDH_COFACTOR, -2, NULL) ++ ++# define EVP_PKEY_CTX_set_ecdh_kdf_type(ctx, kdf) \ ++ EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_EC, \ ++ EVP_PKEY_OP_DERIVE, \ ++ EVP_PKEY_CTRL_EC_KDF_TYPE, kdf, NULL) ++ ++# define EVP_PKEY_CTX_get_ecdh_kdf_type(ctx) \ ++ EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_EC, \ ++ EVP_PKEY_OP_DERIVE, \ ++ EVP_PKEY_CTRL_EC_KDF_TYPE, -2, NULL) ++ ++# define EVP_PKEY_CTX_set_ecdh_kdf_md(ctx, md) \ ++ EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_EC, \ ++ EVP_PKEY_OP_DERIVE, \ ++ EVP_PKEY_CTRL_EC_KDF_MD, 0, (void *)(md)) ++ ++# define EVP_PKEY_CTX_get_ecdh_kdf_md(ctx, pmd) \ ++ EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_EC, \ ++ EVP_PKEY_OP_DERIVE, \ ++ EVP_PKEY_CTRL_GET_EC_KDF_MD, 0, (void *)(pmd)) ++ ++# define EVP_PKEY_CTX_set_ecdh_kdf_outlen(ctx, len) \ ++ EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_EC, \ ++ EVP_PKEY_OP_DERIVE, \ ++ EVP_PKEY_CTRL_EC_KDF_OUTLEN, len, NULL) ++ ++# define EVP_PKEY_CTX_get_ecdh_kdf_outlen(ctx, plen) \ ++ EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_EC, \ ++ EVP_PKEY_OP_DERIVE, \ ++ EVP_PKEY_CTRL_GET_EC_KDF_OUTLEN, 0, \ ++ (void *)(plen)) ++ ++# define EVP_PKEY_CTX_set0_ecdh_kdf_ukm(ctx, p, plen) \ ++ EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_EC, \ ++ EVP_PKEY_OP_DERIVE, \ ++ EVP_PKEY_CTRL_EC_KDF_UKM, plen, (void *)(p)) ++ ++# define EVP_PKEY_CTX_get0_ecdh_kdf_ukm(ctx, p) \ ++ EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_EC, \ ++ EVP_PKEY_OP_DERIVE, \ ++ EVP_PKEY_CTRL_GET_EC_KDF_UKM, 0, (void *)(p)) ++ ++/* SM2 will skip the operation check so no need to pass operation here */ ++# define EVP_PKEY_CTX_set1_id(ctx, id, id_len) \ ++ EVP_PKEY_CTX_ctrl(ctx, -1, -1, \ ++ EVP_PKEY_CTRL_SET1_ID, (int)id_len, (void*)(id)) ++ ++# define EVP_PKEY_CTX_get1_id(ctx, id) \ ++ EVP_PKEY_CTX_ctrl(ctx, -1, -1, \ ++ EVP_PKEY_CTRL_GET1_ID, 0, (void*)(id)) ++ ++# define EVP_PKEY_CTX_get1_id_len(ctx, id_len) \ ++ EVP_PKEY_CTX_ctrl(ctx, -1, -1, \ ++ EVP_PKEY_CTRL_GET1_ID_LEN, 0, (void*)(id_len)) ++ ++# define EVP_PKEY_CTRL_EC_PARAMGEN_CURVE_NID (EVP_PKEY_ALG_CTRL + 1) ++# define EVP_PKEY_CTRL_EC_PARAM_ENC (EVP_PKEY_ALG_CTRL + 2) ++# define EVP_PKEY_CTRL_EC_ECDH_COFACTOR (EVP_PKEY_ALG_CTRL + 3) ++# define EVP_PKEY_CTRL_EC_KDF_TYPE (EVP_PKEY_ALG_CTRL + 4) ++# define EVP_PKEY_CTRL_EC_KDF_MD (EVP_PKEY_ALG_CTRL + 5) ++# define EVP_PKEY_CTRL_GET_EC_KDF_MD (EVP_PKEY_ALG_CTRL + 6) ++# define EVP_PKEY_CTRL_EC_KDF_OUTLEN (EVP_PKEY_ALG_CTRL + 7) ++# define EVP_PKEY_CTRL_GET_EC_KDF_OUTLEN (EVP_PKEY_ALG_CTRL + 8) ++# define EVP_PKEY_CTRL_EC_KDF_UKM (EVP_PKEY_ALG_CTRL + 9) ++# define EVP_PKEY_CTRL_GET_EC_KDF_UKM (EVP_PKEY_ALG_CTRL + 10) ++# define EVP_PKEY_CTRL_SET1_ID (EVP_PKEY_ALG_CTRL + 11) ++# define EVP_PKEY_CTRL_GET1_ID (EVP_PKEY_ALG_CTRL + 12) ++# define EVP_PKEY_CTRL_GET1_ID_LEN (EVP_PKEY_ALG_CTRL + 13) ++/* KDF types */ ++# define EVP_PKEY_ECDH_KDF_NONE 1 ++# define EVP_PKEY_ECDH_KDF_X9_63 2 ++/** The old name for EVP_PKEY_ECDH_KDF_X9_63 ++ * The ECDH KDF specification has been mistakingly attributed to ANSI X9.62, ++ * it is actually specified in ANSI X9.63. ++ * This identifier is retained for backwards compatibility ++ */ ++# define EVP_PKEY_ECDH_KDF_X9_62 EVP_PKEY_ECDH_KDF_X9_63 ++ ++# ifdef __cplusplus ++} ++# endif ++# endif ++#endif +diff --git a/include/TA/openssl/openssl/ecdsa.h b/include/TA/openssl/openssl/ecdsa.h +new file mode 100644 +index 0000000..a9aeb7c +--- /dev/null ++++ b/include/TA/openssl/openssl/ecdsa.h +@@ -0,0 +1,19 @@ ++/* ++ * Copyright 2002-2016 The OpenSSL Project Authors. All Rights Reserved. ++ * ++ * Licensed under the OpenSSL license (the "License"). You may not use ++ * this file except in compliance with the License. You can obtain a copy ++ * in the file LICENSE in the source distribution or at ++ * https://www.openssl.org/source/license.html ++ */ ++ ++#ifndef ECDSA_H ++# define ECDSA_H ++#include ++ ++#ifndef OPENSSL_NO_FIPS ++#define ECDSA_VERIFY_SIG_MIN_KEY_SIZE 160 ++#define ECDSA_SIGN_SIG_MIN_KEY_SIZE 224 ++#endif ++ ++#endif // ECDSA_H +diff --git a/include/TA/openssl/openssl/ecerr.h b/include/TA/openssl/openssl/ecerr.h +new file mode 100644 +index 0000000..a796d22 +--- /dev/null ++++ b/include/TA/openssl/openssl/ecerr.h +@@ -0,0 +1,282 @@ ++/* ++ * Generated by util/mkerr.pl DO NOT EDIT ++ * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved. ++ * ++ * Licensed under the OpenSSL license (the "License"). You may not use ++ * this file except in compliance with the License. You can obtain a copy ++ * in the file LICENSE in the source distribution or at ++ * https://www.openssl.org/source/license.html ++ */ ++ ++#ifndef HEADER_ECERR_H ++# define HEADER_ECERR_H ++ ++# ifndef HEADER_SYMHACKS_H ++# include ++# endif ++ ++# include ++ ++# ifndef OPENSSL_NO_EC ++ ++# ifdef __cplusplus ++extern "C" ++# endif ++int ERR_load_EC_strings(void); ++ ++/* ++ * EC function codes. ++ */ ++# define EC_F_BN_TO_FELEM 224 ++# define EC_F_D2I_ECPARAMETERS 144 ++# define EC_F_D2I_ECPKPARAMETERS 145 ++# define EC_F_D2I_ECPRIVATEKEY 146 ++# define EC_F_DO_EC_KEY_PRINT 221 ++# define EC_F_ECDH_CMS_DECRYPT 238 ++# define EC_F_ECDH_CMS_SET_SHARED_INFO 239 ++# define EC_F_ECDH_COMPUTE_KEY 246 ++# define EC_F_ECDH_SIMPLE_COMPUTE_KEY 257 ++# define EC_F_ECDSA_DO_SIGN_EX 251 ++# define EC_F_ECDSA_DO_VERIFY 252 ++# define EC_F_ECDSA_SIGN_EX 254 ++# define EC_F_ECDSA_SIGN_SETUP 248 ++# define EC_F_ECDSA_SIG_NEW 265 ++# define EC_F_ECDSA_VERIFY 253 ++# define EC_F_ECD_ITEM_VERIFY 270 ++# define EC_F_ECKEY_PARAM2TYPE 223 ++# define EC_F_ECKEY_PARAM_DECODE 212 ++# define EC_F_ECKEY_PRIV_DECODE 213 ++# define EC_F_ECKEY_PRIV_ENCODE 214 ++# define EC_F_ECKEY_PUB_DECODE 215 ++# define EC_F_ECKEY_PUB_ENCODE 216 ++# define EC_F_ECKEY_TYPE2PARAM 220 ++# define EC_F_ECPARAMETERS_PRINT 147 ++# define EC_F_ECPARAMETERS_PRINT_FP 148 ++# define EC_F_ECPKPARAMETERS_PRINT 149 ++# define EC_F_ECPKPARAMETERS_PRINT_FP 150 ++# define EC_F_ECP_NISTZ256_GET_AFFINE 240 ++# define EC_F_ECP_NISTZ256_INV_MOD_ORD 275 ++# define EC_F_ECP_NISTZ256_MULT_PRECOMPUTE 243 ++# define EC_F_ECP_NISTZ256_POINTS_MUL 241 ++# define EC_F_ECP_NISTZ256_PRE_COMP_NEW 244 ++# define EC_F_ECP_NISTZ256_WINDOWED_MUL 242 ++# define EC_F_ECX_KEY_OP 266 ++# define EC_F_ECX_PRIV_ENCODE 267 ++# define EC_F_ECX_PUB_ENCODE 268 ++# define EC_F_EC_ASN1_GROUP2CURVE 153 ++# define EC_F_EC_ASN1_GROUP2FIELDID 154 ++# define EC_F_EC_GF2M_MONTGOMERY_POINT_MULTIPLY 208 ++# define EC_F_EC_GF2M_SIMPLE_FIELD_INV 296 ++# define EC_F_EC_GF2M_SIMPLE_GROUP_CHECK_DISCRIMINANT 159 ++# define EC_F_EC_GF2M_SIMPLE_GROUP_SET_CURVE 195 ++# define EC_F_EC_GF2M_SIMPLE_LADDER_POST 285 ++# define EC_F_EC_GF2M_SIMPLE_LADDER_PRE 288 ++# define EC_F_EC_GF2M_SIMPLE_OCT2POINT 160 ++# define EC_F_EC_GF2M_SIMPLE_POINT2OCT 161 ++# define EC_F_EC_GF2M_SIMPLE_POINTS_MUL 289 ++# define EC_F_EC_GF2M_SIMPLE_POINT_GET_AFFINE_COORDINATES 162 ++# define EC_F_EC_GF2M_SIMPLE_POINT_SET_AFFINE_COORDINATES 163 ++# define EC_F_EC_GF2M_SIMPLE_SET_COMPRESSED_COORDINATES 164 ++# define EC_F_EC_GFP_MONT_FIELD_DECODE 133 ++# define EC_F_EC_GFP_MONT_FIELD_ENCODE 134 ++# define EC_F_EC_GFP_MONT_FIELD_INV 297 ++# define EC_F_EC_GFP_MONT_FIELD_MUL 131 ++# define EC_F_EC_GFP_MONT_FIELD_SET_TO_ONE 209 ++# define EC_F_EC_GFP_MONT_FIELD_SQR 132 ++# define EC_F_EC_GFP_MONT_GROUP_SET_CURVE 189 ++# define EC_F_EC_GFP_NISTP224_GROUP_SET_CURVE 225 ++# define EC_F_EC_GFP_NISTP224_POINTS_MUL 228 ++# define EC_F_EC_GFP_NISTP224_POINT_GET_AFFINE_COORDINATES 226 ++# define EC_F_EC_GFP_NISTP256_GROUP_SET_CURVE 230 ++# define EC_F_EC_GFP_NISTP256_POINTS_MUL 231 ++# define EC_F_EC_GFP_NISTP256_POINT_GET_AFFINE_COORDINATES 232 ++# define EC_F_EC_GFP_NISTP521_GROUP_SET_CURVE 233 ++# define EC_F_EC_GFP_NISTP521_POINTS_MUL 234 ++# define EC_F_EC_GFP_NISTP521_POINT_GET_AFFINE_COORDINATES 235 ++# define EC_F_EC_GFP_NIST_FIELD_MUL 200 ++# define EC_F_EC_GFP_NIST_FIELD_SQR 201 ++# define EC_F_EC_GFP_NIST_GROUP_SET_CURVE 202 ++# define EC_F_EC_GFP_SIMPLE_BLIND_COORDINATES 287 ++# define EC_F_EC_GFP_SIMPLE_FIELD_INV 298 ++# define EC_F_EC_GFP_SIMPLE_GROUP_CHECK_DISCRIMINANT 165 ++# define EC_F_EC_GFP_SIMPLE_GROUP_SET_CURVE 166 ++# define EC_F_EC_GFP_SIMPLE_MAKE_AFFINE 102 ++# define EC_F_EC_GFP_SIMPLE_OCT2POINT 103 ++# define EC_F_EC_GFP_SIMPLE_POINT2OCT 104 ++# define EC_F_EC_GFP_SIMPLE_POINTS_MAKE_AFFINE 137 ++# define EC_F_EC_GFP_SIMPLE_POINT_GET_AFFINE_COORDINATES 167 ++# define EC_F_EC_GFP_SIMPLE_POINT_SET_AFFINE_COORDINATES 168 ++# define EC_F_EC_GFP_SIMPLE_SET_COMPRESSED_COORDINATES 169 ++# define EC_F_EC_GROUP_CHECK 170 ++# define EC_F_EC_GROUP_CHECK_DISCRIMINANT 171 ++# define EC_F_EC_GROUP_COPY 106 ++# define EC_F_EC_GROUP_GET_CURVE 291 ++# define EC_F_EC_GROUP_GET_CURVE_GF2M 172 ++# define EC_F_EC_GROUP_GET_CURVE_GFP 130 ++# define EC_F_EC_GROUP_GET_DEGREE 173 ++# define EC_F_EC_GROUP_GET_ECPARAMETERS 261 ++# define EC_F_EC_GROUP_GET_ECPKPARAMETERS 262 ++# define EC_F_EC_GROUP_GET_PENTANOMIAL_BASIS 193 ++# define EC_F_EC_GROUP_GET_TRINOMIAL_BASIS 194 ++# define EC_F_EC_GROUP_NEW 108 ++# define EC_F_EC_GROUP_NEW_BY_CURVE_NAME 174 ++# define EC_F_EC_GROUP_NEW_FROM_DATA 175 ++# define EC_F_EC_GROUP_NEW_FROM_ECPARAMETERS 263 ++# define EC_F_EC_GROUP_NEW_FROM_ECPKPARAMETERS 264 ++# define EC_F_EC_GROUP_SET_CURVE 292 ++# define EC_F_EC_GROUP_SET_CURVE_GF2M 176 ++# define EC_F_EC_GROUP_SET_CURVE_GFP 109 ++# define EC_F_EC_GROUP_SET_GENERATOR 111 ++# define EC_F_EC_GROUP_SET_SEED 286 ++# define EC_F_EC_KEY_CHECK_KEY 177 ++# define EC_F_EC_KEY_COPY 178 ++# define EC_F_EC_KEY_GENERATE_KEY 179 ++# define EC_F_EC_KEY_NEW 182 ++# define EC_F_EC_KEY_NEW_METHOD 245 ++# define EC_F_EC_KEY_OCT2PRIV 255 ++# define EC_F_EC_KEY_PRINT 180 ++# define EC_F_EC_KEY_PRINT_FP 181 ++# define EC_F_EC_KEY_PRIV2BUF 279 ++# define EC_F_EC_KEY_PRIV2OCT 256 ++# define EC_F_EC_KEY_SET_PUBLIC_KEY_AFFINE_COORDINATES 229 ++# define EC_F_EC_KEY_SIMPLE_CHECK_KEY 258 ++# define EC_F_EC_KEY_SIMPLE_OCT2PRIV 259 ++# define EC_F_EC_KEY_SIMPLE_PRIV2OCT 260 ++# define EC_F_EC_PKEY_CHECK 273 ++# define EC_F_EC_PKEY_PARAM_CHECK 274 ++# define EC_F_EC_POINTS_MAKE_AFFINE 136 ++# define EC_F_EC_POINTS_MUL 290 ++# define EC_F_EC_POINT_ADD 112 ++# define EC_F_EC_POINT_BN2POINT 280 ++# define EC_F_EC_POINT_CMP 113 ++# define EC_F_EC_POINT_COPY 114 ++# define EC_F_EC_POINT_DBL 115 ++# define EC_F_EC_POINT_GET_AFFINE_COORDINATES 293 ++# define EC_F_EC_POINT_GET_AFFINE_COORDINATES_GF2M 183 ++# define EC_F_EC_POINT_GET_AFFINE_COORDINATES_GFP 116 ++# define EC_F_EC_POINT_GET_JPROJECTIVE_COORDINATES_GFP 117 ++# define EC_F_EC_POINT_INVERT 210 ++# define EC_F_EC_POINT_IS_AT_INFINITY 118 ++# define EC_F_EC_POINT_IS_ON_CURVE 119 ++# define EC_F_EC_POINT_MAKE_AFFINE 120 ++# define EC_F_EC_POINT_NEW 121 ++# define EC_F_EC_POINT_OCT2POINT 122 ++# define EC_F_EC_POINT_POINT2BUF 281 ++# define EC_F_EC_POINT_POINT2OCT 123 ++# define EC_F_EC_POINT_SET_AFFINE_COORDINATES 294 ++# define EC_F_EC_POINT_SET_AFFINE_COORDINATES_GF2M 185 ++# define EC_F_EC_POINT_SET_AFFINE_COORDINATES_GFP 124 ++# define EC_F_EC_POINT_SET_COMPRESSED_COORDINATES 295 ++# define EC_F_EC_POINT_SET_COMPRESSED_COORDINATES_GF2M 186 ++# define EC_F_EC_POINT_SET_COMPRESSED_COORDINATES_GFP 125 ++# define EC_F_EC_POINT_SET_JPROJECTIVE_COORDINATES_GFP 126 ++# define EC_F_EC_POINT_SET_TO_INFINITY 127 ++# define EC_F_EC_PRE_COMP_NEW 196 ++# define EC_F_EC_SCALAR_MUL_LADDER 284 ++# define EC_F_EC_WNAF_MUL 187 ++# define EC_F_EC_WNAF_PRECOMPUTE_MULT 188 ++# define EC_F_I2D_ECPARAMETERS 190 ++# define EC_F_I2D_ECPKPARAMETERS 191 ++# define EC_F_I2D_ECPRIVATEKEY 192 ++# define EC_F_I2O_ECPUBLICKEY 151 ++# define EC_F_NISTP224_PRE_COMP_NEW 227 ++# define EC_F_NISTP256_PRE_COMP_NEW 236 ++# define EC_F_NISTP521_PRE_COMP_NEW 237 ++# define EC_F_O2I_ECPUBLICKEY 152 ++# define EC_F_OLD_EC_PRIV_DECODE 222 ++# define EC_F_OSSL_ECDH_COMPUTE_KEY 247 ++# define EC_F_OSSL_ECDSA_SIGN_SIG 249 ++# define EC_F_OSSL_ECDSA_VERIFY_SIG 250 ++# define EC_F_OSSL_ECDSA_SIGN_SIG_ISO_15946_2 300 ++# define EC_F_OSSL_ECDSA_VERIFY_SIG_ISO_15946_2 301 ++# define EC_F_PKEY_ECD_CTRL 271 ++# define EC_F_PKEY_ECD_DIGESTSIGN 272 ++# define EC_F_PKEY_ECD_DIGESTSIGN25519 276 ++# define EC_F_PKEY_ECD_DIGESTSIGN448 277 ++# define EC_F_PKEY_ECX_DERIVE 269 ++# define EC_F_PKEY_EC_CTRL 197 ++# define EC_F_PKEY_EC_CTRL_STR 198 ++# define EC_F_PKEY_EC_DERIVE 217 ++# define EC_F_PKEY_EC_INIT 282 ++# define EC_F_PKEY_EC_KDF_DERIVE 283 ++# define EC_F_PKEY_EC_KEYGEN 199 ++# define EC_F_PKEY_EC_PARAMGEN 219 ++# define EC_F_PKEY_EC_SIGN 218 ++# define EC_F_PKEY_EC_SM2DH_DERIVE 299 ++# define EC_F_VALIDATE_ECX_DERIVE 278 ++ ++/* ++ * EC reason codes. ++ */ ++# define EC_R_ASN1_ERROR 115 ++# define EC_R_BAD_SIGNATURE 156 ++# define EC_R_BIGNUM_OUT_OF_RANGE 144 ++# define EC_R_BUFFER_TOO_SMALL 100 ++# define EC_R_CANNOT_INVERT 165 ++# define EC_R_COORDINATES_OUT_OF_RANGE 146 ++# define EC_R_CURVE_DOES_NOT_SUPPORT_ECDH 160 ++# define EC_R_CURVE_DOES_NOT_SUPPORT_SIGNING 159 ++# define EC_R_D2I_ECPKPARAMETERS_FAILURE 117 ++# define EC_R_DECODE_ERROR 142 ++# define EC_R_DISCRIMINANT_IS_ZERO 118 ++# define EC_R_EC_GROUP_NEW_BY_NAME_FAILURE 119 ++# define EC_R_FIELD_TOO_LARGE 143 ++# define EC_R_GF2M_NOT_SUPPORTED 147 ++# define EC_R_GROUP2PKPARAMETERS_FAILURE 120 ++# define EC_R_I2D_ECPKPARAMETERS_FAILURE 121 ++# define EC_R_INCOMPATIBLE_OBJECTS 101 ++# define EC_R_INVALID_ARGUMENT 112 ++# define EC_R_INVALID_COMPRESSED_POINT 110 ++# define EC_R_INVALID_COMPRESSION_BIT 109 ++# define EC_R_INVALID_CURVE 141 ++# define EC_R_INVALID_DIGEST 151 ++# define EC_R_INVALID_DIGEST_TYPE 138 ++# define EC_R_INVALID_ENCODING 102 ++# define EC_R_INVALID_FIELD 103 ++# define EC_R_INVALID_FORM 104 ++# define EC_R_INVALID_GROUP_ORDER 122 ++# define EC_R_INVALID_KEY 116 ++# define EC_R_INVALID_OUTPUT_LENGTH 161 ++# define EC_R_INVALID_PEER_KEY 133 ++# define EC_R_INVALID_PENTANOMIAL_BASIS 132 ++# define EC_R_INVALID_PRIVATE_KEY 123 ++# define EC_R_INVALID_TRINOMIAL_BASIS 137 ++# define EC_R_KDF_PARAMETER_ERROR 148 ++# define EC_R_KEYS_NOT_SET 140 ++# define EC_R_LADDER_POST_FAILURE 136 ++# define EC_R_LADDER_PRE_FAILURE 153 ++# define EC_R_LADDER_STEP_FAILURE 162 ++# define EC_R_MISSING_OID 167 ++# define EC_R_MISSING_PARAMETERS 124 ++# define EC_R_MISSING_PRIVATE_KEY 125 ++# define EC_R_NEED_NEW_SETUP_VALUES 157 ++# define EC_R_NOT_A_NIST_PRIME 135 ++# define EC_R_NOT_IMPLEMENTED 126 ++# define EC_R_NOT_INITIALIZED 111 ++# define EC_R_NO_PARAMETERS_SET 139 ++# define EC_R_NO_PRIVATE_VALUE 154 ++# define EC_R_OPERATION_NOT_SUPPORTED 152 ++# define EC_R_PASSED_NULL_PARAMETER 134 ++# define EC_R_PEER_KEY_ERROR 149 ++# define EC_R_PKPARAMETERS2GROUP_FAILURE 127 ++# define EC_R_POINT_ARITHMETIC_FAILURE 155 ++# define EC_R_POINT_AT_INFINITY 106 ++# define EC_R_POINT_COORDINATES_BLIND_FAILURE 163 ++# define EC_R_POINT_IS_NOT_ON_CURVE 107 ++# define EC_R_RANDOM_NUMBER_GENERATION_FAILED 158 ++# define EC_R_SHARED_INFO_ERROR 150 ++# define EC_R_SLOT_FULL 108 ++# define EC_R_UNDEFINED_GENERATOR 113 ++# define EC_R_UNDEFINED_ORDER 128 ++# define EC_R_UNKNOWN_COFACTOR 164 ++# define EC_R_UNKNOWN_GROUP 129 ++# define EC_R_UNKNOWN_ORDER 114 ++# define EC_R_UNSUPPORTED_FIELD 131 ++# define EC_R_WRONG_CURVE_PARAMETERS 145 ++# define EC_R_WRONG_ORDER 130 ++#ifndef OPENSSL_NO_FIPS ++# define EC_R_KEY_SIZE_INVALID 166 ++#endif ++ ++# endif ++#endif +diff --git a/include/TA/openssl/openssl/err.h b/include/TA/openssl/openssl/err.h +new file mode 100644 +index 0000000..cd219c7 +--- /dev/null ++++ b/include/TA/openssl/openssl/err.h +@@ -0,0 +1,286 @@ ++/* ++ * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. ++ * ++ * Licensed under the OpenSSL license (the "License"). You may not use ++ * this file except in compliance with the License. You can obtain a copy ++ * in the file LICENSE in the source distribution or at ++ * https://www.openssl.org/source/license.html ++ */ ++ ++#ifndef HEADER_ERR_H ++# define HEADER_ERR_H ++ ++# include ++ ++# ifndef OPENSSL_NO_STDIO ++# include ++# include ++# endif ++ ++# include ++# include ++# include ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++# ifndef OPENSSL_NO_ERR ++# define ERR_PUT_error(a,b,c,d,e) ERR_put_error(a,b,c,d,e) ++# else ++# define ERR_PUT_error(a,b,c,d,e) ERR_put_error(a,b,c,NULL,0) ++# endif ++ ++# include ++ ++# define ERR_TXT_MALLOCED 0x01 ++# define ERR_TXT_STRING 0x02 ++ ++# define ERR_FLAG_MARK 0x01 ++# define ERR_FLAG_CLEAR 0x02 ++ ++# define ERR_NUM_ERRORS 16 ++typedef struct err_state_st { ++ int err_flags[ERR_NUM_ERRORS]; ++ unsigned long err_buffer[ERR_NUM_ERRORS]; ++ char *err_data[ERR_NUM_ERRORS]; ++ int err_data_flags[ERR_NUM_ERRORS]; ++ const char *err_file[ERR_NUM_ERRORS]; ++ int err_line[ERR_NUM_ERRORS]; ++ int top, bottom; ++} ERR_STATE; ++ ++/* library */ ++# define ERR_LIB_NONE 1 ++# define ERR_LIB_SYS 2 ++# define ERR_LIB_BN 3 ++# define ERR_LIB_RSA 4 ++# define ERR_LIB_DH 5 ++# define ERR_LIB_EVP 6 ++# define ERR_LIB_BUF 7 ++# define ERR_LIB_OBJ 8 ++# define ERR_LIB_PEM 9 ++# define ERR_LIB_DSA 10 ++# define ERR_LIB_X509 11 ++/* #define ERR_LIB_METH 12 */ ++# define ERR_LIB_ASN1 13 ++# define ERR_LIB_CONF 14 ++# define ERR_LIB_CRYPTO 15 ++# define ERR_LIB_EC 16 ++# define ERR_LIB_SSL 20 ++/* #define ERR_LIB_SSL23 21 */ ++/* #define ERR_LIB_SSL2 22 */ ++/* #define ERR_LIB_SSL3 23 */ ++/* #define ERR_LIB_RSAREF 30 */ ++/* #define ERR_LIB_PROXY 31 */ ++# define ERR_LIB_BIO 32 ++# define ERR_LIB_PKCS7 33 ++# define ERR_LIB_X509V3 34 ++# define ERR_LIB_PKCS12 35 ++# define ERR_LIB_RAND 36 ++# define ERR_LIB_DSO 37 ++# define ERR_LIB_ENGINE 38 ++# define ERR_LIB_OCSP 39 ++# define ERR_LIB_UI 40 ++# define ERR_LIB_COMP 41 ++# define ERR_LIB_ECDSA 42 ++# define ERR_LIB_ECDH 43 ++# define ERR_LIB_OSSL_STORE 44 ++# define ERR_LIB_FIPS 45 ++# define ERR_LIB_CMS 46 ++# define ERR_LIB_TS 47 ++# define ERR_LIB_HMAC 48 ++/* # define ERR_LIB_JPAKE 49 */ ++# define ERR_LIB_CT 50 ++# define ERR_LIB_ASYNC 51 ++# define ERR_LIB_KDF 52 ++# define ERR_LIB_SM2 53 ++# define ERR_LIB_CRMF 56 ++# define ERR_LIB_CMP 57 ++# define ERR_LIB_SM9 58 ++# define ERR_LIB_PQC 59 ++# define ERR_LIB_PQC_HYBRID 60 ++ ++# define ERR_LIB_USER 128 ++ ++# define SYSerr(f,r) ERR_PUT_error(ERR_LIB_SYS,(f),(r),OPENSSL_FILE,OPENSSL_LINE) ++# define BNerr(f,r) ERR_PUT_error(ERR_LIB_BN,(f),(r),OPENSSL_FILE,OPENSSL_LINE) ++# define RSAerr(f,r) ERR_PUT_error(ERR_LIB_RSA,(f),(r),OPENSSL_FILE,OPENSSL_LINE) ++# define DHerr(f,r) ERR_PUT_error(ERR_LIB_DH,(f),(r),OPENSSL_FILE,OPENSSL_LINE) ++# define EVPerr(f,r) ERR_PUT_error(ERR_LIB_EVP,(f),(r),OPENSSL_FILE,OPENSSL_LINE) ++# define BUFerr(f,r) ERR_PUT_error(ERR_LIB_BUF,(f),(r),OPENSSL_FILE,OPENSSL_LINE) ++# define OBJerr(f,r) ERR_PUT_error(ERR_LIB_OBJ,(f),(r),OPENSSL_FILE,OPENSSL_LINE) ++# define PEMerr(f,r) ERR_PUT_error(ERR_LIB_PEM,(f),(r),OPENSSL_FILE,OPENSSL_LINE) ++# define DSAerr(f,r) ERR_PUT_error(ERR_LIB_DSA,(f),(r),OPENSSL_FILE,OPENSSL_LINE) ++# define X509err(f,r) ERR_PUT_error(ERR_LIB_X509,(f),(r),OPENSSL_FILE,OPENSSL_LINE) ++# define ASN1err(f,r) ERR_PUT_error(ERR_LIB_ASN1,(f),(r),OPENSSL_FILE,OPENSSL_LINE) ++# define CONFerr(f,r) ERR_PUT_error(ERR_LIB_CONF,(f),(r),OPENSSL_FILE,OPENSSL_LINE) ++# define CRYPTOerr(f,r) ERR_PUT_error(ERR_LIB_CRYPTO,(f),(r),OPENSSL_FILE,OPENSSL_LINE) ++# define ECerr(f,r) ERR_PUT_error(ERR_LIB_EC,(f),(r),OPENSSL_FILE,OPENSSL_LINE) ++# define SSLerr(f,r) ERR_PUT_error(ERR_LIB_SSL,(f),(r),OPENSSL_FILE,OPENSSL_LINE) ++# define BIOerr(f,r) ERR_PUT_error(ERR_LIB_BIO,(f),(r),OPENSSL_FILE,OPENSSL_LINE) ++# define PKCS7err(f,r) ERR_PUT_error(ERR_LIB_PKCS7,(f),(r),OPENSSL_FILE,OPENSSL_LINE) ++# define X509V3err(f,r) ERR_PUT_error(ERR_LIB_X509V3,(f),(r),OPENSSL_FILE,OPENSSL_LINE) ++# define PKCS12err(f,r) ERR_PUT_error(ERR_LIB_PKCS12,(f),(r),OPENSSL_FILE,OPENSSL_LINE) ++# define RANDerr(f,r) ERR_PUT_error(ERR_LIB_RAND,(f),(r),OPENSSL_FILE,OPENSSL_LINE) ++# define DSOerr(f,r) ERR_PUT_error(ERR_LIB_DSO,(f),(r),OPENSSL_FILE,OPENSSL_LINE) ++# define ENGINEerr(f,r) ERR_PUT_error(ERR_LIB_ENGINE,(f),(r),OPENSSL_FILE,OPENSSL_LINE) ++# define OCSPerr(f,r) ERR_PUT_error(ERR_LIB_OCSP,(f),(r),OPENSSL_FILE,OPENSSL_LINE) ++# define UIerr(f,r) ERR_PUT_error(ERR_LIB_UI,(f),(r),OPENSSL_FILE,OPENSSL_LINE) ++# define COMPerr(f,r) ERR_PUT_error(ERR_LIB_COMP,(f),(r),OPENSSL_FILE,OPENSSL_LINE) ++# define ECDSAerr(f,r) ERR_PUT_error(ERR_LIB_ECDSA,(f),(r),OPENSSL_FILE,OPENSSL_LINE) ++# define ECDHerr(f,r) ERR_PUT_error(ERR_LIB_ECDH,(f),(r),OPENSSL_FILE,OPENSSL_LINE) ++# define OSSL_STOREerr(f,r) ERR_PUT_error(ERR_LIB_OSSL_STORE,(f),(r),OPENSSL_FILE,OPENSSL_LINE) ++# define FIPSerr(f,r) ERR_PUT_error(ERR_LIB_FIPS,(f),(r),OPENSSL_FILE,OPENSSL_LINE) ++# define CMSerr(f,r) ERR_PUT_error(ERR_LIB_CMS,(f),(r),OPENSSL_FILE,OPENSSL_LINE) ++# define CRMFerr(f,r) ERR_PUT_error(ERR_LIB_CRMF,(f),(r),OPENSSL_FILE,OPENSSL_LINE) ++# define CMPerr(f,r) ERR_PUT_error(ERR_LIB_CMP,(f),(r),OPENSSL_FILE,OPENSSL_LINE) ++# define TSerr(f,r) ERR_PUT_error(ERR_LIB_TS,(f),(r),OPENSSL_FILE,OPENSSL_LINE) ++# define HMACerr(f,r) ERR_PUT_error(ERR_LIB_HMAC,(f),(r),OPENSSL_FILE,OPENSSL_LINE) ++# define CTerr(f,r) ERR_PUT_error(ERR_LIB_CT,(f),(r),OPENSSL_FILE,OPENSSL_LINE) ++# define ASYNCerr(f,r) ERR_PUT_error(ERR_LIB_ASYNC,(f),(r),OPENSSL_FILE,OPENSSL_LINE) ++# define KDFerr(f,r) ERR_PUT_error(ERR_LIB_KDF,(f),(r),OPENSSL_FILE,OPENSSL_LINE) ++# define SM2err(f,r) ERR_PUT_error(ERR_LIB_SM2,(f),(r),OPENSSL_FILE,OPENSSL_LINE) ++# define SM9err(f,r) ERR_PUT_error(ERR_LIB_SM9,(f),(r),OPENSSL_FILE,OPENSSL_LINE) ++# define PQCerr(f,r) ERR_PUT_error(ERR_LIB_SM9,(f),(r),OPENSSL_FILE,OPENSSL_LINE) ++# define PQC_HYBRIDerr(f,r) ERR_PUT_error(ERR_LIB_SM9,(f),(r),OPENSSL_FILE,OPENSSL_LINE) ++ ++# define ERR_PACK(l,f,r) ( \ ++ (((unsigned int)(l) & 0x0FF) << 24L) | \ ++ (((unsigned int)(f) & 0xFFF) << 12L) | \ ++ (((unsigned int)(r) & 0xFFF) ) ) ++# define ERR_GET_LIB(l) (int)(((l) >> 24L) & 0x0FFL) ++# define ERR_GET_FUNC(l) (int)(((l) >> 12L) & 0xFFFL) ++# define ERR_GET_REASON(l) (int)( (l) & 0xFFFL) ++# define ERR_FATAL_ERROR(l) (int)( (l) & ERR_R_FATAL) ++ ++/* OS functions */ ++# define SYS_F_FOPEN 1 ++# define SYS_F_CONNECT 2 ++# define SYS_F_GETSERVBYNAME 3 ++# define SYS_F_SOCKET 4 ++# define SYS_F_IOCTLSOCKET 5 ++# define SYS_F_BIND 6 ++# define SYS_F_LISTEN 7 ++# define SYS_F_ACCEPT 8 ++# define SYS_F_WSASTARTUP 9/* Winsock stuff */ ++# define SYS_F_OPENDIR 10 ++# define SYS_F_FREAD 11 ++# define SYS_F_GETADDRINFO 12 ++# define SYS_F_GETNAMEINFO 13 ++# define SYS_F_SETSOCKOPT 14 ++# define SYS_F_GETSOCKOPT 15 ++# define SYS_F_GETSOCKNAME 16 ++# define SYS_F_GETHOSTBYNAME 17 ++# define SYS_F_FFLUSH 18 ++# define SYS_F_OPEN 19 ++# define SYS_F_CLOSE 20 ++# define SYS_F_IOCTL 21 ++# define SYS_F_STAT 22 ++# define SYS_F_FCNTL 23 ++# define SYS_F_FSTAT 24 ++ ++/* reasons */ ++# define ERR_R_SYS_LIB ERR_LIB_SYS/* 2 */ ++# define ERR_R_BN_LIB ERR_LIB_BN/* 3 */ ++# define ERR_R_RSA_LIB ERR_LIB_RSA/* 4 */ ++# define ERR_R_DH_LIB ERR_LIB_DH/* 5 */ ++# define ERR_R_EVP_LIB ERR_LIB_EVP/* 6 */ ++# define ERR_R_BUF_LIB ERR_LIB_BUF/* 7 */ ++# define ERR_R_OBJ_LIB ERR_LIB_OBJ/* 8 */ ++# define ERR_R_PEM_LIB ERR_LIB_PEM/* 9 */ ++# define ERR_R_DSA_LIB ERR_LIB_DSA/* 10 */ ++# define ERR_R_X509_LIB ERR_LIB_X509/* 11 */ ++# define ERR_R_ASN1_LIB ERR_LIB_ASN1/* 13 */ ++# define ERR_R_EC_LIB ERR_LIB_EC/* 16 */ ++# define ERR_R_BIO_LIB ERR_LIB_BIO/* 32 */ ++# define ERR_R_PKCS7_LIB ERR_LIB_PKCS7/* 33 */ ++# define ERR_R_X509V3_LIB ERR_LIB_X509V3/* 34 */ ++# define ERR_R_ENGINE_LIB ERR_LIB_ENGINE/* 38 */ ++# define ERR_R_UI_LIB ERR_LIB_UI/* 40 */ ++# define ERR_R_ECDSA_LIB ERR_LIB_ECDSA/* 42 */ ++# define ERR_R_OSSL_STORE_LIB ERR_LIB_OSSL_STORE/* 44 */ ++# define ERR_R_SM9_LIB ERR_LIB_SM9/* 58 */ ++# define ERR_R_PQC_HYBRID_LIB ERR_LIB_PQC_HYBRID/* 60 */ ++ ++# define ERR_R_NESTED_ASN1_ERROR 58 ++# define ERR_R_MISSING_ASN1_EOS 63 ++ ++/* fatal error */ ++# define ERR_R_FATAL 64 ++# define ERR_R_MALLOC_FAILURE (1|ERR_R_FATAL) ++# define ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED (2|ERR_R_FATAL) ++# define ERR_R_PASSED_NULL_PARAMETER (3|ERR_R_FATAL) ++# define ERR_R_INTERNAL_ERROR (4|ERR_R_FATAL) ++# define ERR_R_DISABLED (5|ERR_R_FATAL) ++# define ERR_R_INIT_FAIL (6|ERR_R_FATAL) ++# define ERR_R_PASSED_INVALID_ARGUMENT (7) ++# define ERR_R_OPERATION_FAIL (8|ERR_R_FATAL) ++ ++/* ++ * 99 is the maximum possible ERR_R_... code, higher values are reserved for ++ * the individual libraries ++ */ ++ ++typedef struct ERR_string_data_st { ++ unsigned long error; ++ const char *string; ++} ERR_STRING_DATA; ++ ++DEFINE_LHASH_OF(ERR_STRING_DATA); ++ ++void ERR_put_error(int lib, int func, int reason, const char *file, int line); ++void ERR_set_error_data(char *data, int flags); ++ ++unsigned long ERR_get_error(void); ++unsigned long ERR_get_error_line(const char **file, int *line); ++unsigned long ERR_get_error_line_data(const char **file, int *line, ++ const char **data, int *flags); ++unsigned long ERR_peek_error(void); ++unsigned long ERR_peek_error_line(const char **file, int *line); ++unsigned long ERR_peek_error_line_data(const char **file, int *line, ++ const char **data, int *flags); ++unsigned long ERR_peek_last_error(void); ++unsigned long ERR_peek_last_error_line(const char **file, int *line); ++unsigned long ERR_peek_last_error_line_data(const char **file, int *line, ++ const char **data, int *flags); ++void ERR_clear_error(void); ++char *ERR_error_string(unsigned long e, char *buf); ++void ERR_error_string_n(unsigned long e, char *buf, size_t len); ++const char *ERR_lib_error_string(unsigned long e); ++const char *ERR_func_error_string(unsigned long e); ++const char *ERR_reason_error_string(unsigned long e); ++void ERR_print_errors_cb(int (*cb) (const char *str, size_t len, void *u), ++ void *u); ++# ifndef OPENSSL_NO_STDIO ++void ERR_print_errors_fp(FILE *fp); ++# endif ++void ERR_print_errors(BIO *bp); ++void ERR_add_error_data(int num, ...); ++void ERR_add_error_vdata(int num, va_list args); ++int ERR_load_strings(int lib, ERR_STRING_DATA *str); ++int ERR_load_strings_const(const ERR_STRING_DATA *str); ++int ERR_unload_strings(int lib, ERR_STRING_DATA *str); ++int ERR_load_ERR_strings(void); ++ ++#if OPENSSL_API_COMPAT < 0x10100000L ++# define ERR_load_crypto_strings() \ ++ OPENSSL_init_crypto(OPENSSL_INIT_LOAD_CRYPTO_STRINGS, NULL) ++# define ERR_free_strings() while(0) continue ++#endif ++ ++DEPRECATEDIN_1_1_0(void ERR_remove_thread_state(void *)) ++DEPRECATEDIN_1_0_0(void ERR_remove_state(unsigned long pid)) ++ERR_STATE *ERR_get_state(void); ++ ++int ERR_get_next_error_library(void); ++ ++int ERR_set_mark(void); ++int ERR_pop_to_mark(void); ++int ERR_clear_last_mark(void); ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif +diff --git a/include/TA/openssl/openssl/evp.h b/include/TA/openssl/openssl/evp.h +new file mode 100644 +index 0000000..d6c7292 +--- /dev/null ++++ b/include/TA/openssl/openssl/evp.h +@@ -0,0 +1,1683 @@ ++/* ++ * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. ++ * ++ * Licensed under the OpenSSL license (the "License"). You may not use ++ * this file except in compliance with the License. You can obtain a copy ++ * in the file LICENSE in the source distribution or at ++ * https://www.openssl.org/source/license.html ++ */ ++ ++#ifndef HEADER_ENVELOPE_H ++# define HEADER_ENVELOPE_H ++ ++# include ++# include ++# include ++# include ++# include ++ ++# define EVP_MAX_MD_SIZE 64/* longest known is SHA512 */ ++# define EVP_MAX_KEY_LENGTH 64 ++# define EVP_MAX_IV_LENGTH 16 ++# define EVP_MAX_BLOCK_LENGTH 32 ++ ++# define PKCS5_SALT_LEN 8 ++/* Default PKCS#5 iteration count */ ++# define PKCS5_DEFAULT_ITER 2048 ++ ++# include ++ ++# define EVP_PK_RSA 0x0001 ++# define EVP_PK_DSA 0x0002 ++# define EVP_PK_DH 0x0004 ++# define EVP_PK_EC 0x0008 ++# define EVP_PKT_SIGN 0x0010 ++# define EVP_PKT_ENC 0x0020 ++# define EVP_PKT_EXCH 0x0040 ++# define EVP_PKS_RSA 0x0100 ++# define EVP_PKS_DSA 0x0200 ++# define EVP_PKS_EC 0x0400 ++ ++# define EVP_PKEY_NONE NID_undef ++# define EVP_PKEY_RSA NID_rsaEncryption ++# define EVP_PKEY_RSA2 NID_rsa ++# define EVP_PKEY_RSA_PSS NID_rsassaPss ++# define EVP_PKEY_DSA NID_dsa ++# define EVP_PKEY_DSA1 NID_dsa_2 ++# define EVP_PKEY_DSA2 NID_dsaWithSHA ++# define EVP_PKEY_DSA3 NID_dsaWithSHA1 ++# define EVP_PKEY_DSA4 NID_dsaWithSHA1_2 ++# define EVP_PKEY_DH NID_dhKeyAgreement ++# define EVP_PKEY_DHX NID_dhpublicnumber ++# define EVP_PKEY_EC NID_X9_62_id_ecPublicKey ++# define EVP_PKEY_SM2 NID_sm2 ++# define EVP_PKEY_HMAC NID_hmac ++# define EVP_PKEY_CMAC NID_cmac ++# define EVP_PKEY_SCRYPT NID_id_scrypt ++# define EVP_PKEY_TLS1_PRF NID_tls1_prf ++# define EVP_PKEY_HKDF NID_hkdf ++# define EVP_PKEY_POLY1305 NID_poly1305 ++# define EVP_PKEY_SIPHASH NID_siphash ++# define EVP_PKEY_X25519 NID_X25519 ++# define EVP_PKEY_ED25519 NID_ED25519 ++# define EVP_PKEY_X448 NID_X448 ++# define EVP_PKEY_ED448 NID_ED448 ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++# define EVP_PKEY_MO_SIGN 0x0001 ++# define EVP_PKEY_MO_VERIFY 0x0002 ++# define EVP_PKEY_MO_ENCRYPT 0x0004 ++# define EVP_PKEY_MO_DECRYPT 0x0008 ++ ++# ifndef EVP_MD ++EVP_MD *EVP_MD_meth_new(int md_type, int pkey_type); ++EVP_MD *EVP_MD_meth_dup(const EVP_MD *md); ++void EVP_MD_meth_free(EVP_MD *md); ++ ++int EVP_MD_meth_set_input_blocksize(EVP_MD *md, int blocksize); ++int EVP_MD_meth_set_result_size(EVP_MD *md, int resultsize); ++int EVP_MD_meth_set_app_datasize(EVP_MD *md, int datasize); ++int EVP_MD_meth_set_flags(EVP_MD *md, unsigned long flags); ++int EVP_MD_meth_set_init(EVP_MD *md, int (*init)(EVP_MD_CTX *ctx)); ++int EVP_MD_meth_set_update(EVP_MD *md, int (*update)(EVP_MD_CTX *ctx, ++ const void *data, ++ size_t count)); ++int EVP_MD_meth_set_final(EVP_MD *md, int (*final)(EVP_MD_CTX *ctx, ++ unsigned char *md)); ++int EVP_MD_meth_set_copy(EVP_MD *md, int (*copy)(EVP_MD_CTX *to, ++ const EVP_MD_CTX *from)); ++int EVP_MD_meth_set_cleanup(EVP_MD *md, int (*cleanup)(EVP_MD_CTX *ctx)); ++int EVP_MD_meth_set_ctrl(EVP_MD *md, int (*ctrl)(EVP_MD_CTX *ctx, int cmd, ++ int p1, void *p2)); ++ ++int EVP_MD_meth_get_input_blocksize(const EVP_MD *md); ++int EVP_MD_meth_get_result_size(const EVP_MD *md); ++int EVP_MD_meth_get_app_datasize(const EVP_MD *md); ++unsigned long EVP_MD_meth_get_flags(const EVP_MD *md); ++int (*EVP_MD_meth_get_init(const EVP_MD *md))(EVP_MD_CTX *ctx); ++int (*EVP_MD_meth_get_update(const EVP_MD *md))(EVP_MD_CTX *ctx, ++ const void *data, ++ size_t count); ++int (*EVP_MD_meth_get_final(const EVP_MD *md))(EVP_MD_CTX *ctx, ++ unsigned char *md); ++int (*EVP_MD_meth_get_copy(const EVP_MD *md))(EVP_MD_CTX *to, ++ const EVP_MD_CTX *from); ++int (*EVP_MD_meth_get_cleanup(const EVP_MD *md))(EVP_MD_CTX *ctx); ++int (*EVP_MD_meth_get_ctrl(const EVP_MD *md))(EVP_MD_CTX *ctx, int cmd, ++ int p1, void *p2); ++ ++/* digest can only handle a single block */ ++# define EVP_MD_FLAG_ONESHOT 0x0001 ++ ++/* digest is extensible-output function, XOF */ ++# define EVP_MD_FLAG_XOF 0x0002 ++ ++/* DigestAlgorithmIdentifier flags... */ ++ ++# define EVP_MD_FLAG_DIGALGID_MASK 0x0018 ++ ++/* NULL or absent parameter accepted. Use NULL */ ++ ++# define EVP_MD_FLAG_DIGALGID_NULL 0x0000 ++ ++/* NULL or absent parameter accepted. Use NULL for PKCS#1 otherwise absent */ ++ ++# define EVP_MD_FLAG_DIGALGID_ABSENT 0x0008 ++ ++/* Custom handling via ctrl */ ++ ++# define EVP_MD_FLAG_DIGALGID_CUSTOM 0x0018 ++ ++/* Note if suitable for use in FIPS mode */ ++# define EVP_MD_FLAG_FIPS 0x0400 ++ ++/* Digest ctrls */ ++ ++# define EVP_MD_CTRL_DIGALGID 0x1 ++# define EVP_MD_CTRL_MICALG 0x2 ++# define EVP_MD_CTRL_XOF_LEN 0x3 ++ ++/* Minimum Algorithm specific ctrl value */ ++ ++# define EVP_MD_CTRL_ALG_CTRL 0x1000 ++ ++# endif /* !EVP_MD */ ++ ++/* values for EVP_MD_CTX flags */ ++ ++# define EVP_MD_CTX_FLAG_ONESHOT 0x0001/* digest update will be ++ * called once only */ ++# define EVP_MD_CTX_FLAG_CLEANED 0x0002/* context has already been ++ * cleaned */ ++# define EVP_MD_CTX_FLAG_REUSE 0x0004/* Don't free up ctx->md_data ++ * in EVP_MD_CTX_reset */ ++/* ++ * FIPS and pad options are ignored in 1.0.0, definitions are here so we ++ * don't accidentally reuse the values for other purposes. ++ */ ++ ++# define EVP_MD_CTX_FLAG_NON_FIPS_ALLOW 0x0008/* Allow use of non FIPS ++ * digest in FIPS mode */ ++ ++/* ++ * The following PAD options are also currently ignored in 1.0.0, digest ++ * parameters are handled through EVP_DigestSign*() and EVP_DigestVerify*() ++ * instead. ++ */ ++# define EVP_MD_CTX_FLAG_PAD_MASK 0xF0/* RSA mode to use */ ++# define EVP_MD_CTX_FLAG_PAD_PKCS1 0x00/* PKCS#1 v1.5 mode */ ++# define EVP_MD_CTX_FLAG_PAD_X931 0x10/* X9.31 mode */ ++# define EVP_MD_CTX_FLAG_PAD_PSS 0x20/* PSS mode */ ++ ++# define EVP_MD_CTX_FLAG_NO_INIT 0x0100/* Don't initialize md_data */ ++/* ++ * Some functions such as EVP_DigestSign only finalise copies of internal ++ * contexts so additional data can be included after the finalisation call. ++ * This is inefficient if this functionality is not required: it is disabled ++ * if the following flag is set. ++ */ ++# define EVP_MD_CTX_FLAG_FINALISE 0x0200 ++/* NOTE: 0x0400 is reserved for internal usage */ ++ ++EVP_CIPHER *EVP_CIPHER_meth_new(int cipher_type, int block_size, int key_len); ++EVP_CIPHER *EVP_CIPHER_meth_dup(const EVP_CIPHER *cipher); ++void EVP_CIPHER_meth_free(EVP_CIPHER *cipher); ++ ++int EVP_CIPHER_meth_set_iv_length(EVP_CIPHER *cipher, int iv_len); ++int EVP_CIPHER_meth_set_flags(EVP_CIPHER *cipher, unsigned long flags); ++int EVP_CIPHER_meth_set_impl_ctx_size(EVP_CIPHER *cipher, int ctx_size); ++int EVP_CIPHER_meth_set_init(EVP_CIPHER *cipher, ++ int (*init) (EVP_CIPHER_CTX *ctx, ++ const unsigned char *key, ++ const unsigned char *iv, ++ int enc)); ++int EVP_CIPHER_meth_set_do_cipher(EVP_CIPHER *cipher, ++ int (*do_cipher) (EVP_CIPHER_CTX *ctx, ++ unsigned char *out, ++ const unsigned char *in, ++ size_t inl)); ++int EVP_CIPHER_meth_set_cleanup(EVP_CIPHER *cipher, ++ int (*cleanup) (EVP_CIPHER_CTX *)); ++int EVP_CIPHER_meth_set_set_asn1_params(EVP_CIPHER *cipher, ++ int (*set_asn1_parameters) (EVP_CIPHER_CTX *, ++ ASN1_TYPE *)); ++int EVP_CIPHER_meth_set_get_asn1_params(EVP_CIPHER *cipher, ++ int (*get_asn1_parameters) (EVP_CIPHER_CTX *, ++ ASN1_TYPE *)); ++int EVP_CIPHER_meth_set_ctrl(EVP_CIPHER *cipher, ++ int (*ctrl) (EVP_CIPHER_CTX *, int type, ++ int arg, void *ptr)); ++ ++int (*EVP_CIPHER_meth_get_init(const EVP_CIPHER *cipher))(EVP_CIPHER_CTX *ctx, ++ const unsigned char *key, ++ const unsigned char *iv, ++ int enc); ++int (*EVP_CIPHER_meth_get_do_cipher(const EVP_CIPHER *cipher))(EVP_CIPHER_CTX *ctx, ++ unsigned char *out, ++ const unsigned char *in, ++ size_t inl); ++int (*EVP_CIPHER_meth_get_cleanup(const EVP_CIPHER *cipher))(EVP_CIPHER_CTX *); ++int (*EVP_CIPHER_meth_get_set_asn1_params(const EVP_CIPHER *cipher))(EVP_CIPHER_CTX *, ++ ASN1_TYPE *); ++int (*EVP_CIPHER_meth_get_get_asn1_params(const EVP_CIPHER *cipher))(EVP_CIPHER_CTX *, ++ ASN1_TYPE *); ++int (*EVP_CIPHER_meth_get_ctrl(const EVP_CIPHER *cipher))(EVP_CIPHER_CTX *, ++ int type, int arg, ++ void *ptr); ++ ++/* Values for cipher flags */ ++ ++/* Modes for ciphers */ ++ ++# define EVP_CIPH_STREAM_CIPHER 0x0 ++# define EVP_CIPH_ECB_MODE 0x1 ++# define EVP_CIPH_CBC_MODE 0x2 ++# define EVP_CIPH_CFB_MODE 0x3 ++# define EVP_CIPH_OFB_MODE 0x4 ++# define EVP_CIPH_CTR_MODE 0x5 ++# define EVP_CIPH_GCM_MODE 0x6 ++# define EVP_CIPH_CCM_MODE 0x7 ++# define EVP_CIPH_XTS_MODE 0x10001 ++# define EVP_CIPH_WRAP_MODE 0x10002 ++# define EVP_CIPH_OCB_MODE 0x10003 ++# define EVP_CIPH_MODE 0xF0007 ++/* Set if variable length cipher */ ++# define EVP_CIPH_VARIABLE_LENGTH 0x8 ++/* Set if the iv handling should be done by the cipher itself */ ++# define EVP_CIPH_CUSTOM_IV 0x10 ++/* Set if the cipher's init() function should be called if key is NULL */ ++# define EVP_CIPH_ALWAYS_CALL_INIT 0x20 ++/* Call ctrl() to init cipher parameters */ ++# define EVP_CIPH_CTRL_INIT 0x40 ++/* Don't use standard key length function */ ++# define EVP_CIPH_CUSTOM_KEY_LENGTH 0x80 ++/* Don't use standard block padding */ ++# define EVP_CIPH_NO_PADDING 0x100 ++/* cipher handles random key generation */ ++# define EVP_CIPH_RAND_KEY 0x200 ++/* cipher has its own additional copying logic */ ++# define EVP_CIPH_CUSTOM_COPY 0x400 ++/* Don't use standard iv length function */ ++# define EVP_CIPH_CUSTOM_IV_LENGTH 0x800 ++/* Allow use default ASN1 get/set iv */ ++# define EVP_CIPH_FLAG_DEFAULT_ASN1 0x1000 ++/* Buffer length in bits not bytes: CFB1 mode only */ ++# define EVP_CIPH_FLAG_LENGTH_BITS 0x2000 ++/* Note if suitable for use in FIPS mode */ ++# define EVP_CIPH_FLAG_FIPS 0x4000 ++/* Allow non FIPS cipher in FIPS mode */ ++# define EVP_CIPH_FLAG_NON_FIPS_ALLOW 0x8000 ++/* ++ * Cipher handles any and all padding logic as well as finalisation. ++ */ ++# define EVP_CIPH_FLAG_CUSTOM_CIPHER 0x100000 ++# define EVP_CIPH_FLAG_AEAD_CIPHER 0x200000 ++# define EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK 0x400000 ++/* Cipher can handle pipeline operations */ ++# define EVP_CIPH_FLAG_PIPELINE 0X800000 ++ ++/* ++ * Cipher context flag to indicate we can handle wrap mode: if allowed in ++ * older applications it could overflow buffers. ++ */ ++ ++# define EVP_CIPHER_CTX_FLAG_WRAP_ALLOW 0x1 ++ ++/* ctrl() values */ ++ ++# define EVP_CTRL_INIT 0x0 ++# define EVP_CTRL_SET_KEY_LENGTH 0x1 ++# define EVP_CTRL_GET_RC2_KEY_BITS 0x2 ++# define EVP_CTRL_SET_RC2_KEY_BITS 0x3 ++# define EVP_CTRL_GET_RC5_ROUNDS 0x4 ++# define EVP_CTRL_SET_RC5_ROUNDS 0x5 ++# define EVP_CTRL_RAND_KEY 0x6 ++# define EVP_CTRL_PBE_PRF_NID 0x7 ++# define EVP_CTRL_COPY 0x8 ++# define EVP_CTRL_AEAD_SET_IVLEN 0x9 ++# define EVP_CTRL_AEAD_GET_TAG 0x10 ++# define EVP_CTRL_AEAD_SET_TAG 0x11 ++# define EVP_CTRL_AEAD_SET_IV_FIXED 0x12 ++# define EVP_CTRL_GCM_SET_IVLEN EVP_CTRL_AEAD_SET_IVLEN ++# define EVP_CTRL_GCM_GET_TAG EVP_CTRL_AEAD_GET_TAG ++# define EVP_CTRL_GCM_SET_TAG EVP_CTRL_AEAD_SET_TAG ++# define EVP_CTRL_GCM_SET_IV_FIXED EVP_CTRL_AEAD_SET_IV_FIXED ++# define EVP_CTRL_GCM_IV_GEN 0x13 ++# define EVP_CTRL_CCM_SET_IVLEN EVP_CTRL_AEAD_SET_IVLEN ++# define EVP_CTRL_CCM_GET_TAG EVP_CTRL_AEAD_GET_TAG ++# define EVP_CTRL_CCM_SET_TAG EVP_CTRL_AEAD_SET_TAG ++# define EVP_CTRL_CCM_SET_IV_FIXED EVP_CTRL_AEAD_SET_IV_FIXED ++# define EVP_CTRL_CCM_SET_L 0x14 ++# define EVP_CTRL_CCM_SET_MSGLEN 0x15 ++/* ++ * AEAD cipher deduces payload length and returns number of bytes required to ++ * store MAC and eventual padding. Subsequent call to EVP_Cipher even ++ * appends/verifies MAC. ++ */ ++# define EVP_CTRL_AEAD_TLS1_AAD 0x16 ++/* Used by composite AEAD ciphers, no-op in GCM, CCM... */ ++# define EVP_CTRL_AEAD_SET_MAC_KEY 0x17 ++/* Set the GCM invocation field, decrypt only */ ++# define EVP_CTRL_GCM_SET_IV_INV 0x18 ++ ++# define EVP_CTRL_TLS1_1_MULTIBLOCK_AAD 0x19 ++# define EVP_CTRL_TLS1_1_MULTIBLOCK_ENCRYPT 0x1a ++# define EVP_CTRL_TLS1_1_MULTIBLOCK_DECRYPT 0x1b ++# define EVP_CTRL_TLS1_1_MULTIBLOCK_MAX_BUFSIZE 0x1c ++ ++# define EVP_CTRL_SSL3_MASTER_SECRET 0x1d ++ ++/* EVP_CTRL_SET_SBOX takes the char * specifying S-boxes */ ++# define EVP_CTRL_SET_SBOX 0x1e ++/* ++ * EVP_CTRL_SBOX_USED takes a 'size_t' and 'char *', pointing at a ++ * pre-allocated buffer with specified size ++ */ ++# define EVP_CTRL_SBOX_USED 0x1f ++/* EVP_CTRL_KEY_MESH takes 'size_t' number of bytes to mesh the key after, ++ * 0 switches meshing off ++ */ ++# define EVP_CTRL_KEY_MESH 0x20 ++/* EVP_CTRL_BLOCK_PADDING_MODE takes the padding mode */ ++# define EVP_CTRL_BLOCK_PADDING_MODE 0x21 ++ ++/* Set the output buffers to use for a pipelined operation */ ++# define EVP_CTRL_SET_PIPELINE_OUTPUT_BUFS 0x22 ++/* Set the input buffers to use for a pipelined operation */ ++# define EVP_CTRL_SET_PIPELINE_INPUT_BUFS 0x23 ++/* Set the input buffer lengths to use for a pipelined operation */ ++# define EVP_CTRL_SET_PIPELINE_INPUT_LENS 0x24 ++ ++# define EVP_CTRL_GET_IVLEN 0x25 ++#ifndef OPENSSL_NO_TTO ++/* Set the input buffer lengths to use for a pipelined operation in case of TTO */ ++# define EVP_CTRL_GCM_SET_IV_INV_TTO 0x99 ++#endif ++ ++/* Padding modes */ ++#define EVP_PADDING_PKCS7 1 ++#define EVP_PADDING_ISO7816_4 2 ++#define EVP_PADDING_ANSI923 3 ++#define EVP_PADDING_ISO10126 4 ++#define EVP_PADDING_ZERO 5 ++ ++/* RFC 5246 defines additional data to be 13 bytes in length */ ++# define EVP_AEAD_TLS1_AAD_LEN 13 ++ ++typedef struct { ++ unsigned char *out; ++ const unsigned char *inp; ++ size_t len; ++ unsigned int interleave; ++} EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM; ++ ++/* GCM TLS constants */ ++/* Length of fixed part of IV derived from PRF */ ++# define EVP_GCM_TLS_FIXED_IV_LEN 4 ++/* Length of explicit part of IV part of TLS records */ ++# define EVP_GCM_TLS_EXPLICIT_IV_LEN 8 ++/* Length of tag for TLS */ ++# define EVP_GCM_TLS_TAG_LEN 16 ++ ++/* CCM TLS constants */ ++/* Length of fixed part of IV derived from PRF */ ++# define EVP_CCM_TLS_FIXED_IV_LEN 4 ++/* Length of explicit part of IV part of TLS records */ ++# define EVP_CCM_TLS_EXPLICIT_IV_LEN 8 ++/* Total length of CCM IV length for TLS */ ++# define EVP_CCM_TLS_IV_LEN 12 ++/* Length of tag for TLS */ ++# define EVP_CCM_TLS_TAG_LEN 16 ++/* Length of CCM8 tag for TLS */ ++# define EVP_CCM8_TLS_TAG_LEN 8 ++ ++/* Length of tag for TLS */ ++# define EVP_CHACHAPOLY_TLS_TAG_LEN 16 ++ ++typedef struct evp_cipher_info_st { ++ const EVP_CIPHER *cipher; ++ unsigned char iv[EVP_MAX_IV_LENGTH]; ++} EVP_CIPHER_INFO; ++ ++/* Password based encryption function */ ++typedef int (EVP_PBE_KEYGEN) (EVP_CIPHER_CTX *ctx, const char *pass, ++ int passlen, ASN1_TYPE *param, ++ const EVP_CIPHER *cipher, const EVP_MD *md, ++ int en_de); ++ ++# ifndef OPENSSL_NO_RSA ++# define EVP_PKEY_assign_RSA(pkey,rsa) EVP_PKEY_assign((pkey),EVP_PKEY_RSA,\ ++ (char *)(rsa)) ++# endif ++ ++# ifndef OPENSSL_NO_DSA ++# define EVP_PKEY_assign_DSA(pkey,dsa) EVP_PKEY_assign((pkey),EVP_PKEY_DSA,\ ++ (char *)(dsa)) ++# endif ++ ++# ifndef OPENSSL_NO_DH ++# define EVP_PKEY_assign_DH(pkey,dh) EVP_PKEY_assign((pkey),EVP_PKEY_DH,\ ++ (char *)(dh)) ++# endif ++ ++# ifndef OPENSSL_NO_EC ++# define EVP_PKEY_assign_EC_KEY(pkey,eckey) EVP_PKEY_assign((pkey),EVP_PKEY_EC,\ ++ (char *)(eckey)) ++# endif ++# ifndef OPENSSL_NO_SIPHASH ++# define EVP_PKEY_assign_SIPHASH(pkey,shkey) EVP_PKEY_assign((pkey),EVP_PKEY_SIPHASH,\ ++ (char *)(shkey)) ++# endif ++ ++# ifndef OPENSSL_NO_POLY1305 ++# define EVP_PKEY_assign_POLY1305(pkey,polykey) EVP_PKEY_assign((pkey),EVP_PKEY_POLY1305,\ ++ (char *)(polykey)) ++# endif ++ ++/* Add some extra combinations */ ++# define EVP_get_digestbynid(a) EVP_get_digestbyname(OBJ_nid2sn(a)) ++# define EVP_get_digestbyobj(a) EVP_get_digestbynid(OBJ_obj2nid(a)) ++# define EVP_get_cipherbynid(a) EVP_get_cipherbyname(OBJ_nid2sn(a)) ++# define EVP_get_cipherbyobj(a) EVP_get_cipherbynid(OBJ_obj2nid(a)) ++ ++int EVP_MD_type(const EVP_MD *md); ++# define EVP_MD_nid(e) EVP_MD_type(e) ++# define EVP_MD_name(e) OBJ_nid2sn(EVP_MD_nid(e)) ++int EVP_MD_pkey_type(const EVP_MD *md); ++int EVP_MD_size(const EVP_MD *md); ++int EVP_MD_block_size(const EVP_MD *md); ++unsigned long EVP_MD_flags(const EVP_MD *md); ++ ++const EVP_MD *EVP_MD_CTX_md(const EVP_MD_CTX *ctx); ++int (*EVP_MD_CTX_update_fn(EVP_MD_CTX *ctx))(EVP_MD_CTX *ctx, ++ const void *data, size_t count); ++void EVP_MD_CTX_set_update_fn(EVP_MD_CTX *ctx, ++ int (*update) (EVP_MD_CTX *ctx, ++ const void *data, size_t count)); ++# define EVP_MD_CTX_size(e) EVP_MD_size(EVP_MD_CTX_md(e)) ++# define EVP_MD_CTX_block_size(e) EVP_MD_block_size(EVP_MD_CTX_md(e)) ++# define EVP_MD_CTX_type(e) EVP_MD_type(EVP_MD_CTX_md(e)) ++EVP_PKEY_CTX *EVP_MD_CTX_pkey_ctx(const EVP_MD_CTX *ctx); ++void EVP_MD_CTX_set_pkey_ctx(EVP_MD_CTX *ctx, EVP_PKEY_CTX *pctx); ++void *EVP_MD_CTX_md_data(const EVP_MD_CTX *ctx); ++ ++int EVP_CIPHER_nid(const EVP_CIPHER *cipher); ++# define EVP_CIPHER_name(e) OBJ_nid2sn(EVP_CIPHER_nid(e)) ++int EVP_CIPHER_block_size(const EVP_CIPHER *cipher); ++int EVP_CIPHER_impl_ctx_size(const EVP_CIPHER *cipher); ++int EVP_CIPHER_key_length(const EVP_CIPHER *cipher); ++int EVP_CIPHER_iv_length(const EVP_CIPHER *cipher); ++unsigned long EVP_CIPHER_flags(const EVP_CIPHER *cipher); ++# define EVP_CIPHER_mode(e) (EVP_CIPHER_flags(e) & EVP_CIPH_MODE) ++ ++const EVP_CIPHER *EVP_CIPHER_CTX_cipher(const EVP_CIPHER_CTX *ctx); ++int EVP_CIPHER_CTX_encrypting(const EVP_CIPHER_CTX *ctx); ++int EVP_CIPHER_CTX_nid(const EVP_CIPHER_CTX *ctx); ++int EVP_CIPHER_CTX_block_size(const EVP_CIPHER_CTX *ctx); ++int EVP_CIPHER_CTX_key_length(const EVP_CIPHER_CTX *ctx); ++int EVP_CIPHER_CTX_iv_length(const EVP_CIPHER_CTX *ctx); ++const unsigned char *EVP_CIPHER_CTX_iv(const EVP_CIPHER_CTX *ctx); ++const unsigned char *EVP_CIPHER_CTX_original_iv(const EVP_CIPHER_CTX *ctx); ++unsigned char *EVP_CIPHER_CTX_iv_noconst(EVP_CIPHER_CTX *ctx); ++unsigned char *EVP_CIPHER_CTX_buf_noconst(EVP_CIPHER_CTX *ctx); ++int EVP_CIPHER_CTX_num(const EVP_CIPHER_CTX *ctx); ++void EVP_CIPHER_CTX_set_num(EVP_CIPHER_CTX *ctx, int num); ++int EVP_CIPHER_CTX_copy(EVP_CIPHER_CTX *out, const EVP_CIPHER_CTX *in); ++void *EVP_CIPHER_CTX_get_app_data(const EVP_CIPHER_CTX *ctx); ++void EVP_CIPHER_CTX_set_app_data(EVP_CIPHER_CTX *ctx, void *data); ++void *EVP_CIPHER_CTX_get_cipher_data(const EVP_CIPHER_CTX *ctx); ++void *EVP_CIPHER_CTX_set_cipher_data(EVP_CIPHER_CTX *ctx, void *cipher_data); ++# define EVP_CIPHER_CTX_type(c) EVP_CIPHER_type(EVP_CIPHER_CTX_cipher(c)) ++# if OPENSSL_API_COMPAT < 0x10100000L ++# define EVP_CIPHER_CTX_flags(c) EVP_CIPHER_flags(EVP_CIPHER_CTX_cipher(c)) ++# endif ++# define EVP_CIPHER_CTX_mode(c) EVP_CIPHER_mode(EVP_CIPHER_CTX_cipher(c)) ++ ++# define EVP_ENCODE_LENGTH(l) ((((l)+2)/3*4)+((l)/48+1)*2+80) ++# define EVP_DECODE_LENGTH(l) (((l)+3)/4*3+80) ++ ++# define EVP_SignInit_ex(a,b,c) EVP_DigestInit_ex(a,b,c) ++# define EVP_SignInit(a,b) EVP_DigestInit(a,b) ++# define EVP_SignUpdate(a,b,c) EVP_DigestUpdate(a,b,c) ++# define EVP_VerifyInit_ex(a,b,c) EVP_DigestInit_ex(a,b,c) ++# define EVP_VerifyInit(a,b) EVP_DigestInit(a,b) ++# define EVP_VerifyUpdate(a,b,c) EVP_DigestUpdate(a,b,c) ++# define EVP_OpenUpdate(a,b,c,d,e) EVP_DecryptUpdate(a,b,c,d,e) ++# define EVP_SealUpdate(a,b,c,d,e) EVP_EncryptUpdate(a,b,c,d,e) ++# define EVP_DigestSignUpdate(a,b,c) EVP_DigestUpdate(a,b,c) ++# define EVP_DigestVerifyUpdate(a,b,c) EVP_DigestUpdate(a,b,c) ++ ++# ifdef CONST_STRICT ++void BIO_set_md(BIO *, const EVP_MD *md); ++# else ++# define BIO_set_md(b,md) BIO_ctrl(b,BIO_C_SET_MD,0,(char *)(md)) ++# endif ++# define BIO_get_md(b,mdp) BIO_ctrl(b,BIO_C_GET_MD,0,(char *)(mdp)) ++# define BIO_get_md_ctx(b,mdcp) BIO_ctrl(b,BIO_C_GET_MD_CTX,0, \ ++ (char *)(mdcp)) ++# define BIO_set_md_ctx(b,mdcp) BIO_ctrl(b,BIO_C_SET_MD_CTX,0, \ ++ (char *)(mdcp)) ++# define BIO_get_cipher_status(b) BIO_ctrl(b,BIO_C_GET_CIPHER_STATUS,0,NULL) ++# define BIO_get_cipher_ctx(b,c_pp) BIO_ctrl(b,BIO_C_GET_CIPHER_CTX,0, \ ++ (char *)(c_pp)) ++ ++/*__owur*/ int EVP_Cipher(EVP_CIPHER_CTX *c, ++ unsigned char *out, ++ const unsigned char *in, unsigned int inl); ++ ++# define EVP_add_cipher_alias(n,alias) \ ++ OBJ_NAME_add((alias),OBJ_NAME_TYPE_CIPHER_METH|OBJ_NAME_ALIAS,(n)) ++# define EVP_add_digest_alias(n,alias) \ ++ OBJ_NAME_add((alias),OBJ_NAME_TYPE_MD_METH|OBJ_NAME_ALIAS,(n)) ++# define EVP_delete_cipher_alias(alias) \ ++ OBJ_NAME_remove(alias,OBJ_NAME_TYPE_CIPHER_METH|OBJ_NAME_ALIAS); ++# define EVP_delete_digest_alias(alias) \ ++ OBJ_NAME_remove(alias,OBJ_NAME_TYPE_MD_METH|OBJ_NAME_ALIAS); ++ ++int EVP_MD_CTX_ctrl(EVP_MD_CTX *ctx, int cmd, int p1, void *p2); ++EVP_MD_CTX *EVP_MD_CTX_new(void); ++int EVP_MD_CTX_reset(EVP_MD_CTX *ctx); ++void EVP_MD_CTX_free(EVP_MD_CTX *ctx); ++# define EVP_MD_CTX_create() EVP_MD_CTX_new() ++# define EVP_MD_CTX_init(ctx) EVP_MD_CTX_reset((ctx)) ++# define EVP_MD_CTX_destroy(ctx) EVP_MD_CTX_free((ctx)) ++__owur int EVP_MD_CTX_copy_ex(EVP_MD_CTX *out, const EVP_MD_CTX *in); ++void EVP_MD_CTX_set_flags(EVP_MD_CTX *ctx, int flags); ++void EVP_MD_CTX_clear_flags(EVP_MD_CTX *ctx, int flags); ++int EVP_MD_CTX_test_flags(const EVP_MD_CTX *ctx, int flags); ++__owur int EVP_DigestInit_ex(EVP_MD_CTX *ctx, const EVP_MD *type, ++ ENGINE *impl); ++__owur int EVP_DigestUpdate(EVP_MD_CTX *ctx, const void *d, ++ size_t cnt); ++__owur int EVP_DigestFinal_ex(EVP_MD_CTX *ctx, unsigned char *md, ++ unsigned int *s); ++__owur int EVP_Digest(const void *data, size_t count, ++ unsigned char *md, unsigned int *size, ++ const EVP_MD *type, ENGINE *impl); ++ ++__owur int EVP_MD_CTX_copy(EVP_MD_CTX *out, const EVP_MD_CTX *in); ++__owur int EVP_DigestInit(EVP_MD_CTX *ctx, const EVP_MD *type); ++__owur int EVP_DigestFinal(EVP_MD_CTX *ctx, unsigned char *md, ++ unsigned int *s); ++__owur int EVP_DigestFinalXOF(EVP_MD_CTX *ctx, unsigned char *md, ++ size_t len); ++ ++int EVP_read_pw_string(char *buf, int length, const char *prompt, int verify); ++int EVP_read_pw_string_min(char *buf, int minlen, int maxlen, ++ const char *prompt, int verify); ++void EVP_set_pw_prompt(const char *prompt); ++char *EVP_get_pw_prompt(void); ++ ++__owur int EVP_BytesToKey(const EVP_CIPHER *type, const EVP_MD *md, ++ const unsigned char *salt, ++ const unsigned char *data, int datal, int count, ++ unsigned char *key, unsigned char *iv); ++ ++void EVP_CIPHER_CTX_set_flags(EVP_CIPHER_CTX *ctx, int flags); ++void EVP_CIPHER_CTX_clear_flags(EVP_CIPHER_CTX *ctx, int flags); ++int EVP_CIPHER_CTX_test_flags(const EVP_CIPHER_CTX *ctx, int flags); ++ ++__owur int EVP_EncryptInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, ++ const unsigned char *key, const unsigned char *iv); ++/*__owur*/ int EVP_EncryptInit_ex(EVP_CIPHER_CTX *ctx, ++ const EVP_CIPHER *cipher, ENGINE *impl, ++ const unsigned char *key, ++ const unsigned char *iv); ++/*__owur*/ int EVP_EncryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, ++ int *outl, const unsigned char *in, int inl); ++/*__owur*/ int EVP_EncryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out, ++ int *outl); ++/*__owur*/ int EVP_EncryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, ++ int *outl); ++ ++__owur int EVP_DecryptInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, ++ const unsigned char *key, const unsigned char *iv); ++/*__owur*/ int EVP_DecryptInit_ex(EVP_CIPHER_CTX *ctx, ++ const EVP_CIPHER *cipher, ENGINE *impl, ++ const unsigned char *key, ++ const unsigned char *iv); ++/*__owur*/ int EVP_DecryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, ++ int *outl, const unsigned char *in, int inl); ++__owur int EVP_DecryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *outm, ++ int *outl); ++/*__owur*/ int EVP_DecryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *outm, ++ int *outl); ++ ++__owur int EVP_CipherInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, ++ const unsigned char *key, const unsigned char *iv, ++ int enc); ++/*__owur*/ int EVP_CipherInit_ex(EVP_CIPHER_CTX *ctx, ++ const EVP_CIPHER *cipher, ENGINE *impl, ++ const unsigned char *key, ++ const unsigned char *iv, int enc); ++__owur int EVP_CipherUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, ++ int *outl, const unsigned char *in, int inl); ++__owur int EVP_CipherFinal(EVP_CIPHER_CTX *ctx, unsigned char *outm, ++ int *outl); ++__owur int EVP_CipherFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *outm, ++ int *outl); ++ ++__owur int EVP_SignFinal(EVP_MD_CTX *ctx, unsigned char *md, unsigned int *s, ++ EVP_PKEY *pkey); ++ ++__owur int EVP_DigestSign(EVP_MD_CTX *ctx, unsigned char *sigret, ++ size_t *siglen, const unsigned char *tbs, ++ size_t tbslen); ++ ++__owur int EVP_VerifyFinal(EVP_MD_CTX *ctx, const unsigned char *sigbuf, ++ unsigned int siglen, EVP_PKEY *pkey); ++ ++__owur int EVP_DigestVerify(EVP_MD_CTX *ctx, const unsigned char *sigret, ++ size_t siglen, const unsigned char *tbs, ++ size_t tbslen); ++ ++/*__owur*/ int EVP_DigestSignInit(EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx, ++ const EVP_MD *type, ENGINE *e, ++ EVP_PKEY *pkey); ++__owur int EVP_DigestSignFinal(EVP_MD_CTX *ctx, unsigned char *sigret, ++ size_t *siglen); ++ ++__owur int EVP_DigestVerifyInit(EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx, ++ const EVP_MD *type, ENGINE *e, ++ EVP_PKEY *pkey); ++__owur int EVP_DigestVerifyFinal(EVP_MD_CTX *ctx, const unsigned char *sig, ++ size_t siglen); ++ ++# ifndef OPENSSL_NO_RSA ++__owur int EVP_OpenInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *type, ++ const unsigned char *ek, int ekl, ++ const unsigned char *iv, EVP_PKEY *priv); ++__owur int EVP_OpenFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl); ++ ++__owur int EVP_SealInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *type, ++ unsigned char **ek, int *ekl, unsigned char *iv, ++ EVP_PKEY **pubk, int npubk); ++__owur int EVP_SealFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl); ++# endif ++ ++EVP_ENCODE_CTX *EVP_ENCODE_CTX_new(void); ++void EVP_ENCODE_CTX_free(EVP_ENCODE_CTX *ctx); ++int EVP_ENCODE_CTX_copy(EVP_ENCODE_CTX *dctx, EVP_ENCODE_CTX *sctx); ++int EVP_ENCODE_CTX_num(EVP_ENCODE_CTX *ctx); ++void EVP_EncodeInit(EVP_ENCODE_CTX *ctx); ++int EVP_EncodeUpdate(EVP_ENCODE_CTX *ctx, unsigned char *out, int *outl, ++ const unsigned char *in, int inl); ++void EVP_EncodeFinal(EVP_ENCODE_CTX *ctx, unsigned char *out, int *outl); ++int EVP_EncodeBlock(unsigned char *t, const unsigned char *f, int n); ++ ++void EVP_DecodeInit(EVP_ENCODE_CTX *ctx); ++int EVP_DecodeUpdate(EVP_ENCODE_CTX *ctx, unsigned char *out, int *outl, ++ const unsigned char *in, int inl); ++int EVP_DecodeFinal(EVP_ENCODE_CTX *ctx, unsigned ++ char *out, int *outl); ++int EVP_DecodeBlock(unsigned char *t, const unsigned char *f, int n); ++ ++# if OPENSSL_API_COMPAT < 0x10100000L ++# define EVP_CIPHER_CTX_init(c) EVP_CIPHER_CTX_reset(c) ++# define EVP_CIPHER_CTX_cleanup(c) EVP_CIPHER_CTX_reset(c) ++# endif ++EVP_CIPHER_CTX *EVP_CIPHER_CTX_new(void); ++int EVP_CIPHER_CTX_reset(EVP_CIPHER_CTX *c); ++void EVP_CIPHER_CTX_free(EVP_CIPHER_CTX *c); ++int EVP_CIPHER_CTX_set_key_length(EVP_CIPHER_CTX *x, int keylen); ++int EVP_CIPHER_CTX_set_padding(EVP_CIPHER_CTX *c, int pad); ++int EVP_CIPHER_CTX_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr); ++int EVP_CIPHER_CTX_rand_key(EVP_CIPHER_CTX *ctx, unsigned char *key); ++ ++const BIO_METHOD *BIO_f_md(void); ++const BIO_METHOD *BIO_f_base64(void); ++const BIO_METHOD *BIO_f_cipher(void); ++const BIO_METHOD *BIO_f_reliable(void); ++__owur int BIO_set_cipher(BIO *b, const EVP_CIPHER *c, const unsigned char *k, ++ const unsigned char *i, int enc); ++ ++const EVP_MD *EVP_md_null(void); ++# ifndef OPENSSL_NO_MD2 ++const EVP_MD *EVP_md2(void); ++# endif ++# ifndef OPENSSL_NO_MD4 ++const EVP_MD *EVP_md4(void); ++# endif ++# ifndef OPENSSL_NO_MD5 ++const EVP_MD *EVP_md5(void); ++const EVP_MD *EVP_md5_sha1(void); ++# endif ++# ifndef OPENSSL_NO_BLAKE2 ++const EVP_MD *EVP_blake2b512(void); ++const EVP_MD *EVP_blake2s256(void); ++# endif ++const EVP_MD *EVP_sha1(void); ++const EVP_MD *EVP_sha224(void); ++const EVP_MD *EVP_sha256(void); ++const EVP_MD *EVP_sha384(void); ++const EVP_MD *EVP_sha512(void); ++const EVP_MD *EVP_sha512_224(void); ++const EVP_MD *EVP_sha512_256(void); ++const EVP_MD *EVP_sha3_224(void); ++const EVP_MD *EVP_sha3_256(void); ++const EVP_MD *EVP_sha3_384(void); ++const EVP_MD *EVP_sha3_512(void); ++const EVP_MD *EVP_shake128(void); ++const EVP_MD *EVP_shake256(void); ++# ifndef OPENSSL_NO_MDC2 ++const EVP_MD *EVP_mdc2(void); ++# endif ++# ifndef OPENSSL_NO_RMD160 ++const EVP_MD *EVP_ripemd160(void); ++# endif ++# ifndef OPENSSL_NO_WHIRLPOOL ++const EVP_MD *EVP_whirlpool(void); ++# endif ++# ifndef OPENSSL_NO_SM3 ++const EVP_MD *EVP_sm3(void); ++# endif ++const EVP_CIPHER *EVP_enc_null(void); /* does nothing :-) */ ++# ifndef OPENSSL_NO_DES ++const EVP_CIPHER *EVP_des_ecb(void); ++const EVP_CIPHER *EVP_des_ede(void); ++const EVP_CIPHER *EVP_des_ede3(void); ++const EVP_CIPHER *EVP_des_ede_ecb(void); ++const EVP_CIPHER *EVP_des_ede3_ecb(void); ++const EVP_CIPHER *EVP_des_cfb64(void); ++# define EVP_des_cfb EVP_des_cfb64 ++const EVP_CIPHER *EVP_des_cfb1(void); ++const EVP_CIPHER *EVP_des_cfb8(void); ++const EVP_CIPHER *EVP_des_ede_cfb64(void); ++# define EVP_des_ede_cfb EVP_des_ede_cfb64 ++const EVP_CIPHER *EVP_des_ede3_cfb64(void); ++# define EVP_des_ede3_cfb EVP_des_ede3_cfb64 ++const EVP_CIPHER *EVP_des_ede3_cfb1(void); ++const EVP_CIPHER *EVP_des_ede3_cfb8(void); ++const EVP_CIPHER *EVP_des_ofb(void); ++const EVP_CIPHER *EVP_des_ede_ofb(void); ++const EVP_CIPHER *EVP_des_ede3_ofb(void); ++const EVP_CIPHER *EVP_des_cbc(void); ++const EVP_CIPHER *EVP_des_ede_cbc(void); ++const EVP_CIPHER *EVP_des_ede3_cbc(void); ++const EVP_CIPHER *EVP_desx_cbc(void); ++const EVP_CIPHER *EVP_des_ede3_wrap(void); ++/* ++ * This should now be supported through the dev_crypto ENGINE. But also, why ++ * are rc4 and md5 declarations made here inside a "NO_DES" precompiler ++ * branch? ++ */ ++# endif ++# ifndef OPENSSL_NO_RC4 ++const EVP_CIPHER *EVP_rc4(void); ++const EVP_CIPHER *EVP_rc4_40(void); ++# ifndef OPENSSL_NO_MD5 ++const EVP_CIPHER *EVP_rc4_hmac_md5(void); ++# endif ++# endif ++# ifndef OPENSSL_NO_IDEA ++const EVP_CIPHER *EVP_idea_ecb(void); ++const EVP_CIPHER *EVP_idea_cfb64(void); ++# define EVP_idea_cfb EVP_idea_cfb64 ++const EVP_CIPHER *EVP_idea_ofb(void); ++const EVP_CIPHER *EVP_idea_cbc(void); ++# endif ++# ifndef OPENSSL_NO_RC2 ++const EVP_CIPHER *EVP_rc2_ecb(void); ++const EVP_CIPHER *EVP_rc2_cbc(void); ++const EVP_CIPHER *EVP_rc2_40_cbc(void); ++const EVP_CIPHER *EVP_rc2_64_cbc(void); ++const EVP_CIPHER *EVP_rc2_cfb64(void); ++# define EVP_rc2_cfb EVP_rc2_cfb64 ++const EVP_CIPHER *EVP_rc2_ofb(void); ++# endif ++# ifndef OPENSSL_NO_BF ++const EVP_CIPHER *EVP_bf_ecb(void); ++const EVP_CIPHER *EVP_bf_cbc(void); ++const EVP_CIPHER *EVP_bf_cfb64(void); ++# define EVP_bf_cfb EVP_bf_cfb64 ++const EVP_CIPHER *EVP_bf_ofb(void); ++# endif ++# ifndef OPENSSL_NO_CAST ++const EVP_CIPHER *EVP_cast5_ecb(void); ++const EVP_CIPHER *EVP_cast5_cbc(void); ++const EVP_CIPHER *EVP_cast5_cfb64(void); ++# define EVP_cast5_cfb EVP_cast5_cfb64 ++const EVP_CIPHER *EVP_cast5_ofb(void); ++# endif ++# ifndef OPENSSL_NO_RC5 ++const EVP_CIPHER *EVP_rc5_32_12_16_cbc(void); ++const EVP_CIPHER *EVP_rc5_32_12_16_ecb(void); ++const EVP_CIPHER *EVP_rc5_32_12_16_cfb64(void); ++# define EVP_rc5_32_12_16_cfb EVP_rc5_32_12_16_cfb64 ++const EVP_CIPHER *EVP_rc5_32_12_16_ofb(void); ++# endif ++const EVP_CIPHER *EVP_aes_128_ecb(void); ++const EVP_CIPHER *EVP_aes_128_cbc(void); ++const EVP_CIPHER *EVP_aes_128_cfb1(void); ++const EVP_CIPHER *EVP_aes_128_cfb8(void); ++const EVP_CIPHER *EVP_aes_128_cfb128(void); ++# define EVP_aes_128_cfb EVP_aes_128_cfb128 ++const EVP_CIPHER *EVP_aes_128_ofb(void); ++const EVP_CIPHER *EVP_aes_128_ctr(void); ++const EVP_CIPHER *EVP_aes_128_ccm(void); ++const EVP_CIPHER *EVP_aes_128_gcm(void); ++const EVP_CIPHER *EVP_aes_128_xts(void); ++const EVP_CIPHER *EVP_aes_128_wrap(void); ++const EVP_CIPHER *EVP_aes_128_wrap_pad(void); ++# ifndef OPENSSL_NO_OCB ++const EVP_CIPHER *EVP_aes_128_ocb(void); ++# endif ++const EVP_CIPHER *EVP_aes_192_ecb(void); ++const EVP_CIPHER *EVP_aes_192_cbc(void); ++const EVP_CIPHER *EVP_aes_192_cfb1(void); ++const EVP_CIPHER *EVP_aes_192_cfb8(void); ++const EVP_CIPHER *EVP_aes_192_cfb128(void); ++# define EVP_aes_192_cfb EVP_aes_192_cfb128 ++const EVP_CIPHER *EVP_aes_192_ofb(void); ++const EVP_CIPHER *EVP_aes_192_ctr(void); ++const EVP_CIPHER *EVP_aes_192_ccm(void); ++const EVP_CIPHER *EVP_aes_192_gcm(void); ++const EVP_CIPHER *EVP_aes_192_wrap(void); ++const EVP_CIPHER *EVP_aes_192_wrap_pad(void); ++# ifndef OPENSSL_NO_OCB ++const EVP_CIPHER *EVP_aes_192_ocb(void); ++# endif ++const EVP_CIPHER *EVP_aes_256_ecb(void); ++const EVP_CIPHER *EVP_aes_256_cbc(void); ++const EVP_CIPHER *EVP_aes_256_cfb1(void); ++const EVP_CIPHER *EVP_aes_256_cfb8(void); ++const EVP_CIPHER *EVP_aes_256_cfb128(void); ++# define EVP_aes_256_cfb EVP_aes_256_cfb128 ++const EVP_CIPHER *EVP_aes_256_ofb(void); ++const EVP_CIPHER *EVP_aes_256_ctr(void); ++const EVP_CIPHER *EVP_aes_256_ccm(void); ++const EVP_CIPHER *EVP_aes_256_gcm(void); ++const EVP_CIPHER *EVP_aes_256_xts(void); ++const EVP_CIPHER *EVP_aes_256_wrap(void); ++const EVP_CIPHER *EVP_aes_256_wrap_pad(void); ++# ifndef OPENSSL_NO_OCB ++const EVP_CIPHER *EVP_aes_256_ocb(void); ++# endif ++const EVP_CIPHER *EVP_aes_128_cbc_hmac_sha1(void); ++const EVP_CIPHER *EVP_aes_256_cbc_hmac_sha1(void); ++const EVP_CIPHER *EVP_aes_128_cbc_hmac_sha256(void); ++const EVP_CIPHER *EVP_aes_256_cbc_hmac_sha256(void); ++# ifndef OPENSSL_NO_ARIA ++const EVP_CIPHER *EVP_aria_128_ecb(void); ++const EVP_CIPHER *EVP_aria_128_cbc(void); ++const EVP_CIPHER *EVP_aria_128_cfb1(void); ++const EVP_CIPHER *EVP_aria_128_cfb8(void); ++const EVP_CIPHER *EVP_aria_128_cfb128(void); ++# define EVP_aria_128_cfb EVP_aria_128_cfb128 ++const EVP_CIPHER *EVP_aria_128_ctr(void); ++const EVP_CIPHER *EVP_aria_128_ofb(void); ++const EVP_CIPHER *EVP_aria_128_gcm(void); ++const EVP_CIPHER *EVP_aria_128_ccm(void); ++const EVP_CIPHER *EVP_aria_192_ecb(void); ++const EVP_CIPHER *EVP_aria_192_cbc(void); ++const EVP_CIPHER *EVP_aria_192_cfb1(void); ++const EVP_CIPHER *EVP_aria_192_cfb8(void); ++const EVP_CIPHER *EVP_aria_192_cfb128(void); ++# define EVP_aria_192_cfb EVP_aria_192_cfb128 ++const EVP_CIPHER *EVP_aria_192_ctr(void); ++const EVP_CIPHER *EVP_aria_192_ofb(void); ++const EVP_CIPHER *EVP_aria_192_gcm(void); ++const EVP_CIPHER *EVP_aria_192_ccm(void); ++const EVP_CIPHER *EVP_aria_256_ecb(void); ++const EVP_CIPHER *EVP_aria_256_cbc(void); ++const EVP_CIPHER *EVP_aria_256_cfb1(void); ++const EVP_CIPHER *EVP_aria_256_cfb8(void); ++const EVP_CIPHER *EVP_aria_256_cfb128(void); ++# define EVP_aria_256_cfb EVP_aria_256_cfb128 ++const EVP_CIPHER *EVP_aria_256_ctr(void); ++const EVP_CIPHER *EVP_aria_256_ofb(void); ++const EVP_CIPHER *EVP_aria_256_gcm(void); ++const EVP_CIPHER *EVP_aria_256_ccm(void); ++# endif ++# ifndef OPENSSL_NO_CAMELLIA ++const EVP_CIPHER *EVP_camellia_128_ecb(void); ++const EVP_CIPHER *EVP_camellia_128_cbc(void); ++const EVP_CIPHER *EVP_camellia_128_cfb1(void); ++const EVP_CIPHER *EVP_camellia_128_cfb8(void); ++const EVP_CIPHER *EVP_camellia_128_cfb128(void); ++# define EVP_camellia_128_cfb EVP_camellia_128_cfb128 ++const EVP_CIPHER *EVP_camellia_128_ofb(void); ++const EVP_CIPHER *EVP_camellia_128_ctr(void); ++const EVP_CIPHER *EVP_camellia_192_ecb(void); ++const EVP_CIPHER *EVP_camellia_192_cbc(void); ++const EVP_CIPHER *EVP_camellia_192_cfb1(void); ++const EVP_CIPHER *EVP_camellia_192_cfb8(void); ++const EVP_CIPHER *EVP_camellia_192_cfb128(void); ++# define EVP_camellia_192_cfb EVP_camellia_192_cfb128 ++const EVP_CIPHER *EVP_camellia_192_ofb(void); ++const EVP_CIPHER *EVP_camellia_192_ctr(void); ++const EVP_CIPHER *EVP_camellia_256_ecb(void); ++const EVP_CIPHER *EVP_camellia_256_cbc(void); ++const EVP_CIPHER *EVP_camellia_256_cfb1(void); ++const EVP_CIPHER *EVP_camellia_256_cfb8(void); ++const EVP_CIPHER *EVP_camellia_256_cfb128(void); ++# define EVP_camellia_256_cfb EVP_camellia_256_cfb128 ++const EVP_CIPHER *EVP_camellia_256_ofb(void); ++const EVP_CIPHER *EVP_camellia_256_ctr(void); ++# endif ++# ifndef OPENSSL_NO_CHACHA ++const EVP_CIPHER *EVP_chacha20(void); ++# ifndef OPENSSL_NO_POLY1305 ++const EVP_CIPHER *EVP_chacha20_poly1305(void); ++# endif ++# endif ++ ++# ifndef OPENSSL_NO_SEED ++const EVP_CIPHER *EVP_seed_ecb(void); ++const EVP_CIPHER *EVP_seed_cbc(void); ++const EVP_CIPHER *EVP_seed_cfb128(void); ++# define EVP_seed_cfb EVP_seed_cfb128 ++const EVP_CIPHER *EVP_seed_ofb(void); ++# endif ++ ++# ifndef OPENSSL_NO_SM4 ++const EVP_CIPHER *EVP_sm4_ecb(void); ++const EVP_CIPHER *EVP_sm4_cbc(void); ++const EVP_CIPHER *EVP_sm4_cfb128(void); ++# define EVP_sm4_cfb EVP_sm4_cfb128 ++const EVP_CIPHER *EVP_sm4_ofb(void); ++const EVP_CIPHER *EVP_sm4_ctr(void); ++const EVP_CIPHER *EVP_sm4_gcm(void); ++#ifndef OPENSSL_NO_SM4_XTS ++const EVP_CIPHER *EVP_sm4_xts(void); ++# endif ++# endif ++ ++# if OPENSSL_API_COMPAT < 0x10100000L ++# define OPENSSL_add_all_algorithms_conf() \ ++ OPENSSL_init_crypto(OPENSSL_INIT_ADD_ALL_CIPHERS \ ++ | OPENSSL_INIT_ADD_ALL_DIGESTS \ ++ | OPENSSL_INIT_LOAD_CONFIG, NULL) ++# define OPENSSL_add_all_algorithms_noconf() \ ++ OPENSSL_init_crypto(OPENSSL_INIT_ADD_ALL_CIPHERS \ ++ | OPENSSL_INIT_ADD_ALL_DIGESTS, NULL) ++ ++# ifdef OPENSSL_LOAD_CONF ++# define OpenSSL_add_all_algorithms() OPENSSL_add_all_algorithms_conf() ++# else ++# define OpenSSL_add_all_algorithms() OPENSSL_add_all_algorithms_noconf() ++# endif ++ ++# define OpenSSL_add_all_ciphers() \ ++ OPENSSL_init_crypto(OPENSSL_INIT_ADD_ALL_CIPHERS, NULL) ++# define OpenSSL_add_all_digests() \ ++ OPENSSL_init_crypto(OPENSSL_INIT_ADD_ALL_DIGESTS, NULL) ++ ++# define EVP_cleanup() while(0) continue ++# endif ++ ++int EVP_add_cipher(const EVP_CIPHER *cipher); ++int EVP_add_digest(const EVP_MD *digest); ++ ++const EVP_CIPHER *EVP_get_cipherbyname(const char *name); ++const EVP_MD *EVP_get_digestbyname(const char *name); ++ ++void EVP_CIPHER_do_all(void (*fn) (const EVP_CIPHER *ciph, ++ const char *from, const char *to, void *x), ++ void *arg); ++void EVP_CIPHER_do_all_sorted(void (*fn) ++ (const EVP_CIPHER *ciph, const char *from, ++ const char *to, void *x), void *arg); ++ ++void EVP_MD_do_all(void (*fn) (const EVP_MD *ciph, ++ const char *from, const char *to, void *x), ++ void *arg); ++void EVP_MD_do_all_sorted(void (*fn) ++ (const EVP_MD *ciph, const char *from, ++ const char *to, void *x), void *arg); ++ ++int EVP_PKEY_decrypt_old(unsigned char *dec_key, ++ const unsigned char *enc_key, int enc_key_len, ++ EVP_PKEY *private_key); ++int EVP_PKEY_encrypt_old(unsigned char *enc_key, ++ const unsigned char *key, int key_len, ++ EVP_PKEY *pub_key); ++int EVP_PKEY_type(int type); ++int EVP_PKEY_id(const EVP_PKEY *pkey); ++int EVP_PKEY_base_id(const EVP_PKEY *pkey); ++int EVP_PKEY_bits(const EVP_PKEY *pkey); ++int EVP_PKEY_security_bits(const EVP_PKEY *pkey); ++int EVP_PKEY_size(const EVP_PKEY *pkey); ++int EVP_PKEY_set_type(EVP_PKEY *pkey, int type); ++int EVP_PKEY_set_type_str(EVP_PKEY *pkey, const char *str, int len); ++int EVP_PKEY_set_alias_type(EVP_PKEY *pkey, int type); ++# ifndef OPENSSL_NO_ENGINE ++int EVP_PKEY_set1_engine(EVP_PKEY *pkey, ENGINE *e); ++ENGINE *EVP_PKEY_get0_engine(const EVP_PKEY *pkey); ++# endif ++int EVP_PKEY_assign(EVP_PKEY *pkey, int type, void *key); ++void *EVP_PKEY_get0(const EVP_PKEY *pkey); ++const unsigned char *EVP_PKEY_get0_hmac(const EVP_PKEY *pkey, size_t *len); ++# ifndef OPENSSL_NO_POLY1305 ++const unsigned char *EVP_PKEY_get0_poly1305(const EVP_PKEY *pkey, size_t *len); ++# endif ++# ifndef OPENSSL_NO_SIPHASH ++const unsigned char *EVP_PKEY_get0_siphash(const EVP_PKEY *pkey, size_t *len); ++# endif ++ ++# ifndef OPENSSL_NO_RSA ++struct rsa_st; ++int EVP_PKEY_set1_RSA(EVP_PKEY *pkey, struct rsa_st *key); ++struct rsa_st *EVP_PKEY_get0_RSA(EVP_PKEY *pkey); ++struct rsa_st *EVP_PKEY_get1_RSA(EVP_PKEY *pkey); ++# endif ++# ifndef OPENSSL_NO_DSA ++struct dsa_st; ++int EVP_PKEY_set1_DSA(EVP_PKEY *pkey, struct dsa_st *key); ++struct dsa_st *EVP_PKEY_get0_DSA(EVP_PKEY *pkey); ++struct dsa_st *EVP_PKEY_get1_DSA(EVP_PKEY *pkey); ++# endif ++# ifndef OPENSSL_NO_DH ++struct dh_st; ++int EVP_PKEY_set1_DH(EVP_PKEY *pkey, struct dh_st *key); ++struct dh_st *EVP_PKEY_get0_DH(EVP_PKEY *pkey); ++struct dh_st *EVP_PKEY_get1_DH(EVP_PKEY *pkey); ++# endif ++# ifndef OPENSSL_NO_EC ++struct ec_key_st; ++int EVP_PKEY_set1_EC_KEY(EVP_PKEY *pkey, struct ec_key_st *key); ++struct ec_key_st *EVP_PKEY_get0_EC_KEY(EVP_PKEY *pkey); ++struct ec_key_st *EVP_PKEY_get1_EC_KEY(EVP_PKEY *pkey); ++# endif ++ ++EVP_PKEY *EVP_PKEY_new(void); ++int EVP_PKEY_up_ref(EVP_PKEY *pkey); ++void EVP_PKEY_free(EVP_PKEY *pkey); ++ ++EVP_PKEY *d2i_PublicKey(int type, EVP_PKEY **a, const unsigned char **pp, ++ long length); ++int i2d_PublicKey(EVP_PKEY *a, unsigned char **pp); ++ ++EVP_PKEY *d2i_PrivateKey(int type, EVP_PKEY **a, const unsigned char **pp, ++ long length); ++EVP_PKEY *d2i_AutoPrivateKey(EVP_PKEY **a, const unsigned char **pp, ++ long length); ++int i2d_PrivateKey(EVP_PKEY *a, unsigned char **pp); ++ ++int EVP_PKEY_copy_parameters(EVP_PKEY *to, const EVP_PKEY *from); ++int EVP_PKEY_missing_parameters(const EVP_PKEY *pkey); ++int EVP_PKEY_save_parameters(EVP_PKEY *pkey, int mode); ++int EVP_PKEY_cmp_parameters(const EVP_PKEY *a, const EVP_PKEY *b); ++ ++int EVP_PKEY_cmp(const EVP_PKEY *a, const EVP_PKEY *b); ++ ++int EVP_PKEY_print_public(BIO *out, const EVP_PKEY *pkey, ++ int indent, ASN1_PCTX *pctx); ++int EVP_PKEY_print_private(BIO *out, const EVP_PKEY *pkey, ++ int indent, ASN1_PCTX *pctx); ++int EVP_PKEY_print_params(BIO *out, const EVP_PKEY *pkey, ++ int indent, ASN1_PCTX *pctx); ++ ++int EVP_PKEY_get_default_digest_nid(EVP_PKEY *pkey, int *pnid); ++ ++int EVP_PKEY_set1_tls_encodedpoint(EVP_PKEY *pkey, ++ const unsigned char *pt, size_t ptlen); ++size_t EVP_PKEY_get1_tls_encodedpoint(EVP_PKEY *pkey, unsigned char **ppt); ++ ++int EVP_CIPHER_type(const EVP_CIPHER *ctx); ++ ++/* calls methods */ ++int EVP_CIPHER_param_to_asn1(EVP_CIPHER_CTX *c, ASN1_TYPE *type); ++int EVP_CIPHER_asn1_to_param(EVP_CIPHER_CTX *c, ASN1_TYPE *type); ++ ++/* These are used by EVP_CIPHER methods */ ++int EVP_CIPHER_set_asn1_iv(EVP_CIPHER_CTX *c, ASN1_TYPE *type); ++int EVP_CIPHER_get_asn1_iv(EVP_CIPHER_CTX *c, ASN1_TYPE *type); ++ ++/* PKCS5 password based encryption */ ++int PKCS5_PBE_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass, int passlen, ++ ASN1_TYPE *param, const EVP_CIPHER *cipher, ++ const EVP_MD *md, int en_de); ++int PKCS5_PBKDF2_HMAC_SHA1(const char *pass, int passlen, ++ const unsigned char *salt, int saltlen, int iter, ++ int keylen, unsigned char *out); ++int PKCS5_PBKDF2_HMAC(const char *pass, int passlen, ++ const unsigned char *salt, int saltlen, int iter, ++ const EVP_MD *digest, int keylen, unsigned char *out); ++int PKCS5_v2_PBE_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass, int passlen, ++ ASN1_TYPE *param, const EVP_CIPHER *cipher, ++ const EVP_MD *md, int en_de); ++ ++#ifndef OPENSSL_NO_SCRYPT ++int EVP_PBE_scrypt(const char *pass, size_t passlen, ++ const unsigned char *salt, size_t saltlen, ++ uint64_t N, uint64_t r, uint64_t p, uint64_t maxmem, ++ unsigned char *key, size_t keylen); ++ ++int PKCS5_v2_scrypt_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass, ++ int passlen, ASN1_TYPE *param, ++ const EVP_CIPHER *c, const EVP_MD *md, int en_de); ++#endif ++ ++void PKCS5_PBE_add(void); ++ ++int EVP_PBE_CipherInit(ASN1_OBJECT *pbe_obj, const char *pass, int passlen, ++ ASN1_TYPE *param, EVP_CIPHER_CTX *ctx, int en_de); ++ ++/* PBE type */ ++ ++/* Can appear as the outermost AlgorithmIdentifier */ ++# define EVP_PBE_TYPE_OUTER 0x0 ++/* Is an PRF type OID */ ++# define EVP_PBE_TYPE_PRF 0x1 ++/* Is a PKCS#5 v2.0 KDF */ ++# define EVP_PBE_TYPE_KDF 0x2 ++ ++int EVP_PBE_alg_add_type(int pbe_type, int pbe_nid, int cipher_nid, ++ int md_nid, EVP_PBE_KEYGEN *keygen); ++int EVP_PBE_alg_add(int nid, const EVP_CIPHER *cipher, const EVP_MD *md, ++ EVP_PBE_KEYGEN *keygen); ++int EVP_PBE_find(int type, int pbe_nid, int *pcnid, int *pmnid, ++ EVP_PBE_KEYGEN **pkeygen); ++void EVP_PBE_cleanup(void); ++int EVP_PBE_get(int *ptype, int *ppbe_nid, size_t num); ++ ++# define ASN1_PKEY_ALIAS 0x1 ++# define ASN1_PKEY_DYNAMIC 0x2 ++# define ASN1_PKEY_SIGPARAM_NULL 0x4 ++ ++# define ASN1_PKEY_CTRL_PKCS7_SIGN 0x1 ++# define ASN1_PKEY_CTRL_PKCS7_ENCRYPT 0x2 ++# define ASN1_PKEY_CTRL_DEFAULT_MD_NID 0x3 ++# define ASN1_PKEY_CTRL_CMS_SIGN 0x5 ++# define ASN1_PKEY_CTRL_CMS_ENVELOPE 0x7 ++# define ASN1_PKEY_CTRL_CMS_RI_TYPE 0x8 ++ ++# define ASN1_PKEY_CTRL_SET1_TLS_ENCPT 0x9 ++# define ASN1_PKEY_CTRL_GET1_TLS_ENCPT 0xa ++ ++int EVP_PKEY_asn1_get_count(void); ++const EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_get0(int idx); ++const EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_find(ENGINE **pe, int type); ++const EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_find_str(ENGINE **pe, ++ const char *str, int len); ++int EVP_PKEY_asn1_add0(const EVP_PKEY_ASN1_METHOD *ameth); ++int EVP_PKEY_asn1_add_alias(int to, int from); ++int EVP_PKEY_asn1_get0_info(int *ppkey_id, int *pkey_base_id, ++ int *ppkey_flags, const char **pinfo, ++ const char **ppem_str, ++ const EVP_PKEY_ASN1_METHOD *ameth); ++ ++const EVP_PKEY_ASN1_METHOD *EVP_PKEY_get0_asn1(const EVP_PKEY *pkey); ++EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_new(int id, int flags, ++ const char *pem_str, ++ const char *info); ++void EVP_PKEY_asn1_copy(EVP_PKEY_ASN1_METHOD *dst, ++ const EVP_PKEY_ASN1_METHOD *src); ++void EVP_PKEY_asn1_free(EVP_PKEY_ASN1_METHOD *ameth); ++void EVP_PKEY_asn1_set_public(EVP_PKEY_ASN1_METHOD *ameth, ++ int (*pub_decode) (EVP_PKEY *pk, ++ X509_PUBKEY *pub), ++ int (*pub_encode) (X509_PUBKEY *pub, ++ const EVP_PKEY *pk), ++ int (*pub_cmp) (const EVP_PKEY *a, ++ const EVP_PKEY *b), ++ int (*pub_print) (BIO *out, ++ const EVP_PKEY *pkey, ++ int indent, ASN1_PCTX *pctx), ++ int (*pkey_size) (const EVP_PKEY *pk), ++ int (*pkey_bits) (const EVP_PKEY *pk)); ++void EVP_PKEY_asn1_set_private(EVP_PKEY_ASN1_METHOD *ameth, ++ int (*priv_decode) (EVP_PKEY *pk, ++ const PKCS8_PRIV_KEY_INFO ++ *p8inf), ++ int (*priv_encode) (PKCS8_PRIV_KEY_INFO *p8, ++ const EVP_PKEY *pk), ++ int (*priv_print) (BIO *out, ++ const EVP_PKEY *pkey, ++ int indent, ++ ASN1_PCTX *pctx)); ++void EVP_PKEY_asn1_set_param(EVP_PKEY_ASN1_METHOD *ameth, ++ int (*param_decode) (EVP_PKEY *pkey, ++ const unsigned char **pder, ++ int derlen), ++ int (*param_encode) (const EVP_PKEY *pkey, ++ unsigned char **pder), ++ int (*param_missing) (const EVP_PKEY *pk), ++ int (*param_copy) (EVP_PKEY *to, ++ const EVP_PKEY *from), ++ int (*param_cmp) (const EVP_PKEY *a, ++ const EVP_PKEY *b), ++ int (*param_print) (BIO *out, ++ const EVP_PKEY *pkey, ++ int indent, ++ ASN1_PCTX *pctx)); ++ ++void EVP_PKEY_asn1_set_free(EVP_PKEY_ASN1_METHOD *ameth, ++ void (*pkey_free) (EVP_PKEY *pkey)); ++void EVP_PKEY_asn1_set_ctrl(EVP_PKEY_ASN1_METHOD *ameth, ++ int (*pkey_ctrl) (EVP_PKEY *pkey, int op, ++ long arg1, void *arg2)); ++void EVP_PKEY_asn1_set_item(EVP_PKEY_ASN1_METHOD *ameth, ++ int (*item_verify) (EVP_MD_CTX *ctx, ++ const ASN1_ITEM *it, ++ void *asn, ++ X509_ALGOR *a, ++ ASN1_BIT_STRING *sig, ++ EVP_PKEY *pkey), ++ int (*item_sign) (EVP_MD_CTX *ctx, ++ const ASN1_ITEM *it, ++ void *asn, ++ X509_ALGOR *alg1, ++ X509_ALGOR *alg2, ++ ASN1_BIT_STRING *sig)); ++ ++void EVP_PKEY_asn1_set_siginf(EVP_PKEY_ASN1_METHOD *ameth, ++ int (*siginf_set) (X509_SIG_INFO *siginf, ++ const X509_ALGOR *alg, ++ const ASN1_STRING *sig)); ++ ++void EVP_PKEY_asn1_set_check(EVP_PKEY_ASN1_METHOD *ameth, ++ int (*pkey_check) (const EVP_PKEY *pk)); ++ ++void EVP_PKEY_asn1_set_public_check(EVP_PKEY_ASN1_METHOD *ameth, ++ int (*pkey_pub_check) (const EVP_PKEY *pk)); ++ ++void EVP_PKEY_asn1_set_param_check(EVP_PKEY_ASN1_METHOD *ameth, ++ int (*pkey_param_check) (const EVP_PKEY *pk)); ++ ++void EVP_PKEY_asn1_set_set_priv_key(EVP_PKEY_ASN1_METHOD *ameth, ++ int (*set_priv_key) (EVP_PKEY *pk, ++ const unsigned char ++ *priv, ++ size_t len)); ++void EVP_PKEY_asn1_set_set_pub_key(EVP_PKEY_ASN1_METHOD *ameth, ++ int (*set_pub_key) (EVP_PKEY *pk, ++ const unsigned char *pub, ++ size_t len)); ++void EVP_PKEY_asn1_set_get_priv_key(EVP_PKEY_ASN1_METHOD *ameth, ++ int (*get_priv_key) (const EVP_PKEY *pk, ++ unsigned char *priv, ++ size_t *len)); ++void EVP_PKEY_asn1_set_get_pub_key(EVP_PKEY_ASN1_METHOD *ameth, ++ int (*get_pub_key) (const EVP_PKEY *pk, ++ unsigned char *pub, ++ size_t *len)); ++ ++void EVP_PKEY_asn1_set_security_bits(EVP_PKEY_ASN1_METHOD *ameth, ++ int (*pkey_security_bits) (const EVP_PKEY ++ *pk)); ++ ++# define EVP_PKEY_OP_UNDEFINED 0 ++# define EVP_PKEY_OP_PARAMGEN (1<<1) ++# define EVP_PKEY_OP_KEYGEN (1<<2) ++# define EVP_PKEY_OP_SIGN (1<<3) ++# define EVP_PKEY_OP_VERIFY (1<<4) ++# define EVP_PKEY_OP_VERIFYRECOVER (1<<5) ++# define EVP_PKEY_OP_SIGNCTX (1<<6) ++# define EVP_PKEY_OP_VERIFYCTX (1<<7) ++# define EVP_PKEY_OP_ENCRYPT (1<<8) ++# define EVP_PKEY_OP_DECRYPT (1<<9) ++# define EVP_PKEY_OP_DERIVE (1<<10) ++ ++# define EVP_PKEY_OP_TYPE_SIG \ ++ (EVP_PKEY_OP_SIGN | EVP_PKEY_OP_VERIFY | EVP_PKEY_OP_VERIFYRECOVER \ ++ | EVP_PKEY_OP_SIGNCTX | EVP_PKEY_OP_VERIFYCTX) ++ ++# define EVP_PKEY_OP_TYPE_CRYPT \ ++ (EVP_PKEY_OP_ENCRYPT | EVP_PKEY_OP_DECRYPT) ++ ++# define EVP_PKEY_OP_TYPE_NOGEN \ ++ (EVP_PKEY_OP_TYPE_SIG | EVP_PKEY_OP_TYPE_CRYPT | EVP_PKEY_OP_DERIVE) ++ ++# define EVP_PKEY_OP_TYPE_GEN \ ++ (EVP_PKEY_OP_PARAMGEN | EVP_PKEY_OP_KEYGEN) ++ ++# define EVP_PKEY_CTX_set_signature_md(ctx, md) \ ++ EVP_PKEY_CTX_ctrl(ctx, -1, EVP_PKEY_OP_TYPE_SIG, \ ++ EVP_PKEY_CTRL_MD, 0, (void *)(md)) ++ ++# define EVP_PKEY_CTX_get_signature_md(ctx, pmd) \ ++ EVP_PKEY_CTX_ctrl(ctx, -1, EVP_PKEY_OP_TYPE_SIG, \ ++ EVP_PKEY_CTRL_GET_MD, 0, (void *)(pmd)) ++ ++# define EVP_PKEY_CTX_set_mac_key(ctx, key, len) \ ++ EVP_PKEY_CTX_ctrl(ctx, -1, EVP_PKEY_OP_KEYGEN, \ ++ EVP_PKEY_CTRL_SET_MAC_KEY, len, (void *)(key)) ++ ++# define EVP_PKEY_CTRL_MD 1 ++# define EVP_PKEY_CTRL_PEER_KEY 2 ++ ++# define EVP_PKEY_CTRL_PKCS7_ENCRYPT 3 ++# define EVP_PKEY_CTRL_PKCS7_DECRYPT 4 ++ ++# define EVP_PKEY_CTRL_PKCS7_SIGN 5 ++ ++# define EVP_PKEY_CTRL_SET_MAC_KEY 6 ++ ++# define EVP_PKEY_CTRL_DIGESTINIT 7 ++ ++/* Used by GOST key encryption in TLS */ ++# define EVP_PKEY_CTRL_SET_IV 8 ++ ++# define EVP_PKEY_CTRL_CMS_ENCRYPT 9 ++# define EVP_PKEY_CTRL_CMS_DECRYPT 10 ++# define EVP_PKEY_CTRL_CMS_SIGN 11 ++ ++# define EVP_PKEY_CTRL_CIPHER 12 ++ ++# define EVP_PKEY_CTRL_GET_MD 13 ++ ++# define EVP_PKEY_CTRL_SET_DIGEST_SIZE 14 ++ ++# define EVP_PKEY_ALG_CTRL 0x1000 ++ ++# define EVP_PKEY_FLAG_AUTOARGLEN 2 ++/* ++ * Method handles all operations: don't assume any digest related defaults. ++ */ ++# define EVP_PKEY_FLAG_SIGCTX_CUSTOM 4 ++ ++const EVP_PKEY_METHOD *EVP_PKEY_meth_find(int type); ++EVP_PKEY_METHOD *EVP_PKEY_meth_new(int id, int flags); ++void EVP_PKEY_meth_get0_info(int *ppkey_id, int *pflags, ++ const EVP_PKEY_METHOD *meth); ++void EVP_PKEY_meth_copy(EVP_PKEY_METHOD *dst, const EVP_PKEY_METHOD *src); ++void EVP_PKEY_meth_free(EVP_PKEY_METHOD *pmeth); ++int EVP_PKEY_meth_add0(const EVP_PKEY_METHOD *pmeth); ++int EVP_PKEY_meth_remove(const EVP_PKEY_METHOD *pmeth); ++size_t EVP_PKEY_meth_get_count(void); ++const EVP_PKEY_METHOD *EVP_PKEY_meth_get0(size_t idx); ++ ++EVP_PKEY_CTX *EVP_PKEY_CTX_new(EVP_PKEY *pkey, ENGINE *e); ++EVP_PKEY_CTX *EVP_PKEY_CTX_new_id(int id, ENGINE *e); ++#ifndef OPENSSL_NO_GMTLS ++EVP_PKEY_CTX *EVP_PKEY_CTX_new_pkey_id(EVP_PKEY *pkey, int id, ENGINE *e); ++int EVP_PKEY_CTX_set_sm2_param(EVP_PKEY_CTX *pctx, EVP_MD *md, int server, ++ unsigned char *peer_id, int peerid_len, ++ unsigned char *self_id, int selfid_len, ++ EC_KEY *peer_ecdhe_key, EC_KEY *self_ecdhe_key); ++#endif ++EVP_PKEY_CTX *EVP_PKEY_CTX_dup(EVP_PKEY_CTX *ctx); ++void EVP_PKEY_CTX_free(EVP_PKEY_CTX *ctx); ++ ++int EVP_PKEY_CTX_ctrl(EVP_PKEY_CTX *ctx, int keytype, int optype, ++ int cmd, int p1, void *p2); ++int EVP_PKEY_CTX_ctrl_str(EVP_PKEY_CTX *ctx, const char *type, ++ const char *value); ++int EVP_PKEY_CTX_ctrl_uint64(EVP_PKEY_CTX *ctx, int keytype, int optype, ++ int cmd, uint64_t value); ++ ++int EVP_PKEY_CTX_str2ctrl(EVP_PKEY_CTX *ctx, int cmd, const char *str); ++int EVP_PKEY_CTX_hex2ctrl(EVP_PKEY_CTX *ctx, int cmd, const char *hex); ++ ++int EVP_PKEY_CTX_md(EVP_PKEY_CTX *ctx, int optype, int cmd, const char *md); ++ ++int EVP_PKEY_CTX_get_operation(EVP_PKEY_CTX *ctx); ++void EVP_PKEY_CTX_set0_keygen_info(EVP_PKEY_CTX *ctx, int *dat, int datlen); ++ ++EVP_PKEY *EVP_PKEY_new_mac_key(int type, ENGINE *e, ++ const unsigned char *key, int keylen); ++EVP_PKEY *EVP_PKEY_new_raw_private_key(int type, ENGINE *e, ++ const unsigned char *priv, ++ size_t len); ++EVP_PKEY *EVP_PKEY_new_raw_public_key(int type, ENGINE *e, ++ const unsigned char *pub, ++ size_t len); ++int EVP_PKEY_get_raw_private_key(const EVP_PKEY *pkey, unsigned char *priv, ++ size_t *len); ++int EVP_PKEY_get_raw_public_key(const EVP_PKEY *pkey, unsigned char *pub, ++ size_t *len); ++ ++EVP_PKEY *EVP_PKEY_new_CMAC_key(ENGINE *e, const unsigned char *priv, ++ size_t len, const EVP_CIPHER *cipher); ++ ++void EVP_PKEY_CTX_set_data(EVP_PKEY_CTX *ctx, void *data); ++void *EVP_PKEY_CTX_get_data(EVP_PKEY_CTX *ctx); ++EVP_PKEY *EVP_PKEY_CTX_get0_pkey(EVP_PKEY_CTX *ctx); ++ ++EVP_PKEY *EVP_PKEY_CTX_get0_peerkey(EVP_PKEY_CTX *ctx); ++ ++void EVP_PKEY_CTX_set_app_data(EVP_PKEY_CTX *ctx, void *data); ++void *EVP_PKEY_CTX_get_app_data(EVP_PKEY_CTX *ctx); ++ ++int EVP_PKEY_sign_init(EVP_PKEY_CTX *ctx); ++int EVP_PKEY_sign(EVP_PKEY_CTX *ctx, ++ unsigned char *sig, size_t *siglen, ++ const unsigned char *tbs, size_t tbslen); ++int EVP_PKEY_verify_init(EVP_PKEY_CTX *ctx); ++int EVP_PKEY_verify(EVP_PKEY_CTX *ctx, ++ const unsigned char *sig, size_t siglen, ++ const unsigned char *tbs, size_t tbslen); ++int EVP_PKEY_verify_recover_init(EVP_PKEY_CTX *ctx); ++int EVP_PKEY_verify_recover(EVP_PKEY_CTX *ctx, ++ unsigned char *rout, size_t *routlen, ++ const unsigned char *sig, size_t siglen); ++int EVP_PKEY_encrypt_init(EVP_PKEY_CTX *ctx); ++int EVP_PKEY_encrypt(EVP_PKEY_CTX *ctx, ++ unsigned char *out, size_t *outlen, ++ const unsigned char *in, size_t inlen); ++int EVP_PKEY_decrypt_init(EVP_PKEY_CTX *ctx); ++int EVP_PKEY_decrypt(EVP_PKEY_CTX *ctx, ++ unsigned char *out, size_t *outlen, ++ const unsigned char *in, size_t inlen); ++ ++int EVP_PKEY_derive_init(EVP_PKEY_CTX *ctx); ++int EVP_PKEY_derive_set_peer(EVP_PKEY_CTX *ctx, EVP_PKEY *peer); ++int EVP_PKEY_derive(EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen); ++ ++typedef int EVP_PKEY_gen_cb(EVP_PKEY_CTX *ctx); ++ ++int EVP_PKEY_paramgen_init(EVP_PKEY_CTX *ctx); ++int EVP_PKEY_paramgen(EVP_PKEY_CTX *ctx, EVP_PKEY **ppkey); ++int EVP_PKEY_keygen_init(EVP_PKEY_CTX *ctx); ++int EVP_PKEY_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY **ppkey); ++int EVP_PKEY_check(EVP_PKEY_CTX *ctx); ++int EVP_PKEY_public_check(EVP_PKEY_CTX *ctx); ++int EVP_PKEY_param_check(EVP_PKEY_CTX *ctx); ++ ++void EVP_PKEY_CTX_set_cb(EVP_PKEY_CTX *ctx, EVP_PKEY_gen_cb *cb); ++EVP_PKEY_gen_cb *EVP_PKEY_CTX_get_cb(EVP_PKEY_CTX *ctx); ++ ++int EVP_PKEY_CTX_get_keygen_info(EVP_PKEY_CTX *ctx, int idx); ++ ++void EVP_PKEY_meth_set_init(EVP_PKEY_METHOD *pmeth, ++ int (*init) (EVP_PKEY_CTX *ctx)); ++ ++void EVP_PKEY_meth_set_copy(EVP_PKEY_METHOD *pmeth, ++ int (*copy) (EVP_PKEY_CTX *dst, ++ EVP_PKEY_CTX *src)); ++ ++void EVP_PKEY_meth_set_cleanup(EVP_PKEY_METHOD *pmeth, ++ void (*cleanup) (EVP_PKEY_CTX *ctx)); ++ ++void EVP_PKEY_meth_set_paramgen(EVP_PKEY_METHOD *pmeth, ++ int (*paramgen_init) (EVP_PKEY_CTX *ctx), ++ int (*paramgen) (EVP_PKEY_CTX *ctx, ++ EVP_PKEY *pkey)); ++ ++void EVP_PKEY_meth_set_keygen(EVP_PKEY_METHOD *pmeth, ++ int (*keygen_init) (EVP_PKEY_CTX *ctx), ++ int (*keygen) (EVP_PKEY_CTX *ctx, ++ EVP_PKEY *pkey)); ++ ++void EVP_PKEY_meth_set_sign(EVP_PKEY_METHOD *pmeth, ++ int (*sign_init) (EVP_PKEY_CTX *ctx), ++ int (*sign) (EVP_PKEY_CTX *ctx, ++ unsigned char *sig, size_t *siglen, ++ const unsigned char *tbs, ++ size_t tbslen)); ++ ++void EVP_PKEY_meth_set_verify(EVP_PKEY_METHOD *pmeth, ++ int (*verify_init) (EVP_PKEY_CTX *ctx), ++ int (*verify) (EVP_PKEY_CTX *ctx, ++ const unsigned char *sig, ++ size_t siglen, ++ const unsigned char *tbs, ++ size_t tbslen)); ++ ++void EVP_PKEY_meth_set_verify_recover(EVP_PKEY_METHOD *pmeth, ++ int (*verify_recover_init) (EVP_PKEY_CTX ++ *ctx), ++ int (*verify_recover) (EVP_PKEY_CTX ++ *ctx, ++ unsigned char ++ *sig, ++ size_t *siglen, ++ const unsigned ++ char *tbs, ++ size_t tbslen)); ++ ++void EVP_PKEY_meth_set_signctx(EVP_PKEY_METHOD *pmeth, ++ int (*signctx_init) (EVP_PKEY_CTX *ctx, ++ EVP_MD_CTX *mctx), ++ int (*signctx) (EVP_PKEY_CTX *ctx, ++ unsigned char *sig, ++ size_t *siglen, ++ EVP_MD_CTX *mctx)); ++ ++void EVP_PKEY_meth_set_verifyctx(EVP_PKEY_METHOD *pmeth, ++ int (*verifyctx_init) (EVP_PKEY_CTX *ctx, ++ EVP_MD_CTX *mctx), ++ int (*verifyctx) (EVP_PKEY_CTX *ctx, ++ const unsigned char *sig, ++ int siglen, ++ EVP_MD_CTX *mctx)); ++ ++void EVP_PKEY_meth_set_encrypt(EVP_PKEY_METHOD *pmeth, ++ int (*encrypt_init) (EVP_PKEY_CTX *ctx), ++ int (*encryptfn) (EVP_PKEY_CTX *ctx, ++ unsigned char *out, ++ size_t *outlen, ++ const unsigned char *in, ++ size_t inlen)); ++ ++void EVP_PKEY_meth_set_decrypt(EVP_PKEY_METHOD *pmeth, ++ int (*decrypt_init) (EVP_PKEY_CTX *ctx), ++ int (*decrypt) (EVP_PKEY_CTX *ctx, ++ unsigned char *out, ++ size_t *outlen, ++ const unsigned char *in, ++ size_t inlen)); ++ ++void EVP_PKEY_meth_set_derive(EVP_PKEY_METHOD *pmeth, ++ int (*derive_init) (EVP_PKEY_CTX *ctx), ++ int (*derive) (EVP_PKEY_CTX *ctx, ++ unsigned char *key, ++ size_t *keylen)); ++ ++void EVP_PKEY_meth_set_ctrl(EVP_PKEY_METHOD *pmeth, ++ int (*ctrl) (EVP_PKEY_CTX *ctx, int type, int p1, ++ void *p2), ++ int (*ctrl_str) (EVP_PKEY_CTX *ctx, ++ const char *type, ++ const char *value)); ++ ++void EVP_PKEY_meth_set_digestsign(EVP_PKEY_METHOD *pmeth, ++ int (*digestsign) (EVP_MD_CTX *ctx, ++ unsigned char *sig, ++ size_t *siglen, ++ const unsigned char *tbs, ++ size_t tbslen)); ++ ++void EVP_PKEY_meth_set_digestverify(EVP_PKEY_METHOD *pmeth, ++ int (*digestverify) (EVP_MD_CTX *ctx, ++ const unsigned char *sig, ++ size_t siglen, ++ const unsigned char *tbs, ++ size_t tbslen)); ++ ++void EVP_PKEY_meth_set_check(EVP_PKEY_METHOD *pmeth, ++ int (*check) (EVP_PKEY *pkey)); ++ ++void EVP_PKEY_meth_set_public_check(EVP_PKEY_METHOD *pmeth, ++ int (*check) (EVP_PKEY *pkey)); ++ ++void EVP_PKEY_meth_set_param_check(EVP_PKEY_METHOD *pmeth, ++ int (*check) (EVP_PKEY *pkey)); ++ ++void EVP_PKEY_meth_set_digest_custom(EVP_PKEY_METHOD *pmeth, ++ int (*digest_custom) (EVP_PKEY_CTX *ctx, ++ EVP_MD_CTX *mctx)); ++ ++void EVP_PKEY_meth_get_init(const EVP_PKEY_METHOD *pmeth, ++ int (**pinit) (EVP_PKEY_CTX *ctx)); ++ ++void EVP_PKEY_meth_get_copy(const EVP_PKEY_METHOD *pmeth, ++ int (**pcopy) (EVP_PKEY_CTX *dst, ++ EVP_PKEY_CTX *src)); ++ ++void EVP_PKEY_meth_get_cleanup(const EVP_PKEY_METHOD *pmeth, ++ void (**pcleanup) (EVP_PKEY_CTX *ctx)); ++ ++void EVP_PKEY_meth_get_paramgen(const EVP_PKEY_METHOD *pmeth, ++ int (**pparamgen_init) (EVP_PKEY_CTX *ctx), ++ int (**pparamgen) (EVP_PKEY_CTX *ctx, ++ EVP_PKEY *pkey)); ++ ++void EVP_PKEY_meth_get_keygen(const EVP_PKEY_METHOD *pmeth, ++ int (**pkeygen_init) (EVP_PKEY_CTX *ctx), ++ int (**pkeygen) (EVP_PKEY_CTX *ctx, ++ EVP_PKEY *pkey)); ++ ++void EVP_PKEY_meth_get_sign(const EVP_PKEY_METHOD *pmeth, ++ int (**psign_init) (EVP_PKEY_CTX *ctx), ++ int (**psign) (EVP_PKEY_CTX *ctx, ++ unsigned char *sig, size_t *siglen, ++ const unsigned char *tbs, ++ size_t tbslen)); ++ ++void EVP_PKEY_meth_get_verify(const EVP_PKEY_METHOD *pmeth, ++ int (**pverify_init) (EVP_PKEY_CTX *ctx), ++ int (**pverify) (EVP_PKEY_CTX *ctx, ++ const unsigned char *sig, ++ size_t siglen, ++ const unsigned char *tbs, ++ size_t tbslen)); ++ ++void EVP_PKEY_meth_get_verify_recover(const EVP_PKEY_METHOD *pmeth, ++ int (**pverify_recover_init) (EVP_PKEY_CTX ++ *ctx), ++ int (**pverify_recover) (EVP_PKEY_CTX ++ *ctx, ++ unsigned char ++ *sig, ++ size_t *siglen, ++ const unsigned ++ char *tbs, ++ size_t tbslen)); ++ ++void EVP_PKEY_meth_get_signctx(const EVP_PKEY_METHOD *pmeth, ++ int (**psignctx_init) (EVP_PKEY_CTX *ctx, ++ EVP_MD_CTX *mctx), ++ int (**psignctx) (EVP_PKEY_CTX *ctx, ++ unsigned char *sig, ++ size_t *siglen, ++ EVP_MD_CTX *mctx)); ++ ++void EVP_PKEY_meth_get_verifyctx(const EVP_PKEY_METHOD *pmeth, ++ int (**pverifyctx_init) (EVP_PKEY_CTX *ctx, ++ EVP_MD_CTX *mctx), ++ int (**pverifyctx) (EVP_PKEY_CTX *ctx, ++ const unsigned char *sig, ++ int siglen, ++ EVP_MD_CTX *mctx)); ++ ++void EVP_PKEY_meth_get_encrypt(const EVP_PKEY_METHOD *pmeth, ++ int (**pencrypt_init) (EVP_PKEY_CTX *ctx), ++ int (**pencryptfn) (EVP_PKEY_CTX *ctx, ++ unsigned char *out, ++ size_t *outlen, ++ const unsigned char *in, ++ size_t inlen)); ++ ++void EVP_PKEY_meth_get_decrypt(const EVP_PKEY_METHOD *pmeth, ++ int (**pdecrypt_init) (EVP_PKEY_CTX *ctx), ++ int (**pdecrypt) (EVP_PKEY_CTX *ctx, ++ unsigned char *out, ++ size_t *outlen, ++ const unsigned char *in, ++ size_t inlen)); ++ ++void EVP_PKEY_meth_get_derive(const EVP_PKEY_METHOD *pmeth, ++ int (**pderive_init) (EVP_PKEY_CTX *ctx), ++ int (**pderive) (EVP_PKEY_CTX *ctx, ++ unsigned char *key, ++ size_t *keylen)); ++ ++void EVP_PKEY_meth_get_ctrl(const EVP_PKEY_METHOD *pmeth, ++ int (**pctrl) (EVP_PKEY_CTX *ctx, int type, int p1, ++ void *p2), ++ int (**pctrl_str) (EVP_PKEY_CTX *ctx, ++ const char *type, ++ const char *value)); ++ ++void EVP_PKEY_meth_get_digestsign(EVP_PKEY_METHOD *pmeth, ++ int (**digestsign) (EVP_MD_CTX *ctx, ++ unsigned char *sig, ++ size_t *siglen, ++ const unsigned char *tbs, ++ size_t tbslen)); ++ ++void EVP_PKEY_meth_get_digestverify(EVP_PKEY_METHOD *pmeth, ++ int (**digestverify) (EVP_MD_CTX *ctx, ++ const unsigned char *sig, ++ size_t siglen, ++ const unsigned char *tbs, ++ size_t tbslen)); ++ ++void EVP_PKEY_meth_get_check(const EVP_PKEY_METHOD *pmeth, ++ int (**pcheck) (EVP_PKEY *pkey)); ++ ++void EVP_PKEY_meth_get_public_check(const EVP_PKEY_METHOD *pmeth, ++ int (**pcheck) (EVP_PKEY *pkey)); ++ ++void EVP_PKEY_meth_get_param_check(const EVP_PKEY_METHOD *pmeth, ++ int (**pcheck) (EVP_PKEY *pkey)); ++ ++void EVP_PKEY_meth_get_digest_custom(EVP_PKEY_METHOD *pmeth, ++ int (**pdigest_custom) (EVP_PKEY_CTX *ctx, ++ EVP_MD_CTX *mctx)); ++void EVP_add_alg_module(void); ++ ++#ifndef OPENSSL_NO_SM2 ++int EVP_PKEY_is_sm2(EVP_PKEY *pkey); ++#endif ++ ++# ifdef __cplusplus ++} ++# endif ++#endif +diff --git a/include/TA/openssl/openssl/evperr.h b/include/TA/openssl/openssl/evperr.h +new file mode 100644 +index 0000000..daabe9b +--- /dev/null ++++ b/include/TA/openssl/openssl/evperr.h +@@ -0,0 +1,206 @@ ++/* ++ * Generated by util/mkerr.pl DO NOT EDIT ++ * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved. ++ * ++ * Licensed under the OpenSSL license (the "License"). You may not use ++ * this file except in compliance with the License. You can obtain a copy ++ * in the file LICENSE in the source distribution or at ++ * https://www.openssl.org/source/license.html ++ */ ++ ++#ifndef HEADER_EVPERR_H ++# define HEADER_EVPERR_H ++ ++# include ++ ++# ifdef __cplusplus ++extern "C" ++# endif ++int ERR_load_EVP_strings(void); ++ ++/* ++ * EVP function codes. ++ */ ++# define EVP_F_AESNI_INIT_KEY 165 ++# define EVP_F_AESNI_XTS_INIT_KEY 207 ++# define EVP_F_AES_GCM_CTRL 196 ++# define EVP_F_AES_INIT_KEY 133 ++# define EVP_F_AES_OCB_CIPHER 169 ++# define EVP_F_AES_T4_INIT_KEY 178 ++# define EVP_F_AES_T4_XTS_INIT_KEY 208 ++# define EVP_F_AES_WRAP_CIPHER 170 ++# define EVP_F_AES_XTS_INIT_KEY 209 ++# define EVP_F_ALG_MODULE_INIT 177 ++# define EVP_F_ARIA_CCM_INIT_KEY 175 ++# define EVP_F_ARIA_GCM_CTRL 197 ++# define EVP_F_ARIA_GCM_INIT_KEY 176 ++# define EVP_F_ARIA_INIT_KEY 185 ++# define EVP_F_B64_NEW 198 ++# define EVP_F_CAMELLIA_INIT_KEY 159 ++# define EVP_F_CHACHA20_POLY1305_CTRL 182 ++# define EVP_F_CMLL_T4_INIT_KEY 179 ++# define EVP_F_DES_EDE3_WRAP_CIPHER 171 ++# define EVP_F_DO_SIGVER_INIT 161 ++# define EVP_F_ENC_NEW 199 ++# define EVP_F_EVP_CIPHERINIT_EX 123 ++# define EVP_F_EVP_CIPHER_ASN1_TO_PARAM 204 ++# define EVP_F_EVP_CIPHER_CTX_COPY 163 ++# define EVP_F_EVP_CIPHER_CTX_CTRL 124 ++# define EVP_F_EVP_CIPHER_CTX_SET_KEY_LENGTH 122 ++# define EVP_F_EVP_CIPHER_PARAM_TO_ASN1 205 ++# define EVP_F_EVP_DECRYPTFINAL_EX 101 ++# define EVP_F_EVP_DECRYPTUPDATE 166 ++# define EVP_F_EVP_DIGESTFINALXOF 174 ++# define EVP_F_EVP_DIGESTINIT_EX 128 ++# define EVP_F_EVP_ENCRYPTDECRYPTUPDATE 219 ++# define EVP_F_EVP_ENCRYPTFINAL_EX 127 ++# define EVP_F_EVP_ENCRYPTUPDATE 167 ++# define EVP_F_EVP_MD_CTX_COPY_EX 110 ++# define EVP_F_EVP_MD_SIZE 162 ++# define EVP_F_EVP_OPENINIT 102 ++# define EVP_F_EVP_PBE_ALG_ADD 115 ++# define EVP_F_EVP_PBE_ALG_ADD_TYPE 160 ++# define EVP_F_EVP_PBE_CIPHERINIT 116 ++# define EVP_F_EVP_PBE_SCRYPT 181 ++# define EVP_F_EVP_PKCS82PKEY 111 ++# define EVP_F_EVP_PKEY2PKCS8 113 ++# define EVP_F_EVP_PKEY_ASN1_ADD0 188 ++# define EVP_F_EVP_PKEY_CHECK 186 ++# define EVP_F_EVP_PKEY_COPY_PARAMETERS 103 ++# define EVP_F_EVP_PKEY_CTX_CTRL 137 ++# define EVP_F_EVP_PKEY_CTX_CTRL_STR 150 ++# define EVP_F_EVP_PKEY_CTX_DUP 156 ++# define EVP_F_EVP_PKEY_CTX_MD 168 ++# define EVP_F_EVP_PKEY_DECRYPT 104 ++# define EVP_F_EVP_PKEY_DECRYPT_INIT 138 ++# define EVP_F_EVP_PKEY_DECRYPT_OLD 151 ++# define EVP_F_EVP_PKEY_DERIVE 153 ++# define EVP_F_EVP_PKEY_DERIVE_INIT 154 ++# define EVP_F_EVP_PKEY_DERIVE_SET_PEER 155 ++# define EVP_F_EVP_PKEY_ENCRYPT 105 ++# define EVP_F_EVP_PKEY_ENCRYPT_INIT 139 ++# define EVP_F_EVP_PKEY_ENCRYPT_OLD 152 ++# define EVP_F_EVP_PKEY_GET0_DH 119 ++# define EVP_F_EVP_PKEY_GET0_DSA 120 ++# define EVP_F_EVP_PKEY_GET0_EC_KEY 131 ++# define EVP_F_EVP_PKEY_GET0_HMAC 183 ++# define EVP_F_EVP_PKEY_GET0_POLY1305 184 ++# define EVP_F_EVP_PKEY_GET0_RSA 121 ++# define EVP_F_EVP_PKEY_GET0_SIPHASH 172 ++# define EVP_F_EVP_PKEY_GET_RAW_PRIVATE_KEY 202 ++# define EVP_F_EVP_PKEY_GET_RAW_PUBLIC_KEY 203 ++# define EVP_F_EVP_PKEY_KEYGEN 146 ++# define EVP_F_EVP_PKEY_KEYGEN_INIT 147 ++# define EVP_F_EVP_PKEY_METH_ADD0 194 ++# define EVP_F_EVP_PKEY_METH_NEW 195 ++# define EVP_F_EVP_PKEY_NEW 106 ++# define EVP_F_EVP_PKEY_NEW_CMAC_KEY 193 ++# define EVP_F_EVP_PKEY_NEW_RAW_PRIVATE_KEY 191 ++# define EVP_F_EVP_PKEY_NEW_RAW_PUBLIC_KEY 192 ++# define EVP_F_EVP_PKEY_PARAMGEN 148 ++# define EVP_F_EVP_PKEY_PARAMGEN_INIT 149 ++# define EVP_F_EVP_PKEY_PARAM_CHECK 189 ++# define EVP_F_EVP_PKEY_PUBLIC_CHECK 190 ++# define EVP_F_EVP_PKEY_SET1_ENGINE 187 ++# define EVP_F_EVP_PKEY_SET_ALIAS_TYPE 206 ++# define EVP_F_EVP_PKEY_SIGN 140 ++# define EVP_F_EVP_PKEY_SIGN_INIT 141 ++# define EVP_F_EVP_PKEY_VERIFY 142 ++# define EVP_F_EVP_PKEY_VERIFY_INIT 143 ++# define EVP_F_EVP_PKEY_VERIFY_RECOVER 144 ++# define EVP_F_EVP_PKEY_VERIFY_RECOVER_INIT 145 ++# define EVP_F_EVP_SIGNFINAL 107 ++# define EVP_F_EVP_VERIFYFINAL 108 ++# define EVP_F_INT_CTX_NEW 157 ++# define EVP_F_OK_NEW 200 ++# define EVP_F_PKCS5_PBE_KEYIVGEN 117 ++# define EVP_F_PKCS5_V2_PBE_KEYIVGEN 118 ++# define EVP_F_PKCS5_V2_PBKDF2_KEYIVGEN 164 ++# define EVP_F_PKCS5_V2_SCRYPT_KEYIVGEN 180 ++# define EVP_F_PKEY_SET_TYPE 158 ++# define EVP_F_RC2_MAGIC_TO_METH 109 ++# define EVP_F_RC5_CTRL 125 ++# define EVP_F_R_32_12_16_INIT_KEY 242 ++# define EVP_F_S390X_AES_GCM_CTRL 201 ++# define EVP_F_UPDATE 173 ++# define EVP_F_SM4_GCM_CTRL 231 ++# define EVP_F_SM4_XTS_INIT_KEY 232 ++ ++/* ++ * EVP reason codes. ++ */ ++# define EVP_R_AES_KEY_SETUP_FAILED 143 ++# define EVP_R_ARIA_KEY_SETUP_FAILED 176 ++# define EVP_R_BAD_DECRYPT 100 ++# define EVP_R_BAD_KEY_LENGTH 195 ++# define EVP_R_BUFFER_TOO_SMALL 155 ++# define EVP_R_CAMELLIA_KEY_SETUP_FAILED 157 ++# define EVP_R_CIPHER_PARAMETER_ERROR 122 ++# define EVP_R_COMMAND_NOT_SUPPORTED 147 ++# define EVP_R_COPY_ERROR 173 ++# define EVP_R_CTRL_NOT_IMPLEMENTED 132 ++# define EVP_R_CTRL_OPERATION_NOT_IMPLEMENTED 133 ++# define EVP_R_DATA_NOT_MULTIPLE_OF_BLOCK_LENGTH 138 ++# define EVP_R_DECODE_ERROR 114 ++# define EVP_R_DIFFERENT_KEY_TYPES 101 ++# define EVP_R_DIFFERENT_PARAMETERS 153 ++# define EVP_R_ERROR_LOADING_SECTION 165 ++# define EVP_R_ERROR_SETTING_FIPS_MODE 166 ++# define EVP_R_EXPECTING_AN_HMAC_KEY 174 ++# define EVP_R_EXPECTING_AN_RSA_KEY 127 ++# define EVP_R_EXPECTING_A_DH_KEY 128 ++# define EVP_R_EXPECTING_A_DSA_KEY 129 ++# define EVP_R_EXPECTING_A_EC_KEY 142 ++# define EVP_R_EXPECTING_A_POLY1305_KEY 164 ++# define EVP_R_EXPECTING_A_SIPHASH_KEY 175 ++# define EVP_R_FIPS_MODE_NOT_SUPPORTED 167 ++# define EVP_R_GET_RAW_KEY_FAILED 182 ++# define EVP_R_ILLEGAL_SCRYPT_PARAMETERS 171 ++# define EVP_R_INITIALIZATION_ERROR 134 ++# define EVP_R_INPUT_NOT_INITIALIZED 111 ++# define EVP_R_INVALID_DIGEST 152 ++# define EVP_R_INVALID_FIPS_MODE 168 ++# define EVP_R_INVALID_IV_LENGTH 194 ++# define EVP_R_INVALID_KEY 163 ++# define EVP_R_INVALID_KEY_LENGTH 130 ++# define EVP_R_INVALID_OPERATION 148 ++# define EVP_R_KEYGEN_FAILURE 120 ++# define EVP_R_KEY_SETUP_FAILED 180 ++# define EVP_R_MEMORY_LIMIT_EXCEEDED 172 ++# define EVP_R_MESSAGE_DIGEST_IS_NULL 159 ++# define EVP_R_METHOD_NOT_SUPPORTED 144 ++# define EVP_R_MISSING_PARAMETERS 103 ++# define EVP_R_NOT_XOF_OR_INVALID_LENGTH 178 ++# define EVP_R_NO_CIPHER_SET 131 ++# define EVP_R_NO_DEFAULT_DIGEST 158 ++# define EVP_R_NO_DIGEST_SET 139 ++# define EVP_R_NO_KEY_SET 154 ++# define EVP_R_NO_OPERATION_SET 149 ++# define EVP_R_ONLY_ONESHOT_SUPPORTED 177 ++# define EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE 150 ++# define EVP_R_OPERATON_NOT_INITIALIZED 151 ++# define EVP_R_OUTPUT_WOULD_OVERFLOW 184 ++# define EVP_R_PARTIALLY_OVERLAPPING 162 ++# define EVP_R_PBKDF2_ERROR 181 ++# define EVP_R_PKEY_APPLICATION_ASN1_METHOD_ALREADY_REGISTERED 179 ++# define EVP_R_PRIVATE_KEY_DECODE_ERROR 145 ++# define EVP_R_PRIVATE_KEY_ENCODE_ERROR 146 ++# define EVP_R_PUBLIC_KEY_NOT_RSA 106 ++# define EVP_R_UNKNOWN_CIPHER 160 ++# define EVP_R_UNKNOWN_DIGEST 161 ++# define EVP_R_UNKNOWN_OPTION 169 ++# define EVP_R_UNKNOWN_PBE_ALGORITHM 121 ++# define EVP_R_UNSUPPORTED_ALGORITHM 156 ++# define EVP_R_UNSUPPORTED_CIPHER 107 ++# define EVP_R_UNSUPPORTED_KEYLENGTH 123 ++# define EVP_R_UNSUPPORTED_KEY_DERIVATION_FUNCTION 124 ++# define EVP_R_UNSUPPORTED_KEY_SIZE 108 ++# define EVP_R_UNSUPPORTED_NUMBER_OF_ROUNDS 135 ++# define EVP_R_UNSUPPORTED_PRF 125 ++# define EVP_R_UNSUPPORTED_PRIVATE_KEY_ALGORITHM 118 ++# define EVP_R_UNSUPPORTED_SALT_TYPE 126 ++# define EVP_R_WRAP_MODE_NOT_ALLOWED 170 ++# define EVP_R_WRONG_FINAL_BLOCK_LENGTH 109 ++# define EVP_R_XTS_DUPLICATED_KEYS 183 ++ ++#endif +diff --git a/include/TA/openssl/openssl/hmac.h b/include/TA/openssl/openssl/hmac.h +new file mode 100644 +index 0000000..458efc1 +--- /dev/null ++++ b/include/TA/openssl/openssl/hmac.h +@@ -0,0 +1,51 @@ ++/* ++ * Copyright 1995-2018 The OpenSSL Project Authors. All Rights Reserved. ++ * ++ * Licensed under the OpenSSL license (the "License"). You may not use ++ * this file except in compliance with the License. You can obtain a copy ++ * in the file LICENSE in the source distribution or at ++ * https://www.openssl.org/source/license.html ++ */ ++ ++#ifndef HEADER_HMAC_H ++# define HEADER_HMAC_H ++ ++# include ++ ++# include ++ ++# if OPENSSL_API_COMPAT < 0x10200000L ++# define HMAC_MAX_MD_CBLOCK 128 /* Deprecated */ ++# endif ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++size_t HMAC_size(const HMAC_CTX *e); ++HMAC_CTX *HMAC_CTX_new(void); ++int HMAC_CTX_reset(HMAC_CTX *ctx); ++void HMAC_CTX_free(HMAC_CTX *ctx); ++ ++DEPRECATEDIN_1_1_0(__owur int HMAC_Init(HMAC_CTX *ctx, const void *key, int len, ++ const EVP_MD *md)) ++ ++/*__owur*/ int HMAC_Init_ex(HMAC_CTX *ctx, const void *key, int len, ++ const EVP_MD *md, ENGINE *impl); ++/*__owur*/ int HMAC_Update(HMAC_CTX *ctx, const unsigned char *data, ++ size_t len); ++/*__owur*/ int HMAC_Final(HMAC_CTX *ctx, unsigned char *md, ++ unsigned int *len); ++unsigned char *HMAC(const EVP_MD *evp_md, const void *key, int key_len, ++ const unsigned char *d, size_t n, unsigned char *md, ++ unsigned int *md_len); ++__owur int HMAC_CTX_copy(HMAC_CTX *dctx, HMAC_CTX *sctx); ++ ++void HMAC_CTX_set_flags(HMAC_CTX *ctx, unsigned long flags); ++const EVP_MD *HMAC_CTX_get_md(const HMAC_CTX *ctx); ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif +diff --git a/include/TA/openssl/openssl/kdf.h b/include/TA/openssl/openssl/kdf.h +new file mode 100644 +index 0000000..01e5448 +--- /dev/null ++++ b/include/TA/openssl/openssl/kdf.h +@@ -0,0 +1,96 @@ ++/* ++ * Copyright 2016-2018 The OpenSSL Project Authors. All Rights Reserved. ++ * ++ * Licensed under the OpenSSL license (the "License"). You may not use ++ * this file except in compliance with the License. You can obtain a copy ++ * in the file LICENSE in the source distribution or at ++ * https://www.openssl.org/source/license.html ++ */ ++ ++#ifndef HEADER_KDF_H ++# define HEADER_KDF_H ++ ++# include ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++# define EVP_PKEY_CTRL_TLS_MD (EVP_PKEY_ALG_CTRL) ++# define EVP_PKEY_CTRL_TLS_SECRET (EVP_PKEY_ALG_CTRL + 1) ++# define EVP_PKEY_CTRL_TLS_SEED (EVP_PKEY_ALG_CTRL + 2) ++# define EVP_PKEY_CTRL_HKDF_MD (EVP_PKEY_ALG_CTRL + 3) ++# define EVP_PKEY_CTRL_HKDF_SALT (EVP_PKEY_ALG_CTRL + 4) ++# define EVP_PKEY_CTRL_HKDF_KEY (EVP_PKEY_ALG_CTRL + 5) ++# define EVP_PKEY_CTRL_HKDF_INFO (EVP_PKEY_ALG_CTRL + 6) ++# define EVP_PKEY_CTRL_HKDF_MODE (EVP_PKEY_ALG_CTRL + 7) ++# define EVP_PKEY_CTRL_PASS (EVP_PKEY_ALG_CTRL + 8) ++# define EVP_PKEY_CTRL_SCRYPT_SALT (EVP_PKEY_ALG_CTRL + 9) ++# define EVP_PKEY_CTRL_SCRYPT_N (EVP_PKEY_ALG_CTRL + 10) ++# define EVP_PKEY_CTRL_SCRYPT_R (EVP_PKEY_ALG_CTRL + 11) ++# define EVP_PKEY_CTRL_SCRYPT_P (EVP_PKEY_ALG_CTRL + 12) ++# define EVP_PKEY_CTRL_SCRYPT_MAXMEM_BYTES (EVP_PKEY_ALG_CTRL + 13) ++ ++# define EVP_PKEY_HKDEF_MODE_EXTRACT_AND_EXPAND 0 ++# define EVP_PKEY_HKDEF_MODE_EXTRACT_ONLY 1 ++# define EVP_PKEY_HKDEF_MODE_EXPAND_ONLY 2 ++ ++# define EVP_PKEY_CTX_set_tls1_prf_md(pctx, md) \ ++ EVP_PKEY_CTX_ctrl(pctx, -1, EVP_PKEY_OP_DERIVE, \ ++ EVP_PKEY_CTRL_TLS_MD, 0, (void *)(md)) ++ ++# define EVP_PKEY_CTX_set1_tls1_prf_secret(pctx, sec, seclen) \ ++ EVP_PKEY_CTX_ctrl(pctx, -1, EVP_PKEY_OP_DERIVE, \ ++ EVP_PKEY_CTRL_TLS_SECRET, seclen, (void *)(sec)) ++ ++# define EVP_PKEY_CTX_add1_tls1_prf_seed(pctx, seed, seedlen) \ ++ EVP_PKEY_CTX_ctrl(pctx, -1, EVP_PKEY_OP_DERIVE, \ ++ EVP_PKEY_CTRL_TLS_SEED, seedlen, (void *)(seed)) ++ ++# define EVP_PKEY_CTX_set_hkdf_md(pctx, md) \ ++ EVP_PKEY_CTX_ctrl(pctx, -1, EVP_PKEY_OP_DERIVE, \ ++ EVP_PKEY_CTRL_HKDF_MD, 0, (void *)(md)) ++ ++# define EVP_PKEY_CTX_set1_hkdf_salt(pctx, salt, saltlen) \ ++ EVP_PKEY_CTX_ctrl(pctx, -1, EVP_PKEY_OP_DERIVE, \ ++ EVP_PKEY_CTRL_HKDF_SALT, saltlen, (void *)(salt)) ++ ++# define EVP_PKEY_CTX_set1_hkdf_key(pctx, key, keylen) \ ++ EVP_PKEY_CTX_ctrl(pctx, -1, EVP_PKEY_OP_DERIVE, \ ++ EVP_PKEY_CTRL_HKDF_KEY, keylen, (void *)(key)) ++ ++# define EVP_PKEY_CTX_add1_hkdf_info(pctx, info, infolen) \ ++ EVP_PKEY_CTX_ctrl(pctx, -1, EVP_PKEY_OP_DERIVE, \ ++ EVP_PKEY_CTRL_HKDF_INFO, infolen, (void *)(info)) ++ ++# define EVP_PKEY_CTX_hkdf_mode(pctx, mode) \ ++ EVP_PKEY_CTX_ctrl(pctx, -1, EVP_PKEY_OP_DERIVE, \ ++ EVP_PKEY_CTRL_HKDF_MODE, mode, NULL) ++ ++# define EVP_PKEY_CTX_set1_pbe_pass(pctx, pass, passlen) \ ++ EVP_PKEY_CTX_ctrl(pctx, -1, EVP_PKEY_OP_DERIVE, \ ++ EVP_PKEY_CTRL_PASS, passlen, (void *)(pass)) ++ ++# define EVP_PKEY_CTX_set1_scrypt_salt(pctx, salt, saltlen) \ ++ EVP_PKEY_CTX_ctrl(pctx, -1, EVP_PKEY_OP_DERIVE, \ ++ EVP_PKEY_CTRL_SCRYPT_SALT, saltlen, (void *)(salt)) ++ ++# define EVP_PKEY_CTX_set_scrypt_N(pctx, n) \ ++ EVP_PKEY_CTX_ctrl_uint64(pctx, -1, EVP_PKEY_OP_DERIVE, \ ++ EVP_PKEY_CTRL_SCRYPT_N, n) ++ ++# define EVP_PKEY_CTX_set_scrypt_r(pctx, r) \ ++ EVP_PKEY_CTX_ctrl_uint64(pctx, -1, EVP_PKEY_OP_DERIVE, \ ++ EVP_PKEY_CTRL_SCRYPT_R, r) ++ ++# define EVP_PKEY_CTX_set_scrypt_p(pctx, p) \ ++ EVP_PKEY_CTX_ctrl_uint64(pctx, -1, EVP_PKEY_OP_DERIVE, \ ++ EVP_PKEY_CTRL_SCRYPT_P, p) ++ ++# define EVP_PKEY_CTX_set_scrypt_maxmem_bytes(pctx, maxmem_bytes) \ ++ EVP_PKEY_CTX_ctrl_uint64(pctx, -1, EVP_PKEY_OP_DERIVE, \ ++ EVP_PKEY_CTRL_SCRYPT_MAXMEM_BYTES, maxmem_bytes) ++ ++# ifdef __cplusplus ++} ++# endif ++#endif +diff --git a/include/TA/openssl/openssl/kdferr.h b/include/TA/openssl/openssl/kdferr.h +new file mode 100644 +index 0000000..3f51bd0 +--- /dev/null ++++ b/include/TA/openssl/openssl/kdferr.h +@@ -0,0 +1,55 @@ ++/* ++ * Generated by util/mkerr.pl DO NOT EDIT ++ * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. ++ * ++ * Licensed under the OpenSSL license (the "License"). You may not use ++ * this file except in compliance with the License. You can obtain a copy ++ * in the file LICENSE in the source distribution or at ++ * https://www.openssl.org/source/license.html ++ */ ++ ++#ifndef HEADER_KDFERR_H ++# define HEADER_KDFERR_H ++ ++# ifndef HEADER_SYMHACKS_H ++# include ++# endif ++ ++# ifdef __cplusplus ++extern "C" ++# endif ++int ERR_load_KDF_strings(void); ++ ++/* ++ * KDF function codes. ++ */ ++# define KDF_F_PKEY_HKDF_CTRL_STR 103 ++# define KDF_F_PKEY_HKDF_DERIVE 102 ++# define KDF_F_PKEY_HKDF_INIT 108 ++# define KDF_F_PKEY_SCRYPT_CTRL_STR 104 ++# define KDF_F_PKEY_SCRYPT_CTRL_UINT64 105 ++# define KDF_F_PKEY_SCRYPT_DERIVE 109 ++# define KDF_F_PKEY_SCRYPT_INIT 106 ++# define KDF_F_PKEY_SCRYPT_SET_MEMBUF 107 ++# define KDF_F_PKEY_TLS1_PRF_CTRL_STR 100 ++# define KDF_F_PKEY_TLS1_PRF_DERIVE 101 ++# define KDF_F_PKEY_TLS1_PRF_INIT 110 ++# define KDF_F_TLS1_PRF_ALG 111 ++ ++/* ++ * KDF reason codes. ++ */ ++# define KDF_R_INVALID_DIGEST 100 ++# define KDF_R_MISSING_ITERATION_COUNT 109 ++# define KDF_R_MISSING_KEY 104 ++# define KDF_R_MISSING_MESSAGE_DIGEST 105 ++# define KDF_R_MISSING_PARAMETER 101 ++# define KDF_R_MISSING_PASS 110 ++# define KDF_R_MISSING_SALT 111 ++# define KDF_R_MISSING_SECRET 107 ++# define KDF_R_MISSING_SEED 106 ++# define KDF_R_UNKNOWN_PARAMETER_TYPE 103 ++# define KDF_R_VALUE_ERROR 108 ++# define KDF_R_VALUE_MISSING 102 ++ ++#endif +diff --git a/include/TA/openssl/openssl/lhash.h b/include/TA/openssl/openssl/lhash.h +new file mode 100644 +index 0000000..84cfab0 +--- /dev/null ++++ b/include/TA/openssl/openssl/lhash.h +@@ -0,0 +1,240 @@ ++/* ++ * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved. ++ * ++ * Licensed under the OpenSSL license (the "License"). You may not use ++ * this file except in compliance with the License. You can obtain a copy ++ * in the file LICENSE in the source distribution or at ++ * https://www.openssl.org/source/license.html ++ */ ++ ++/* ++ * Header for dynamic hash table routines Author - Eric Young ++ */ ++ ++#ifndef HEADER_LHASH_H ++# define HEADER_LHASH_H ++ ++# include ++# include ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++typedef struct lhash_node_st OPENSSL_LH_NODE; ++typedef int (*OPENSSL_LH_COMPFUNC) (const void *, const void *); ++typedef unsigned long (*OPENSSL_LH_HASHFUNC) (const void *); ++typedef void (*OPENSSL_LH_DOALL_FUNC) (void *); ++typedef void (*OPENSSL_LH_DOALL_FUNCARG) (void *, void *); ++typedef struct lhash_st OPENSSL_LHASH; ++ ++/* ++ * Macros for declaring and implementing type-safe wrappers for LHASH ++ * callbacks. This way, callbacks can be provided to LHASH structures without ++ * function pointer casting and the macro-defined callbacks provide ++ * per-variable casting before deferring to the underlying type-specific ++ * callbacks. NB: It is possible to place a "static" in front of both the ++ * DECLARE and IMPLEMENT macros if the functions are strictly internal. ++ */ ++ ++/* First: "hash" functions */ ++# define DECLARE_LHASH_HASH_FN(name, o_type) \ ++ unsigned long name##_LHASH_HASH(const void *); ++# define IMPLEMENT_LHASH_HASH_FN(name, o_type) \ ++ unsigned long name##_LHASH_HASH(const void *arg) { \ ++ const o_type *a = arg; \ ++ return name##_hash(a); } ++# define LHASH_HASH_FN(name) name##_LHASH_HASH ++ ++/* Second: "compare" functions */ ++# define DECLARE_LHASH_COMP_FN(name, o_type) \ ++ int name##_LHASH_COMP(const void *, const void *); ++# define IMPLEMENT_LHASH_COMP_FN(name, o_type) \ ++ int name##_LHASH_COMP(const void *arg1, const void *arg2) { \ ++ const o_type *a = arg1; \ ++ const o_type *b = arg2; \ ++ return name##_cmp(a,b); } ++# define LHASH_COMP_FN(name) name##_LHASH_COMP ++ ++/* Fourth: "doall_arg" functions */ ++# define DECLARE_LHASH_DOALL_ARG_FN(name, o_type, a_type) \ ++ void name##_LHASH_DOALL_ARG(void *, void *); ++# define IMPLEMENT_LHASH_DOALL_ARG_FN(name, o_type, a_type) \ ++ void name##_LHASH_DOALL_ARG(void *arg1, void *arg2) { \ ++ o_type *a = arg1; \ ++ a_type *b = arg2; \ ++ name##_doall_arg(a, b); } ++# define LHASH_DOALL_ARG_FN(name) name##_LHASH_DOALL_ARG ++ ++# define LH_LOAD_MULT 256 ++ ++int OPENSSL_LH_error(OPENSSL_LHASH *lh); ++OPENSSL_LHASH *OPENSSL_LH_new(OPENSSL_LH_HASHFUNC h, OPENSSL_LH_COMPFUNC c); ++void OPENSSL_LH_free(OPENSSL_LHASH *lh); ++void *OPENSSL_LH_insert(OPENSSL_LHASH *lh, void *data); ++void *OPENSSL_LH_delete(OPENSSL_LHASH *lh, const void *data); ++void *OPENSSL_LH_retrieve(OPENSSL_LHASH *lh, const void *data); ++void OPENSSL_LH_doall(OPENSSL_LHASH *lh, OPENSSL_LH_DOALL_FUNC func); ++void OPENSSL_LH_doall_arg(OPENSSL_LHASH *lh, OPENSSL_LH_DOALL_FUNCARG func, void *arg); ++unsigned long OPENSSL_LH_strhash(const char *c); ++unsigned long OPENSSL_LH_num_items(const OPENSSL_LHASH *lh); ++unsigned long OPENSSL_LH_get_down_load(const OPENSSL_LHASH *lh); ++void OPENSSL_LH_set_down_load(OPENSSL_LHASH *lh, unsigned long down_load); ++ ++# ifndef OPENSSL_NO_STDIO ++void OPENSSL_LH_stats(const OPENSSL_LHASH *lh, FILE *fp); ++void OPENSSL_LH_node_stats(const OPENSSL_LHASH *lh, FILE *fp); ++void OPENSSL_LH_node_usage_stats(const OPENSSL_LHASH *lh, FILE *fp); ++# endif ++void OPENSSL_LH_stats_bio(const OPENSSL_LHASH *lh, BIO *out); ++void OPENSSL_LH_node_stats_bio(const OPENSSL_LHASH *lh, BIO *out); ++void OPENSSL_LH_node_usage_stats_bio(const OPENSSL_LHASH *lh, BIO *out); ++ ++# if OPENSSL_API_COMPAT < 0x10100000L ++# define _LHASH OPENSSL_LHASH ++# define LHASH_NODE OPENSSL_LH_NODE ++# define lh_error OPENSSL_LH_error ++# define lh_new OPENSSL_LH_new ++# define lh_free OPENSSL_LH_free ++# define lh_insert OPENSSL_LH_insert ++# define lh_delete OPENSSL_LH_delete ++# define lh_retrieve OPENSSL_LH_retrieve ++# define lh_doall OPENSSL_LH_doall ++# define lh_doall_arg OPENSSL_LH_doall_arg ++# define lh_strhash OPENSSL_LH_strhash ++# define lh_num_items OPENSSL_LH_num_items ++# ifndef OPENSSL_NO_STDIO ++# define lh_stats OPENSSL_LH_stats ++# define lh_node_stats OPENSSL_LH_node_stats ++# define lh_node_usage_stats OPENSSL_LH_node_usage_stats ++# endif ++# define lh_stats_bio OPENSSL_LH_stats_bio ++# define lh_node_stats_bio OPENSSL_LH_node_stats_bio ++# define lh_node_usage_stats_bio OPENSSL_LH_node_usage_stats_bio ++# endif ++ ++/* Type checking... */ ++ ++# define LHASH_OF(type) struct lhash_st_##type ++ ++# define DEFINE_LHASH_OF(type) \ ++ LHASH_OF(type) { union lh_##type##_dummy { void* d1; unsigned long d2; int d3; } dummy; }; \ ++ static ossl_unused ossl_inline LHASH_OF(type) *lh_##type##_new(unsigned long (*hfn)(const type *), \ ++ int (*cfn)(const type *, const type *)) \ ++ { \ ++ return (LHASH_OF(type) *) \ ++ OPENSSL_LH_new((OPENSSL_LH_HASHFUNC)hfn, (OPENSSL_LH_COMPFUNC)cfn); \ ++ } \ ++ static ossl_unused ossl_inline void lh_##type##_free(LHASH_OF(type) *lh) \ ++ { \ ++ OPENSSL_LH_free((OPENSSL_LHASH *)lh); \ ++ } \ ++ static ossl_unused ossl_inline type *lh_##type##_insert(LHASH_OF(type) *lh, type *d) \ ++ { \ ++ return (type *)OPENSSL_LH_insert((OPENSSL_LHASH *)lh, d); \ ++ } \ ++ static ossl_unused ossl_inline type *lh_##type##_delete(LHASH_OF(type) *lh, const type *d) \ ++ { \ ++ return (type *)OPENSSL_LH_delete((OPENSSL_LHASH *)lh, d); \ ++ } \ ++ static ossl_unused ossl_inline type *lh_##type##_retrieve(LHASH_OF(type) *lh, const type *d) \ ++ { \ ++ return (type *)OPENSSL_LH_retrieve((OPENSSL_LHASH *)lh, d); \ ++ } \ ++ static ossl_unused ossl_inline int lh_##type##_error(LHASH_OF(type) *lh) \ ++ { \ ++ return OPENSSL_LH_error((OPENSSL_LHASH *)lh); \ ++ } \ ++ static ossl_unused ossl_inline unsigned long lh_##type##_num_items(LHASH_OF(type) *lh) \ ++ { \ ++ return OPENSSL_LH_num_items((OPENSSL_LHASH *)lh); \ ++ } \ ++ static ossl_unused ossl_inline void lh_##type##_node_stats_bio(const LHASH_OF(type) *lh, BIO *out) \ ++ { \ ++ OPENSSL_LH_node_stats_bio((const OPENSSL_LHASH *)lh, out); \ ++ } \ ++ static ossl_unused ossl_inline void lh_##type##_node_usage_stats_bio(const LHASH_OF(type) *lh, BIO *out) \ ++ { \ ++ OPENSSL_LH_node_usage_stats_bio((const OPENSSL_LHASH *)lh, out); \ ++ } \ ++ static ossl_unused ossl_inline void lh_##type##_stats_bio(const LHASH_OF(type) *lh, BIO *out) \ ++ { \ ++ OPENSSL_LH_stats_bio((const OPENSSL_LHASH *)lh, out); \ ++ } \ ++ static ossl_unused ossl_inline unsigned long lh_##type##_get_down_load(LHASH_OF(type) *lh) \ ++ { \ ++ return OPENSSL_LH_get_down_load((OPENSSL_LHASH *)lh); \ ++ } \ ++ static ossl_unused ossl_inline void lh_##type##_set_down_load(LHASH_OF(type) *lh, unsigned long dl) \ ++ { \ ++ OPENSSL_LH_set_down_load((OPENSSL_LHASH *)lh, dl); \ ++ } \ ++ static ossl_unused ossl_inline void lh_##type##_doall(LHASH_OF(type) *lh, \ ++ void (*doall)(type *)) \ ++ { \ ++ OPENSSL_LH_doall((OPENSSL_LHASH *)lh, (OPENSSL_LH_DOALL_FUNC)doall); \ ++ } \ ++ LHASH_OF(type) ++ ++#define IMPLEMENT_LHASH_DOALL_ARG_CONST(type, argtype) \ ++ int_implement_lhash_doall(type, argtype, const type) ++ ++#define IMPLEMENT_LHASH_DOALL_ARG(type, argtype) \ ++ int_implement_lhash_doall(type, argtype, type) ++ ++#define int_implement_lhash_doall(type, argtype, cbargtype) \ ++ static ossl_unused ossl_inline void \ ++ lh_##type##_doall_##argtype(LHASH_OF(type) *lh, \ ++ void (*fn)(cbargtype *, argtype *), \ ++ argtype *arg) \ ++ { \ ++ OPENSSL_LH_doall_arg((OPENSSL_LHASH *)lh, (OPENSSL_LH_DOALL_FUNCARG)fn, (void *)arg); \ ++ } \ ++ LHASH_OF(type) ++ ++DEFINE_LHASH_OF(OPENSSL_STRING); ++# ifdef _MSC_VER ++/* ++ * push and pop this warning: ++ * warning C4090: 'function': different 'const' qualifiers ++ */ ++# pragma warning (push) ++# pragma warning (disable: 4090) ++# endif ++ ++DEFINE_LHASH_OF(OPENSSL_CSTRING); ++ ++# ifdef _MSC_VER ++# pragma warning (pop) ++# endif ++ ++/* ++ * If called without higher optimization (min. -xO3) the Oracle Developer ++ * Studio compiler generates code for the defined (static inline) functions ++ * above. ++ * This would later lead to the linker complaining about missing symbols when ++ * this header file is included but the resulting object is not linked against ++ * the Crypto library (openssl#6912). ++ */ ++# ifdef __SUNPRO_C ++# pragma weak OPENSSL_LH_new ++# pragma weak OPENSSL_LH_free ++# pragma weak OPENSSL_LH_insert ++# pragma weak OPENSSL_LH_delete ++# pragma weak OPENSSL_LH_retrieve ++# pragma weak OPENSSL_LH_error ++# pragma weak OPENSSL_LH_num_items ++# pragma weak OPENSSL_LH_node_stats_bio ++# pragma weak OPENSSL_LH_node_usage_stats_bio ++# pragma weak OPENSSL_LH_stats_bio ++# pragma weak OPENSSL_LH_get_down_load ++# pragma weak OPENSSL_LH_set_down_load ++# pragma weak OPENSSL_LH_doall ++# pragma weak OPENSSL_LH_doall_arg ++# endif /* __SUNPRO_C */ ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif +diff --git a/include/TA/openssl/openssl/obj_mac.h b/include/TA/openssl/openssl/obj_mac.h +new file mode 100644 +index 0000000..66ec330 +--- /dev/null ++++ b/include/TA/openssl/openssl/obj_mac.h +@@ -0,0 +1,5303 @@ ++/* ++ * WARNING: do not edit! ++ * Generated by crypto/objects/objects.pl ++ * ++ * Copyright 2000-2022 The OpenSSL Project Authors. All Rights Reserved. ++ * Licensed under the OpenSSL license (the "License"). You may not use ++ * this file except in compliance with the License. You can obtain a copy ++ * in the file LICENSE in the source distribution or at ++ * https://www.openssl.org/source/license.html ++ */ ++ ++#define SN_undef "UNDEF" ++#define LN_undef "undefined" ++#define NID_undef 0 ++#define OBJ_undef 0L ++ ++#define SN_itu_t "ITU-T" ++#define LN_itu_t "itu-t" ++#define NID_itu_t 645 ++#define OBJ_itu_t 0L ++ ++#define NID_ccitt 404 ++#define OBJ_ccitt OBJ_itu_t ++ ++#define SN_iso "ISO" ++#define LN_iso "iso" ++#define NID_iso 181 ++#define OBJ_iso 1L ++ ++#define SN_joint_iso_itu_t "JOINT-ISO-ITU-T" ++#define LN_joint_iso_itu_t "joint-iso-itu-t" ++#define NID_joint_iso_itu_t 646 ++#define OBJ_joint_iso_itu_t 2L ++ ++#define NID_joint_iso_ccitt 393 ++#define OBJ_joint_iso_ccitt OBJ_joint_iso_itu_t ++ ++#define SN_member_body "member-body" ++#define LN_member_body "ISO Member Body" ++#define NID_member_body 182 ++#define OBJ_member_body OBJ_iso,2L ++ ++#define SN_identified_organization "identified-organization" ++#define NID_identified_organization 676 ++#define OBJ_identified_organization OBJ_iso,3L ++ ++#define SN_hmac_md5 "HMAC-MD5" ++#define LN_hmac_md5 "hmac-md5" ++#define NID_hmac_md5 780 ++#define OBJ_hmac_md5 OBJ_identified_organization,6L,1L,5L,5L,8L,1L,1L ++ ++#define SN_hmac_sha1 "HMAC-SHA1" ++#define LN_hmac_sha1 "hmac-sha1" ++#define NID_hmac_sha1 781 ++#define OBJ_hmac_sha1 OBJ_identified_organization,6L,1L,5L,5L,8L,1L,2L ++ ++#define SN_x509ExtAdmission "x509ExtAdmission" ++#define LN_x509ExtAdmission "Professional Information or basis for Admission" ++#define NID_x509ExtAdmission 1093 ++#define OBJ_x509ExtAdmission OBJ_identified_organization,36L,8L,3L,3L ++ ++#define SN_certicom_arc "certicom-arc" ++#define NID_certicom_arc 677 ++#define OBJ_certicom_arc OBJ_identified_organization,132L ++ ++#define SN_ieee "ieee" ++#define NID_ieee 1170 ++#define OBJ_ieee OBJ_identified_organization,111L ++ ++#define SN_ieee_siswg "ieee-siswg" ++#define LN_ieee_siswg "IEEE Security in Storage Working Group" ++#define NID_ieee_siswg 1171 ++#define OBJ_ieee_siswg OBJ_ieee,2L,1619L ++ ++#define SN_international_organizations "international-organizations" ++#define LN_international_organizations "International Organizations" ++#define NID_international_organizations 647 ++#define OBJ_international_organizations OBJ_joint_iso_itu_t,23L ++ ++#define SN_subject_key_attestation_evidence "subject-key-attestation-evidence" ++#define LN_subject_key_attestation_evidence "Subject Key Attestation Evidence" ++#define NID_subject_key_attestation_evidence 1195 ++#define OBJ_subject_key_attestation_evidence OBJ_international_organizations,133L,6L,1L,1L ++ ++#define SN_wap "wap" ++#define NID_wap 678 ++#define OBJ_wap OBJ_international_organizations,43L ++ ++#define SN_wap_wsg "wap-wsg" ++#define NID_wap_wsg 679 ++#define OBJ_wap_wsg OBJ_wap,1L ++ ++#define SN_selected_attribute_types "selected-attribute-types" ++#define LN_selected_attribute_types "Selected Attribute Types" ++#define NID_selected_attribute_types 394 ++#define OBJ_selected_attribute_types OBJ_joint_iso_itu_t,5L,1L,5L ++ ++#define SN_clearance "clearance" ++#define NID_clearance 395 ++#define OBJ_clearance OBJ_selected_attribute_types,55L ++ ++#define SN_ISO_US "ISO-US" ++#define LN_ISO_US "ISO US Member Body" ++#define NID_ISO_US 183 ++#define OBJ_ISO_US OBJ_member_body,840L ++ ++#define SN_X9_57 "X9-57" ++#define LN_X9_57 "X9.57" ++#define NID_X9_57 184 ++#define OBJ_X9_57 OBJ_ISO_US,10040L ++ ++#define SN_X9cm "X9cm" ++#define LN_X9cm "X9.57 CM ?" ++#define NID_X9cm 185 ++#define OBJ_X9cm OBJ_X9_57,4L ++ ++#define SN_ISO_CN "ISO-CN" ++#define LN_ISO_CN "ISO CN Member Body" ++#define NID_ISO_CN 1140 ++#define OBJ_ISO_CN OBJ_member_body,156L ++ ++#define SN_oscca "oscca" ++#define NID_oscca 1141 ++#define OBJ_oscca OBJ_ISO_CN,10197L ++ ++#define SN_sm_scheme "sm-scheme" ++#define NID_sm_scheme 1142 ++#define OBJ_sm_scheme OBJ_oscca,1L ++ ++#define SN_dsa "DSA" ++#define LN_dsa "dsaEncryption" ++#define NID_dsa 116 ++#define OBJ_dsa OBJ_X9cm,1L ++ ++#define SN_dsaWithSHA1 "DSA-SHA1" ++#define LN_dsaWithSHA1 "dsaWithSHA1" ++#define NID_dsaWithSHA1 113 ++#define OBJ_dsaWithSHA1 OBJ_X9cm,3L ++ ++#define SN_ansi_X9_62 "ansi-X9-62" ++#define LN_ansi_X9_62 "ANSI X9.62" ++#define NID_ansi_X9_62 405 ++#define OBJ_ansi_X9_62 OBJ_ISO_US,10045L ++ ++#define OBJ_X9_62_id_fieldType OBJ_ansi_X9_62,1L ++ ++#define SN_X9_62_prime_field "prime-field" ++#define NID_X9_62_prime_field 406 ++#define OBJ_X9_62_prime_field OBJ_X9_62_id_fieldType,1L ++ ++#define SN_X9_62_characteristic_two_field "characteristic-two-field" ++#define NID_X9_62_characteristic_two_field 407 ++#define OBJ_X9_62_characteristic_two_field OBJ_X9_62_id_fieldType,2L ++ ++#define SN_X9_62_id_characteristic_two_basis "id-characteristic-two-basis" ++#define NID_X9_62_id_characteristic_two_basis 680 ++#define OBJ_X9_62_id_characteristic_two_basis OBJ_X9_62_characteristic_two_field,3L ++ ++#define SN_X9_62_onBasis "onBasis" ++#define NID_X9_62_onBasis 681 ++#define OBJ_X9_62_onBasis OBJ_X9_62_id_characteristic_two_basis,1L ++ ++#define SN_X9_62_tpBasis "tpBasis" ++#define NID_X9_62_tpBasis 682 ++#define OBJ_X9_62_tpBasis OBJ_X9_62_id_characteristic_two_basis,2L ++ ++#define SN_X9_62_ppBasis "ppBasis" ++#define NID_X9_62_ppBasis 683 ++#define OBJ_X9_62_ppBasis OBJ_X9_62_id_characteristic_two_basis,3L ++ ++#define OBJ_X9_62_id_publicKeyType OBJ_ansi_X9_62,2L ++ ++#define SN_X9_62_id_ecPublicKey "id-ecPublicKey" ++#define NID_X9_62_id_ecPublicKey 408 ++#define OBJ_X9_62_id_ecPublicKey OBJ_X9_62_id_publicKeyType,1L ++ ++#define OBJ_X9_62_ellipticCurve OBJ_ansi_X9_62,3L ++ ++#define OBJ_X9_62_c_TwoCurve OBJ_X9_62_ellipticCurve,0L ++ ++#define SN_X9_62_c2pnb163v1 "c2pnb163v1" ++#define NID_X9_62_c2pnb163v1 684 ++#define OBJ_X9_62_c2pnb163v1 OBJ_X9_62_c_TwoCurve,1L ++ ++#define SN_X9_62_c2pnb163v2 "c2pnb163v2" ++#define NID_X9_62_c2pnb163v2 685 ++#define OBJ_X9_62_c2pnb163v2 OBJ_X9_62_c_TwoCurve,2L ++ ++#define SN_X9_62_c2pnb163v3 "c2pnb163v3" ++#define NID_X9_62_c2pnb163v3 686 ++#define OBJ_X9_62_c2pnb163v3 OBJ_X9_62_c_TwoCurve,3L ++ ++#define SN_X9_62_c2pnb176v1 "c2pnb176v1" ++#define NID_X9_62_c2pnb176v1 687 ++#define OBJ_X9_62_c2pnb176v1 OBJ_X9_62_c_TwoCurve,4L ++ ++#define SN_X9_62_c2tnb191v1 "c2tnb191v1" ++#define NID_X9_62_c2tnb191v1 688 ++#define OBJ_X9_62_c2tnb191v1 OBJ_X9_62_c_TwoCurve,5L ++ ++#define SN_X9_62_c2tnb191v2 "c2tnb191v2" ++#define NID_X9_62_c2tnb191v2 689 ++#define OBJ_X9_62_c2tnb191v2 OBJ_X9_62_c_TwoCurve,6L ++ ++#define SN_X9_62_c2tnb191v3 "c2tnb191v3" ++#define NID_X9_62_c2tnb191v3 690 ++#define OBJ_X9_62_c2tnb191v3 OBJ_X9_62_c_TwoCurve,7L ++ ++#define SN_X9_62_c2onb191v4 "c2onb191v4" ++#define NID_X9_62_c2onb191v4 691 ++#define OBJ_X9_62_c2onb191v4 OBJ_X9_62_c_TwoCurve,8L ++ ++#define SN_X9_62_c2onb191v5 "c2onb191v5" ++#define NID_X9_62_c2onb191v5 692 ++#define OBJ_X9_62_c2onb191v5 OBJ_X9_62_c_TwoCurve,9L ++ ++#define SN_X9_62_c2pnb208w1 "c2pnb208w1" ++#define NID_X9_62_c2pnb208w1 693 ++#define OBJ_X9_62_c2pnb208w1 OBJ_X9_62_c_TwoCurve,10L ++ ++#define SN_X9_62_c2tnb239v1 "c2tnb239v1" ++#define NID_X9_62_c2tnb239v1 694 ++#define OBJ_X9_62_c2tnb239v1 OBJ_X9_62_c_TwoCurve,11L ++ ++#define SN_X9_62_c2tnb239v2 "c2tnb239v2" ++#define NID_X9_62_c2tnb239v2 695 ++#define OBJ_X9_62_c2tnb239v2 OBJ_X9_62_c_TwoCurve,12L ++ ++#define SN_X9_62_c2tnb239v3 "c2tnb239v3" ++#define NID_X9_62_c2tnb239v3 696 ++#define OBJ_X9_62_c2tnb239v3 OBJ_X9_62_c_TwoCurve,13L ++ ++#define SN_X9_62_c2onb239v4 "c2onb239v4" ++#define NID_X9_62_c2onb239v4 697 ++#define OBJ_X9_62_c2onb239v4 OBJ_X9_62_c_TwoCurve,14L ++ ++#define SN_X9_62_c2onb239v5 "c2onb239v5" ++#define NID_X9_62_c2onb239v5 698 ++#define OBJ_X9_62_c2onb239v5 OBJ_X9_62_c_TwoCurve,15L ++ ++#define SN_X9_62_c2pnb272w1 "c2pnb272w1" ++#define NID_X9_62_c2pnb272w1 699 ++#define OBJ_X9_62_c2pnb272w1 OBJ_X9_62_c_TwoCurve,16L ++ ++#define SN_X9_62_c2pnb304w1 "c2pnb304w1" ++#define NID_X9_62_c2pnb304w1 700 ++#define OBJ_X9_62_c2pnb304w1 OBJ_X9_62_c_TwoCurve,17L ++ ++#define SN_X9_62_c2tnb359v1 "c2tnb359v1" ++#define NID_X9_62_c2tnb359v1 701 ++#define OBJ_X9_62_c2tnb359v1 OBJ_X9_62_c_TwoCurve,18L ++ ++#define SN_X9_62_c2pnb368w1 "c2pnb368w1" ++#define NID_X9_62_c2pnb368w1 702 ++#define OBJ_X9_62_c2pnb368w1 OBJ_X9_62_c_TwoCurve,19L ++ ++#define SN_X9_62_c2tnb431r1 "c2tnb431r1" ++#define NID_X9_62_c2tnb431r1 703 ++#define OBJ_X9_62_c2tnb431r1 OBJ_X9_62_c_TwoCurve,20L ++ ++#define OBJ_X9_62_primeCurve OBJ_X9_62_ellipticCurve,1L ++ ++#define SN_X9_62_prime192v1 "prime192v1" ++#define NID_X9_62_prime192v1 409 ++#define OBJ_X9_62_prime192v1 OBJ_X9_62_primeCurve,1L ++ ++#define SN_X9_62_prime192v2 "prime192v2" ++#define NID_X9_62_prime192v2 410 ++#define OBJ_X9_62_prime192v2 OBJ_X9_62_primeCurve,2L ++ ++#define SN_X9_62_prime192v3 "prime192v3" ++#define NID_X9_62_prime192v3 411 ++#define OBJ_X9_62_prime192v3 OBJ_X9_62_primeCurve,3L ++ ++#define SN_X9_62_prime239v1 "prime239v1" ++#define NID_X9_62_prime239v1 412 ++#define OBJ_X9_62_prime239v1 OBJ_X9_62_primeCurve,4L ++ ++#define SN_X9_62_prime239v2 "prime239v2" ++#define NID_X9_62_prime239v2 413 ++#define OBJ_X9_62_prime239v2 OBJ_X9_62_primeCurve,5L ++ ++#define SN_X9_62_prime239v3 "prime239v3" ++#define NID_X9_62_prime239v3 414 ++#define OBJ_X9_62_prime239v3 OBJ_X9_62_primeCurve,6L ++ ++#define SN_X9_62_prime256v1 "prime256v1" ++#define NID_X9_62_prime256v1 415 ++#define OBJ_X9_62_prime256v1 OBJ_X9_62_primeCurve,7L ++ ++#define OBJ_X9_62_id_ecSigType OBJ_ansi_X9_62,4L ++ ++#define SN_ecdsa_with_SHA1 "ecdsa-with-SHA1" ++#define NID_ecdsa_with_SHA1 416 ++#define OBJ_ecdsa_with_SHA1 OBJ_X9_62_id_ecSigType,1L ++ ++#define SN_ecdsa_with_Recommended "ecdsa-with-Recommended" ++#define NID_ecdsa_with_Recommended 791 ++#define OBJ_ecdsa_with_Recommended OBJ_X9_62_id_ecSigType,2L ++ ++#define SN_ecdsa_with_Specified "ecdsa-with-Specified" ++#define NID_ecdsa_with_Specified 792 ++#define OBJ_ecdsa_with_Specified OBJ_X9_62_id_ecSigType,3L ++ ++#define SN_ecdsa_with_SHA224 "ecdsa-with-SHA224" ++#define NID_ecdsa_with_SHA224 793 ++#define OBJ_ecdsa_with_SHA224 OBJ_ecdsa_with_Specified,1L ++ ++#define SN_ecdsa_with_SHA256 "ecdsa-with-SHA256" ++#define NID_ecdsa_with_SHA256 794 ++#define OBJ_ecdsa_with_SHA256 OBJ_ecdsa_with_Specified,2L ++ ++#define SN_ecdsa_with_SHA384 "ecdsa-with-SHA384" ++#define NID_ecdsa_with_SHA384 795 ++#define OBJ_ecdsa_with_SHA384 OBJ_ecdsa_with_Specified,3L ++ ++#define SN_ecdsa_with_SHA512 "ecdsa-with-SHA512" ++#define NID_ecdsa_with_SHA512 796 ++#define OBJ_ecdsa_with_SHA512 OBJ_ecdsa_with_Specified,4L ++ ++#define SN_ec192wapi "ec192wapi" ++#define NID_ec192wapi 1214 ++#define OBJ_ec192wapi OBJ_ISO_CN,11235L,1L,1L,2L,1L ++ ++#define SN_ec192wapi_with_SHA256 "ec192wapi-with-SHA256" ++#define NID_ec192wapi_with_SHA256 1215 ++#define OBJ_ec192wapi_with_SHA256 OBJ_ISO_CN,11235L,1L,1L,1L ++ ++#define OBJ_secg_ellipticCurve OBJ_certicom_arc,0L ++ ++#define SN_secp112r1 "secp112r1" ++#define NID_secp112r1 704 ++#define OBJ_secp112r1 OBJ_secg_ellipticCurve,6L ++ ++#define SN_secp112r2 "secp112r2" ++#define NID_secp112r2 705 ++#define OBJ_secp112r2 OBJ_secg_ellipticCurve,7L ++ ++#define SN_secp128r1 "secp128r1" ++#define NID_secp128r1 706 ++#define OBJ_secp128r1 OBJ_secg_ellipticCurve,28L ++ ++#define SN_secp128r2 "secp128r2" ++#define NID_secp128r2 707 ++#define OBJ_secp128r2 OBJ_secg_ellipticCurve,29L ++ ++#define SN_secp160k1 "secp160k1" ++#define NID_secp160k1 708 ++#define OBJ_secp160k1 OBJ_secg_ellipticCurve,9L ++ ++#define SN_secp160r1 "secp160r1" ++#define NID_secp160r1 709 ++#define OBJ_secp160r1 OBJ_secg_ellipticCurve,8L ++ ++#define SN_secp160r2 "secp160r2" ++#define NID_secp160r2 710 ++#define OBJ_secp160r2 OBJ_secg_ellipticCurve,30L ++ ++#define SN_secp192k1 "secp192k1" ++#define NID_secp192k1 711 ++#define OBJ_secp192k1 OBJ_secg_ellipticCurve,31L ++ ++#define SN_secp224k1 "secp224k1" ++#define NID_secp224k1 712 ++#define OBJ_secp224k1 OBJ_secg_ellipticCurve,32L ++ ++#define SN_secp224r1 "secp224r1" ++#define NID_secp224r1 713 ++#define OBJ_secp224r1 OBJ_secg_ellipticCurve,33L ++ ++#define SN_secp256k1 "secp256k1" ++#define NID_secp256k1 714 ++#define OBJ_secp256k1 OBJ_secg_ellipticCurve,10L ++ ++#define SN_secp384r1 "secp384r1" ++#define NID_secp384r1 715 ++#define OBJ_secp384r1 OBJ_secg_ellipticCurve,34L ++ ++#define SN_secp521r1 "secp521r1" ++#define NID_secp521r1 716 ++#define OBJ_secp521r1 OBJ_secg_ellipticCurve,35L ++ ++#define SN_sect113r1 "sect113r1" ++#define NID_sect113r1 717 ++#define OBJ_sect113r1 OBJ_secg_ellipticCurve,4L ++ ++#define SN_sect113r2 "sect113r2" ++#define NID_sect113r2 718 ++#define OBJ_sect113r2 OBJ_secg_ellipticCurve,5L ++ ++#define SN_sect131r1 "sect131r1" ++#define NID_sect131r1 719 ++#define OBJ_sect131r1 OBJ_secg_ellipticCurve,22L ++ ++#define SN_sect131r2 "sect131r2" ++#define NID_sect131r2 720 ++#define OBJ_sect131r2 OBJ_secg_ellipticCurve,23L ++ ++#define SN_sect163k1 "sect163k1" ++#define NID_sect163k1 721 ++#define OBJ_sect163k1 OBJ_secg_ellipticCurve,1L ++ ++#define SN_sect163r1 "sect163r1" ++#define NID_sect163r1 722 ++#define OBJ_sect163r1 OBJ_secg_ellipticCurve,2L ++ ++#define SN_sect163r2 "sect163r2" ++#define NID_sect163r2 723 ++#define OBJ_sect163r2 OBJ_secg_ellipticCurve,15L ++ ++#define SN_sect193r1 "sect193r1" ++#define NID_sect193r1 724 ++#define OBJ_sect193r1 OBJ_secg_ellipticCurve,24L ++ ++#define SN_sect193r2 "sect193r2" ++#define NID_sect193r2 725 ++#define OBJ_sect193r2 OBJ_secg_ellipticCurve,25L ++ ++#define SN_sect233k1 "sect233k1" ++#define NID_sect233k1 726 ++#define OBJ_sect233k1 OBJ_secg_ellipticCurve,26L ++ ++#define SN_sect233r1 "sect233r1" ++#define NID_sect233r1 727 ++#define OBJ_sect233r1 OBJ_secg_ellipticCurve,27L ++ ++#define SN_sect239k1 "sect239k1" ++#define NID_sect239k1 728 ++#define OBJ_sect239k1 OBJ_secg_ellipticCurve,3L ++ ++#define SN_sect283k1 "sect283k1" ++#define NID_sect283k1 729 ++#define OBJ_sect283k1 OBJ_secg_ellipticCurve,16L ++ ++#define SN_sect283r1 "sect283r1" ++#define NID_sect283r1 730 ++#define OBJ_sect283r1 OBJ_secg_ellipticCurve,17L ++ ++#define SN_sect409k1 "sect409k1" ++#define NID_sect409k1 731 ++#define OBJ_sect409k1 OBJ_secg_ellipticCurve,36L ++ ++#define SN_sect409r1 "sect409r1" ++#define NID_sect409r1 732 ++#define OBJ_sect409r1 OBJ_secg_ellipticCurve,37L ++ ++#define SN_sect571k1 "sect571k1" ++#define NID_sect571k1 733 ++#define OBJ_sect571k1 OBJ_secg_ellipticCurve,38L ++ ++#define SN_sect571r1 "sect571r1" ++#define NID_sect571r1 734 ++#define OBJ_sect571r1 OBJ_secg_ellipticCurve,39L ++ ++#define OBJ_wap_wsg_idm_ecid OBJ_wap_wsg,4L ++ ++#define SN_wap_wsg_idm_ecid_wtls1 "wap-wsg-idm-ecid-wtls1" ++#define NID_wap_wsg_idm_ecid_wtls1 735 ++#define OBJ_wap_wsg_idm_ecid_wtls1 OBJ_wap_wsg_idm_ecid,1L ++ ++#define SN_wap_wsg_idm_ecid_wtls3 "wap-wsg-idm-ecid-wtls3" ++#define NID_wap_wsg_idm_ecid_wtls3 736 ++#define OBJ_wap_wsg_idm_ecid_wtls3 OBJ_wap_wsg_idm_ecid,3L ++ ++#define SN_wap_wsg_idm_ecid_wtls4 "wap-wsg-idm-ecid-wtls4" ++#define NID_wap_wsg_idm_ecid_wtls4 737 ++#define OBJ_wap_wsg_idm_ecid_wtls4 OBJ_wap_wsg_idm_ecid,4L ++ ++#define SN_wap_wsg_idm_ecid_wtls5 "wap-wsg-idm-ecid-wtls5" ++#define NID_wap_wsg_idm_ecid_wtls5 738 ++#define OBJ_wap_wsg_idm_ecid_wtls5 OBJ_wap_wsg_idm_ecid,5L ++ ++#define SN_wap_wsg_idm_ecid_wtls6 "wap-wsg-idm-ecid-wtls6" ++#define NID_wap_wsg_idm_ecid_wtls6 739 ++#define OBJ_wap_wsg_idm_ecid_wtls6 OBJ_wap_wsg_idm_ecid,6L ++ ++#define SN_wap_wsg_idm_ecid_wtls7 "wap-wsg-idm-ecid-wtls7" ++#define NID_wap_wsg_idm_ecid_wtls7 740 ++#define OBJ_wap_wsg_idm_ecid_wtls7 OBJ_wap_wsg_idm_ecid,7L ++ ++#define SN_wap_wsg_idm_ecid_wtls8 "wap-wsg-idm-ecid-wtls8" ++#define NID_wap_wsg_idm_ecid_wtls8 741 ++#define OBJ_wap_wsg_idm_ecid_wtls8 OBJ_wap_wsg_idm_ecid,8L ++ ++#define SN_wap_wsg_idm_ecid_wtls9 "wap-wsg-idm-ecid-wtls9" ++#define NID_wap_wsg_idm_ecid_wtls9 742 ++#define OBJ_wap_wsg_idm_ecid_wtls9 OBJ_wap_wsg_idm_ecid,9L ++ ++#define SN_wap_wsg_idm_ecid_wtls10 "wap-wsg-idm-ecid-wtls10" ++#define NID_wap_wsg_idm_ecid_wtls10 743 ++#define OBJ_wap_wsg_idm_ecid_wtls10 OBJ_wap_wsg_idm_ecid,10L ++ ++#define SN_wap_wsg_idm_ecid_wtls11 "wap-wsg-idm-ecid-wtls11" ++#define NID_wap_wsg_idm_ecid_wtls11 744 ++#define OBJ_wap_wsg_idm_ecid_wtls11 OBJ_wap_wsg_idm_ecid,11L ++ ++#define SN_wap_wsg_idm_ecid_wtls12 "wap-wsg-idm-ecid-wtls12" ++#define NID_wap_wsg_idm_ecid_wtls12 745 ++#define OBJ_wap_wsg_idm_ecid_wtls12 OBJ_wap_wsg_idm_ecid,12L ++ ++#define SN_cast5_cbc "CAST5-CBC" ++#define LN_cast5_cbc "cast5-cbc" ++#define NID_cast5_cbc 108 ++#define OBJ_cast5_cbc OBJ_ISO_US,113533L,7L,66L,10L ++ ++#define SN_cast5_ecb "CAST5-ECB" ++#define LN_cast5_ecb "cast5-ecb" ++#define NID_cast5_ecb 109 ++ ++#define SN_cast5_cfb64 "CAST5-CFB" ++#define LN_cast5_cfb64 "cast5-cfb" ++#define NID_cast5_cfb64 110 ++ ++#define SN_cast5_ofb64 "CAST5-OFB" ++#define LN_cast5_ofb64 "cast5-ofb" ++#define NID_cast5_ofb64 111 ++ ++#define LN_pbeWithMD5AndCast5_CBC "pbeWithMD5AndCast5CBC" ++#define NID_pbeWithMD5AndCast5_CBC 112 ++#define OBJ_pbeWithMD5AndCast5_CBC OBJ_ISO_US,113533L,7L,66L,12L ++ ++#define SN_id_PasswordBasedMAC "id-PasswordBasedMAC" ++#define LN_id_PasswordBasedMAC "password based MAC" ++#define NID_id_PasswordBasedMAC 782 ++#define OBJ_id_PasswordBasedMAC OBJ_ISO_US,113533L,7L,66L,13L ++ ++#define SN_id_DHBasedMac "id-DHBasedMac" ++#define LN_id_DHBasedMac "Diffie-Hellman based MAC" ++#define NID_id_DHBasedMac 783 ++#define OBJ_id_DHBasedMac OBJ_ISO_US,113533L,7L,66L,30L ++ ++#define SN_rsadsi "rsadsi" ++#define LN_rsadsi "RSA Data Security, Inc." ++#define NID_rsadsi 1 ++#define OBJ_rsadsi OBJ_ISO_US,113549L ++ ++#define SN_pkcs "pkcs" ++#define LN_pkcs "RSA Data Security, Inc. PKCS" ++#define NID_pkcs 2 ++#define OBJ_pkcs OBJ_rsadsi,1L ++ ++#define SN_pkcs1 "pkcs1" ++#define NID_pkcs1 186 ++#define OBJ_pkcs1 OBJ_pkcs,1L ++ ++#define LN_rsaEncryption "rsaEncryption" ++#define NID_rsaEncryption 6 ++#define OBJ_rsaEncryption OBJ_pkcs1,1L ++ ++#define SN_md2WithRSAEncryption "RSA-MD2" ++#define LN_md2WithRSAEncryption "md2WithRSAEncryption" ++#define NID_md2WithRSAEncryption 7 ++#define OBJ_md2WithRSAEncryption OBJ_pkcs1,2L ++ ++#define SN_md4WithRSAEncryption "RSA-MD4" ++#define LN_md4WithRSAEncryption "md4WithRSAEncryption" ++#define NID_md4WithRSAEncryption 396 ++#define OBJ_md4WithRSAEncryption OBJ_pkcs1,3L ++ ++#define SN_md5WithRSAEncryption "RSA-MD5" ++#define LN_md5WithRSAEncryption "md5WithRSAEncryption" ++#define NID_md5WithRSAEncryption 8 ++#define OBJ_md5WithRSAEncryption OBJ_pkcs1,4L ++ ++#define SN_sha1WithRSAEncryption "RSA-SHA1" ++#define LN_sha1WithRSAEncryption "sha1WithRSAEncryption" ++#define NID_sha1WithRSAEncryption 65 ++#define OBJ_sha1WithRSAEncryption OBJ_pkcs1,5L ++ ++#define SN_rsaesOaep "RSAES-OAEP" ++#define LN_rsaesOaep "rsaesOaep" ++#define NID_rsaesOaep 919 ++#define OBJ_rsaesOaep OBJ_pkcs1,7L ++ ++#define SN_mgf1 "MGF1" ++#define LN_mgf1 "mgf1" ++#define NID_mgf1 911 ++#define OBJ_mgf1 OBJ_pkcs1,8L ++ ++#define SN_pSpecified "PSPECIFIED" ++#define LN_pSpecified "pSpecified" ++#define NID_pSpecified 935 ++#define OBJ_pSpecified OBJ_pkcs1,9L ++ ++#define SN_rsassaPss "RSASSA-PSS" ++#define LN_rsassaPss "rsassaPss" ++#define NID_rsassaPss 912 ++#define OBJ_rsassaPss OBJ_pkcs1,10L ++ ++#define SN_sha256WithRSAEncryption "RSA-SHA256" ++#define LN_sha256WithRSAEncryption "sha256WithRSAEncryption" ++#define NID_sha256WithRSAEncryption 668 ++#define OBJ_sha256WithRSAEncryption OBJ_pkcs1,11L ++ ++#define SN_sha384WithRSAEncryption "RSA-SHA384" ++#define LN_sha384WithRSAEncryption "sha384WithRSAEncryption" ++#define NID_sha384WithRSAEncryption 669 ++#define OBJ_sha384WithRSAEncryption OBJ_pkcs1,12L ++ ++#define SN_sha512WithRSAEncryption "RSA-SHA512" ++#define LN_sha512WithRSAEncryption "sha512WithRSAEncryption" ++#define NID_sha512WithRSAEncryption 670 ++#define OBJ_sha512WithRSAEncryption OBJ_pkcs1,13L ++ ++#define SN_sha224WithRSAEncryption "RSA-SHA224" ++#define LN_sha224WithRSAEncryption "sha224WithRSAEncryption" ++#define NID_sha224WithRSAEncryption 671 ++#define OBJ_sha224WithRSAEncryption OBJ_pkcs1,14L ++ ++#define SN_sha512_224WithRSAEncryption "RSA-SHA512/224" ++#define LN_sha512_224WithRSAEncryption "sha512-224WithRSAEncryption" ++#define NID_sha512_224WithRSAEncryption 1145 ++#define OBJ_sha512_224WithRSAEncryption OBJ_pkcs1,15L ++ ++#define SN_sha512_256WithRSAEncryption "RSA-SHA512/256" ++#define LN_sha512_256WithRSAEncryption "sha512-256WithRSAEncryption" ++#define NID_sha512_256WithRSAEncryption 1146 ++#define OBJ_sha512_256WithRSAEncryption OBJ_pkcs1,16L ++ ++#define SN_pkcs3 "pkcs3" ++#define NID_pkcs3 27 ++#define OBJ_pkcs3 OBJ_pkcs,3L ++ ++#define LN_dhKeyAgreement "dhKeyAgreement" ++#define NID_dhKeyAgreement 28 ++#define OBJ_dhKeyAgreement OBJ_pkcs3,1L ++ ++#define SN_pkcs5 "pkcs5" ++#define NID_pkcs5 187 ++#define OBJ_pkcs5 OBJ_pkcs,5L ++ ++#define SN_pbeWithMD2AndDES_CBC "PBE-MD2-DES" ++#define LN_pbeWithMD2AndDES_CBC "pbeWithMD2AndDES-CBC" ++#define NID_pbeWithMD2AndDES_CBC 9 ++#define OBJ_pbeWithMD2AndDES_CBC OBJ_pkcs5,1L ++ ++#define SN_pbeWithMD5AndDES_CBC "PBE-MD5-DES" ++#define LN_pbeWithMD5AndDES_CBC "pbeWithMD5AndDES-CBC" ++#define NID_pbeWithMD5AndDES_CBC 10 ++#define OBJ_pbeWithMD5AndDES_CBC OBJ_pkcs5,3L ++ ++#define SN_pbeWithMD2AndRC2_CBC "PBE-MD2-RC2-64" ++#define LN_pbeWithMD2AndRC2_CBC "pbeWithMD2AndRC2-CBC" ++#define NID_pbeWithMD2AndRC2_CBC 168 ++#define OBJ_pbeWithMD2AndRC2_CBC OBJ_pkcs5,4L ++ ++#define SN_pbeWithMD5AndRC2_CBC "PBE-MD5-RC2-64" ++#define LN_pbeWithMD5AndRC2_CBC "pbeWithMD5AndRC2-CBC" ++#define NID_pbeWithMD5AndRC2_CBC 169 ++#define OBJ_pbeWithMD5AndRC2_CBC OBJ_pkcs5,6L ++ ++#define SN_pbeWithSHA1AndDES_CBC "PBE-SHA1-DES" ++#define LN_pbeWithSHA1AndDES_CBC "pbeWithSHA1AndDES-CBC" ++#define NID_pbeWithSHA1AndDES_CBC 170 ++#define OBJ_pbeWithSHA1AndDES_CBC OBJ_pkcs5,10L ++ ++#define SN_pbeWithSHA1AndRC2_CBC "PBE-SHA1-RC2-64" ++#define LN_pbeWithSHA1AndRC2_CBC "pbeWithSHA1AndRC2-CBC" ++#define NID_pbeWithSHA1AndRC2_CBC 68 ++#define OBJ_pbeWithSHA1AndRC2_CBC OBJ_pkcs5,11L ++ ++#define LN_id_pbkdf2 "PBKDF2" ++#define NID_id_pbkdf2 69 ++#define OBJ_id_pbkdf2 OBJ_pkcs5,12L ++ ++#define LN_pbes2 "PBES2" ++#define NID_pbes2 161 ++#define OBJ_pbes2 OBJ_pkcs5,13L ++ ++#define LN_pbmac1 "PBMAC1" ++#define NID_pbmac1 162 ++#define OBJ_pbmac1 OBJ_pkcs5,14L ++ ++#define SN_pkcs7 "pkcs7" ++#define NID_pkcs7 20 ++#define OBJ_pkcs7 OBJ_pkcs,7L ++ ++#define LN_pkcs7_data "pkcs7-data" ++#define NID_pkcs7_data 21 ++#define OBJ_pkcs7_data OBJ_pkcs7,1L ++ ++#define LN_pkcs7_signed "pkcs7-signedData" ++#define NID_pkcs7_signed 22 ++#define OBJ_pkcs7_signed OBJ_pkcs7,2L ++ ++#define LN_pkcs7_enveloped "pkcs7-envelopedData" ++#define NID_pkcs7_enveloped 23 ++#define OBJ_pkcs7_enveloped OBJ_pkcs7,3L ++ ++#define LN_pkcs7_signedAndEnveloped "pkcs7-signedAndEnvelopedData" ++#define NID_pkcs7_signedAndEnveloped 24 ++#define OBJ_pkcs7_signedAndEnveloped OBJ_pkcs7,4L ++ ++#define LN_pkcs7_digest "pkcs7-digestData" ++#define NID_pkcs7_digest 25 ++#define OBJ_pkcs7_digest OBJ_pkcs7,5L ++ ++#define LN_pkcs7_encrypted "pkcs7-encryptedData" ++#define NID_pkcs7_encrypted 26 ++#define OBJ_pkcs7_encrypted OBJ_pkcs7,6L ++ ++#define SN_pkcs9 "pkcs9" ++#define NID_pkcs9 47 ++#define OBJ_pkcs9 OBJ_pkcs,9L ++ ++#define LN_pkcs9_emailAddress "emailAddress" ++#define NID_pkcs9_emailAddress 48 ++#define OBJ_pkcs9_emailAddress OBJ_pkcs9,1L ++ ++#define LN_pkcs9_unstructuredName "unstructuredName" ++#define NID_pkcs9_unstructuredName 49 ++#define OBJ_pkcs9_unstructuredName OBJ_pkcs9,2L ++ ++#define LN_pkcs9_contentType "contentType" ++#define NID_pkcs9_contentType 50 ++#define OBJ_pkcs9_contentType OBJ_pkcs9,3L ++ ++#define LN_pkcs9_messageDigest "messageDigest" ++#define NID_pkcs9_messageDigest 51 ++#define OBJ_pkcs9_messageDigest OBJ_pkcs9,4L ++ ++#define LN_pkcs9_signingTime "signingTime" ++#define NID_pkcs9_signingTime 52 ++#define OBJ_pkcs9_signingTime OBJ_pkcs9,5L ++ ++#define LN_pkcs9_countersignature "countersignature" ++#define NID_pkcs9_countersignature 53 ++#define OBJ_pkcs9_countersignature OBJ_pkcs9,6L ++ ++#define LN_pkcs9_challengePassword "challengePassword" ++#define NID_pkcs9_challengePassword 54 ++#define OBJ_pkcs9_challengePassword OBJ_pkcs9,7L ++ ++#define LN_pkcs9_unstructuredAddress "unstructuredAddress" ++#define NID_pkcs9_unstructuredAddress 55 ++#define OBJ_pkcs9_unstructuredAddress OBJ_pkcs9,8L ++ ++#define LN_pkcs9_extCertAttributes "extendedCertificateAttributes" ++#define NID_pkcs9_extCertAttributes 56 ++#define OBJ_pkcs9_extCertAttributes OBJ_pkcs9,9L ++ ++#define SN_ext_req "extReq" ++#define LN_ext_req "Extension Request" ++#define NID_ext_req 172 ++#define OBJ_ext_req OBJ_pkcs9,14L ++ ++#define SN_SMIMECapabilities "SMIME-CAPS" ++#define LN_SMIMECapabilities "S/MIME Capabilities" ++#define NID_SMIMECapabilities 167 ++#define OBJ_SMIMECapabilities OBJ_pkcs9,15L ++ ++#define SN_SMIME "SMIME" ++#define LN_SMIME "S/MIME" ++#define NID_SMIME 188 ++#define OBJ_SMIME OBJ_pkcs9,16L ++ ++#define SN_id_smime_mod "id-smime-mod" ++#define NID_id_smime_mod 189 ++#define OBJ_id_smime_mod OBJ_SMIME,0L ++ ++#define SN_id_smime_ct "id-smime-ct" ++#define NID_id_smime_ct 190 ++#define OBJ_id_smime_ct OBJ_SMIME,1L ++ ++#define SN_id_smime_aa "id-smime-aa" ++#define NID_id_smime_aa 191 ++#define OBJ_id_smime_aa OBJ_SMIME,2L ++ ++#define SN_id_smime_alg "id-smime-alg" ++#define NID_id_smime_alg 192 ++#define OBJ_id_smime_alg OBJ_SMIME,3L ++ ++#define SN_id_smime_cd "id-smime-cd" ++#define NID_id_smime_cd 193 ++#define OBJ_id_smime_cd OBJ_SMIME,4L ++ ++#define SN_id_smime_spq "id-smime-spq" ++#define NID_id_smime_spq 194 ++#define OBJ_id_smime_spq OBJ_SMIME,5L ++ ++#define SN_id_smime_cti "id-smime-cti" ++#define NID_id_smime_cti 195 ++#define OBJ_id_smime_cti OBJ_SMIME,6L ++ ++#define SN_id_smime_mod_cms "id-smime-mod-cms" ++#define NID_id_smime_mod_cms 196 ++#define OBJ_id_smime_mod_cms OBJ_id_smime_mod,1L ++ ++#define SN_id_smime_mod_ess "id-smime-mod-ess" ++#define NID_id_smime_mod_ess 197 ++#define OBJ_id_smime_mod_ess OBJ_id_smime_mod,2L ++ ++#define SN_id_smime_mod_oid "id-smime-mod-oid" ++#define NID_id_smime_mod_oid 198 ++#define OBJ_id_smime_mod_oid OBJ_id_smime_mod,3L ++ ++#define SN_id_smime_mod_msg_v3 "id-smime-mod-msg-v3" ++#define NID_id_smime_mod_msg_v3 199 ++#define OBJ_id_smime_mod_msg_v3 OBJ_id_smime_mod,4L ++ ++#define SN_id_smime_mod_ets_eSignature_88 "id-smime-mod-ets-eSignature-88" ++#define NID_id_smime_mod_ets_eSignature_88 200 ++#define OBJ_id_smime_mod_ets_eSignature_88 OBJ_id_smime_mod,5L ++ ++#define SN_id_smime_mod_ets_eSignature_97 "id-smime-mod-ets-eSignature-97" ++#define NID_id_smime_mod_ets_eSignature_97 201 ++#define OBJ_id_smime_mod_ets_eSignature_97 OBJ_id_smime_mod,6L ++ ++#define SN_id_smime_mod_ets_eSigPolicy_88 "id-smime-mod-ets-eSigPolicy-88" ++#define NID_id_smime_mod_ets_eSigPolicy_88 202 ++#define OBJ_id_smime_mod_ets_eSigPolicy_88 OBJ_id_smime_mod,7L ++ ++#define SN_id_smime_mod_ets_eSigPolicy_97 "id-smime-mod-ets-eSigPolicy-97" ++#define NID_id_smime_mod_ets_eSigPolicy_97 203 ++#define OBJ_id_smime_mod_ets_eSigPolicy_97 OBJ_id_smime_mod,8L ++ ++#define SN_id_smime_ct_receipt "id-smime-ct-receipt" ++#define NID_id_smime_ct_receipt 204 ++#define OBJ_id_smime_ct_receipt OBJ_id_smime_ct,1L ++ ++#define SN_id_smime_ct_authData "id-smime-ct-authData" ++#define NID_id_smime_ct_authData 205 ++#define OBJ_id_smime_ct_authData OBJ_id_smime_ct,2L ++ ++#define SN_id_smime_ct_publishCert "id-smime-ct-publishCert" ++#define NID_id_smime_ct_publishCert 206 ++#define OBJ_id_smime_ct_publishCert OBJ_id_smime_ct,3L ++ ++#define SN_id_smime_ct_TSTInfo "id-smime-ct-TSTInfo" ++#define NID_id_smime_ct_TSTInfo 207 ++#define OBJ_id_smime_ct_TSTInfo OBJ_id_smime_ct,4L ++ ++#define SN_id_smime_ct_TDTInfo "id-smime-ct-TDTInfo" ++#define NID_id_smime_ct_TDTInfo 208 ++#define OBJ_id_smime_ct_TDTInfo OBJ_id_smime_ct,5L ++ ++#define SN_id_smime_ct_contentInfo "id-smime-ct-contentInfo" ++#define NID_id_smime_ct_contentInfo 209 ++#define OBJ_id_smime_ct_contentInfo OBJ_id_smime_ct,6L ++ ++#define SN_id_smime_ct_DVCSRequestData "id-smime-ct-DVCSRequestData" ++#define NID_id_smime_ct_DVCSRequestData 210 ++#define OBJ_id_smime_ct_DVCSRequestData OBJ_id_smime_ct,7L ++ ++#define SN_id_smime_ct_DVCSResponseData "id-smime-ct-DVCSResponseData" ++#define NID_id_smime_ct_DVCSResponseData 211 ++#define OBJ_id_smime_ct_DVCSResponseData OBJ_id_smime_ct,8L ++ ++#define SN_id_smime_ct_compressedData "id-smime-ct-compressedData" ++#define NID_id_smime_ct_compressedData 786 ++#define OBJ_id_smime_ct_compressedData OBJ_id_smime_ct,9L ++ ++#define SN_id_smime_ct_contentCollection "id-smime-ct-contentCollection" ++#define NID_id_smime_ct_contentCollection 1058 ++#define OBJ_id_smime_ct_contentCollection OBJ_id_smime_ct,19L ++ ++#define SN_id_smime_ct_authEnvelopedData "id-smime-ct-authEnvelopedData" ++#define NID_id_smime_ct_authEnvelopedData 1059 ++#define OBJ_id_smime_ct_authEnvelopedData OBJ_id_smime_ct,23L ++ ++#define SN_id_ct_asciiTextWithCRLF "id-ct-asciiTextWithCRLF" ++#define NID_id_ct_asciiTextWithCRLF 787 ++#define OBJ_id_ct_asciiTextWithCRLF OBJ_id_smime_ct,27L ++ ++#define SN_id_ct_xml "id-ct-xml" ++#define NID_id_ct_xml 1060 ++#define OBJ_id_ct_xml OBJ_id_smime_ct,28L ++ ++#define SN_id_smime_aa_receiptRequest "id-smime-aa-receiptRequest" ++#define NID_id_smime_aa_receiptRequest 212 ++#define OBJ_id_smime_aa_receiptRequest OBJ_id_smime_aa,1L ++ ++#define SN_id_smime_aa_securityLabel "id-smime-aa-securityLabel" ++#define NID_id_smime_aa_securityLabel 213 ++#define OBJ_id_smime_aa_securityLabel OBJ_id_smime_aa,2L ++ ++#define SN_id_smime_aa_mlExpandHistory "id-smime-aa-mlExpandHistory" ++#define NID_id_smime_aa_mlExpandHistory 214 ++#define OBJ_id_smime_aa_mlExpandHistory OBJ_id_smime_aa,3L ++ ++#define SN_id_smime_aa_contentHint "id-smime-aa-contentHint" ++#define NID_id_smime_aa_contentHint 215 ++#define OBJ_id_smime_aa_contentHint OBJ_id_smime_aa,4L ++ ++#define SN_id_smime_aa_msgSigDigest "id-smime-aa-msgSigDigest" ++#define NID_id_smime_aa_msgSigDigest 216 ++#define OBJ_id_smime_aa_msgSigDigest OBJ_id_smime_aa,5L ++ ++#define SN_id_smime_aa_encapContentType "id-smime-aa-encapContentType" ++#define NID_id_smime_aa_encapContentType 217 ++#define OBJ_id_smime_aa_encapContentType OBJ_id_smime_aa,6L ++ ++#define SN_id_smime_aa_contentIdentifier "id-smime-aa-contentIdentifier" ++#define NID_id_smime_aa_contentIdentifier 218 ++#define OBJ_id_smime_aa_contentIdentifier OBJ_id_smime_aa,7L ++ ++#define SN_id_smime_aa_macValue "id-smime-aa-macValue" ++#define NID_id_smime_aa_macValue 219 ++#define OBJ_id_smime_aa_macValue OBJ_id_smime_aa,8L ++ ++#define SN_id_smime_aa_equivalentLabels "id-smime-aa-equivalentLabels" ++#define NID_id_smime_aa_equivalentLabels 220 ++#define OBJ_id_smime_aa_equivalentLabels OBJ_id_smime_aa,9L ++ ++#define SN_id_smime_aa_contentReference "id-smime-aa-contentReference" ++#define NID_id_smime_aa_contentReference 221 ++#define OBJ_id_smime_aa_contentReference OBJ_id_smime_aa,10L ++ ++#define SN_id_smime_aa_encrypKeyPref "id-smime-aa-encrypKeyPref" ++#define NID_id_smime_aa_encrypKeyPref 222 ++#define OBJ_id_smime_aa_encrypKeyPref OBJ_id_smime_aa,11L ++ ++#define SN_id_smime_aa_signingCertificate "id-smime-aa-signingCertificate" ++#define NID_id_smime_aa_signingCertificate 223 ++#define OBJ_id_smime_aa_signingCertificate OBJ_id_smime_aa,12L ++ ++#define SN_id_smime_aa_smimeEncryptCerts "id-smime-aa-smimeEncryptCerts" ++#define NID_id_smime_aa_smimeEncryptCerts 224 ++#define OBJ_id_smime_aa_smimeEncryptCerts OBJ_id_smime_aa,13L ++ ++#define SN_id_smime_aa_timeStampToken "id-smime-aa-timeStampToken" ++#define NID_id_smime_aa_timeStampToken 225 ++#define OBJ_id_smime_aa_timeStampToken OBJ_id_smime_aa,14L ++ ++#define SN_id_smime_aa_ets_sigPolicyId "id-smime-aa-ets-sigPolicyId" ++#define NID_id_smime_aa_ets_sigPolicyId 226 ++#define OBJ_id_smime_aa_ets_sigPolicyId OBJ_id_smime_aa,15L ++ ++#define SN_id_smime_aa_ets_commitmentType "id-smime-aa-ets-commitmentType" ++#define NID_id_smime_aa_ets_commitmentType 227 ++#define OBJ_id_smime_aa_ets_commitmentType OBJ_id_smime_aa,16L ++ ++#define SN_id_smime_aa_ets_signerLocation "id-smime-aa-ets-signerLocation" ++#define NID_id_smime_aa_ets_signerLocation 228 ++#define OBJ_id_smime_aa_ets_signerLocation OBJ_id_smime_aa,17L ++ ++#define SN_id_smime_aa_ets_signerAttr "id-smime-aa-ets-signerAttr" ++#define NID_id_smime_aa_ets_signerAttr 229 ++#define OBJ_id_smime_aa_ets_signerAttr OBJ_id_smime_aa,18L ++ ++#define SN_id_smime_aa_ets_otherSigCert "id-smime-aa-ets-otherSigCert" ++#define NID_id_smime_aa_ets_otherSigCert 230 ++#define OBJ_id_smime_aa_ets_otherSigCert OBJ_id_smime_aa,19L ++ ++#define SN_id_smime_aa_ets_contentTimestamp "id-smime-aa-ets-contentTimestamp" ++#define NID_id_smime_aa_ets_contentTimestamp 231 ++#define OBJ_id_smime_aa_ets_contentTimestamp OBJ_id_smime_aa,20L ++ ++#define SN_id_smime_aa_ets_CertificateRefs "id-smime-aa-ets-CertificateRefs" ++#define NID_id_smime_aa_ets_CertificateRefs 232 ++#define OBJ_id_smime_aa_ets_CertificateRefs OBJ_id_smime_aa,21L ++ ++#define SN_id_smime_aa_ets_RevocationRefs "id-smime-aa-ets-RevocationRefs" ++#define NID_id_smime_aa_ets_RevocationRefs 233 ++#define OBJ_id_smime_aa_ets_RevocationRefs OBJ_id_smime_aa,22L ++ ++#define SN_id_smime_aa_ets_certValues "id-smime-aa-ets-certValues" ++#define NID_id_smime_aa_ets_certValues 234 ++#define OBJ_id_smime_aa_ets_certValues OBJ_id_smime_aa,23L ++ ++#define SN_id_smime_aa_ets_revocationValues "id-smime-aa-ets-revocationValues" ++#define NID_id_smime_aa_ets_revocationValues 235 ++#define OBJ_id_smime_aa_ets_revocationValues OBJ_id_smime_aa,24L ++ ++#define SN_id_smime_aa_ets_escTimeStamp "id-smime-aa-ets-escTimeStamp" ++#define NID_id_smime_aa_ets_escTimeStamp 236 ++#define OBJ_id_smime_aa_ets_escTimeStamp OBJ_id_smime_aa,25L ++ ++#define SN_id_smime_aa_ets_certCRLTimestamp "id-smime-aa-ets-certCRLTimestamp" ++#define NID_id_smime_aa_ets_certCRLTimestamp 237 ++#define OBJ_id_smime_aa_ets_certCRLTimestamp OBJ_id_smime_aa,26L ++ ++#define SN_id_smime_aa_ets_archiveTimeStamp "id-smime-aa-ets-archiveTimeStamp" ++#define NID_id_smime_aa_ets_archiveTimeStamp 238 ++#define OBJ_id_smime_aa_ets_archiveTimeStamp OBJ_id_smime_aa,27L ++ ++#define SN_id_smime_aa_signatureType "id-smime-aa-signatureType" ++#define NID_id_smime_aa_signatureType 239 ++#define OBJ_id_smime_aa_signatureType OBJ_id_smime_aa,28L ++ ++#define SN_id_smime_aa_dvcs_dvc "id-smime-aa-dvcs-dvc" ++#define NID_id_smime_aa_dvcs_dvc 240 ++#define OBJ_id_smime_aa_dvcs_dvc OBJ_id_smime_aa,29L ++ ++#define SN_id_smime_aa_signingCertificateV2 "id-smime-aa-signingCertificateV2" ++#define NID_id_smime_aa_signingCertificateV2 1086 ++#define OBJ_id_smime_aa_signingCertificateV2 OBJ_id_smime_aa,47L ++ ++#define SN_id_smime_alg_ESDHwith3DES "id-smime-alg-ESDHwith3DES" ++#define NID_id_smime_alg_ESDHwith3DES 241 ++#define OBJ_id_smime_alg_ESDHwith3DES OBJ_id_smime_alg,1L ++ ++#define SN_id_smime_alg_ESDHwithRC2 "id-smime-alg-ESDHwithRC2" ++#define NID_id_smime_alg_ESDHwithRC2 242 ++#define OBJ_id_smime_alg_ESDHwithRC2 OBJ_id_smime_alg,2L ++ ++#define SN_id_smime_alg_3DESwrap "id-smime-alg-3DESwrap" ++#define NID_id_smime_alg_3DESwrap 243 ++#define OBJ_id_smime_alg_3DESwrap OBJ_id_smime_alg,3L ++ ++#define SN_id_smime_alg_RC2wrap "id-smime-alg-RC2wrap" ++#define NID_id_smime_alg_RC2wrap 244 ++#define OBJ_id_smime_alg_RC2wrap OBJ_id_smime_alg,4L ++ ++#define SN_id_smime_alg_ESDH "id-smime-alg-ESDH" ++#define NID_id_smime_alg_ESDH 245 ++#define OBJ_id_smime_alg_ESDH OBJ_id_smime_alg,5L ++ ++#define SN_id_smime_alg_CMS3DESwrap "id-smime-alg-CMS3DESwrap" ++#define NID_id_smime_alg_CMS3DESwrap 246 ++#define OBJ_id_smime_alg_CMS3DESwrap OBJ_id_smime_alg,6L ++ ++#define SN_id_smime_alg_CMSRC2wrap "id-smime-alg-CMSRC2wrap" ++#define NID_id_smime_alg_CMSRC2wrap 247 ++#define OBJ_id_smime_alg_CMSRC2wrap OBJ_id_smime_alg,7L ++ ++#define SN_id_alg_PWRI_KEK "id-alg-PWRI-KEK" ++#define NID_id_alg_PWRI_KEK 893 ++#define OBJ_id_alg_PWRI_KEK OBJ_id_smime_alg,9L ++ ++#define SN_id_smime_cd_ldap "id-smime-cd-ldap" ++#define NID_id_smime_cd_ldap 248 ++#define OBJ_id_smime_cd_ldap OBJ_id_smime_cd,1L ++ ++#define SN_id_smime_spq_ets_sqt_uri "id-smime-spq-ets-sqt-uri" ++#define NID_id_smime_spq_ets_sqt_uri 249 ++#define OBJ_id_smime_spq_ets_sqt_uri OBJ_id_smime_spq,1L ++ ++#define SN_id_smime_spq_ets_sqt_unotice "id-smime-spq-ets-sqt-unotice" ++#define NID_id_smime_spq_ets_sqt_unotice 250 ++#define OBJ_id_smime_spq_ets_sqt_unotice OBJ_id_smime_spq,2L ++ ++#define SN_id_smime_cti_ets_proofOfOrigin "id-smime-cti-ets-proofOfOrigin" ++#define NID_id_smime_cti_ets_proofOfOrigin 251 ++#define OBJ_id_smime_cti_ets_proofOfOrigin OBJ_id_smime_cti,1L ++ ++#define SN_id_smime_cti_ets_proofOfReceipt "id-smime-cti-ets-proofOfReceipt" ++#define NID_id_smime_cti_ets_proofOfReceipt 252 ++#define OBJ_id_smime_cti_ets_proofOfReceipt OBJ_id_smime_cti,2L ++ ++#define SN_id_smime_cti_ets_proofOfDelivery "id-smime-cti-ets-proofOfDelivery" ++#define NID_id_smime_cti_ets_proofOfDelivery 253 ++#define OBJ_id_smime_cti_ets_proofOfDelivery OBJ_id_smime_cti,3L ++ ++#define SN_id_smime_cti_ets_proofOfSender "id-smime-cti-ets-proofOfSender" ++#define NID_id_smime_cti_ets_proofOfSender 254 ++#define OBJ_id_smime_cti_ets_proofOfSender OBJ_id_smime_cti,4L ++ ++#define SN_id_smime_cti_ets_proofOfApproval "id-smime-cti-ets-proofOfApproval" ++#define NID_id_smime_cti_ets_proofOfApproval 255 ++#define OBJ_id_smime_cti_ets_proofOfApproval OBJ_id_smime_cti,5L ++ ++#define SN_id_smime_cti_ets_proofOfCreation "id-smime-cti-ets-proofOfCreation" ++#define NID_id_smime_cti_ets_proofOfCreation 256 ++#define OBJ_id_smime_cti_ets_proofOfCreation OBJ_id_smime_cti,6L ++ ++#define LN_friendlyName "friendlyName" ++#define NID_friendlyName 156 ++#define OBJ_friendlyName OBJ_pkcs9,20L ++ ++#define LN_localKeyID "localKeyID" ++#define NID_localKeyID 157 ++#define OBJ_localKeyID OBJ_pkcs9,21L ++ ++#define SN_ms_csp_name "CSPName" ++#define LN_ms_csp_name "Microsoft CSP Name" ++#define NID_ms_csp_name 417 ++#define OBJ_ms_csp_name 1L,3L,6L,1L,4L,1L,311L,17L,1L ++ ++#define SN_LocalKeySet "LocalKeySet" ++#define LN_LocalKeySet "Microsoft Local Key set" ++#define NID_LocalKeySet 856 ++#define OBJ_LocalKeySet 1L,3L,6L,1L,4L,1L,311L,17L,2L ++ ++#define OBJ_certTypes OBJ_pkcs9,22L ++ ++#define LN_x509Certificate "x509Certificate" ++#define NID_x509Certificate 158 ++#define OBJ_x509Certificate OBJ_certTypes,1L ++ ++#define LN_sdsiCertificate "sdsiCertificate" ++#define NID_sdsiCertificate 159 ++#define OBJ_sdsiCertificate OBJ_certTypes,2L ++ ++#define OBJ_crlTypes OBJ_pkcs9,23L ++ ++#define LN_x509Crl "x509Crl" ++#define NID_x509Crl 160 ++#define OBJ_x509Crl OBJ_crlTypes,1L ++ ++#define OBJ_pkcs12 OBJ_pkcs,12L ++ ++#define OBJ_pkcs12_pbeids OBJ_pkcs12,1L ++ ++#define SN_pbe_WithSHA1And128BitRC4 "PBE-SHA1-RC4-128" ++#define LN_pbe_WithSHA1And128BitRC4 "pbeWithSHA1And128BitRC4" ++#define NID_pbe_WithSHA1And128BitRC4 144 ++#define OBJ_pbe_WithSHA1And128BitRC4 OBJ_pkcs12_pbeids,1L ++ ++#define SN_pbe_WithSHA1And40BitRC4 "PBE-SHA1-RC4-40" ++#define LN_pbe_WithSHA1And40BitRC4 "pbeWithSHA1And40BitRC4" ++#define NID_pbe_WithSHA1And40BitRC4 145 ++#define OBJ_pbe_WithSHA1And40BitRC4 OBJ_pkcs12_pbeids,2L ++ ++#define SN_pbe_WithSHA1And3_Key_TripleDES_CBC "PBE-SHA1-3DES" ++#define LN_pbe_WithSHA1And3_Key_TripleDES_CBC "pbeWithSHA1And3-KeyTripleDES-CBC" ++#define NID_pbe_WithSHA1And3_Key_TripleDES_CBC 146 ++#define OBJ_pbe_WithSHA1And3_Key_TripleDES_CBC OBJ_pkcs12_pbeids,3L ++ ++#define SN_pbe_WithSHA1And2_Key_TripleDES_CBC "PBE-SHA1-2DES" ++#define LN_pbe_WithSHA1And2_Key_TripleDES_CBC "pbeWithSHA1And2-KeyTripleDES-CBC" ++#define NID_pbe_WithSHA1And2_Key_TripleDES_CBC 147 ++#define OBJ_pbe_WithSHA1And2_Key_TripleDES_CBC OBJ_pkcs12_pbeids,4L ++ ++#define SN_pbe_WithSHA1And128BitRC2_CBC "PBE-SHA1-RC2-128" ++#define LN_pbe_WithSHA1And128BitRC2_CBC "pbeWithSHA1And128BitRC2-CBC" ++#define NID_pbe_WithSHA1And128BitRC2_CBC 148 ++#define OBJ_pbe_WithSHA1And128BitRC2_CBC OBJ_pkcs12_pbeids,5L ++ ++#define SN_pbe_WithSHA1And40BitRC2_CBC "PBE-SHA1-RC2-40" ++#define LN_pbe_WithSHA1And40BitRC2_CBC "pbeWithSHA1And40BitRC2-CBC" ++#define NID_pbe_WithSHA1And40BitRC2_CBC 149 ++#define OBJ_pbe_WithSHA1And40BitRC2_CBC OBJ_pkcs12_pbeids,6L ++ ++#define OBJ_pkcs12_Version1 OBJ_pkcs12,10L ++ ++#define OBJ_pkcs12_BagIds OBJ_pkcs12_Version1,1L ++ ++#define LN_keyBag "keyBag" ++#define NID_keyBag 150 ++#define OBJ_keyBag OBJ_pkcs12_BagIds,1L ++ ++#define LN_pkcs8ShroudedKeyBag "pkcs8ShroudedKeyBag" ++#define NID_pkcs8ShroudedKeyBag 151 ++#define OBJ_pkcs8ShroudedKeyBag OBJ_pkcs12_BagIds,2L ++ ++#define LN_certBag "certBag" ++#define NID_certBag 152 ++#define OBJ_certBag OBJ_pkcs12_BagIds,3L ++ ++#define LN_crlBag "crlBag" ++#define NID_crlBag 153 ++#define OBJ_crlBag OBJ_pkcs12_BagIds,4L ++ ++#define LN_secretBag "secretBag" ++#define NID_secretBag 154 ++#define OBJ_secretBag OBJ_pkcs12_BagIds,5L ++ ++#define LN_safeContentsBag "safeContentsBag" ++#define NID_safeContentsBag 155 ++#define OBJ_safeContentsBag OBJ_pkcs12_BagIds,6L ++ ++#define SN_md2 "MD2" ++#define LN_md2 "md2" ++#define NID_md2 3 ++#define OBJ_md2 OBJ_rsadsi,2L,2L ++ ++#define SN_md4 "MD4" ++#define LN_md4 "md4" ++#define NID_md4 257 ++#define OBJ_md4 OBJ_rsadsi,2L,4L ++ ++#define SN_md5 "MD5" ++#define LN_md5 "md5" ++#define NID_md5 4 ++#define OBJ_md5 OBJ_rsadsi,2L,5L ++ ++#define SN_md5_sha1 "MD5-SHA1" ++#define LN_md5_sha1 "md5-sha1" ++#define NID_md5_sha1 114 ++ ++#define LN_hmacWithMD5 "hmacWithMD5" ++#define NID_hmacWithMD5 797 ++#define OBJ_hmacWithMD5 OBJ_rsadsi,2L,6L ++ ++#define LN_hmacWithSHA1 "hmacWithSHA1" ++#define NID_hmacWithSHA1 163 ++#define OBJ_hmacWithSHA1 OBJ_rsadsi,2L,7L ++ ++#define SN_sm2 "SM2" ++#define LN_sm2 "sm2" ++#define NID_sm2 1172 ++#define OBJ_sm2 OBJ_sm_scheme,301L ++ ++#define SN_sm3 "SM3" ++#define LN_sm3 "sm3" ++#define NID_sm3 1143 ++#define OBJ_sm3 OBJ_sm_scheme,401L ++ ++#define SN_SM2_with_SM3 "SM2-SM3" ++#define LN_SM2_with_SM3 "SM2-with-SM3" ++#define NID_SM2_with_SM3 1196 ++#define OBJ_SM2_with_SM3 OBJ_sm_scheme,501L ++ ++#define SN_sm3WithRSAEncryption "RSA-SM3" ++#define LN_sm3WithRSAEncryption "sm3WithRSAEncryption" ++#define NID_sm3WithRSAEncryption 1144 ++#define OBJ_sm3WithRSAEncryption OBJ_sm_scheme,504L ++ ++#define SN_sm9 "SM9" ++#define LN_sm9 "sm9" ++#define NID_sm9 1197 ++#define OBJ_sm9 OBJ_sm_scheme,302L ++ ++#define SN_sm2_sign "SM2-1" ++#define LN_sm2_sign "sm2-sign" ++#define NID_sm2_sign 1198 ++#define OBJ_sm2_sign OBJ_sm2,1L ++ ++#define SN_sm2_encrypt "SM2-3" ++#define LN_sm2_encrypt "sm2-encrypt" ++#define NID_sm2_encrypt 1211 ++#define OBJ_sm2_encrypt OBJ_sm2,3L ++ ++#define SN_sm2_cryptography_message_syntax_specification "sm2-cryptography-message-syntax-specification" ++#define LN_sm2_cryptography_message_syntax_specification "SM2 Cryptography Message Syntax Specification" ++#define NID_sm2_cryptography_message_syntax_specification 1199 ++#define OBJ_sm2_cryptography_message_syntax_specification OBJ_oscca,6L,1L,4L,2L ++ ++#define LN_pkcs7_sm2data "pkcs7-sm2data" ++#define NID_pkcs7_sm2data 1200 ++#define OBJ_pkcs7_sm2data OBJ_sm2_cryptography_message_syntax_specification,1L ++ ++#define LN_pkcs7_sm2signedData "pkcs7-sm2signedData" ++#define NID_pkcs7_sm2signedData 1201 ++#define OBJ_pkcs7_sm2signedData OBJ_sm2_cryptography_message_syntax_specification,2L ++ ++#define LN_pkcs7_sm2envelopedData "pkcs7-sm2envelopedData" ++#define NID_pkcs7_sm2envelopedData 1212 ++#define OBJ_pkcs7_sm2envelopedData OBJ_sm2_cryptography_message_syntax_specification,3L ++ ++#define LN_pkcs7_sm2signedAndEnvelopedData "pkcs7-sm2signedAndEnvelopedData" ++#define NID_pkcs7_sm2signedAndEnvelopedData 1213 ++#define OBJ_pkcs7_sm2signedAndEnvelopedData OBJ_sm2_cryptography_message_syntax_specification,4L ++ ++#define SN_sm2_cryptography_algorithm_application_specification "sm2-cryptography-algorithm-application-specification" ++#define LN_sm2_cryptography_algorithm_application_specification "SM2 Cryptography Algorithm Application Specification" ++#define NID_sm2_cryptography_algorithm_application_specification 1204 ++#define OBJ_sm2_cryptography_algorithm_application_specification OBJ_oscca,6L,1L,4L,1L ++ ++#define SN_q5 "q5" ++#define LN_q5 "Password-based Key Derivation Specification" ++#define NID_q5 1205 ++#define OBJ_q5 OBJ_sm2_cryptography_algorithm_application_specification,5L ++ ++#define LN_id_gm_pbkdf "GM-PBKDF" ++#define NID_id_gm_pbkdf 1206 ++#define OBJ_id_gm_pbkdf OBJ_q5,1L ++ ++#define LN_id_gm_pbes "GM-PBES" ++#define NID_id_gm_pbes 1207 ++#define OBJ_id_gm_pbes OBJ_q5,2L ++ ++#define SN_pbeWithSM3AndSM4_CBC "PBE-SM3-SM4" ++#define LN_pbeWithSM3AndSM4_CBC "pbeWithSM3AndSM4-CBC" ++#define NID_pbeWithSM3AndSM4_CBC 1208 ++#define OBJ_pbeWithSM3AndSM4_CBC OBJ_sm2_cryptography_algorithm_application_specification,12L,1L,1L ++ ++#define SN_hmacWithSM3 "sm3WithKey" ++#define LN_hmacWithSM3 "hmacWithSM3" ++#define NID_hmacWithSM3 1209 ++#define OBJ_hmacWithSM3 OBJ_sm3,2L ++ ++#define LN_hmacWithSHA224 "hmacWithSHA224" ++#define NID_hmacWithSHA224 798 ++#define OBJ_hmacWithSHA224 OBJ_rsadsi,2L,8L ++ ++#define LN_hmacWithSHA256 "hmacWithSHA256" ++#define NID_hmacWithSHA256 799 ++#define OBJ_hmacWithSHA256 OBJ_rsadsi,2L,9L ++ ++#define LN_hmacWithSHA384 "hmacWithSHA384" ++#define NID_hmacWithSHA384 800 ++#define OBJ_hmacWithSHA384 OBJ_rsadsi,2L,10L ++ ++#define LN_hmacWithSHA512 "hmacWithSHA512" ++#define NID_hmacWithSHA512 801 ++#define OBJ_hmacWithSHA512 OBJ_rsadsi,2L,11L ++ ++#define LN_hmacWithSHA512_224 "hmacWithSHA512-224" ++#define NID_hmacWithSHA512_224 1193 ++#define OBJ_hmacWithSHA512_224 OBJ_rsadsi,2L,12L ++ ++#define LN_hmacWithSHA512_256 "hmacWithSHA512-256" ++#define NID_hmacWithSHA512_256 1194 ++#define OBJ_hmacWithSHA512_256 OBJ_rsadsi,2L,13L ++ ++#define SN_rc2_cbc "RC2-CBC" ++#define LN_rc2_cbc "rc2-cbc" ++#define NID_rc2_cbc 37 ++#define OBJ_rc2_cbc OBJ_rsadsi,3L,2L ++ ++#define SN_rc2_ecb "RC2-ECB" ++#define LN_rc2_ecb "rc2-ecb" ++#define NID_rc2_ecb 38 ++ ++#define SN_rc2_cfb64 "RC2-CFB" ++#define LN_rc2_cfb64 "rc2-cfb" ++#define NID_rc2_cfb64 39 ++ ++#define SN_rc2_ofb64 "RC2-OFB" ++#define LN_rc2_ofb64 "rc2-ofb" ++#define NID_rc2_ofb64 40 ++ ++#define SN_rc2_40_cbc "RC2-40-CBC" ++#define LN_rc2_40_cbc "rc2-40-cbc" ++#define NID_rc2_40_cbc 98 ++ ++#define SN_rc2_64_cbc "RC2-64-CBC" ++#define LN_rc2_64_cbc "rc2-64-cbc" ++#define NID_rc2_64_cbc 166 ++ ++#define SN_rc4 "RC4" ++#define LN_rc4 "rc4" ++#define NID_rc4 5 ++#define OBJ_rc4 OBJ_rsadsi,3L,4L ++ ++#define SN_rc4_40 "RC4-40" ++#define LN_rc4_40 "rc4-40" ++#define NID_rc4_40 97 ++ ++#define SN_des_ede3_cbc "DES-EDE3-CBC" ++#define LN_des_ede3_cbc "des-ede3-cbc" ++#define NID_des_ede3_cbc 44 ++#define OBJ_des_ede3_cbc OBJ_rsadsi,3L,7L ++ ++#define SN_rc5_cbc "RC5-CBC" ++#define LN_rc5_cbc "rc5-cbc" ++#define NID_rc5_cbc 120 ++#define OBJ_rc5_cbc OBJ_rsadsi,3L,8L ++ ++#define SN_rc5_ecb "RC5-ECB" ++#define LN_rc5_ecb "rc5-ecb" ++#define NID_rc5_ecb 121 ++ ++#define SN_rc5_cfb64 "RC5-CFB" ++#define LN_rc5_cfb64 "rc5-cfb" ++#define NID_rc5_cfb64 122 ++ ++#define SN_rc5_ofb64 "RC5-OFB" ++#define LN_rc5_ofb64 "rc5-ofb" ++#define NID_rc5_ofb64 123 ++ ++#define SN_ms_ext_req "msExtReq" ++#define LN_ms_ext_req "Microsoft Extension Request" ++#define NID_ms_ext_req 171 ++#define OBJ_ms_ext_req 1L,3L,6L,1L,4L,1L,311L,2L,1L,14L ++ ++#define SN_ms_code_ind "msCodeInd" ++#define LN_ms_code_ind "Microsoft Individual Code Signing" ++#define NID_ms_code_ind 134 ++#define OBJ_ms_code_ind 1L,3L,6L,1L,4L,1L,311L,2L,1L,21L ++ ++#define SN_ms_code_com "msCodeCom" ++#define LN_ms_code_com "Microsoft Commercial Code Signing" ++#define NID_ms_code_com 135 ++#define OBJ_ms_code_com 1L,3L,6L,1L,4L,1L,311L,2L,1L,22L ++ ++#define SN_ms_ctl_sign "msCTLSign" ++#define LN_ms_ctl_sign "Microsoft Trust List Signing" ++#define NID_ms_ctl_sign 136 ++#define OBJ_ms_ctl_sign 1L,3L,6L,1L,4L,1L,311L,10L,3L,1L ++ ++#define SN_ms_sgc "msSGC" ++#define LN_ms_sgc "Microsoft Server Gated Crypto" ++#define NID_ms_sgc 137 ++#define OBJ_ms_sgc 1L,3L,6L,1L,4L,1L,311L,10L,3L,3L ++ ++#define SN_ms_efs "msEFS" ++#define LN_ms_efs "Microsoft Encrypted File System" ++#define NID_ms_efs 138 ++#define OBJ_ms_efs 1L,3L,6L,1L,4L,1L,311L,10L,3L,4L ++ ++#define SN_ms_smartcard_login "msSmartcardLogin" ++#define LN_ms_smartcard_login "Microsoft Smartcard Login" ++#define NID_ms_smartcard_login 648 ++#define OBJ_ms_smartcard_login 1L,3L,6L,1L,4L,1L,311L,20L,2L,2L ++ ++#define SN_ms_upn "msUPN" ++#define LN_ms_upn "Microsoft User Principal Name" ++#define NID_ms_upn 649 ++#define OBJ_ms_upn 1L,3L,6L,1L,4L,1L,311L,20L,2L,3L ++ ++#define SN_idea_cbc "IDEA-CBC" ++#define LN_idea_cbc "idea-cbc" ++#define NID_idea_cbc 34 ++#define OBJ_idea_cbc 1L,3L,6L,1L,4L,1L,188L,7L,1L,1L,2L ++ ++#define SN_idea_ecb "IDEA-ECB" ++#define LN_idea_ecb "idea-ecb" ++#define NID_idea_ecb 36 ++ ++#define SN_idea_cfb64 "IDEA-CFB" ++#define LN_idea_cfb64 "idea-cfb" ++#define NID_idea_cfb64 35 ++ ++#define SN_idea_ofb64 "IDEA-OFB" ++#define LN_idea_ofb64 "idea-ofb" ++#define NID_idea_ofb64 46 ++ ++#define SN_bf_cbc "BF-CBC" ++#define LN_bf_cbc "bf-cbc" ++#define NID_bf_cbc 91 ++#define OBJ_bf_cbc 1L,3L,6L,1L,4L,1L,3029L,1L,2L ++ ++#define SN_bf_ecb "BF-ECB" ++#define LN_bf_ecb "bf-ecb" ++#define NID_bf_ecb 92 ++ ++#define SN_bf_cfb64 "BF-CFB" ++#define LN_bf_cfb64 "bf-cfb" ++#define NID_bf_cfb64 93 ++ ++#define SN_bf_ofb64 "BF-OFB" ++#define LN_bf_ofb64 "bf-ofb" ++#define NID_bf_ofb64 94 ++ ++#define SN_id_pkix "PKIX" ++#define NID_id_pkix 127 ++#define OBJ_id_pkix 1L,3L,6L,1L,5L,5L,7L ++ ++#define SN_id_pkix_mod "id-pkix-mod" ++#define NID_id_pkix_mod 258 ++#define OBJ_id_pkix_mod OBJ_id_pkix,0L ++ ++#define SN_id_pe "id-pe" ++#define NID_id_pe 175 ++#define OBJ_id_pe OBJ_id_pkix,1L ++ ++#define SN_id_qt "id-qt" ++#define NID_id_qt 259 ++#define OBJ_id_qt OBJ_id_pkix,2L ++ ++#define SN_id_kp "id-kp" ++#define NID_id_kp 128 ++#define OBJ_id_kp OBJ_id_pkix,3L ++ ++#define SN_id_it "id-it" ++#define NID_id_it 260 ++#define OBJ_id_it OBJ_id_pkix,4L ++ ++#define SN_id_pkip "id-pkip" ++#define NID_id_pkip 261 ++#define OBJ_id_pkip OBJ_id_pkix,5L ++ ++#define SN_id_alg "id-alg" ++#define NID_id_alg 262 ++#define OBJ_id_alg OBJ_id_pkix,6L ++ ++#define SN_id_cmc "id-cmc" ++#define NID_id_cmc 263 ++#define OBJ_id_cmc OBJ_id_pkix,7L ++ ++#define SN_id_on "id-on" ++#define NID_id_on 264 ++#define OBJ_id_on OBJ_id_pkix,8L ++ ++#define SN_id_pda "id-pda" ++#define NID_id_pda 265 ++#define OBJ_id_pda OBJ_id_pkix,9L ++ ++#define SN_id_aca "id-aca" ++#define NID_id_aca 266 ++#define OBJ_id_aca OBJ_id_pkix,10L ++ ++#define SN_id_qcs "id-qcs" ++#define NID_id_qcs 267 ++#define OBJ_id_qcs OBJ_id_pkix,11L ++ ++#define SN_id_cct "id-cct" ++#define NID_id_cct 268 ++#define OBJ_id_cct OBJ_id_pkix,12L ++ ++#define SN_id_ppl "id-ppl" ++#define NID_id_ppl 662 ++#define OBJ_id_ppl OBJ_id_pkix,21L ++ ++#define SN_id_ad "id-ad" ++#define NID_id_ad 176 ++#define OBJ_id_ad OBJ_id_pkix,48L ++ ++#define SN_id_pkix1_explicit_88 "id-pkix1-explicit-88" ++#define NID_id_pkix1_explicit_88 269 ++#define OBJ_id_pkix1_explicit_88 OBJ_id_pkix_mod,1L ++ ++#define SN_id_pkix1_implicit_88 "id-pkix1-implicit-88" ++#define NID_id_pkix1_implicit_88 270 ++#define OBJ_id_pkix1_implicit_88 OBJ_id_pkix_mod,2L ++ ++#define SN_id_pkix1_explicit_93 "id-pkix1-explicit-93" ++#define NID_id_pkix1_explicit_93 271 ++#define OBJ_id_pkix1_explicit_93 OBJ_id_pkix_mod,3L ++ ++#define SN_id_pkix1_implicit_93 "id-pkix1-implicit-93" ++#define NID_id_pkix1_implicit_93 272 ++#define OBJ_id_pkix1_implicit_93 OBJ_id_pkix_mod,4L ++ ++#define SN_id_mod_crmf "id-mod-crmf" ++#define NID_id_mod_crmf 273 ++#define OBJ_id_mod_crmf OBJ_id_pkix_mod,5L ++ ++#define SN_id_mod_cmc "id-mod-cmc" ++#define NID_id_mod_cmc 274 ++#define OBJ_id_mod_cmc OBJ_id_pkix_mod,6L ++ ++#define SN_id_mod_kea_profile_88 "id-mod-kea-profile-88" ++#define NID_id_mod_kea_profile_88 275 ++#define OBJ_id_mod_kea_profile_88 OBJ_id_pkix_mod,7L ++ ++#define SN_id_mod_kea_profile_93 "id-mod-kea-profile-93" ++#define NID_id_mod_kea_profile_93 276 ++#define OBJ_id_mod_kea_profile_93 OBJ_id_pkix_mod,8L ++ ++#define SN_id_mod_cmp "id-mod-cmp" ++#define NID_id_mod_cmp 277 ++#define OBJ_id_mod_cmp OBJ_id_pkix_mod,9L ++ ++#define SN_id_mod_qualified_cert_88 "id-mod-qualified-cert-88" ++#define NID_id_mod_qualified_cert_88 278 ++#define OBJ_id_mod_qualified_cert_88 OBJ_id_pkix_mod,10L ++ ++#define SN_id_mod_qualified_cert_93 "id-mod-qualified-cert-93" ++#define NID_id_mod_qualified_cert_93 279 ++#define OBJ_id_mod_qualified_cert_93 OBJ_id_pkix_mod,11L ++ ++#define SN_id_mod_attribute_cert "id-mod-attribute-cert" ++#define NID_id_mod_attribute_cert 280 ++#define OBJ_id_mod_attribute_cert OBJ_id_pkix_mod,12L ++ ++#define SN_id_mod_timestamp_protocol "id-mod-timestamp-protocol" ++#define NID_id_mod_timestamp_protocol 281 ++#define OBJ_id_mod_timestamp_protocol OBJ_id_pkix_mod,13L ++ ++#define SN_id_mod_ocsp "id-mod-ocsp" ++#define NID_id_mod_ocsp 282 ++#define OBJ_id_mod_ocsp OBJ_id_pkix_mod,14L ++ ++#define SN_id_mod_dvcs "id-mod-dvcs" ++#define NID_id_mod_dvcs 283 ++#define OBJ_id_mod_dvcs OBJ_id_pkix_mod,15L ++ ++#define SN_id_mod_cmp2000 "id-mod-cmp2000" ++#define NID_id_mod_cmp2000 284 ++#define OBJ_id_mod_cmp2000 OBJ_id_pkix_mod,16L ++ ++#define SN_info_access "authorityInfoAccess" ++#define LN_info_access "Authority Information Access" ++#define NID_info_access 177 ++#define OBJ_info_access OBJ_id_pe,1L ++ ++#define SN_biometricInfo "biometricInfo" ++#define LN_biometricInfo "Biometric Info" ++#define NID_biometricInfo 285 ++#define OBJ_biometricInfo OBJ_id_pe,2L ++ ++#define SN_qcStatements "qcStatements" ++#define NID_qcStatements 286 ++#define OBJ_qcStatements OBJ_id_pe,3L ++ ++#define SN_ac_auditEntity "ac-auditEntity" ++#define NID_ac_auditEntity 287 ++#define OBJ_ac_auditEntity OBJ_id_pe,4L ++ ++#define SN_ac_targeting "ac-targeting" ++#define NID_ac_targeting 288 ++#define OBJ_ac_targeting OBJ_id_pe,5L ++ ++#define SN_aaControls "aaControls" ++#define NID_aaControls 289 ++#define OBJ_aaControls OBJ_id_pe,6L ++ ++#define SN_sbgp_ipAddrBlock "sbgp-ipAddrBlock" ++#define NID_sbgp_ipAddrBlock 290 ++#define OBJ_sbgp_ipAddrBlock OBJ_id_pe,7L ++ ++#define SN_sbgp_autonomousSysNum "sbgp-autonomousSysNum" ++#define NID_sbgp_autonomousSysNum 291 ++#define OBJ_sbgp_autonomousSysNum OBJ_id_pe,8L ++ ++#define SN_sbgp_routerIdentifier "sbgp-routerIdentifier" ++#define NID_sbgp_routerIdentifier 292 ++#define OBJ_sbgp_routerIdentifier OBJ_id_pe,9L ++ ++#define SN_ac_proxying "ac-proxying" ++#define NID_ac_proxying 397 ++#define OBJ_ac_proxying OBJ_id_pe,10L ++ ++#define SN_sinfo_access "subjectInfoAccess" ++#define LN_sinfo_access "Subject Information Access" ++#define NID_sinfo_access 398 ++#define OBJ_sinfo_access OBJ_id_pe,11L ++ ++#define SN_proxyCertInfo "proxyCertInfo" ++#define LN_proxyCertInfo "Proxy Certificate Information" ++#define NID_proxyCertInfo 663 ++#define OBJ_proxyCertInfo OBJ_id_pe,14L ++ ++#define SN_tlsfeature "tlsfeature" ++#define LN_tlsfeature "TLS Feature" ++#define NID_tlsfeature 1020 ++#define OBJ_tlsfeature OBJ_id_pe,24L ++ ++#define SN_id_qt_cps "id-qt-cps" ++#define LN_id_qt_cps "Policy Qualifier CPS" ++#define NID_id_qt_cps 164 ++#define OBJ_id_qt_cps OBJ_id_qt,1L ++ ++#define SN_id_qt_unotice "id-qt-unotice" ++#define LN_id_qt_unotice "Policy Qualifier User Notice" ++#define NID_id_qt_unotice 165 ++#define OBJ_id_qt_unotice OBJ_id_qt,2L ++ ++#define SN_textNotice "textNotice" ++#define NID_textNotice 293 ++#define OBJ_textNotice OBJ_id_qt,3L ++ ++#define SN_server_auth "serverAuth" ++#define LN_server_auth "TLS Web Server Authentication" ++#define NID_server_auth 129 ++#define OBJ_server_auth OBJ_id_kp,1L ++ ++#define SN_client_auth "clientAuth" ++#define LN_client_auth "TLS Web Client Authentication" ++#define NID_client_auth 130 ++#define OBJ_client_auth OBJ_id_kp,2L ++ ++#define SN_code_sign "codeSigning" ++#define LN_code_sign "Code Signing" ++#define NID_code_sign 131 ++#define OBJ_code_sign OBJ_id_kp,3L ++ ++#define SN_email_protect "emailProtection" ++#define LN_email_protect "E-mail Protection" ++#define NID_email_protect 132 ++#define OBJ_email_protect OBJ_id_kp,4L ++ ++#define SN_ipsecEndSystem "ipsecEndSystem" ++#define LN_ipsecEndSystem "IPSec End System" ++#define NID_ipsecEndSystem 294 ++#define OBJ_ipsecEndSystem OBJ_id_kp,5L ++ ++#define SN_ipsecTunnel "ipsecTunnel" ++#define LN_ipsecTunnel "IPSec Tunnel" ++#define NID_ipsecTunnel 295 ++#define OBJ_ipsecTunnel OBJ_id_kp,6L ++ ++#define SN_ipsecUser "ipsecUser" ++#define LN_ipsecUser "IPSec User" ++#define NID_ipsecUser 296 ++#define OBJ_ipsecUser OBJ_id_kp,7L ++ ++#define SN_time_stamp "timeStamping" ++#define LN_time_stamp "Time Stamping" ++#define NID_time_stamp 133 ++#define OBJ_time_stamp OBJ_id_kp,8L ++ ++#define SN_OCSP_sign "OCSPSigning" ++#define LN_OCSP_sign "OCSP Signing" ++#define NID_OCSP_sign 180 ++#define OBJ_OCSP_sign OBJ_id_kp,9L ++ ++#define SN_dvcs "DVCS" ++#define LN_dvcs "dvcs" ++#define NID_dvcs 297 ++#define OBJ_dvcs OBJ_id_kp,10L ++ ++#define SN_ipsec_IKE "ipsecIKE" ++#define LN_ipsec_IKE "ipsec Internet Key Exchange" ++#define NID_ipsec_IKE 1022 ++#define OBJ_ipsec_IKE OBJ_id_kp,17L ++ ++#define SN_capwapAC "capwapAC" ++#define LN_capwapAC "Ctrl/provision WAP Access" ++#define NID_capwapAC 1023 ++#define OBJ_capwapAC OBJ_id_kp,18L ++ ++#define SN_capwapWTP "capwapWTP" ++#define LN_capwapWTP "Ctrl/Provision WAP Termination" ++#define NID_capwapWTP 1024 ++#define OBJ_capwapWTP OBJ_id_kp,19L ++ ++#define SN_sshClient "secureShellClient" ++#define LN_sshClient "SSH Client" ++#define NID_sshClient 1025 ++#define OBJ_sshClient OBJ_id_kp,21L ++ ++#define SN_sshServer "secureShellServer" ++#define LN_sshServer "SSH Server" ++#define NID_sshServer 1026 ++#define OBJ_sshServer OBJ_id_kp,22L ++ ++#define SN_sendRouter "sendRouter" ++#define LN_sendRouter "Send Router" ++#define NID_sendRouter 1027 ++#define OBJ_sendRouter OBJ_id_kp,23L ++ ++#define SN_sendProxiedRouter "sendProxiedRouter" ++#define LN_sendProxiedRouter "Send Proxied Router" ++#define NID_sendProxiedRouter 1028 ++#define OBJ_sendProxiedRouter OBJ_id_kp,24L ++ ++#define SN_sendOwner "sendOwner" ++#define LN_sendOwner "Send Owner" ++#define NID_sendOwner 1029 ++#define OBJ_sendOwner OBJ_id_kp,25L ++ ++#define SN_sendProxiedOwner "sendProxiedOwner" ++#define LN_sendProxiedOwner "Send Proxied Owner" ++#define NID_sendProxiedOwner 1030 ++#define OBJ_sendProxiedOwner OBJ_id_kp,26L ++ ++#define SN_cmcCA "cmcCA" ++#define LN_cmcCA "CMC Certificate Authority" ++#define NID_cmcCA 1131 ++#define OBJ_cmcCA OBJ_id_kp,27L ++ ++#define SN_cmcRA "cmcRA" ++#define LN_cmcRA "CMC Registration Authority" ++#define NID_cmcRA 1132 ++#define OBJ_cmcRA OBJ_id_kp,28L ++ ++#define SN_id_it_caProtEncCert "id-it-caProtEncCert" ++#define NID_id_it_caProtEncCert 298 ++#define OBJ_id_it_caProtEncCert OBJ_id_it,1L ++ ++#define SN_id_it_signKeyPairTypes "id-it-signKeyPairTypes" ++#define NID_id_it_signKeyPairTypes 299 ++#define OBJ_id_it_signKeyPairTypes OBJ_id_it,2L ++ ++#define SN_id_it_encKeyPairTypes "id-it-encKeyPairTypes" ++#define NID_id_it_encKeyPairTypes 300 ++#define OBJ_id_it_encKeyPairTypes OBJ_id_it,3L ++ ++#define SN_id_it_preferredSymmAlg "id-it-preferredSymmAlg" ++#define NID_id_it_preferredSymmAlg 301 ++#define OBJ_id_it_preferredSymmAlg OBJ_id_it,4L ++ ++#define SN_id_it_caKeyUpdateInfo "id-it-caKeyUpdateInfo" ++#define NID_id_it_caKeyUpdateInfo 302 ++#define OBJ_id_it_caKeyUpdateInfo OBJ_id_it,5L ++ ++#define SN_id_it_currentCRL "id-it-currentCRL" ++#define NID_id_it_currentCRL 303 ++#define OBJ_id_it_currentCRL OBJ_id_it,6L ++ ++#define SN_id_it_unsupportedOIDs "id-it-unsupportedOIDs" ++#define NID_id_it_unsupportedOIDs 304 ++#define OBJ_id_it_unsupportedOIDs OBJ_id_it,7L ++ ++#define SN_id_it_subscriptionRequest "id-it-subscriptionRequest" ++#define NID_id_it_subscriptionRequest 305 ++#define OBJ_id_it_subscriptionRequest OBJ_id_it,8L ++ ++#define SN_id_it_subscriptionResponse "id-it-subscriptionResponse" ++#define NID_id_it_subscriptionResponse 306 ++#define OBJ_id_it_subscriptionResponse OBJ_id_it,9L ++ ++#define SN_id_it_keyPairParamReq "id-it-keyPairParamReq" ++#define NID_id_it_keyPairParamReq 307 ++#define OBJ_id_it_keyPairParamReq OBJ_id_it,10L ++ ++#define SN_id_it_keyPairParamRep "id-it-keyPairParamRep" ++#define NID_id_it_keyPairParamRep 308 ++#define OBJ_id_it_keyPairParamRep OBJ_id_it,11L ++ ++#define SN_id_it_revPassphrase "id-it-revPassphrase" ++#define NID_id_it_revPassphrase 309 ++#define OBJ_id_it_revPassphrase OBJ_id_it,12L ++ ++#define SN_id_it_implicitConfirm "id-it-implicitConfirm" ++#define NID_id_it_implicitConfirm 310 ++#define OBJ_id_it_implicitConfirm OBJ_id_it,13L ++ ++#define SN_id_it_confirmWaitTime "id-it-confirmWaitTime" ++#define NID_id_it_confirmWaitTime 311 ++#define OBJ_id_it_confirmWaitTime OBJ_id_it,14L ++ ++#define SN_id_it_origPKIMessage "id-it-origPKIMessage" ++#define NID_id_it_origPKIMessage 312 ++#define OBJ_id_it_origPKIMessage OBJ_id_it,15L ++ ++#define SN_id_it_suppLangTags "id-it-suppLangTags" ++#define NID_id_it_suppLangTags 784 ++#define OBJ_id_it_suppLangTags OBJ_id_it,16L ++ ++#define SN_id_regCtrl "id-regCtrl" ++#define NID_id_regCtrl 313 ++#define OBJ_id_regCtrl OBJ_id_pkip,1L ++ ++#define SN_id_regInfo "id-regInfo" ++#define NID_id_regInfo 314 ++#define OBJ_id_regInfo OBJ_id_pkip,2L ++ ++#define SN_id_regCtrl_regToken "id-regCtrl-regToken" ++#define NID_id_regCtrl_regToken 315 ++#define OBJ_id_regCtrl_regToken OBJ_id_regCtrl,1L ++ ++#define SN_id_regCtrl_authenticator "id-regCtrl-authenticator" ++#define NID_id_regCtrl_authenticator 316 ++#define OBJ_id_regCtrl_authenticator OBJ_id_regCtrl,2L ++ ++#define SN_id_regCtrl_pkiPublicationInfo "id-regCtrl-pkiPublicationInfo" ++#define NID_id_regCtrl_pkiPublicationInfo 317 ++#define OBJ_id_regCtrl_pkiPublicationInfo OBJ_id_regCtrl,3L ++ ++#define SN_id_regCtrl_pkiArchiveOptions "id-regCtrl-pkiArchiveOptions" ++#define NID_id_regCtrl_pkiArchiveOptions 318 ++#define OBJ_id_regCtrl_pkiArchiveOptions OBJ_id_regCtrl,4L ++ ++#define SN_id_regCtrl_oldCertID "id-regCtrl-oldCertID" ++#define NID_id_regCtrl_oldCertID 319 ++#define OBJ_id_regCtrl_oldCertID OBJ_id_regCtrl,5L ++ ++#define SN_id_regCtrl_protocolEncrKey "id-regCtrl-protocolEncrKey" ++#define NID_id_regCtrl_protocolEncrKey 320 ++#define OBJ_id_regCtrl_protocolEncrKey OBJ_id_regCtrl,6L ++ ++#define SN_id_regInfo_utf8Pairs "id-regInfo-utf8Pairs" ++#define NID_id_regInfo_utf8Pairs 321 ++#define OBJ_id_regInfo_utf8Pairs OBJ_id_regInfo,1L ++ ++#define SN_id_regInfo_certReq "id-regInfo-certReq" ++#define NID_id_regInfo_certReq 322 ++#define OBJ_id_regInfo_certReq OBJ_id_regInfo,2L ++ ++#define SN_id_alg_des40 "id-alg-des40" ++#define NID_id_alg_des40 323 ++#define OBJ_id_alg_des40 OBJ_id_alg,1L ++ ++#define SN_id_alg_noSignature "id-alg-noSignature" ++#define NID_id_alg_noSignature 324 ++#define OBJ_id_alg_noSignature OBJ_id_alg,2L ++ ++#define SN_id_alg_dh_sig_hmac_sha1 "id-alg-dh-sig-hmac-sha1" ++#define NID_id_alg_dh_sig_hmac_sha1 325 ++#define OBJ_id_alg_dh_sig_hmac_sha1 OBJ_id_alg,3L ++ ++#define SN_id_alg_dh_pop "id-alg-dh-pop" ++#define NID_id_alg_dh_pop 326 ++#define OBJ_id_alg_dh_pop OBJ_id_alg,4L ++ ++#define SN_id_cmc_statusInfo "id-cmc-statusInfo" ++#define NID_id_cmc_statusInfo 327 ++#define OBJ_id_cmc_statusInfo OBJ_id_cmc,1L ++ ++#define SN_id_cmc_identification "id-cmc-identification" ++#define NID_id_cmc_identification 328 ++#define OBJ_id_cmc_identification OBJ_id_cmc,2L ++ ++#define SN_id_cmc_identityProof "id-cmc-identityProof" ++#define NID_id_cmc_identityProof 329 ++#define OBJ_id_cmc_identityProof OBJ_id_cmc,3L ++ ++#define SN_id_cmc_dataReturn "id-cmc-dataReturn" ++#define NID_id_cmc_dataReturn 330 ++#define OBJ_id_cmc_dataReturn OBJ_id_cmc,4L ++ ++#define SN_id_cmc_transactionId "id-cmc-transactionId" ++#define NID_id_cmc_transactionId 331 ++#define OBJ_id_cmc_transactionId OBJ_id_cmc,5L ++ ++#define SN_id_cmc_senderNonce "id-cmc-senderNonce" ++#define NID_id_cmc_senderNonce 332 ++#define OBJ_id_cmc_senderNonce OBJ_id_cmc,6L ++ ++#define SN_id_cmc_recipientNonce "id-cmc-recipientNonce" ++#define NID_id_cmc_recipientNonce 333 ++#define OBJ_id_cmc_recipientNonce OBJ_id_cmc,7L ++ ++#define SN_id_cmc_addExtensions "id-cmc-addExtensions" ++#define NID_id_cmc_addExtensions 334 ++#define OBJ_id_cmc_addExtensions OBJ_id_cmc,8L ++ ++#define SN_id_cmc_encryptedPOP "id-cmc-encryptedPOP" ++#define NID_id_cmc_encryptedPOP 335 ++#define OBJ_id_cmc_encryptedPOP OBJ_id_cmc,9L ++ ++#define SN_id_cmc_decryptedPOP "id-cmc-decryptedPOP" ++#define NID_id_cmc_decryptedPOP 336 ++#define OBJ_id_cmc_decryptedPOP OBJ_id_cmc,10L ++ ++#define SN_id_cmc_lraPOPWitness "id-cmc-lraPOPWitness" ++#define NID_id_cmc_lraPOPWitness 337 ++#define OBJ_id_cmc_lraPOPWitness OBJ_id_cmc,11L ++ ++#define SN_id_cmc_getCert "id-cmc-getCert" ++#define NID_id_cmc_getCert 338 ++#define OBJ_id_cmc_getCert OBJ_id_cmc,15L ++ ++#define SN_id_cmc_getCRL "id-cmc-getCRL" ++#define NID_id_cmc_getCRL 339 ++#define OBJ_id_cmc_getCRL OBJ_id_cmc,16L ++ ++#define SN_id_cmc_revokeRequest "id-cmc-revokeRequest" ++#define NID_id_cmc_revokeRequest 340 ++#define OBJ_id_cmc_revokeRequest OBJ_id_cmc,17L ++ ++#define SN_id_cmc_regInfo "id-cmc-regInfo" ++#define NID_id_cmc_regInfo 341 ++#define OBJ_id_cmc_regInfo OBJ_id_cmc,18L ++ ++#define SN_id_cmc_responseInfo "id-cmc-responseInfo" ++#define NID_id_cmc_responseInfo 342 ++#define OBJ_id_cmc_responseInfo OBJ_id_cmc,19L ++ ++#define SN_id_cmc_queryPending "id-cmc-queryPending" ++#define NID_id_cmc_queryPending 343 ++#define OBJ_id_cmc_queryPending OBJ_id_cmc,21L ++ ++#define SN_id_cmc_popLinkRandom "id-cmc-popLinkRandom" ++#define NID_id_cmc_popLinkRandom 344 ++#define OBJ_id_cmc_popLinkRandom OBJ_id_cmc,22L ++ ++#define SN_id_cmc_popLinkWitness "id-cmc-popLinkWitness" ++#define NID_id_cmc_popLinkWitness 345 ++#define OBJ_id_cmc_popLinkWitness OBJ_id_cmc,23L ++ ++#define SN_id_cmc_confirmCertAcceptance "id-cmc-confirmCertAcceptance" ++#define NID_id_cmc_confirmCertAcceptance 346 ++#define OBJ_id_cmc_confirmCertAcceptance OBJ_id_cmc,24L ++ ++#define SN_id_on_personalData "id-on-personalData" ++#define NID_id_on_personalData 347 ++#define OBJ_id_on_personalData OBJ_id_on,1L ++ ++#define SN_id_on_permanentIdentifier "id-on-permanentIdentifier" ++#define LN_id_on_permanentIdentifier "Permanent Identifier" ++#define NID_id_on_permanentIdentifier 858 ++#define OBJ_id_on_permanentIdentifier OBJ_id_on,3L ++ ++#define SN_id_pda_dateOfBirth "id-pda-dateOfBirth" ++#define NID_id_pda_dateOfBirth 348 ++#define OBJ_id_pda_dateOfBirth OBJ_id_pda,1L ++ ++#define SN_id_pda_placeOfBirth "id-pda-placeOfBirth" ++#define NID_id_pda_placeOfBirth 349 ++#define OBJ_id_pda_placeOfBirth OBJ_id_pda,2L ++ ++#define SN_id_pda_gender "id-pda-gender" ++#define NID_id_pda_gender 351 ++#define OBJ_id_pda_gender OBJ_id_pda,3L ++ ++#define SN_id_pda_countryOfCitizenship "id-pda-countryOfCitizenship" ++#define NID_id_pda_countryOfCitizenship 352 ++#define OBJ_id_pda_countryOfCitizenship OBJ_id_pda,4L ++ ++#define SN_id_pda_countryOfResidence "id-pda-countryOfResidence" ++#define NID_id_pda_countryOfResidence 353 ++#define OBJ_id_pda_countryOfResidence OBJ_id_pda,5L ++ ++#define SN_id_aca_authenticationInfo "id-aca-authenticationInfo" ++#define NID_id_aca_authenticationInfo 354 ++#define OBJ_id_aca_authenticationInfo OBJ_id_aca,1L ++ ++#define SN_id_aca_accessIdentity "id-aca-accessIdentity" ++#define NID_id_aca_accessIdentity 355 ++#define OBJ_id_aca_accessIdentity OBJ_id_aca,2L ++ ++#define SN_id_aca_chargingIdentity "id-aca-chargingIdentity" ++#define NID_id_aca_chargingIdentity 356 ++#define OBJ_id_aca_chargingIdentity OBJ_id_aca,3L ++ ++#define SN_id_aca_group "id-aca-group" ++#define NID_id_aca_group 357 ++#define OBJ_id_aca_group OBJ_id_aca,4L ++ ++#define SN_id_aca_role "id-aca-role" ++#define NID_id_aca_role 358 ++#define OBJ_id_aca_role OBJ_id_aca,5L ++ ++#define SN_id_aca_encAttrs "id-aca-encAttrs" ++#define NID_id_aca_encAttrs 399 ++#define OBJ_id_aca_encAttrs OBJ_id_aca,6L ++ ++#define SN_id_qcs_pkixQCSyntax_v1 "id-qcs-pkixQCSyntax-v1" ++#define NID_id_qcs_pkixQCSyntax_v1 359 ++#define OBJ_id_qcs_pkixQCSyntax_v1 OBJ_id_qcs,1L ++ ++#define SN_id_cct_crs "id-cct-crs" ++#define NID_id_cct_crs 360 ++#define OBJ_id_cct_crs OBJ_id_cct,1L ++ ++#define SN_id_cct_PKIData "id-cct-PKIData" ++#define NID_id_cct_PKIData 361 ++#define OBJ_id_cct_PKIData OBJ_id_cct,2L ++ ++#define SN_id_cct_PKIResponse "id-cct-PKIResponse" ++#define NID_id_cct_PKIResponse 362 ++#define OBJ_id_cct_PKIResponse OBJ_id_cct,3L ++ ++#define SN_id_ppl_anyLanguage "id-ppl-anyLanguage" ++#define LN_id_ppl_anyLanguage "Any language" ++#define NID_id_ppl_anyLanguage 664 ++#define OBJ_id_ppl_anyLanguage OBJ_id_ppl,0L ++ ++#define SN_id_ppl_inheritAll "id-ppl-inheritAll" ++#define LN_id_ppl_inheritAll "Inherit all" ++#define NID_id_ppl_inheritAll 665 ++#define OBJ_id_ppl_inheritAll OBJ_id_ppl,1L ++ ++#define SN_Independent "id-ppl-independent" ++#define LN_Independent "Independent" ++#define NID_Independent 667 ++#define OBJ_Independent OBJ_id_ppl,2L ++ ++#define SN_ad_OCSP "OCSP" ++#define LN_ad_OCSP "OCSP" ++#define NID_ad_OCSP 178 ++#define OBJ_ad_OCSP OBJ_id_ad,1L ++ ++#define SN_ad_ca_issuers "caIssuers" ++#define LN_ad_ca_issuers "CA Issuers" ++#define NID_ad_ca_issuers 179 ++#define OBJ_ad_ca_issuers OBJ_id_ad,2L ++ ++#define SN_ad_timeStamping "ad_timestamping" ++#define LN_ad_timeStamping "AD Time Stamping" ++#define NID_ad_timeStamping 363 ++#define OBJ_ad_timeStamping OBJ_id_ad,3L ++ ++#define SN_ad_dvcs "AD_DVCS" ++#define LN_ad_dvcs "ad dvcs" ++#define NID_ad_dvcs 364 ++#define OBJ_ad_dvcs OBJ_id_ad,4L ++ ++#define SN_caRepository "caRepository" ++#define LN_caRepository "CA Repository" ++#define NID_caRepository 785 ++#define OBJ_caRepository OBJ_id_ad,5L ++ ++#define OBJ_id_pkix_OCSP OBJ_ad_OCSP ++ ++#define SN_id_pkix_OCSP_basic "basicOCSPResponse" ++#define LN_id_pkix_OCSP_basic "Basic OCSP Response" ++#define NID_id_pkix_OCSP_basic 365 ++#define OBJ_id_pkix_OCSP_basic OBJ_id_pkix_OCSP,1L ++ ++#define SN_id_pkix_OCSP_Nonce "Nonce" ++#define LN_id_pkix_OCSP_Nonce "OCSP Nonce" ++#define NID_id_pkix_OCSP_Nonce 366 ++#define OBJ_id_pkix_OCSP_Nonce OBJ_id_pkix_OCSP,2L ++ ++#define SN_id_pkix_OCSP_CrlID "CrlID" ++#define LN_id_pkix_OCSP_CrlID "OCSP CRL ID" ++#define NID_id_pkix_OCSP_CrlID 367 ++#define OBJ_id_pkix_OCSP_CrlID OBJ_id_pkix_OCSP,3L ++ ++#define SN_id_pkix_OCSP_acceptableResponses "acceptableResponses" ++#define LN_id_pkix_OCSP_acceptableResponses "Acceptable OCSP Responses" ++#define NID_id_pkix_OCSP_acceptableResponses 368 ++#define OBJ_id_pkix_OCSP_acceptableResponses OBJ_id_pkix_OCSP,4L ++ ++#define SN_id_pkix_OCSP_noCheck "noCheck" ++#define LN_id_pkix_OCSP_noCheck "OCSP No Check" ++#define NID_id_pkix_OCSP_noCheck 369 ++#define OBJ_id_pkix_OCSP_noCheck OBJ_id_pkix_OCSP,5L ++ ++#define SN_id_pkix_OCSP_archiveCutoff "archiveCutoff" ++#define LN_id_pkix_OCSP_archiveCutoff "OCSP Archive Cutoff" ++#define NID_id_pkix_OCSP_archiveCutoff 370 ++#define OBJ_id_pkix_OCSP_archiveCutoff OBJ_id_pkix_OCSP,6L ++ ++#define SN_id_pkix_OCSP_serviceLocator "serviceLocator" ++#define LN_id_pkix_OCSP_serviceLocator "OCSP Service Locator" ++#define NID_id_pkix_OCSP_serviceLocator 371 ++#define OBJ_id_pkix_OCSP_serviceLocator OBJ_id_pkix_OCSP,7L ++ ++#define SN_id_pkix_OCSP_extendedStatus "extendedStatus" ++#define LN_id_pkix_OCSP_extendedStatus "Extended OCSP Status" ++#define NID_id_pkix_OCSP_extendedStatus 372 ++#define OBJ_id_pkix_OCSP_extendedStatus OBJ_id_pkix_OCSP,8L ++ ++#define SN_id_pkix_OCSP_valid "valid" ++#define NID_id_pkix_OCSP_valid 373 ++#define OBJ_id_pkix_OCSP_valid OBJ_id_pkix_OCSP,9L ++ ++#define SN_id_pkix_OCSP_path "path" ++#define NID_id_pkix_OCSP_path 374 ++#define OBJ_id_pkix_OCSP_path OBJ_id_pkix_OCSP,10L ++ ++#define SN_id_pkix_OCSP_trustRoot "trustRoot" ++#define LN_id_pkix_OCSP_trustRoot "Trust Root" ++#define NID_id_pkix_OCSP_trustRoot 375 ++#define OBJ_id_pkix_OCSP_trustRoot OBJ_id_pkix_OCSP,11L ++ ++#define SN_algorithm "algorithm" ++#define LN_algorithm "algorithm" ++#define NID_algorithm 376 ++#define OBJ_algorithm 1L,3L,14L,3L,2L ++ ++#define SN_md5WithRSA "RSA-NP-MD5" ++#define LN_md5WithRSA "md5WithRSA" ++#define NID_md5WithRSA 104 ++#define OBJ_md5WithRSA OBJ_algorithm,3L ++ ++#define SN_des_ecb "DES-ECB" ++#define LN_des_ecb "des-ecb" ++#define NID_des_ecb 29 ++#define OBJ_des_ecb OBJ_algorithm,6L ++ ++#define SN_des_cbc "DES-CBC" ++#define LN_des_cbc "des-cbc" ++#define NID_des_cbc 31 ++#define OBJ_des_cbc OBJ_algorithm,7L ++ ++#define SN_des_ofb64 "DES-OFB" ++#define LN_des_ofb64 "des-ofb" ++#define NID_des_ofb64 45 ++#define OBJ_des_ofb64 OBJ_algorithm,8L ++ ++#define SN_des_cfb64 "DES-CFB" ++#define LN_des_cfb64 "des-cfb" ++#define NID_des_cfb64 30 ++#define OBJ_des_cfb64 OBJ_algorithm,9L ++ ++#define SN_rsaSignature "rsaSignature" ++#define NID_rsaSignature 377 ++#define OBJ_rsaSignature OBJ_algorithm,11L ++ ++#define SN_dsa_2 "DSA-old" ++#define LN_dsa_2 "dsaEncryption-old" ++#define NID_dsa_2 67 ++#define OBJ_dsa_2 OBJ_algorithm,12L ++ ++#define SN_dsaWithSHA "DSA-SHA" ++#define LN_dsaWithSHA "dsaWithSHA" ++#define NID_dsaWithSHA 66 ++#define OBJ_dsaWithSHA OBJ_algorithm,13L ++ ++#define SN_shaWithRSAEncryption "RSA-SHA" ++#define LN_shaWithRSAEncryption "shaWithRSAEncryption" ++#define NID_shaWithRSAEncryption 42 ++#define OBJ_shaWithRSAEncryption OBJ_algorithm,15L ++ ++#define SN_des_ede_ecb "DES-EDE" ++#define LN_des_ede_ecb "des-ede" ++#define NID_des_ede_ecb 32 ++#define OBJ_des_ede_ecb OBJ_algorithm,17L ++ ++#define SN_des_ede3_ecb "DES-EDE3" ++#define LN_des_ede3_ecb "des-ede3" ++#define NID_des_ede3_ecb 33 ++ ++#define SN_des_ede_cbc "DES-EDE-CBC" ++#define LN_des_ede_cbc "des-ede-cbc" ++#define NID_des_ede_cbc 43 ++ ++#define SN_des_ede_cfb64 "DES-EDE-CFB" ++#define LN_des_ede_cfb64 "des-ede-cfb" ++#define NID_des_ede_cfb64 60 ++ ++#define SN_des_ede3_cfb64 "DES-EDE3-CFB" ++#define LN_des_ede3_cfb64 "des-ede3-cfb" ++#define NID_des_ede3_cfb64 61 ++ ++#define SN_des_ede_ofb64 "DES-EDE-OFB" ++#define LN_des_ede_ofb64 "des-ede-ofb" ++#define NID_des_ede_ofb64 62 ++ ++#define SN_des_ede3_ofb64 "DES-EDE3-OFB" ++#define LN_des_ede3_ofb64 "des-ede3-ofb" ++#define NID_des_ede3_ofb64 63 ++ ++#define SN_desx_cbc "DESX-CBC" ++#define LN_desx_cbc "desx-cbc" ++#define NID_desx_cbc 80 ++ ++#define SN_sha "SHA" ++#define LN_sha "sha" ++#define NID_sha 41 ++#define OBJ_sha OBJ_algorithm,18L ++ ++#define SN_sha1 "SHA1" ++#define LN_sha1 "sha1" ++#define NID_sha1 64 ++#define OBJ_sha1 OBJ_algorithm,26L ++ ++#define SN_dsaWithSHA1_2 "DSA-SHA1-old" ++#define LN_dsaWithSHA1_2 "dsaWithSHA1-old" ++#define NID_dsaWithSHA1_2 70 ++#define OBJ_dsaWithSHA1_2 OBJ_algorithm,27L ++ ++#define SN_sha1WithRSA "RSA-SHA1-2" ++#define LN_sha1WithRSA "sha1WithRSA" ++#define NID_sha1WithRSA 115 ++#define OBJ_sha1WithRSA OBJ_algorithm,29L ++ ++#define SN_ripemd160 "RIPEMD160" ++#define LN_ripemd160 "ripemd160" ++#define NID_ripemd160 117 ++#define OBJ_ripemd160 1L,3L,36L,3L,2L,1L ++ ++#define SN_ripemd160WithRSA "RSA-RIPEMD160" ++#define LN_ripemd160WithRSA "ripemd160WithRSA" ++#define NID_ripemd160WithRSA 119 ++#define OBJ_ripemd160WithRSA 1L,3L,36L,3L,3L,1L,2L ++ ++#define SN_blake2b512 "BLAKE2b512" ++#define LN_blake2b512 "blake2b512" ++#define NID_blake2b512 1056 ++#define OBJ_blake2b512 1L,3L,6L,1L,4L,1L,1722L,12L,2L,1L,16L ++ ++#define SN_blake2s256 "BLAKE2s256" ++#define LN_blake2s256 "blake2s256" ++#define NID_blake2s256 1057 ++#define OBJ_blake2s256 1L,3L,6L,1L,4L,1L,1722L,12L,2L,2L,8L ++ ++#define SN_sxnet "SXNetID" ++#define LN_sxnet "Strong Extranet ID" ++#define NID_sxnet 143 ++#define OBJ_sxnet 1L,3L,101L,1L,4L,1L ++ ++#define SN_X500 "X500" ++#define LN_X500 "directory services (X.500)" ++#define NID_X500 11 ++#define OBJ_X500 2L,5L ++ ++#define SN_X509 "X509" ++#define NID_X509 12 ++#define OBJ_X509 OBJ_X500,4L ++ ++#define SN_commonName "CN" ++#define LN_commonName "commonName" ++#define NID_commonName 13 ++#define OBJ_commonName OBJ_X509,3L ++ ++#define SN_surname "SN" ++#define LN_surname "surname" ++#define NID_surname 100 ++#define OBJ_surname OBJ_X509,4L ++ ++#define LN_serialNumber "serialNumber" ++#define NID_serialNumber 105 ++#define OBJ_serialNumber OBJ_X509,5L ++ ++#define SN_countryName "C" ++#define LN_countryName "countryName" ++#define NID_countryName 14 ++#define OBJ_countryName OBJ_X509,6L ++ ++#define SN_localityName "L" ++#define LN_localityName "localityName" ++#define NID_localityName 15 ++#define OBJ_localityName OBJ_X509,7L ++ ++#define SN_stateOrProvinceName "ST" ++#define LN_stateOrProvinceName "stateOrProvinceName" ++#define NID_stateOrProvinceName 16 ++#define OBJ_stateOrProvinceName OBJ_X509,8L ++ ++#define SN_streetAddress "street" ++#define LN_streetAddress "streetAddress" ++#define NID_streetAddress 660 ++#define OBJ_streetAddress OBJ_X509,9L ++ ++#define SN_organizationName "O" ++#define LN_organizationName "organizationName" ++#define NID_organizationName 17 ++#define OBJ_organizationName OBJ_X509,10L ++ ++#define SN_organizationalUnitName "OU" ++#define LN_organizationalUnitName "organizationalUnitName" ++#define NID_organizationalUnitName 18 ++#define OBJ_organizationalUnitName OBJ_X509,11L ++ ++#define SN_title "title" ++#define LN_title "title" ++#define NID_title 106 ++#define OBJ_title OBJ_X509,12L ++ ++#define LN_description "description" ++#define NID_description 107 ++#define OBJ_description OBJ_X509,13L ++ ++#define LN_searchGuide "searchGuide" ++#define NID_searchGuide 859 ++#define OBJ_searchGuide OBJ_X509,14L ++ ++#define LN_businessCategory "businessCategory" ++#define NID_businessCategory 860 ++#define OBJ_businessCategory OBJ_X509,15L ++ ++#define LN_postalAddress "postalAddress" ++#define NID_postalAddress 861 ++#define OBJ_postalAddress OBJ_X509,16L ++ ++#define LN_postalCode "postalCode" ++#define NID_postalCode 661 ++#define OBJ_postalCode OBJ_X509,17L ++ ++#define LN_postOfficeBox "postOfficeBox" ++#define NID_postOfficeBox 862 ++#define OBJ_postOfficeBox OBJ_X509,18L ++ ++#define LN_physicalDeliveryOfficeName "physicalDeliveryOfficeName" ++#define NID_physicalDeliveryOfficeName 863 ++#define OBJ_physicalDeliveryOfficeName OBJ_X509,19L ++ ++#define LN_telephoneNumber "telephoneNumber" ++#define NID_telephoneNumber 864 ++#define OBJ_telephoneNumber OBJ_X509,20L ++ ++#define LN_telexNumber "telexNumber" ++#define NID_telexNumber 865 ++#define OBJ_telexNumber OBJ_X509,21L ++ ++#define LN_teletexTerminalIdentifier "teletexTerminalIdentifier" ++#define NID_teletexTerminalIdentifier 866 ++#define OBJ_teletexTerminalIdentifier OBJ_X509,22L ++ ++#define LN_facsimileTelephoneNumber "facsimileTelephoneNumber" ++#define NID_facsimileTelephoneNumber 867 ++#define OBJ_facsimileTelephoneNumber OBJ_X509,23L ++ ++#define LN_x121Address "x121Address" ++#define NID_x121Address 868 ++#define OBJ_x121Address OBJ_X509,24L ++ ++#define LN_internationaliSDNNumber "internationaliSDNNumber" ++#define NID_internationaliSDNNumber 869 ++#define OBJ_internationaliSDNNumber OBJ_X509,25L ++ ++#define LN_registeredAddress "registeredAddress" ++#define NID_registeredAddress 870 ++#define OBJ_registeredAddress OBJ_X509,26L ++ ++#define LN_destinationIndicator "destinationIndicator" ++#define NID_destinationIndicator 871 ++#define OBJ_destinationIndicator OBJ_X509,27L ++ ++#define LN_preferredDeliveryMethod "preferredDeliveryMethod" ++#define NID_preferredDeliveryMethod 872 ++#define OBJ_preferredDeliveryMethod OBJ_X509,28L ++ ++#define LN_presentationAddress "presentationAddress" ++#define NID_presentationAddress 873 ++#define OBJ_presentationAddress OBJ_X509,29L ++ ++#define LN_supportedApplicationContext "supportedApplicationContext" ++#define NID_supportedApplicationContext 874 ++#define OBJ_supportedApplicationContext OBJ_X509,30L ++ ++#define SN_member "member" ++#define NID_member 875 ++#define OBJ_member OBJ_X509,31L ++ ++#define SN_owner "owner" ++#define NID_owner 876 ++#define OBJ_owner OBJ_X509,32L ++ ++#define LN_roleOccupant "roleOccupant" ++#define NID_roleOccupant 877 ++#define OBJ_roleOccupant OBJ_X509,33L ++ ++#define SN_seeAlso "seeAlso" ++#define NID_seeAlso 878 ++#define OBJ_seeAlso OBJ_X509,34L ++ ++#define LN_userPassword "userPassword" ++#define NID_userPassword 879 ++#define OBJ_userPassword OBJ_X509,35L ++ ++#define LN_userCertificate "userCertificate" ++#define NID_userCertificate 880 ++#define OBJ_userCertificate OBJ_X509,36L ++ ++#define LN_cACertificate "cACertificate" ++#define NID_cACertificate 881 ++#define OBJ_cACertificate OBJ_X509,37L ++ ++#define LN_authorityRevocationList "authorityRevocationList" ++#define NID_authorityRevocationList 882 ++#define OBJ_authorityRevocationList OBJ_X509,38L ++ ++#define LN_certificateRevocationList "certificateRevocationList" ++#define NID_certificateRevocationList 883 ++#define OBJ_certificateRevocationList OBJ_X509,39L ++ ++#define LN_crossCertificatePair "crossCertificatePair" ++#define NID_crossCertificatePair 884 ++#define OBJ_crossCertificatePair OBJ_X509,40L ++ ++#define SN_name "name" ++#define LN_name "name" ++#define NID_name 173 ++#define OBJ_name OBJ_X509,41L ++ ++#define SN_givenName "GN" ++#define LN_givenName "givenName" ++#define NID_givenName 99 ++#define OBJ_givenName OBJ_X509,42L ++ ++#define SN_initials "initials" ++#define LN_initials "initials" ++#define NID_initials 101 ++#define OBJ_initials OBJ_X509,43L ++ ++#define LN_generationQualifier "generationQualifier" ++#define NID_generationQualifier 509 ++#define OBJ_generationQualifier OBJ_X509,44L ++ ++#define LN_x500UniqueIdentifier "x500UniqueIdentifier" ++#define NID_x500UniqueIdentifier 503 ++#define OBJ_x500UniqueIdentifier OBJ_X509,45L ++ ++#define SN_dnQualifier "dnQualifier" ++#define LN_dnQualifier "dnQualifier" ++#define NID_dnQualifier 174 ++#define OBJ_dnQualifier OBJ_X509,46L ++ ++#define LN_enhancedSearchGuide "enhancedSearchGuide" ++#define NID_enhancedSearchGuide 885 ++#define OBJ_enhancedSearchGuide OBJ_X509,47L ++ ++#define LN_protocolInformation "protocolInformation" ++#define NID_protocolInformation 886 ++#define OBJ_protocolInformation OBJ_X509,48L ++ ++#define LN_distinguishedName "distinguishedName" ++#define NID_distinguishedName 887 ++#define OBJ_distinguishedName OBJ_X509,49L ++ ++#define LN_uniqueMember "uniqueMember" ++#define NID_uniqueMember 888 ++#define OBJ_uniqueMember OBJ_X509,50L ++ ++#define LN_houseIdentifier "houseIdentifier" ++#define NID_houseIdentifier 889 ++#define OBJ_houseIdentifier OBJ_X509,51L ++ ++#define LN_supportedAlgorithms "supportedAlgorithms" ++#define NID_supportedAlgorithms 890 ++#define OBJ_supportedAlgorithms OBJ_X509,52L ++ ++#define LN_deltaRevocationList "deltaRevocationList" ++#define NID_deltaRevocationList 891 ++#define OBJ_deltaRevocationList OBJ_X509,53L ++ ++#define SN_dmdName "dmdName" ++#define NID_dmdName 892 ++#define OBJ_dmdName OBJ_X509,54L ++ ++#define LN_pseudonym "pseudonym" ++#define NID_pseudonym 510 ++#define OBJ_pseudonym OBJ_X509,65L ++ ++#define SN_role "role" ++#define LN_role "role" ++#define NID_role 400 ++#define OBJ_role OBJ_X509,72L ++ ++#define LN_organizationIdentifier "organizationIdentifier" ++#define NID_organizationIdentifier 1089 ++#define OBJ_organizationIdentifier OBJ_X509,97L ++ ++#define SN_countryCode3c "c3" ++#define LN_countryCode3c "countryCode3c" ++#define NID_countryCode3c 1090 ++#define OBJ_countryCode3c OBJ_X509,98L ++ ++#define SN_countryCode3n "n3" ++#define LN_countryCode3n "countryCode3n" ++#define NID_countryCode3n 1091 ++#define OBJ_countryCode3n OBJ_X509,99L ++ ++#define LN_dnsName "dnsName" ++#define NID_dnsName 1092 ++#define OBJ_dnsName OBJ_X509,100L ++ ++#define SN_X500algorithms "X500algorithms" ++#define LN_X500algorithms "directory services - algorithms" ++#define NID_X500algorithms 378 ++#define OBJ_X500algorithms OBJ_X500,8L ++ ++#define SN_rsa "RSA" ++#define LN_rsa "rsa" ++#define NID_rsa 19 ++#define OBJ_rsa OBJ_X500algorithms,1L,1L ++ ++#define SN_mdc2WithRSA "RSA-MDC2" ++#define LN_mdc2WithRSA "mdc2WithRSA" ++#define NID_mdc2WithRSA 96 ++#define OBJ_mdc2WithRSA OBJ_X500algorithms,3L,100L ++ ++#define SN_mdc2 "MDC2" ++#define LN_mdc2 "mdc2" ++#define NID_mdc2 95 ++#define OBJ_mdc2 OBJ_X500algorithms,3L,101L ++ ++#define SN_id_ce "id-ce" ++#define NID_id_ce 81 ++#define OBJ_id_ce OBJ_X500,29L ++ ++#define SN_subject_directory_attributes "subjectDirectoryAttributes" ++#define LN_subject_directory_attributes "X509v3 Subject Directory Attributes" ++#define NID_subject_directory_attributes 769 ++#define OBJ_subject_directory_attributes OBJ_id_ce,9L ++ ++#define SN_subject_key_identifier "subjectKeyIdentifier" ++#define LN_subject_key_identifier "X509v3 Subject Key Identifier" ++#define NID_subject_key_identifier 82 ++#define OBJ_subject_key_identifier OBJ_id_ce,14L ++ ++#define SN_key_usage "keyUsage" ++#define LN_key_usage "X509v3 Key Usage" ++#define NID_key_usage 83 ++#define OBJ_key_usage OBJ_id_ce,15L ++ ++#define SN_private_key_usage_period "privateKeyUsagePeriod" ++#define LN_private_key_usage_period "X509v3 Private Key Usage Period" ++#define NID_private_key_usage_period 84 ++#define OBJ_private_key_usage_period OBJ_id_ce,16L ++ ++#define SN_subject_alt_name "subjectAltName" ++#define LN_subject_alt_name "X509v3 Subject Alternative Name" ++#define NID_subject_alt_name 85 ++#define OBJ_subject_alt_name OBJ_id_ce,17L ++ ++#define SN_issuer_alt_name "issuerAltName" ++#define LN_issuer_alt_name "X509v3 Issuer Alternative Name" ++#define NID_issuer_alt_name 86 ++#define OBJ_issuer_alt_name OBJ_id_ce,18L ++ ++#define SN_basic_constraints "basicConstraints" ++#define LN_basic_constraints "X509v3 Basic Constraints" ++#define NID_basic_constraints 87 ++#define OBJ_basic_constraints OBJ_id_ce,19L ++ ++#define SN_crl_number "crlNumber" ++#define LN_crl_number "X509v3 CRL Number" ++#define NID_crl_number 88 ++#define OBJ_crl_number OBJ_id_ce,20L ++ ++#define SN_crl_reason "CRLReason" ++#define LN_crl_reason "X509v3 CRL Reason Code" ++#define NID_crl_reason 141 ++#define OBJ_crl_reason OBJ_id_ce,21L ++ ++#define SN_invalidity_date "invalidityDate" ++#define LN_invalidity_date "Invalidity Date" ++#define NID_invalidity_date 142 ++#define OBJ_invalidity_date OBJ_id_ce,24L ++ ++#define SN_delta_crl "deltaCRL" ++#define LN_delta_crl "X509v3 Delta CRL Indicator" ++#define NID_delta_crl 140 ++#define OBJ_delta_crl OBJ_id_ce,27L ++ ++#define SN_issuing_distribution_point "issuingDistributionPoint" ++#define LN_issuing_distribution_point "X509v3 Issuing Distribution Point" ++#define NID_issuing_distribution_point 770 ++#define OBJ_issuing_distribution_point OBJ_id_ce,28L ++ ++#define SN_certificate_issuer "certificateIssuer" ++#define LN_certificate_issuer "X509v3 Certificate Issuer" ++#define NID_certificate_issuer 771 ++#define OBJ_certificate_issuer OBJ_id_ce,29L ++ ++#define SN_name_constraints "nameConstraints" ++#define LN_name_constraints "X509v3 Name Constraints" ++#define NID_name_constraints 666 ++#define OBJ_name_constraints OBJ_id_ce,30L ++ ++#define SN_crl_distribution_points "crlDistributionPoints" ++#define LN_crl_distribution_points "X509v3 CRL Distribution Points" ++#define NID_crl_distribution_points 103 ++#define OBJ_crl_distribution_points OBJ_id_ce,31L ++ ++#define SN_certificate_policies "certificatePolicies" ++#define LN_certificate_policies "X509v3 Certificate Policies" ++#define NID_certificate_policies 89 ++#define OBJ_certificate_policies OBJ_id_ce,32L ++ ++#define SN_any_policy "anyPolicy" ++#define LN_any_policy "X509v3 Any Policy" ++#define NID_any_policy 746 ++#define OBJ_any_policy OBJ_certificate_policies,0L ++ ++#define SN_policy_mappings "policyMappings" ++#define LN_policy_mappings "X509v3 Policy Mappings" ++#define NID_policy_mappings 747 ++#define OBJ_policy_mappings OBJ_id_ce,33L ++ ++#define SN_authority_key_identifier "authorityKeyIdentifier" ++#define LN_authority_key_identifier "X509v3 Authority Key Identifier" ++#define NID_authority_key_identifier 90 ++#define OBJ_authority_key_identifier OBJ_id_ce,35L ++ ++#define SN_policy_constraints "policyConstraints" ++#define LN_policy_constraints "X509v3 Policy Constraints" ++#define NID_policy_constraints 401 ++#define OBJ_policy_constraints OBJ_id_ce,36L ++ ++#define SN_ext_key_usage "extendedKeyUsage" ++#define LN_ext_key_usage "X509v3 Extended Key Usage" ++#define NID_ext_key_usage 126 ++#define OBJ_ext_key_usage OBJ_id_ce,37L ++ ++#define SN_freshest_crl "freshestCRL" ++#define LN_freshest_crl "X509v3 Freshest CRL" ++#define NID_freshest_crl 857 ++#define OBJ_freshest_crl OBJ_id_ce,46L ++ ++#define SN_inhibit_any_policy "inhibitAnyPolicy" ++#define LN_inhibit_any_policy "X509v3 Inhibit Any Policy" ++#define NID_inhibit_any_policy 748 ++#define OBJ_inhibit_any_policy OBJ_id_ce,54L ++ ++#define SN_target_information "targetInformation" ++#define LN_target_information "X509v3 AC Targeting" ++#define NID_target_information 402 ++#define OBJ_target_information OBJ_id_ce,55L ++ ++#define SN_no_rev_avail "noRevAvail" ++#define LN_no_rev_avail "X509v3 No Revocation Available" ++#define NID_no_rev_avail 403 ++#define OBJ_no_rev_avail OBJ_id_ce,56L ++ ++#define SN_anyExtendedKeyUsage "anyExtendedKeyUsage" ++#define LN_anyExtendedKeyUsage "Any Extended Key Usage" ++#define NID_anyExtendedKeyUsage 910 ++#define OBJ_anyExtendedKeyUsage OBJ_ext_key_usage,0L ++ ++#define SN_netscape "Netscape" ++#define LN_netscape "Netscape Communications Corp." ++#define NID_netscape 57 ++#define OBJ_netscape 2L,16L,840L,1L,113730L ++ ++#define SN_netscape_cert_extension "nsCertExt" ++#define LN_netscape_cert_extension "Netscape Certificate Extension" ++#define NID_netscape_cert_extension 58 ++#define OBJ_netscape_cert_extension OBJ_netscape,1L ++ ++#define SN_netscape_data_type "nsDataType" ++#define LN_netscape_data_type "Netscape Data Type" ++#define NID_netscape_data_type 59 ++#define OBJ_netscape_data_type OBJ_netscape,2L ++ ++#define SN_netscape_cert_type "nsCertType" ++#define LN_netscape_cert_type "Netscape Cert Type" ++#define NID_netscape_cert_type 71 ++#define OBJ_netscape_cert_type OBJ_netscape_cert_extension,1L ++ ++#define SN_netscape_base_url "nsBaseUrl" ++#define LN_netscape_base_url "Netscape Base Url" ++#define NID_netscape_base_url 72 ++#define OBJ_netscape_base_url OBJ_netscape_cert_extension,2L ++ ++#define SN_netscape_revocation_url "nsRevocationUrl" ++#define LN_netscape_revocation_url "Netscape Revocation Url" ++#define NID_netscape_revocation_url 73 ++#define OBJ_netscape_revocation_url OBJ_netscape_cert_extension,3L ++ ++#define SN_netscape_ca_revocation_url "nsCaRevocationUrl" ++#define LN_netscape_ca_revocation_url "Netscape CA Revocation Url" ++#define NID_netscape_ca_revocation_url 74 ++#define OBJ_netscape_ca_revocation_url OBJ_netscape_cert_extension,4L ++ ++#define SN_netscape_renewal_url "nsRenewalUrl" ++#define LN_netscape_renewal_url "Netscape Renewal Url" ++#define NID_netscape_renewal_url 75 ++#define OBJ_netscape_renewal_url OBJ_netscape_cert_extension,7L ++ ++#define SN_netscape_ca_policy_url "nsCaPolicyUrl" ++#define LN_netscape_ca_policy_url "Netscape CA Policy Url" ++#define NID_netscape_ca_policy_url 76 ++#define OBJ_netscape_ca_policy_url OBJ_netscape_cert_extension,8L ++ ++#define SN_netscape_ssl_server_name "nsSslServerName" ++#define LN_netscape_ssl_server_name "Netscape SSL Server Name" ++#define NID_netscape_ssl_server_name 77 ++#define OBJ_netscape_ssl_server_name OBJ_netscape_cert_extension,12L ++ ++#define SN_netscape_comment "nsComment" ++#define LN_netscape_comment "Netscape Comment" ++#define NID_netscape_comment 78 ++#define OBJ_netscape_comment OBJ_netscape_cert_extension,13L ++ ++#define SN_netscape_cert_sequence "nsCertSequence" ++#define LN_netscape_cert_sequence "Netscape Certificate Sequence" ++#define NID_netscape_cert_sequence 79 ++#define OBJ_netscape_cert_sequence OBJ_netscape_data_type,5L ++ ++#define SN_ns_sgc "nsSGC" ++#define LN_ns_sgc "Netscape Server Gated Crypto" ++#define NID_ns_sgc 139 ++#define OBJ_ns_sgc OBJ_netscape,4L,1L ++ ++#define SN_org "ORG" ++#define LN_org "org" ++#define NID_org 379 ++#define OBJ_org OBJ_iso,3L ++ ++#define SN_dod "DOD" ++#define LN_dod "dod" ++#define NID_dod 380 ++#define OBJ_dod OBJ_org,6L ++ ++#define SN_iana "IANA" ++#define LN_iana "iana" ++#define NID_iana 381 ++#define OBJ_iana OBJ_dod,1L ++ ++#define OBJ_internet OBJ_iana ++ ++#define SN_Directory "directory" ++#define LN_Directory "Directory" ++#define NID_Directory 382 ++#define OBJ_Directory OBJ_internet,1L ++ ++#define SN_Management "mgmt" ++#define LN_Management "Management" ++#define NID_Management 383 ++#define OBJ_Management OBJ_internet,2L ++ ++#define SN_Experimental "experimental" ++#define LN_Experimental "Experimental" ++#define NID_Experimental 384 ++#define OBJ_Experimental OBJ_internet,3L ++ ++#define SN_Private "private" ++#define LN_Private "Private" ++#define NID_Private 385 ++#define OBJ_Private OBJ_internet,4L ++ ++#define SN_Security "security" ++#define LN_Security "Security" ++#define NID_Security 386 ++#define OBJ_Security OBJ_internet,5L ++ ++#define SN_SNMPv2 "snmpv2" ++#define LN_SNMPv2 "SNMPv2" ++#define NID_SNMPv2 387 ++#define OBJ_SNMPv2 OBJ_internet,6L ++ ++#define LN_Mail "Mail" ++#define NID_Mail 388 ++#define OBJ_Mail OBJ_internet,7L ++ ++#define SN_Enterprises "enterprises" ++#define LN_Enterprises "Enterprises" ++#define NID_Enterprises 389 ++#define OBJ_Enterprises OBJ_Private,1L ++ ++#define SN_dcObject "dcobject" ++#define LN_dcObject "dcObject" ++#define NID_dcObject 390 ++#define OBJ_dcObject OBJ_Enterprises,1466L,344L ++ ++#define SN_mime_mhs "mime-mhs" ++#define LN_mime_mhs "MIME MHS" ++#define NID_mime_mhs 504 ++#define OBJ_mime_mhs OBJ_Mail,1L ++ ++#define SN_mime_mhs_headings "mime-mhs-headings" ++#define LN_mime_mhs_headings "mime-mhs-headings" ++#define NID_mime_mhs_headings 505 ++#define OBJ_mime_mhs_headings OBJ_mime_mhs,1L ++ ++#define SN_mime_mhs_bodies "mime-mhs-bodies" ++#define LN_mime_mhs_bodies "mime-mhs-bodies" ++#define NID_mime_mhs_bodies 506 ++#define OBJ_mime_mhs_bodies OBJ_mime_mhs,2L ++ ++#define SN_id_hex_partial_message "id-hex-partial-message" ++#define LN_id_hex_partial_message "id-hex-partial-message" ++#define NID_id_hex_partial_message 507 ++#define OBJ_id_hex_partial_message OBJ_mime_mhs_headings,1L ++ ++#define SN_id_hex_multipart_message "id-hex-multipart-message" ++#define LN_id_hex_multipart_message "id-hex-multipart-message" ++#define NID_id_hex_multipart_message 508 ++#define OBJ_id_hex_multipart_message OBJ_mime_mhs_headings,2L ++ ++#define SN_zlib_compression "ZLIB" ++#define LN_zlib_compression "zlib compression" ++#define NID_zlib_compression 125 ++#define OBJ_zlib_compression OBJ_id_smime_alg,8L ++ ++#define OBJ_csor 2L,16L,840L,1L,101L,3L ++ ++#define OBJ_nistAlgorithms OBJ_csor,4L ++ ++#define OBJ_aes OBJ_nistAlgorithms,1L ++ ++#define SN_aes_128_ecb "AES-128-ECB" ++#define LN_aes_128_ecb "aes-128-ecb" ++#define NID_aes_128_ecb 418 ++#define OBJ_aes_128_ecb OBJ_aes,1L ++ ++#define SN_aes_128_cbc "AES-128-CBC" ++#define LN_aes_128_cbc "aes-128-cbc" ++#define NID_aes_128_cbc 419 ++#define OBJ_aes_128_cbc OBJ_aes,2L ++ ++#define SN_aes_128_ofb128 "AES-128-OFB" ++#define LN_aes_128_ofb128 "aes-128-ofb" ++#define NID_aes_128_ofb128 420 ++#define OBJ_aes_128_ofb128 OBJ_aes,3L ++ ++#define SN_aes_128_cfb128 "AES-128-CFB" ++#define LN_aes_128_cfb128 "aes-128-cfb" ++#define NID_aes_128_cfb128 421 ++#define OBJ_aes_128_cfb128 OBJ_aes,4L ++ ++#define SN_id_aes128_wrap "id-aes128-wrap" ++#define NID_id_aes128_wrap 788 ++#define OBJ_id_aes128_wrap OBJ_aes,5L ++ ++#define SN_aes_128_gcm "id-aes128-GCM" ++#define LN_aes_128_gcm "aes-128-gcm" ++#define NID_aes_128_gcm 895 ++#define OBJ_aes_128_gcm OBJ_aes,6L ++ ++#define SN_aes_128_ccm "id-aes128-CCM" ++#define LN_aes_128_ccm "aes-128-ccm" ++#define NID_aes_128_ccm 896 ++#define OBJ_aes_128_ccm OBJ_aes,7L ++ ++#define SN_id_aes128_wrap_pad "id-aes128-wrap-pad" ++#define NID_id_aes128_wrap_pad 897 ++#define OBJ_id_aes128_wrap_pad OBJ_aes,8L ++ ++#define SN_aes_192_ecb "AES-192-ECB" ++#define LN_aes_192_ecb "aes-192-ecb" ++#define NID_aes_192_ecb 422 ++#define OBJ_aes_192_ecb OBJ_aes,21L ++ ++#define SN_aes_192_cbc "AES-192-CBC" ++#define LN_aes_192_cbc "aes-192-cbc" ++#define NID_aes_192_cbc 423 ++#define OBJ_aes_192_cbc OBJ_aes,22L ++ ++#define SN_aes_192_ofb128 "AES-192-OFB" ++#define LN_aes_192_ofb128 "aes-192-ofb" ++#define NID_aes_192_ofb128 424 ++#define OBJ_aes_192_ofb128 OBJ_aes,23L ++ ++#define SN_aes_192_cfb128 "AES-192-CFB" ++#define LN_aes_192_cfb128 "aes-192-cfb" ++#define NID_aes_192_cfb128 425 ++#define OBJ_aes_192_cfb128 OBJ_aes,24L ++ ++#define SN_id_aes192_wrap "id-aes192-wrap" ++#define NID_id_aes192_wrap 789 ++#define OBJ_id_aes192_wrap OBJ_aes,25L ++ ++#define SN_aes_192_gcm "id-aes192-GCM" ++#define LN_aes_192_gcm "aes-192-gcm" ++#define NID_aes_192_gcm 898 ++#define OBJ_aes_192_gcm OBJ_aes,26L ++ ++#define SN_aes_192_ccm "id-aes192-CCM" ++#define LN_aes_192_ccm "aes-192-ccm" ++#define NID_aes_192_ccm 899 ++#define OBJ_aes_192_ccm OBJ_aes,27L ++ ++#define SN_id_aes192_wrap_pad "id-aes192-wrap-pad" ++#define NID_id_aes192_wrap_pad 900 ++#define OBJ_id_aes192_wrap_pad OBJ_aes,28L ++ ++#define SN_aes_256_ecb "AES-256-ECB" ++#define LN_aes_256_ecb "aes-256-ecb" ++#define NID_aes_256_ecb 426 ++#define OBJ_aes_256_ecb OBJ_aes,41L ++ ++#define SN_aes_256_cbc "AES-256-CBC" ++#define LN_aes_256_cbc "aes-256-cbc" ++#define NID_aes_256_cbc 427 ++#define OBJ_aes_256_cbc OBJ_aes,42L ++ ++#define SN_aes_256_ofb128 "AES-256-OFB" ++#define LN_aes_256_ofb128 "aes-256-ofb" ++#define NID_aes_256_ofb128 428 ++#define OBJ_aes_256_ofb128 OBJ_aes,43L ++ ++#define SN_aes_256_cfb128 "AES-256-CFB" ++#define LN_aes_256_cfb128 "aes-256-cfb" ++#define NID_aes_256_cfb128 429 ++#define OBJ_aes_256_cfb128 OBJ_aes,44L ++ ++#define SN_id_aes256_wrap "id-aes256-wrap" ++#define NID_id_aes256_wrap 790 ++#define OBJ_id_aes256_wrap OBJ_aes,45L ++ ++#define SN_aes_256_gcm "id-aes256-GCM" ++#define LN_aes_256_gcm "aes-256-gcm" ++#define NID_aes_256_gcm 901 ++#define OBJ_aes_256_gcm OBJ_aes,46L ++ ++#define SN_aes_256_ccm "id-aes256-CCM" ++#define LN_aes_256_ccm "aes-256-ccm" ++#define NID_aes_256_ccm 902 ++#define OBJ_aes_256_ccm OBJ_aes,47L ++ ++#define SN_id_aes256_wrap_pad "id-aes256-wrap-pad" ++#define NID_id_aes256_wrap_pad 903 ++#define OBJ_id_aes256_wrap_pad OBJ_aes,48L ++ ++#define SN_aes_128_xts "AES-128-XTS" ++#define LN_aes_128_xts "aes-128-xts" ++#define NID_aes_128_xts 913 ++#define OBJ_aes_128_xts OBJ_ieee_siswg,0L,1L,1L ++ ++#define SN_aes_256_xts "AES-256-XTS" ++#define LN_aes_256_xts "aes-256-xts" ++#define NID_aes_256_xts 914 ++#define OBJ_aes_256_xts OBJ_ieee_siswg,0L,1L,2L ++ ++#define SN_aes_128_cfb1 "AES-128-CFB1" ++#define LN_aes_128_cfb1 "aes-128-cfb1" ++#define NID_aes_128_cfb1 650 ++ ++#define SN_aes_192_cfb1 "AES-192-CFB1" ++#define LN_aes_192_cfb1 "aes-192-cfb1" ++#define NID_aes_192_cfb1 651 ++ ++#define SN_aes_256_cfb1 "AES-256-CFB1" ++#define LN_aes_256_cfb1 "aes-256-cfb1" ++#define NID_aes_256_cfb1 652 ++ ++#define SN_aes_128_cfb8 "AES-128-CFB8" ++#define LN_aes_128_cfb8 "aes-128-cfb8" ++#define NID_aes_128_cfb8 653 ++ ++#define SN_aes_192_cfb8 "AES-192-CFB8" ++#define LN_aes_192_cfb8 "aes-192-cfb8" ++#define NID_aes_192_cfb8 654 ++ ++#define SN_aes_256_cfb8 "AES-256-CFB8" ++#define LN_aes_256_cfb8 "aes-256-cfb8" ++#define NID_aes_256_cfb8 655 ++ ++#define SN_aes_128_ctr "AES-128-CTR" ++#define LN_aes_128_ctr "aes-128-ctr" ++#define NID_aes_128_ctr 904 ++ ++#define SN_aes_192_ctr "AES-192-CTR" ++#define LN_aes_192_ctr "aes-192-ctr" ++#define NID_aes_192_ctr 905 ++ ++#define SN_aes_256_ctr "AES-256-CTR" ++#define LN_aes_256_ctr "aes-256-ctr" ++#define NID_aes_256_ctr 906 ++ ++#define SN_aes_128_ocb "AES-128-OCB" ++#define LN_aes_128_ocb "aes-128-ocb" ++#define NID_aes_128_ocb 958 ++ ++#define SN_aes_192_ocb "AES-192-OCB" ++#define LN_aes_192_ocb "aes-192-ocb" ++#define NID_aes_192_ocb 959 ++ ++#define SN_aes_256_ocb "AES-256-OCB" ++#define LN_aes_256_ocb "aes-256-ocb" ++#define NID_aes_256_ocb 960 ++ ++#define SN_des_cfb1 "DES-CFB1" ++#define LN_des_cfb1 "des-cfb1" ++#define NID_des_cfb1 656 ++ ++#define SN_des_cfb8 "DES-CFB8" ++#define LN_des_cfb8 "des-cfb8" ++#define NID_des_cfb8 657 ++ ++#define SN_des_ede3_cfb1 "DES-EDE3-CFB1" ++#define LN_des_ede3_cfb1 "des-ede3-cfb1" ++#define NID_des_ede3_cfb1 658 ++ ++#define SN_des_ede3_cfb8 "DES-EDE3-CFB8" ++#define LN_des_ede3_cfb8 "des-ede3-cfb8" ++#define NID_des_ede3_cfb8 659 ++ ++#define OBJ_nist_hashalgs OBJ_nistAlgorithms,2L ++ ++#define SN_sha256 "SHA256" ++#define LN_sha256 "sha256" ++#define NID_sha256 672 ++#define OBJ_sha256 OBJ_nist_hashalgs,1L ++ ++#define SN_sha384 "SHA384" ++#define LN_sha384 "sha384" ++#define NID_sha384 673 ++#define OBJ_sha384 OBJ_nist_hashalgs,2L ++ ++#define SN_sha512 "SHA512" ++#define LN_sha512 "sha512" ++#define NID_sha512 674 ++#define OBJ_sha512 OBJ_nist_hashalgs,3L ++ ++#define SN_sha224 "SHA224" ++#define LN_sha224 "sha224" ++#define NID_sha224 675 ++#define OBJ_sha224 OBJ_nist_hashalgs,4L ++ ++#define SN_sha512_224 "SHA512-224" ++#define LN_sha512_224 "sha512-224" ++#define NID_sha512_224 1094 ++#define OBJ_sha512_224 OBJ_nist_hashalgs,5L ++ ++#define SN_sha512_256 "SHA512-256" ++#define LN_sha512_256 "sha512-256" ++#define NID_sha512_256 1095 ++#define OBJ_sha512_256 OBJ_nist_hashalgs,6L ++ ++#define SN_sha3_224 "SHA3-224" ++#define LN_sha3_224 "sha3-224" ++#define NID_sha3_224 1096 ++#define OBJ_sha3_224 OBJ_nist_hashalgs,7L ++ ++#define SN_sha3_256 "SHA3-256" ++#define LN_sha3_256 "sha3-256" ++#define NID_sha3_256 1097 ++#define OBJ_sha3_256 OBJ_nist_hashalgs,8L ++ ++#define SN_sha3_384 "SHA3-384" ++#define LN_sha3_384 "sha3-384" ++#define NID_sha3_384 1098 ++#define OBJ_sha3_384 OBJ_nist_hashalgs,9L ++ ++#define SN_sha3_512 "SHA3-512" ++#define LN_sha3_512 "sha3-512" ++#define NID_sha3_512 1099 ++#define OBJ_sha3_512 OBJ_nist_hashalgs,10L ++ ++#define SN_shake128 "SHAKE128" ++#define LN_shake128 "shake128" ++#define NID_shake128 1100 ++#define OBJ_shake128 OBJ_nist_hashalgs,11L ++ ++#define SN_shake256 "SHAKE256" ++#define LN_shake256 "shake256" ++#define NID_shake256 1101 ++#define OBJ_shake256 OBJ_nist_hashalgs,12L ++ ++#define SN_hmac_sha3_224 "id-hmacWithSHA3-224" ++#define LN_hmac_sha3_224 "hmac-sha3-224" ++#define NID_hmac_sha3_224 1102 ++#define OBJ_hmac_sha3_224 OBJ_nist_hashalgs,13L ++ ++#define SN_hmac_sha3_256 "id-hmacWithSHA3-256" ++#define LN_hmac_sha3_256 "hmac-sha3-256" ++#define NID_hmac_sha3_256 1103 ++#define OBJ_hmac_sha3_256 OBJ_nist_hashalgs,14L ++ ++#define SN_hmac_sha3_384 "id-hmacWithSHA3-384" ++#define LN_hmac_sha3_384 "hmac-sha3-384" ++#define NID_hmac_sha3_384 1104 ++#define OBJ_hmac_sha3_384 OBJ_nist_hashalgs,15L ++ ++#define SN_hmac_sha3_512 "id-hmacWithSHA3-512" ++#define LN_hmac_sha3_512 "hmac-sha3-512" ++#define NID_hmac_sha3_512 1105 ++#define OBJ_hmac_sha3_512 OBJ_nist_hashalgs,16L ++ ++#define OBJ_dsa_with_sha2 OBJ_nistAlgorithms,3L ++ ++#define SN_dsa_with_SHA224 "dsa_with_SHA224" ++#define NID_dsa_with_SHA224 802 ++#define OBJ_dsa_with_SHA224 OBJ_dsa_with_sha2,1L ++ ++#define SN_dsa_with_SHA256 "dsa_with_SHA256" ++#define NID_dsa_with_SHA256 803 ++#define OBJ_dsa_with_SHA256 OBJ_dsa_with_sha2,2L ++ ++#define OBJ_sigAlgs OBJ_nistAlgorithms,3L ++ ++#define SN_dsa_with_SHA384 "id-dsa-with-sha384" ++#define LN_dsa_with_SHA384 "dsa_with_SHA384" ++#define NID_dsa_with_SHA384 1106 ++#define OBJ_dsa_with_SHA384 OBJ_sigAlgs,3L ++ ++#define SN_dsa_with_SHA512 "id-dsa-with-sha512" ++#define LN_dsa_with_SHA512 "dsa_with_SHA512" ++#define NID_dsa_with_SHA512 1107 ++#define OBJ_dsa_with_SHA512 OBJ_sigAlgs,4L ++ ++#define SN_dsa_with_SHA3_224 "id-dsa-with-sha3-224" ++#define LN_dsa_with_SHA3_224 "dsa_with_SHA3-224" ++#define NID_dsa_with_SHA3_224 1108 ++#define OBJ_dsa_with_SHA3_224 OBJ_sigAlgs,5L ++ ++#define SN_dsa_with_SHA3_256 "id-dsa-with-sha3-256" ++#define LN_dsa_with_SHA3_256 "dsa_with_SHA3-256" ++#define NID_dsa_with_SHA3_256 1109 ++#define OBJ_dsa_with_SHA3_256 OBJ_sigAlgs,6L ++ ++#define SN_dsa_with_SHA3_384 "id-dsa-with-sha3-384" ++#define LN_dsa_with_SHA3_384 "dsa_with_SHA3-384" ++#define NID_dsa_with_SHA3_384 1110 ++#define OBJ_dsa_with_SHA3_384 OBJ_sigAlgs,7L ++ ++#define SN_dsa_with_SHA3_512 "id-dsa-with-sha3-512" ++#define LN_dsa_with_SHA3_512 "dsa_with_SHA3-512" ++#define NID_dsa_with_SHA3_512 1111 ++#define OBJ_dsa_with_SHA3_512 OBJ_sigAlgs,8L ++ ++#define SN_ecdsa_with_SHA3_224 "id-ecdsa-with-sha3-224" ++#define LN_ecdsa_with_SHA3_224 "ecdsa_with_SHA3-224" ++#define NID_ecdsa_with_SHA3_224 1112 ++#define OBJ_ecdsa_with_SHA3_224 OBJ_sigAlgs,9L ++ ++#define SN_ecdsa_with_SHA3_256 "id-ecdsa-with-sha3-256" ++#define LN_ecdsa_with_SHA3_256 "ecdsa_with_SHA3-256" ++#define NID_ecdsa_with_SHA3_256 1113 ++#define OBJ_ecdsa_with_SHA3_256 OBJ_sigAlgs,10L ++ ++#define SN_ecdsa_with_SHA3_384 "id-ecdsa-with-sha3-384" ++#define LN_ecdsa_with_SHA3_384 "ecdsa_with_SHA3-384" ++#define NID_ecdsa_with_SHA3_384 1114 ++#define OBJ_ecdsa_with_SHA3_384 OBJ_sigAlgs,11L ++ ++#define SN_ecdsa_with_SHA3_512 "id-ecdsa-with-sha3-512" ++#define LN_ecdsa_with_SHA3_512 "ecdsa_with_SHA3-512" ++#define NID_ecdsa_with_SHA3_512 1115 ++#define OBJ_ecdsa_with_SHA3_512 OBJ_sigAlgs,12L ++ ++#define SN_RSA_SHA3_224 "id-rsassa-pkcs1-v1_5-with-sha3-224" ++#define LN_RSA_SHA3_224 "RSA-SHA3-224" ++#define NID_RSA_SHA3_224 1116 ++#define OBJ_RSA_SHA3_224 OBJ_sigAlgs,13L ++ ++#define SN_RSA_SHA3_256 "id-rsassa-pkcs1-v1_5-with-sha3-256" ++#define LN_RSA_SHA3_256 "RSA-SHA3-256" ++#define NID_RSA_SHA3_256 1117 ++#define OBJ_RSA_SHA3_256 OBJ_sigAlgs,14L ++ ++#define SN_RSA_SHA3_384 "id-rsassa-pkcs1-v1_5-with-sha3-384" ++#define LN_RSA_SHA3_384 "RSA-SHA3-384" ++#define NID_RSA_SHA3_384 1118 ++#define OBJ_RSA_SHA3_384 OBJ_sigAlgs,15L ++ ++#define SN_RSA_SHA3_512 "id-rsassa-pkcs1-v1_5-with-sha3-512" ++#define LN_RSA_SHA3_512 "RSA-SHA3-512" ++#define NID_RSA_SHA3_512 1119 ++#define OBJ_RSA_SHA3_512 OBJ_sigAlgs,16L ++ ++#define SN_hold_instruction_code "holdInstructionCode" ++#define LN_hold_instruction_code "Hold Instruction Code" ++#define NID_hold_instruction_code 430 ++#define OBJ_hold_instruction_code OBJ_id_ce,23L ++ ++#define OBJ_holdInstruction OBJ_X9_57,2L ++ ++#define SN_hold_instruction_none "holdInstructionNone" ++#define LN_hold_instruction_none "Hold Instruction None" ++#define NID_hold_instruction_none 431 ++#define OBJ_hold_instruction_none OBJ_holdInstruction,1L ++ ++#define SN_hold_instruction_call_issuer "holdInstructionCallIssuer" ++#define LN_hold_instruction_call_issuer "Hold Instruction Call Issuer" ++#define NID_hold_instruction_call_issuer 432 ++#define OBJ_hold_instruction_call_issuer OBJ_holdInstruction,2L ++ ++#define SN_hold_instruction_reject "holdInstructionReject" ++#define LN_hold_instruction_reject "Hold Instruction Reject" ++#define NID_hold_instruction_reject 433 ++#define OBJ_hold_instruction_reject OBJ_holdInstruction,3L ++ ++#define SN_data "data" ++#define NID_data 434 ++#define OBJ_data OBJ_itu_t,9L ++ ++#define SN_pss "pss" ++#define NID_pss 435 ++#define OBJ_pss OBJ_data,2342L ++ ++#define SN_ucl "ucl" ++#define NID_ucl 436 ++#define OBJ_ucl OBJ_pss,19200300L ++ ++#define SN_pilot "pilot" ++#define NID_pilot 437 ++#define OBJ_pilot OBJ_ucl,100L ++ ++#define LN_pilotAttributeType "pilotAttributeType" ++#define NID_pilotAttributeType 438 ++#define OBJ_pilotAttributeType OBJ_pilot,1L ++ ++#define LN_pilotAttributeSyntax "pilotAttributeSyntax" ++#define NID_pilotAttributeSyntax 439 ++#define OBJ_pilotAttributeSyntax OBJ_pilot,3L ++ ++#define LN_pilotObjectClass "pilotObjectClass" ++#define NID_pilotObjectClass 440 ++#define OBJ_pilotObjectClass OBJ_pilot,4L ++ ++#define LN_pilotGroups "pilotGroups" ++#define NID_pilotGroups 441 ++#define OBJ_pilotGroups OBJ_pilot,10L ++ ++#define LN_iA5StringSyntax "iA5StringSyntax" ++#define NID_iA5StringSyntax 442 ++#define OBJ_iA5StringSyntax OBJ_pilotAttributeSyntax,4L ++ ++#define LN_caseIgnoreIA5StringSyntax "caseIgnoreIA5StringSyntax" ++#define NID_caseIgnoreIA5StringSyntax 443 ++#define OBJ_caseIgnoreIA5StringSyntax OBJ_pilotAttributeSyntax,5L ++ ++#define LN_pilotObject "pilotObject" ++#define NID_pilotObject 444 ++#define OBJ_pilotObject OBJ_pilotObjectClass,3L ++ ++#define LN_pilotPerson "pilotPerson" ++#define NID_pilotPerson 445 ++#define OBJ_pilotPerson OBJ_pilotObjectClass,4L ++ ++#define SN_account "account" ++#define NID_account 446 ++#define OBJ_account OBJ_pilotObjectClass,5L ++ ++#define SN_document "document" ++#define NID_document 447 ++#define OBJ_document OBJ_pilotObjectClass,6L ++ ++#define SN_room "room" ++#define NID_room 448 ++#define OBJ_room OBJ_pilotObjectClass,7L ++ ++#define LN_documentSeries "documentSeries" ++#define NID_documentSeries 449 ++#define OBJ_documentSeries OBJ_pilotObjectClass,9L ++ ++#define SN_Domain "domain" ++#define LN_Domain "Domain" ++#define NID_Domain 392 ++#define OBJ_Domain OBJ_pilotObjectClass,13L ++ ++#define LN_rFC822localPart "rFC822localPart" ++#define NID_rFC822localPart 450 ++#define OBJ_rFC822localPart OBJ_pilotObjectClass,14L ++ ++#define LN_dNSDomain "dNSDomain" ++#define NID_dNSDomain 451 ++#define OBJ_dNSDomain OBJ_pilotObjectClass,15L ++ ++#define LN_domainRelatedObject "domainRelatedObject" ++#define NID_domainRelatedObject 452 ++#define OBJ_domainRelatedObject OBJ_pilotObjectClass,17L ++ ++#define LN_friendlyCountry "friendlyCountry" ++#define NID_friendlyCountry 453 ++#define OBJ_friendlyCountry OBJ_pilotObjectClass,18L ++ ++#define LN_simpleSecurityObject "simpleSecurityObject" ++#define NID_simpleSecurityObject 454 ++#define OBJ_simpleSecurityObject OBJ_pilotObjectClass,19L ++ ++#define LN_pilotOrganization "pilotOrganization" ++#define NID_pilotOrganization 455 ++#define OBJ_pilotOrganization OBJ_pilotObjectClass,20L ++ ++#define LN_pilotDSA "pilotDSA" ++#define NID_pilotDSA 456 ++#define OBJ_pilotDSA OBJ_pilotObjectClass,21L ++ ++#define LN_qualityLabelledData "qualityLabelledData" ++#define NID_qualityLabelledData 457 ++#define OBJ_qualityLabelledData OBJ_pilotObjectClass,22L ++ ++#define SN_userId "UID" ++#define LN_userId "userId" ++#define NID_userId 458 ++#define OBJ_userId OBJ_pilotAttributeType,1L ++ ++#define LN_textEncodedORAddress "textEncodedORAddress" ++#define NID_textEncodedORAddress 459 ++#define OBJ_textEncodedORAddress OBJ_pilotAttributeType,2L ++ ++#define SN_rfc822Mailbox "mail" ++#define LN_rfc822Mailbox "rfc822Mailbox" ++#define NID_rfc822Mailbox 460 ++#define OBJ_rfc822Mailbox OBJ_pilotAttributeType,3L ++ ++#define SN_info "info" ++#define NID_info 461 ++#define OBJ_info OBJ_pilotAttributeType,4L ++ ++#define LN_favouriteDrink "favouriteDrink" ++#define NID_favouriteDrink 462 ++#define OBJ_favouriteDrink OBJ_pilotAttributeType,5L ++ ++#define LN_roomNumber "roomNumber" ++#define NID_roomNumber 463 ++#define OBJ_roomNumber OBJ_pilotAttributeType,6L ++ ++#define SN_photo "photo" ++#define NID_photo 464 ++#define OBJ_photo OBJ_pilotAttributeType,7L ++ ++#define LN_userClass "userClass" ++#define NID_userClass 465 ++#define OBJ_userClass OBJ_pilotAttributeType,8L ++ ++#define SN_host "host" ++#define NID_host 466 ++#define OBJ_host OBJ_pilotAttributeType,9L ++ ++#define SN_manager "manager" ++#define NID_manager 467 ++#define OBJ_manager OBJ_pilotAttributeType,10L ++ ++#define LN_documentIdentifier "documentIdentifier" ++#define NID_documentIdentifier 468 ++#define OBJ_documentIdentifier OBJ_pilotAttributeType,11L ++ ++#define LN_documentTitle "documentTitle" ++#define NID_documentTitle 469 ++#define OBJ_documentTitle OBJ_pilotAttributeType,12L ++ ++#define LN_documentVersion "documentVersion" ++#define NID_documentVersion 470 ++#define OBJ_documentVersion OBJ_pilotAttributeType,13L ++ ++#define LN_documentAuthor "documentAuthor" ++#define NID_documentAuthor 471 ++#define OBJ_documentAuthor OBJ_pilotAttributeType,14L ++ ++#define LN_documentLocation "documentLocation" ++#define NID_documentLocation 472 ++#define OBJ_documentLocation OBJ_pilotAttributeType,15L ++ ++#define LN_homeTelephoneNumber "homeTelephoneNumber" ++#define NID_homeTelephoneNumber 473 ++#define OBJ_homeTelephoneNumber OBJ_pilotAttributeType,20L ++ ++#define SN_secretary "secretary" ++#define NID_secretary 474 ++#define OBJ_secretary OBJ_pilotAttributeType,21L ++ ++#define LN_otherMailbox "otherMailbox" ++#define NID_otherMailbox 475 ++#define OBJ_otherMailbox OBJ_pilotAttributeType,22L ++ ++#define LN_lastModifiedTime "lastModifiedTime" ++#define NID_lastModifiedTime 476 ++#define OBJ_lastModifiedTime OBJ_pilotAttributeType,23L ++ ++#define LN_lastModifiedBy "lastModifiedBy" ++#define NID_lastModifiedBy 477 ++#define OBJ_lastModifiedBy OBJ_pilotAttributeType,24L ++ ++#define SN_domainComponent "DC" ++#define LN_domainComponent "domainComponent" ++#define NID_domainComponent 391 ++#define OBJ_domainComponent OBJ_pilotAttributeType,25L ++ ++#define LN_aRecord "aRecord" ++#define NID_aRecord 478 ++#define OBJ_aRecord OBJ_pilotAttributeType,26L ++ ++#define LN_pilotAttributeType27 "pilotAttributeType27" ++#define NID_pilotAttributeType27 479 ++#define OBJ_pilotAttributeType27 OBJ_pilotAttributeType,27L ++ ++#define LN_mXRecord "mXRecord" ++#define NID_mXRecord 480 ++#define OBJ_mXRecord OBJ_pilotAttributeType,28L ++ ++#define LN_nSRecord "nSRecord" ++#define NID_nSRecord 481 ++#define OBJ_nSRecord OBJ_pilotAttributeType,29L ++ ++#define LN_sOARecord "sOARecord" ++#define NID_sOARecord 482 ++#define OBJ_sOARecord OBJ_pilotAttributeType,30L ++ ++#define LN_cNAMERecord "cNAMERecord" ++#define NID_cNAMERecord 483 ++#define OBJ_cNAMERecord OBJ_pilotAttributeType,31L ++ ++#define LN_associatedDomain "associatedDomain" ++#define NID_associatedDomain 484 ++#define OBJ_associatedDomain OBJ_pilotAttributeType,37L ++ ++#define LN_associatedName "associatedName" ++#define NID_associatedName 485 ++#define OBJ_associatedName OBJ_pilotAttributeType,38L ++ ++#define LN_homePostalAddress "homePostalAddress" ++#define NID_homePostalAddress 486 ++#define OBJ_homePostalAddress OBJ_pilotAttributeType,39L ++ ++#define LN_personalTitle "personalTitle" ++#define NID_personalTitle 487 ++#define OBJ_personalTitle OBJ_pilotAttributeType,40L ++ ++#define LN_mobileTelephoneNumber "mobileTelephoneNumber" ++#define NID_mobileTelephoneNumber 488 ++#define OBJ_mobileTelephoneNumber OBJ_pilotAttributeType,41L ++ ++#define LN_pagerTelephoneNumber "pagerTelephoneNumber" ++#define NID_pagerTelephoneNumber 489 ++#define OBJ_pagerTelephoneNumber OBJ_pilotAttributeType,42L ++ ++#define LN_friendlyCountryName "friendlyCountryName" ++#define NID_friendlyCountryName 490 ++#define OBJ_friendlyCountryName OBJ_pilotAttributeType,43L ++ ++#define SN_uniqueIdentifier "uid" ++#define LN_uniqueIdentifier "uniqueIdentifier" ++#define NID_uniqueIdentifier 102 ++#define OBJ_uniqueIdentifier OBJ_pilotAttributeType,44L ++ ++#define LN_organizationalStatus "organizationalStatus" ++#define NID_organizationalStatus 491 ++#define OBJ_organizationalStatus OBJ_pilotAttributeType,45L ++ ++#define LN_janetMailbox "janetMailbox" ++#define NID_janetMailbox 492 ++#define OBJ_janetMailbox OBJ_pilotAttributeType,46L ++ ++#define LN_mailPreferenceOption "mailPreferenceOption" ++#define NID_mailPreferenceOption 493 ++#define OBJ_mailPreferenceOption OBJ_pilotAttributeType,47L ++ ++#define LN_buildingName "buildingName" ++#define NID_buildingName 494 ++#define OBJ_buildingName OBJ_pilotAttributeType,48L ++ ++#define LN_dSAQuality "dSAQuality" ++#define NID_dSAQuality 495 ++#define OBJ_dSAQuality OBJ_pilotAttributeType,49L ++ ++#define LN_singleLevelQuality "singleLevelQuality" ++#define NID_singleLevelQuality 496 ++#define OBJ_singleLevelQuality OBJ_pilotAttributeType,50L ++ ++#define LN_subtreeMinimumQuality "subtreeMinimumQuality" ++#define NID_subtreeMinimumQuality 497 ++#define OBJ_subtreeMinimumQuality OBJ_pilotAttributeType,51L ++ ++#define LN_subtreeMaximumQuality "subtreeMaximumQuality" ++#define NID_subtreeMaximumQuality 498 ++#define OBJ_subtreeMaximumQuality OBJ_pilotAttributeType,52L ++ ++#define LN_personalSignature "personalSignature" ++#define NID_personalSignature 499 ++#define OBJ_personalSignature OBJ_pilotAttributeType,53L ++ ++#define LN_dITRedirect "dITRedirect" ++#define NID_dITRedirect 500 ++#define OBJ_dITRedirect OBJ_pilotAttributeType,54L ++ ++#define SN_audio "audio" ++#define NID_audio 501 ++#define OBJ_audio OBJ_pilotAttributeType,55L ++ ++#define LN_documentPublisher "documentPublisher" ++#define NID_documentPublisher 502 ++#define OBJ_documentPublisher OBJ_pilotAttributeType,56L ++ ++#define SN_id_set "id-set" ++#define LN_id_set "Secure Electronic Transactions" ++#define NID_id_set 512 ++#define OBJ_id_set OBJ_international_organizations,42L ++ ++#define SN_set_ctype "set-ctype" ++#define LN_set_ctype "content types" ++#define NID_set_ctype 513 ++#define OBJ_set_ctype OBJ_id_set,0L ++ ++#define SN_set_msgExt "set-msgExt" ++#define LN_set_msgExt "message extensions" ++#define NID_set_msgExt 514 ++#define OBJ_set_msgExt OBJ_id_set,1L ++ ++#define SN_set_attr "set-attr" ++#define NID_set_attr 515 ++#define OBJ_set_attr OBJ_id_set,3L ++ ++#define SN_set_policy "set-policy" ++#define NID_set_policy 516 ++#define OBJ_set_policy OBJ_id_set,5L ++ ++#define SN_set_certExt "set-certExt" ++#define LN_set_certExt "certificate extensions" ++#define NID_set_certExt 517 ++#define OBJ_set_certExt OBJ_id_set,7L ++ ++#define SN_set_brand "set-brand" ++#define NID_set_brand 518 ++#define OBJ_set_brand OBJ_id_set,8L ++ ++#define SN_setct_PANData "setct-PANData" ++#define NID_setct_PANData 519 ++#define OBJ_setct_PANData OBJ_set_ctype,0L ++ ++#define SN_setct_PANToken "setct-PANToken" ++#define NID_setct_PANToken 520 ++#define OBJ_setct_PANToken OBJ_set_ctype,1L ++ ++#define SN_setct_PANOnly "setct-PANOnly" ++#define NID_setct_PANOnly 521 ++#define OBJ_setct_PANOnly OBJ_set_ctype,2L ++ ++#define SN_setct_OIData "setct-OIData" ++#define NID_setct_OIData 522 ++#define OBJ_setct_OIData OBJ_set_ctype,3L ++ ++#define SN_setct_PI "setct-PI" ++#define NID_setct_PI 523 ++#define OBJ_setct_PI OBJ_set_ctype,4L ++ ++#define SN_setct_PIData "setct-PIData" ++#define NID_setct_PIData 524 ++#define OBJ_setct_PIData OBJ_set_ctype,5L ++ ++#define SN_setct_PIDataUnsigned "setct-PIDataUnsigned" ++#define NID_setct_PIDataUnsigned 525 ++#define OBJ_setct_PIDataUnsigned OBJ_set_ctype,6L ++ ++#define SN_setct_HODInput "setct-HODInput" ++#define NID_setct_HODInput 526 ++#define OBJ_setct_HODInput OBJ_set_ctype,7L ++ ++#define SN_setct_AuthResBaggage "setct-AuthResBaggage" ++#define NID_setct_AuthResBaggage 527 ++#define OBJ_setct_AuthResBaggage OBJ_set_ctype,8L ++ ++#define SN_setct_AuthRevReqBaggage "setct-AuthRevReqBaggage" ++#define NID_setct_AuthRevReqBaggage 528 ++#define OBJ_setct_AuthRevReqBaggage OBJ_set_ctype,9L ++ ++#define SN_setct_AuthRevResBaggage "setct-AuthRevResBaggage" ++#define NID_setct_AuthRevResBaggage 529 ++#define OBJ_setct_AuthRevResBaggage OBJ_set_ctype,10L ++ ++#define SN_setct_CapTokenSeq "setct-CapTokenSeq" ++#define NID_setct_CapTokenSeq 530 ++#define OBJ_setct_CapTokenSeq OBJ_set_ctype,11L ++ ++#define SN_setct_PInitResData "setct-PInitResData" ++#define NID_setct_PInitResData 531 ++#define OBJ_setct_PInitResData OBJ_set_ctype,12L ++ ++#define SN_setct_PI_TBS "setct-PI-TBS" ++#define NID_setct_PI_TBS 532 ++#define OBJ_setct_PI_TBS OBJ_set_ctype,13L ++ ++#define SN_setct_PResData "setct-PResData" ++#define NID_setct_PResData 533 ++#define OBJ_setct_PResData OBJ_set_ctype,14L ++ ++#define SN_setct_AuthReqTBS "setct-AuthReqTBS" ++#define NID_setct_AuthReqTBS 534 ++#define OBJ_setct_AuthReqTBS OBJ_set_ctype,16L ++ ++#define SN_setct_AuthResTBS "setct-AuthResTBS" ++#define NID_setct_AuthResTBS 535 ++#define OBJ_setct_AuthResTBS OBJ_set_ctype,17L ++ ++#define SN_setct_AuthResTBSX "setct-AuthResTBSX" ++#define NID_setct_AuthResTBSX 536 ++#define OBJ_setct_AuthResTBSX OBJ_set_ctype,18L ++ ++#define SN_setct_AuthTokenTBS "setct-AuthTokenTBS" ++#define NID_setct_AuthTokenTBS 537 ++#define OBJ_setct_AuthTokenTBS OBJ_set_ctype,19L ++ ++#define SN_setct_CapTokenData "setct-CapTokenData" ++#define NID_setct_CapTokenData 538 ++#define OBJ_setct_CapTokenData OBJ_set_ctype,20L ++ ++#define SN_setct_CapTokenTBS "setct-CapTokenTBS" ++#define NID_setct_CapTokenTBS 539 ++#define OBJ_setct_CapTokenTBS OBJ_set_ctype,21L ++ ++#define SN_setct_AcqCardCodeMsg "setct-AcqCardCodeMsg" ++#define NID_setct_AcqCardCodeMsg 540 ++#define OBJ_setct_AcqCardCodeMsg OBJ_set_ctype,22L ++ ++#define SN_setct_AuthRevReqTBS "setct-AuthRevReqTBS" ++#define NID_setct_AuthRevReqTBS 541 ++#define OBJ_setct_AuthRevReqTBS OBJ_set_ctype,23L ++ ++#define SN_setct_AuthRevResData "setct-AuthRevResData" ++#define NID_setct_AuthRevResData 542 ++#define OBJ_setct_AuthRevResData OBJ_set_ctype,24L ++ ++#define SN_setct_AuthRevResTBS "setct-AuthRevResTBS" ++#define NID_setct_AuthRevResTBS 543 ++#define OBJ_setct_AuthRevResTBS OBJ_set_ctype,25L ++ ++#define SN_setct_CapReqTBS "setct-CapReqTBS" ++#define NID_setct_CapReqTBS 544 ++#define OBJ_setct_CapReqTBS OBJ_set_ctype,26L ++ ++#define SN_setct_CapReqTBSX "setct-CapReqTBSX" ++#define NID_setct_CapReqTBSX 545 ++#define OBJ_setct_CapReqTBSX OBJ_set_ctype,27L ++ ++#define SN_setct_CapResData "setct-CapResData" ++#define NID_setct_CapResData 546 ++#define OBJ_setct_CapResData OBJ_set_ctype,28L ++ ++#define SN_setct_CapRevReqTBS "setct-CapRevReqTBS" ++#define NID_setct_CapRevReqTBS 547 ++#define OBJ_setct_CapRevReqTBS OBJ_set_ctype,29L ++ ++#define SN_setct_CapRevReqTBSX "setct-CapRevReqTBSX" ++#define NID_setct_CapRevReqTBSX 548 ++#define OBJ_setct_CapRevReqTBSX OBJ_set_ctype,30L ++ ++#define SN_setct_CapRevResData "setct-CapRevResData" ++#define NID_setct_CapRevResData 549 ++#define OBJ_setct_CapRevResData OBJ_set_ctype,31L ++ ++#define SN_setct_CredReqTBS "setct-CredReqTBS" ++#define NID_setct_CredReqTBS 550 ++#define OBJ_setct_CredReqTBS OBJ_set_ctype,32L ++ ++#define SN_setct_CredReqTBSX "setct-CredReqTBSX" ++#define NID_setct_CredReqTBSX 551 ++#define OBJ_setct_CredReqTBSX OBJ_set_ctype,33L ++ ++#define SN_setct_CredResData "setct-CredResData" ++#define NID_setct_CredResData 552 ++#define OBJ_setct_CredResData OBJ_set_ctype,34L ++ ++#define SN_setct_CredRevReqTBS "setct-CredRevReqTBS" ++#define NID_setct_CredRevReqTBS 553 ++#define OBJ_setct_CredRevReqTBS OBJ_set_ctype,35L ++ ++#define SN_setct_CredRevReqTBSX "setct-CredRevReqTBSX" ++#define NID_setct_CredRevReqTBSX 554 ++#define OBJ_setct_CredRevReqTBSX OBJ_set_ctype,36L ++ ++#define SN_setct_CredRevResData "setct-CredRevResData" ++#define NID_setct_CredRevResData 555 ++#define OBJ_setct_CredRevResData OBJ_set_ctype,37L ++ ++#define SN_setct_PCertReqData "setct-PCertReqData" ++#define NID_setct_PCertReqData 556 ++#define OBJ_setct_PCertReqData OBJ_set_ctype,38L ++ ++#define SN_setct_PCertResTBS "setct-PCertResTBS" ++#define NID_setct_PCertResTBS 557 ++#define OBJ_setct_PCertResTBS OBJ_set_ctype,39L ++ ++#define SN_setct_BatchAdminReqData "setct-BatchAdminReqData" ++#define NID_setct_BatchAdminReqData 558 ++#define OBJ_setct_BatchAdminReqData OBJ_set_ctype,40L ++ ++#define SN_setct_BatchAdminResData "setct-BatchAdminResData" ++#define NID_setct_BatchAdminResData 559 ++#define OBJ_setct_BatchAdminResData OBJ_set_ctype,41L ++ ++#define SN_setct_CardCInitResTBS "setct-CardCInitResTBS" ++#define NID_setct_CardCInitResTBS 560 ++#define OBJ_setct_CardCInitResTBS OBJ_set_ctype,42L ++ ++#define SN_setct_MeAqCInitResTBS "setct-MeAqCInitResTBS" ++#define NID_setct_MeAqCInitResTBS 561 ++#define OBJ_setct_MeAqCInitResTBS OBJ_set_ctype,43L ++ ++#define SN_setct_RegFormResTBS "setct-RegFormResTBS" ++#define NID_setct_RegFormResTBS 562 ++#define OBJ_setct_RegFormResTBS OBJ_set_ctype,44L ++ ++#define SN_setct_CertReqData "setct-CertReqData" ++#define NID_setct_CertReqData 563 ++#define OBJ_setct_CertReqData OBJ_set_ctype,45L ++ ++#define SN_setct_CertReqTBS "setct-CertReqTBS" ++#define NID_setct_CertReqTBS 564 ++#define OBJ_setct_CertReqTBS OBJ_set_ctype,46L ++ ++#define SN_setct_CertResData "setct-CertResData" ++#define NID_setct_CertResData 565 ++#define OBJ_setct_CertResData OBJ_set_ctype,47L ++ ++#define SN_setct_CertInqReqTBS "setct-CertInqReqTBS" ++#define NID_setct_CertInqReqTBS 566 ++#define OBJ_setct_CertInqReqTBS OBJ_set_ctype,48L ++ ++#define SN_setct_ErrorTBS "setct-ErrorTBS" ++#define NID_setct_ErrorTBS 567 ++#define OBJ_setct_ErrorTBS OBJ_set_ctype,49L ++ ++#define SN_setct_PIDualSignedTBE "setct-PIDualSignedTBE" ++#define NID_setct_PIDualSignedTBE 568 ++#define OBJ_setct_PIDualSignedTBE OBJ_set_ctype,50L ++ ++#define SN_setct_PIUnsignedTBE "setct-PIUnsignedTBE" ++#define NID_setct_PIUnsignedTBE 569 ++#define OBJ_setct_PIUnsignedTBE OBJ_set_ctype,51L ++ ++#define SN_setct_AuthReqTBE "setct-AuthReqTBE" ++#define NID_setct_AuthReqTBE 570 ++#define OBJ_setct_AuthReqTBE OBJ_set_ctype,52L ++ ++#define SN_setct_AuthResTBE "setct-AuthResTBE" ++#define NID_setct_AuthResTBE 571 ++#define OBJ_setct_AuthResTBE OBJ_set_ctype,53L ++ ++#define SN_setct_AuthResTBEX "setct-AuthResTBEX" ++#define NID_setct_AuthResTBEX 572 ++#define OBJ_setct_AuthResTBEX OBJ_set_ctype,54L ++ ++#define SN_setct_AuthTokenTBE "setct-AuthTokenTBE" ++#define NID_setct_AuthTokenTBE 573 ++#define OBJ_setct_AuthTokenTBE OBJ_set_ctype,55L ++ ++#define SN_setct_CapTokenTBE "setct-CapTokenTBE" ++#define NID_setct_CapTokenTBE 574 ++#define OBJ_setct_CapTokenTBE OBJ_set_ctype,56L ++ ++#define SN_setct_CapTokenTBEX "setct-CapTokenTBEX" ++#define NID_setct_CapTokenTBEX 575 ++#define OBJ_setct_CapTokenTBEX OBJ_set_ctype,57L ++ ++#define SN_setct_AcqCardCodeMsgTBE "setct-AcqCardCodeMsgTBE" ++#define NID_setct_AcqCardCodeMsgTBE 576 ++#define OBJ_setct_AcqCardCodeMsgTBE OBJ_set_ctype,58L ++ ++#define SN_setct_AuthRevReqTBE "setct-AuthRevReqTBE" ++#define NID_setct_AuthRevReqTBE 577 ++#define OBJ_setct_AuthRevReqTBE OBJ_set_ctype,59L ++ ++#define SN_setct_AuthRevResTBE "setct-AuthRevResTBE" ++#define NID_setct_AuthRevResTBE 578 ++#define OBJ_setct_AuthRevResTBE OBJ_set_ctype,60L ++ ++#define SN_setct_AuthRevResTBEB "setct-AuthRevResTBEB" ++#define NID_setct_AuthRevResTBEB 579 ++#define OBJ_setct_AuthRevResTBEB OBJ_set_ctype,61L ++ ++#define SN_setct_CapReqTBE "setct-CapReqTBE" ++#define NID_setct_CapReqTBE 580 ++#define OBJ_setct_CapReqTBE OBJ_set_ctype,62L ++ ++#define SN_setct_CapReqTBEX "setct-CapReqTBEX" ++#define NID_setct_CapReqTBEX 581 ++#define OBJ_setct_CapReqTBEX OBJ_set_ctype,63L ++ ++#define SN_setct_CapResTBE "setct-CapResTBE" ++#define NID_setct_CapResTBE 582 ++#define OBJ_setct_CapResTBE OBJ_set_ctype,64L ++ ++#define SN_setct_CapRevReqTBE "setct-CapRevReqTBE" ++#define NID_setct_CapRevReqTBE 583 ++#define OBJ_setct_CapRevReqTBE OBJ_set_ctype,65L ++ ++#define SN_setct_CapRevReqTBEX "setct-CapRevReqTBEX" ++#define NID_setct_CapRevReqTBEX 584 ++#define OBJ_setct_CapRevReqTBEX OBJ_set_ctype,66L ++ ++#define SN_setct_CapRevResTBE "setct-CapRevResTBE" ++#define NID_setct_CapRevResTBE 585 ++#define OBJ_setct_CapRevResTBE OBJ_set_ctype,67L ++ ++#define SN_setct_CredReqTBE "setct-CredReqTBE" ++#define NID_setct_CredReqTBE 586 ++#define OBJ_setct_CredReqTBE OBJ_set_ctype,68L ++ ++#define SN_setct_CredReqTBEX "setct-CredReqTBEX" ++#define NID_setct_CredReqTBEX 587 ++#define OBJ_setct_CredReqTBEX OBJ_set_ctype,69L ++ ++#define SN_setct_CredResTBE "setct-CredResTBE" ++#define NID_setct_CredResTBE 588 ++#define OBJ_setct_CredResTBE OBJ_set_ctype,70L ++ ++#define SN_setct_CredRevReqTBE "setct-CredRevReqTBE" ++#define NID_setct_CredRevReqTBE 589 ++#define OBJ_setct_CredRevReqTBE OBJ_set_ctype,71L ++ ++#define SN_setct_CredRevReqTBEX "setct-CredRevReqTBEX" ++#define NID_setct_CredRevReqTBEX 590 ++#define OBJ_setct_CredRevReqTBEX OBJ_set_ctype,72L ++ ++#define SN_setct_CredRevResTBE "setct-CredRevResTBE" ++#define NID_setct_CredRevResTBE 591 ++#define OBJ_setct_CredRevResTBE OBJ_set_ctype,73L ++ ++#define SN_setct_BatchAdminReqTBE "setct-BatchAdminReqTBE" ++#define NID_setct_BatchAdminReqTBE 592 ++#define OBJ_setct_BatchAdminReqTBE OBJ_set_ctype,74L ++ ++#define SN_setct_BatchAdminResTBE "setct-BatchAdminResTBE" ++#define NID_setct_BatchAdminResTBE 593 ++#define OBJ_setct_BatchAdminResTBE OBJ_set_ctype,75L ++ ++#define SN_setct_RegFormReqTBE "setct-RegFormReqTBE" ++#define NID_setct_RegFormReqTBE 594 ++#define OBJ_setct_RegFormReqTBE OBJ_set_ctype,76L ++ ++#define SN_setct_CertReqTBE "setct-CertReqTBE" ++#define NID_setct_CertReqTBE 595 ++#define OBJ_setct_CertReqTBE OBJ_set_ctype,77L ++ ++#define SN_setct_CertReqTBEX "setct-CertReqTBEX" ++#define NID_setct_CertReqTBEX 596 ++#define OBJ_setct_CertReqTBEX OBJ_set_ctype,78L ++ ++#define SN_setct_CertResTBE "setct-CertResTBE" ++#define NID_setct_CertResTBE 597 ++#define OBJ_setct_CertResTBE OBJ_set_ctype,79L ++ ++#define SN_setct_CRLNotificationTBS "setct-CRLNotificationTBS" ++#define NID_setct_CRLNotificationTBS 598 ++#define OBJ_setct_CRLNotificationTBS OBJ_set_ctype,80L ++ ++#define SN_setct_CRLNotificationResTBS "setct-CRLNotificationResTBS" ++#define NID_setct_CRLNotificationResTBS 599 ++#define OBJ_setct_CRLNotificationResTBS OBJ_set_ctype,81L ++ ++#define SN_setct_BCIDistributionTBS "setct-BCIDistributionTBS" ++#define NID_setct_BCIDistributionTBS 600 ++#define OBJ_setct_BCIDistributionTBS OBJ_set_ctype,82L ++ ++#define SN_setext_genCrypt "setext-genCrypt" ++#define LN_setext_genCrypt "generic cryptogram" ++#define NID_setext_genCrypt 601 ++#define OBJ_setext_genCrypt OBJ_set_msgExt,1L ++ ++#define SN_setext_miAuth "setext-miAuth" ++#define LN_setext_miAuth "merchant initiated auth" ++#define NID_setext_miAuth 602 ++#define OBJ_setext_miAuth OBJ_set_msgExt,3L ++ ++#define SN_setext_pinSecure "setext-pinSecure" ++#define NID_setext_pinSecure 603 ++#define OBJ_setext_pinSecure OBJ_set_msgExt,4L ++ ++#define SN_setext_pinAny "setext-pinAny" ++#define NID_setext_pinAny 604 ++#define OBJ_setext_pinAny OBJ_set_msgExt,5L ++ ++#define SN_setext_track2 "setext-track2" ++#define NID_setext_track2 605 ++#define OBJ_setext_track2 OBJ_set_msgExt,7L ++ ++#define SN_setext_cv "setext-cv" ++#define LN_setext_cv "additional verification" ++#define NID_setext_cv 606 ++#define OBJ_setext_cv OBJ_set_msgExt,8L ++ ++#define SN_set_policy_root "set-policy-root" ++#define NID_set_policy_root 607 ++#define OBJ_set_policy_root OBJ_set_policy,0L ++ ++#define SN_setCext_hashedRoot "setCext-hashedRoot" ++#define NID_setCext_hashedRoot 608 ++#define OBJ_setCext_hashedRoot OBJ_set_certExt,0L ++ ++#define SN_setCext_certType "setCext-certType" ++#define NID_setCext_certType 609 ++#define OBJ_setCext_certType OBJ_set_certExt,1L ++ ++#define SN_setCext_merchData "setCext-merchData" ++#define NID_setCext_merchData 610 ++#define OBJ_setCext_merchData OBJ_set_certExt,2L ++ ++#define SN_setCext_cCertRequired "setCext-cCertRequired" ++#define NID_setCext_cCertRequired 611 ++#define OBJ_setCext_cCertRequired OBJ_set_certExt,3L ++ ++#define SN_setCext_tunneling "setCext-tunneling" ++#define NID_setCext_tunneling 612 ++#define OBJ_setCext_tunneling OBJ_set_certExt,4L ++ ++#define SN_setCext_setExt "setCext-setExt" ++#define NID_setCext_setExt 613 ++#define OBJ_setCext_setExt OBJ_set_certExt,5L ++ ++#define SN_setCext_setQualf "setCext-setQualf" ++#define NID_setCext_setQualf 614 ++#define OBJ_setCext_setQualf OBJ_set_certExt,6L ++ ++#define SN_setCext_PGWYcapabilities "setCext-PGWYcapabilities" ++#define NID_setCext_PGWYcapabilities 615 ++#define OBJ_setCext_PGWYcapabilities OBJ_set_certExt,7L ++ ++#define SN_setCext_TokenIdentifier "setCext-TokenIdentifier" ++#define NID_setCext_TokenIdentifier 616 ++#define OBJ_setCext_TokenIdentifier OBJ_set_certExt,8L ++ ++#define SN_setCext_Track2Data "setCext-Track2Data" ++#define NID_setCext_Track2Data 617 ++#define OBJ_setCext_Track2Data OBJ_set_certExt,9L ++ ++#define SN_setCext_TokenType "setCext-TokenType" ++#define NID_setCext_TokenType 618 ++#define OBJ_setCext_TokenType OBJ_set_certExt,10L ++ ++#define SN_setCext_IssuerCapabilities "setCext-IssuerCapabilities" ++#define NID_setCext_IssuerCapabilities 619 ++#define OBJ_setCext_IssuerCapabilities OBJ_set_certExt,11L ++ ++#define SN_setAttr_Cert "setAttr-Cert" ++#define NID_setAttr_Cert 620 ++#define OBJ_setAttr_Cert OBJ_set_attr,0L ++ ++#define SN_setAttr_PGWYcap "setAttr-PGWYcap" ++#define LN_setAttr_PGWYcap "payment gateway capabilities" ++#define NID_setAttr_PGWYcap 621 ++#define OBJ_setAttr_PGWYcap OBJ_set_attr,1L ++ ++#define SN_setAttr_TokenType "setAttr-TokenType" ++#define NID_setAttr_TokenType 622 ++#define OBJ_setAttr_TokenType OBJ_set_attr,2L ++ ++#define SN_setAttr_IssCap "setAttr-IssCap" ++#define LN_setAttr_IssCap "issuer capabilities" ++#define NID_setAttr_IssCap 623 ++#define OBJ_setAttr_IssCap OBJ_set_attr,3L ++ ++#define SN_set_rootKeyThumb "set-rootKeyThumb" ++#define NID_set_rootKeyThumb 624 ++#define OBJ_set_rootKeyThumb OBJ_setAttr_Cert,0L ++ ++#define SN_set_addPolicy "set-addPolicy" ++#define NID_set_addPolicy 625 ++#define OBJ_set_addPolicy OBJ_setAttr_Cert,1L ++ ++#define SN_setAttr_Token_EMV "setAttr-Token-EMV" ++#define NID_setAttr_Token_EMV 626 ++#define OBJ_setAttr_Token_EMV OBJ_setAttr_TokenType,1L ++ ++#define SN_setAttr_Token_B0Prime "setAttr-Token-B0Prime" ++#define NID_setAttr_Token_B0Prime 627 ++#define OBJ_setAttr_Token_B0Prime OBJ_setAttr_TokenType,2L ++ ++#define SN_setAttr_IssCap_CVM "setAttr-IssCap-CVM" ++#define NID_setAttr_IssCap_CVM 628 ++#define OBJ_setAttr_IssCap_CVM OBJ_setAttr_IssCap,3L ++ ++#define SN_setAttr_IssCap_T2 "setAttr-IssCap-T2" ++#define NID_setAttr_IssCap_T2 629 ++#define OBJ_setAttr_IssCap_T2 OBJ_setAttr_IssCap,4L ++ ++#define SN_setAttr_IssCap_Sig "setAttr-IssCap-Sig" ++#define NID_setAttr_IssCap_Sig 630 ++#define OBJ_setAttr_IssCap_Sig OBJ_setAttr_IssCap,5L ++ ++#define SN_setAttr_GenCryptgrm "setAttr-GenCryptgrm" ++#define LN_setAttr_GenCryptgrm "generate cryptogram" ++#define NID_setAttr_GenCryptgrm 631 ++#define OBJ_setAttr_GenCryptgrm OBJ_setAttr_IssCap_CVM,1L ++ ++#define SN_setAttr_T2Enc "setAttr-T2Enc" ++#define LN_setAttr_T2Enc "encrypted track 2" ++#define NID_setAttr_T2Enc 632 ++#define OBJ_setAttr_T2Enc OBJ_setAttr_IssCap_T2,1L ++ ++#define SN_setAttr_T2cleartxt "setAttr-T2cleartxt" ++#define LN_setAttr_T2cleartxt "cleartext track 2" ++#define NID_setAttr_T2cleartxt 633 ++#define OBJ_setAttr_T2cleartxt OBJ_setAttr_IssCap_T2,2L ++ ++#define SN_setAttr_TokICCsig "setAttr-TokICCsig" ++#define LN_setAttr_TokICCsig "ICC or token signature" ++#define NID_setAttr_TokICCsig 634 ++#define OBJ_setAttr_TokICCsig OBJ_setAttr_IssCap_Sig,1L ++ ++#define SN_setAttr_SecDevSig "setAttr-SecDevSig" ++#define LN_setAttr_SecDevSig "secure device signature" ++#define NID_setAttr_SecDevSig 635 ++#define OBJ_setAttr_SecDevSig OBJ_setAttr_IssCap_Sig,2L ++ ++#define SN_set_brand_IATA_ATA "set-brand-IATA-ATA" ++#define NID_set_brand_IATA_ATA 636 ++#define OBJ_set_brand_IATA_ATA OBJ_set_brand,1L ++ ++#define SN_set_brand_Diners "set-brand-Diners" ++#define NID_set_brand_Diners 637 ++#define OBJ_set_brand_Diners OBJ_set_brand,30L ++ ++#define SN_set_brand_AmericanExpress "set-brand-AmericanExpress" ++#define NID_set_brand_AmericanExpress 638 ++#define OBJ_set_brand_AmericanExpress OBJ_set_brand,34L ++ ++#define SN_set_brand_JCB "set-brand-JCB" ++#define NID_set_brand_JCB 639 ++#define OBJ_set_brand_JCB OBJ_set_brand,35L ++ ++#define SN_set_brand_Visa "set-brand-Visa" ++#define NID_set_brand_Visa 640 ++#define OBJ_set_brand_Visa OBJ_set_brand,4L ++ ++#define SN_set_brand_MasterCard "set-brand-MasterCard" ++#define NID_set_brand_MasterCard 641 ++#define OBJ_set_brand_MasterCard OBJ_set_brand,5L ++ ++#define SN_set_brand_Novus "set-brand-Novus" ++#define NID_set_brand_Novus 642 ++#define OBJ_set_brand_Novus OBJ_set_brand,6011L ++ ++#define SN_des_cdmf "DES-CDMF" ++#define LN_des_cdmf "des-cdmf" ++#define NID_des_cdmf 643 ++#define OBJ_des_cdmf OBJ_rsadsi,3L,10L ++ ++#define SN_rsaOAEPEncryptionSET "rsaOAEPEncryptionSET" ++#define NID_rsaOAEPEncryptionSET 644 ++#define OBJ_rsaOAEPEncryptionSET OBJ_rsadsi,1L,1L,6L ++ ++#define SN_ipsec3 "Oakley-EC2N-3" ++#define LN_ipsec3 "ipsec3" ++#define NID_ipsec3 749 ++ ++#define SN_ipsec4 "Oakley-EC2N-4" ++#define LN_ipsec4 "ipsec4" ++#define NID_ipsec4 750 ++ ++#define SN_whirlpool "whirlpool" ++#define NID_whirlpool 804 ++#define OBJ_whirlpool OBJ_iso,0L,10118L,3L,0L,55L ++ ++#define SN_cryptopro "cryptopro" ++#define NID_cryptopro 805 ++#define OBJ_cryptopro OBJ_member_body,643L,2L,2L ++ ++#define SN_cryptocom "cryptocom" ++#define NID_cryptocom 806 ++#define OBJ_cryptocom OBJ_member_body,643L,2L,9L ++ ++#define SN_id_tc26 "id-tc26" ++#define NID_id_tc26 974 ++#define OBJ_id_tc26 OBJ_member_body,643L,7L,1L ++ ++#define SN_id_GostR3411_94_with_GostR3410_2001 "id-GostR3411-94-with-GostR3410-2001" ++#define LN_id_GostR3411_94_with_GostR3410_2001 "GOST R 34.11-94 with GOST R 34.10-2001" ++#define NID_id_GostR3411_94_with_GostR3410_2001 807 ++#define OBJ_id_GostR3411_94_with_GostR3410_2001 OBJ_cryptopro,3L ++ ++#define SN_id_GostR3411_94_with_GostR3410_94 "id-GostR3411-94-with-GostR3410-94" ++#define LN_id_GostR3411_94_with_GostR3410_94 "GOST R 34.11-94 with GOST R 34.10-94" ++#define NID_id_GostR3411_94_with_GostR3410_94 808 ++#define OBJ_id_GostR3411_94_with_GostR3410_94 OBJ_cryptopro,4L ++ ++#define SN_id_GostR3411_94 "md_gost94" ++#define LN_id_GostR3411_94 "GOST R 34.11-94" ++#define NID_id_GostR3411_94 809 ++#define OBJ_id_GostR3411_94 OBJ_cryptopro,9L ++ ++#define SN_id_HMACGostR3411_94 "id-HMACGostR3411-94" ++#define LN_id_HMACGostR3411_94 "HMAC GOST 34.11-94" ++#define NID_id_HMACGostR3411_94 810 ++#define OBJ_id_HMACGostR3411_94 OBJ_cryptopro,10L ++ ++#define SN_id_GostR3410_2001 "gost2001" ++#define LN_id_GostR3410_2001 "GOST R 34.10-2001" ++#define NID_id_GostR3410_2001 811 ++#define OBJ_id_GostR3410_2001 OBJ_cryptopro,19L ++ ++#define SN_id_GostR3410_94 "gost94" ++#define LN_id_GostR3410_94 "GOST R 34.10-94" ++#define NID_id_GostR3410_94 812 ++#define OBJ_id_GostR3410_94 OBJ_cryptopro,20L ++ ++#define SN_id_Gost28147_89 "gost89" ++#define LN_id_Gost28147_89 "GOST 28147-89" ++#define NID_id_Gost28147_89 813 ++#define OBJ_id_Gost28147_89 OBJ_cryptopro,21L ++ ++#define SN_gost89_cnt "gost89-cnt" ++#define NID_gost89_cnt 814 ++ ++#define SN_gost89_cnt_12 "gost89-cnt-12" ++#define NID_gost89_cnt_12 975 ++ ++#define SN_gost89_cbc "gost89-cbc" ++#define NID_gost89_cbc 1009 ++ ++#define SN_gost89_ecb "gost89-ecb" ++#define NID_gost89_ecb 1010 ++ ++#define SN_gost89_ctr "gost89-ctr" ++#define NID_gost89_ctr 1011 ++ ++#define SN_id_Gost28147_89_MAC "gost-mac" ++#define LN_id_Gost28147_89_MAC "GOST 28147-89 MAC" ++#define NID_id_Gost28147_89_MAC 815 ++#define OBJ_id_Gost28147_89_MAC OBJ_cryptopro,22L ++ ++#define SN_gost_mac_12 "gost-mac-12" ++#define NID_gost_mac_12 976 ++ ++#define SN_id_GostR3411_94_prf "prf-gostr3411-94" ++#define LN_id_GostR3411_94_prf "GOST R 34.11-94 PRF" ++#define NID_id_GostR3411_94_prf 816 ++#define OBJ_id_GostR3411_94_prf OBJ_cryptopro,23L ++ ++#define SN_id_GostR3410_2001DH "id-GostR3410-2001DH" ++#define LN_id_GostR3410_2001DH "GOST R 34.10-2001 DH" ++#define NID_id_GostR3410_2001DH 817 ++#define OBJ_id_GostR3410_2001DH OBJ_cryptopro,98L ++ ++#define SN_id_GostR3410_94DH "id-GostR3410-94DH" ++#define LN_id_GostR3410_94DH "GOST R 34.10-94 DH" ++#define NID_id_GostR3410_94DH 818 ++#define OBJ_id_GostR3410_94DH OBJ_cryptopro,99L ++ ++#define SN_id_Gost28147_89_CryptoPro_KeyMeshing "id-Gost28147-89-CryptoPro-KeyMeshing" ++#define NID_id_Gost28147_89_CryptoPro_KeyMeshing 819 ++#define OBJ_id_Gost28147_89_CryptoPro_KeyMeshing OBJ_cryptopro,14L,1L ++ ++#define SN_id_Gost28147_89_None_KeyMeshing "id-Gost28147-89-None-KeyMeshing" ++#define NID_id_Gost28147_89_None_KeyMeshing 820 ++#define OBJ_id_Gost28147_89_None_KeyMeshing OBJ_cryptopro,14L,0L ++ ++#define SN_id_GostR3411_94_TestParamSet "id-GostR3411-94-TestParamSet" ++#define NID_id_GostR3411_94_TestParamSet 821 ++#define OBJ_id_GostR3411_94_TestParamSet OBJ_cryptopro,30L,0L ++ ++#define SN_id_GostR3411_94_CryptoProParamSet "id-GostR3411-94-CryptoProParamSet" ++#define NID_id_GostR3411_94_CryptoProParamSet 822 ++#define OBJ_id_GostR3411_94_CryptoProParamSet OBJ_cryptopro,30L,1L ++ ++#define SN_id_Gost28147_89_TestParamSet "id-Gost28147-89-TestParamSet" ++#define NID_id_Gost28147_89_TestParamSet 823 ++#define OBJ_id_Gost28147_89_TestParamSet OBJ_cryptopro,31L,0L ++ ++#define SN_id_Gost28147_89_CryptoPro_A_ParamSet "id-Gost28147-89-CryptoPro-A-ParamSet" ++#define NID_id_Gost28147_89_CryptoPro_A_ParamSet 824 ++#define OBJ_id_Gost28147_89_CryptoPro_A_ParamSet OBJ_cryptopro,31L,1L ++ ++#define SN_id_Gost28147_89_CryptoPro_B_ParamSet "id-Gost28147-89-CryptoPro-B-ParamSet" ++#define NID_id_Gost28147_89_CryptoPro_B_ParamSet 825 ++#define OBJ_id_Gost28147_89_CryptoPro_B_ParamSet OBJ_cryptopro,31L,2L ++ ++#define SN_id_Gost28147_89_CryptoPro_C_ParamSet "id-Gost28147-89-CryptoPro-C-ParamSet" ++#define NID_id_Gost28147_89_CryptoPro_C_ParamSet 826 ++#define OBJ_id_Gost28147_89_CryptoPro_C_ParamSet OBJ_cryptopro,31L,3L ++ ++#define SN_id_Gost28147_89_CryptoPro_D_ParamSet "id-Gost28147-89-CryptoPro-D-ParamSet" ++#define NID_id_Gost28147_89_CryptoPro_D_ParamSet 827 ++#define OBJ_id_Gost28147_89_CryptoPro_D_ParamSet OBJ_cryptopro,31L,4L ++ ++#define SN_id_Gost28147_89_CryptoPro_Oscar_1_1_ParamSet "id-Gost28147-89-CryptoPro-Oscar-1-1-ParamSet" ++#define NID_id_Gost28147_89_CryptoPro_Oscar_1_1_ParamSet 828 ++#define OBJ_id_Gost28147_89_CryptoPro_Oscar_1_1_ParamSet OBJ_cryptopro,31L,5L ++ ++#define SN_id_Gost28147_89_CryptoPro_Oscar_1_0_ParamSet "id-Gost28147-89-CryptoPro-Oscar-1-0-ParamSet" ++#define NID_id_Gost28147_89_CryptoPro_Oscar_1_0_ParamSet 829 ++#define OBJ_id_Gost28147_89_CryptoPro_Oscar_1_0_ParamSet OBJ_cryptopro,31L,6L ++ ++#define SN_id_Gost28147_89_CryptoPro_RIC_1_ParamSet "id-Gost28147-89-CryptoPro-RIC-1-ParamSet" ++#define NID_id_Gost28147_89_CryptoPro_RIC_1_ParamSet 830 ++#define OBJ_id_Gost28147_89_CryptoPro_RIC_1_ParamSet OBJ_cryptopro,31L,7L ++ ++#define SN_id_GostR3410_94_TestParamSet "id-GostR3410-94-TestParamSet" ++#define NID_id_GostR3410_94_TestParamSet 831 ++#define OBJ_id_GostR3410_94_TestParamSet OBJ_cryptopro,32L,0L ++ ++#define SN_id_GostR3410_94_CryptoPro_A_ParamSet "id-GostR3410-94-CryptoPro-A-ParamSet" ++#define NID_id_GostR3410_94_CryptoPro_A_ParamSet 832 ++#define OBJ_id_GostR3410_94_CryptoPro_A_ParamSet OBJ_cryptopro,32L,2L ++ ++#define SN_id_GostR3410_94_CryptoPro_B_ParamSet "id-GostR3410-94-CryptoPro-B-ParamSet" ++#define NID_id_GostR3410_94_CryptoPro_B_ParamSet 833 ++#define OBJ_id_GostR3410_94_CryptoPro_B_ParamSet OBJ_cryptopro,32L,3L ++ ++#define SN_id_GostR3410_94_CryptoPro_C_ParamSet "id-GostR3410-94-CryptoPro-C-ParamSet" ++#define NID_id_GostR3410_94_CryptoPro_C_ParamSet 834 ++#define OBJ_id_GostR3410_94_CryptoPro_C_ParamSet OBJ_cryptopro,32L,4L ++ ++#define SN_id_GostR3410_94_CryptoPro_D_ParamSet "id-GostR3410-94-CryptoPro-D-ParamSet" ++#define NID_id_GostR3410_94_CryptoPro_D_ParamSet 835 ++#define OBJ_id_GostR3410_94_CryptoPro_D_ParamSet OBJ_cryptopro,32L,5L ++ ++#define SN_id_GostR3410_94_CryptoPro_XchA_ParamSet "id-GostR3410-94-CryptoPro-XchA-ParamSet" ++#define NID_id_GostR3410_94_CryptoPro_XchA_ParamSet 836 ++#define OBJ_id_GostR3410_94_CryptoPro_XchA_ParamSet OBJ_cryptopro,33L,1L ++ ++#define SN_id_GostR3410_94_CryptoPro_XchB_ParamSet "id-GostR3410-94-CryptoPro-XchB-ParamSet" ++#define NID_id_GostR3410_94_CryptoPro_XchB_ParamSet 837 ++#define OBJ_id_GostR3410_94_CryptoPro_XchB_ParamSet OBJ_cryptopro,33L,2L ++ ++#define SN_id_GostR3410_94_CryptoPro_XchC_ParamSet "id-GostR3410-94-CryptoPro-XchC-ParamSet" ++#define NID_id_GostR3410_94_CryptoPro_XchC_ParamSet 838 ++#define OBJ_id_GostR3410_94_CryptoPro_XchC_ParamSet OBJ_cryptopro,33L,3L ++ ++#define SN_id_GostR3410_2001_TestParamSet "id-GostR3410-2001-TestParamSet" ++#define NID_id_GostR3410_2001_TestParamSet 839 ++#define OBJ_id_GostR3410_2001_TestParamSet OBJ_cryptopro,35L,0L ++ ++#define SN_id_GostR3410_2001_CryptoPro_A_ParamSet "id-GostR3410-2001-CryptoPro-A-ParamSet" ++#define NID_id_GostR3410_2001_CryptoPro_A_ParamSet 840 ++#define OBJ_id_GostR3410_2001_CryptoPro_A_ParamSet OBJ_cryptopro,35L,1L ++ ++#define SN_id_GostR3410_2001_CryptoPro_B_ParamSet "id-GostR3410-2001-CryptoPro-B-ParamSet" ++#define NID_id_GostR3410_2001_CryptoPro_B_ParamSet 841 ++#define OBJ_id_GostR3410_2001_CryptoPro_B_ParamSet OBJ_cryptopro,35L,2L ++ ++#define SN_id_GostR3410_2001_CryptoPro_C_ParamSet "id-GostR3410-2001-CryptoPro-C-ParamSet" ++#define NID_id_GostR3410_2001_CryptoPro_C_ParamSet 842 ++#define OBJ_id_GostR3410_2001_CryptoPro_C_ParamSet OBJ_cryptopro,35L,3L ++ ++#define SN_id_GostR3410_2001_CryptoPro_XchA_ParamSet "id-GostR3410-2001-CryptoPro-XchA-ParamSet" ++#define NID_id_GostR3410_2001_CryptoPro_XchA_ParamSet 843 ++#define OBJ_id_GostR3410_2001_CryptoPro_XchA_ParamSet OBJ_cryptopro,36L,0L ++ ++#define SN_id_GostR3410_2001_CryptoPro_XchB_ParamSet "id-GostR3410-2001-CryptoPro-XchB-ParamSet" ++#define NID_id_GostR3410_2001_CryptoPro_XchB_ParamSet 844 ++#define OBJ_id_GostR3410_2001_CryptoPro_XchB_ParamSet OBJ_cryptopro,36L,1L ++ ++#define SN_id_GostR3410_94_a "id-GostR3410-94-a" ++#define NID_id_GostR3410_94_a 845 ++#define OBJ_id_GostR3410_94_a OBJ_id_GostR3410_94,1L ++ ++#define SN_id_GostR3410_94_aBis "id-GostR3410-94-aBis" ++#define NID_id_GostR3410_94_aBis 846 ++#define OBJ_id_GostR3410_94_aBis OBJ_id_GostR3410_94,2L ++ ++#define SN_id_GostR3410_94_b "id-GostR3410-94-b" ++#define NID_id_GostR3410_94_b 847 ++#define OBJ_id_GostR3410_94_b OBJ_id_GostR3410_94,3L ++ ++#define SN_id_GostR3410_94_bBis "id-GostR3410-94-bBis" ++#define NID_id_GostR3410_94_bBis 848 ++#define OBJ_id_GostR3410_94_bBis OBJ_id_GostR3410_94,4L ++ ++#define SN_id_Gost28147_89_cc "id-Gost28147-89-cc" ++#define LN_id_Gost28147_89_cc "GOST 28147-89 Cryptocom ParamSet" ++#define NID_id_Gost28147_89_cc 849 ++#define OBJ_id_Gost28147_89_cc OBJ_cryptocom,1L,6L,1L ++ ++#define SN_id_GostR3410_94_cc "gost94cc" ++#define LN_id_GostR3410_94_cc "GOST 34.10-94 Cryptocom" ++#define NID_id_GostR3410_94_cc 850 ++#define OBJ_id_GostR3410_94_cc OBJ_cryptocom,1L,5L,3L ++ ++#define SN_id_GostR3410_2001_cc "gost2001cc" ++#define LN_id_GostR3410_2001_cc "GOST 34.10-2001 Cryptocom" ++#define NID_id_GostR3410_2001_cc 851 ++#define OBJ_id_GostR3410_2001_cc OBJ_cryptocom,1L,5L,4L ++ ++#define SN_id_GostR3411_94_with_GostR3410_94_cc "id-GostR3411-94-with-GostR3410-94-cc" ++#define LN_id_GostR3411_94_with_GostR3410_94_cc "GOST R 34.11-94 with GOST R 34.10-94 Cryptocom" ++#define NID_id_GostR3411_94_with_GostR3410_94_cc 852 ++#define OBJ_id_GostR3411_94_with_GostR3410_94_cc OBJ_cryptocom,1L,3L,3L ++ ++#define SN_id_GostR3411_94_with_GostR3410_2001_cc "id-GostR3411-94-with-GostR3410-2001-cc" ++#define LN_id_GostR3411_94_with_GostR3410_2001_cc "GOST R 34.11-94 with GOST R 34.10-2001 Cryptocom" ++#define NID_id_GostR3411_94_with_GostR3410_2001_cc 853 ++#define OBJ_id_GostR3411_94_with_GostR3410_2001_cc OBJ_cryptocom,1L,3L,4L ++ ++#define SN_id_GostR3410_2001_ParamSet_cc "id-GostR3410-2001-ParamSet-cc" ++#define LN_id_GostR3410_2001_ParamSet_cc "GOST R 3410-2001 Parameter Set Cryptocom" ++#define NID_id_GostR3410_2001_ParamSet_cc 854 ++#define OBJ_id_GostR3410_2001_ParamSet_cc OBJ_cryptocom,1L,8L,1L ++ ++#define SN_id_tc26_algorithms "id-tc26-algorithms" ++#define NID_id_tc26_algorithms 977 ++#define OBJ_id_tc26_algorithms OBJ_id_tc26,1L ++ ++#define SN_id_tc26_sign "id-tc26-sign" ++#define NID_id_tc26_sign 978 ++#define OBJ_id_tc26_sign OBJ_id_tc26_algorithms,1L ++ ++#define SN_id_GostR3410_2012_256 "gost2012_256" ++#define LN_id_GostR3410_2012_256 "GOST R 34.10-2012 with 256 bit modulus" ++#define NID_id_GostR3410_2012_256 979 ++#define OBJ_id_GostR3410_2012_256 OBJ_id_tc26_sign,1L ++ ++#define SN_id_GostR3410_2012_512 "gost2012_512" ++#define LN_id_GostR3410_2012_512 "GOST R 34.10-2012 with 512 bit modulus" ++#define NID_id_GostR3410_2012_512 980 ++#define OBJ_id_GostR3410_2012_512 OBJ_id_tc26_sign,2L ++ ++#define SN_id_tc26_digest "id-tc26-digest" ++#define NID_id_tc26_digest 981 ++#define OBJ_id_tc26_digest OBJ_id_tc26_algorithms,2L ++ ++#define SN_id_GostR3411_2012_256 "md_gost12_256" ++#define LN_id_GostR3411_2012_256 "GOST R 34.11-2012 with 256 bit hash" ++#define NID_id_GostR3411_2012_256 982 ++#define OBJ_id_GostR3411_2012_256 OBJ_id_tc26_digest,2L ++ ++#define SN_id_GostR3411_2012_512 "md_gost12_512" ++#define LN_id_GostR3411_2012_512 "GOST R 34.11-2012 with 512 bit hash" ++#define NID_id_GostR3411_2012_512 983 ++#define OBJ_id_GostR3411_2012_512 OBJ_id_tc26_digest,3L ++ ++#define SN_id_tc26_signwithdigest "id-tc26-signwithdigest" ++#define NID_id_tc26_signwithdigest 984 ++#define OBJ_id_tc26_signwithdigest OBJ_id_tc26_algorithms,3L ++ ++#define SN_id_tc26_signwithdigest_gost3410_2012_256 "id-tc26-signwithdigest-gost3410-2012-256" ++#define LN_id_tc26_signwithdigest_gost3410_2012_256 "GOST R 34.10-2012 with GOST R 34.11-2012 (256 bit)" ++#define NID_id_tc26_signwithdigest_gost3410_2012_256 985 ++#define OBJ_id_tc26_signwithdigest_gost3410_2012_256 OBJ_id_tc26_signwithdigest,2L ++ ++#define SN_id_tc26_signwithdigest_gost3410_2012_512 "id-tc26-signwithdigest-gost3410-2012-512" ++#define LN_id_tc26_signwithdigest_gost3410_2012_512 "GOST R 34.10-2012 with GOST R 34.11-2012 (512 bit)" ++#define NID_id_tc26_signwithdigest_gost3410_2012_512 986 ++#define OBJ_id_tc26_signwithdigest_gost3410_2012_512 OBJ_id_tc26_signwithdigest,3L ++ ++#define SN_id_tc26_mac "id-tc26-mac" ++#define NID_id_tc26_mac 987 ++#define OBJ_id_tc26_mac OBJ_id_tc26_algorithms,4L ++ ++#define SN_id_tc26_hmac_gost_3411_2012_256 "id-tc26-hmac-gost-3411-2012-256" ++#define LN_id_tc26_hmac_gost_3411_2012_256 "HMAC GOST 34.11-2012 256 bit" ++#define NID_id_tc26_hmac_gost_3411_2012_256 988 ++#define OBJ_id_tc26_hmac_gost_3411_2012_256 OBJ_id_tc26_mac,1L ++ ++#define SN_id_tc26_hmac_gost_3411_2012_512 "id-tc26-hmac-gost-3411-2012-512" ++#define LN_id_tc26_hmac_gost_3411_2012_512 "HMAC GOST 34.11-2012 512 bit" ++#define NID_id_tc26_hmac_gost_3411_2012_512 989 ++#define OBJ_id_tc26_hmac_gost_3411_2012_512 OBJ_id_tc26_mac,2L ++ ++#define SN_id_tc26_cipher "id-tc26-cipher" ++#define NID_id_tc26_cipher 990 ++#define OBJ_id_tc26_cipher OBJ_id_tc26_algorithms,5L ++ ++#define SN_id_tc26_cipher_gostr3412_2015_magma "id-tc26-cipher-gostr3412-2015-magma" ++#define NID_id_tc26_cipher_gostr3412_2015_magma 1173 ++#define OBJ_id_tc26_cipher_gostr3412_2015_magma OBJ_id_tc26_cipher,1L ++ ++#define SN_id_tc26_cipher_gostr3412_2015_magma_ctracpkm "id-tc26-cipher-gostr3412-2015-magma-ctracpkm" ++#define NID_id_tc26_cipher_gostr3412_2015_magma_ctracpkm 1174 ++#define OBJ_id_tc26_cipher_gostr3412_2015_magma_ctracpkm OBJ_id_tc26_cipher_gostr3412_2015_magma,1L ++ ++#define SN_id_tc26_cipher_gostr3412_2015_magma_ctracpkm_omac "id-tc26-cipher-gostr3412-2015-magma-ctracpkm-omac" ++#define NID_id_tc26_cipher_gostr3412_2015_magma_ctracpkm_omac 1175 ++#define OBJ_id_tc26_cipher_gostr3412_2015_magma_ctracpkm_omac OBJ_id_tc26_cipher_gostr3412_2015_magma,2L ++ ++#define SN_id_tc26_cipher_gostr3412_2015_kuznyechik "id-tc26-cipher-gostr3412-2015-kuznyechik" ++#define NID_id_tc26_cipher_gostr3412_2015_kuznyechik 1176 ++#define OBJ_id_tc26_cipher_gostr3412_2015_kuznyechik OBJ_id_tc26_cipher,2L ++ ++#define SN_id_tc26_cipher_gostr3412_2015_kuznyechik_ctracpkm "id-tc26-cipher-gostr3412-2015-kuznyechik-ctracpkm" ++#define NID_id_tc26_cipher_gostr3412_2015_kuznyechik_ctracpkm 1177 ++#define OBJ_id_tc26_cipher_gostr3412_2015_kuznyechik_ctracpkm OBJ_id_tc26_cipher_gostr3412_2015_kuznyechik,1L ++ ++#define SN_id_tc26_cipher_gostr3412_2015_kuznyechik_ctracpkm_omac "id-tc26-cipher-gostr3412-2015-kuznyechik-ctracpkm-omac" ++#define NID_id_tc26_cipher_gostr3412_2015_kuznyechik_ctracpkm_omac 1178 ++#define OBJ_id_tc26_cipher_gostr3412_2015_kuznyechik_ctracpkm_omac OBJ_id_tc26_cipher_gostr3412_2015_kuznyechik,2L ++ ++#define SN_id_tc26_agreement "id-tc26-agreement" ++#define NID_id_tc26_agreement 991 ++#define OBJ_id_tc26_agreement OBJ_id_tc26_algorithms,6L ++ ++#define SN_id_tc26_agreement_gost_3410_2012_256 "id-tc26-agreement-gost-3410-2012-256" ++#define NID_id_tc26_agreement_gost_3410_2012_256 992 ++#define OBJ_id_tc26_agreement_gost_3410_2012_256 OBJ_id_tc26_agreement,1L ++ ++#define SN_id_tc26_agreement_gost_3410_2012_512 "id-tc26-agreement-gost-3410-2012-512" ++#define NID_id_tc26_agreement_gost_3410_2012_512 993 ++#define OBJ_id_tc26_agreement_gost_3410_2012_512 OBJ_id_tc26_agreement,2L ++ ++#define SN_id_tc26_wrap "id-tc26-wrap" ++#define NID_id_tc26_wrap 1179 ++#define OBJ_id_tc26_wrap OBJ_id_tc26_algorithms,7L ++ ++#define SN_id_tc26_wrap_gostr3412_2015_magma "id-tc26-wrap-gostr3412-2015-magma" ++#define NID_id_tc26_wrap_gostr3412_2015_magma 1180 ++#define OBJ_id_tc26_wrap_gostr3412_2015_magma OBJ_id_tc26_wrap,1L ++ ++#define SN_id_tc26_wrap_gostr3412_2015_magma_kexp15 "id-tc26-wrap-gostr3412-2015-magma-kexp15" ++#define NID_id_tc26_wrap_gostr3412_2015_magma_kexp15 1181 ++#define OBJ_id_tc26_wrap_gostr3412_2015_magma_kexp15 OBJ_id_tc26_wrap_gostr3412_2015_magma,1L ++ ++#define SN_id_tc26_wrap_gostr3412_2015_kuznyechik "id-tc26-wrap-gostr3412-2015-kuznyechik" ++#define NID_id_tc26_wrap_gostr3412_2015_kuznyechik 1182 ++#define OBJ_id_tc26_wrap_gostr3412_2015_kuznyechik OBJ_id_tc26_wrap,2L ++ ++#define SN_id_tc26_wrap_gostr3412_2015_kuznyechik_kexp15 "id-tc26-wrap-gostr3412-2015-kuznyechik-kexp15" ++#define NID_id_tc26_wrap_gostr3412_2015_kuznyechik_kexp15 1183 ++#define OBJ_id_tc26_wrap_gostr3412_2015_kuznyechik_kexp15 OBJ_id_tc26_wrap_gostr3412_2015_kuznyechik,1L ++ ++#define SN_id_tc26_constants "id-tc26-constants" ++#define NID_id_tc26_constants 994 ++#define OBJ_id_tc26_constants OBJ_id_tc26,2L ++ ++#define SN_id_tc26_sign_constants "id-tc26-sign-constants" ++#define NID_id_tc26_sign_constants 995 ++#define OBJ_id_tc26_sign_constants OBJ_id_tc26_constants,1L ++ ++#define SN_id_tc26_gost_3410_2012_256_constants "id-tc26-gost-3410-2012-256-constants" ++#define NID_id_tc26_gost_3410_2012_256_constants 1147 ++#define OBJ_id_tc26_gost_3410_2012_256_constants OBJ_id_tc26_sign_constants,1L ++ ++#define SN_id_tc26_gost_3410_2012_256_paramSetA "id-tc26-gost-3410-2012-256-paramSetA" ++#define LN_id_tc26_gost_3410_2012_256_paramSetA "GOST R 34.10-2012 (256 bit) ParamSet A" ++#define NID_id_tc26_gost_3410_2012_256_paramSetA 1148 ++#define OBJ_id_tc26_gost_3410_2012_256_paramSetA OBJ_id_tc26_gost_3410_2012_256_constants,1L ++ ++#define SN_id_tc26_gost_3410_2012_256_paramSetB "id-tc26-gost-3410-2012-256-paramSetB" ++#define LN_id_tc26_gost_3410_2012_256_paramSetB "GOST R 34.10-2012 (256 bit) ParamSet B" ++#define NID_id_tc26_gost_3410_2012_256_paramSetB 1184 ++#define OBJ_id_tc26_gost_3410_2012_256_paramSetB OBJ_id_tc26_gost_3410_2012_256_constants,2L ++ ++#define SN_id_tc26_gost_3410_2012_256_paramSetC "id-tc26-gost-3410-2012-256-paramSetC" ++#define LN_id_tc26_gost_3410_2012_256_paramSetC "GOST R 34.10-2012 (256 bit) ParamSet C" ++#define NID_id_tc26_gost_3410_2012_256_paramSetC 1185 ++#define OBJ_id_tc26_gost_3410_2012_256_paramSetC OBJ_id_tc26_gost_3410_2012_256_constants,3L ++ ++#define SN_id_tc26_gost_3410_2012_256_paramSetD "id-tc26-gost-3410-2012-256-paramSetD" ++#define LN_id_tc26_gost_3410_2012_256_paramSetD "GOST R 34.10-2012 (256 bit) ParamSet D" ++#define NID_id_tc26_gost_3410_2012_256_paramSetD 1186 ++#define OBJ_id_tc26_gost_3410_2012_256_paramSetD OBJ_id_tc26_gost_3410_2012_256_constants,4L ++ ++#define SN_id_tc26_gost_3410_2012_512_constants "id-tc26-gost-3410-2012-512-constants" ++#define NID_id_tc26_gost_3410_2012_512_constants 996 ++#define OBJ_id_tc26_gost_3410_2012_512_constants OBJ_id_tc26_sign_constants,2L ++ ++#define SN_id_tc26_gost_3410_2012_512_paramSetTest "id-tc26-gost-3410-2012-512-paramSetTest" ++#define LN_id_tc26_gost_3410_2012_512_paramSetTest "GOST R 34.10-2012 (512 bit) testing parameter set" ++#define NID_id_tc26_gost_3410_2012_512_paramSetTest 997 ++#define OBJ_id_tc26_gost_3410_2012_512_paramSetTest OBJ_id_tc26_gost_3410_2012_512_constants,0L ++ ++#define SN_id_tc26_gost_3410_2012_512_paramSetA "id-tc26-gost-3410-2012-512-paramSetA" ++#define LN_id_tc26_gost_3410_2012_512_paramSetA "GOST R 34.10-2012 (512 bit) ParamSet A" ++#define NID_id_tc26_gost_3410_2012_512_paramSetA 998 ++#define OBJ_id_tc26_gost_3410_2012_512_paramSetA OBJ_id_tc26_gost_3410_2012_512_constants,1L ++ ++#define SN_id_tc26_gost_3410_2012_512_paramSetB "id-tc26-gost-3410-2012-512-paramSetB" ++#define LN_id_tc26_gost_3410_2012_512_paramSetB "GOST R 34.10-2012 (512 bit) ParamSet B" ++#define NID_id_tc26_gost_3410_2012_512_paramSetB 999 ++#define OBJ_id_tc26_gost_3410_2012_512_paramSetB OBJ_id_tc26_gost_3410_2012_512_constants,2L ++ ++#define SN_id_tc26_gost_3410_2012_512_paramSetC "id-tc26-gost-3410-2012-512-paramSetC" ++#define LN_id_tc26_gost_3410_2012_512_paramSetC "GOST R 34.10-2012 (512 bit) ParamSet C" ++#define NID_id_tc26_gost_3410_2012_512_paramSetC 1149 ++#define OBJ_id_tc26_gost_3410_2012_512_paramSetC OBJ_id_tc26_gost_3410_2012_512_constants,3L ++ ++#define SN_id_tc26_digest_constants "id-tc26-digest-constants" ++#define NID_id_tc26_digest_constants 1000 ++#define OBJ_id_tc26_digest_constants OBJ_id_tc26_constants,2L ++ ++#define SN_id_tc26_cipher_constants "id-tc26-cipher-constants" ++#define NID_id_tc26_cipher_constants 1001 ++#define OBJ_id_tc26_cipher_constants OBJ_id_tc26_constants,5L ++ ++#define SN_id_tc26_gost_28147_constants "id-tc26-gost-28147-constants" ++#define NID_id_tc26_gost_28147_constants 1002 ++#define OBJ_id_tc26_gost_28147_constants OBJ_id_tc26_cipher_constants,1L ++ ++#define SN_id_tc26_gost_28147_param_Z "id-tc26-gost-28147-param-Z" ++#define LN_id_tc26_gost_28147_param_Z "GOST 28147-89 TC26 parameter set" ++#define NID_id_tc26_gost_28147_param_Z 1003 ++#define OBJ_id_tc26_gost_28147_param_Z OBJ_id_tc26_gost_28147_constants,1L ++ ++#define SN_INN "INN" ++#define LN_INN "INN" ++#define NID_INN 1004 ++#define OBJ_INN OBJ_member_body,643L,3L,131L,1L,1L ++ ++#define SN_OGRN "OGRN" ++#define LN_OGRN "OGRN" ++#define NID_OGRN 1005 ++#define OBJ_OGRN OBJ_member_body,643L,100L,1L ++ ++#define SN_SNILS "SNILS" ++#define LN_SNILS "SNILS" ++#define NID_SNILS 1006 ++#define OBJ_SNILS OBJ_member_body,643L,100L,3L ++ ++#define SN_subjectSignTool "subjectSignTool" ++#define LN_subjectSignTool "Signing Tool of Subject" ++#define NID_subjectSignTool 1007 ++#define OBJ_subjectSignTool OBJ_member_body,643L,100L,111L ++ ++#define SN_issuerSignTool "issuerSignTool" ++#define LN_issuerSignTool "Signing Tool of Issuer" ++#define NID_issuerSignTool 1008 ++#define OBJ_issuerSignTool OBJ_member_body,643L,100L,112L ++ ++#define SN_grasshopper_ecb "grasshopper-ecb" ++#define NID_grasshopper_ecb 1012 ++ ++#define SN_grasshopper_ctr "grasshopper-ctr" ++#define NID_grasshopper_ctr 1013 ++ ++#define SN_grasshopper_ofb "grasshopper-ofb" ++#define NID_grasshopper_ofb 1014 ++ ++#define SN_grasshopper_cbc "grasshopper-cbc" ++#define NID_grasshopper_cbc 1015 ++ ++#define SN_grasshopper_cfb "grasshopper-cfb" ++#define NID_grasshopper_cfb 1016 ++ ++#define SN_grasshopper_mac "grasshopper-mac" ++#define NID_grasshopper_mac 1017 ++ ++#define SN_magma_ecb "magma-ecb" ++#define NID_magma_ecb 1187 ++ ++#define SN_magma_ctr "magma-ctr" ++#define NID_magma_ctr 1188 ++ ++#define SN_magma_ofb "magma-ofb" ++#define NID_magma_ofb 1189 ++ ++#define SN_magma_cbc "magma-cbc" ++#define NID_magma_cbc 1190 ++ ++#define SN_magma_cfb "magma-cfb" ++#define NID_magma_cfb 1191 ++ ++#define SN_magma_mac "magma-mac" ++#define NID_magma_mac 1192 ++ ++#define SN_camellia_128_cbc "CAMELLIA-128-CBC" ++#define LN_camellia_128_cbc "camellia-128-cbc" ++#define NID_camellia_128_cbc 751 ++#define OBJ_camellia_128_cbc 1L,2L,392L,200011L,61L,1L,1L,1L,2L ++ ++#define SN_camellia_192_cbc "CAMELLIA-192-CBC" ++#define LN_camellia_192_cbc "camellia-192-cbc" ++#define NID_camellia_192_cbc 752 ++#define OBJ_camellia_192_cbc 1L,2L,392L,200011L,61L,1L,1L,1L,3L ++ ++#define SN_camellia_256_cbc "CAMELLIA-256-CBC" ++#define LN_camellia_256_cbc "camellia-256-cbc" ++#define NID_camellia_256_cbc 753 ++#define OBJ_camellia_256_cbc 1L,2L,392L,200011L,61L,1L,1L,1L,4L ++ ++#define SN_id_camellia128_wrap "id-camellia128-wrap" ++#define NID_id_camellia128_wrap 907 ++#define OBJ_id_camellia128_wrap 1L,2L,392L,200011L,61L,1L,1L,3L,2L ++ ++#define SN_id_camellia192_wrap "id-camellia192-wrap" ++#define NID_id_camellia192_wrap 908 ++#define OBJ_id_camellia192_wrap 1L,2L,392L,200011L,61L,1L,1L,3L,3L ++ ++#define SN_id_camellia256_wrap "id-camellia256-wrap" ++#define NID_id_camellia256_wrap 909 ++#define OBJ_id_camellia256_wrap 1L,2L,392L,200011L,61L,1L,1L,3L,4L ++ ++#define OBJ_ntt_ds 0L,3L,4401L,5L ++ ++#define OBJ_camellia OBJ_ntt_ds,3L,1L,9L ++ ++#define SN_camellia_128_ecb "CAMELLIA-128-ECB" ++#define LN_camellia_128_ecb "camellia-128-ecb" ++#define NID_camellia_128_ecb 754 ++#define OBJ_camellia_128_ecb OBJ_camellia,1L ++ ++#define SN_camellia_128_ofb128 "CAMELLIA-128-OFB" ++#define LN_camellia_128_ofb128 "camellia-128-ofb" ++#define NID_camellia_128_ofb128 766 ++#define OBJ_camellia_128_ofb128 OBJ_camellia,3L ++ ++#define SN_camellia_128_cfb128 "CAMELLIA-128-CFB" ++#define LN_camellia_128_cfb128 "camellia-128-cfb" ++#define NID_camellia_128_cfb128 757 ++#define OBJ_camellia_128_cfb128 OBJ_camellia,4L ++ ++#define SN_camellia_128_gcm "CAMELLIA-128-GCM" ++#define LN_camellia_128_gcm "camellia-128-gcm" ++#define NID_camellia_128_gcm 961 ++#define OBJ_camellia_128_gcm OBJ_camellia,6L ++ ++#define SN_camellia_128_ccm "CAMELLIA-128-CCM" ++#define LN_camellia_128_ccm "camellia-128-ccm" ++#define NID_camellia_128_ccm 962 ++#define OBJ_camellia_128_ccm OBJ_camellia,7L ++ ++#define SN_camellia_128_ctr "CAMELLIA-128-CTR" ++#define LN_camellia_128_ctr "camellia-128-ctr" ++#define NID_camellia_128_ctr 963 ++#define OBJ_camellia_128_ctr OBJ_camellia,9L ++ ++#define SN_camellia_128_cmac "CAMELLIA-128-CMAC" ++#define LN_camellia_128_cmac "camellia-128-cmac" ++#define NID_camellia_128_cmac 964 ++#define OBJ_camellia_128_cmac OBJ_camellia,10L ++ ++#define SN_camellia_192_ecb "CAMELLIA-192-ECB" ++#define LN_camellia_192_ecb "camellia-192-ecb" ++#define NID_camellia_192_ecb 755 ++#define OBJ_camellia_192_ecb OBJ_camellia,21L ++ ++#define SN_camellia_192_ofb128 "CAMELLIA-192-OFB" ++#define LN_camellia_192_ofb128 "camellia-192-ofb" ++#define NID_camellia_192_ofb128 767 ++#define OBJ_camellia_192_ofb128 OBJ_camellia,23L ++ ++#define SN_camellia_192_cfb128 "CAMELLIA-192-CFB" ++#define LN_camellia_192_cfb128 "camellia-192-cfb" ++#define NID_camellia_192_cfb128 758 ++#define OBJ_camellia_192_cfb128 OBJ_camellia,24L ++ ++#define SN_camellia_192_gcm "CAMELLIA-192-GCM" ++#define LN_camellia_192_gcm "camellia-192-gcm" ++#define NID_camellia_192_gcm 965 ++#define OBJ_camellia_192_gcm OBJ_camellia,26L ++ ++#define SN_camellia_192_ccm "CAMELLIA-192-CCM" ++#define LN_camellia_192_ccm "camellia-192-ccm" ++#define NID_camellia_192_ccm 966 ++#define OBJ_camellia_192_ccm OBJ_camellia,27L ++ ++#define SN_camellia_192_ctr "CAMELLIA-192-CTR" ++#define LN_camellia_192_ctr "camellia-192-ctr" ++#define NID_camellia_192_ctr 967 ++#define OBJ_camellia_192_ctr OBJ_camellia,29L ++ ++#define SN_camellia_192_cmac "CAMELLIA-192-CMAC" ++#define LN_camellia_192_cmac "camellia-192-cmac" ++#define NID_camellia_192_cmac 968 ++#define OBJ_camellia_192_cmac OBJ_camellia,30L ++ ++#define SN_camellia_256_ecb "CAMELLIA-256-ECB" ++#define LN_camellia_256_ecb "camellia-256-ecb" ++#define NID_camellia_256_ecb 756 ++#define OBJ_camellia_256_ecb OBJ_camellia,41L ++ ++#define SN_camellia_256_ofb128 "CAMELLIA-256-OFB" ++#define LN_camellia_256_ofb128 "camellia-256-ofb" ++#define NID_camellia_256_ofb128 768 ++#define OBJ_camellia_256_ofb128 OBJ_camellia,43L ++ ++#define SN_camellia_256_cfb128 "CAMELLIA-256-CFB" ++#define LN_camellia_256_cfb128 "camellia-256-cfb" ++#define NID_camellia_256_cfb128 759 ++#define OBJ_camellia_256_cfb128 OBJ_camellia,44L ++ ++#define SN_camellia_256_gcm "CAMELLIA-256-GCM" ++#define LN_camellia_256_gcm "camellia-256-gcm" ++#define NID_camellia_256_gcm 969 ++#define OBJ_camellia_256_gcm OBJ_camellia,46L ++ ++#define SN_camellia_256_ccm "CAMELLIA-256-CCM" ++#define LN_camellia_256_ccm "camellia-256-ccm" ++#define NID_camellia_256_ccm 970 ++#define OBJ_camellia_256_ccm OBJ_camellia,47L ++ ++#define SN_camellia_256_ctr "CAMELLIA-256-CTR" ++#define LN_camellia_256_ctr "camellia-256-ctr" ++#define NID_camellia_256_ctr 971 ++#define OBJ_camellia_256_ctr OBJ_camellia,49L ++ ++#define SN_camellia_256_cmac "CAMELLIA-256-CMAC" ++#define LN_camellia_256_cmac "camellia-256-cmac" ++#define NID_camellia_256_cmac 972 ++#define OBJ_camellia_256_cmac OBJ_camellia,50L ++ ++#define SN_camellia_128_cfb1 "CAMELLIA-128-CFB1" ++#define LN_camellia_128_cfb1 "camellia-128-cfb1" ++#define NID_camellia_128_cfb1 760 ++ ++#define SN_camellia_192_cfb1 "CAMELLIA-192-CFB1" ++#define LN_camellia_192_cfb1 "camellia-192-cfb1" ++#define NID_camellia_192_cfb1 761 ++ ++#define SN_camellia_256_cfb1 "CAMELLIA-256-CFB1" ++#define LN_camellia_256_cfb1 "camellia-256-cfb1" ++#define NID_camellia_256_cfb1 762 ++ ++#define SN_camellia_128_cfb8 "CAMELLIA-128-CFB8" ++#define LN_camellia_128_cfb8 "camellia-128-cfb8" ++#define NID_camellia_128_cfb8 763 ++ ++#define SN_camellia_192_cfb8 "CAMELLIA-192-CFB8" ++#define LN_camellia_192_cfb8 "camellia-192-cfb8" ++#define NID_camellia_192_cfb8 764 ++ ++#define SN_camellia_256_cfb8 "CAMELLIA-256-CFB8" ++#define LN_camellia_256_cfb8 "camellia-256-cfb8" ++#define NID_camellia_256_cfb8 765 ++ ++#define OBJ_aria 1L,2L,410L,200046L,1L,1L ++ ++#define SN_aria_128_ecb "ARIA-128-ECB" ++#define LN_aria_128_ecb "aria-128-ecb" ++#define NID_aria_128_ecb 1065 ++#define OBJ_aria_128_ecb OBJ_aria,1L ++ ++#define SN_aria_128_cbc "ARIA-128-CBC" ++#define LN_aria_128_cbc "aria-128-cbc" ++#define NID_aria_128_cbc 1066 ++#define OBJ_aria_128_cbc OBJ_aria,2L ++ ++#define SN_aria_128_cfb128 "ARIA-128-CFB" ++#define LN_aria_128_cfb128 "aria-128-cfb" ++#define NID_aria_128_cfb128 1067 ++#define OBJ_aria_128_cfb128 OBJ_aria,3L ++ ++#define SN_aria_128_ofb128 "ARIA-128-OFB" ++#define LN_aria_128_ofb128 "aria-128-ofb" ++#define NID_aria_128_ofb128 1068 ++#define OBJ_aria_128_ofb128 OBJ_aria,4L ++ ++#define SN_aria_128_ctr "ARIA-128-CTR" ++#define LN_aria_128_ctr "aria-128-ctr" ++#define NID_aria_128_ctr 1069 ++#define OBJ_aria_128_ctr OBJ_aria,5L ++ ++#define SN_aria_192_ecb "ARIA-192-ECB" ++#define LN_aria_192_ecb "aria-192-ecb" ++#define NID_aria_192_ecb 1070 ++#define OBJ_aria_192_ecb OBJ_aria,6L ++ ++#define SN_aria_192_cbc "ARIA-192-CBC" ++#define LN_aria_192_cbc "aria-192-cbc" ++#define NID_aria_192_cbc 1071 ++#define OBJ_aria_192_cbc OBJ_aria,7L ++ ++#define SN_aria_192_cfb128 "ARIA-192-CFB" ++#define LN_aria_192_cfb128 "aria-192-cfb" ++#define NID_aria_192_cfb128 1072 ++#define OBJ_aria_192_cfb128 OBJ_aria,8L ++ ++#define SN_aria_192_ofb128 "ARIA-192-OFB" ++#define LN_aria_192_ofb128 "aria-192-ofb" ++#define NID_aria_192_ofb128 1073 ++#define OBJ_aria_192_ofb128 OBJ_aria,9L ++ ++#define SN_aria_192_ctr "ARIA-192-CTR" ++#define LN_aria_192_ctr "aria-192-ctr" ++#define NID_aria_192_ctr 1074 ++#define OBJ_aria_192_ctr OBJ_aria,10L ++ ++#define SN_aria_256_ecb "ARIA-256-ECB" ++#define LN_aria_256_ecb "aria-256-ecb" ++#define NID_aria_256_ecb 1075 ++#define OBJ_aria_256_ecb OBJ_aria,11L ++ ++#define SN_aria_256_cbc "ARIA-256-CBC" ++#define LN_aria_256_cbc "aria-256-cbc" ++#define NID_aria_256_cbc 1076 ++#define OBJ_aria_256_cbc OBJ_aria,12L ++ ++#define SN_aria_256_cfb128 "ARIA-256-CFB" ++#define LN_aria_256_cfb128 "aria-256-cfb" ++#define NID_aria_256_cfb128 1077 ++#define OBJ_aria_256_cfb128 OBJ_aria,13L ++ ++#define SN_aria_256_ofb128 "ARIA-256-OFB" ++#define LN_aria_256_ofb128 "aria-256-ofb" ++#define NID_aria_256_ofb128 1078 ++#define OBJ_aria_256_ofb128 OBJ_aria,14L ++ ++#define SN_aria_256_ctr "ARIA-256-CTR" ++#define LN_aria_256_ctr "aria-256-ctr" ++#define NID_aria_256_ctr 1079 ++#define OBJ_aria_256_ctr OBJ_aria,15L ++ ++#define SN_aria_128_cfb1 "ARIA-128-CFB1" ++#define LN_aria_128_cfb1 "aria-128-cfb1" ++#define NID_aria_128_cfb1 1080 ++ ++#define SN_aria_192_cfb1 "ARIA-192-CFB1" ++#define LN_aria_192_cfb1 "aria-192-cfb1" ++#define NID_aria_192_cfb1 1081 ++ ++#define SN_aria_256_cfb1 "ARIA-256-CFB1" ++#define LN_aria_256_cfb1 "aria-256-cfb1" ++#define NID_aria_256_cfb1 1082 ++ ++#define SN_aria_128_cfb8 "ARIA-128-CFB8" ++#define LN_aria_128_cfb8 "aria-128-cfb8" ++#define NID_aria_128_cfb8 1083 ++ ++#define SN_aria_192_cfb8 "ARIA-192-CFB8" ++#define LN_aria_192_cfb8 "aria-192-cfb8" ++#define NID_aria_192_cfb8 1084 ++ ++#define SN_aria_256_cfb8 "ARIA-256-CFB8" ++#define LN_aria_256_cfb8 "aria-256-cfb8" ++#define NID_aria_256_cfb8 1085 ++ ++#define SN_aria_128_ccm "ARIA-128-CCM" ++#define LN_aria_128_ccm "aria-128-ccm" ++#define NID_aria_128_ccm 1120 ++#define OBJ_aria_128_ccm OBJ_aria,37L ++ ++#define SN_aria_192_ccm "ARIA-192-CCM" ++#define LN_aria_192_ccm "aria-192-ccm" ++#define NID_aria_192_ccm 1121 ++#define OBJ_aria_192_ccm OBJ_aria,38L ++ ++#define SN_aria_256_ccm "ARIA-256-CCM" ++#define LN_aria_256_ccm "aria-256-ccm" ++#define NID_aria_256_ccm 1122 ++#define OBJ_aria_256_ccm OBJ_aria,39L ++ ++#define SN_aria_128_gcm "ARIA-128-GCM" ++#define LN_aria_128_gcm "aria-128-gcm" ++#define NID_aria_128_gcm 1123 ++#define OBJ_aria_128_gcm OBJ_aria,34L ++ ++#define SN_aria_192_gcm "ARIA-192-GCM" ++#define LN_aria_192_gcm "aria-192-gcm" ++#define NID_aria_192_gcm 1124 ++#define OBJ_aria_192_gcm OBJ_aria,35L ++ ++#define SN_aria_256_gcm "ARIA-256-GCM" ++#define LN_aria_256_gcm "aria-256-gcm" ++#define NID_aria_256_gcm 1125 ++#define OBJ_aria_256_gcm OBJ_aria,36L ++ ++#define SN_kisa "KISA" ++#define LN_kisa "kisa" ++#define NID_kisa 773 ++#define OBJ_kisa OBJ_member_body,410L,200004L ++ ++#define SN_seed_ecb "SEED-ECB" ++#define LN_seed_ecb "seed-ecb" ++#define NID_seed_ecb 776 ++#define OBJ_seed_ecb OBJ_kisa,1L,3L ++ ++#define SN_seed_cbc "SEED-CBC" ++#define LN_seed_cbc "seed-cbc" ++#define NID_seed_cbc 777 ++#define OBJ_seed_cbc OBJ_kisa,1L,4L ++ ++#define SN_seed_cfb128 "SEED-CFB" ++#define LN_seed_cfb128 "seed-cfb" ++#define NID_seed_cfb128 779 ++#define OBJ_seed_cfb128 OBJ_kisa,1L,5L ++ ++#define SN_seed_ofb128 "SEED-OFB" ++#define LN_seed_ofb128 "seed-ofb" ++#define NID_seed_ofb128 778 ++#define OBJ_seed_ofb128 OBJ_kisa,1L,6L ++ ++#define SN_sm4Cipher "SM4-CIPHER" ++#define LN_sm4Cipher "sm4Cipher" ++#define NID_sm4Cipher 1210 ++#define OBJ_sm4Cipher OBJ_sm_scheme,104L ++ ++#define SN_sm4_ecb "SM4-ECB" ++#define LN_sm4_ecb "sm4-ecb" ++#define NID_sm4_ecb 1133 ++#define OBJ_sm4_ecb OBJ_sm_scheme,104L,1L ++ ++#define SN_sm4_cbc "SM4-CBC" ++#define LN_sm4_cbc "sm4-cbc" ++#define NID_sm4_cbc 1134 ++#define OBJ_sm4_cbc OBJ_sm_scheme,104L,2L ++ ++#define SN_sm4_ofb128 "SM4-OFB" ++#define LN_sm4_ofb128 "sm4-ofb" ++#define NID_sm4_ofb128 1135 ++#define OBJ_sm4_ofb128 OBJ_sm_scheme,104L,3L ++ ++#define SN_sm4_cfb128 "SM4-CFB" ++#define LN_sm4_cfb128 "sm4-cfb" ++#define NID_sm4_cfb128 1137 ++#define OBJ_sm4_cfb128 OBJ_sm_scheme,104L,4L ++ ++#define SN_sm4_cfb1 "SM4-CFB1" ++#define LN_sm4_cfb1 "sm4-cfb1" ++#define NID_sm4_cfb1 1136 ++#define OBJ_sm4_cfb1 OBJ_sm_scheme,104L,5L ++ ++#define SN_sm4_cfb8 "SM4-CFB8" ++#define LN_sm4_cfb8 "sm4-cfb8" ++#define NID_sm4_cfb8 1138 ++#define OBJ_sm4_cfb8 OBJ_sm_scheme,104L,6L ++ ++#define SN_sm4_ctr "SM4-CTR" ++#define LN_sm4_ctr "sm4-ctr" ++#define NID_sm4_ctr 1139 ++#define OBJ_sm4_ctr OBJ_sm_scheme,104L,7L ++ ++#define SN_sm4_gcm "SM4-GCM" ++#define LN_sm4_gcm "sm4-gcm" ++#define NID_sm4_gcm 1203 ++#define OBJ_sm4_gcm OBJ_sm_scheme,104L,8L ++ ++#define SN_sm4_xts "SM4-XTS" ++#define LN_sm4_xts "sm4-xts" ++#define NID_sm4_xts 1202 ++#define OBJ_sm4_xts OBJ_sm_scheme,104L,10L ++ ++#define SN_hmac "HMAC" ++#define LN_hmac "hmac" ++#define NID_hmac 855 ++ ++#define SN_cmac "CMAC" ++#define LN_cmac "cmac" ++#define NID_cmac 894 ++ ++#define SN_rc4_hmac_md5 "RC4-HMAC-MD5" ++#define LN_rc4_hmac_md5 "rc4-hmac-md5" ++#define NID_rc4_hmac_md5 915 ++ ++#define SN_aes_128_cbc_hmac_sha1 "AES-128-CBC-HMAC-SHA1" ++#define LN_aes_128_cbc_hmac_sha1 "aes-128-cbc-hmac-sha1" ++#define NID_aes_128_cbc_hmac_sha1 916 ++ ++#define SN_aes_192_cbc_hmac_sha1 "AES-192-CBC-HMAC-SHA1" ++#define LN_aes_192_cbc_hmac_sha1 "aes-192-cbc-hmac-sha1" ++#define NID_aes_192_cbc_hmac_sha1 917 ++ ++#define SN_aes_256_cbc_hmac_sha1 "AES-256-CBC-HMAC-SHA1" ++#define LN_aes_256_cbc_hmac_sha1 "aes-256-cbc-hmac-sha1" ++#define NID_aes_256_cbc_hmac_sha1 918 ++ ++#define SN_aes_128_cbc_hmac_sha256 "AES-128-CBC-HMAC-SHA256" ++#define LN_aes_128_cbc_hmac_sha256 "aes-128-cbc-hmac-sha256" ++#define NID_aes_128_cbc_hmac_sha256 948 ++ ++#define SN_aes_192_cbc_hmac_sha256 "AES-192-CBC-HMAC-SHA256" ++#define LN_aes_192_cbc_hmac_sha256 "aes-192-cbc-hmac-sha256" ++#define NID_aes_192_cbc_hmac_sha256 949 ++ ++#define SN_aes_256_cbc_hmac_sha256 "AES-256-CBC-HMAC-SHA256" ++#define LN_aes_256_cbc_hmac_sha256 "aes-256-cbc-hmac-sha256" ++#define NID_aes_256_cbc_hmac_sha256 950 ++ ++#define SN_chacha20_poly1305 "ChaCha20-Poly1305" ++#define LN_chacha20_poly1305 "chacha20-poly1305" ++#define NID_chacha20_poly1305 1018 ++ ++#define SN_chacha20 "ChaCha20" ++#define LN_chacha20 "chacha20" ++#define NID_chacha20 1019 ++ ++#define SN_dhpublicnumber "dhpublicnumber" ++#define LN_dhpublicnumber "X9.42 DH" ++#define NID_dhpublicnumber 920 ++#define OBJ_dhpublicnumber OBJ_ISO_US,10046L,2L,1L ++ ++#define SN_brainpoolP160r1 "brainpoolP160r1" ++#define NID_brainpoolP160r1 921 ++#define OBJ_brainpoolP160r1 1L,3L,36L,3L,3L,2L,8L,1L,1L,1L ++ ++#define SN_brainpoolP160t1 "brainpoolP160t1" ++#define NID_brainpoolP160t1 922 ++#define OBJ_brainpoolP160t1 1L,3L,36L,3L,3L,2L,8L,1L,1L,2L ++ ++#define SN_brainpoolP192r1 "brainpoolP192r1" ++#define NID_brainpoolP192r1 923 ++#define OBJ_brainpoolP192r1 1L,3L,36L,3L,3L,2L,8L,1L,1L,3L ++ ++#define SN_brainpoolP192t1 "brainpoolP192t1" ++#define NID_brainpoolP192t1 924 ++#define OBJ_brainpoolP192t1 1L,3L,36L,3L,3L,2L,8L,1L,1L,4L ++ ++#define SN_brainpoolP224r1 "brainpoolP224r1" ++#define NID_brainpoolP224r1 925 ++#define OBJ_brainpoolP224r1 1L,3L,36L,3L,3L,2L,8L,1L,1L,5L ++ ++#define SN_brainpoolP224t1 "brainpoolP224t1" ++#define NID_brainpoolP224t1 926 ++#define OBJ_brainpoolP224t1 1L,3L,36L,3L,3L,2L,8L,1L,1L,6L ++ ++#define SN_brainpoolP256r1 "brainpoolP256r1" ++#define NID_brainpoolP256r1 927 ++#define OBJ_brainpoolP256r1 1L,3L,36L,3L,3L,2L,8L,1L,1L,7L ++ ++#define SN_brainpoolP256t1 "brainpoolP256t1" ++#define NID_brainpoolP256t1 928 ++#define OBJ_brainpoolP256t1 1L,3L,36L,3L,3L,2L,8L,1L,1L,8L ++ ++#define SN_brainpoolP320r1 "brainpoolP320r1" ++#define NID_brainpoolP320r1 929 ++#define OBJ_brainpoolP320r1 1L,3L,36L,3L,3L,2L,8L,1L,1L,9L ++ ++#define SN_brainpoolP320t1 "brainpoolP320t1" ++#define NID_brainpoolP320t1 930 ++#define OBJ_brainpoolP320t1 1L,3L,36L,3L,3L,2L,8L,1L,1L,10L ++ ++#define SN_brainpoolP384r1 "brainpoolP384r1" ++#define NID_brainpoolP384r1 931 ++#define OBJ_brainpoolP384r1 1L,3L,36L,3L,3L,2L,8L,1L,1L,11L ++ ++#define SN_brainpoolP384t1 "brainpoolP384t1" ++#define NID_brainpoolP384t1 932 ++#define OBJ_brainpoolP384t1 1L,3L,36L,3L,3L,2L,8L,1L,1L,12L ++ ++#define SN_brainpoolP512r1 "brainpoolP512r1" ++#define NID_brainpoolP512r1 933 ++#define OBJ_brainpoolP512r1 1L,3L,36L,3L,3L,2L,8L,1L,1L,13L ++ ++#define SN_brainpoolP512t1 "brainpoolP512t1" ++#define NID_brainpoolP512t1 934 ++#define OBJ_brainpoolP512t1 1L,3L,36L,3L,3L,2L,8L,1L,1L,14L ++ ++#define OBJ_x9_63_scheme 1L,3L,133L,16L,840L,63L,0L ++ ++#define OBJ_secg_scheme OBJ_certicom_arc,1L ++ ++#define SN_dhSinglePass_stdDH_sha1kdf_scheme "dhSinglePass-stdDH-sha1kdf-scheme" ++#define NID_dhSinglePass_stdDH_sha1kdf_scheme 936 ++#define OBJ_dhSinglePass_stdDH_sha1kdf_scheme OBJ_x9_63_scheme,2L ++ ++#define SN_dhSinglePass_stdDH_sha224kdf_scheme "dhSinglePass-stdDH-sha224kdf-scheme" ++#define NID_dhSinglePass_stdDH_sha224kdf_scheme 937 ++#define OBJ_dhSinglePass_stdDH_sha224kdf_scheme OBJ_secg_scheme,11L,0L ++ ++#define SN_dhSinglePass_stdDH_sha256kdf_scheme "dhSinglePass-stdDH-sha256kdf-scheme" ++#define NID_dhSinglePass_stdDH_sha256kdf_scheme 938 ++#define OBJ_dhSinglePass_stdDH_sha256kdf_scheme OBJ_secg_scheme,11L,1L ++ ++#define SN_dhSinglePass_stdDH_sha384kdf_scheme "dhSinglePass-stdDH-sha384kdf-scheme" ++#define NID_dhSinglePass_stdDH_sha384kdf_scheme 939 ++#define OBJ_dhSinglePass_stdDH_sha384kdf_scheme OBJ_secg_scheme,11L,2L ++ ++#define SN_dhSinglePass_stdDH_sha512kdf_scheme "dhSinglePass-stdDH-sha512kdf-scheme" ++#define NID_dhSinglePass_stdDH_sha512kdf_scheme 940 ++#define OBJ_dhSinglePass_stdDH_sha512kdf_scheme OBJ_secg_scheme,11L,3L ++ ++#define SN_dhSinglePass_cofactorDH_sha1kdf_scheme "dhSinglePass-cofactorDH-sha1kdf-scheme" ++#define NID_dhSinglePass_cofactorDH_sha1kdf_scheme 941 ++#define OBJ_dhSinglePass_cofactorDH_sha1kdf_scheme OBJ_x9_63_scheme,3L ++ ++#define SN_dhSinglePass_cofactorDH_sha224kdf_scheme "dhSinglePass-cofactorDH-sha224kdf-scheme" ++#define NID_dhSinglePass_cofactorDH_sha224kdf_scheme 942 ++#define OBJ_dhSinglePass_cofactorDH_sha224kdf_scheme OBJ_secg_scheme,14L,0L ++ ++#define SN_dhSinglePass_cofactorDH_sha256kdf_scheme "dhSinglePass-cofactorDH-sha256kdf-scheme" ++#define NID_dhSinglePass_cofactorDH_sha256kdf_scheme 943 ++#define OBJ_dhSinglePass_cofactorDH_sha256kdf_scheme OBJ_secg_scheme,14L,1L ++ ++#define SN_dhSinglePass_cofactorDH_sha384kdf_scheme "dhSinglePass-cofactorDH-sha384kdf-scheme" ++#define NID_dhSinglePass_cofactorDH_sha384kdf_scheme 944 ++#define OBJ_dhSinglePass_cofactorDH_sha384kdf_scheme OBJ_secg_scheme,14L,2L ++ ++#define SN_dhSinglePass_cofactorDH_sha512kdf_scheme "dhSinglePass-cofactorDH-sha512kdf-scheme" ++#define NID_dhSinglePass_cofactorDH_sha512kdf_scheme 945 ++#define OBJ_dhSinglePass_cofactorDH_sha512kdf_scheme OBJ_secg_scheme,14L,3L ++ ++#define SN_dh_std_kdf "dh-std-kdf" ++#define NID_dh_std_kdf 946 ++ ++#define SN_dh_cofactor_kdf "dh-cofactor-kdf" ++#define NID_dh_cofactor_kdf 947 ++ ++#define SN_ct_precert_scts "ct_precert_scts" ++#define LN_ct_precert_scts "CT Precertificate SCTs" ++#define NID_ct_precert_scts 951 ++#define OBJ_ct_precert_scts 1L,3L,6L,1L,4L,1L,11129L,2L,4L,2L ++ ++#define SN_ct_precert_poison "ct_precert_poison" ++#define LN_ct_precert_poison "CT Precertificate Poison" ++#define NID_ct_precert_poison 952 ++#define OBJ_ct_precert_poison 1L,3L,6L,1L,4L,1L,11129L,2L,4L,3L ++ ++#define SN_ct_precert_signer "ct_precert_signer" ++#define LN_ct_precert_signer "CT Precertificate Signer" ++#define NID_ct_precert_signer 953 ++#define OBJ_ct_precert_signer 1L,3L,6L,1L,4L,1L,11129L,2L,4L,4L ++ ++#define SN_ct_cert_scts "ct_cert_scts" ++#define LN_ct_cert_scts "CT Certificate SCTs" ++#define NID_ct_cert_scts 954 ++#define OBJ_ct_cert_scts 1L,3L,6L,1L,4L,1L,11129L,2L,4L,5L ++ ++#define SN_jurisdictionLocalityName "jurisdictionL" ++#define LN_jurisdictionLocalityName "jurisdictionLocalityName" ++#define NID_jurisdictionLocalityName 955 ++#define OBJ_jurisdictionLocalityName 1L,3L,6L,1L,4L,1L,311L,60L,2L,1L,1L ++ ++#define SN_jurisdictionStateOrProvinceName "jurisdictionST" ++#define LN_jurisdictionStateOrProvinceName "jurisdictionStateOrProvinceName" ++#define NID_jurisdictionStateOrProvinceName 956 ++#define OBJ_jurisdictionStateOrProvinceName 1L,3L,6L,1L,4L,1L,311L,60L,2L,1L,2L ++ ++#define SN_jurisdictionCountryName "jurisdictionC" ++#define LN_jurisdictionCountryName "jurisdictionCountryName" ++#define NID_jurisdictionCountryName 957 ++#define OBJ_jurisdictionCountryName 1L,3L,6L,1L,4L,1L,311L,60L,2L,1L,3L ++ ++#define SN_id_scrypt "id-scrypt" ++#define LN_id_scrypt "scrypt" ++#define NID_id_scrypt 973 ++#define OBJ_id_scrypt 1L,3L,6L,1L,4L,1L,11591L,4L,11L ++ ++#define SN_tls1_prf "TLS1-PRF" ++#define LN_tls1_prf "tls1-prf" ++#define NID_tls1_prf 1021 ++ ++#define SN_hkdf "HKDF" ++#define LN_hkdf "hkdf" ++#define NID_hkdf 1036 ++ ++#define SN_id_pkinit "id-pkinit" ++#define NID_id_pkinit 1031 ++#define OBJ_id_pkinit 1L,3L,6L,1L,5L,2L,3L ++ ++#define SN_pkInitClientAuth "pkInitClientAuth" ++#define LN_pkInitClientAuth "PKINIT Client Auth" ++#define NID_pkInitClientAuth 1032 ++#define OBJ_pkInitClientAuth OBJ_id_pkinit,4L ++ ++#define SN_pkInitKDC "pkInitKDC" ++#define LN_pkInitKDC "Signing KDC Response" ++#define NID_pkInitKDC 1033 ++#define OBJ_pkInitKDC OBJ_id_pkinit,5L ++ ++#define SN_X25519 "X25519" ++#define NID_X25519 1034 ++#define OBJ_X25519 1L,3L,101L,110L ++ ++#define SN_X448 "X448" ++#define NID_X448 1035 ++#define OBJ_X448 1L,3L,101L,111L ++ ++#define SN_ED25519 "ED25519" ++#define NID_ED25519 1087 ++#define OBJ_ED25519 1L,3L,101L,112L ++ ++#define SN_ED448 "ED448" ++#define NID_ED448 1088 ++#define OBJ_ED448 1L,3L,101L,113L ++ ++#define SN_kx_rsa "KxRSA" ++#define LN_kx_rsa "kx-rsa" ++#define NID_kx_rsa 1037 ++ ++#define SN_kx_ecdhe "KxECDHE" ++#define LN_kx_ecdhe "kx-ecdhe" ++#define NID_kx_ecdhe 1038 ++ ++#define SN_kx_dhe "KxDHE" ++#define LN_kx_dhe "kx-dhe" ++#define NID_kx_dhe 1039 ++ ++#define SN_kx_ecdhe_psk "KxECDHE-PSK" ++#define LN_kx_ecdhe_psk "kx-ecdhe-psk" ++#define NID_kx_ecdhe_psk 1040 ++ ++#define SN_kx_dhe_psk "KxDHE-PSK" ++#define LN_kx_dhe_psk "kx-dhe-psk" ++#define NID_kx_dhe_psk 1041 ++ ++#define SN_kx_rsa_psk "KxRSA_PSK" ++#define LN_kx_rsa_psk "kx-rsa-psk" ++#define NID_kx_rsa_psk 1042 ++ ++#define SN_kx_psk "KxPSK" ++#define LN_kx_psk "kx-psk" ++#define NID_kx_psk 1043 ++ ++#define SN_kx_srp "KxSRP" ++#define LN_kx_srp "kx-srp" ++#define NID_kx_srp 1044 ++ ++#define SN_kx_gost "KxGOST" ++#define LN_kx_gost "kx-gost" ++#define NID_kx_gost 1045 ++ ++#define SN_kx_any "KxANY" ++#define LN_kx_any "kx-any" ++#define NID_kx_any 1063 ++ ++#define SN_auth_rsa "AuthRSA" ++#define LN_auth_rsa "auth-rsa" ++#define NID_auth_rsa 1046 ++ ++#define SN_auth_ecdsa "AuthECDSA" ++#define LN_auth_ecdsa "auth-ecdsa" ++#define NID_auth_ecdsa 1047 ++ ++#define SN_auth_psk "AuthPSK" ++#define LN_auth_psk "auth-psk" ++#define NID_auth_psk 1048 ++ ++#define SN_auth_dss "AuthDSS" ++#define LN_auth_dss "auth-dss" ++#define NID_auth_dss 1049 ++ ++#define SN_auth_gost01 "AuthGOST01" ++#define LN_auth_gost01 "auth-gost01" ++#define NID_auth_gost01 1050 ++ ++#define SN_auth_gost12 "AuthGOST12" ++#define LN_auth_gost12 "auth-gost12" ++#define NID_auth_gost12 1051 ++ ++#define SN_auth_srp "AuthSRP" ++#define LN_auth_srp "auth-srp" ++#define NID_auth_srp 1052 ++ ++#define SN_auth_null "AuthNULL" ++#define LN_auth_null "auth-null" ++#define NID_auth_null 1053 ++ ++#define SN_auth_any "AuthANY" ++#define LN_auth_any "auth-any" ++#define NID_auth_any 1064 ++ ++#define SN_poly1305 "Poly1305" ++#define LN_poly1305 "poly1305" ++#define NID_poly1305 1061 ++ ++#define SN_siphash "SipHash" ++#define LN_siphash "siphash" ++#define NID_siphash 1062 ++ ++#define SN_ffdhe2048 "ffdhe2048" ++#define NID_ffdhe2048 1126 ++ ++#define SN_ffdhe3072 "ffdhe3072" ++#define NID_ffdhe3072 1127 ++ ++#define SN_ffdhe4096 "ffdhe4096" ++#define NID_ffdhe4096 1128 ++ ++#define SN_ffdhe6144 "ffdhe6144" ++#define NID_ffdhe6144 1129 ++ ++#define SN_ffdhe8192 "ffdhe8192" ++#define NID_ffdhe8192 1130 ++ ++#define SN_kyber512 "kyber512" ++#define LN_kyber512 "kyber512" ++#define NID_kyber512 1216 ++ ++#define SN_x25519_kyber512 "x25519_kyber512" ++#define LN_x25519_kyber512 "x25519_kyber512" ++#define NID_x25519_kyber512 1217 ++ ++#define SN_ISO_UA "ISO-UA" ++#define NID_ISO_UA 1150 ++#define OBJ_ISO_UA OBJ_member_body,804L ++ ++#define SN_ua_pki "ua-pki" ++#define NID_ua_pki 1151 ++#define OBJ_ua_pki OBJ_ISO_UA,2L,1L,1L,1L ++ ++#define SN_dstu28147 "dstu28147" ++#define LN_dstu28147 "DSTU Gost 28147-2009" ++#define NID_dstu28147 1152 ++#define OBJ_dstu28147 OBJ_ua_pki,1L,1L,1L ++ ++#define SN_dstu28147_ofb "dstu28147-ofb" ++#define LN_dstu28147_ofb "DSTU Gost 28147-2009 OFB mode" ++#define NID_dstu28147_ofb 1153 ++#define OBJ_dstu28147_ofb OBJ_dstu28147,2L ++ ++#define SN_dstu28147_cfb "dstu28147-cfb" ++#define LN_dstu28147_cfb "DSTU Gost 28147-2009 CFB mode" ++#define NID_dstu28147_cfb 1154 ++#define OBJ_dstu28147_cfb OBJ_dstu28147,3L ++ ++#define SN_dstu28147_wrap "dstu28147-wrap" ++#define LN_dstu28147_wrap "DSTU Gost 28147-2009 key wrap" ++#define NID_dstu28147_wrap 1155 ++#define OBJ_dstu28147_wrap OBJ_dstu28147,5L ++ ++#define SN_hmacWithDstu34311 "hmacWithDstu34311" ++#define LN_hmacWithDstu34311 "HMAC DSTU Gost 34311-95" ++#define NID_hmacWithDstu34311 1156 ++#define OBJ_hmacWithDstu34311 OBJ_ua_pki,1L,1L,2L ++ ++#define SN_dstu34311 "dstu34311" ++#define LN_dstu34311 "DSTU Gost 34311-95" ++#define NID_dstu34311 1157 ++#define OBJ_dstu34311 OBJ_ua_pki,1L,2L,1L ++ ++#define SN_dstu4145le "dstu4145le" ++#define LN_dstu4145le "DSTU 4145-2002 little endian" ++#define NID_dstu4145le 1158 ++#define OBJ_dstu4145le OBJ_ua_pki,1L,3L,1L,1L ++ ++#define SN_dstu4145be "dstu4145be" ++#define LN_dstu4145be "DSTU 4145-2002 big endian" ++#define NID_dstu4145be 1159 ++#define OBJ_dstu4145be OBJ_dstu4145le,1L,1L ++ ++#define SN_uacurve0 "uacurve0" ++#define LN_uacurve0 "DSTU curve 0" ++#define NID_uacurve0 1160 ++#define OBJ_uacurve0 OBJ_dstu4145le,2L,0L ++ ++#define SN_uacurve1 "uacurve1" ++#define LN_uacurve1 "DSTU curve 1" ++#define NID_uacurve1 1161 ++#define OBJ_uacurve1 OBJ_dstu4145le,2L,1L ++ ++#define SN_uacurve2 "uacurve2" ++#define LN_uacurve2 "DSTU curve 2" ++#define NID_uacurve2 1162 ++#define OBJ_uacurve2 OBJ_dstu4145le,2L,2L ++ ++#define SN_uacurve3 "uacurve3" ++#define LN_uacurve3 "DSTU curve 3" ++#define NID_uacurve3 1163 ++#define OBJ_uacurve3 OBJ_dstu4145le,2L,3L ++ ++#define SN_uacurve4 "uacurve4" ++#define LN_uacurve4 "DSTU curve 4" ++#define NID_uacurve4 1164 ++#define OBJ_uacurve4 OBJ_dstu4145le,2L,4L ++ ++#define SN_uacurve5 "uacurve5" ++#define LN_uacurve5 "DSTU curve 5" ++#define NID_uacurve5 1165 ++#define OBJ_uacurve5 OBJ_dstu4145le,2L,5L ++ ++#define SN_uacurve6 "uacurve6" ++#define LN_uacurve6 "DSTU curve 6" ++#define NID_uacurve6 1166 ++#define OBJ_uacurve6 OBJ_dstu4145le,2L,6L ++ ++#define SN_uacurve7 "uacurve7" ++#define LN_uacurve7 "DSTU curve 7" ++#define NID_uacurve7 1167 ++#define OBJ_uacurve7 OBJ_dstu4145le,2L,7L ++ ++#define SN_uacurve8 "uacurve8" ++#define LN_uacurve8 "DSTU curve 8" ++#define NID_uacurve8 1168 ++#define OBJ_uacurve8 OBJ_dstu4145le,2L,8L ++ ++#define SN_uacurve9 "uacurve9" ++#define LN_uacurve9 "DSTU curve 9" ++#define NID_uacurve9 1169 ++#define OBJ_uacurve9 OBJ_dstu4145le,2L,9L +diff --git a/include/TA/openssl/openssl/objects.h b/include/TA/openssl/openssl/objects.h +new file mode 100644 +index 0000000..611895f +--- /dev/null ++++ b/include/TA/openssl/openssl/objects.h +@@ -0,0 +1,173 @@ ++/* ++ * Copyright 1995-2018 The OpenSSL Project Authors. All Rights Reserved. ++ * ++ * Licensed under the OpenSSL license (the "License"). You may not use ++ * this file except in compliance with the License. You can obtain a copy ++ * in the file LICENSE in the source distribution or at ++ * https://www.openssl.org/source/license.html ++ */ ++ ++#ifndef HEADER_OBJECTS_H ++# define HEADER_OBJECTS_H ++ ++# include ++# include ++# include ++# include ++ ++# define OBJ_NAME_TYPE_UNDEF 0x00 ++# define OBJ_NAME_TYPE_MD_METH 0x01 ++# define OBJ_NAME_TYPE_CIPHER_METH 0x02 ++# define OBJ_NAME_TYPE_PKEY_METH 0x03 ++# define OBJ_NAME_TYPE_COMP_METH 0x04 ++# define OBJ_NAME_TYPE_NUM 0x05 ++ ++# define OBJ_NAME_ALIAS 0x8000 ++ ++# define OBJ_BSEARCH_VALUE_ON_NOMATCH 0x01 ++# define OBJ_BSEARCH_FIRST_VALUE_ON_MATCH 0x02 ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++typedef struct obj_name_st { ++ int type; ++ int alias; ++ const char *name; ++ const char *data; ++} OBJ_NAME; ++ ++# define OBJ_create_and_add_object(a,b,c) OBJ_create(a,b,c) ++ ++int OBJ_NAME_init(void); ++int OBJ_NAME_new_index(unsigned long (*hash_func) (const char *), ++ int (*cmp_func) (const char *, const char *), ++ void (*free_func) (const char *, int, const char *)); ++const char *OBJ_NAME_get(const char *name, int type); ++int OBJ_NAME_add(const char *name, int type, const char *data); ++int OBJ_NAME_remove(const char *name, int type); ++void OBJ_NAME_cleanup(int type); /* -1 for everything */ ++void OBJ_NAME_do_all(int type, void (*fn) (const OBJ_NAME *, void *arg), ++ void *arg); ++void OBJ_NAME_do_all_sorted(int type, ++ void (*fn) (const OBJ_NAME *, void *arg), ++ void *arg); ++ ++ASN1_OBJECT *OBJ_dup(const ASN1_OBJECT *o); ++ASN1_OBJECT *OBJ_nid2obj(int n); ++const char *OBJ_nid2ln(int n); ++const char *OBJ_nid2sn(int n); ++int OBJ_obj2nid(const ASN1_OBJECT *o); ++ASN1_OBJECT *OBJ_txt2obj(const char *s, int no_name); ++int OBJ_obj2txt(char *buf, int buf_len, const ASN1_OBJECT *a, int no_name); ++int OBJ_txt2nid(const char *s); ++int OBJ_ln2nid(const char *s); ++int OBJ_sn2nid(const char *s); ++int OBJ_cmp(const ASN1_OBJECT *a, const ASN1_OBJECT *b); ++const void *OBJ_bsearch_(const void *key, const void *base, int num, int size, ++ int (*cmp) (const void *, const void *)); ++const void *OBJ_bsearch_ex_(const void *key, const void *base, int num, ++ int size, ++ int (*cmp) (const void *, const void *), ++ int flags); ++ ++# define _DECLARE_OBJ_BSEARCH_CMP_FN(scope, type1, type2, nm) \ ++ static int nm##_cmp_BSEARCH_CMP_FN(const void *, const void *); \ ++ static int nm##_cmp(type1 const *, type2 const *); \ ++ scope type2 * OBJ_bsearch_##nm(type1 *key, type2 const *base, int num) ++ ++# define DECLARE_OBJ_BSEARCH_CMP_FN(type1, type2, cmp) \ ++ _DECLARE_OBJ_BSEARCH_CMP_FN(static, type1, type2, cmp) ++# define DECLARE_OBJ_BSEARCH_GLOBAL_CMP_FN(type1, type2, nm) \ ++ type2 * OBJ_bsearch_##nm(type1 *key, type2 const *base, int num) ++ ++/*- ++ * Unsolved problem: if a type is actually a pointer type, like ++ * nid_triple is, then its impossible to get a const where you need ++ * it. Consider: ++ * ++ * typedef int nid_triple[3]; ++ * const void *a_; ++ * const nid_triple const *a = a_; ++ * ++ * The assignment discards a const because what you really want is: ++ * ++ * const int const * const *a = a_; ++ * ++ * But if you do that, you lose the fact that a is an array of 3 ints, ++ * which breaks comparison functions. ++ * ++ * Thus we end up having to cast, sadly, or unpack the ++ * declarations. Or, as I finally did in this case, declare nid_triple ++ * to be a struct, which it should have been in the first place. ++ * ++ * Ben, August 2008. ++ * ++ * Also, strictly speaking not all types need be const, but handling ++ * the non-constness means a lot of complication, and in practice ++ * comparison routines do always not touch their arguments. ++ */ ++ ++# define IMPLEMENT_OBJ_BSEARCH_CMP_FN(type1, type2, nm) \ ++ static int nm##_cmp_BSEARCH_CMP_FN(const void *a_, const void *b_) \ ++ { \ ++ type1 const *a = a_; \ ++ type2 const *b = b_; \ ++ return nm##_cmp(a,b); \ ++ } \ ++ static type2 *OBJ_bsearch_##nm(type1 *key, type2 const *base, int num) \ ++ { \ ++ return (type2 *)OBJ_bsearch_(key, base, num, sizeof(type2), \ ++ nm##_cmp_BSEARCH_CMP_FN); \ ++ } \ ++ extern void dummy_prototype(void) ++ ++# define IMPLEMENT_OBJ_BSEARCH_GLOBAL_CMP_FN(type1, type2, nm) \ ++ static int nm##_cmp_BSEARCH_CMP_FN(const void *a_, const void *b_) \ ++ { \ ++ type1 const *a = a_; \ ++ type2 const *b = b_; \ ++ return nm##_cmp(a,b); \ ++ } \ ++ type2 *OBJ_bsearch_##nm(type1 *key, type2 const *base, int num) \ ++ { \ ++ return (type2 *)OBJ_bsearch_(key, base, num, sizeof(type2), \ ++ nm##_cmp_BSEARCH_CMP_FN); \ ++ } \ ++ extern void dummy_prototype(void) ++ ++# define OBJ_bsearch(type1,key,type2,base,num,cmp) \ ++ ((type2 *)OBJ_bsearch_(CHECKED_PTR_OF(type1,key),CHECKED_PTR_OF(type2,base), \ ++ num,sizeof(type2), \ ++ ((void)CHECKED_PTR_OF(type1,cmp##_type_1), \ ++ (void)CHECKED_PTR_OF(type2,cmp##_type_2), \ ++ cmp##_BSEARCH_CMP_FN))) ++ ++# define OBJ_bsearch_ex(type1,key,type2,base,num,cmp,flags) \ ++ ((type2 *)OBJ_bsearch_ex_(CHECKED_PTR_OF(type1,key),CHECKED_PTR_OF(type2,base), \ ++ num,sizeof(type2), \ ++ ((void)CHECKED_PTR_OF(type1,cmp##_type_1), \ ++ (void)type_2=CHECKED_PTR_OF(type2,cmp##_type_2), \ ++ cmp##_BSEARCH_CMP_FN)),flags) ++ ++int OBJ_new_nid(int num); ++int OBJ_add_object(const ASN1_OBJECT *obj); ++int OBJ_create(const char *oid, const char *sn, const char *ln); ++#if OPENSSL_API_COMPAT < 0x10100000L ++# define OBJ_cleanup() while(0) continue ++#endif ++int OBJ_create_objects(BIO *in); ++ ++size_t OBJ_length(const ASN1_OBJECT *obj); ++const unsigned char *OBJ_get0_data(const ASN1_OBJECT *obj); ++ ++int OBJ_find_sigid_algs(int signid, int *pdig_nid, int *ppkey_nid); ++int OBJ_find_sigid_by_algs(int *psignid, int dig_nid, int pkey_nid); ++int OBJ_add_sigid(int signid, int dig_id, int pkey_id); ++void OBJ_sigid_free(void); ++ ++# ifdef __cplusplus ++} ++# endif ++#endif +diff --git a/include/TA/openssl/openssl/objectserr.h b/include/TA/openssl/openssl/objectserr.h +new file mode 100644 +index 0000000..02e166f +--- /dev/null ++++ b/include/TA/openssl/openssl/objectserr.h +@@ -0,0 +1,42 @@ ++/* ++ * Generated by util/mkerr.pl DO NOT EDIT ++ * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. ++ * ++ * Licensed under the OpenSSL license (the "License"). You may not use ++ * this file except in compliance with the License. You can obtain a copy ++ * in the file LICENSE in the source distribution or at ++ * https://www.openssl.org/source/license.html ++ */ ++ ++#ifndef HEADER_OBJERR_H ++# define HEADER_OBJERR_H ++ ++# ifndef HEADER_SYMHACKS_H ++# include ++# endif ++ ++# ifdef __cplusplus ++extern "C" ++# endif ++int ERR_load_OBJ_strings(void); ++ ++/* ++ * OBJ function codes. ++ */ ++# define OBJ_F_OBJ_ADD_OBJECT 105 ++# define OBJ_F_OBJ_ADD_SIGID 107 ++# define OBJ_F_OBJ_CREATE 100 ++# define OBJ_F_OBJ_DUP 101 ++# define OBJ_F_OBJ_NAME_NEW_INDEX 106 ++# define OBJ_F_OBJ_NID2LN 102 ++# define OBJ_F_OBJ_NID2OBJ 103 ++# define OBJ_F_OBJ_NID2SN 104 ++# define OBJ_F_OBJ_TXT2OBJ 108 ++ ++/* ++ * OBJ reason codes. ++ */ ++# define OBJ_R_OID_EXISTS 102 ++# define OBJ_R_UNKNOWN_NID 101 ++ ++#endif +diff --git a/include/TA/openssl/openssl/opensslconf.h b/include/TA/openssl/openssl/opensslconf.h +new file mode 100644 +index 0000000..c16743b +--- /dev/null ++++ b/include/TA/openssl/openssl/opensslconf.h +@@ -0,0 +1,365 @@ ++/* ++ * Copyright (c) Huawei Technologies Co., Ltd. 2022-2022. All rights reserved. ++ * iTrustee licensed under the Mulan PSL v2. ++ * You can use this software according to the terms and conditions of the Mulan PSL v2. ++ * You may obtain a copy of Mulan PSL v2 at: ++ * http://license.coscl.org.cn/MulanPSL2 ++ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR ++ * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR ++ * PURPOSE. ++ * See the Mulan PSL v2 for more details. ++ * Description: TEE openssl conf. ++ */ ++ ++#ifndef __TEE_OPENSSLCONF_H ++#define __TEE_OPENSSLCONF_H ++ ++#include ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++#define __NEED_ssize_t ++ ++#ifdef OPENSSL_ALGORITHM_DEFINES ++# error OPENSSL_ALGORITHM_DEFINES no longer supported ++#endif ++ ++/* ++ * OpenSSL was configured with the following options: ++ */ ++ ++#ifdef linux ++# undef linux ++#endif ++#ifdef __linux__ ++# undef __linux__ ++#endif ++#ifndef OPENSSL_NO_PKCS12 ++# define OPENSSL_NO_PKCS12 ++#endif ++#ifndef OPENSSL_NO_SM2_ENVELOP ++# define OPENSSL_NO_SM2_ENVELOP ++#endif ++#ifndef OPENSSL_NO_GMSM ++# define OPENSSL_NO_GMSM ++#endif ++#ifndef OPENSSL_NO_GMTLS ++# define OPENSSL_NO_GMTLS ++#endif ++#ifndef OPENSSL_NO_PKCS7_SM2 ++# define OPENSSL_NO_PKCS7_SM2 ++#endif ++#ifndef OPENSSL_NO_PKCS8_SM2 ++# define OPENSSL_NO_PKCS8_SM2 ++#endif ++#ifndef OPENSSL_NO_CMS_SM2 ++# define OPENSSL_NO_CMS_SM2 ++#endif ++#ifndef OPENSSL_NO_SM9 ++# define OPENSSL_NO_SM9 ++#endif ++#ifndef OPENSSL_NO_SM4_XTS ++# define OPENSSL_NO_SM4_XTS ++#endif ++#ifndef OPENSSL_NO_PQCHYBRID ++# define OPENSSL_NO_PQCHYBRID ++#endif ++#ifndef OPENSSL_NO_PQC ++# define OPENSSL_NO_PQC ++#endif ++#ifndef OPENSSL_NO_WAPI ++# define OPENSSL_NO_WAPI ++#endif ++#ifndef OPENSSL_NO_CRL_MEMPOOL ++# define OPENSSL_NO_CRL_MEMPOOL ++#endif ++#ifndef OPENSSL_NO_X509_REQ_EXP_ATTR ++# define OPENSSL_NO_X509_REQ_EXP_ATTR ++#endif ++#ifndef OPENSSL_NO_NDCPP ++# define OPENSSL_NO_NDCPP ++#endif ++#ifndef OPENSSL_NO_FIPS ++# define OPENSSL_NO_FIPS ++#endif ++#ifndef CONFIG_CRYPTO_ISO19790_MODE ++#ifndef OPENSSL_NO_CMVP ++# define OPENSSL_NO_CMVP ++#endif ++#endif ++#ifndef OPENSSL_RAND_SEED_HWENG ++# define OPENSSL_RAND_SEED_HWENG ++#endif ++#ifndef OPENSSL_NO_MD2 ++# define OPENSSL_NO_MD2 ++#endif ++#ifndef OPENSSL_NO_RC5 ++# define OPENSSL_NO_RC5 ++#endif ++#ifndef OPENSSL_NO_ASAN ++# define OPENSSL_NO_ASAN ++#endif ++#ifndef OPENSSL_NO_CRYPTO_MDEBUG ++# define OPENSSL_NO_CRYPTO_MDEBUG ++#endif ++#ifndef OPENSSL_NO_CRYPTO_MDEBUG_BACKTRACE ++# define OPENSSL_NO_CRYPTO_MDEBUG_BACKTRACE ++#endif ++#ifndef OPENSSL_NO_DEVCRYPTOENG ++# define OPENSSL_NO_DEVCRYPTOENG ++#endif ++#ifndef OPENSSL_NO_EC_NISTP_64_GCC_128 ++# define OPENSSL_NO_EC_NISTP_64_GCC_128 ++#endif ++#ifndef OPENSSL_NO_EGD ++# define OPENSSL_NO_EGD ++#endif ++#ifndef OPENSSL_NO_EXTERNAL_TESTS ++# define OPENSSL_NO_EXTERNAL_TESTS ++#endif ++#ifndef OPENSSL_NO_FUZZ_AFL ++# define OPENSSL_NO_FUZZ_AFL ++#endif ++#ifndef OPENSSL_NO_FUZZ_LIBFUZZER ++# define OPENSSL_NO_FUZZ_LIBFUZZER ++#endif ++#ifndef OPENSSL_NO_HEARTBEATS ++# define OPENSSL_NO_HEARTBEATS ++#endif ++#ifndef OPENSSL_NO_MSAN ++# define OPENSSL_NO_MSAN ++#endif ++#ifndef OPENSSL_NO_SCTP ++# define OPENSSL_NO_SCTP ++#endif ++#ifndef OPENSSL_NO_SSL_TRACE ++# define OPENSSL_NO_SSL_TRACE ++#endif ++#ifndef OPENSSL_NO_SSL3 ++# define OPENSSL_NO_SSL3 ++#endif ++#ifndef OPENSSL_NO_SSL3_METHOD ++# define OPENSSL_NO_SSL3_METHOD ++#endif ++#ifndef OPENSSL_NO_UBSAN ++# define OPENSSL_NO_UBSAN ++#endif ++#ifndef OPENSSL_NO_UNIT_TEST ++# define OPENSSL_NO_UNIT_TEST ++#endif ++#ifndef OPENSSL_NO_WEAK_SSL_CIPHERS ++# define OPENSSL_NO_WEAK_SSL_CIPHERS ++#endif ++#ifndef OPENSSL_NO_STATIC_ENGINE ++# define OPENSSL_NO_STATIC_ENGINE ++#endif ++ ++/* ++ * Sometimes OPENSSSL_NO_xxx ends up with an empty file and some compilers ++ * don't like that. This will hopefully silence them. ++ */ ++#define NON_EMPTY_TRANSLATION_UNIT static void *dummy = &dummy; ++ ++/* ++ * Applications should use -DOPENSSL_API_COMPAT= to suppress the ++ * declarations of functions deprecated in or before . Otherwise, they ++ * still won't see them if the library has been built to disable deprecated ++ * functions. ++ */ ++#ifndef DECLARE_DEPRECATED ++# define DECLARE_DEPRECATED(f) f; ++#endif ++ ++#ifndef OPENSSL_FILE ++# ifdef OPENSSL_NO_FILENAMES ++# define OPENSSL_FILE "" ++# define OPENSSL_LINE 0 ++# else ++# define OPENSSL_FILE __FILE__ ++# define OPENSSL_LINE __LINE__ ++# endif ++#endif ++ ++#ifndef OPENSSL_MIN_API ++# define OPENSSL_MIN_API 0 ++#endif ++ ++#if !defined(OPENSSL_API_COMPAT) || OPENSSL_API_COMPAT < OPENSSL_MIN_API ++# undef OPENSSL_API_COMPAT ++# define OPENSSL_API_COMPAT OPENSSL_MIN_API ++#endif ++ ++/* ++ * Do not deprecate things to be deprecated in version 1.2.0 before the ++ * OpenSSL version number matches. ++ */ ++#if OPENSSL_VERSION_NUMBER < 0x10200000L ++# define DEPRECATEDIN_1_2_0(f) f; ++#elif OPENSSL_API_COMPAT < 0x10200000L ++# define DEPRECATEDIN_1_2_0(f) DECLARE_DEPRECATED(f) ++#else ++# define DEPRECATEDIN_1_2_0(f) f; ++#endif ++ ++#if OPENSSL_API_COMPAT < 0x10100000L ++# define DEPRECATEDIN_1_1_0(f) DECLARE_DEPRECATED(f) ++#else ++# define DEPRECATEDIN_1_1_0(f) ++#endif ++ ++#if OPENSSL_API_COMPAT < 0x10000000L ++# define DEPRECATEDIN_1_0_0(f) DECLARE_DEPRECATED(f) ++#else ++# define DEPRECATEDIN_1_0_0(f) ++#endif ++ ++#if OPENSSL_API_COMPAT < 0x00908000L ++# define DEPRECATEDIN_0_9_8(f) DECLARE_DEPRECATED(f) ++#else ++# define DEPRECATEDIN_0_9_8(f) ++#endif ++ ++/* Generate 80386 code? */ ++#undef I386_ONLY ++ ++#undef OPENSSL_UNISTD ++#define OPENSSL_UNISTD ++ ++#undef OPENSSL_EXPORT_VAR_AS_FUNCTION ++ ++/* ++ * The following are cipher-specific, but are part of the public API. ++ */ ++# if defined(__arm) || defined(__arm__) ++# define THIRTY_TWO_BIT ++# undef SIXTY_FOUR_BIT_LONG ++# undef SIXTY_FOUR_BIT ++# elif defined(__aarch64__) ++# undef SIXTY_FOUR_BIT_LONG ++# undef THIRTY_TWO_BIT ++# define SIXTY_FOUR_BIT ++# endif ++#define RC4_INT unsigned int ++ ++#ifndef __STDC_NO_ATOMICS__ ++# define __STDC_NO_ATOMICS__ ++#endif ++#ifndef OPENSSL_NO_ENGINE ++# define OPENSSL_NO_ENGINE ++#endif ++#ifndef OPENSSL_NO_POLY1305 ++# define OPENSSL_NO_POLY1305 ++#endif ++#ifndef OPENSSL_NO_DSA ++# define OPENSSL_NO_DSA ++#endif ++#ifndef OPENSSL_NO_SCRYPT ++# define OPENSSL_NO_SCRYPT ++#endif ++#ifndef OPENSSL_NO_SIPHASH ++# define OPENSSL_NO_SIPHASH ++#endif ++#ifndef OPENSSL_NO_CAMELLIA ++# define OPENSSL_NO_CAMELLIA ++#endif ++#ifndef OPENSSL_NO_CHACHA ++# define OPENSSL_NO_CHACHA ++#endif ++#ifndef OPENSSL_NO_RC4 ++# define OPENSSL_NO_RC4 ++#endif ++#ifndef OPENSSL_NO_MD4 ++# define OPENSSL_NO_MD4 ++#endif ++#ifndef OPENSSL_NO_IDEA ++# define OPENSSL_NO_IDEA ++#endif ++#ifndef OPENSSL_NO_RC2 ++# define OPENSSL_NO_RC2 ++#endif ++#ifndef OPENSSL_NO_BF ++# define OPENSSL_NO_BF ++#endif ++#ifndef OPENSSL_NO_CAST ++# define OPENSSL_NO_CAST ++#endif ++#ifndef OPENSSL_NO_MDC2 ++# define OPENSSL_NO_MDC2 ++#endif ++#ifndef OPENSSL_NO_RMD160 ++# define OPENSSL_NO_RMD160 ++#endif ++#ifndef OPENSSL_NO_WHIRLPOOL ++# define OPENSSL_NO_WHIRLPOOL ++#endif ++#ifndef OPENSSL_USE_NODELETE ++# define OPENSSL_USE_NODELETE ++#endif ++#ifndef OPENSSL_NO_COMP ++# define OPENSSL_NO_COMP ++#endif ++#ifndef OPENSSL_NO_TS ++# define OPENSSL_NO_TS ++#endif ++#ifndef OPENSSL_NO_OCSP ++# define OPENSSL_NO_OCSP ++#endif ++#ifndef OPENSSL_NO_POSIX_IO ++# define OPENSSL_NO_POSIX_IO ++#endif ++#ifndef OPENSSL_NO_STDIO ++# define OPENSSL_NO_STDIO ++#endif ++#ifndef OPENSSL_NO_CT ++# define OPENSSL_NO_CT ++#endif ++#ifndef CONFIG_OPENSSL_NO_ASM ++#ifndef SHA1_ASM ++# define SHA1_ASM ++#endif ++#ifndef SHA256_ASM ++# define SHA256_ASM ++#endif ++#ifndef SHA512_ASM ++# define SHA512_ASM ++#endif ++#ifndef ECP_NISTZ256_ASM ++# define ECP_NISTZ256_ASM ++#endif ++#ifndef OPENSSL_BN_ASM_MONT ++# define OPENSSL_BN_ASM_MONT ++#endif ++#endif ++#ifndef OPENSSL_NO_CMS ++# define OPENSSL_NO_CMS ++#endif ++#ifndef OPENSSL_NO_ERR ++# define OPENSSL_NO_ERR ++#endif ++#ifndef OPENSSL_NO_BLAKE2 ++# define OPENSSL_NO_BLAKE2 ++#endif ++#ifndef OPENSSL_NO_ARIA ++# define OPENSSL_NO_ARIA ++#endif ++#ifndef OPENSSL_NO_SEED ++# define OPENSSL_NO_SEED ++#endif ++#ifndef OPENSSL_NO_DGRAM ++# define OPENSSL_NO_DGRAM ++#endif ++#ifndef OPENSSL_NO_SOCK ++# define OPENSSL_NO_SOCK ++#endif ++#ifndef OPENSSL_NO_OCB ++# define OPENSSL_NO_OCB ++#endif ++#ifndef OPENSSL_NO_DH ++# define OPENSSL_NO_DH ++#endif ++ ++#ifdef __cplusplus ++} ++#endif ++#endif +diff --git a/include/TA/openssl/openssl/opensslv.h b/include/TA/openssl/openssl/opensslv.h +new file mode 100644 +index 0000000..2b107a8 +--- /dev/null ++++ b/include/TA/openssl/openssl/opensslv.h +@@ -0,0 +1,100 @@ ++/* ++ * Copyright 1999-2021 The OpenSSL Project Authors. All Rights Reserved. ++ * ++ * Licensed under the OpenSSL license (the "License"). You may not use ++ * this file except in compliance with the License. You can obtain a copy ++ * in the file LICENSE in the source distribution or at ++ * https://www.openssl.org/source/license.html ++ */ ++ ++#ifndef HEADER_OPENSSLV_H ++# define HEADER_OPENSSLV_H ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++/*- ++ * Numeric release version identifier: ++ * MNNFFPPS: major minor fix patch status ++ * The status nibble has one of the values 0 for development, 1 to e for betas ++ * 1 to 14, and f for release. The patch level is exactly that. ++ * For example: ++ * 0.9.3-dev 0x00903000 ++ * 0.9.3-beta1 0x00903001 ++ * 0.9.3-beta2-dev 0x00903002 ++ * 0.9.3-beta2 0x00903002 (same as ...beta2-dev) ++ * 0.9.3 0x0090300f ++ * 0.9.3a 0x0090301f ++ * 0.9.4 0x0090400f ++ * 1.2.3z 0x102031af ++ * ++ * For continuity reasons (because 0.9.5 is already out, and is coded ++ * 0x00905100), between 0.9.5 and 0.9.6 the coding of the patch level ++ * part is slightly different, by setting the highest bit. This means ++ * that 0.9.5a looks like this: 0x0090581f. At 0.9.6, we can start ++ * with 0x0090600S... ++ * ++ * (Prior to 0.9.3-dev a different scheme was used: 0.9.2b is 0x0922.) ++ * (Prior to 0.9.5a beta1, a different scheme was used: MMNNFFRBB for ++ * major minor fix final patch/beta) ++ */ ++# define OPENSSL_VERSION_NUMBER 0x101010efL ++# define OPENSSL_VERSION_TEXT "OpenSSL 1.1.1n 15 Mar 2022" ++ ++/*- ++ * The macros below are to be used for shared library (.so, .dll, ...) ++ * versioning. That kind of versioning works a bit differently between ++ * operating systems. The most usual scheme is to set a major and a minor ++ * number, and have the runtime loader check that the major number is equal ++ * to what it was at application link time, while the minor number has to ++ * be greater or equal to what it was at application link time. With this ++ * scheme, the version number is usually part of the file name, like this: ++ * ++ * libcrypto.so.0.9 ++ * ++ * Some unixen also make a softlink with the major version number only: ++ * ++ * libcrypto.so.0 ++ * ++ * On Tru64 and IRIX 6.x it works a little bit differently. There, the ++ * shared library version is stored in the file, and is actually a series ++ * of versions, separated by colons. The rightmost version present in the ++ * library when linking an application is stored in the application to be ++ * matched at run time. When the application is run, a check is done to ++ * see if the library version stored in the application matches any of the ++ * versions in the version string of the library itself. ++ * This version string can be constructed in any way, depending on what ++ * kind of matching is desired. However, to implement the same scheme as ++ * the one used in the other unixen, all compatible versions, from lowest ++ * to highest, should be part of the string. Consecutive builds would ++ * give the following versions strings: ++ * ++ * 3.0 ++ * 3.0:3.1 ++ * 3.0:3.1:3.2 ++ * 4.0 ++ * 4.0:4.1 ++ * ++ * Notice how version 4 is completely incompatible with version, and ++ * therefore give the breach you can see. ++ * ++ * There may be other schemes as well that I haven't yet discovered. ++ * ++ * So, here's the way it works here: first of all, the library version ++ * number doesn't need at all to match the overall OpenSSL version. ++ * However, it's nice and more understandable if it actually does. ++ * The current library version is stored in the macro SHLIB_VERSION_NUMBER, ++ * which is just a piece of text in the format "M.m.e" (Major, minor, edit). ++ * For the sake of Tru64, IRIX, and any other OS that behaves in similar ways, ++ * we need to keep a history of version numbers, which is done in the ++ * macro SHLIB_VERSION_HISTORY. The numbers are separated by colons and ++ * should only keep the versions that are binary compatible with the current. ++ */ ++# define SHLIB_VERSION_HISTORY "" ++# define SHLIB_VERSION_NUMBER "1.1" ++ ++#ifdef __cplusplus ++} ++#endif ++#endif /* HEADER_OPENSSLV_H */ +diff --git a/include/TA/openssl/openssl/ossl_typ.h b/include/TA/openssl/openssl/ossl_typ.h +new file mode 100644 +index 0000000..fa54d67 +--- /dev/null ++++ b/include/TA/openssl/openssl/ossl_typ.h +@@ -0,0 +1,200 @@ ++/* ++ * Copyright 2001-2018 The OpenSSL Project Authors. All Rights Reserved. ++ * ++ * Licensed under the OpenSSL license (the "License"). You may not use ++ * this file except in compliance with the License. You can obtain a copy ++ * in the file LICENSE in the source distribution or at ++ * https://www.openssl.org/source/license.html ++ */ ++ ++#ifndef HEADER_OPENSSL_TYPES_H ++# define HEADER_OPENSSL_TYPES_H ++ ++#include ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++# include ++ ++# ifdef NO_ASN1_TYPEDEFS ++# define ASN1_INTEGER ASN1_STRING ++# define ASN1_ENUMERATED ASN1_STRING ++# define ASN1_BIT_STRING ASN1_STRING ++# define ASN1_OCTET_STRING ASN1_STRING ++# define ASN1_PRINTABLESTRING ASN1_STRING ++# define ASN1_T61STRING ASN1_STRING ++# define ASN1_IA5STRING ASN1_STRING ++# define ASN1_UTCTIME ASN1_STRING ++# define ASN1_GENERALIZEDTIME ASN1_STRING ++# define ASN1_TIME ASN1_STRING ++# define ASN1_GENERALSTRING ASN1_STRING ++# define ASN1_UNIVERSALSTRING ASN1_STRING ++# define ASN1_BMPSTRING ASN1_STRING ++# define ASN1_VISIBLESTRING ASN1_STRING ++# define ASN1_UTF8STRING ASN1_STRING ++# define ASN1_BOOLEAN int ++# define ASN1_NULL int ++# else ++typedef struct asn1_string_st ASN1_INTEGER; ++typedef struct asn1_string_st ASN1_ENUMERATED; ++typedef struct asn1_string_st ASN1_BIT_STRING; ++typedef struct asn1_string_st ASN1_OCTET_STRING; ++typedef struct asn1_string_st ASN1_PRINTABLESTRING; ++typedef struct asn1_string_st ASN1_T61STRING; ++typedef struct asn1_string_st ASN1_IA5STRING; ++typedef struct asn1_string_st ASN1_GENERALSTRING; ++typedef struct asn1_string_st ASN1_UNIVERSALSTRING; ++typedef struct asn1_string_st ASN1_BMPSTRING; ++typedef struct asn1_string_st ASN1_UTCTIME; ++typedef struct asn1_string_st ASN1_TIME; ++typedef struct asn1_string_st ASN1_GENERALIZEDTIME; ++typedef struct asn1_string_st ASN1_VISIBLESTRING; ++typedef struct asn1_string_st ASN1_UTF8STRING; ++typedef struct asn1_string_st ASN1_STRING; ++typedef int ASN1_BOOLEAN; ++typedef int ASN1_NULL; ++# endif ++ ++typedef struct asn1_object_st ASN1_OBJECT; ++ ++typedef struct ASN1_ITEM_st ASN1_ITEM; ++typedef struct asn1_pctx_st ASN1_PCTX; ++typedef struct asn1_sctx_st ASN1_SCTX; ++ ++# ifdef _WIN32 ++# undef X509_NAME ++# undef X509_EXTENSIONS ++# undef PKCS7_ISSUER_AND_SERIAL ++# undef PKCS7_SIGNER_INFO ++# undef OCSP_REQUEST ++# undef OCSP_RESPONSE ++# endif ++ ++# ifdef BIGNUM ++# undef BIGNUM ++# endif ++struct dane_st; ++typedef struct bio_st BIO; ++typedef struct bignum_st BIGNUM; ++typedef struct bignum_ctx BN_CTX; ++typedef struct bn_blinding_st BN_BLINDING; ++typedef struct bn_mont_ctx_st BN_MONT_CTX; ++typedef struct bn_recp_ctx_st BN_RECP_CTX; ++typedef struct bn_gencb_st BN_GENCB; ++ ++typedef struct buf_mem_st BUF_MEM; ++ ++typedef struct evp_cipher_st EVP_CIPHER; ++typedef struct evp_cipher_ctx_st EVP_CIPHER_CTX; ++typedef struct evp_md_st EVP_MD; ++typedef struct evp_md_ctx_st EVP_MD_CTX; ++typedef struct evp_pkey_st EVP_PKEY; ++ ++typedef struct evp_pkey_asn1_method_st EVP_PKEY_ASN1_METHOD; ++ ++typedef struct evp_pkey_method_st EVP_PKEY_METHOD; ++typedef struct evp_pkey_ctx_st EVP_PKEY_CTX; ++#ifndef OPENSSL_NO_GMSM ++typedef struct sm2_derive_param_st SM2_DERIVE_PARAM; ++#endif ++ ++typedef struct evp_Encode_Ctx_st EVP_ENCODE_CTX; ++ ++typedef struct hmac_ctx_st HMAC_CTX; ++ ++typedef struct dh_st DH; ++typedef struct dh_method DH_METHOD; ++ ++typedef struct dsa_st DSA; ++typedef struct dsa_method DSA_METHOD; ++ ++typedef struct rsa_st RSA; ++typedef struct rsa_meth_st RSA_METHOD; ++typedef struct rsa_pss_params_st RSA_PSS_PARAMS; ++ ++typedef struct ec_key_st EC_KEY; ++typedef struct ec_key_method_st EC_KEY_METHOD; ++ ++typedef struct rand_meth_st RAND_METHOD; ++typedef struct rand_drbg_st RAND_DRBG; ++ ++typedef struct ssl_dane_st SSL_DANE; ++typedef struct x509_st X509; ++typedef struct X509_algor_st X509_ALGOR; ++typedef struct X509_crl_st X509_CRL; ++typedef struct x509_crl_method_st X509_CRL_METHOD; ++typedef struct x509_revoked_st X509_REVOKED; ++typedef struct X509_name_st X509_NAME; ++typedef struct X509_pubkey_st X509_PUBKEY; ++typedef struct x509_store_st X509_STORE; ++typedef struct x509_store_ctx_st X509_STORE_CTX; ++ ++typedef struct x509_object_st X509_OBJECT; ++typedef struct x509_lookup_st X509_LOOKUP; ++typedef struct x509_lookup_method_st X509_LOOKUP_METHOD; ++typedef struct X509_VERIFY_PARAM_st X509_VERIFY_PARAM; ++ ++typedef struct x509_sig_info_st X509_SIG_INFO; ++ ++typedef struct pkcs8_priv_key_info_st PKCS8_PRIV_KEY_INFO; ++ ++typedef struct v3_ext_ctx X509V3_CTX; ++typedef struct conf_st CONF; ++typedef struct ossl_init_settings_st OPENSSL_INIT_SETTINGS; ++ ++typedef struct ui_st UI; ++typedef struct ui_method_st UI_METHOD; ++ ++typedef struct engine_st ENGINE; ++typedef struct ssl_st SSL; ++typedef struct ssl_ctx_st SSL_CTX; ++ ++typedef struct comp_ctx_st COMP_CTX; ++typedef struct comp_method_st COMP_METHOD; ++ ++typedef struct X509_POLICY_NODE_st X509_POLICY_NODE; ++typedef struct X509_POLICY_LEVEL_st X509_POLICY_LEVEL; ++typedef struct X509_POLICY_TREE_st X509_POLICY_TREE; ++typedef struct X509_POLICY_CACHE_st X509_POLICY_CACHE; ++ ++typedef struct AUTHORITY_KEYID_st AUTHORITY_KEYID; ++typedef struct DIST_POINT_st DIST_POINT; ++typedef struct ISSUING_DIST_POINT_st ISSUING_DIST_POINT; ++typedef struct NAME_CONSTRAINTS_st NAME_CONSTRAINTS; ++ ++typedef struct crypto_ex_data_st CRYPTO_EX_DATA; ++ ++typedef struct ocsp_req_ctx_st OCSP_REQ_CTX; ++typedef struct ocsp_response_st OCSP_RESPONSE; ++typedef struct ocsp_responder_id_st OCSP_RESPID; ++ ++typedef struct sct_st SCT; ++typedef struct sct_ctx_st SCT_CTX; ++typedef struct ctlog_st CTLOG; ++typedef struct ctlog_store_st CTLOG_STORE; ++typedef struct ct_policy_eval_ctx_st CT_POLICY_EVAL_CTX; ++ ++typedef struct ossl_store_info_st OSSL_STORE_INFO; ++typedef struct ossl_store_search_st OSSL_STORE_SEARCH; ++ ++#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L && \ ++ defined(INTMAX_MAX) && defined(UINTMAX_MAX) ++typedef intmax_t ossl_intmax_t; ++typedef uintmax_t ossl_uintmax_t; ++#else ++/* ++ * Not long long, because the C-library can only be expected to provide ++ * strtoll(), strtoull() at the same time as intmax_t and strtoimax(), ++ * strtoumax(). Since we use these for parsing arguments, we need the ++ * conversion functions, not just the sizes. ++ */ ++typedef long ossl_intmax_t; ++typedef unsigned long ossl_uintmax_t; ++#endif ++ ++#ifdef __cplusplus ++} ++#endif ++#endif /* def HEADER_OPENSSL_TYPES_H */ +diff --git a/include/TA/openssl/openssl/pem.h b/include/TA/openssl/openssl/pem.h +new file mode 100644 +index 0000000..a187bea +--- /dev/null ++++ b/include/TA/openssl/openssl/pem.h +@@ -0,0 +1,389 @@ ++/* ++ * Copyright 1995-2018 The OpenSSL Project Authors. All Rights Reserved. ++ * ++ * Licensed under the OpenSSL license (the "License"). You may not use ++ * this file except in compliance with the License. You can obtain a copy ++ * in the file LICENSE in the source distribution or at ++ * https://www.openssl.org/source/license.html ++ */ ++ ++#ifndef HEADER_PEM_H ++# define HEADER_PEM_H ++ ++# include ++# include ++# include ++# include ++# include ++# include ++# ifndef OPENSSL_NO_SM2_ENVELOP ++# include ++# endif ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++# define PEM_BUFSIZE 1024 ++ ++# define PEM_STRING_X509_OLD "X509 CERTIFICATE" ++# define PEM_STRING_X509 "CERTIFICATE" ++# define PEM_STRING_X509_TRUSTED "TRUSTED CERTIFICATE" ++# define PEM_STRING_X509_REQ_OLD "NEW CERTIFICATE REQUEST" ++# define PEM_STRING_X509_REQ "CERTIFICATE REQUEST" ++# define PEM_STRING_X509_CRL "X509 CRL" ++# define PEM_STRING_EVP_PKEY "ANY PRIVATE KEY" ++# define PEM_STRING_PUBLIC "PUBLIC KEY" ++# define PEM_STRING_RSA "RSA PRIVATE KEY" ++# define PEM_STRING_RSA_PUBLIC "RSA PUBLIC KEY" ++# define PEM_STRING_DSA "DSA PRIVATE KEY" ++# define PEM_STRING_DSA_PUBLIC "DSA PUBLIC KEY" ++# define PEM_STRING_PKCS7 "PKCS7" ++# define PEM_STRING_PKCS7_SIGNED "PKCS #7 SIGNED DATA" ++# define PEM_STRING_PKCS8 "ENCRYPTED PRIVATE KEY" ++# define PEM_STRING_PKCS8INF "PRIVATE KEY" ++# define PEM_STRING_DHPARAMS "DH PARAMETERS" ++# define PEM_STRING_DHXPARAMS "X9.42 DH PARAMETERS" ++# define PEM_STRING_SSL_SESSION "SSL SESSION PARAMETERS" ++# define PEM_STRING_DSAPARAMS "DSA PARAMETERS" ++# define PEM_STRING_ECDSA_PUBLIC "ECDSA PUBLIC KEY" ++# define PEM_STRING_ECPARAMETERS "EC PARAMETERS" ++# define PEM_STRING_ECPRIVATEKEY "EC PRIVATE KEY" ++# define PEM_STRING_PARAMETERS "PARAMETERS" ++# define PEM_STRING_CMS "CMS" ++# ifndef OPENSSL_NO_SM2_ENVELOP ++# define PEM_STRING_SM2_ENVELOPED_KEY "SM2 ENVELOPED KEY" ++# endif ++ ++# define PEM_TYPE_ENCRYPTED 10 ++# define PEM_TYPE_MIC_ONLY 20 ++# define PEM_TYPE_MIC_CLEAR 30 ++# define PEM_TYPE_CLEAR 40 ++ ++/* ++ * These macros make the PEM_read/PEM_write functions easier to maintain and ++ * write. Now they are all implemented with either: IMPLEMENT_PEM_rw(...) or ++ * IMPLEMENT_PEM_rw_cb(...) ++ */ ++ ++# ifdef OPENSSL_NO_STDIO ++ ++# define IMPLEMENT_PEM_read_fp(name, type, str, asn1) /**/ ++# define IMPLEMENT_PEM_write_fp(name, type, str, asn1) /**/ ++# define IMPLEMENT_PEM_write_fp_const(name, type, str, asn1) /**/ ++# define IMPLEMENT_PEM_write_cb_fp(name, type, str, asn1) /**/ ++# define IMPLEMENT_PEM_write_cb_fp_const(name, type, str, asn1) /**/ ++# else ++ ++# define IMPLEMENT_PEM_read_fp(name, type, str, asn1) \ ++type *PEM_read_##name(FILE *fp, type **x, pem_password_cb *cb, void *u)\ ++{ \ ++return PEM_ASN1_read((d2i_of_void *)d2i_##asn1, str,fp,(void **)x,cb,u); \ ++} ++ ++# define IMPLEMENT_PEM_write_fp(name, type, str, asn1) \ ++int PEM_write_##name(FILE *fp, type *x) \ ++{ \ ++return PEM_ASN1_write((i2d_of_void *)i2d_##asn1,str,fp,x,NULL,NULL,0,NULL,NULL); \ ++} ++ ++# define IMPLEMENT_PEM_write_fp_const(name, type, str, asn1) \ ++int PEM_write_##name(FILE *fp, const type *x) \ ++{ \ ++return PEM_ASN1_write((i2d_of_void *)i2d_##asn1,str,fp,(void *)x,NULL,NULL,0,NULL,NULL); \ ++} ++ ++# define IMPLEMENT_PEM_write_cb_fp(name, type, str, asn1) \ ++int PEM_write_##name(FILE *fp, type *x, const EVP_CIPHER *enc, \ ++ unsigned char *kstr, int klen, pem_password_cb *cb, \ ++ void *u) \ ++ { \ ++ return PEM_ASN1_write((i2d_of_void *)i2d_##asn1,str,fp,x,enc,kstr,klen,cb,u); \ ++ } ++ ++# define IMPLEMENT_PEM_write_cb_fp_const(name, type, str, asn1) \ ++int PEM_write_##name(FILE *fp, type *x, const EVP_CIPHER *enc, \ ++ unsigned char *kstr, int klen, pem_password_cb *cb, \ ++ void *u) \ ++ { \ ++ return PEM_ASN1_write((i2d_of_void *)i2d_##asn1,str,fp,x,enc,kstr,klen,cb,u); \ ++ } ++ ++# endif ++ ++# define IMPLEMENT_PEM_read_bio(name, type, str, asn1) \ ++type *PEM_read_bio_##name(BIO *bp, type **x, pem_password_cb *cb, void *u)\ ++{ \ ++return PEM_ASN1_read_bio((d2i_of_void *)d2i_##asn1, str,bp,(void **)x,cb,u); \ ++} ++ ++# define IMPLEMENT_PEM_write_bio(name, type, str, asn1) \ ++int PEM_write_bio_##name(BIO *bp, type *x) \ ++{ \ ++return PEM_ASN1_write_bio((i2d_of_void *)i2d_##asn1,str,bp,x,NULL,NULL,0,NULL,NULL); \ ++} ++ ++# define IMPLEMENT_PEM_write_bio_const(name, type, str, asn1) \ ++int PEM_write_bio_##name(BIO *bp, const type *x) \ ++{ \ ++return PEM_ASN1_write_bio((i2d_of_void *)i2d_##asn1,str,bp,(void *)x,NULL,NULL,0,NULL,NULL); \ ++} ++ ++# define IMPLEMENT_PEM_write_cb_bio(name, type, str, asn1) \ ++int PEM_write_bio_##name(BIO *bp, type *x, const EVP_CIPHER *enc, \ ++ unsigned char *kstr, int klen, pem_password_cb *cb, void *u) \ ++ { \ ++ return PEM_ASN1_write_bio((i2d_of_void *)i2d_##asn1,str,bp,x,enc,kstr,klen,cb,u); \ ++ } ++ ++# define IMPLEMENT_PEM_write_cb_bio_const(name, type, str, asn1) \ ++int PEM_write_bio_##name(BIO *bp, type *x, const EVP_CIPHER *enc, \ ++ unsigned char *kstr, int klen, pem_password_cb *cb, void *u) \ ++ { \ ++ return PEM_ASN1_write_bio((i2d_of_void *)i2d_##asn1,str,bp,(void *)x,enc,kstr,klen,cb,u); \ ++ } ++ ++# define IMPLEMENT_PEM_write(name, type, str, asn1) \ ++ IMPLEMENT_PEM_write_bio(name, type, str, asn1) \ ++ IMPLEMENT_PEM_write_fp(name, type, str, asn1) ++ ++# define IMPLEMENT_PEM_write_const(name, type, str, asn1) \ ++ IMPLEMENT_PEM_write_bio_const(name, type, str, asn1) \ ++ IMPLEMENT_PEM_write_fp_const(name, type, str, asn1) ++ ++# define IMPLEMENT_PEM_write_cb(name, type, str, asn1) \ ++ IMPLEMENT_PEM_write_cb_bio(name, type, str, asn1) \ ++ IMPLEMENT_PEM_write_cb_fp(name, type, str, asn1) ++ ++# define IMPLEMENT_PEM_write_cb_const(name, type, str, asn1) \ ++ IMPLEMENT_PEM_write_cb_bio_const(name, type, str, asn1) \ ++ IMPLEMENT_PEM_write_cb_fp_const(name, type, str, asn1) ++ ++# define IMPLEMENT_PEM_read(name, type, str, asn1) \ ++ IMPLEMENT_PEM_read_bio(name, type, str, asn1) \ ++ IMPLEMENT_PEM_read_fp(name, type, str, asn1) ++ ++# define IMPLEMENT_PEM_rw(name, type, str, asn1) \ ++ IMPLEMENT_PEM_read(name, type, str, asn1) \ ++ IMPLEMENT_PEM_write(name, type, str, asn1) ++ ++# define IMPLEMENT_PEM_rw_const(name, type, str, asn1) \ ++ IMPLEMENT_PEM_read(name, type, str, asn1) \ ++ IMPLEMENT_PEM_write_const(name, type, str, asn1) ++ ++# define IMPLEMENT_PEM_rw_cb(name, type, str, asn1) \ ++ IMPLEMENT_PEM_read(name, type, str, asn1) \ ++ IMPLEMENT_PEM_write_cb(name, type, str, asn1) ++ ++/* These are the same except they are for the declarations */ ++ ++# if defined(OPENSSL_NO_STDIO) ++ ++# define DECLARE_PEM_read_fp(name, type) /**/ ++# define DECLARE_PEM_write_fp(name, type) /**/ ++# define DECLARE_PEM_write_fp_const(name, type) /**/ ++# define DECLARE_PEM_write_cb_fp(name, type) /**/ ++# else ++ ++# define DECLARE_PEM_read_fp(name, type) \ ++ type *PEM_read_##name(FILE *fp, type **x, pem_password_cb *cb, void *u); ++ ++# define DECLARE_PEM_write_fp(name, type) \ ++ int PEM_write_##name(FILE *fp, type *x); ++ ++# define DECLARE_PEM_write_fp_const(name, type) \ ++ int PEM_write_##name(FILE *fp, const type *x); ++ ++# define DECLARE_PEM_write_cb_fp(name, type) \ ++ int PEM_write_##name(FILE *fp, type *x, const EVP_CIPHER *enc, \ ++ unsigned char *kstr, int klen, pem_password_cb *cb, void *u); ++ ++# endif ++ ++# define DECLARE_PEM_read_bio(name, type) \ ++ type *PEM_read_bio_##name(BIO *bp, type **x, pem_password_cb *cb, void *u); ++ ++# define DECLARE_PEM_write_bio(name, type) \ ++ int PEM_write_bio_##name(BIO *bp, type *x); ++ ++# define DECLARE_PEM_write_bio_const(name, type) \ ++ int PEM_write_bio_##name(BIO *bp, const type *x); ++ ++# define DECLARE_PEM_write_cb_bio(name, type) \ ++ int PEM_write_bio_##name(BIO *bp, type *x, const EVP_CIPHER *enc, \ ++ unsigned char *kstr, int klen, pem_password_cb *cb, void *u); ++ ++# define DECLARE_PEM_write(name, type) \ ++ DECLARE_PEM_write_bio(name, type) \ ++ DECLARE_PEM_write_fp(name, type) ++# define DECLARE_PEM_write_const(name, type) \ ++ DECLARE_PEM_write_bio_const(name, type) \ ++ DECLARE_PEM_write_fp_const(name, type) ++# define DECLARE_PEM_write_cb(name, type) \ ++ DECLARE_PEM_write_cb_bio(name, type) \ ++ DECLARE_PEM_write_cb_fp(name, type) ++# define DECLARE_PEM_read(name, type) \ ++ DECLARE_PEM_read_bio(name, type) \ ++ DECLARE_PEM_read_fp(name, type) ++# define DECLARE_PEM_rw(name, type) \ ++ DECLARE_PEM_read(name, type) \ ++ DECLARE_PEM_write(name, type) ++# define DECLARE_PEM_rw_const(name, type) \ ++ DECLARE_PEM_read(name, type) \ ++ DECLARE_PEM_write_const(name, type) ++# define DECLARE_PEM_rw_cb(name, type) \ ++ DECLARE_PEM_read(name, type) \ ++ DECLARE_PEM_write_cb(name, type) ++typedef int pem_password_cb (char *buf, int size, int rwflag, void *userdata); ++ ++int PEM_get_EVP_CIPHER_INFO(char *header, EVP_CIPHER_INFO *cipher); ++int PEM_do_header(EVP_CIPHER_INFO *cipher, unsigned char *data, long *len, ++ pem_password_cb *callback, void *u); ++ ++int PEM_read_bio(BIO *bp, char **name, char **header, ++ unsigned char **data, long *len); ++# define PEM_FLAG_SECURE 0x1 ++# define PEM_FLAG_EAY_COMPATIBLE 0x2 ++# define PEM_FLAG_ONLY_B64 0x4 ++int PEM_read_bio_ex(BIO *bp, char **name, char **header, ++ unsigned char **data, long *len, unsigned int flags); ++int PEM_bytes_read_bio_secmem(unsigned char **pdata, long *plen, char **pnm, ++ const char *name, BIO *bp, pem_password_cb *cb, ++ void *u); ++int PEM_write_bio(BIO *bp, const char *name, const char *hdr, ++ const unsigned char *data, long len); ++int PEM_bytes_read_bio(unsigned char **pdata, long *plen, char **pnm, ++ const char *name, BIO *bp, pem_password_cb *cb, ++ void *u); ++void *PEM_ASN1_read_bio(d2i_of_void *d2i, const char *name, BIO *bp, void **x, ++ pem_password_cb *cb, void *u); ++int PEM_ASN1_write_bio(i2d_of_void *i2d, const char *name, BIO *bp, void *x, ++ const EVP_CIPHER *enc, unsigned char *kstr, int klen, ++ pem_password_cb *cb, void *u); ++ ++STACK_OF(X509_INFO) *PEM_X509_INFO_read_bio(BIO *bp, STACK_OF(X509_INFO) *sk, ++ pem_password_cb *cb, void *u); ++int PEM_X509_INFO_write_bio(BIO *bp, X509_INFO *xi, EVP_CIPHER *enc, ++ unsigned char *kstr, int klen, ++ pem_password_cb *cd, void *u); ++ ++#ifndef OPENSSL_NO_STDIO ++int PEM_read(FILE *fp, char **name, char **header, ++ unsigned char **data, long *len); ++int PEM_write(FILE *fp, const char *name, const char *hdr, ++ const unsigned char *data, long len); ++void *PEM_ASN1_read(d2i_of_void *d2i, const char *name, FILE *fp, void **x, ++ pem_password_cb *cb, void *u); ++int PEM_ASN1_write(i2d_of_void *i2d, const char *name, FILE *fp, ++ void *x, const EVP_CIPHER *enc, unsigned char *kstr, ++ int klen, pem_password_cb *callback, void *u); ++STACK_OF(X509_INFO) *PEM_X509_INFO_read(FILE *fp, STACK_OF(X509_INFO) *sk, ++ pem_password_cb *cb, void *u); ++#endif ++ ++int PEM_SignInit(EVP_MD_CTX *ctx, EVP_MD *type); ++int PEM_SignUpdate(EVP_MD_CTX *ctx, unsigned char *d, unsigned int cnt); ++int PEM_SignFinal(EVP_MD_CTX *ctx, unsigned char *sigret, ++ unsigned int *siglen, EVP_PKEY *pkey); ++ ++/* The default pem_password_cb that's used internally */ ++int PEM_def_callback(char *buf, int num, int rwflag, void *userdata); ++void PEM_proc_type(char *buf, int type); ++void PEM_dek_info(char *buf, const char *type, int len, char *str); ++ ++# include ++ ++DECLARE_PEM_rw(X509, X509) ++DECLARE_PEM_rw(X509_AUX, X509) ++DECLARE_PEM_rw(X509_REQ, X509_REQ) ++DECLARE_PEM_write(X509_REQ_NEW, X509_REQ) ++DECLARE_PEM_rw(X509_CRL, X509_CRL) ++DECLARE_PEM_rw(PKCS7, PKCS7) ++DECLARE_PEM_rw(NETSCAPE_CERT_SEQUENCE, NETSCAPE_CERT_SEQUENCE) ++DECLARE_PEM_rw(PKCS8, X509_SIG) ++DECLARE_PEM_rw(PKCS8_PRIV_KEY_INFO, PKCS8_PRIV_KEY_INFO) ++# ifndef OPENSSL_NO_RSA ++DECLARE_PEM_rw_cb(RSAPrivateKey, RSA) ++DECLARE_PEM_rw_const(RSAPublicKey, RSA) ++DECLARE_PEM_rw(RSA_PUBKEY, RSA) ++# endif ++# ifndef OPENSSL_NO_DSA ++DECLARE_PEM_rw_cb(DSAPrivateKey, DSA) ++DECLARE_PEM_rw(DSA_PUBKEY, DSA) ++DECLARE_PEM_rw_const(DSAparams, DSA) ++# endif ++# ifndef OPENSSL_NO_EC ++DECLARE_PEM_rw_const(ECPKParameters, EC_GROUP) ++DECLARE_PEM_rw_cb(ECPrivateKey, EC_KEY) ++DECLARE_PEM_rw(EC_PUBKEY, EC_KEY) ++# endif ++# ifndef OPENSSL_NO_DH ++DECLARE_PEM_rw_const(DHparams, DH) ++DECLARE_PEM_write_const(DHxparams, DH) ++# endif ++DECLARE_PEM_rw_cb(PrivateKey, EVP_PKEY) ++DECLARE_PEM_rw(PUBKEY, EVP_PKEY) ++ ++int PEM_write_bio_PrivateKey_traditional(BIO *bp, EVP_PKEY *x, ++ const EVP_CIPHER *enc, ++ unsigned char *kstr, int klen, ++ pem_password_cb *cb, void *u); ++ ++int PEM_write_bio_PKCS8PrivateKey_nid(BIO *bp, EVP_PKEY *x, int nid, ++ char *kstr, int klen, ++ pem_password_cb *cb, void *u); ++int PEM_write_bio_PKCS8PrivateKey(BIO *, EVP_PKEY *, const EVP_CIPHER *, ++ char *, int, pem_password_cb *, void *); ++int i2d_PKCS8PrivateKey_bio(BIO *bp, EVP_PKEY *x, const EVP_CIPHER *enc, ++ char *kstr, int klen, ++ pem_password_cb *cb, void *u); ++int i2d_PKCS8PrivateKey_nid_bio(BIO *bp, EVP_PKEY *x, int nid, ++ char *kstr, int klen, ++ pem_password_cb *cb, void *u); ++EVP_PKEY *d2i_PKCS8PrivateKey_bio(BIO *bp, EVP_PKEY **x, pem_password_cb *cb, ++ void *u); ++ ++# ifndef OPENSSL_NO_STDIO ++int i2d_PKCS8PrivateKey_fp(FILE *fp, EVP_PKEY *x, const EVP_CIPHER *enc, ++ char *kstr, int klen, ++ pem_password_cb *cb, void *u); ++int i2d_PKCS8PrivateKey_nid_fp(FILE *fp, EVP_PKEY *x, int nid, ++ char *kstr, int klen, ++ pem_password_cb *cb, void *u); ++int PEM_write_PKCS8PrivateKey_nid(FILE *fp, EVP_PKEY *x, int nid, ++ char *kstr, int klen, ++ pem_password_cb *cb, void *u); ++ ++EVP_PKEY *d2i_PKCS8PrivateKey_fp(FILE *fp, EVP_PKEY **x, pem_password_cb *cb, ++ void *u); ++ ++int PEM_write_PKCS8PrivateKey(FILE *fp, EVP_PKEY *x, const EVP_CIPHER *enc, ++ char *kstr, int klen, pem_password_cb *cd, ++ void *u); ++# endif ++EVP_PKEY *PEM_read_bio_Parameters(BIO *bp, EVP_PKEY **x); ++int PEM_write_bio_Parameters(BIO *bp, EVP_PKEY *x); ++ ++# ifndef OPENSSL_NO_DSA ++EVP_PKEY *b2i_PrivateKey(const unsigned char **in, long length); ++EVP_PKEY *b2i_PublicKey(const unsigned char **in, long length); ++EVP_PKEY *b2i_PrivateKey_bio(BIO *in); ++EVP_PKEY *b2i_PublicKey_bio(BIO *in); ++int i2b_PrivateKey_bio(BIO *out, EVP_PKEY *pk); ++int i2b_PublicKey_bio(BIO *out, EVP_PKEY *pk); ++# ifndef OPENSSL_NO_RC4 ++EVP_PKEY *b2i_PVK_bio(BIO *in, pem_password_cb *cb, void *u); ++int i2b_PVK_bio(BIO *out, EVP_PKEY *pk, int enclevel, ++ pem_password_cb *cb, void *u); ++# endif ++# endif ++# ifndef OPENSSL_NO_SM2_ENVELOP ++DECLARE_PEM_rw(SM2_ENVELOPED_KEY, SM2_ENVELOPED_KEY) ++SM2_ENVELOPED_KEY *d2i_SM2_ENVELOPED_KEY_bio(BIO *bp, SM2_ENVELOPED_KEY **sm2evpkey); ++int i2d_SM2_ENVELOPED_KEY_bio(BIO *bp, SM2_ENVELOPED_KEY *sm2evpkey); ++# endif ++ ++# ifdef __cplusplus ++} ++# endif ++#endif +diff --git a/include/TA/openssl/openssl/pemerr.h b/include/TA/openssl/openssl/pemerr.h +new file mode 100644 +index 0000000..4f7e357 +--- /dev/null ++++ b/include/TA/openssl/openssl/pemerr.h +@@ -0,0 +1,105 @@ ++/* ++ * Generated by util/mkerr.pl DO NOT EDIT ++ * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved. ++ * ++ * Licensed under the OpenSSL license (the "License"). You may not use ++ * this file except in compliance with the License. You can obtain a copy ++ * in the file LICENSE in the source distribution or at ++ * https://www.openssl.org/source/license.html ++ */ ++ ++#ifndef HEADER_PEMERR_H ++# define HEADER_PEMERR_H ++ ++# ifndef HEADER_SYMHACKS_H ++# include ++# endif ++ ++# ifdef __cplusplus ++extern "C" ++# endif ++int ERR_load_PEM_strings(void); ++ ++/* ++ * PEM function codes. ++ */ ++# define PEM_F_B2I_DSS 127 ++# define PEM_F_B2I_PVK_BIO 128 ++# define PEM_F_B2I_RSA 129 ++# define PEM_F_CHECK_BITLEN_DSA 130 ++# define PEM_F_CHECK_BITLEN_RSA 131 ++# define PEM_F_D2I_PKCS8PRIVATEKEY_BIO 120 ++# define PEM_F_D2I_PKCS8PRIVATEKEY_FP 121 ++# define PEM_F_DO_B2I 132 ++# define PEM_F_DO_B2I_BIO 133 ++# define PEM_F_DO_BLOB_HEADER 134 ++# define PEM_F_DO_I2B 146 ++# define PEM_F_DO_PK8PKEY 126 ++# define PEM_F_DO_PK8PKEY_FP 125 ++# define PEM_F_DO_PVK_BODY 135 ++# define PEM_F_DO_PVK_HEADER 136 ++# define PEM_F_GET_HEADER_AND_DATA 143 ++# define PEM_F_GET_NAME 144 ++# define PEM_F_I2B_PVK 137 ++# define PEM_F_I2B_PVK_BIO 138 ++# define PEM_F_LOAD_IV 101 ++# define PEM_F_PEM_ASN1_READ 102 ++# define PEM_F_PEM_ASN1_READ_BIO 103 ++# define PEM_F_PEM_ASN1_WRITE 104 ++# define PEM_F_PEM_ASN1_WRITE_BIO 105 ++# define PEM_F_PEM_DEF_CALLBACK 100 ++# define PEM_F_PEM_DO_HEADER 106 ++# define PEM_F_PEM_GET_EVP_CIPHER_INFO 107 ++# define PEM_F_PEM_READ 108 ++# define PEM_F_PEM_READ_BIO 109 ++# define PEM_F_PEM_READ_BIO_DHPARAMS 141 ++# define PEM_F_PEM_READ_BIO_EX 145 ++# define PEM_F_PEM_READ_BIO_PARAMETERS 140 ++# define PEM_F_PEM_READ_BIO_PRIVATEKEY 123 ++# define PEM_F_PEM_READ_DHPARAMS 142 ++# define PEM_F_PEM_READ_PRIVATEKEY 124 ++# define PEM_F_PEM_SIGNFINAL 112 ++# define PEM_F_PEM_WRITE 113 ++# define PEM_F_PEM_WRITE_BIO 114 ++# define PEM_F_PEM_WRITE_BIO_PRIVATEKEY_TRADITIONAL 147 ++# define PEM_F_PEM_WRITE_PRIVATEKEY 139 ++# define PEM_F_PEM_X509_INFO_READ 115 ++# define PEM_F_PEM_X509_INFO_READ_BIO 116 ++# define PEM_F_PEM_X509_INFO_WRITE_BIO 117 ++ ++/* ++ * PEM reason codes. ++ */ ++# define PEM_R_BAD_BASE64_DECODE 100 ++# define PEM_R_BAD_DECRYPT 101 ++# define PEM_R_BAD_END_LINE 102 ++# define PEM_R_BAD_IV_CHARS 103 ++# define PEM_R_BAD_MAGIC_NUMBER 116 ++# define PEM_R_BAD_PASSWORD_READ 104 ++# define PEM_R_BAD_VERSION_NUMBER 117 ++# define PEM_R_BIO_WRITE_FAILURE 118 ++# define PEM_R_CIPHER_IS_NULL 127 ++# define PEM_R_ERROR_CONVERTING_PRIVATE_KEY 115 ++# define PEM_R_EXPECTING_PRIVATE_KEY_BLOB 119 ++# define PEM_R_EXPECTING_PUBLIC_KEY_BLOB 120 ++# define PEM_R_HEADER_TOO_LONG 128 ++# define PEM_R_INCONSISTENT_HEADER 121 ++# define PEM_R_KEYBLOB_HEADER_PARSE_ERROR 122 ++# define PEM_R_KEYBLOB_TOO_SHORT 123 ++# define PEM_R_MISSING_DEK_IV 129 ++# define PEM_R_NOT_DEK_INFO 105 ++# define PEM_R_NOT_ENCRYPTED 106 ++# define PEM_R_NOT_PROC_TYPE 107 ++# define PEM_R_NO_START_LINE 108 ++# define PEM_R_PROBLEMS_GETTING_PASSWORD 109 ++# define PEM_R_PVK_DATA_TOO_SHORT 124 ++# define PEM_R_PVK_TOO_SHORT 125 ++# define PEM_R_READ_KEY 111 ++# define PEM_R_SHORT_HEADER 112 ++# define PEM_R_UNEXPECTED_DEK_IV 130 ++# define PEM_R_UNSUPPORTED_CIPHER 113 ++# define PEM_R_UNSUPPORTED_ENCRYPTION 114 ++# define PEM_R_UNSUPPORTED_KEY_COMPONENTS 126 ++# define PEM_R_UNSUPPORTED_PUBLIC_KEY_TYPE 110 ++ ++#endif +diff --git a/include/TA/openssl/openssl/pkcs7.h b/include/TA/openssl/openssl/pkcs7.h +new file mode 100644 +index 0000000..0ea05c5 +--- /dev/null ++++ b/include/TA/openssl/openssl/pkcs7.h +@@ -0,0 +1,457 @@ ++/* ++ * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved. ++ * ++ * Licensed under the OpenSSL license (the "License"). You may not use ++ * this file except in compliance with the License. You can obtain a copy ++ * in the file LICENSE in the source distribution or at ++ * https://www.openssl.org/source/license.html ++ */ ++ ++#ifndef HEADER_PKCS7_H ++# define HEADER_PKCS7_H ++ ++# include ++# include ++# include ++ ++# include ++# include ++# include ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++/*- ++Encryption_ID DES-CBC ++Digest_ID MD5 ++Digest_Encryption_ID rsaEncryption ++Key_Encryption_ID rsaEncryption ++*/ ++ ++typedef struct pkcs7_issuer_and_serial_st { ++ X509_NAME *issuer; ++ ASN1_INTEGER *serial; ++} PKCS7_ISSUER_AND_SERIAL; ++ ++typedef struct pkcs7_signer_info_st { ++ ASN1_INTEGER *version; /* version 1 */ ++ PKCS7_ISSUER_AND_SERIAL *issuer_and_serial; ++ X509_ALGOR *digest_alg; ++ STACK_OF(X509_ATTRIBUTE) *auth_attr; /* [ 0 ] */ ++ X509_ALGOR *digest_enc_alg; ++ ASN1_OCTET_STRING *enc_digest; ++ STACK_OF(X509_ATTRIBUTE) *unauth_attr; /* [ 1 ] */ ++ /* The private key to sign with */ ++ EVP_PKEY *pkey; ++} PKCS7_SIGNER_INFO; ++ ++DEFINE_STACK_OF(PKCS7_SIGNER_INFO) ++ ++typedef struct pkcs7_recip_info_st { ++ ASN1_INTEGER *version; /* version 0 */ ++ PKCS7_ISSUER_AND_SERIAL *issuer_and_serial; ++ X509_ALGOR *key_enc_algor; ++ ASN1_OCTET_STRING *enc_key; ++ X509 *cert; /* get the pub-key from this */ ++} PKCS7_RECIP_INFO; ++ ++DEFINE_STACK_OF(PKCS7_RECIP_INFO) ++ ++typedef struct pkcs7_signed_st { ++ ASN1_INTEGER *version; /* version 1 */ ++ STACK_OF(X509_ALGOR) *md_algs; /* md used */ ++ STACK_OF(X509) *cert; /* [ 0 ] */ ++ STACK_OF(X509_CRL) *crl; /* [ 1 ] */ ++ STACK_OF(PKCS7_SIGNER_INFO) *signer_info; ++ struct pkcs7_st *contents; ++} PKCS7_SIGNED; ++/* ++ * The above structure is very very similar to PKCS7_SIGN_ENVELOPE. How about ++ * merging the two ++ */ ++ ++typedef struct pkcs7_enc_content_st { ++ ASN1_OBJECT *content_type; ++ X509_ALGOR *algorithm; ++ ASN1_OCTET_STRING *enc_data; /* [ 0 ] */ ++ const EVP_CIPHER *cipher; ++} PKCS7_ENC_CONTENT; ++ ++typedef struct pkcs7_enveloped_st { ++ ASN1_INTEGER *version; /* version 0 */ ++ STACK_OF(PKCS7_RECIP_INFO) *recipientinfo; ++ PKCS7_ENC_CONTENT *enc_data; ++} PKCS7_ENVELOPE; ++ ++typedef struct pkcs7_signedandenveloped_st { ++ ASN1_INTEGER *version; /* version 1 */ ++ STACK_OF(X509_ALGOR) *md_algs; /* md used */ ++ STACK_OF(X509) *cert; /* [ 0 ] */ ++ STACK_OF(X509_CRL) *crl; /* [ 1 ] */ ++ STACK_OF(PKCS7_SIGNER_INFO) *signer_info; ++ PKCS7_ENC_CONTENT *enc_data; ++ STACK_OF(PKCS7_RECIP_INFO) *recipientinfo; ++} PKCS7_SIGN_ENVELOPE; ++ ++typedef struct pkcs7_digest_st { ++ ASN1_INTEGER *version; /* version 0 */ ++ X509_ALGOR *md; /* md used */ ++ struct pkcs7_st *contents; ++ ASN1_OCTET_STRING *digest; ++} PKCS7_DIGEST; ++ ++typedef struct pkcs7_encrypted_st { ++ ASN1_INTEGER *version; /* version 0 */ ++ PKCS7_ENC_CONTENT *enc_data; ++} PKCS7_ENCRYPT; ++ ++typedef struct pkcs7_st { ++ /* ++ * The following is non NULL if it contains ASN1 encoding of this ++ * structure ++ */ ++ unsigned char *asn1; ++ long length; ++# define PKCS7_S_HEADER 0 ++# define PKCS7_S_BODY 1 ++# define PKCS7_S_TAIL 2 ++ int state; /* used during processing */ ++ int detached; ++ ASN1_OBJECT *type; ++ /* content as defined by the type */ ++ /* ++ * all encryption/message digests are applied to the 'contents', leaving ++ * out the 'type' field. ++ */ ++ union { ++ char *ptr; ++ /* NID_pkcs7_data */ ++ ASN1_OCTET_STRING *data; ++ /* NID_pkcs7_signed */ ++ PKCS7_SIGNED *sign; ++ /* NID_pkcs7_enveloped */ ++ PKCS7_ENVELOPE *enveloped; ++ /* NID_pkcs7_signedAndEnveloped */ ++ PKCS7_SIGN_ENVELOPE *signed_and_enveloped; ++ /* NID_pkcs7_digest */ ++ PKCS7_DIGEST *digest; ++ /* NID_pkcs7_encrypted */ ++ PKCS7_ENCRYPT *encrypted; ++ /* Anything else */ ++ ASN1_TYPE *other; ++ } d; ++} PKCS7; ++ ++DEFINE_STACK_OF(PKCS7) ++ ++# define PKCS7_OP_SET_DETACHED_SIGNATURE 1 ++# define PKCS7_OP_GET_DETACHED_SIGNATURE 2 ++ ++# define PKCS7_get_signed_attributes(si) ((si)->auth_attr) ++# define PKCS7_get_attributes(si) ((si)->unauth_attr) ++ ++#ifndef OPENSSL_NO_PKCS7_SM2 ++# define PKCS7_type_is_sm2(a) (OBJ_obj2nid((a)->type) == NID_pkcs7_sm2data \ ++ || OBJ_obj2nid((a)->type) == NID_pkcs7_sm2signedData \ ++ || OBJ_obj2nid((a)->type) == NID_pkcs7_sm2envelopedData \ ++ || OBJ_obj2nid((a)->type) == NID_pkcs7_sm2signedAndEnvelopedData \ ++ ) ++# define PKCS7_type_is_signed(a) (OBJ_obj2nid((a)->type) == NID_pkcs7_signed \ ++ || OBJ_obj2nid((a)->type) == NID_pkcs7_sm2signedData \ ++ ) ++# define PKCS7_type_is_encrypted(a) (OBJ_obj2nid((a)->type) == NID_pkcs7_encrypted) ++# define PKCS7_type_is_enveloped(a) (OBJ_obj2nid((a)->type) == NID_pkcs7_enveloped \ ++ || OBJ_obj2nid((a)->type) == NID_pkcs7_sm2envelopedData \ ++ ) ++# define PKCS7_type_is_signedAndEnveloped(a) \ ++ (OBJ_obj2nid((a)->type) == NID_pkcs7_signedAndEnveloped \ ++ || OBJ_obj2nid((a)->type) == NID_pkcs7_sm2signedAndEnvelopedData \ ++ ) ++# define PKCS7_type_is_data(a) (OBJ_obj2nid((a)->type) == NID_pkcs7_data \ ++ || OBJ_obj2nid((a)->type) == NID_pkcs7_sm2data \ ++ ) ++# define PKCS7_type_is_digest(a) (OBJ_obj2nid((a)->type) == NID_pkcs7_digest) ++#else ++# define PKCS7_type_is_signed(a) (OBJ_obj2nid((a)->type) == NID_pkcs7_signed) ++# define PKCS7_type_is_encrypted(a) (OBJ_obj2nid((a)->type) == NID_pkcs7_encrypted) ++# define PKCS7_type_is_enveloped(a) (OBJ_obj2nid((a)->type) == NID_pkcs7_enveloped) ++# define PKCS7_type_is_signedAndEnveloped(a) \ ++ (OBJ_obj2nid((a)->type) == NID_pkcs7_signedAndEnveloped) ++# define PKCS7_type_is_data(a) (OBJ_obj2nid((a)->type) == NID_pkcs7_data) ++# define PKCS7_type_is_digest(a) (OBJ_obj2nid((a)->type) == NID_pkcs7_digest) ++#endif ++ ++# define PKCS7_set_detached(p,v) \ ++ PKCS7_ctrl(p,PKCS7_OP_SET_DETACHED_SIGNATURE,v,NULL) ++# define PKCS7_get_detached(p) \ ++ PKCS7_ctrl(p,PKCS7_OP_GET_DETACHED_SIGNATURE,0,NULL) ++ ++# define PKCS7_is_detached(p7) (PKCS7_type_is_signed(p7) && PKCS7_get_detached(p7)) ++ ++/* S/MIME related flags */ ++ ++# define PKCS7_TEXT 0x1 ++# define PKCS7_NOCERTS 0x2 ++# define PKCS7_NOSIGS 0x4 ++# define PKCS7_NOCHAIN 0x8 ++# define PKCS7_NOINTERN 0x10 ++# define PKCS7_NOVERIFY 0x20 ++# define PKCS7_DETACHED 0x40 ++# define PKCS7_BINARY 0x80 ++# define PKCS7_NOATTR 0x100 ++# define PKCS7_NOSMIMECAP 0x200 ++# define PKCS7_NOOLDMIMETYPE 0x400 ++# define PKCS7_CRLFEOL 0x800 ++# define PKCS7_STREAM 0x1000 ++# define PKCS7_NOCRL 0x2000 ++# define PKCS7_PARTIAL 0x4000 ++# define PKCS7_REUSE_DIGEST 0x8000 ++# define PKCS7_NO_DUAL_CONTENT 0x10000 ++# define PKCS7_NOPADDING 0x20000 ++ ++/* Flags: for compatibility with older code */ ++ ++# define SMIME_TEXT PKCS7_TEXT ++# define SMIME_NOCERTS PKCS7_NOCERTS ++# define SMIME_NOSIGS PKCS7_NOSIGS ++# define SMIME_NOCHAIN PKCS7_NOCHAIN ++# define SMIME_NOINTERN PKCS7_NOINTERN ++# define SMIME_NOVERIFY PKCS7_NOVERIFY ++# define SMIME_DETACHED PKCS7_DETACHED ++# define SMIME_BINARY PKCS7_BINARY ++# define SMIME_NOATTR PKCS7_NOATTR ++ ++/* CRLF ASCII canonicalisation */ ++# define SMIME_ASCIICRLF 0x80000 ++ ++DECLARE_ASN1_FUNCTIONS(PKCS7_ISSUER_AND_SERIAL) ++ ++int PKCS7_ISSUER_AND_SERIAL_digest(PKCS7_ISSUER_AND_SERIAL *data, ++ const EVP_MD *type, unsigned char *md, ++ unsigned int *len); ++# ifndef OPENSSL_NO_STDIO ++PKCS7 *d2i_PKCS7_fp(FILE *fp, PKCS7 **p7); ++int i2d_PKCS7_fp(FILE *fp, PKCS7 *p7); ++# endif ++PKCS7 *PKCS7_dup(PKCS7 *p7); ++PKCS7 *d2i_PKCS7_bio(BIO *bp, PKCS7 **p7); ++int i2d_PKCS7_bio(BIO *bp, PKCS7 *p7); ++int i2d_PKCS7_bio_stream(BIO *out, PKCS7 *p7, BIO *in, int flags); ++int PEM_write_bio_PKCS7_stream(BIO *out, PKCS7 *p7, BIO *in, int flags); ++ ++DECLARE_ASN1_FUNCTIONS(PKCS7_SIGNER_INFO) ++DECLARE_ASN1_FUNCTIONS(PKCS7_RECIP_INFO) ++DECLARE_ASN1_FUNCTIONS(PKCS7_SIGNED) ++DECLARE_ASN1_FUNCTIONS(PKCS7_ENC_CONTENT) ++DECLARE_ASN1_FUNCTIONS(PKCS7_ENVELOPE) ++DECLARE_ASN1_FUNCTIONS(PKCS7_SIGN_ENVELOPE) ++DECLARE_ASN1_FUNCTIONS(PKCS7_DIGEST) ++DECLARE_ASN1_FUNCTIONS(PKCS7_ENCRYPT) ++DECLARE_ASN1_FUNCTIONS(PKCS7) ++ ++DECLARE_ASN1_ITEM(PKCS7_ATTR_SIGN) ++DECLARE_ASN1_ITEM(PKCS7_ATTR_VERIFY) ++ ++DECLARE_ASN1_NDEF_FUNCTION(PKCS7) ++DECLARE_ASN1_PRINT_FUNCTION(PKCS7) ++ ++long PKCS7_ctrl(PKCS7 *p7, int cmd, long larg, char *parg); ++ ++int PKCS7_set_type(PKCS7 *p7, int type); ++int PKCS7_set0_type_other(PKCS7 *p7, int type, ASN1_TYPE *other); ++int PKCS7_set_content(PKCS7 *p7, PKCS7 *p7_data); ++int PKCS7_SIGNER_INFO_set(PKCS7_SIGNER_INFO *p7i, X509 *x509, EVP_PKEY *pkey, ++ const EVP_MD *dgst); ++int PKCS7_SIGNER_INFO_sign(PKCS7_SIGNER_INFO *si); ++int PKCS7_add_signer(PKCS7 *p7, PKCS7_SIGNER_INFO *p7i); ++int PKCS7_add_certificate(PKCS7 *p7, X509 *x509); ++int PKCS7_add_crl(PKCS7 *p7, X509_CRL *x509); ++int PKCS7_content_new(PKCS7 *p7, int nid); ++int PKCS7_dataVerify(X509_STORE *cert_store, X509_STORE_CTX *ctx, ++ BIO *bio, PKCS7 *p7, PKCS7_SIGNER_INFO *si); ++int PKCS7_signatureVerify(BIO *bio, PKCS7 *p7, PKCS7_SIGNER_INFO *si, ++ X509 *x509); ++ ++BIO *PKCS7_dataInit(PKCS7 *p7, BIO *bio); ++int PKCS7_dataFinal(PKCS7 *p7, BIO *bio); ++BIO *PKCS7_dataDecode(PKCS7 *p7, EVP_PKEY *pkey, BIO *in_bio, X509 *pcert); ++ ++PKCS7_SIGNER_INFO *PKCS7_add_signature(PKCS7 *p7, X509 *x509, ++ EVP_PKEY *pkey, const EVP_MD *dgst); ++X509 *PKCS7_cert_from_signer_info(PKCS7 *p7, PKCS7_SIGNER_INFO *si); ++int PKCS7_set_digest(PKCS7 *p7, const EVP_MD *md); ++STACK_OF(PKCS7_SIGNER_INFO) *PKCS7_get_signer_info(PKCS7 *p7); ++ ++PKCS7_RECIP_INFO *PKCS7_add_recipient(PKCS7 *p7, X509 *x509); ++void PKCS7_SIGNER_INFO_get0_algs(PKCS7_SIGNER_INFO *si, EVP_PKEY **pk, ++ X509_ALGOR **pdig, X509_ALGOR **psig); ++void PKCS7_RECIP_INFO_get0_alg(PKCS7_RECIP_INFO *ri, X509_ALGOR **penc); ++int PKCS7_add_recipient_info(PKCS7 *p7, PKCS7_RECIP_INFO *ri); ++int PKCS7_RECIP_INFO_set(PKCS7_RECIP_INFO *p7i, X509 *x509); ++int PKCS7_set_cipher(PKCS7 *p7, const EVP_CIPHER *cipher); ++int PKCS7_stream(unsigned char ***boundary, PKCS7 *p7); ++ ++PKCS7_ISSUER_AND_SERIAL *PKCS7_get_issuer_and_serial(PKCS7 *p7, int idx); ++ASN1_OCTET_STRING *PKCS7_digest_from_attributes(STACK_OF(X509_ATTRIBUTE) *sk); ++int PKCS7_add_signed_attribute(PKCS7_SIGNER_INFO *p7si, int nid, int type, ++ void *data); ++int PKCS7_add_attribute(PKCS7_SIGNER_INFO *p7si, int nid, int atrtype, ++ void *value); ++ASN1_TYPE *PKCS7_get_attribute(PKCS7_SIGNER_INFO *si, int nid); ++ASN1_TYPE *PKCS7_get_signed_attribute(PKCS7_SIGNER_INFO *si, int nid); ++int PKCS7_set_signed_attributes(PKCS7_SIGNER_INFO *p7si, ++ STACK_OF(X509_ATTRIBUTE) *sk); ++int PKCS7_set_attributes(PKCS7_SIGNER_INFO *p7si, ++ STACK_OF(X509_ATTRIBUTE) *sk); ++ ++PKCS7 *PKCS7_sign(X509 *signcert, EVP_PKEY *pkey, STACK_OF(X509) *certs, ++ BIO *data, int flags); ++ ++PKCS7_SIGNER_INFO *PKCS7_sign_add_signer(PKCS7 *p7, ++ X509 *signcert, EVP_PKEY *pkey, ++ const EVP_MD *md, int flags); ++ ++int PKCS7_final(PKCS7 *p7, BIO *data, int flags); ++int PKCS7_verify(PKCS7 *p7, STACK_OF(X509) *certs, X509_STORE *store, ++ BIO *indata, BIO *out, int flags); ++STACK_OF(X509) *PKCS7_get0_signers(PKCS7 *p7, STACK_OF(X509) *certs, ++ int flags); ++PKCS7 *PKCS7_encrypt(STACK_OF(X509) *certs, BIO *in, const EVP_CIPHER *cipher, ++ int flags); ++int PKCS7_decrypt(PKCS7 *p7, EVP_PKEY *pkey, X509 *cert, BIO *data, ++ int flags); ++ ++int PKCS7_add_attrib_smimecap(PKCS7_SIGNER_INFO *si, ++ STACK_OF(X509_ALGOR) *cap); ++STACK_OF(X509_ALGOR) *PKCS7_get_smimecap(PKCS7_SIGNER_INFO *si); ++int PKCS7_simple_smimecap(STACK_OF(X509_ALGOR) *sk, int nid, int arg); ++ ++int PKCS7_add_attrib_content_type(PKCS7_SIGNER_INFO *si, ASN1_OBJECT *coid); ++int PKCS7_add0_attrib_signing_time(PKCS7_SIGNER_INFO *si, ASN1_TIME *t); ++int PKCS7_add1_attrib_digest(PKCS7_SIGNER_INFO *si, ++ const unsigned char *md, int mdlen); ++ ++int SMIME_write_PKCS7(BIO *bio, PKCS7 *p7, BIO *data, int flags); ++PKCS7 *SMIME_read_PKCS7(BIO *bio, BIO **bcont); ++ ++BIO *BIO_new_PKCS7(BIO *out, PKCS7 *p7); ++ ++#ifndef OPENSSL_NO_PKCS7_SM2 ++/** ++ * @API: ++ * PKCS7 *PKCS7_sm2_sign_envelop(X509 *signer, EVP_PKEY *pkey, STACK_OF(X509) *certs, ++ STACK_OF(X509) *recips, const EVP_CIPHER *cipher, ++ BIO *indata, int flags); ++ * @function: Build a complete PKCS#7 sm2 signedAndEnveloped data ++ * @param[in] ++ * X509 *signer -- the certificate to sign with ++ * EVP_PKEY *pkey -- the corresponding private key ++ * STACK_OF(X509) *certs -- an optional additional set of certificates ++ * STACK_OF(X509) *recips -- a list of recipient certificates ++ * const EVP_CIPHER *cipher -- the symmetric cipher to use ++ * BIO *indata -- the content to be enveloped and signed ++ * int flags -- an optional set of flags ++ * @return PKCS7* PKCS7 struct pointer ++ * @see GM/T 0010-2012 SM2 cryptography message syntax specification. Sec. 10 ++ * @reused API: ++ * PKCS7_set_type ++ * PKCS7_set_cipher ++ * PKCS7_sign_add_signer ++ * PKCS7_add_recipient ++ * PKCS7_add_certificate ++ * PKCS7_final ++ */ ++PKCS7 *PKCS7_sm2_sign_envelop(X509 *signer, EVP_PKEY *pkey, STACK_OF(X509) *certs, ++ STACK_OF(X509) *recips, const EVP_CIPHER *cipher, ++ BIO *indata, int flags); ++/** ++ * @API: ++ * int PKCS7_sm2_decrypt(PKCS7 *p7, EVP_PKEY *pkey, X509 *cert, BIO *data, int flags); ++ * @function: PKCS#7 sm2 enveloped or signedAndEnveloped data decryption ++ * @param[in] ++ * PKCS7 *p7 -- PKCS7 struct pointer ++ * EVP_PKEY *pkey -- the private key for decryption ++ * X509 *cert -- the corresponding recipient certificate ++ * int flags -- an optional set of flags ++ * @param[out] ++ * BIO *data -- output data BIO struct pointer ++ * @return int: 1 for success; 0 for failure ++ * @see GM/T 0010-2012 SM2 cryptography message syntax specification. Sec. 9 and 10 ++ * @reused API: ++ * PKCS7_decrypt ++ */ ++int PKCS7_sm2_decrypt(PKCS7 *p7, EVP_PKEY *pkey, X509 *cert, BIO *data, int flags); ++/** ++ * @API: ++ * int PKCS7_sm2_verify(PKCS7 *p7, STACK_OF(X509) *certs, X509_STORE *store, ++ BIO *indata, BIO *out, int flags); ++ * @function: PKCS#7 sm2 signed or signedAndEnveloped data signature verification ++ * @param[in] ++ * PKCS7 *p7 -- PKCS7 struct pointer ++ * STACK_OF(X509) *certs -- a set of signer certificates ++ * EVP_PKEY *pkey -- the private key for decryption ++ * X509 *cert -- the corresponding recipient certificate ++ * int flags -- an optional set of flags ++ * @param[out] ++ * BIO *data -- output data BIO struct pointer ++ * @return int: 1 for success; 0 for failure ++ * @see GM/T 0010-2012 SM2 cryptography message syntax specification. Sec. 8 and 10 ++ * @reused API: ++ * PKCS7_get0_signers ++ * PKCS7_get_signer_info ++ * PKCS7_signatureVerify ++ */ ++int PKCS7_sm2_verify(PKCS7 *p7, STACK_OF(X509) *certs, X509_STORE *store, ++ BIO *indata, BIO *out, int flags); ++/** ++ * @API: ++ * int PKCS7_sm2_decrypt_verify(PKCS7 *p7, X509 *recip, EVP_PKEY *recipkey, STACK_OF(X509) *certs, ++ X509_STORE *store, BIO *out, int flags); ++ * @function: PKCS#7 sm2 signedAndEnveloped data decryption and signature verification ++ * @param[in] ++ * PKCS7 *p7 -- PKCS7 struct pointer ++ * X509 *recip -- the recipient certificate ++ * EVP_PKEY *recipkey -- the corresponding private key for decryption ++ * STACK_OF(X509) *certs -- a set of signer certificates ++ * X509_STORE *store -- the trusted certificate store to use for chain verification ++ * int flags -- an optional set of flags ++ * @param[out] ++ * BIO *out -- output data BIO struct pointer ++ * @return int: 1 for success; 0 for failure ++ * @see GM/T 0010-2012 SM2 cryptography message syntax specification. Sec. 8 and 10 ++ * @reused API: ++ * PKCS7_sm2_decrypt ++ * PKCS7_sm2_verify ++ */ ++int PKCS7_sm2_decrypt_verify(PKCS7 *p7, X509 *recip, EVP_PKEY *recipkey, STACK_OF(X509) *certs, ++ X509_STORE *store, BIO *out, int flags); ++/** ++ * @API: ++ * int PKCS7_sm2_dataFinal(PKCS7 *p7, BIO *bio, BIO *data); ++ * @function: PKCS#7 sm2 signed, enveloped and signedAndEnveloped data signing and encrypting ++ * @param[in] ++ * PKCS7 *p7 -- PKCS7 struct pointer ++ * BIO *bio -- BIO chain ++ * BIO *data -- input data BIO struct pointer ++ * @param[out] ++ * BIO *out -- output data BIO struct pointer ++ * @return int: 1 for success; 0 for failure ++ * @see GM/T 0010-2012 SM2 cryptography message syntax specification. Sec. 8, 9 and 10 ++ * @note: ++ * Why do we create a new sm2 data final API? ++ * ++ * The process in the native OpenSSL API PKCS7_final calls PKCS7_dataInit and PKCS7_dataFinal ++ * in sequence. PKCS7_dataInit constructs a digest BIO. Each digest algorithm corresponds to only ++ * one digest BIO. PKCS7_dataFinal obtains the digest value in plaintext. Because the z value of ++ * SM2 Signature needs to be calculated and it is different for each signer. ++ * ++ * The interface is added to adapt to the multi-sm2-signer scenario. ++ */ ++int PKCS7_sm2_dataFinal(PKCS7 *p7, BIO *bio, BIO *data); ++#endif ++ ++# ifdef __cplusplus ++} ++# endif ++#endif +diff --git a/include/TA/openssl/openssl/pkcs7err.h b/include/TA/openssl/openssl/pkcs7err.h +new file mode 100644 +index 0000000..22f8d52 +--- /dev/null ++++ b/include/TA/openssl/openssl/pkcs7err.h +@@ -0,0 +1,118 @@ ++/* ++ * Generated by util/mkerr.pl DO NOT EDIT ++ * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. ++ * ++ * Licensed under the OpenSSL license (the "License"). You may not use ++ * this file except in compliance with the License. You can obtain a copy ++ * in the file LICENSE in the source distribution or at ++ * https://www.openssl.org/source/license.html ++ */ ++ ++#ifndef HEADER_PKCS7ERR_H ++# define HEADER_PKCS7ERR_H ++ ++# ifndef HEADER_SYMHACKS_H ++# include ++# endif ++ ++# ifdef __cplusplus ++extern "C" ++# endif ++int ERR_load_PKCS7_strings(void); ++ ++/* ++ * PKCS7 function codes. ++ */ ++# define PKCS7_F_DO_PKCS7_SIGNED_ATTRIB 136 ++# define PKCS7_F_PKCS7_ADD0_ATTRIB_SIGNING_TIME 135 ++# define PKCS7_F_PKCS7_ADD_ATTRIB_SMIMECAP 118 ++# define PKCS7_F_PKCS7_ADD_CERTIFICATE 100 ++# define PKCS7_F_PKCS7_ADD_CRL 101 ++# define PKCS7_F_PKCS7_ADD_RECIPIENT_INFO 102 ++# define PKCS7_F_PKCS7_ADD_SIGNATURE 131 ++# define PKCS7_F_PKCS7_ADD_SIGNER 103 ++# define PKCS7_F_PKCS7_BIO_ADD_DIGEST 125 ++# define PKCS7_F_PKCS7_COPY_EXISTING_DIGEST 138 ++# define PKCS7_F_PKCS7_CTRL 104 ++# define PKCS7_F_PKCS7_DATADECODE 112 ++# define PKCS7_F_PKCS7_DATAFINAL 128 ++# define PKCS7_F_PKCS7_DATAINIT 105 ++# define PKCS7_F_PKCS7_DATAVERIFY 107 ++# define PKCS7_F_PKCS7_DECRYPT 114 ++# define PKCS7_F_PKCS7_DECRYPT_RINFO 133 ++# define PKCS7_F_PKCS7_ENCODE_RINFO 132 ++# define PKCS7_F_PKCS7_ENCRYPT 115 ++# define PKCS7_F_PKCS7_FINAL 134 ++# define PKCS7_F_PKCS7_FIND_DIGEST 127 ++# define PKCS7_F_PKCS7_GET0_SIGNERS 124 ++# define PKCS7_F_PKCS7_RECIP_INFO_SET 130 ++# define PKCS7_F_PKCS7_SET_CIPHER 108 ++# define PKCS7_F_PKCS7_SET_CONTENT 109 ++# define PKCS7_F_PKCS7_SET_DIGEST 126 ++# define PKCS7_F_PKCS7_SET_TYPE 110 ++# define PKCS7_F_PKCS7_SIGN 116 ++# define PKCS7_F_PKCS7_SIGNATUREVERIFY 113 ++# define PKCS7_F_PKCS7_SIGNER_INFO_SET 129 ++# define PKCS7_F_PKCS7_SIGNER_INFO_SIGN 139 ++# define PKCS7_F_PKCS7_SIGN_ADD_SIGNER 137 ++# define PKCS7_F_PKCS7_SIMPLE_SMIMECAP 119 ++# define PKCS7_F_PKCS7_VERIFY 117 ++# define PKCS7_F_PKCS7_ADD_RECIPIENT 140 ++# define PKCS7_F_PKCS7_SM2_SIGN_ENVELOP 141 ++# define PKCS7_F_PKCS7_SM2_VERIFY 142 ++# define PKCS7_F_PKCS7_SM2_VERIFY_CERT 143 ++# define PKCS7_F_PKCS7_SM2_VERIFY_SIGNATURE 144 ++# define PKCS7_F_PKCS7_SM2_VERIFY_DATA 145 ++# define PKCS7_F_PKCS7_SM2_DECRYPT_VERIFY 146 ++# define PKCS7_F_PKCS7_SM2_SIGN_DATA 147 ++# define PKCS7_F_PKCS7_SM2_DATAFINAL 148 ++ ++/* ++ * PKCS7 reason codes. ++ */ ++# define PKCS7_R_CERTIFICATE_VERIFY_ERROR 117 ++# define PKCS7_R_CIPHER_HAS_NO_OBJECT_IDENTIFIER 144 ++# define PKCS7_R_CIPHER_NOT_INITIALIZED 116 ++# define PKCS7_R_CONTENT_AND_DATA_PRESENT 118 ++# define PKCS7_R_CTRL_ERROR 152 ++# define PKCS7_R_DECRYPT_ERROR 119 ++# define PKCS7_R_DIGEST_FAILURE 101 ++# define PKCS7_R_ENCRYPTION_CTRL_FAILURE 149 ++# define PKCS7_R_ENCRYPTION_NOT_SUPPORTED_FOR_THIS_KEY_TYPE 150 ++# define PKCS7_R_ERROR_ADDING_RECIPIENT 120 ++# define PKCS7_R_ERROR_SETTING_CIPHER 121 ++# define PKCS7_R_INVALID_NULL_POINTER 143 ++# define PKCS7_R_INVALID_SIGNED_DATA_TYPE 155 ++# define PKCS7_R_NO_CONTENT 122 ++# define PKCS7_R_NO_DEFAULT_DIGEST 151 ++# define PKCS7_R_NO_MATCHING_DIGEST_TYPE_FOUND 154 ++# define PKCS7_R_NO_RECIPIENT_MATCHES_CERTIFICATE 115 ++# define PKCS7_R_NO_SIGNATURES_ON_DATA 123 ++# define PKCS7_R_NO_SIGNERS 142 ++# define PKCS7_R_OPERATION_NOT_SUPPORTED_ON_THIS_TYPE 104 ++# define PKCS7_R_PKCS7_ADD_SIGNATURE_ERROR 124 ++# define PKCS7_R_PKCS7_ADD_SIGNER_ERROR 153 ++# define PKCS7_R_PKCS7_DATASIGN 145 ++# define PKCS7_R_PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE 127 ++# define PKCS7_R_SIGNATURE_FAILURE 105 ++# define PKCS7_R_SIGNER_CERTIFICATE_NOT_FOUND 128 ++# define PKCS7_R_SIGNING_CTRL_FAILURE 147 ++# define PKCS7_R_SIGNING_NOT_SUPPORTED_FOR_THIS_KEY_TYPE 148 ++# define PKCS7_R_SMIME_TEXT_ERROR 129 ++# define PKCS7_R_UNABLE_TO_FIND_CERTIFICATE 106 ++# define PKCS7_R_UNABLE_TO_FIND_MEM_BIO 107 ++# define PKCS7_R_UNABLE_TO_FIND_MESSAGE_DIGEST 108 ++# define PKCS7_R_UNKNOWN_DIGEST_TYPE 109 ++# define PKCS7_R_UNKNOWN_OPERATION 110 ++# define PKCS7_R_UNSUPPORTED_CIPHER_TYPE 111 ++# define PKCS7_R_UNSUPPORTED_CONTENT_TYPE 112 ++# define PKCS7_R_WRONG_CONTENT_TYPE 113 ++# define PKCS7_R_WRONG_PKCS7_TYPE 114 ++# define PKCS7_R_UNSUPPORTED_SIGNERS 146 ++# define PKCS7_R_UNSUPPORTED_RECIPIENTS 147 ++# define PKCS7_R_SM2_SIGN_DATA_FAILURE 148 ++# define PKCS7_R_SM2_VERIFY_DATA_FAILURE 149 ++# define PKCS7_R_SM2_SIGNATURE_FAILURE 150 ++# define PKCS7_R_SM2_VERIFY_ERROR 151 ++ ++#endif +diff --git a/include/TA/openssl/openssl/rand.h b/include/TA/openssl/openssl/rand.h +new file mode 100644 +index 0000000..ec3b31f +--- /dev/null ++++ b/include/TA/openssl/openssl/rand.h +@@ -0,0 +1,87 @@ ++/* ++ * Copyright 1995-2018 The OpenSSL Project Authors. All Rights Reserved. ++ * ++ * Licensed under the OpenSSL license (the "License"). You may not use ++ * this file except in compliance with the License. You can obtain a copy ++ * in the file LICENSE in the source distribution or at ++ * https://www.openssl.org/source/license.html ++ */ ++ ++#ifndef HEADER_RAND_H ++# define HEADER_RAND_H ++ ++# include ++# include ++# include ++# include ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++struct rand_meth_st { ++ int (*seed) (const void *buf, int num); ++ int (*bytes) (unsigned char *buf, int num); ++ void (*cleanup) (void); ++ int (*add) (const void *buf, int num, double randomness); ++ int (*pseudorand) (unsigned char *buf, int num); ++ int (*status) (void); ++}; ++ ++int RAND_set_rand_method(const RAND_METHOD *meth); ++const RAND_METHOD *RAND_get_rand_method(void); ++# ifndef OPENSSL_NO_ENGINE ++int RAND_set_rand_engine(ENGINE *engine); ++# endif ++ ++RAND_METHOD *RAND_OpenSSL(void); ++ ++# if OPENSSL_API_COMPAT < 0x10100000L ++# define RAND_cleanup() while(0) continue ++# endif ++int RAND_bytes(unsigned char *buf, int num); ++int RAND_priv_bytes(unsigned char *buf, int num); ++DEPRECATEDIN_1_1_0(int RAND_pseudo_bytes(unsigned char *buf, int num)) ++ ++void RAND_seed(const void *buf, int num); ++void RAND_keep_random_devices_open(int keep); ++ ++# if defined(__ANDROID__) && defined(__NDK_FPABI__) ++__NDK_FPABI__ /* __attribute__((pcs("aapcs"))) on ARM */ ++# endif ++void RAND_add(const void *buf, int num, double randomness); ++int RAND_load_file(const char *file, long max_bytes); ++int RAND_write_file(const char *file); ++const char *RAND_file_name(char *file, size_t num); ++int RAND_status(void); ++ ++# ifndef OPENSSL_NO_EGD ++int RAND_query_egd_bytes(const char *path, unsigned char *buf, int bytes); ++int RAND_egd(const char *path); ++int RAND_egd_bytes(const char *path, int bytes); ++# endif ++ ++int RAND_poll(void); ++ ++# if defined(_WIN32) && (defined(BASETYPES) || defined(_WINDEF_H)) ++/* application has to include in order to use these */ ++DEPRECATEDIN_1_1_0(void RAND_screen(void)) ++DEPRECATEDIN_1_1_0(int RAND_event(UINT, WPARAM, LPARAM)) ++# endif ++ ++#if !defined(OPENSSL_NO_FIPS) || !defined(OPENSSL_NO_CMVP) ++int FIPS_rand_set_method(const RAND_METHOD *meth); ++const RAND_METHOD *FIPS_rand_get_method(void); ++int FIPS_rand_strength(void); ++/* 1.0.0 compat functions */ ++int FIPS_rand_seed(const void *buf, int num); ++int FIPS_rand_bytes(unsigned char *out, int outlen); ++void FIPS_rand_reset(void); ++int FIPS_rand_status(void); ++#endif ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif +diff --git a/include/TA/openssl/openssl/randerr.h b/include/TA/openssl/openssl/randerr.h +new file mode 100644 +index 0000000..79d5790 +--- /dev/null ++++ b/include/TA/openssl/openssl/randerr.h +@@ -0,0 +1,94 @@ ++/* ++ * Generated by util/mkerr.pl DO NOT EDIT ++ * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved. ++ * ++ * Licensed under the OpenSSL license (the "License"). You may not use ++ * this file except in compliance with the License. You can obtain a copy ++ * in the file LICENSE in the source distribution or at ++ * https://www.openssl.org/source/license.html ++ */ ++ ++#ifndef HEADER_RANDERR_H ++# define HEADER_RANDERR_H ++ ++# include ++ ++# ifdef __cplusplus ++extern "C" ++# endif ++int ERR_load_RAND_strings(void); ++ ++/* ++ * RAND function codes. ++ */ ++# define RAND_F_DATA_COLLECT_METHOD 127 ++# define RAND_F_DRBG_BYTES 101 ++# define RAND_F_DRBG_GET_ENTROPY 105 ++# define RAND_F_DRBG_SETUP 117 ++# define RAND_F_GET_ENTROPY 106 ++# define RAND_F_RAND_BYTES 100 ++# define RAND_F_RAND_DRBG_ENABLE_LOCKING 119 ++# define RAND_F_RAND_DRBG_GENERATE 107 ++# define RAND_F_RAND_DRBG_GET_ENTROPY 120 ++# define RAND_F_RAND_DRBG_GET_NONCE 123 ++# define RAND_F_RAND_DRBG_INSTANTIATE 108 ++# define RAND_F_RAND_DRBG_NEW 109 ++# define RAND_F_RAND_DRBG_RESEED 110 ++# define RAND_F_RAND_DRBG_RESTART 102 ++# define RAND_F_RAND_DRBG_SET 104 ++# define RAND_F_RAND_DRBG_SET_DEFAULTS 121 ++# define RAND_F_RAND_DRBG_UNINSTANTIATE 118 ++# define RAND_F_RAND_LOAD_FILE 111 ++# define RAND_F_RAND_POOL_ACQUIRE_ENTROPY 122 ++# define RAND_F_RAND_POOL_ADD 103 ++# define RAND_F_RAND_POOL_ADD_BEGIN 113 ++# define RAND_F_RAND_POOL_ADD_END 114 ++# define RAND_F_RAND_POOL_ATTACH 124 ++# define RAND_F_RAND_POOL_BYTES_NEEDED 115 ++# define RAND_F_RAND_POOL_GROW 125 ++# define RAND_F_RAND_POOL_NEW 116 ++# define RAND_F_RAND_PSEUDO_BYTES 126 ++# define RAND_F_RAND_WRITE_FILE 112 ++ ++/* ++ * RAND reason codes. ++ */ ++# define RAND_R_ADDITIONAL_INPUT_TOO_LONG 102 ++# define RAND_R_ALREADY_INSTANTIATED 103 ++# define RAND_R_ARGUMENT_OUT_OF_RANGE 105 ++# define RAND_R_CANNOT_OPEN_FILE 121 ++# define RAND_R_DRBG_ALREADY_INITIALIZED 129 ++# define RAND_R_DRBG_NOT_INITIALISED 104 ++# define RAND_R_ENTROPY_INPUT_TOO_LONG 106 ++# define RAND_R_ENTROPY_OUT_OF_RANGE 124 ++# define RAND_R_ERROR_ENTROPY_POOL_WAS_IGNORED 127 ++# define RAND_R_ERROR_INITIALISING_DRBG 107 ++# define RAND_R_ERROR_INSTANTIATING_DRBG 108 ++# define RAND_R_ERROR_RETRIEVING_ADDITIONAL_INPUT 109 ++# define RAND_R_ERROR_RETRIEVING_ENTROPY 110 ++# define RAND_R_ERROR_RETRIEVING_NONCE 111 ++# define RAND_R_FAILED_TO_CREATE_LOCK 126 ++# define RAND_R_FUNC_NOT_IMPLEMENTED 101 ++# define RAND_R_FWRITE_ERROR 123 ++# define RAND_R_GENERATE_ERROR 112 ++# define RAND_R_INTERNAL_ERROR 113 ++# define RAND_R_IN_ERROR_STATE 114 ++# define RAND_R_NOT_A_REGULAR_FILE 122 ++# define RAND_R_NOT_INSTANTIATED 115 ++# define RAND_R_NO_DRBG_IMPLEMENTATION_SELECTED 128 ++# define RAND_R_PARENT_LOCKING_NOT_ENABLED 130 ++# define RAND_R_PARENT_STRENGTH_TOO_WEAK 131 ++# define RAND_R_PERSONALISATION_STRING_TOO_LONG 116 ++# define RAND_R_PREDICTION_RESISTANCE_NOT_SUPPORTED 133 ++# define RAND_R_PRNG_NOT_SEEDED 100 ++# define RAND_R_RANDOM_POOL_OVERFLOW 125 ++# define RAND_R_RANDOM_POOL_UNDERFLOW 134 ++# define RAND_R_REQUEST_TOO_LARGE_FOR_DRBG 117 ++# define RAND_R_RESEED_ERROR 118 ++# define RAND_R_SELFTEST_FAILURE 119 ++# define RAND_R_TOO_LITTLE_NONCE_REQUESTED 135 ++# define RAND_R_TOO_MUCH_NONCE_REQUESTED 136 ++# define RAND_R_UNSUPPORTED_DRBG_FLAGS 132 ++# define RAND_R_UNSUPPORTED_DRBG_TYPE 120 ++ ++#endif +diff --git a/include/TA/openssl/openssl/rsa.h b/include/TA/openssl/openssl/rsa.h +new file mode 100644 +index 0000000..459f0d2 +--- /dev/null ++++ b/include/TA/openssl/openssl/rsa.h +@@ -0,0 +1,518 @@ ++/* ++ * Copyright 1995-2018 The OpenSSL Project Authors. All Rights Reserved. ++ * ++ * Licensed under the OpenSSL license (the "License"). You may not use ++ * this file except in compliance with the License. You can obtain a copy ++ * in the file LICENSE in the source distribution or at ++ * https://www.openssl.org/source/license.html ++ */ ++ ++#ifndef HEADER_RSA_H ++# define HEADER_RSA_H ++ ++# include ++ ++# ifndef OPENSSL_NO_RSA ++# include ++# include ++# include ++# include ++# if OPENSSL_API_COMPAT < 0x10100000L ++# include ++# endif ++# include ++# ifdef __cplusplus ++extern "C" { ++# endif ++ ++/* The types RSA and RSA_METHOD are defined in ossl_typ.h */ ++ ++# ifndef OPENSSL_RSA_MAX_MODULUS_BITS ++# define OPENSSL_RSA_MAX_MODULUS_BITS 16384 ++# endif ++ ++# ifndef OPENSSL_NO_FIPS ++ # define OPENSSL_RSA_FIPS_MIN_MODULUS_BITS 2048 ++ # define OPENSSL_RSA_FIPS_MIN_MODULUS_BITS_LEGACY 1024 ++#else ++ # define OPENSSL_RSA_FIPS_MIN_MODULUS_BITS 1024 ++# endif ++ ++# ifndef OPENSSL_RSA_SMALL_MODULUS_BITS ++# define OPENSSL_RSA_SMALL_MODULUS_BITS 3072 ++# endif ++# ifndef OPENSSL_RSA_MAX_PUBEXP_BITS ++ ++/* exponent limit enforced for "large" modulus only */ ++# define OPENSSL_RSA_MAX_PUBEXP_BITS 64 ++# endif ++ ++# define RSA_3 0x3L ++# define RSA_F4 0x10001L ++ ++/* based on RFC 8017 appendix A.1.2 */ ++# define RSA_ASN1_VERSION_DEFAULT 0 ++# define RSA_ASN1_VERSION_MULTI 1 ++ ++# define RSA_DEFAULT_PRIME_NUM 2 ++ ++# define RSA_METHOD_FLAG_NO_CHECK 0x0001/* don't check pub/private ++ * match */ ++ ++# define RSA_FLAG_CACHE_PUBLIC 0x0002 ++# define RSA_FLAG_CACHE_PRIVATE 0x0004 ++# define RSA_FLAG_BLINDING 0x0008 ++# define RSA_FLAG_THREAD_SAFE 0x0010 ++/* ++ * This flag means the private key operations will be handled by rsa_mod_exp ++ * and that they do not depend on the private key components being present: ++ * for example a key stored in external hardware. Without this flag ++ * bn_mod_exp gets called when private key components are absent. ++ */ ++# define RSA_FLAG_EXT_PKEY 0x0020 ++ ++/* ++ * new with 0.9.6j and 0.9.7b; the built-in ++ * RSA implementation now uses blinding by ++ * default (ignoring RSA_FLAG_BLINDING), ++ * but other engines might not need it ++ */ ++# define RSA_FLAG_NO_BLINDING 0x0080 ++# if OPENSSL_API_COMPAT < 0x10100000L ++/* ++ * Does nothing. Previously this switched off constant time behaviour. ++ */ ++# define RSA_FLAG_NO_CONSTTIME 0x0000 ++# endif ++# if OPENSSL_API_COMPAT < 0x00908000L ++/* deprecated name for the flag*/ ++/* ++ * new with 0.9.7h; the built-in RSA ++ * implementation now uses constant time ++ * modular exponentiation for secret exponents ++ * by default. This flag causes the ++ * faster variable sliding window method to ++ * be used for all exponents. ++ */ ++# define RSA_FLAG_NO_EXP_CONSTTIME RSA_FLAG_NO_CONSTTIME ++# endif ++ ++# define EVP_PKEY_CTX_set_rsa_padding(ctx, pad) \ ++ RSA_pkey_ctx_ctrl(ctx, -1, EVP_PKEY_CTRL_RSA_PADDING, pad, NULL) ++ ++# define EVP_PKEY_CTX_get_rsa_padding(ctx, ppad) \ ++ RSA_pkey_ctx_ctrl(ctx, -1, EVP_PKEY_CTRL_GET_RSA_PADDING, 0, ppad) ++ ++# define EVP_PKEY_CTX_set_rsa_pss_saltlen(ctx, len) \ ++ RSA_pkey_ctx_ctrl(ctx, (EVP_PKEY_OP_SIGN|EVP_PKEY_OP_VERIFY), \ ++ EVP_PKEY_CTRL_RSA_PSS_SALTLEN, len, NULL) ++/* Salt length matches digest */ ++# define RSA_PSS_SALTLEN_DIGEST -1 ++/* Verify only: auto detect salt length */ ++# define RSA_PSS_SALTLEN_AUTO -2 ++/* Set salt length to maximum possible */ ++# define RSA_PSS_SALTLEN_MAX -3 ++/* Old compatible max salt length for sign only */ ++# define RSA_PSS_SALTLEN_MAX_SIGN -2 ++ ++# define EVP_PKEY_CTX_set_rsa_pss_keygen_saltlen(ctx, len) \ ++ EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_RSA_PSS, EVP_PKEY_OP_KEYGEN, \ ++ EVP_PKEY_CTRL_RSA_PSS_SALTLEN, len, NULL) ++ ++# define EVP_PKEY_CTX_get_rsa_pss_saltlen(ctx, plen) \ ++ RSA_pkey_ctx_ctrl(ctx, (EVP_PKEY_OP_SIGN|EVP_PKEY_OP_VERIFY), \ ++ EVP_PKEY_CTRL_GET_RSA_PSS_SALTLEN, 0, plen) ++ ++# define EVP_PKEY_CTX_set_rsa_keygen_bits(ctx, bits) \ ++ RSA_pkey_ctx_ctrl(ctx, EVP_PKEY_OP_KEYGEN, \ ++ EVP_PKEY_CTRL_RSA_KEYGEN_BITS, bits, NULL) ++ ++# define EVP_PKEY_CTX_set_rsa_keygen_pubexp(ctx, pubexp) \ ++ RSA_pkey_ctx_ctrl(ctx, EVP_PKEY_OP_KEYGEN, \ ++ EVP_PKEY_CTRL_RSA_KEYGEN_PUBEXP, 0, pubexp) ++ ++# define EVP_PKEY_CTX_set_rsa_keygen_primes(ctx, primes) \ ++ RSA_pkey_ctx_ctrl(ctx, EVP_PKEY_OP_KEYGEN, \ ++ EVP_PKEY_CTRL_RSA_KEYGEN_PRIMES, primes, NULL) ++ ++# define EVP_PKEY_CTX_set_rsa_mgf1_md(ctx, md) \ ++ RSA_pkey_ctx_ctrl(ctx, EVP_PKEY_OP_TYPE_SIG | EVP_PKEY_OP_TYPE_CRYPT, \ ++ EVP_PKEY_CTRL_RSA_MGF1_MD, 0, (void *)(md)) ++ ++# define EVP_PKEY_CTX_set_rsa_pss_keygen_mgf1_md(ctx, md) \ ++ EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_RSA_PSS, EVP_PKEY_OP_KEYGEN, \ ++ EVP_PKEY_CTRL_RSA_MGF1_MD, 0, (void *)(md)) ++ ++# define EVP_PKEY_CTX_set_rsa_oaep_md(ctx, md) \ ++ EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_RSA, EVP_PKEY_OP_TYPE_CRYPT, \ ++ EVP_PKEY_CTRL_RSA_OAEP_MD, 0, (void *)(md)) ++ ++# define EVP_PKEY_CTX_get_rsa_mgf1_md(ctx, pmd) \ ++ RSA_pkey_ctx_ctrl(ctx, EVP_PKEY_OP_TYPE_SIG | EVP_PKEY_OP_TYPE_CRYPT, \ ++ EVP_PKEY_CTRL_GET_RSA_MGF1_MD, 0, (void *)(pmd)) ++ ++# define EVP_PKEY_CTX_get_rsa_oaep_md(ctx, pmd) \ ++ EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_RSA, EVP_PKEY_OP_TYPE_CRYPT, \ ++ EVP_PKEY_CTRL_GET_RSA_OAEP_MD, 0, (void *)(pmd)) ++ ++# define EVP_PKEY_CTX_set0_rsa_oaep_label(ctx, l, llen) \ ++ EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_RSA, EVP_PKEY_OP_TYPE_CRYPT, \ ++ EVP_PKEY_CTRL_RSA_OAEP_LABEL, llen, (void *)(l)) ++ ++# define EVP_PKEY_CTX_get0_rsa_oaep_label(ctx, l) \ ++ EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_RSA, EVP_PKEY_OP_TYPE_CRYPT, \ ++ EVP_PKEY_CTRL_GET_RSA_OAEP_LABEL, 0, (void *)(l)) ++ ++# define EVP_PKEY_CTX_set_rsa_pss_keygen_md(ctx, md) \ ++ EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_RSA_PSS, \ ++ EVP_PKEY_OP_KEYGEN, EVP_PKEY_CTRL_MD, \ ++ 0, (void *)(md)) ++ ++# define EVP_PKEY_CTRL_RSA_PADDING (EVP_PKEY_ALG_CTRL + 1) ++# define EVP_PKEY_CTRL_RSA_PSS_SALTLEN (EVP_PKEY_ALG_CTRL + 2) ++ ++# define EVP_PKEY_CTRL_RSA_KEYGEN_BITS (EVP_PKEY_ALG_CTRL + 3) ++# define EVP_PKEY_CTRL_RSA_KEYGEN_PUBEXP (EVP_PKEY_ALG_CTRL + 4) ++# define EVP_PKEY_CTRL_RSA_MGF1_MD (EVP_PKEY_ALG_CTRL + 5) ++ ++# define EVP_PKEY_CTRL_GET_RSA_PADDING (EVP_PKEY_ALG_CTRL + 6) ++# define EVP_PKEY_CTRL_GET_RSA_PSS_SALTLEN (EVP_PKEY_ALG_CTRL + 7) ++# define EVP_PKEY_CTRL_GET_RSA_MGF1_MD (EVP_PKEY_ALG_CTRL + 8) ++ ++# define EVP_PKEY_CTRL_RSA_OAEP_MD (EVP_PKEY_ALG_CTRL + 9) ++# define EVP_PKEY_CTRL_RSA_OAEP_LABEL (EVP_PKEY_ALG_CTRL + 10) ++ ++# define EVP_PKEY_CTRL_GET_RSA_OAEP_MD (EVP_PKEY_ALG_CTRL + 11) ++# define EVP_PKEY_CTRL_GET_RSA_OAEP_LABEL (EVP_PKEY_ALG_CTRL + 12) ++ ++# define EVP_PKEY_CTRL_RSA_KEYGEN_PRIMES (EVP_PKEY_ALG_CTRL + 13) ++ ++# define RSA_PKCS1_PADDING 1 ++# define RSA_SSLV23_PADDING 2 ++# define RSA_NO_PADDING 3 ++# define RSA_PKCS1_OAEP_PADDING 4 ++# define RSA_X931_PADDING 5 ++/* EVP_PKEY_ only */ ++# define RSA_PKCS1_PSS_PADDING 6 ++ ++# define RSA_PKCS1_PADDING_SIZE 11 ++ ++# define RSA_set_app_data(s,arg) RSA_set_ex_data(s,0,arg) ++# define RSA_get_app_data(s) RSA_get_ex_data(s,0) ++ ++RSA *RSA_new(void); ++RSA *RSA_new_method(ENGINE *engine); ++int RSA_bits(const RSA *rsa); ++int RSA_size(const RSA *rsa); ++int RSA_security_bits(const RSA *rsa); ++ ++int RSA_set0_key(RSA *r, BIGNUM *n, BIGNUM *e, BIGNUM *d); ++int RSA_set0_factors(RSA *r, BIGNUM *p, BIGNUM *q); ++int RSA_set0_crt_params(RSA *r,BIGNUM *dmp1, BIGNUM *dmq1, BIGNUM *iqmp); ++int RSA_set0_multi_prime_params(RSA *r, BIGNUM *primes[], BIGNUM *exps[], ++ BIGNUM *coeffs[], int pnum); ++void RSA_get0_key(const RSA *r, ++ const BIGNUM **n, const BIGNUM **e, const BIGNUM **d); ++void RSA_get0_factors(const RSA *r, const BIGNUM **p, const BIGNUM **q); ++int RSA_get_multi_prime_extra_count(const RSA *r); ++int RSA_get0_multi_prime_factors(const RSA *r, const BIGNUM *primes[]); ++void RSA_get0_crt_params(const RSA *r, ++ const BIGNUM **dmp1, const BIGNUM **dmq1, ++ const BIGNUM **iqmp); ++int RSA_get0_multi_prime_crt_params(const RSA *r, const BIGNUM *exps[], ++ const BIGNUM *coeffs[]); ++const BIGNUM *RSA_get0_n(const RSA *d); ++const BIGNUM *RSA_get0_e(const RSA *d); ++const BIGNUM *RSA_get0_d(const RSA *d); ++const BIGNUM *RSA_get0_p(const RSA *d); ++const BIGNUM *RSA_get0_q(const RSA *d); ++const BIGNUM *RSA_get0_dmp1(const RSA *r); ++const BIGNUM *RSA_get0_dmq1(const RSA *r); ++const BIGNUM *RSA_get0_iqmp(const RSA *r); ++const RSA_PSS_PARAMS *RSA_get0_pss_params(const RSA *r); ++void RSA_clear_flags(RSA *r, int flags); ++int RSA_test_flags(const RSA *r, int flags); ++void RSA_set_flags(RSA *r, int flags); ++int RSA_get_version(RSA *r); ++ENGINE *RSA_get0_engine(const RSA *r); ++ ++/* Deprecated version */ ++DEPRECATEDIN_0_9_8(RSA *RSA_generate_key(int bits, unsigned long e, void ++ (*callback) (int, int, void *), ++ void *cb_arg)) ++ ++/* New version */ ++int RSA_generate_key_ex(RSA *rsa, int bits, BIGNUM *e, BN_GENCB *cb); ++/* Multi-prime version */ ++int RSA_generate_multi_prime_key(RSA *rsa, int bits, int primes, ++ BIGNUM *e, BN_GENCB *cb); ++ ++int RSA_X931_derive_ex(RSA *rsa, BIGNUM *p1, BIGNUM *p2, BIGNUM *q1, ++ BIGNUM *q2, const BIGNUM *Xp1, const BIGNUM *Xp2, ++ const BIGNUM *Xp, const BIGNUM *Xq1, const BIGNUM *Xq2, ++ const BIGNUM *Xq, const BIGNUM *e, BN_GENCB *cb); ++int RSA_X931_generate_key_ex(RSA *rsa, int bits, const BIGNUM *e, ++ BN_GENCB *cb); ++ ++int RSA_check_key(const RSA *); ++int RSA_check_key_ex(const RSA *, BN_GENCB *cb); ++ /* next 4 return -1 on error */ ++int RSA_public_encrypt(int flen, const unsigned char *from, ++ unsigned char *to, RSA *rsa, int padding); ++int RSA_private_encrypt(int flen, const unsigned char *from, ++ unsigned char *to, RSA *rsa, int padding); ++int RSA_public_decrypt(int flen, const unsigned char *from, ++ unsigned char *to, RSA *rsa, int padding); ++int RSA_private_decrypt(int flen, const unsigned char *from, ++ unsigned char *to, RSA *rsa, int padding); ++void RSA_free(RSA *r); ++/* "up" the RSA object's reference count */ ++int RSA_up_ref(RSA *r); ++ ++int RSA_flags(const RSA *r); ++ ++void RSA_set_default_method(const RSA_METHOD *meth); ++const RSA_METHOD *RSA_get_default_method(void); ++const RSA_METHOD *RSA_null_method(void); ++const RSA_METHOD *RSA_get_method(const RSA *rsa); ++int RSA_set_method(RSA *rsa, const RSA_METHOD *meth); ++ ++/* these are the actual RSA functions */ ++const RSA_METHOD *RSA_PKCS1_OpenSSL(void); ++ ++int RSA_pkey_ctx_ctrl(EVP_PKEY_CTX *ctx, int optype, int cmd, int p1, void *p2); ++ ++DECLARE_ASN1_ENCODE_FUNCTIONS_const(RSA, RSAPublicKey) ++DECLARE_ASN1_ENCODE_FUNCTIONS_const(RSA, RSAPrivateKey) ++ ++struct rsa_pss_params_st { ++ X509_ALGOR *hashAlgorithm; ++ X509_ALGOR *maskGenAlgorithm; ++ ASN1_INTEGER *saltLength; ++ ASN1_INTEGER *trailerField; ++ /* Decoded hash algorithm from maskGenAlgorithm */ ++ X509_ALGOR *maskHash; ++}; ++ ++DECLARE_ASN1_FUNCTIONS(RSA_PSS_PARAMS) ++ ++typedef struct rsa_oaep_params_st { ++ X509_ALGOR *hashFunc; ++ X509_ALGOR *maskGenFunc; ++ X509_ALGOR *pSourceFunc; ++ /* Decoded hash algorithm from maskGenFunc */ ++ X509_ALGOR *maskHash; ++} RSA_OAEP_PARAMS; ++ ++DECLARE_ASN1_FUNCTIONS(RSA_OAEP_PARAMS) ++ ++# ifndef OPENSSL_NO_STDIO ++int RSA_print_fp(FILE *fp, const RSA *r, int offset); ++# endif ++ ++int RSA_print(BIO *bp, const RSA *r, int offset); ++ ++/* ++ * The following 2 functions sign and verify a X509_SIG ASN1 object inside ++ * PKCS#1 padded RSA encryption ++ */ ++int RSA_sign(int type, const unsigned char *m, unsigned int m_length, ++ unsigned char *sigret, unsigned int *siglen, RSA *rsa); ++int RSA_verify(int type, const unsigned char *m, unsigned int m_length, ++ const unsigned char *sigbuf, unsigned int siglen, RSA *rsa); ++ ++/* ++ * The following 2 function sign and verify a ASN1_OCTET_STRING object inside ++ * PKCS#1 padded RSA encryption ++ */ ++int RSA_sign_ASN1_OCTET_STRING(int type, ++ const unsigned char *m, unsigned int m_length, ++ unsigned char *sigret, unsigned int *siglen, ++ RSA *rsa); ++int RSA_verify_ASN1_OCTET_STRING(int type, const unsigned char *m, ++ unsigned int m_length, unsigned char *sigbuf, ++ unsigned int siglen, RSA *rsa); ++ ++int RSA_blinding_on(RSA *rsa, BN_CTX *ctx); ++void RSA_blinding_off(RSA *rsa); ++BN_BLINDING *RSA_setup_blinding(RSA *rsa, BN_CTX *ctx); ++ ++int RSA_padding_add_PKCS1_type_1(unsigned char *to, int tlen, ++ const unsigned char *f, int fl); ++int RSA_padding_check_PKCS1_type_1(unsigned char *to, int tlen, ++ const unsigned char *f, int fl, ++ int rsa_len); ++int RSA_padding_add_PKCS1_type_2(unsigned char *to, int tlen, ++ const unsigned char *f, int fl); ++int RSA_padding_check_PKCS1_type_2(unsigned char *to, int tlen, ++ const unsigned char *f, int fl, ++ int rsa_len); ++int PKCS1_MGF1(unsigned char *mask, long len, const unsigned char *seed, ++ long seedlen, const EVP_MD *dgst); ++int RSA_padding_add_PKCS1_OAEP(unsigned char *to, int tlen, ++ const unsigned char *f, int fl, ++ const unsigned char *p, int pl); ++int RSA_padding_check_PKCS1_OAEP(unsigned char *to, int tlen, ++ const unsigned char *f, int fl, int rsa_len, ++ const unsigned char *p, int pl); ++int RSA_padding_add_PKCS1_OAEP_mgf1(unsigned char *to, int tlen, ++ const unsigned char *from, int flen, ++ const unsigned char *param, int plen, ++ const EVP_MD *md, const EVP_MD *mgf1md); ++int RSA_padding_check_PKCS1_OAEP_mgf1(unsigned char *to, int tlen, ++ const unsigned char *from, int flen, ++ int num, const unsigned char *param, ++ int plen, const EVP_MD *md, ++ const EVP_MD *mgf1md); ++int RSA_padding_add_SSLv23(unsigned char *to, int tlen, ++ const unsigned char *f, int fl); ++int RSA_padding_check_SSLv23(unsigned char *to, int tlen, ++ const unsigned char *f, int fl, int rsa_len); ++int RSA_padding_add_none(unsigned char *to, int tlen, const unsigned char *f, ++ int fl); ++int RSA_padding_check_none(unsigned char *to, int tlen, ++ const unsigned char *f, int fl, int rsa_len); ++int RSA_padding_add_X931(unsigned char *to, int tlen, const unsigned char *f, ++ int fl); ++int RSA_padding_check_X931(unsigned char *to, int tlen, ++ const unsigned char *f, int fl, int rsa_len); ++int RSA_X931_hash_id(int nid); ++ ++int RSA_verify_PKCS1_PSS(RSA *rsa, const unsigned char *mHash, ++ const EVP_MD *Hash, const unsigned char *EM, ++ int sLen); ++int RSA_padding_add_PKCS1_PSS(RSA *rsa, unsigned char *EM, ++ const unsigned char *mHash, const EVP_MD *Hash, ++ int sLen); ++ ++int RSA_verify_PKCS1_PSS_mgf1(RSA *rsa, const unsigned char *mHash, ++ const EVP_MD *Hash, const EVP_MD *mgf1Hash, ++ const unsigned char *EM, int sLen); ++ ++int RSA_padding_add_PKCS1_PSS_mgf1(RSA *rsa, unsigned char *EM, ++ const unsigned char *mHash, ++ const EVP_MD *Hash, const EVP_MD *mgf1Hash, ++ int sLen); ++ ++#define RSA_get_ex_new_index(l, p, newf, dupf, freef) \ ++ CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_RSA, l, p, newf, dupf, freef) ++int RSA_set_ex_data(RSA *r, int idx, void *arg); ++void *RSA_get_ex_data(const RSA *r, int idx); ++ ++RSA *RSAPublicKey_dup(RSA *rsa); ++RSA *RSAPrivateKey_dup(RSA *rsa); ++ ++/* ++ * If this flag is set the RSA method is FIPS compliant and can be used in ++ * FIPS mode. This is set in the validated module method. If an application ++ * sets this flag in its own methods it is its responsibility to ensure the ++ * result is compliant. ++ */ ++ ++# define RSA_FLAG_FIPS_METHOD 0x0400 ++ ++/* ++ * If this flag is set the operations normally disabled in FIPS mode are ++ * permitted it is then the applications responsibility to ensure that the ++ * usage is compliant. ++ */ ++ ++# define RSA_FLAG_NON_FIPS_ALLOW 0x0400 ++/* ++ * Application has decided PRNG is good enough to generate a key: don't ++ * check. ++ */ ++# define RSA_FLAG_CHECKED 0x0800 ++ ++RSA_METHOD *RSA_meth_new(const char *name, int flags); ++void RSA_meth_free(RSA_METHOD *meth); ++RSA_METHOD *RSA_meth_dup(const RSA_METHOD *meth); ++const char *RSA_meth_get0_name(const RSA_METHOD *meth); ++int RSA_meth_set1_name(RSA_METHOD *meth, const char *name); ++int RSA_meth_get_flags(const RSA_METHOD *meth); ++int RSA_meth_set_flags(RSA_METHOD *meth, int flags); ++void *RSA_meth_get0_app_data(const RSA_METHOD *meth); ++int RSA_meth_set0_app_data(RSA_METHOD *meth, void *app_data); ++int (*RSA_meth_get_pub_enc(const RSA_METHOD *meth)) ++ (int flen, const unsigned char *from, ++ unsigned char *to, RSA *rsa, int padding); ++int RSA_meth_set_pub_enc(RSA_METHOD *rsa, ++ int (*pub_enc) (int flen, const unsigned char *from, ++ unsigned char *to, RSA *rsa, ++ int padding)); ++int (*RSA_meth_get_pub_dec(const RSA_METHOD *meth)) ++ (int flen, const unsigned char *from, ++ unsigned char *to, RSA *rsa, int padding); ++int RSA_meth_set_pub_dec(RSA_METHOD *rsa, ++ int (*pub_dec) (int flen, const unsigned char *from, ++ unsigned char *to, RSA *rsa, ++ int padding)); ++int (*RSA_meth_get_priv_enc(const RSA_METHOD *meth)) ++ (int flen, const unsigned char *from, ++ unsigned char *to, RSA *rsa, int padding); ++int RSA_meth_set_priv_enc(RSA_METHOD *rsa, ++ int (*priv_enc) (int flen, const unsigned char *from, ++ unsigned char *to, RSA *rsa, ++ int padding)); ++int (*RSA_meth_get_priv_dec(const RSA_METHOD *meth)) ++ (int flen, const unsigned char *from, ++ unsigned char *to, RSA *rsa, int padding); ++int RSA_meth_set_priv_dec(RSA_METHOD *rsa, ++ int (*priv_dec) (int flen, const unsigned char *from, ++ unsigned char *to, RSA *rsa, ++ int padding)); ++int (*RSA_meth_get_mod_exp(const RSA_METHOD *meth)) ++ (BIGNUM *r0, const BIGNUM *i, RSA *rsa, BN_CTX *ctx); ++int RSA_meth_set_mod_exp(RSA_METHOD *rsa, ++ int (*mod_exp) (BIGNUM *r0, const BIGNUM *i, RSA *rsa, ++ BN_CTX *ctx)); ++int (*RSA_meth_get_bn_mod_exp(const RSA_METHOD *meth)) ++ (BIGNUM *r, const BIGNUM *a, const BIGNUM *p, ++ const BIGNUM *m, BN_CTX *ctx, BN_MONT_CTX *m_ctx); ++int RSA_meth_set_bn_mod_exp(RSA_METHOD *rsa, ++ int (*bn_mod_exp) (BIGNUM *r, ++ const BIGNUM *a, ++ const BIGNUM *p, ++ const BIGNUM *m, ++ BN_CTX *ctx, ++ BN_MONT_CTX *m_ctx)); ++int (*RSA_meth_get_init(const RSA_METHOD *meth)) (RSA *rsa); ++int RSA_meth_set_init(RSA_METHOD *rsa, int (*init) (RSA *rsa)); ++int (*RSA_meth_get_finish(const RSA_METHOD *meth)) (RSA *rsa); ++int RSA_meth_set_finish(RSA_METHOD *rsa, int (*finish) (RSA *rsa)); ++int (*RSA_meth_get_sign(const RSA_METHOD *meth)) ++ (int type, ++ const unsigned char *m, unsigned int m_length, ++ unsigned char *sigret, unsigned int *siglen, ++ const RSA *rsa); ++int RSA_meth_set_sign(RSA_METHOD *rsa, ++ int (*sign) (int type, const unsigned char *m, ++ unsigned int m_length, ++ unsigned char *sigret, unsigned int *siglen, ++ const RSA *rsa)); ++int (*RSA_meth_get_verify(const RSA_METHOD *meth)) ++ (int dtype, const unsigned char *m, ++ unsigned int m_length, const unsigned char *sigbuf, ++ unsigned int siglen, const RSA *rsa); ++int RSA_meth_set_verify(RSA_METHOD *rsa, ++ int (*verify) (int dtype, const unsigned char *m, ++ unsigned int m_length, ++ const unsigned char *sigbuf, ++ unsigned int siglen, const RSA *rsa)); ++int (*RSA_meth_get_keygen(const RSA_METHOD *meth)) ++ (RSA *rsa, int bits, BIGNUM *e, BN_GENCB *cb); ++int RSA_meth_set_keygen(RSA_METHOD *rsa, ++ int (*keygen) (RSA *rsa, int bits, BIGNUM *e, ++ BN_GENCB *cb)); ++int (*RSA_meth_get_multi_prime_keygen(const RSA_METHOD *meth)) ++ (RSA *rsa, int bits, int primes, BIGNUM *e, BN_GENCB *cb); ++int RSA_meth_set_multi_prime_keygen(RSA_METHOD *meth, ++ int (*keygen) (RSA *rsa, int bits, ++ int primes, BIGNUM *e, ++ BN_GENCB *cb)); ++ ++# ifdef __cplusplus ++} ++# endif ++# endif ++#endif +diff --git a/include/TA/openssl/openssl/rsaerr.h b/include/TA/openssl/openssl/rsaerr.h +new file mode 100644 +index 0000000..30a39de +--- /dev/null ++++ b/include/TA/openssl/openssl/rsaerr.h +@@ -0,0 +1,174 @@ ++/* ++ * Generated by util/mkerr.pl DO NOT EDIT ++ * Copyright 1995-2019 The OpenSSL Project Authors. All Rights Reserved. ++ * ++ * Licensed under the OpenSSL license (the "License"). You may not use ++ * this file except in compliance with the License. You can obtain a copy ++ * in the file LICENSE in the source distribution or at ++ * https://www.openssl.org/source/license.html ++ */ ++ ++#ifndef HEADER_RSAERR_H ++# define HEADER_RSAERR_H ++ ++# ifndef HEADER_SYMHACKS_H ++# include ++# endif ++ ++# ifdef __cplusplus ++extern "C" ++# endif ++int ERR_load_RSA_strings(void); ++ ++/* ++ * RSA function codes. ++ */ ++# define RSA_F_CHECK_PADDING_MD 140 ++# define RSA_F_ENCODE_PKCS1 146 ++# define RSA_F_INT_RSA_VERIFY 145 ++# define RSA_F_OLD_RSA_PRIV_DECODE 147 ++# define RSA_F_PKEY_PSS_INIT 165 ++# define RSA_F_PKEY_RSA_CTRL 143 ++# define RSA_F_PKEY_RSA_CTRL_STR 144 ++# define RSA_F_PKEY_RSA_SIGN 142 ++# define RSA_F_PKEY_RSA_VERIFY 149 ++# define RSA_F_PKEY_RSA_VERIFYRECOVER 141 ++# define RSA_F_RSA_ALGOR_TO_MD 156 ++# define RSA_F_RSA_BUILTIN_KEYGEN 129 ++# define RSA_F_RSA_CHECK_KEY 123 ++# define RSA_F_RSA_CHECK_KEY_EX 160 ++# define RSA_F_RSA_CMS_DECRYPT 159 ++# define RSA_F_RSA_CMS_VERIFY 158 ++# define RSA_F_RSA_ITEM_VERIFY 148 ++# define RSA_F_RSA_METH_DUP 161 ++# define RSA_F_RSA_METH_NEW 162 ++# define RSA_F_RSA_METH_SET1_NAME 163 ++# define RSA_F_RSA_MGF1_TO_MD 157 ++# define RSA_F_RSA_MULTIP_INFO_NEW 166 ++# define RSA_F_RSA_NEW_METHOD 106 ++# define RSA_F_RSA_NULL 124 ++# define RSA_F_RSA_NULL_PRIVATE_DECRYPT 132 ++# define RSA_F_RSA_NULL_PRIVATE_ENCRYPT 133 ++# define RSA_F_RSA_NULL_PUBLIC_DECRYPT 134 ++# define RSA_F_RSA_NULL_PUBLIC_ENCRYPT 135 ++# define RSA_F_RSA_OSSL_PRIVATE_DECRYPT 101 ++# define RSA_F_RSA_OSSL_PRIVATE_ENCRYPT 102 ++# define RSA_F_RSA_OSSL_PUBLIC_DECRYPT 103 ++# define RSA_F_RSA_OSSL_PUBLIC_ENCRYPT 104 ++# define RSA_F_RSA_PADDING_ADD_NONE 107 ++# define RSA_F_RSA_PADDING_ADD_PKCS1_OAEP 121 ++# define RSA_F_RSA_PADDING_ADD_PKCS1_OAEP_MGF1 154 ++# define RSA_F_RSA_PADDING_ADD_PKCS1_PSS 125 ++# define RSA_F_RSA_PADDING_ADD_PKCS1_PSS_MGF1 152 ++# define RSA_F_RSA_PADDING_ADD_PKCS1_TYPE_1 108 ++# define RSA_F_RSA_PADDING_ADD_PKCS1_TYPE_2 109 ++# define RSA_F_RSA_PADDING_ADD_SSLV23 110 ++# define RSA_F_RSA_PADDING_ADD_X931 127 ++# define RSA_F_RSA_PADDING_CHECK_NONE 111 ++# define RSA_F_RSA_PADDING_CHECK_PKCS1_OAEP 122 ++# define RSA_F_RSA_PADDING_CHECK_PKCS1_OAEP_MGF1 153 ++# define RSA_F_RSA_PADDING_CHECK_PKCS1_TYPE_1 112 ++# define RSA_F_RSA_PADDING_CHECK_PKCS1_TYPE_2 113 ++# define RSA_F_RSA_PADDING_CHECK_SSLV23 114 ++# define RSA_F_RSA_PADDING_CHECK_X931 128 ++# define RSA_F_RSA_PARAM_DECODE 164 ++# define RSA_F_RSA_PRINT 115 ++# define RSA_F_RSA_PRINT_FP 116 ++# define RSA_F_RSA_PRIV_DECODE 150 ++# define RSA_F_RSA_PRIV_ENCODE 138 ++# define RSA_F_RSA_PSS_GET_PARAM 151 ++# define RSA_F_RSA_PSS_TO_CTX 155 ++# define RSA_F_RSA_PUB_DECODE 139 ++# define RSA_F_RSA_SETUP_BLINDING 136 ++# define RSA_F_RSA_SIGN 117 ++# define RSA_F_RSA_SIGN_ASN1_OCTET_STRING 118 ++# define RSA_F_RSA_VERIFY 119 ++# define RSA_F_RSA_VERIFY_ASN1_OCTET_STRING 120 ++# define RSA_F_RSA_VERIFY_PKCS1_PSS_MGF1 126 ++# define RSA_F_SETUP_TBUF 167 ++#ifndef OPENSSL_NO_FIPS ++# define RSA_F_RSA_GENERATE_MULTI_PRIME_KEY 207 ++# define RSA_F_FIPS_NDCPP_RSA_BUILTIN_KEYGEN 206 ++#endif ++ ++/* ++ * RSA reason codes. ++ */ ++# define RSA_R_ALGORITHM_MISMATCH 100 ++# define RSA_R_BAD_E_VALUE 101 ++# define RSA_R_BAD_FIXED_HEADER_DECRYPT 102 ++# define RSA_R_BAD_PAD_BYTE_COUNT 103 ++# define RSA_R_BAD_SIGNATURE 104 ++# define RSA_R_BLOCK_TYPE_IS_NOT_01 106 ++# define RSA_R_BLOCK_TYPE_IS_NOT_02 107 ++# define RSA_R_DATA_GREATER_THAN_MOD_LEN 108 ++# define RSA_R_DATA_TOO_LARGE 109 ++# define RSA_R_DATA_TOO_LARGE_FOR_KEY_SIZE 110 ++# define RSA_R_DATA_TOO_LARGE_FOR_MODULUS 132 ++# define RSA_R_DATA_TOO_SMALL 111 ++# define RSA_R_DATA_TOO_SMALL_FOR_KEY_SIZE 122 ++# define RSA_R_DIGEST_DOES_NOT_MATCH 158 ++# define RSA_R_DIGEST_NOT_ALLOWED 145 ++# define RSA_R_DIGEST_TOO_BIG_FOR_RSA_KEY 112 ++# define RSA_R_DMP1_NOT_CONGRUENT_TO_D 124 ++# define RSA_R_DMQ1_NOT_CONGRUENT_TO_D 125 ++# define RSA_R_D_E_NOT_CONGRUENT_TO_1 123 ++# define RSA_R_FIRST_OCTET_INVALID 133 ++# define RSA_R_ILLEGAL_OR_UNSUPPORTED_PADDING_MODE 144 ++# define RSA_R_INVALID_DIGEST 157 ++# define RSA_R_INVALID_DIGEST_LENGTH 143 ++# define RSA_R_INVALID_HEADER 137 ++# define RSA_R_INVALID_LABEL 160 ++# define RSA_R_INVALID_MESSAGE_LENGTH 131 ++# define RSA_R_INVALID_MGF1_MD 156 ++# define RSA_R_INVALID_MULTI_PRIME_KEY 167 ++# define RSA_R_INVALID_OAEP_PARAMETERS 161 ++# define RSA_R_INVALID_PADDING 138 ++# define RSA_R_INVALID_PADDING_MODE 141 ++# define RSA_R_INVALID_PSS_PARAMETERS 149 ++# define RSA_R_INVALID_PSS_SALTLEN 146 ++# define RSA_R_INVALID_SALT_LENGTH 150 ++# define RSA_R_INVALID_TRAILER 139 ++# define RSA_R_INVALID_X931_DIGEST 142 ++# define RSA_R_IQMP_NOT_INVERSE_OF_Q 126 ++# define RSA_R_KEY_PRIME_NUM_INVALID 165 ++# define RSA_R_KEY_SIZE_TOO_SMALL 120 ++# define RSA_R_LAST_OCTET_INVALID 134 ++# define RSA_R_MISSING_PRIVATE_KEY 179 ++# define RSA_R_MGF1_DIGEST_NOT_ALLOWED 152 ++# define RSA_R_MODULUS_TOO_LARGE 105 ++# define RSA_R_MP_COEFFICIENT_NOT_INVERSE_OF_R 168 ++# define RSA_R_MP_EXPONENT_NOT_CONGRUENT_TO_D 169 ++# define RSA_R_MP_R_NOT_PRIME 170 ++# define RSA_R_NO_PUBLIC_EXPONENT 140 ++# define RSA_R_NULL_BEFORE_BLOCK_MISSING 113 ++# define RSA_R_N_DOES_NOT_EQUAL_PRODUCT_OF_PRIMES 172 ++# define RSA_R_N_DOES_NOT_EQUAL_P_Q 127 ++# define RSA_R_OAEP_DECODING_ERROR 121 ++# define RSA_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE 148 ++# define RSA_R_PADDING_CHECK_FAILED 114 ++# define RSA_R_PKCS_DECODING_ERROR 159 ++# define RSA_R_PSS_SALTLEN_TOO_SMALL 164 ++# define RSA_R_P_NOT_PRIME 128 ++# define RSA_R_Q_NOT_PRIME 129 ++# define RSA_R_RSA_OPERATIONS_NOT_SUPPORTED 130 ++# define RSA_R_SLEN_CHECK_FAILED 136 ++# define RSA_R_SLEN_RECOVERY_FAILED 135 ++# define RSA_R_SSLV3_ROLLBACK_ATTACK 115 ++# define RSA_R_THE_ASN1_OBJECT_IDENTIFIER_IS_NOT_KNOWN_FOR_THIS_MD 116 ++# define RSA_R_UNKNOWN_ALGORITHM_TYPE 117 ++# define RSA_R_UNKNOWN_DIGEST 166 ++# define RSA_R_UNKNOWN_MASK_DIGEST 151 ++# define RSA_R_UNKNOWN_PADDING_TYPE 118 ++# define RSA_R_UNSUPPORTED_ENCRYPTION_TYPE 162 ++# define RSA_R_UNSUPPORTED_LABEL_SOURCE 163 ++# define RSA_R_UNSUPPORTED_MASK_ALGORITHM 153 ++# define RSA_R_UNSUPPORTED_MASK_PARAMETER 154 ++# define RSA_R_UNSUPPORTED_SIGNATURE_TYPE 155 ++# define RSA_R_VALUE_MISSING 147 ++# define RSA_R_WRONG_SIGNATURE_LENGTH 119 ++#ifndef OPENSSL_NO_FIPS ++# define RSA_R_UNSUPPORTED_PARAMETERS 202 ++#endif ++ ++#endif +diff --git a/include/TA/openssl/openssl/safestack.h b/include/TA/openssl/openssl/safestack.h +new file mode 100644 +index 0000000..38b5578 +--- /dev/null ++++ b/include/TA/openssl/openssl/safestack.h +@@ -0,0 +1,207 @@ ++/* ++ * Copyright 1999-2019 The OpenSSL Project Authors. All Rights Reserved. ++ * ++ * Licensed under the OpenSSL license (the "License"). You may not use ++ * this file except in compliance with the License. You can obtain a copy ++ * in the file LICENSE in the source distribution or at ++ * https://www.openssl.org/source/license.html ++ */ ++ ++#ifndef HEADER_SAFESTACK_H ++# define HEADER_SAFESTACK_H ++ ++# include ++# include ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++# define STACK_OF(type) struct stack_st_##type ++ ++# define SKM_DEFINE_STACK_OF(t1, t2, t3) \ ++ STACK_OF(t1); \ ++ typedef int (*sk_##t1##_compfunc)(const t3 * const *a, const t3 *const *b); \ ++ typedef void (*sk_##t1##_freefunc)(t3 *a); \ ++ typedef t3 * (*sk_##t1##_copyfunc)(const t3 *a); \ ++ static ossl_unused ossl_inline int sk_##t1##_num(const STACK_OF(t1) *sk) \ ++ { \ ++ return OPENSSL_sk_num((const OPENSSL_STACK *)sk); \ ++ } \ ++ static ossl_unused ossl_inline t2 *sk_##t1##_value(const STACK_OF(t1) *sk, int idx) \ ++ { \ ++ return (t2 *)OPENSSL_sk_value((const OPENSSL_STACK *)sk, idx); \ ++ } \ ++ static ossl_unused ossl_inline STACK_OF(t1) *sk_##t1##_new(sk_##t1##_compfunc compare) \ ++ { \ ++ return (STACK_OF(t1) *)OPENSSL_sk_new((OPENSSL_sk_compfunc)compare); \ ++ } \ ++ static ossl_unused ossl_inline STACK_OF(t1) *sk_##t1##_new_null(void) \ ++ { \ ++ return (STACK_OF(t1) *)OPENSSL_sk_new_null(); \ ++ } \ ++ static ossl_unused ossl_inline STACK_OF(t1) *sk_##t1##_new_reserve(sk_##t1##_compfunc compare, int n) \ ++ { \ ++ return (STACK_OF(t1) *)OPENSSL_sk_new_reserve((OPENSSL_sk_compfunc)compare, n); \ ++ } \ ++ static ossl_unused ossl_inline int sk_##t1##_reserve(STACK_OF(t1) *sk, int n) \ ++ { \ ++ return OPENSSL_sk_reserve((OPENSSL_STACK *)sk, n); \ ++ } \ ++ static ossl_unused ossl_inline void sk_##t1##_free(STACK_OF(t1) *sk) \ ++ { \ ++ OPENSSL_sk_free((OPENSSL_STACK *)sk); \ ++ } \ ++ static ossl_unused ossl_inline void sk_##t1##_zero(STACK_OF(t1) *sk) \ ++ { \ ++ OPENSSL_sk_zero((OPENSSL_STACK *)sk); \ ++ } \ ++ static ossl_unused ossl_inline t2 *sk_##t1##_delete(STACK_OF(t1) *sk, int i) \ ++ { \ ++ return (t2 *)OPENSSL_sk_delete((OPENSSL_STACK *)sk, i); \ ++ } \ ++ static ossl_unused ossl_inline t2 *sk_##t1##_delete_ptr(STACK_OF(t1) *sk, t2 *ptr) \ ++ { \ ++ return (t2 *)OPENSSL_sk_delete_ptr((OPENSSL_STACK *)sk, \ ++ (const void *)ptr); \ ++ } \ ++ static ossl_unused ossl_inline int sk_##t1##_push(STACK_OF(t1) *sk, t2 *ptr) \ ++ { \ ++ return OPENSSL_sk_push((OPENSSL_STACK *)sk, (const void *)ptr); \ ++ } \ ++ static ossl_unused ossl_inline int sk_##t1##_unshift(STACK_OF(t1) *sk, t2 *ptr) \ ++ { \ ++ return OPENSSL_sk_unshift((OPENSSL_STACK *)sk, (const void *)ptr); \ ++ } \ ++ static ossl_unused ossl_inline t2 *sk_##t1##_pop(STACK_OF(t1) *sk) \ ++ { \ ++ return (t2 *)OPENSSL_sk_pop((OPENSSL_STACK *)sk); \ ++ } \ ++ static ossl_unused ossl_inline t2 *sk_##t1##_shift(STACK_OF(t1) *sk) \ ++ { \ ++ return (t2 *)OPENSSL_sk_shift((OPENSSL_STACK *)sk); \ ++ } \ ++ static ossl_unused ossl_inline void sk_##t1##_pop_free(STACK_OF(t1) *sk, sk_##t1##_freefunc freefunc) \ ++ { \ ++ OPENSSL_sk_pop_free((OPENSSL_STACK *)sk, (OPENSSL_sk_freefunc)freefunc); \ ++ } \ ++ static ossl_unused ossl_inline int sk_##t1##_insert(STACK_OF(t1) *sk, t2 *ptr, int idx) \ ++ { \ ++ return OPENSSL_sk_insert((OPENSSL_STACK *)sk, (const void *)ptr, idx); \ ++ } \ ++ static ossl_unused ossl_inline t2 *sk_##t1##_set(STACK_OF(t1) *sk, int idx, t2 *ptr) \ ++ { \ ++ return (t2 *)OPENSSL_sk_set((OPENSSL_STACK *)sk, idx, (const void *)ptr); \ ++ } \ ++ static ossl_unused ossl_inline int sk_##t1##_find(STACK_OF(t1) *sk, t2 *ptr) \ ++ { \ ++ return OPENSSL_sk_find((OPENSSL_STACK *)sk, (const void *)ptr); \ ++ } \ ++ static ossl_unused ossl_inline int sk_##t1##_find_ex(STACK_OF(t1) *sk, t2 *ptr) \ ++ { \ ++ return OPENSSL_sk_find_ex((OPENSSL_STACK *)sk, (const void *)ptr); \ ++ } \ ++ static ossl_unused ossl_inline void sk_##t1##_sort(STACK_OF(t1) *sk) \ ++ { \ ++ OPENSSL_sk_sort((OPENSSL_STACK *)sk); \ ++ } \ ++ static ossl_unused ossl_inline int sk_##t1##_is_sorted(const STACK_OF(t1) *sk) \ ++ { \ ++ return OPENSSL_sk_is_sorted((const OPENSSL_STACK *)sk); \ ++ } \ ++ static ossl_unused ossl_inline STACK_OF(t1) * sk_##t1##_dup(const STACK_OF(t1) *sk) \ ++ { \ ++ return (STACK_OF(t1) *)OPENSSL_sk_dup((const OPENSSL_STACK *)sk); \ ++ } \ ++ static ossl_unused ossl_inline STACK_OF(t1) *sk_##t1##_deep_copy(const STACK_OF(t1) *sk, \ ++ sk_##t1##_copyfunc copyfunc, \ ++ sk_##t1##_freefunc freefunc) \ ++ { \ ++ return (STACK_OF(t1) *)OPENSSL_sk_deep_copy((const OPENSSL_STACK *)sk, \ ++ (OPENSSL_sk_copyfunc)copyfunc, \ ++ (OPENSSL_sk_freefunc)freefunc); \ ++ } \ ++ static ossl_unused ossl_inline sk_##t1##_compfunc sk_##t1##_set_cmp_func(STACK_OF(t1) *sk, sk_##t1##_compfunc compare) \ ++ { \ ++ return (sk_##t1##_compfunc)OPENSSL_sk_set_cmp_func((OPENSSL_STACK *)sk, (OPENSSL_sk_compfunc)compare); \ ++ } ++ ++# define DEFINE_SPECIAL_STACK_OF(t1, t2) SKM_DEFINE_STACK_OF(t1, t2, t2) ++# define DEFINE_STACK_OF(t) SKM_DEFINE_STACK_OF(t, t, t) ++# define DEFINE_SPECIAL_STACK_OF_CONST(t1, t2) \ ++ SKM_DEFINE_STACK_OF(t1, const t2, t2) ++# define DEFINE_STACK_OF_CONST(t) SKM_DEFINE_STACK_OF(t, const t, t) ++ ++/*- ++ * Strings are special: normally an lhash entry will point to a single ++ * (somewhat) mutable object. In the case of strings: ++ * ++ * a) Instead of a single char, there is an array of chars, NUL-terminated. ++ * b) The string may have be immutable. ++ * ++ * So, they need their own declarations. Especially important for ++ * type-checking tools, such as Deputy. ++ * ++ * In practice, however, it appears to be hard to have a const ++ * string. For now, I'm settling for dealing with the fact it is a ++ * string at all. ++ */ ++typedef char *OPENSSL_STRING; ++typedef const char *OPENSSL_CSTRING; ++ ++/*- ++ * Confusingly, LHASH_OF(STRING) deals with char ** throughout, but ++ * STACK_OF(STRING) is really more like STACK_OF(char), only, as mentioned ++ * above, instead of a single char each entry is a NUL-terminated array of ++ * chars. So, we have to implement STRING specially for STACK_OF. This is ++ * dealt with in the autogenerated macros below. ++ */ ++DEFINE_SPECIAL_STACK_OF(OPENSSL_STRING, char) ++DEFINE_SPECIAL_STACK_OF_CONST(OPENSSL_CSTRING, char) ++ ++/* ++ * Similarly, we sometimes use a block of characters, NOT nul-terminated. ++ * These should also be distinguished from "normal" stacks. ++ */ ++typedef void *OPENSSL_BLOCK; ++DEFINE_SPECIAL_STACK_OF(OPENSSL_BLOCK, void) ++ ++/* ++ * If called without higher optimization (min. -xO3) the Oracle Developer ++ * Studio compiler generates code for the defined (static inline) functions ++ * above. ++ * This would later lead to the linker complaining about missing symbols when ++ * this header file is included but the resulting object is not linked against ++ * the Crypto library (openssl#6912). ++ */ ++# ifdef __SUNPRO_C ++# pragma weak OPENSSL_sk_num ++# pragma weak OPENSSL_sk_value ++# pragma weak OPENSSL_sk_new ++# pragma weak OPENSSL_sk_new_null ++# pragma weak OPENSSL_sk_new_reserve ++# pragma weak OPENSSL_sk_reserve ++# pragma weak OPENSSL_sk_free ++# pragma weak OPENSSL_sk_zero ++# pragma weak OPENSSL_sk_delete ++# pragma weak OPENSSL_sk_delete_ptr ++# pragma weak OPENSSL_sk_push ++# pragma weak OPENSSL_sk_unshift ++# pragma weak OPENSSL_sk_pop ++# pragma weak OPENSSL_sk_shift ++# pragma weak OPENSSL_sk_pop_free ++# pragma weak OPENSSL_sk_insert ++# pragma weak OPENSSL_sk_set ++# pragma weak OPENSSL_sk_find ++# pragma weak OPENSSL_sk_find_ex ++# pragma weak OPENSSL_sk_sort ++# pragma weak OPENSSL_sk_is_sorted ++# pragma weak OPENSSL_sk_dup ++# pragma weak OPENSSL_sk_deep_copy ++# pragma weak OPENSSL_sk_set_cmp_func ++# endif /* __SUNPRO_C */ ++ ++# ifdef __cplusplus ++} ++# endif ++#endif +diff --git a/include/TA/openssl/openssl/sha.h b/include/TA/openssl/openssl/sha.h +new file mode 100644 +index 0000000..4a47e6e +--- /dev/null ++++ b/include/TA/openssl/openssl/sha.h +@@ -0,0 +1,116 @@ ++/* ++ * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved. ++ * ++ * Licensed under the OpenSSL license (the "License"). You may not use ++ * this file except in compliance with the License. You can obtain a copy ++ * in the file LICENSE in the source distribution or at ++ * https://www.openssl.org/source/license.html ++ */ ++ ++#ifndef HEADER_SHA_H ++# define HEADER_SHA_H ++ ++# include ++# include ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++/*- ++ * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ++ * ! SHA_LONG has to be at least 32 bits wide. ! ++ * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ++ */ ++# define SHA_LONG unsigned int ++ ++# define SHA_LBLOCK 16 ++# define SHA_CBLOCK (SHA_LBLOCK*4)/* SHA treats input data as a ++ * contiguous array of 32 bit wide ++ * big-endian values. */ ++# define SHA_LAST_BLOCK (SHA_CBLOCK-8) ++# define SHA_DIGEST_LENGTH 20 ++ ++typedef struct SHAstate_st { ++ SHA_LONG h0, h1, h2, h3, h4; ++ SHA_LONG Nl, Nh; ++ SHA_LONG data[SHA_LBLOCK]; ++ unsigned int num; ++} SHA_CTX; ++ ++int SHA1_Init(SHA_CTX *c); ++int SHA1_Update(SHA_CTX *c, const void *data, size_t len); ++int SHA1_Final(unsigned char *md, SHA_CTX *c); ++unsigned char *SHA1(const unsigned char *d, size_t n, unsigned char *md); ++void SHA1_Transform(SHA_CTX *c, const unsigned char *data); ++ ++# define SHA256_CBLOCK (SHA_LBLOCK*4)/* SHA-256 treats input data as a ++ * contiguous array of 32 bit wide ++ * big-endian values. */ ++ ++typedef struct SHA256state_st { ++ SHA_LONG h[8]; ++ SHA_LONG Nl, Nh; ++ SHA_LONG data[SHA_LBLOCK]; ++ unsigned int num, md_len; ++} SHA256_CTX; ++ ++int SHA224_Init(SHA256_CTX *c); ++int SHA224_Update(SHA256_CTX *c, const void *data, size_t len); ++int SHA224_Final(unsigned char *md, SHA256_CTX *c); ++unsigned char *SHA224(const unsigned char *d, size_t n, unsigned char *md); ++int SHA256_Init(SHA256_CTX *c); ++int SHA256_Update(SHA256_CTX *c, const void *data, size_t len); ++int SHA256_Final(unsigned char *md, SHA256_CTX *c); ++unsigned char *SHA256(const unsigned char *d, size_t n, unsigned char *md); ++void SHA256_Transform(SHA256_CTX *c, const unsigned char *data); ++ ++# define SHA224_DIGEST_LENGTH 28 ++# define SHA256_DIGEST_LENGTH 32 ++# define SHA384_DIGEST_LENGTH 48 ++# define SHA512_DIGEST_LENGTH 64 ++ ++/* ++ * Unlike 32-bit digest algorithms, SHA-512 *relies* on SHA_LONG64 ++ * being exactly 64-bit wide. See Implementation Notes in sha512.c ++ * for further details. ++ */ ++/* ++ * SHA-512 treats input data as a ++ * contiguous array of 64 bit ++ * wide big-endian values. ++ */ ++# define SHA512_CBLOCK (SHA_LBLOCK*8) ++# if (defined(_WIN32) || defined(_WIN64)) && !defined(__MINGW32__) ++# define SHA_LONG64 unsigned __int64 ++# elif defined(__arch64__) ++# define SHA_LONG64 unsigned long ++# else ++# define SHA_LONG64 unsigned long long ++# endif ++ ++typedef struct SHA512state_st { ++ SHA_LONG64 h[8]; ++ SHA_LONG64 Nl, Nh; ++ union { ++ SHA_LONG64 d[SHA_LBLOCK]; ++ unsigned char p[SHA512_CBLOCK]; ++ } u; ++ unsigned int num, md_len; ++} SHA512_CTX; ++ ++int SHA384_Init(SHA512_CTX *c); ++int SHA384_Update(SHA512_CTX *c, const void *data, size_t len); ++int SHA384_Final(unsigned char *md, SHA512_CTX *c); ++unsigned char *SHA384(const unsigned char *d, size_t n, unsigned char *md); ++int SHA512_Init(SHA512_CTX *c); ++int SHA512_Update(SHA512_CTX *c, const void *data, size_t len); ++int SHA512_Final(unsigned char *md, SHA512_CTX *c); ++unsigned char *SHA512(const unsigned char *d, size_t n, unsigned char *md); ++void SHA512_Transform(SHA512_CTX *c, const unsigned char *data); ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif +diff --git a/include/TA/openssl/openssl/stack.h b/include/TA/openssl/openssl/stack.h +new file mode 100644 +index 0000000..cfc0750 +--- /dev/null ++++ b/include/TA/openssl/openssl/stack.h +@@ -0,0 +1,83 @@ ++/* ++ * Copyright 1995-2017 The OpenSSL Project Authors. All Rights Reserved. ++ * ++ * Licensed under the OpenSSL license (the "License"). You may not use ++ * this file except in compliance with the License. You can obtain a copy ++ * in the file LICENSE in the source distribution or at ++ * https://www.openssl.org/source/license.html ++ */ ++ ++#ifndef HEADER_STACK_H ++# define HEADER_STACK_H ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++typedef struct stack_st OPENSSL_STACK; /* Use STACK_OF(...) instead */ ++ ++typedef int (*OPENSSL_sk_compfunc)(const void *, const void *); ++typedef void (*OPENSSL_sk_freefunc)(void *); ++typedef void *(*OPENSSL_sk_copyfunc)(const void *); ++ ++int OPENSSL_sk_num(const OPENSSL_STACK *); ++void *OPENSSL_sk_value(const OPENSSL_STACK *, int); ++ ++void *OPENSSL_sk_set(OPENSSL_STACK *st, int i, const void *data); ++ ++OPENSSL_STACK *OPENSSL_sk_new(OPENSSL_sk_compfunc cmp); ++OPENSSL_STACK *OPENSSL_sk_new_null(void); ++OPENSSL_STACK *OPENSSL_sk_new_reserve(OPENSSL_sk_compfunc c, int n); ++int OPENSSL_sk_reserve(OPENSSL_STACK *st, int n); ++void OPENSSL_sk_free(OPENSSL_STACK *); ++void OPENSSL_sk_pop_free(OPENSSL_STACK *st, void (*func) (void *)); ++OPENSSL_STACK *OPENSSL_sk_deep_copy(const OPENSSL_STACK *, ++ OPENSSL_sk_copyfunc c, ++ OPENSSL_sk_freefunc f); ++int OPENSSL_sk_insert(OPENSSL_STACK *sk, const void *data, int where); ++void *OPENSSL_sk_delete(OPENSSL_STACK *st, int loc); ++void *OPENSSL_sk_delete_ptr(OPENSSL_STACK *st, const void *p); ++int OPENSSL_sk_find(OPENSSL_STACK *st, const void *data); ++int OPENSSL_sk_find_ex(OPENSSL_STACK *st, const void *data); ++int OPENSSL_sk_push(OPENSSL_STACK *st, const void *data); ++int OPENSSL_sk_unshift(OPENSSL_STACK *st, const void *data); ++void *OPENSSL_sk_shift(OPENSSL_STACK *st); ++void *OPENSSL_sk_pop(OPENSSL_STACK *st); ++void OPENSSL_sk_zero(OPENSSL_STACK *st); ++OPENSSL_sk_compfunc OPENSSL_sk_set_cmp_func(OPENSSL_STACK *sk, ++ OPENSSL_sk_compfunc cmp); ++OPENSSL_STACK *OPENSSL_sk_dup(const OPENSSL_STACK *st); ++void OPENSSL_sk_sort(OPENSSL_STACK *st); ++int OPENSSL_sk_is_sorted(const OPENSSL_STACK *st); ++ ++# if OPENSSL_API_COMPAT < 0x10100000L ++# define _STACK OPENSSL_STACK ++# define sk_num OPENSSL_sk_num ++# define sk_value OPENSSL_sk_value ++# define sk_set OPENSSL_sk_set ++# define sk_new OPENSSL_sk_new ++# define sk_new_null OPENSSL_sk_new_null ++# define sk_free OPENSSL_sk_free ++# define sk_pop_free OPENSSL_sk_pop_free ++# define sk_deep_copy OPENSSL_sk_deep_copy ++# define sk_insert OPENSSL_sk_insert ++# define sk_delete OPENSSL_sk_delete ++# define sk_delete_ptr OPENSSL_sk_delete_ptr ++# define sk_find OPENSSL_sk_find ++# define sk_find_ex OPENSSL_sk_find_ex ++# define sk_push OPENSSL_sk_push ++# define sk_unshift OPENSSL_sk_unshift ++# define sk_shift OPENSSL_sk_shift ++# define sk_pop OPENSSL_sk_pop ++# define sk_zero OPENSSL_sk_zero ++# define sk_set_cmp_func OPENSSL_sk_set_cmp_func ++# define sk_dup OPENSSL_sk_dup ++# define sk_sort OPENSSL_sk_sort ++# define sk_is_sorted OPENSSL_sk_is_sorted ++# endif ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif +diff --git a/include/TA/openssl/openssl/symhacks.h b/include/TA/openssl/openssl/symhacks.h +new file mode 100644 +index 0000000..156ea6e +--- /dev/null ++++ b/include/TA/openssl/openssl/symhacks.h +@@ -0,0 +1,37 @@ ++/* ++ * Copyright 1999-2018 The OpenSSL Project Authors. All Rights Reserved. ++ * ++ * Licensed under the OpenSSL license (the "License"). You may not use ++ * this file except in compliance with the License. You can obtain a copy ++ * in the file LICENSE in the source distribution or at ++ * https://www.openssl.org/source/license.html ++ */ ++ ++#ifndef HEADER_SYMHACKS_H ++# define HEADER_SYMHACKS_H ++ ++# include ++ ++/* Case insensitive linking causes problems.... */ ++# if defined(OPENSSL_SYS_VMS) ++# undef ERR_load_CRYPTO_strings ++# define ERR_load_CRYPTO_strings ERR_load_CRYPTOlib_strings ++# undef OCSP_crlID_new ++# define OCSP_crlID_new OCSP_crlID2_new ++ ++# undef d2i_ECPARAMETERS ++# define d2i_ECPARAMETERS d2i_UC_ECPARAMETERS ++# undef i2d_ECPARAMETERS ++# define i2d_ECPARAMETERS i2d_UC_ECPARAMETERS ++# undef d2i_ECPKPARAMETERS ++# define d2i_ECPKPARAMETERS d2i_UC_ECPKPARAMETERS ++# undef i2d_ECPKPARAMETERS ++# define i2d_ECPKPARAMETERS i2d_UC_ECPKPARAMETERS ++ ++/* This one clashes with CMS_data_create */ ++# undef cms_Data_create ++# define cms_Data_create priv_cms_Data_create ++ ++# endif ++ ++#endif /* ! defined HEADER_VMS_IDHACKS_H */ +diff --git a/include/TA/openssl/openssl/x509.h b/include/TA/openssl/openssl/x509.h +new file mode 100644 +index 0000000..efdde0e +--- /dev/null ++++ b/include/TA/openssl/openssl/x509.h +@@ -0,0 +1,1065 @@ ++/* ++ * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved. ++ * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved ++ * ++ * Licensed under the OpenSSL license (the "License"). You may not use ++ * this file except in compliance with the License. You can obtain a copy ++ * in the file LICENSE in the source distribution or at ++ * https://www.openssl.org/source/license.html ++ */ ++ ++#ifndef HEADER_X509_H ++# define HEADER_X509_H ++ ++# include ++# include ++# include ++# include ++# include ++# include ++# include ++# include ++# include ++ ++# if OPENSSL_API_COMPAT < 0x10100000L ++# include ++# include ++# include ++# endif ++ ++# include ++# include ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++/* Flags for X509_get_signature_info() */ ++/* Signature info is valid */ ++# define X509_SIG_INFO_VALID 0x1 ++/* Signature is suitable for TLS use */ ++# define X509_SIG_INFO_TLS 0x2 ++ ++# define X509_FILETYPE_PEM 1 ++# define X509_FILETYPE_ASN1 2 ++# define X509_FILETYPE_DEFAULT 3 ++ ++# define X509v3_KU_DIGITAL_SIGNATURE 0x0080 ++# define X509v3_KU_NON_REPUDIATION 0x0040 ++# define X509v3_KU_KEY_ENCIPHERMENT 0x0020 ++# define X509v3_KU_DATA_ENCIPHERMENT 0x0010 ++# define X509v3_KU_KEY_AGREEMENT 0x0008 ++# define X509v3_KU_KEY_CERT_SIGN 0x0004 ++# define X509v3_KU_CRL_SIGN 0x0002 ++# define X509v3_KU_ENCIPHER_ONLY 0x0001 ++# define X509v3_KU_DECIPHER_ONLY 0x8000 ++# define X509v3_KU_UNDEF 0xffff ++#define X509v3_KU_SM2_SIGN (X509v3_KU_DIGITAL_SIGNATURE | X509v3_KU_NON_REPUDIATION) ++#define X509v3_KU_SM2_ENC_ENCIPHERMENT (X509v3_KU_KEY_ENCIPHERMENT | X509v3_KU_DATA_ENCIPHERMENT) ++#define X509v3_KU_SM2_ENC_CIPHER_ONLY (X509v3_KU_ENCIPHER_ONLY | X509v3_KU_DECIPHER_ONLY) ++ ++struct X509_algor_st { ++ ASN1_OBJECT *algorithm; ++ ASN1_TYPE *parameter; ++} /* X509_ALGOR */ ; ++ ++typedef STACK_OF(X509_ALGOR) X509_ALGORS; ++ ++typedef struct X509_val_st { ++ ASN1_TIME *notBefore; ++ ASN1_TIME *notAfter; ++} X509_VAL; ++ ++typedef struct X509_sig_st X509_SIG; ++ ++typedef struct X509_name_entry_st X509_NAME_ENTRY; ++ ++DEFINE_STACK_OF(X509_NAME_ENTRY) ++ ++DEFINE_STACK_OF(X509_NAME) ++ ++# define X509_EX_V_NETSCAPE_HACK 0x8000 ++# define X509_EX_V_INIT 0x0001 ++typedef struct X509_extension_st X509_EXTENSION; ++ ++typedef STACK_OF(X509_EXTENSION) X509_EXTENSIONS; ++ ++DEFINE_STACK_OF(X509_EXTENSION) ++ ++typedef struct x509_attributes_st X509_ATTRIBUTE; ++ ++DEFINE_STACK_OF(X509_ATTRIBUTE) ++ ++typedef struct X509_req_info_st X509_REQ_INFO; ++ ++typedef struct X509_req_st X509_REQ; ++ ++typedef struct x509_cert_aux_st X509_CERT_AUX; ++ ++typedef struct x509_cinf_st X509_CINF; ++ ++DEFINE_STACK_OF(X509) ++ ++/* This is used for a table of trust checking functions */ ++ ++typedef struct x509_trust_st { ++ int trust; ++ int flags; ++ int (*check_trust) (struct x509_trust_st *, X509 *, int); ++ char *name; ++ int arg1; ++ void *arg2; ++} X509_TRUST; ++ ++DEFINE_STACK_OF(X509_TRUST) ++ ++/* standard trust ids */ ++ ++# define X509_TRUST_DEFAULT 0 /* Only valid in purpose settings */ ++ ++# define X509_TRUST_COMPAT 1 ++# define X509_TRUST_SSL_CLIENT 2 ++# define X509_TRUST_SSL_SERVER 3 ++# define X509_TRUST_EMAIL 4 ++# define X509_TRUST_OBJECT_SIGN 5 ++# define X509_TRUST_OCSP_SIGN 6 ++# define X509_TRUST_OCSP_REQUEST 7 ++# define X509_TRUST_TSA 8 ++ ++/* Keep these up to date! */ ++# define X509_TRUST_MIN 1 ++# define X509_TRUST_MAX 8 ++ ++/* trust_flags values */ ++# define X509_TRUST_DYNAMIC (1U << 0) ++# define X509_TRUST_DYNAMIC_NAME (1U << 1) ++/* No compat trust if self-signed, preempts "DO_SS" */ ++# define X509_TRUST_NO_SS_COMPAT (1U << 2) ++/* Compat trust if no explicit accepted trust EKUs */ ++# define X509_TRUST_DO_SS_COMPAT (1U << 3) ++/* Accept "anyEKU" as a wildcard trust OID */ ++# define X509_TRUST_OK_ANY_EKU (1U << 4) ++ ++/* check_trust return codes */ ++ ++# define X509_TRUST_TRUSTED 1 ++# define X509_TRUST_REJECTED 2 ++# define X509_TRUST_UNTRUSTED 3 ++ ++/* Flags for X509_print_ex() */ ++ ++# define X509_FLAG_COMPAT 0 ++# define X509_FLAG_NO_HEADER 1L ++# define X509_FLAG_NO_VERSION (1L << 1) ++# define X509_FLAG_NO_SERIAL (1L << 2) ++# define X509_FLAG_NO_SIGNAME (1L << 3) ++# define X509_FLAG_NO_ISSUER (1L << 4) ++# define X509_FLAG_NO_VALIDITY (1L << 5) ++# define X509_FLAG_NO_SUBJECT (1L << 6) ++# define X509_FLAG_NO_PUBKEY (1L << 7) ++# define X509_FLAG_NO_EXTENSIONS (1L << 8) ++# define X509_FLAG_NO_SIGDUMP (1L << 9) ++# define X509_FLAG_NO_AUX (1L << 10) ++# define X509_FLAG_NO_ATTRIBUTES (1L << 11) ++# define X509_FLAG_NO_IDS (1L << 12) ++ ++/* Flags specific to X509_NAME_print_ex() */ ++ ++/* The field separator information */ ++ ++# define XN_FLAG_SEP_MASK (0xf << 16) ++ ++# define XN_FLAG_COMPAT 0/* Traditional; use old X509_NAME_print */ ++# define XN_FLAG_SEP_COMMA_PLUS (1 << 16)/* RFC2253 ,+ */ ++# define XN_FLAG_SEP_CPLUS_SPC (2 << 16)/* ,+ spaced: more readable */ ++# define XN_FLAG_SEP_SPLUS_SPC (3 << 16)/* ;+ spaced */ ++# define XN_FLAG_SEP_MULTILINE (4 << 16)/* One line per field */ ++ ++# define XN_FLAG_DN_REV (1 << 20)/* Reverse DN order */ ++ ++/* How the field name is shown */ ++ ++# define XN_FLAG_FN_MASK (0x3 << 21) ++ ++# define XN_FLAG_FN_SN 0/* Object short name */ ++# define XN_FLAG_FN_LN (1 << 21)/* Object long name */ ++# define XN_FLAG_FN_OID (2 << 21)/* Always use OIDs */ ++# define XN_FLAG_FN_NONE (3 << 21)/* No field names */ ++ ++# define XN_FLAG_SPC_EQ (1 << 23)/* Put spaces round '=' */ ++ ++/* ++ * This determines if we dump fields we don't recognise: RFC2253 requires ++ * this. ++ */ ++ ++# define XN_FLAG_DUMP_UNKNOWN_FIELDS (1 << 24) ++ ++# define XN_FLAG_FN_ALIGN (1 << 25)/* Align field names to 20 ++ * characters */ ++ ++/* Complete set of RFC2253 flags */ ++ ++# define XN_FLAG_RFC2253 (ASN1_STRFLGS_RFC2253 | \ ++ XN_FLAG_SEP_COMMA_PLUS | \ ++ XN_FLAG_DN_REV | \ ++ XN_FLAG_FN_SN | \ ++ XN_FLAG_DUMP_UNKNOWN_FIELDS) ++ ++/* readable oneline form */ ++ ++# define XN_FLAG_ONELINE (ASN1_STRFLGS_RFC2253 | \ ++ ASN1_STRFLGS_ESC_QUOTE | \ ++ XN_FLAG_SEP_CPLUS_SPC | \ ++ XN_FLAG_SPC_EQ | \ ++ XN_FLAG_FN_SN) ++ ++/* readable multiline form */ ++ ++# define 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) ++ ++DEFINE_STACK_OF(X509_REVOKED) ++ ++typedef struct X509_crl_info_st X509_CRL_INFO; ++ ++DEFINE_STACK_OF(X509_CRL) ++ ++typedef struct private_key_st { ++ int version; ++ /* The PKCS#8 data types */ ++ X509_ALGOR *enc_algor; ++ ASN1_OCTET_STRING *enc_pkey; /* encrypted pub key */ ++ /* When decrypted, the following will not be NULL */ ++ EVP_PKEY *dec_pkey; ++ /* used to encrypt and decrypt */ ++ int key_length; ++ char *key_data; ++ int key_free; /* true if we should auto free key_data */ ++ /* expanded version of 'enc_algor' */ ++ EVP_CIPHER_INFO cipher; ++} X509_PKEY; ++ ++typedef struct X509_info_st { ++ X509 *x509; ++ X509_CRL *crl; ++ X509_PKEY *x_pkey; ++ EVP_CIPHER_INFO enc_cipher; ++ int enc_len; ++ char *enc_data; ++} X509_INFO; ++ ++DEFINE_STACK_OF(X509_INFO) ++ ++/* ++ * The next 2 structures and their 8 routines are used to manipulate Netscape's ++ * spki structures - useful if you are writing a CA web page ++ */ ++typedef struct Netscape_spkac_st { ++ X509_PUBKEY *pubkey; ++ ASN1_IA5STRING *challenge; /* challenge sent in atlas >= PR2 */ ++} NETSCAPE_SPKAC; ++ ++typedef struct Netscape_spki_st { ++ NETSCAPE_SPKAC *spkac; /* signed public key and challenge */ ++ X509_ALGOR sig_algor; ++ ASN1_BIT_STRING *signature; ++} NETSCAPE_SPKI; ++ ++/* Netscape certificate sequence structure */ ++typedef struct Netscape_certificate_sequence { ++ ASN1_OBJECT *type; ++ STACK_OF(X509) *certs; ++} NETSCAPE_CERT_SEQUENCE; ++ ++/*- Unused (and iv length is wrong) ++typedef struct CBCParameter_st ++ { ++ unsigned char iv[8]; ++ } CBC_PARAM; ++*/ ++ ++/* Password based encryption structure */ ++ ++typedef struct PBEPARAM_st { ++ ASN1_OCTET_STRING *salt; ++ ASN1_INTEGER *iter; ++} PBEPARAM; ++ ++/* Password based encryption V2 structures */ ++ ++typedef struct PBE2PARAM_st { ++ X509_ALGOR *keyfunc; ++ X509_ALGOR *encryption; ++} PBE2PARAM; ++ ++typedef struct PBKDF2PARAM_st { ++/* Usually OCTET STRING but could be anything */ ++ ASN1_TYPE *salt; ++ ASN1_INTEGER *iter; ++ ASN1_INTEGER *keylength; ++ X509_ALGOR *prf; ++} PBKDF2PARAM; ++ ++#ifndef OPENSSL_NO_SCRYPT ++typedef struct SCRYPT_PARAMS_st { ++ ASN1_OCTET_STRING *salt; ++ ASN1_INTEGER *costParameter; ++ ASN1_INTEGER *blockSize; ++ ASN1_INTEGER *parallelizationParameter; ++ ASN1_INTEGER *keyLength; ++} SCRYPT_PARAMS; ++#endif ++ ++#ifdef __cplusplus ++} ++#endif ++ ++# include ++# include ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++# define X509_EXT_PACK_UNKNOWN 1 ++# define X509_EXT_PACK_STRING 2 ++ ++# define X509_extract_key(x) X509_get_pubkey(x)/*****/ ++# define X509_REQ_extract_key(a) X509_REQ_get_pubkey(a) ++# define X509_name_cmp(a,b) X509_NAME_cmp((a),(b)) ++ ++void X509_CRL_set_default_method(const X509_CRL_METHOD *meth); ++X509_CRL_METHOD *X509_CRL_METHOD_new(int (*crl_init) (X509_CRL *crl), ++ int (*crl_free) (X509_CRL *crl), ++ int (*crl_lookup) (X509_CRL *crl, ++ X509_REVOKED **ret, ++ ASN1_INTEGER *ser, ++ X509_NAME *issuer), ++ int (*crl_verify) (X509_CRL *crl, ++ EVP_PKEY *pk)); ++void X509_CRL_METHOD_free(X509_CRL_METHOD *m); ++ ++void X509_CRL_set_meth_data(X509_CRL *crl, void *dat); ++void *X509_CRL_get_meth_data(X509_CRL *crl); ++ ++const char *X509_verify_cert_error_string(long n); ++ ++int X509_verify(X509 *a, EVP_PKEY *r); ++ ++int X509_REQ_verify(X509_REQ *a, EVP_PKEY *r); ++int X509_CRL_verify(X509_CRL *a, EVP_PKEY *r); ++int NETSCAPE_SPKI_verify(NETSCAPE_SPKI *a, EVP_PKEY *r); ++ ++NETSCAPE_SPKI *NETSCAPE_SPKI_b64_decode(const char *str, int len); ++char *NETSCAPE_SPKI_b64_encode(NETSCAPE_SPKI *x); ++EVP_PKEY *NETSCAPE_SPKI_get_pubkey(NETSCAPE_SPKI *x); ++int NETSCAPE_SPKI_set_pubkey(NETSCAPE_SPKI *x, EVP_PKEY *pkey); ++ ++int NETSCAPE_SPKI_print(BIO *out, NETSCAPE_SPKI *spki); ++ ++int X509_signature_dump(BIO *bp, const ASN1_STRING *sig, int indent); ++int X509_signature_print(BIO *bp, const X509_ALGOR *alg, ++ const ASN1_STRING *sig); ++ ++int X509_sign(X509 *x, EVP_PKEY *pkey, const EVP_MD *md); ++int X509_sign_ctx(X509 *x, EVP_MD_CTX *ctx); ++# ifndef OPENSSL_NO_OCSP ++int X509_http_nbio(OCSP_REQ_CTX *rctx, X509 **pcert); ++# endif ++int X509_REQ_sign(X509_REQ *x, EVP_PKEY *pkey, const EVP_MD *md); ++int X509_REQ_sign_ctx(X509_REQ *x, EVP_MD_CTX *ctx); ++int X509_CRL_sign(X509_CRL *x, EVP_PKEY *pkey, const EVP_MD *md); ++int X509_CRL_sign_ctx(X509_CRL *x, EVP_MD_CTX *ctx); ++# ifndef OPENSSL_NO_OCSP ++int X509_CRL_http_nbio(OCSP_REQ_CTX *rctx, X509_CRL **pcrl); ++# endif ++int NETSCAPE_SPKI_sign(NETSCAPE_SPKI *x, EVP_PKEY *pkey, const EVP_MD *md); ++ ++int X509_pubkey_digest(const X509 *data, const EVP_MD *type, ++ unsigned char *md, unsigned int *len); ++int X509_digest(const X509 *data, const EVP_MD *type, ++ unsigned char *md, unsigned int *len); ++int X509_CRL_digest(const X509_CRL *data, const EVP_MD *type, ++ unsigned char *md, unsigned int *len); ++int X509_REQ_digest(const X509_REQ *data, const EVP_MD *type, ++ unsigned char *md, unsigned int *len); ++int X509_NAME_digest(const X509_NAME *data, const EVP_MD *type, ++ unsigned char *md, unsigned int *len); ++ ++# ifndef OPENSSL_NO_STDIO ++X509 *d2i_X509_fp(FILE *fp, X509 **x509); ++int i2d_X509_fp(FILE *fp, X509 *x509); ++X509_CRL *d2i_X509_CRL_fp(FILE *fp, X509_CRL **crl); ++int i2d_X509_CRL_fp(FILE *fp, X509_CRL *crl); ++X509_REQ *d2i_X509_REQ_fp(FILE *fp, X509_REQ **req); ++int i2d_X509_REQ_fp(FILE *fp, X509_REQ *req); ++# ifndef OPENSSL_NO_RSA ++RSA *d2i_RSAPrivateKey_fp(FILE *fp, RSA **rsa); ++int i2d_RSAPrivateKey_fp(FILE *fp, RSA *rsa); ++RSA *d2i_RSAPublicKey_fp(FILE *fp, RSA **rsa); ++int i2d_RSAPublicKey_fp(FILE *fp, RSA *rsa); ++RSA *d2i_RSA_PUBKEY_fp(FILE *fp, RSA **rsa); ++int i2d_RSA_PUBKEY_fp(FILE *fp, RSA *rsa); ++# endif ++# ifndef OPENSSL_NO_DSA ++DSA *d2i_DSA_PUBKEY_fp(FILE *fp, DSA **dsa); ++int i2d_DSA_PUBKEY_fp(FILE *fp, DSA *dsa); ++DSA *d2i_DSAPrivateKey_fp(FILE *fp, DSA **dsa); ++int i2d_DSAPrivateKey_fp(FILE *fp, DSA *dsa); ++# endif ++# ifndef OPENSSL_NO_EC ++EC_KEY *d2i_EC_PUBKEY_fp(FILE *fp, EC_KEY **eckey); ++int i2d_EC_PUBKEY_fp(FILE *fp, EC_KEY *eckey); ++EC_KEY *d2i_ECPrivateKey_fp(FILE *fp, EC_KEY **eckey); ++int i2d_ECPrivateKey_fp(FILE *fp, EC_KEY *eckey); ++# endif ++X509_SIG *d2i_PKCS8_fp(FILE *fp, X509_SIG **p8); ++int i2d_PKCS8_fp(FILE *fp, X509_SIG *p8); ++PKCS8_PRIV_KEY_INFO *d2i_PKCS8_PRIV_KEY_INFO_fp(FILE *fp, ++ PKCS8_PRIV_KEY_INFO **p8inf); ++int i2d_PKCS8_PRIV_KEY_INFO_fp(FILE *fp, PKCS8_PRIV_KEY_INFO *p8inf); ++int i2d_PKCS8PrivateKeyInfo_fp(FILE *fp, EVP_PKEY *key); ++int i2d_PrivateKey_fp(FILE *fp, EVP_PKEY *pkey); ++EVP_PKEY *d2i_PrivateKey_fp(FILE *fp, EVP_PKEY **a); ++int i2d_PUBKEY_fp(FILE *fp, EVP_PKEY *pkey); ++EVP_PKEY *d2i_PUBKEY_fp(FILE *fp, EVP_PKEY **a); ++# endif ++ ++X509 *d2i_X509_bio(BIO *bp, X509 **x509); ++int i2d_X509_bio(BIO *bp, X509 *x509); ++X509_CRL *d2i_X509_CRL_bio(BIO *bp, X509_CRL **crl); ++int i2d_X509_CRL_bio(BIO *bp, X509_CRL *crl); ++X509_REQ *d2i_X509_REQ_bio(BIO *bp, X509_REQ **req); ++int i2d_X509_REQ_bio(BIO *bp, X509_REQ *req); ++# ifndef OPENSSL_NO_RSA ++RSA *d2i_RSAPrivateKey_bio(BIO *bp, RSA **rsa); ++int i2d_RSAPrivateKey_bio(BIO *bp, RSA *rsa); ++RSA *d2i_RSAPublicKey_bio(BIO *bp, RSA **rsa); ++int i2d_RSAPublicKey_bio(BIO *bp, RSA *rsa); ++RSA *d2i_RSA_PUBKEY_bio(BIO *bp, RSA **rsa); ++int i2d_RSA_PUBKEY_bio(BIO *bp, RSA *rsa); ++# endif ++# ifndef OPENSSL_NO_DSA ++DSA *d2i_DSA_PUBKEY_bio(BIO *bp, DSA **dsa); ++int i2d_DSA_PUBKEY_bio(BIO *bp, DSA *dsa); ++DSA *d2i_DSAPrivateKey_bio(BIO *bp, DSA **dsa); ++int i2d_DSAPrivateKey_bio(BIO *bp, DSA *dsa); ++# endif ++# ifndef OPENSSL_NO_EC ++EC_KEY *d2i_EC_PUBKEY_bio(BIO *bp, EC_KEY **eckey); ++int i2d_EC_PUBKEY_bio(BIO *bp, EC_KEY *eckey); ++EC_KEY *d2i_ECPrivateKey_bio(BIO *bp, EC_KEY **eckey); ++int i2d_ECPrivateKey_bio(BIO *bp, EC_KEY *eckey); ++# endif ++X509_SIG *d2i_PKCS8_bio(BIO *bp, X509_SIG **p8); ++int i2d_PKCS8_bio(BIO *bp, X509_SIG *p8); ++PKCS8_PRIV_KEY_INFO *d2i_PKCS8_PRIV_KEY_INFO_bio(BIO *bp, ++ PKCS8_PRIV_KEY_INFO **p8inf); ++int i2d_PKCS8_PRIV_KEY_INFO_bio(BIO *bp, PKCS8_PRIV_KEY_INFO *p8inf); ++int i2d_PKCS8PrivateKeyInfo_bio(BIO *bp, EVP_PKEY *key); ++int i2d_PrivateKey_bio(BIO *bp, EVP_PKEY *pkey); ++EVP_PKEY *d2i_PrivateKey_bio(BIO *bp, EVP_PKEY **a); ++int i2d_PUBKEY_bio(BIO *bp, EVP_PKEY *pkey); ++EVP_PKEY *d2i_PUBKEY_bio(BIO *bp, EVP_PKEY **a); ++ ++X509 *X509_dup(X509 *x509); ++X509_ATTRIBUTE *X509_ATTRIBUTE_dup(X509_ATTRIBUTE *xa); ++X509_EXTENSION *X509_EXTENSION_dup(X509_EXTENSION *ex); ++X509_CRL *X509_CRL_dup(X509_CRL *crl); ++X509_REVOKED *X509_REVOKED_dup(X509_REVOKED *rev); ++X509_REQ *X509_REQ_dup(X509_REQ *req); ++X509_ALGOR *X509_ALGOR_dup(X509_ALGOR *xn); ++int X509_ALGOR_set0(X509_ALGOR *alg, ASN1_OBJECT *aobj, int ptype, ++ void *pval); ++void X509_ALGOR_get0(const ASN1_OBJECT **paobj, int *pptype, ++ const void **ppval, const X509_ALGOR *algor); ++void X509_ALGOR_set_md(X509_ALGOR *alg, const EVP_MD *md); ++int X509_ALGOR_cmp(const X509_ALGOR *a, const X509_ALGOR *b); ++int X509_ALGOR_copy(X509_ALGOR *dest, const X509_ALGOR *src); ++ ++X509_NAME *X509_NAME_dup(X509_NAME *xn); ++X509_NAME_ENTRY *X509_NAME_ENTRY_dup(X509_NAME_ENTRY *ne); ++ ++int X509_cmp_time(const ASN1_TIME *s, time_t *t); ++int X509_cmp_current_time(const ASN1_TIME *s); ++ASN1_TIME *X509_time_adj(ASN1_TIME *s, long adj, time_t *t); ++ASN1_TIME *X509_time_adj_ex(ASN1_TIME *s, ++ int offset_day, long offset_sec, time_t *t); ++ASN1_TIME *X509_gmtime_adj(ASN1_TIME *s, long adj); ++ ++const char *X509_get_default_cert_area(void); ++const char *X509_get_default_cert_dir(void); ++const char *X509_get_default_cert_file(void); ++const char *X509_get_default_cert_dir_env(void); ++const char *X509_get_default_cert_file_env(void); ++const char *X509_get_default_private_dir(void); ++ ++X509_REQ *X509_to_X509_REQ(X509 *x, EVP_PKEY *pkey, const EVP_MD *md); ++X509 *X509_REQ_to_X509(X509_REQ *r, int days, EVP_PKEY *pkey); ++ ++DECLARE_ASN1_FUNCTIONS(X509_ALGOR) ++DECLARE_ASN1_ENCODE_FUNCTIONS(X509_ALGORS, X509_ALGORS, X509_ALGORS) ++DECLARE_ASN1_FUNCTIONS(X509_VAL) ++ ++DECLARE_ASN1_FUNCTIONS(X509_PUBKEY) ++ ++int X509_PUBKEY_set(X509_PUBKEY **x, EVP_PKEY *pkey); ++EVP_PKEY *X509_PUBKEY_get0(X509_PUBKEY *key); ++EVP_PKEY *X509_PUBKEY_get(X509_PUBKEY *key); ++int X509_get_pubkey_parameters(EVP_PKEY *pkey, STACK_OF(X509) *chain); ++long X509_get_pathlen(X509 *x); ++int i2d_PUBKEY(EVP_PKEY *a, unsigned char **pp); ++EVP_PKEY *d2i_PUBKEY(EVP_PKEY **a, const unsigned char **pp, long length); ++# ifndef OPENSSL_NO_RSA ++int i2d_RSA_PUBKEY(RSA *a, unsigned char **pp); ++RSA *d2i_RSA_PUBKEY(RSA **a, const unsigned char **pp, long length); ++# endif ++# ifndef OPENSSL_NO_DSA ++int i2d_DSA_PUBKEY(DSA *a, unsigned char **pp); ++DSA *d2i_DSA_PUBKEY(DSA **a, const unsigned char **pp, long length); ++# endif ++# ifndef OPENSSL_NO_EC ++int i2d_EC_PUBKEY(EC_KEY *a, unsigned char **pp); ++EC_KEY *d2i_EC_PUBKEY(EC_KEY **a, const unsigned char **pp, long length); ++# endif ++ ++DECLARE_ASN1_FUNCTIONS(X509_SIG) ++void X509_SIG_get0(const X509_SIG *sig, const X509_ALGOR **palg, ++ const ASN1_OCTET_STRING **pdigest); ++void X509_SIG_getm(X509_SIG *sig, X509_ALGOR **palg, ++ ASN1_OCTET_STRING **pdigest); ++ ++DECLARE_ASN1_FUNCTIONS(X509_REQ_INFO) ++DECLARE_ASN1_FUNCTIONS(X509_REQ) ++ ++DECLARE_ASN1_FUNCTIONS(X509_ATTRIBUTE) ++X509_ATTRIBUTE *X509_ATTRIBUTE_create(int nid, int atrtype, void *value); ++ ++DECLARE_ASN1_FUNCTIONS(X509_EXTENSION) ++DECLARE_ASN1_ENCODE_FUNCTIONS(X509_EXTENSIONS, X509_EXTENSIONS, X509_EXTENSIONS) ++ ++DECLARE_ASN1_FUNCTIONS(X509_NAME_ENTRY) ++ ++DECLARE_ASN1_FUNCTIONS(X509_NAME) ++ ++int X509_NAME_set(X509_NAME **xn, X509_NAME *name); ++ ++DECLARE_ASN1_FUNCTIONS(X509_CINF) ++ ++DECLARE_ASN1_FUNCTIONS(X509) ++DECLARE_ASN1_FUNCTIONS(X509_CERT_AUX) ++ ++#define X509_get_ex_new_index(l, p, newf, dupf, freef) \ ++ CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_X509, l, p, newf, dupf, freef) ++int X509_set_ex_data(X509 *r, int idx, void *arg); ++void *X509_get_ex_data(X509 *r, int idx); ++int i2d_X509_AUX(X509 *a, unsigned char **pp); ++X509 *d2i_X509_AUX(X509 **a, const unsigned char **pp, long length); ++ ++int i2d_re_X509_tbs(X509 *x, unsigned char **pp); ++ ++int X509_SIG_INFO_get(const X509_SIG_INFO *siginf, int *mdnid, int *pknid, ++ int *secbits, uint32_t *flags); ++void X509_SIG_INFO_set(X509_SIG_INFO *siginf, int mdnid, int pknid, ++ int secbits, uint32_t flags); ++ ++int X509_get_signature_info(X509 *x, int *mdnid, int *pknid, int *secbits, ++ uint32_t *flags); ++ ++void X509_get0_signature(const ASN1_BIT_STRING **psig, ++ const X509_ALGOR **palg, const X509 *x); ++int X509_get_signature_nid(const X509 *x); ++ ++# ifndef OPENSSL_NO_SM2 ++void X509_set0_sm2_id(X509 *x, ASN1_OCTET_STRING *sm2_id); ++ASN1_OCTET_STRING *X509_get0_sm2_id(X509 *x); ++void X509_REQ_set0_sm2_id(X509_REQ *x, ASN1_OCTET_STRING *sm2_id); ++ASN1_OCTET_STRING *X509_REQ_get0_sm2_id(X509_REQ *x); ++# endif ++ ++int X509_trusted(const X509 *x); ++int X509_alias_set1(X509 *x, const unsigned char *name, int len); ++int X509_keyid_set1(X509 *x, const unsigned char *id, int len); ++unsigned char *X509_alias_get0(X509 *x, int *len); ++unsigned char *X509_keyid_get0(X509 *x, int *len); ++int (*X509_TRUST_set_default(int (*trust) (int, X509 *, int))) (int, X509 *, ++ int); ++int X509_TRUST_set(int *t, int trust); ++int X509_add1_trust_object(X509 *x, const ASN1_OBJECT *obj); ++int X509_add1_reject_object(X509 *x, const ASN1_OBJECT *obj); ++void X509_trust_clear(X509 *x); ++void X509_reject_clear(X509 *x); ++ ++STACK_OF(ASN1_OBJECT) *X509_get0_trust_objects(X509 *x); ++STACK_OF(ASN1_OBJECT) *X509_get0_reject_objects(X509 *x); ++ ++DECLARE_ASN1_FUNCTIONS(X509_REVOKED) ++DECLARE_ASN1_FUNCTIONS(X509_CRL_INFO) ++DECLARE_ASN1_FUNCTIONS(X509_CRL) ++ ++int X509_CRL_add0_revoked(X509_CRL *crl, X509_REVOKED *rev); ++int X509_CRL_get0_by_serial(X509_CRL *crl, ++ X509_REVOKED **ret, ASN1_INTEGER *serial); ++int X509_CRL_get0_by_cert(X509_CRL *crl, X509_REVOKED **ret, X509 *x); ++ ++X509_PKEY *X509_PKEY_new(void); ++void X509_PKEY_free(X509_PKEY *a); ++ ++DECLARE_ASN1_FUNCTIONS(NETSCAPE_SPKI) ++DECLARE_ASN1_FUNCTIONS(NETSCAPE_SPKAC) ++DECLARE_ASN1_FUNCTIONS(NETSCAPE_CERT_SEQUENCE) ++ ++X509_INFO *X509_INFO_new(void); ++void X509_INFO_free(X509_INFO *a); ++char *X509_NAME_oneline(const X509_NAME *a, char *buf, int size); ++ ++int ASN1_verify(i2d_of_void *i2d, X509_ALGOR *algor1, ++ ASN1_BIT_STRING *signature, char *data, EVP_PKEY *pkey); ++ ++int ASN1_digest(i2d_of_void *i2d, const EVP_MD *type, char *data, ++ unsigned char *md, unsigned int *len); ++ ++int ASN1_sign(i2d_of_void *i2d, X509_ALGOR *algor1, ++ X509_ALGOR *algor2, ASN1_BIT_STRING *signature, ++ char *data, EVP_PKEY *pkey, const EVP_MD *type); ++ ++int ASN1_item_digest(const ASN1_ITEM *it, const EVP_MD *type, void *data, ++ unsigned char *md, unsigned int *len); ++ ++int ASN1_item_verify(const ASN1_ITEM *it, X509_ALGOR *algor1, ++ ASN1_BIT_STRING *signature, void *data, EVP_PKEY *pkey); ++ ++int ASN1_item_sign(const ASN1_ITEM *it, X509_ALGOR *algor1, ++ X509_ALGOR *algor2, ASN1_BIT_STRING *signature, void *data, ++ EVP_PKEY *pkey, const EVP_MD *type); ++int ASN1_item_sign_ctx(const ASN1_ITEM *it, X509_ALGOR *algor1, ++ X509_ALGOR *algor2, ASN1_BIT_STRING *signature, ++ void *asn, EVP_MD_CTX *ctx); ++ ++long X509_get_version(const X509 *x); ++int X509_set_version(X509 *x, long version); ++int X509_set_serialNumber(X509 *x, ASN1_INTEGER *serial); ++ASN1_INTEGER *X509_get_serialNumber(X509 *x); ++const ASN1_INTEGER *X509_get0_serialNumber(const X509 *x); ++int X509_set_issuer_name(X509 *x, X509_NAME *name); ++X509_NAME *X509_get_issuer_name(const X509 *a); ++int X509_set_subject_name(X509 *x, X509_NAME *name); ++X509_NAME *X509_get_subject_name(const X509 *a); ++const ASN1_TIME * X509_get0_notBefore(const X509 *x); ++ASN1_TIME *X509_getm_notBefore(const X509 *x); ++int X509_set1_notBefore(X509 *x, const ASN1_TIME *tm); ++const ASN1_TIME *X509_get0_notAfter(const X509 *x); ++ASN1_TIME *X509_getm_notAfter(const X509 *x); ++int X509_set1_notAfter(X509 *x, const ASN1_TIME *tm); ++int X509_set_pubkey(X509 *x, EVP_PKEY *pkey); ++int X509_up_ref(X509 *x); ++int X509_get_signature_type(const X509 *x); ++ ++#ifndef OPENSSL_NO_X509_REQ_EXP_ATTR ++int X509_REQ_add1_exp_attr_by_NID(X509_REQ *req, ++ int nid, int type, ++ const unsigned char *bytes, int len); ++#endif ++ ++# if OPENSSL_API_COMPAT < 0x10100000L ++# define X509_get_notBefore X509_getm_notBefore ++# define X509_get_notAfter X509_getm_notAfter ++# define X509_set_notBefore X509_set1_notBefore ++# define X509_set_notAfter X509_set1_notAfter ++#endif ++ ++/* ++ * This one is only used so that a binary form can output, as in ++ * i2d_X509_PUBKEY(X509_get_X509_PUBKEY(x), &buf) ++ */ ++X509_PUBKEY *X509_get_X509_PUBKEY(const X509 *x); ++const STACK_OF(X509_EXTENSION) *X509_get0_extensions(const X509 *x); ++void X509_get0_uids(const X509 *x, const ASN1_BIT_STRING **piuid, ++ const ASN1_BIT_STRING **psuid); ++const X509_ALGOR *X509_get0_tbs_sigalg(const X509 *x); ++ ++EVP_PKEY *X509_get0_pubkey(const X509 *x); ++EVP_PKEY *X509_get_pubkey(X509 *x); ++ASN1_BIT_STRING *X509_get0_pubkey_bitstr(const X509 *x); ++int X509_certificate_type(const X509 *x, const EVP_PKEY *pubkey); ++ ++long X509_REQ_get_version(const X509_REQ *req); ++int X509_REQ_set_version(X509_REQ *x, long version); ++X509_NAME *X509_REQ_get_subject_name(const X509_REQ *req); ++int X509_REQ_set_subject_name(X509_REQ *req, X509_NAME *name); ++void X509_REQ_get0_signature(const X509_REQ *req, const ASN1_BIT_STRING **psig, ++ const X509_ALGOR **palg); ++void X509_REQ_set0_signature(X509_REQ *req, ASN1_BIT_STRING *psig); ++int X509_REQ_set1_signature_algo(X509_REQ *req, X509_ALGOR *palg); ++int X509_REQ_get_signature_nid(const X509_REQ *req); ++int i2d_re_X509_REQ_tbs(X509_REQ *req, unsigned char **pp); ++int X509_REQ_set_pubkey(X509_REQ *x, EVP_PKEY *pkey); ++EVP_PKEY *X509_REQ_get_pubkey(X509_REQ *req); ++EVP_PKEY *X509_REQ_get0_pubkey(X509_REQ *req); ++X509_PUBKEY *X509_REQ_get_X509_PUBKEY(X509_REQ *req); ++int X509_REQ_extension_nid(int nid); ++int *X509_REQ_get_extension_nids(void); ++void X509_REQ_set_extension_nids(int *nids); ++STACK_OF(X509_EXTENSION) *X509_REQ_get_extensions(X509_REQ *req); ++int X509_REQ_add_extensions_nid(X509_REQ *req, STACK_OF(X509_EXTENSION) *exts, ++ int nid); ++int X509_REQ_add_extensions(X509_REQ *req, STACK_OF(X509_EXTENSION) *exts); ++int X509_REQ_get_attr_count(const X509_REQ *req); ++int X509_REQ_get_attr_by_NID(const X509_REQ *req, int nid, int lastpos); ++int X509_REQ_get_attr_by_OBJ(const X509_REQ *req, const ASN1_OBJECT *obj, ++ int lastpos); ++X509_ATTRIBUTE *X509_REQ_get_attr(const X509_REQ *req, int loc); ++X509_ATTRIBUTE *X509_REQ_delete_attr(X509_REQ *req, int loc); ++int X509_REQ_add1_attr(X509_REQ *req, X509_ATTRIBUTE *attr); ++int X509_REQ_add1_attr_by_OBJ(X509_REQ *req, ++ const ASN1_OBJECT *obj, int type, ++ const unsigned char *bytes, int len); ++int X509_REQ_add1_attr_by_NID(X509_REQ *req, ++ int nid, int type, ++ const unsigned char *bytes, int len); ++int X509_REQ_add1_attr_by_txt(X509_REQ *req, ++ const char *attrname, int type, ++ const unsigned char *bytes, int len); ++ ++int X509_CRL_set_version(X509_CRL *x, long version); ++int X509_CRL_set_issuer_name(X509_CRL *x, X509_NAME *name); ++int X509_CRL_set1_lastUpdate(X509_CRL *x, const ASN1_TIME *tm); ++int X509_CRL_set1_nextUpdate(X509_CRL *x, const ASN1_TIME *tm); ++int X509_CRL_sort(X509_CRL *crl); ++int X509_CRL_up_ref(X509_CRL *crl); ++ ++# if OPENSSL_API_COMPAT < 0x10100000L ++# define X509_CRL_set_lastUpdate X509_CRL_set1_lastUpdate ++# define X509_CRL_set_nextUpdate X509_CRL_set1_nextUpdate ++#endif ++ ++long X509_CRL_get_version(const X509_CRL *crl); ++const ASN1_TIME *X509_CRL_get0_lastUpdate(const X509_CRL *crl); ++const ASN1_TIME *X509_CRL_get0_nextUpdate(const X509_CRL *crl); ++DEPRECATEDIN_1_1_0(ASN1_TIME *X509_CRL_get_lastUpdate(X509_CRL *crl)) ++DEPRECATEDIN_1_1_0(ASN1_TIME *X509_CRL_get_nextUpdate(X509_CRL *crl)) ++const unsigned char *X509_CRL_get_hash(const X509_CRL *crl); ++X509_NAME *X509_CRL_get_issuer(const X509_CRL *crl); ++const STACK_OF(X509_EXTENSION) *X509_CRL_get0_extensions(const X509_CRL *crl); ++STACK_OF(X509_REVOKED) *X509_CRL_get_REVOKED(X509_CRL *crl); ++void X509_CRL_get0_signature(const X509_CRL *crl, const ASN1_BIT_STRING **psig, ++ const X509_ALGOR **palg); ++int X509_CRL_get_signature_nid(const X509_CRL *crl); ++int i2d_re_X509_CRL_tbs(X509_CRL *req, unsigned char **pp); ++ ++const ASN1_INTEGER *X509_REVOKED_get0_serialNumber(const X509_REVOKED *x); ++int X509_REVOKED_set_serialNumber(X509_REVOKED *x, ASN1_INTEGER *serial); ++const ASN1_TIME *X509_REVOKED_get0_revocationDate(const X509_REVOKED *x); ++int X509_REVOKED_set_revocationDate(X509_REVOKED *r, ASN1_TIME *tm); ++const STACK_OF(X509_EXTENSION) * ++X509_REVOKED_get0_extensions(const X509_REVOKED *r); ++ ++X509_CRL *X509_CRL_diff(X509_CRL *base, X509_CRL *newer, ++ EVP_PKEY *skey, const EVP_MD *md, unsigned int flags); ++ ++int X509_REQ_check_private_key(X509_REQ *x509, EVP_PKEY *pkey); ++ ++int X509_check_private_key(const X509 *x509, const EVP_PKEY *pkey); ++int X509_chain_check_suiteb(int *perror_depth, ++ X509 *x, STACK_OF(X509) *chain, ++ unsigned long flags); ++int X509_CRL_check_suiteb(X509_CRL *crl, EVP_PKEY *pk, unsigned long flags); ++STACK_OF(X509) *X509_chain_up_ref(STACK_OF(X509) *chain); ++ ++int X509_issuer_and_serial_cmp(const X509 *a, const X509 *b); ++unsigned long X509_issuer_and_serial_hash(X509 *a); ++ ++int X509_issuer_name_cmp(const X509 *a, const X509 *b); ++unsigned long X509_issuer_name_hash(X509 *a); ++ ++int X509_subject_name_cmp(const X509 *a, const X509 *b); ++unsigned long X509_subject_name_hash(X509 *x); ++ ++# ifndef OPENSSL_NO_MD5 ++unsigned long X509_issuer_name_hash_old(X509 *a); ++unsigned long X509_subject_name_hash_old(X509 *x); ++# endif ++ ++int X509_cmp(const X509 *a, const X509 *b); ++int X509_NAME_cmp(const X509_NAME *a, const X509_NAME *b); ++unsigned long X509_NAME_hash(X509_NAME *x); ++unsigned long X509_NAME_hash_old(X509_NAME *x); ++ ++int X509_CRL_cmp(const X509_CRL *a, const X509_CRL *b); ++int X509_CRL_match(const X509_CRL *a, const X509_CRL *b); ++int X509_aux_print(BIO *out, X509 *x, int indent); ++# ifndef OPENSSL_NO_STDIO ++int X509_print_ex_fp(FILE *bp, X509 *x, unsigned long nmflag, ++ unsigned long cflag); ++int X509_print_fp(FILE *bp, X509 *x); ++int X509_CRL_print_fp(FILE *bp, X509_CRL *x); ++int X509_REQ_print_fp(FILE *bp, X509_REQ *req); ++int X509_NAME_print_ex_fp(FILE *fp, const X509_NAME *nm, int indent, ++ unsigned long flags); ++# endif ++ ++int X509_NAME_print(BIO *bp, const X509_NAME *name, int obase); ++int X509_NAME_print_ex(BIO *out, const X509_NAME *nm, int indent, ++ unsigned long flags); ++int X509_print_ex(BIO *bp, X509 *x, unsigned long nmflag, ++ unsigned long cflag); ++int X509_print(BIO *bp, X509 *x); ++int X509_ocspid_print(BIO *bp, X509 *x); ++int X509_CRL_print_ex(BIO *out, X509_CRL *x, unsigned long nmflag); ++int X509_CRL_print(BIO *bp, X509_CRL *x); ++int X509_REQ_print_ex(BIO *bp, X509_REQ *x, unsigned long nmflag, ++ unsigned long cflag); ++int X509_REQ_print(BIO *bp, X509_REQ *req); ++ ++int X509_NAME_entry_count(const X509_NAME *name); ++int X509_NAME_get_text_by_NID(X509_NAME *name, int nid, char *buf, int len); ++int X509_NAME_get_text_by_OBJ(X509_NAME *name, const ASN1_OBJECT *obj, ++ char *buf, int len); ++ ++/* ++ * NOTE: you should be passing -1, not 0 as lastpos. The functions that use ++ * lastpos, search after that position on. ++ */ ++int X509_NAME_get_index_by_NID(X509_NAME *name, int nid, int lastpos); ++int X509_NAME_get_index_by_OBJ(X509_NAME *name, const ASN1_OBJECT *obj, ++ int lastpos); ++X509_NAME_ENTRY *X509_NAME_get_entry(const X509_NAME *name, int loc); ++X509_NAME_ENTRY *X509_NAME_delete_entry(X509_NAME *name, int loc); ++int X509_NAME_add_entry(X509_NAME *name, const X509_NAME_ENTRY *ne, ++ int loc, int set); ++int X509_NAME_add_entry_by_OBJ(X509_NAME *name, const ASN1_OBJECT *obj, int type, ++ const unsigned char *bytes, int len, int loc, ++ int set); ++int X509_NAME_add_entry_by_NID(X509_NAME *name, int nid, int type, ++ const unsigned char *bytes, int len, int loc, ++ int set); ++X509_NAME_ENTRY *X509_NAME_ENTRY_create_by_txt(X509_NAME_ENTRY **ne, ++ const char *field, int type, ++ const unsigned char *bytes, ++ int len); ++X509_NAME_ENTRY *X509_NAME_ENTRY_create_by_NID(X509_NAME_ENTRY **ne, int nid, ++ int type, ++ const unsigned char *bytes, ++ int len); ++int X509_NAME_add_entry_by_txt(X509_NAME *name, const char *field, int type, ++ const unsigned char *bytes, int len, int loc, ++ int set); ++X509_NAME_ENTRY *X509_NAME_ENTRY_create_by_OBJ(X509_NAME_ENTRY **ne, ++ const ASN1_OBJECT *obj, int type, ++ const unsigned char *bytes, ++ int len); ++int X509_NAME_ENTRY_set_object(X509_NAME_ENTRY *ne, const ASN1_OBJECT *obj); ++int X509_NAME_ENTRY_set_data(X509_NAME_ENTRY *ne, int type, ++ const unsigned char *bytes, int len); ++ASN1_OBJECT *X509_NAME_ENTRY_get_object(const X509_NAME_ENTRY *ne); ++ASN1_STRING * X509_NAME_ENTRY_get_data(const X509_NAME_ENTRY *ne); ++int X509_NAME_ENTRY_set(const X509_NAME_ENTRY *ne); ++ ++int X509_NAME_get0_der(X509_NAME *nm, const unsigned char **pder, ++ size_t *pderlen); ++ ++int X509v3_get_ext_count(const STACK_OF(X509_EXTENSION) *x); ++int X509v3_get_ext_by_NID(const STACK_OF(X509_EXTENSION) *x, ++ int nid, int lastpos); ++int X509v3_get_ext_by_OBJ(const STACK_OF(X509_EXTENSION) *x, ++ const ASN1_OBJECT *obj, int lastpos); ++int X509v3_get_ext_by_critical(const STACK_OF(X509_EXTENSION) *x, ++ int crit, int lastpos); ++X509_EXTENSION *X509v3_get_ext(const STACK_OF(X509_EXTENSION) *x, int loc); ++X509_EXTENSION *X509v3_delete_ext(STACK_OF(X509_EXTENSION) *x, int loc); ++STACK_OF(X509_EXTENSION) *X509v3_add_ext(STACK_OF(X509_EXTENSION) **x, ++ X509_EXTENSION *ex, int loc); ++ ++int X509_get_ext_count(const X509 *x); ++int X509_get_ext_by_NID(const X509 *x, int nid, int lastpos); ++int X509_get_ext_by_OBJ(const X509 *x, const ASN1_OBJECT *obj, int lastpos); ++int X509_get_ext_by_critical(const X509 *x, int crit, int lastpos); ++X509_EXTENSION *X509_get_ext(const X509 *x, int loc); ++X509_EXTENSION *X509_delete_ext(X509 *x, int loc); ++int X509_add_ext(X509 *x, X509_EXTENSION *ex, int loc); ++void *X509_get_ext_d2i(const X509 *x, int nid, int *crit, int *idx); ++int X509_add1_ext_i2d(X509 *x, int nid, void *value, int crit, ++ unsigned long flags); ++ ++int X509_CRL_get_ext_count(const X509_CRL *x); ++int X509_CRL_get_ext_by_NID(const X509_CRL *x, int nid, int lastpos); ++int X509_CRL_get_ext_by_OBJ(const X509_CRL *x, const ASN1_OBJECT *obj, ++ int lastpos); ++int X509_CRL_get_ext_by_critical(const X509_CRL *x, int crit, int lastpos); ++X509_EXTENSION *X509_CRL_get_ext(const X509_CRL *x, int loc); ++X509_EXTENSION *X509_CRL_delete_ext(X509_CRL *x, int loc); ++int X509_CRL_add_ext(X509_CRL *x, X509_EXTENSION *ex, int loc); ++void *X509_CRL_get_ext_d2i(const X509_CRL *x, int nid, int *crit, int *idx); ++int X509_CRL_add1_ext_i2d(X509_CRL *x, int nid, void *value, int crit, ++ unsigned long flags); ++ ++int X509_REVOKED_get_ext_count(const X509_REVOKED *x); ++int X509_REVOKED_get_ext_by_NID(const X509_REVOKED *x, int nid, int lastpos); ++int X509_REVOKED_get_ext_by_OBJ(const X509_REVOKED *x, const ASN1_OBJECT *obj, ++ int lastpos); ++int X509_REVOKED_get_ext_by_critical(const X509_REVOKED *x, int crit, ++ int lastpos); ++X509_EXTENSION *X509_REVOKED_get_ext(const X509_REVOKED *x, int loc); ++X509_EXTENSION *X509_REVOKED_delete_ext(X509_REVOKED *x, int loc); ++int X509_REVOKED_add_ext(X509_REVOKED *x, X509_EXTENSION *ex, int loc); ++void *X509_REVOKED_get_ext_d2i(const X509_REVOKED *x, int nid, int *crit, ++ int *idx); ++int X509_REVOKED_add1_ext_i2d(X509_REVOKED *x, int nid, void *value, int crit, ++ unsigned long flags); ++ ++X509_EXTENSION *X509_EXTENSION_create_by_NID(X509_EXTENSION **ex, ++ int nid, int crit, ++ ASN1_OCTET_STRING *data); ++X509_EXTENSION *X509_EXTENSION_create_by_OBJ(X509_EXTENSION **ex, ++ const ASN1_OBJECT *obj, int crit, ++ ASN1_OCTET_STRING *data); ++int X509_EXTENSION_set_object(X509_EXTENSION *ex, const ASN1_OBJECT *obj); ++int X509_EXTENSION_set_critical(X509_EXTENSION *ex, int crit); ++int X509_EXTENSION_set_data(X509_EXTENSION *ex, ASN1_OCTET_STRING *data); ++ASN1_OBJECT *X509_EXTENSION_get_object(X509_EXTENSION *ex); ++ASN1_OCTET_STRING *X509_EXTENSION_get_data(X509_EXTENSION *ne); ++int X509_EXTENSION_get_critical(const X509_EXTENSION *ex); ++ ++int X509at_get_attr_count(const STACK_OF(X509_ATTRIBUTE) *x); ++int X509at_get_attr_by_NID(const STACK_OF(X509_ATTRIBUTE) *x, int nid, ++ int lastpos); ++int X509at_get_attr_by_OBJ(const STACK_OF(X509_ATTRIBUTE) *sk, ++ const ASN1_OBJECT *obj, int lastpos); ++X509_ATTRIBUTE *X509at_get_attr(const STACK_OF(X509_ATTRIBUTE) *x, int loc); ++X509_ATTRIBUTE *X509at_delete_attr(STACK_OF(X509_ATTRIBUTE) *x, int loc); ++STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr(STACK_OF(X509_ATTRIBUTE) **x, ++ X509_ATTRIBUTE *attr); ++STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_OBJ(STACK_OF(X509_ATTRIBUTE) ++ **x, const ASN1_OBJECT *obj, ++ int type, ++ const unsigned char *bytes, ++ int len); ++STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_NID(STACK_OF(X509_ATTRIBUTE) ++ **x, int nid, int type, ++ const unsigned char *bytes, ++ int len); ++STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_txt(STACK_OF(X509_ATTRIBUTE) ++ **x, const char *attrname, ++ int type, ++ const unsigned char *bytes, ++ int len); ++void *X509at_get0_data_by_OBJ(const STACK_OF(X509_ATTRIBUTE) *x, ++ const ASN1_OBJECT *obj, int lastpos, int type); ++X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_NID(X509_ATTRIBUTE **attr, int nid, ++ int atrtype, const void *data, ++ int len); ++X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_OBJ(X509_ATTRIBUTE **attr, ++ const ASN1_OBJECT *obj, ++ int atrtype, const void *data, ++ int len); ++X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_txt(X509_ATTRIBUTE **attr, ++ const char *atrname, int type, ++ const unsigned char *bytes, ++ int len); ++int X509_ATTRIBUTE_set1_object(X509_ATTRIBUTE *attr, const ASN1_OBJECT *obj); ++int X509_ATTRIBUTE_set1_data(X509_ATTRIBUTE *attr, int attrtype, ++ const void *data, int len); ++void *X509_ATTRIBUTE_get0_data(X509_ATTRIBUTE *attr, int idx, int atrtype, ++ void *data); ++int X509_ATTRIBUTE_count(const X509_ATTRIBUTE *attr); ++ASN1_OBJECT *X509_ATTRIBUTE_get0_object(X509_ATTRIBUTE *attr); ++ASN1_TYPE *X509_ATTRIBUTE_get0_type(X509_ATTRIBUTE *attr, int idx); ++ ++int EVP_PKEY_get_attr_count(const EVP_PKEY *key); ++int EVP_PKEY_get_attr_by_NID(const EVP_PKEY *key, int nid, int lastpos); ++int EVP_PKEY_get_attr_by_OBJ(const EVP_PKEY *key, const ASN1_OBJECT *obj, ++ int lastpos); ++X509_ATTRIBUTE *EVP_PKEY_get_attr(const EVP_PKEY *key, int loc); ++X509_ATTRIBUTE *EVP_PKEY_delete_attr(EVP_PKEY *key, int loc); ++int EVP_PKEY_add1_attr(EVP_PKEY *key, X509_ATTRIBUTE *attr); ++int EVP_PKEY_add1_attr_by_OBJ(EVP_PKEY *key, ++ const ASN1_OBJECT *obj, int type, ++ const unsigned char *bytes, int len); ++int EVP_PKEY_add1_attr_by_NID(EVP_PKEY *key, ++ int nid, int type, ++ const unsigned char *bytes, int len); ++int EVP_PKEY_add1_attr_by_txt(EVP_PKEY *key, ++ const char *attrname, int type, ++ const unsigned char *bytes, int len); ++ ++int X509_verify_cert(X509_STORE_CTX *ctx); ++ ++/* lookup a cert from a X509 STACK */ ++X509 *X509_find_by_issuer_and_serial(STACK_OF(X509) *sk, X509_NAME *name, ++ ASN1_INTEGER *serial); ++X509 *X509_find_by_subject(STACK_OF(X509) *sk, X509_NAME *name); ++ ++DECLARE_ASN1_FUNCTIONS(PBEPARAM) ++DECLARE_ASN1_FUNCTIONS(PBE2PARAM) ++DECLARE_ASN1_FUNCTIONS(PBKDF2PARAM) ++#ifndef OPENSSL_NO_SCRYPT ++DECLARE_ASN1_FUNCTIONS(SCRYPT_PARAMS) ++#endif ++ ++int PKCS5_pbe_set0_algor(X509_ALGOR *algor, int alg, int iter, ++ const unsigned char *salt, int saltlen); ++ ++X509_ALGOR *PKCS5_pbe_set(int alg, int iter, ++ const unsigned char *salt, int saltlen); ++X509_ALGOR *PKCS5_pbe2_set(const EVP_CIPHER *cipher, int iter, ++ unsigned char *salt, int saltlen); ++X509_ALGOR *PKCS5_pbe2_set_iv(const EVP_CIPHER *cipher, int iter, ++ unsigned char *salt, int saltlen, ++ unsigned char *aiv, int prf_nid); ++ ++#ifndef OPENSSL_NO_SCRYPT ++X509_ALGOR *PKCS5_pbe2_set_scrypt(const EVP_CIPHER *cipher, ++ const unsigned char *salt, int saltlen, ++ unsigned char *aiv, uint64_t N, uint64_t r, ++ uint64_t p); ++#endif ++ ++X509_ALGOR *PKCS5_pbkdf2_set(int iter, unsigned char *salt, int saltlen, ++ int prf_nid, int keylen); ++ ++/* PKCS#8 utilities */ ++ ++DECLARE_ASN1_FUNCTIONS(PKCS8_PRIV_KEY_INFO) ++ ++EVP_PKEY *EVP_PKCS82PKEY(const PKCS8_PRIV_KEY_INFO *p8); ++PKCS8_PRIV_KEY_INFO *EVP_PKEY2PKCS8(EVP_PKEY *pkey); ++ ++int PKCS8_pkey_set0(PKCS8_PRIV_KEY_INFO *priv, ASN1_OBJECT *aobj, ++ int version, int ptype, void *pval, ++ unsigned char *penc, int penclen); ++int PKCS8_pkey_get0(const ASN1_OBJECT **ppkalg, ++ const unsigned char **pk, int *ppklen, ++ const X509_ALGOR **pa, const PKCS8_PRIV_KEY_INFO *p8); ++ ++const STACK_OF(X509_ATTRIBUTE) * ++PKCS8_pkey_get0_attrs(const PKCS8_PRIV_KEY_INFO *p8); ++int PKCS8_pkey_add1_attr_by_NID(PKCS8_PRIV_KEY_INFO *p8, int nid, int type, ++ const unsigned char *bytes, int len); ++ ++int X509_PUBKEY_set0_param(X509_PUBKEY *pub, ASN1_OBJECT *aobj, ++ int ptype, void *pval, ++ unsigned char *penc, int penclen); ++int X509_PUBKEY_get0_param(ASN1_OBJECT **ppkalg, ++ const unsigned char **pk, int *ppklen, ++ X509_ALGOR **pa, X509_PUBKEY *pub); ++ ++int X509_check_trust(X509 *x, int id, int flags); ++int X509_TRUST_get_count(void); ++X509_TRUST *X509_TRUST_get0(int idx); ++int X509_TRUST_get_by_id(int id); ++int X509_TRUST_add(int id, int flags, int (*ck) (X509_TRUST *, X509 *, int), ++ const char *name, int arg1, void *arg2); ++void X509_TRUST_cleanup(void); ++int X509_TRUST_get_flags(const X509_TRUST *xp); ++char *X509_TRUST_get0_name(const X509_TRUST *xp); ++int X509_TRUST_get_trust(const X509_TRUST *xp); ++ ++# ifdef __cplusplus ++} ++# endif ++#endif +diff --git a/include/TA/openssl/openssl/x509_vfy.h b/include/TA/openssl/openssl/x509_vfy.h +new file mode 100644 +index 0000000..fa6027f +--- /dev/null ++++ b/include/TA/openssl/openssl/x509_vfy.h +@@ -0,0 +1,633 @@ ++/* ++ * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved. ++ * ++ * Licensed under the OpenSSL license (the "License"). You may not use ++ * this file except in compliance with the License. You can obtain a copy ++ * in the file LICENSE in the source distribution or at ++ * https://www.openssl.org/source/license.html ++ */ ++ ++#ifndef HEADER_X509_VFY_H ++# define HEADER_X509_VFY_H ++ ++/* ++ * Protect against recursion, x509.h and x509_vfy.h each include the other. ++ */ ++# ifndef HEADER_X509_H ++# include ++# endif ++ ++# include ++# include ++# include ++# include ++# include ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++/*- ++SSL_CTX -> X509_STORE ++ -> X509_LOOKUP ++ ->X509_LOOKUP_METHOD ++ -> X509_LOOKUP ++ ->X509_LOOKUP_METHOD ++ ++SSL -> X509_STORE_CTX ++ ->X509_STORE ++ ++The X509_STORE holds the tables etc for verification stuff. ++A X509_STORE_CTX is used while validating a single certificate. ++The X509_STORE has X509_LOOKUPs for looking up certs. ++The X509_STORE then calls a function to actually verify the ++certificate chain. ++*/ ++ ++typedef enum { ++ X509_LU_NONE = 0, ++ X509_LU_X509, X509_LU_CRL ++} X509_LOOKUP_TYPE; ++ ++#if OPENSSL_API_COMPAT < 0x10100000L ++#define X509_LU_RETRY -1 ++#define X509_LU_FAIL 0 ++#endif ++ ++DEFINE_STACK_OF(X509_LOOKUP) ++DEFINE_STACK_OF(X509_OBJECT) ++DEFINE_STACK_OF(X509_VERIFY_PARAM) ++ ++int X509_STORE_set_depth(X509_STORE *store, int depth); ++ ++typedef int (*X509_STORE_CTX_verify_cb)(int, X509_STORE_CTX *); ++typedef int (*X509_STORE_CTX_verify_fn)(X509_STORE_CTX *); ++typedef int (*X509_STORE_CTX_get_issuer_fn)(X509 **issuer, ++ X509_STORE_CTX *ctx, X509 *x); ++typedef int (*X509_STORE_CTX_check_issued_fn)(X509_STORE_CTX *ctx, ++ X509 *x, X509 *issuer); ++typedef int (*X509_STORE_CTX_check_revocation_fn)(X509_STORE_CTX *ctx); ++typedef int (*X509_STORE_CTX_get_crl_fn)(X509_STORE_CTX *ctx, ++ X509_CRL **crl, X509 *x); ++typedef int (*X509_STORE_CTX_check_crl_fn)(X509_STORE_CTX *ctx, X509_CRL *crl); ++typedef int (*X509_STORE_CTX_cert_crl_fn)(X509_STORE_CTX *ctx, ++ X509_CRL *crl, X509 *x); ++typedef int (*X509_STORE_CTX_check_policy_fn)(X509_STORE_CTX *ctx); ++typedef STACK_OF(X509) *(*X509_STORE_CTX_lookup_certs_fn)(X509_STORE_CTX *ctx, ++ X509_NAME *nm); ++typedef STACK_OF(X509_CRL) *(*X509_STORE_CTX_lookup_crls_fn)(X509_STORE_CTX *ctx, ++ X509_NAME *nm); ++typedef int (*X509_STORE_CTX_cleanup_fn)(X509_STORE_CTX *ctx); ++ ++void X509_STORE_CTX_set_depth(X509_STORE_CTX *ctx, int depth); ++ ++# define X509_STORE_CTX_set_app_data(ctx,data) \ ++ X509_STORE_CTX_set_ex_data(ctx,0,data) ++# define X509_STORE_CTX_get_app_data(ctx) \ ++ X509_STORE_CTX_get_ex_data(ctx,0) ++ ++# define X509_L_FILE_LOAD 1 ++# define X509_L_ADD_DIR 2 ++ ++# define X509_LOOKUP_load_file(x,name,type) \ ++ X509_LOOKUP_ctrl((x),X509_L_FILE_LOAD,(name),(long)(type),NULL) ++ ++# define X509_LOOKUP_add_dir(x,name,type) \ ++ X509_LOOKUP_ctrl((x),X509_L_ADD_DIR,(name),(long)(type),NULL) ++ ++# define X509_V_OK 0 ++# define X509_V_ERR_UNSPECIFIED 1 ++# define X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT 2 ++# define X509_V_ERR_UNABLE_TO_GET_CRL 3 ++# define X509_V_ERR_UNABLE_TO_DECRYPT_CERT_SIGNATURE 4 ++# define X509_V_ERR_UNABLE_TO_DECRYPT_CRL_SIGNATURE 5 ++# define X509_V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY 6 ++# define X509_V_ERR_CERT_SIGNATURE_FAILURE 7 ++# define X509_V_ERR_CRL_SIGNATURE_FAILURE 8 ++# define X509_V_ERR_CERT_NOT_YET_VALID 9 ++# define X509_V_ERR_CERT_HAS_EXPIRED 10 ++# define X509_V_ERR_CRL_NOT_YET_VALID 11 ++# define X509_V_ERR_CRL_HAS_EXPIRED 12 ++# define X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD 13 ++# define X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD 14 ++# define X509_V_ERR_ERROR_IN_CRL_LAST_UPDATE_FIELD 15 ++# define X509_V_ERR_ERROR_IN_CRL_NEXT_UPDATE_FIELD 16 ++# define X509_V_ERR_OUT_OF_MEM 17 ++# define X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT 18 ++# define X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN 19 ++# define X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY 20 ++# define X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE 21 ++# define X509_V_ERR_CERT_CHAIN_TOO_LONG 22 ++# define X509_V_ERR_CERT_REVOKED 23 ++# define X509_V_ERR_INVALID_CA 24 ++# define X509_V_ERR_PATH_LENGTH_EXCEEDED 25 ++# define X509_V_ERR_INVALID_PURPOSE 26 ++# define X509_V_ERR_CERT_UNTRUSTED 27 ++# define X509_V_ERR_CERT_REJECTED 28 ++/* These are 'informational' when looking for issuer cert */ ++# define X509_V_ERR_SUBJECT_ISSUER_MISMATCH 29 ++# define X509_V_ERR_AKID_SKID_MISMATCH 30 ++# define X509_V_ERR_AKID_ISSUER_SERIAL_MISMATCH 31 ++# define X509_V_ERR_KEYUSAGE_NO_CERTSIGN 32 ++# define X509_V_ERR_UNABLE_TO_GET_CRL_ISSUER 33 ++# define X509_V_ERR_UNHANDLED_CRITICAL_EXTENSION 34 ++# define X509_V_ERR_KEYUSAGE_NO_CRL_SIGN 35 ++# define X509_V_ERR_UNHANDLED_CRITICAL_CRL_EXTENSION 36 ++# define X509_V_ERR_INVALID_NON_CA 37 ++# define X509_V_ERR_PROXY_PATH_LENGTH_EXCEEDED 38 ++# define X509_V_ERR_KEYUSAGE_NO_DIGITAL_SIGNATURE 39 ++# define X509_V_ERR_PROXY_CERTIFICATES_NOT_ALLOWED 40 ++# define X509_V_ERR_INVALID_EXTENSION 41 ++# define X509_V_ERR_INVALID_POLICY_EXTENSION 42 ++# define X509_V_ERR_NO_EXPLICIT_POLICY 43 ++# define X509_V_ERR_DIFFERENT_CRL_SCOPE 44 ++# define X509_V_ERR_UNSUPPORTED_EXTENSION_FEATURE 45 ++# define X509_V_ERR_UNNESTED_RESOURCE 46 ++# define X509_V_ERR_PERMITTED_VIOLATION 47 ++# define X509_V_ERR_EXCLUDED_VIOLATION 48 ++# define X509_V_ERR_SUBTREE_MINMAX 49 ++/* The application is not happy */ ++# define X509_V_ERR_APPLICATION_VERIFICATION 50 ++# define X509_V_ERR_UNSUPPORTED_CONSTRAINT_TYPE 51 ++# define X509_V_ERR_UNSUPPORTED_CONSTRAINT_SYNTAX 52 ++# define X509_V_ERR_UNSUPPORTED_NAME_SYNTAX 53 ++# define X509_V_ERR_CRL_PATH_VALIDATION_ERROR 54 ++/* Another issuer check debug option */ ++# define X509_V_ERR_PATH_LOOP 55 ++/* Suite B mode algorithm violation */ ++# define X509_V_ERR_SUITE_B_INVALID_VERSION 56 ++# define X509_V_ERR_SUITE_B_INVALID_ALGORITHM 57 ++# define X509_V_ERR_SUITE_B_INVALID_CURVE 58 ++# define X509_V_ERR_SUITE_B_INVALID_SIGNATURE_ALGORITHM 59 ++# define X509_V_ERR_SUITE_B_LOS_NOT_ALLOWED 60 ++# define X509_V_ERR_SUITE_B_CANNOT_SIGN_P_384_WITH_P_256 61 ++/* Host, email and IP check errors */ ++# define X509_V_ERR_HOSTNAME_MISMATCH 62 ++# define X509_V_ERR_EMAIL_MISMATCH 63 ++# define X509_V_ERR_IP_ADDRESS_MISMATCH 64 ++/* DANE TLSA errors */ ++# define X509_V_ERR_DANE_NO_MATCH 65 ++/* security level errors */ ++# define X509_V_ERR_EE_KEY_TOO_SMALL 66 ++# define X509_V_ERR_CA_KEY_TOO_SMALL 67 ++# define X509_V_ERR_CA_MD_TOO_WEAK 68 ++/* Caller error */ ++# define X509_V_ERR_INVALID_CALL 69 ++/* Issuer lookup error */ ++# define X509_V_ERR_STORE_LOOKUP 70 ++/* Certificate transparency */ ++# define X509_V_ERR_NO_VALID_SCTS 71 ++ ++# define X509_V_ERR_PROXY_SUBJECT_NAME_VIOLATION 72 ++/* OCSP status errors */ ++# define X509_V_ERR_OCSP_VERIFY_NEEDED 73 /* Need OCSP verification */ ++# define X509_V_ERR_OCSP_VERIFY_FAILED 74 /* Couldn't verify cert through OCSP */ ++# define X509_V_ERR_OCSP_CERT_UNKNOWN 75 /* Certificate wasn't recognized by the OCSP responder */ ++# define X509_V_ERR_SIGNATURE_ALGORITHM_MISMATCH 76 ++# define X509_V_ERR_NO_ISSUER_PUBLIC_KEY 77 ++# define X509_V_ERR_UNSUPPORTED_SIGNATURE_ALGORITHM 78 ++# define X509_V_ERR_EC_KEY_EXPLICIT_PARAMS 79 ++ ++/*huawei_0032_check_x509v3_pathlen_extension.patch*/ ++# define X509_V_ERR_INVALID_PATHLEN_EXTENSION 101 /* Returned by the verify callback to indicate that the pathlen is invalid */ ++ ++/* Certificate verify flags */ ++ ++# if OPENSSL_API_COMPAT < 0x10100000L ++# define X509_V_FLAG_CB_ISSUER_CHECK 0x0 /* Deprecated */ ++# endif ++/* Use check time instead of current time */ ++# define X509_V_FLAG_USE_CHECK_TIME 0x2 ++/* Lookup CRLs */ ++# define X509_V_FLAG_CRL_CHECK 0x4 ++/* Lookup CRLs for whole chain */ ++# define X509_V_FLAG_CRL_CHECK_ALL 0x8 ++/* Ignore unhandled critical extensions */ ++# define X509_V_FLAG_IGNORE_CRITICAL 0x10 ++/* Disable workarounds for broken certificates */ ++# define X509_V_FLAG_X509_STRICT 0x20 ++/* Enable proxy certificate validation */ ++# define X509_V_FLAG_ALLOW_PROXY_CERTS 0x40 ++/* Enable policy checking */ ++# define X509_V_FLAG_POLICY_CHECK 0x80 ++/* Policy variable require-explicit-policy */ ++# define X509_V_FLAG_EXPLICIT_POLICY 0x100 ++/* Policy variable inhibit-any-policy */ ++# define X509_V_FLAG_INHIBIT_ANY 0x200 ++/* Policy variable inhibit-policy-mapping */ ++# define X509_V_FLAG_INHIBIT_MAP 0x400 ++/* Notify callback that policy is OK */ ++# define X509_V_FLAG_NOTIFY_POLICY 0x800 ++/* Extended CRL features such as indirect CRLs, alternate CRL signing keys */ ++# define X509_V_FLAG_EXTENDED_CRL_SUPPORT 0x1000 ++/* Delta CRL support */ ++# define X509_V_FLAG_USE_DELTAS 0x2000 ++/* Check self-signed CA signature */ ++# define X509_V_FLAG_CHECK_SS_SIGNATURE 0x4000 ++/* Use trusted store first */ ++# define X509_V_FLAG_TRUSTED_FIRST 0x8000 ++/* Suite B 128 bit only mode: not normally used */ ++# define X509_V_FLAG_SUITEB_128_LOS_ONLY 0x10000 ++/* Suite B 192 bit only mode */ ++# define X509_V_FLAG_SUITEB_192_LOS 0x20000 ++/* Suite B 128 bit mode allowing 192 bit algorithms */ ++# define X509_V_FLAG_SUITEB_128_LOS 0x30000 ++/* Allow partial chains if at least one certificate is in trusted store */ ++# define X509_V_FLAG_PARTIAL_CHAIN 0x80000 ++/* ++ * If the initial chain is not trusted, do not attempt to build an alternative ++ * chain. Alternate chain checking was introduced in 1.1.0. Setting this flag ++ * will force the behaviour to match that of previous versions. ++ */ ++# define X509_V_FLAG_NO_ALT_CHAINS 0x100000 ++/* Do not check certificate/CRL validity against current time */ ++# define X509_V_FLAG_NO_CHECK_TIME 0x200000 ++ ++# define X509_VP_FLAG_DEFAULT 0x1 ++# define X509_VP_FLAG_OVERWRITE 0x2 ++# define X509_VP_FLAG_RESET_FLAGS 0x4 ++# define X509_VP_FLAG_LOCKED 0x8 ++# define X509_VP_FLAG_ONCE 0x10 ++ ++/* Internal use: mask of policy related options */ ++# define X509_V_FLAG_POLICY_MASK (X509_V_FLAG_POLICY_CHECK \ ++ | X509_V_FLAG_EXPLICIT_POLICY \ ++ | X509_V_FLAG_INHIBIT_ANY \ ++ | X509_V_FLAG_INHIBIT_MAP) ++ ++int X509_OBJECT_idx_by_subject(STACK_OF(X509_OBJECT) *h, X509_LOOKUP_TYPE type, ++ X509_NAME *name); ++X509_OBJECT *X509_OBJECT_retrieve_by_subject(STACK_OF(X509_OBJECT) *h, ++ X509_LOOKUP_TYPE type, ++ X509_NAME *name); ++X509_OBJECT *X509_OBJECT_retrieve_match(STACK_OF(X509_OBJECT) *h, ++ X509_OBJECT *x); ++int X509_OBJECT_up_ref_count(X509_OBJECT *a); ++X509_OBJECT *X509_OBJECT_new(void); ++void X509_OBJECT_free(X509_OBJECT *a); ++X509_LOOKUP_TYPE X509_OBJECT_get_type(const X509_OBJECT *a); ++X509 *X509_OBJECT_get0_X509(const X509_OBJECT *a); ++int X509_OBJECT_set1_X509(X509_OBJECT *a, X509 *obj); ++X509_CRL *X509_OBJECT_get0_X509_CRL(X509_OBJECT *a); ++int X509_OBJECT_set1_X509_CRL(X509_OBJECT *a, X509_CRL *obj); ++X509_STORE *X509_STORE_new(void); ++void X509_STORE_free(X509_STORE *v); ++int X509_STORE_lock(X509_STORE *ctx); ++int X509_STORE_unlock(X509_STORE *ctx); ++int X509_STORE_up_ref(X509_STORE *v); ++STACK_OF(X509_OBJECT) *X509_STORE_get0_objects(X509_STORE *v); ++ ++STACK_OF(X509) *X509_STORE_CTX_get1_certs(X509_STORE_CTX *st, X509_NAME *nm); ++STACK_OF(X509_CRL) *X509_STORE_CTX_get1_crls(X509_STORE_CTX *st, X509_NAME *nm); ++int X509_STORE_set_flags(X509_STORE *ctx, unsigned long flags); ++int X509_STORE_set_purpose(X509_STORE *ctx, int purpose); ++int X509_STORE_set_trust(X509_STORE *ctx, int trust); ++int X509_STORE_set1_param(X509_STORE *ctx, X509_VERIFY_PARAM *pm); ++X509_VERIFY_PARAM *X509_STORE_get0_param(X509_STORE *ctx); ++ ++void X509_STORE_set_verify(X509_STORE *ctx, X509_STORE_CTX_verify_fn verify); ++#define X509_STORE_set_verify_func(ctx, func) \ ++ X509_STORE_set_verify((ctx),(func)) ++void X509_STORE_CTX_set_verify(X509_STORE_CTX *ctx, ++ X509_STORE_CTX_verify_fn verify); ++X509_STORE_CTX_verify_fn X509_STORE_get_verify(X509_STORE *ctx); ++void X509_STORE_set_verify_cb(X509_STORE *ctx, ++ X509_STORE_CTX_verify_cb verify_cb); ++# define X509_STORE_set_verify_cb_func(ctx,func) \ ++ X509_STORE_set_verify_cb((ctx),(func)) ++X509_STORE_CTX_verify_cb X509_STORE_get_verify_cb(X509_STORE *ctx); ++void X509_STORE_set_get_issuer(X509_STORE *ctx, ++ X509_STORE_CTX_get_issuer_fn get_issuer); ++X509_STORE_CTX_get_issuer_fn X509_STORE_get_get_issuer(X509_STORE *ctx); ++void X509_STORE_set_check_issued(X509_STORE *ctx, ++ X509_STORE_CTX_check_issued_fn check_issued); ++X509_STORE_CTX_check_issued_fn X509_STORE_get_check_issued(X509_STORE *ctx); ++void X509_STORE_set_check_revocation(X509_STORE *ctx, ++ X509_STORE_CTX_check_revocation_fn check_revocation); ++X509_STORE_CTX_check_revocation_fn X509_STORE_get_check_revocation(X509_STORE *ctx); ++void X509_STORE_set_get_crl(X509_STORE *ctx, ++ X509_STORE_CTX_get_crl_fn get_crl); ++X509_STORE_CTX_get_crl_fn X509_STORE_get_get_crl(X509_STORE *ctx); ++void X509_STORE_set_check_crl(X509_STORE *ctx, ++ X509_STORE_CTX_check_crl_fn check_crl); ++X509_STORE_CTX_check_crl_fn X509_STORE_get_check_crl(X509_STORE *ctx); ++void X509_STORE_set_cert_crl(X509_STORE *ctx, ++ X509_STORE_CTX_cert_crl_fn cert_crl); ++X509_STORE_CTX_cert_crl_fn X509_STORE_get_cert_crl(X509_STORE *ctx); ++void X509_STORE_set_check_policy(X509_STORE *ctx, ++ X509_STORE_CTX_check_policy_fn check_policy); ++X509_STORE_CTX_check_policy_fn X509_STORE_get_check_policy(X509_STORE *ctx); ++void X509_STORE_set_lookup_certs(X509_STORE *ctx, ++ X509_STORE_CTX_lookup_certs_fn lookup_certs); ++X509_STORE_CTX_lookup_certs_fn X509_STORE_get_lookup_certs(X509_STORE *ctx); ++void X509_STORE_set_lookup_crls(X509_STORE *ctx, ++ X509_STORE_CTX_lookup_crls_fn lookup_crls); ++#define X509_STORE_set_lookup_crls_cb(ctx, func) \ ++ X509_STORE_set_lookup_crls((ctx), (func)) ++X509_STORE_CTX_lookup_crls_fn X509_STORE_get_lookup_crls(X509_STORE *ctx); ++void X509_STORE_set_cleanup(X509_STORE *ctx, ++ X509_STORE_CTX_cleanup_fn cleanup); ++X509_STORE_CTX_cleanup_fn X509_STORE_get_cleanup(X509_STORE *ctx); ++ ++#define X509_STORE_get_ex_new_index(l, p, newf, dupf, freef) \ ++ CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_X509_STORE, l, p, newf, dupf, freef) ++int X509_STORE_set_ex_data(X509_STORE *ctx, int idx, void *data); ++void *X509_STORE_get_ex_data(X509_STORE *ctx, int idx); ++ ++X509_STORE_CTX *X509_STORE_CTX_new(void); ++ ++int X509_STORE_CTX_get1_issuer(X509 **issuer, X509_STORE_CTX *ctx, X509 *x); ++ ++void X509_STORE_CTX_free(X509_STORE_CTX *ctx); ++int X509_STORE_CTX_init(X509_STORE_CTX *ctx, X509_STORE *store, ++ X509 *x509, STACK_OF(X509) *chain); ++void X509_STORE_CTX_set0_trusted_stack(X509_STORE_CTX *ctx, STACK_OF(X509) *sk); ++void X509_STORE_CTX_cleanup(X509_STORE_CTX *ctx); ++ ++X509_STORE *X509_STORE_CTX_get0_store(X509_STORE_CTX *ctx); ++X509 *X509_STORE_CTX_get0_cert(X509_STORE_CTX *ctx); ++STACK_OF(X509)* X509_STORE_CTX_get0_untrusted(X509_STORE_CTX *ctx); ++void X509_STORE_CTX_set0_untrusted(X509_STORE_CTX *ctx, STACK_OF(X509) *sk); ++void X509_STORE_CTX_set_verify_cb(X509_STORE_CTX *ctx, ++ X509_STORE_CTX_verify_cb verify); ++X509_STORE_CTX_verify_cb X509_STORE_CTX_get_verify_cb(X509_STORE_CTX *ctx); ++X509_STORE_CTX_verify_fn X509_STORE_CTX_get_verify(X509_STORE_CTX *ctx); ++X509_STORE_CTX_get_issuer_fn X509_STORE_CTX_get_get_issuer(X509_STORE_CTX *ctx); ++X509_STORE_CTX_check_issued_fn X509_STORE_CTX_get_check_issued(X509_STORE_CTX *ctx); ++X509_STORE_CTX_check_revocation_fn X509_STORE_CTX_get_check_revocation(X509_STORE_CTX *ctx); ++X509_STORE_CTX_get_crl_fn X509_STORE_CTX_get_get_crl(X509_STORE_CTX *ctx); ++X509_STORE_CTX_check_crl_fn X509_STORE_CTX_get_check_crl(X509_STORE_CTX *ctx); ++X509_STORE_CTX_cert_crl_fn X509_STORE_CTX_get_cert_crl(X509_STORE_CTX *ctx); ++X509_STORE_CTX_check_policy_fn X509_STORE_CTX_get_check_policy(X509_STORE_CTX *ctx); ++X509_STORE_CTX_lookup_certs_fn X509_STORE_CTX_get_lookup_certs(X509_STORE_CTX *ctx); ++X509_STORE_CTX_lookup_crls_fn X509_STORE_CTX_get_lookup_crls(X509_STORE_CTX *ctx); ++X509_STORE_CTX_cleanup_fn X509_STORE_CTX_get_cleanup(X509_STORE_CTX *ctx); ++ ++#if OPENSSL_API_COMPAT < 0x10100000L ++# define X509_STORE_CTX_get_chain X509_STORE_CTX_get0_chain ++# define X509_STORE_CTX_set_chain X509_STORE_CTX_set0_untrusted ++# define X509_STORE_CTX_trusted_stack X509_STORE_CTX_set0_trusted_stack ++# define X509_STORE_get_by_subject X509_STORE_CTX_get_by_subject ++# define X509_STORE_get1_certs X509_STORE_CTX_get1_certs ++# define X509_STORE_get1_crls X509_STORE_CTX_get1_crls ++/* the following macro is misspelled; use X509_STORE_get1_certs instead */ ++# define X509_STORE_get1_cert X509_STORE_CTX_get1_certs ++/* the following macro is misspelled; use X509_STORE_get1_crls instead */ ++# define X509_STORE_get1_crl X509_STORE_CTX_get1_crls ++#endif ++ ++X509_LOOKUP *X509_STORE_add_lookup(X509_STORE *v, X509_LOOKUP_METHOD *m); ++X509_LOOKUP_METHOD *X509_LOOKUP_hash_dir(void); ++X509_LOOKUP_METHOD *X509_LOOKUP_file(void); ++ ++typedef int (*X509_LOOKUP_ctrl_fn)(X509_LOOKUP *ctx, int cmd, const char *argc, ++ long argl, char **ret); ++typedef int (*X509_LOOKUP_get_by_subject_fn)(X509_LOOKUP *ctx, ++ X509_LOOKUP_TYPE type, ++ X509_NAME *name, ++ X509_OBJECT *ret); ++typedef int (*X509_LOOKUP_get_by_issuer_serial_fn)(X509_LOOKUP *ctx, ++ X509_LOOKUP_TYPE type, ++ X509_NAME *name, ++ ASN1_INTEGER *serial, ++ X509_OBJECT *ret); ++typedef int (*X509_LOOKUP_get_by_fingerprint_fn)(X509_LOOKUP *ctx, ++ X509_LOOKUP_TYPE type, ++ const unsigned char* bytes, ++ int len, ++ X509_OBJECT *ret); ++typedef int (*X509_LOOKUP_get_by_alias_fn)(X509_LOOKUP *ctx, ++ X509_LOOKUP_TYPE type, ++ const char *str, ++ int len, ++ X509_OBJECT *ret); ++ ++X509_LOOKUP_METHOD *X509_LOOKUP_meth_new(const char *name); ++void X509_LOOKUP_meth_free(X509_LOOKUP_METHOD *method); ++ ++int X509_LOOKUP_meth_set_new_item(X509_LOOKUP_METHOD *method, ++ int (*new_item) (X509_LOOKUP *ctx)); ++int (*X509_LOOKUP_meth_get_new_item(const X509_LOOKUP_METHOD* method)) ++ (X509_LOOKUP *ctx); ++ ++int X509_LOOKUP_meth_set_free(X509_LOOKUP_METHOD *method, ++ void (*free_fn) (X509_LOOKUP *ctx)); ++void (*X509_LOOKUP_meth_get_free(const X509_LOOKUP_METHOD* method)) ++ (X509_LOOKUP *ctx); ++ ++int X509_LOOKUP_meth_set_init(X509_LOOKUP_METHOD *method, ++ int (*init) (X509_LOOKUP *ctx)); ++int (*X509_LOOKUP_meth_get_init(const X509_LOOKUP_METHOD* method)) ++ (X509_LOOKUP *ctx); ++ ++int X509_LOOKUP_meth_set_shutdown(X509_LOOKUP_METHOD *method, ++ int (*shutdown) (X509_LOOKUP *ctx)); ++int (*X509_LOOKUP_meth_get_shutdown(const X509_LOOKUP_METHOD* method)) ++ (X509_LOOKUP *ctx); ++ ++int X509_LOOKUP_meth_set_ctrl(X509_LOOKUP_METHOD *method, ++ X509_LOOKUP_ctrl_fn ctrl_fn); ++X509_LOOKUP_ctrl_fn X509_LOOKUP_meth_get_ctrl(const X509_LOOKUP_METHOD *method); ++ ++int X509_LOOKUP_meth_set_get_by_subject(X509_LOOKUP_METHOD *method, ++ X509_LOOKUP_get_by_subject_fn fn); ++X509_LOOKUP_get_by_subject_fn X509_LOOKUP_meth_get_get_by_subject( ++ const X509_LOOKUP_METHOD *method); ++ ++int X509_LOOKUP_meth_set_get_by_issuer_serial(X509_LOOKUP_METHOD *method, ++ X509_LOOKUP_get_by_issuer_serial_fn fn); ++X509_LOOKUP_get_by_issuer_serial_fn X509_LOOKUP_meth_get_get_by_issuer_serial( ++ const X509_LOOKUP_METHOD *method); ++ ++int X509_LOOKUP_meth_set_get_by_fingerprint(X509_LOOKUP_METHOD *method, ++ X509_LOOKUP_get_by_fingerprint_fn fn); ++X509_LOOKUP_get_by_fingerprint_fn X509_LOOKUP_meth_get_get_by_fingerprint( ++ const X509_LOOKUP_METHOD *method); ++ ++int X509_LOOKUP_meth_set_get_by_alias(X509_LOOKUP_METHOD *method, ++ X509_LOOKUP_get_by_alias_fn fn); ++X509_LOOKUP_get_by_alias_fn X509_LOOKUP_meth_get_get_by_alias( ++ const X509_LOOKUP_METHOD *method); ++ ++int X509_STORE_add_cert(X509_STORE *ctx, X509 *x); ++int X509_STORE_add_crl(X509_STORE *ctx, X509_CRL *x); ++ ++int X509_STORE_CTX_get_by_subject(X509_STORE_CTX *vs, X509_LOOKUP_TYPE type, ++ X509_NAME *name, X509_OBJECT *ret); ++X509_OBJECT *X509_STORE_CTX_get_obj_by_subject(X509_STORE_CTX *vs, ++ X509_LOOKUP_TYPE type, ++ X509_NAME *name); ++ ++int X509_LOOKUP_ctrl(X509_LOOKUP *ctx, int cmd, const char *argc, ++ long argl, char **ret); ++ ++int X509_load_cert_file(X509_LOOKUP *ctx, const char *file, int type); ++int X509_load_crl_file(X509_LOOKUP *ctx, const char *file, int type); ++int X509_load_cert_crl_file(X509_LOOKUP *ctx, const char *file, int type); ++ ++X509_LOOKUP *X509_LOOKUP_new(X509_LOOKUP_METHOD *method); ++void X509_LOOKUP_free(X509_LOOKUP *ctx); ++int X509_LOOKUP_init(X509_LOOKUP *ctx); ++int X509_LOOKUP_by_subject(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type, ++ X509_NAME *name, X509_OBJECT *ret); ++int X509_LOOKUP_by_issuer_serial(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type, ++ X509_NAME *name, ASN1_INTEGER *serial, ++ X509_OBJECT *ret); ++int X509_LOOKUP_by_fingerprint(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type, ++ const unsigned char *bytes, int len, ++ X509_OBJECT *ret); ++int X509_LOOKUP_by_alias(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type, ++ const char *str, int len, X509_OBJECT *ret); ++int X509_LOOKUP_set_method_data(X509_LOOKUP *ctx, void *data); ++void *X509_LOOKUP_get_method_data(const X509_LOOKUP *ctx); ++X509_STORE *X509_LOOKUP_get_store(const X509_LOOKUP *ctx); ++int X509_LOOKUP_shutdown(X509_LOOKUP *ctx); ++ ++int X509_STORE_load_locations(X509_STORE *ctx, ++ const char *file, const char *dir); ++int X509_STORE_set_default_paths(X509_STORE *ctx); ++ ++#define X509_STORE_CTX_get_ex_new_index(l, p, newf, dupf, freef) \ ++ CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_X509_STORE_CTX, l, p, newf, dupf, freef) ++int X509_STORE_CTX_set_ex_data(X509_STORE_CTX *ctx, int idx, void *data); ++void *X509_STORE_CTX_get_ex_data(X509_STORE_CTX *ctx, int idx); ++int X509_STORE_CTX_get_error(X509_STORE_CTX *ctx); ++void X509_STORE_CTX_set_error(X509_STORE_CTX *ctx, int s); ++int X509_STORE_CTX_get_error_depth(X509_STORE_CTX *ctx); ++void X509_STORE_CTX_set_error_depth(X509_STORE_CTX *ctx, int depth); ++X509 *X509_STORE_CTX_get_current_cert(X509_STORE_CTX *ctx); ++void X509_STORE_CTX_set_current_cert(X509_STORE_CTX *ctx, X509 *x); ++X509 *X509_STORE_CTX_get0_current_issuer(X509_STORE_CTX *ctx); ++X509_CRL *X509_STORE_CTX_get0_current_crl(X509_STORE_CTX *ctx); ++X509_STORE_CTX *X509_STORE_CTX_get0_parent_ctx(X509_STORE_CTX *ctx); ++STACK_OF(X509) *X509_STORE_CTX_get0_chain(X509_STORE_CTX *ctx); ++STACK_OF(X509) *X509_STORE_CTX_get1_chain(X509_STORE_CTX *ctx); ++void X509_STORE_CTX_set_cert(X509_STORE_CTX *c, X509 *x); ++void X509_STORE_CTX_set0_verified_chain(X509_STORE_CTX *c, STACK_OF(X509) *sk); ++void X509_STORE_CTX_set0_crls(X509_STORE_CTX *c, STACK_OF(X509_CRL) *sk); ++int X509_STORE_CTX_set_purpose(X509_STORE_CTX *ctx, int purpose); ++int X509_STORE_CTX_set_trust(X509_STORE_CTX *ctx, int trust); ++int X509_STORE_CTX_purpose_inherit(X509_STORE_CTX *ctx, int def_purpose, ++ int purpose, int trust); ++void X509_STORE_CTX_set_flags(X509_STORE_CTX *ctx, unsigned long flags); ++void X509_STORE_CTX_set_time(X509_STORE_CTX *ctx, unsigned long flags, ++ time_t t); ++ ++X509_POLICY_TREE *X509_STORE_CTX_get0_policy_tree(X509_STORE_CTX *ctx); ++int X509_STORE_CTX_get_explicit_policy(X509_STORE_CTX *ctx); ++int X509_STORE_CTX_get_num_untrusted(X509_STORE_CTX *ctx); ++ ++X509_VERIFY_PARAM *X509_STORE_CTX_get0_param(X509_STORE_CTX *ctx); ++void X509_STORE_CTX_set0_param(X509_STORE_CTX *ctx, X509_VERIFY_PARAM *param); ++int X509_STORE_CTX_set_default(X509_STORE_CTX *ctx, const char *name); ++ ++/* ++ * Bridge opacity barrier between libcrypt and libssl, also needed to support ++ * offline testing in test/danetest.c ++ */ ++void X509_STORE_CTX_set0_dane(X509_STORE_CTX *ctx, SSL_DANE *dane); ++#define DANE_FLAG_NO_DANE_EE_NAMECHECKS (1L << 0) ++ ++/* X509_VERIFY_PARAM functions */ ++ ++X509_VERIFY_PARAM *X509_VERIFY_PARAM_new(void); ++void X509_VERIFY_PARAM_free(X509_VERIFY_PARAM *param); ++int X509_VERIFY_PARAM_inherit(X509_VERIFY_PARAM *to, ++ const X509_VERIFY_PARAM *from); ++int X509_VERIFY_PARAM_set1(X509_VERIFY_PARAM *to, ++ const X509_VERIFY_PARAM *from); ++int X509_VERIFY_PARAM_set1_name(X509_VERIFY_PARAM *param, const char *name); ++int X509_VERIFY_PARAM_set_flags(X509_VERIFY_PARAM *param, ++ unsigned long flags); ++int X509_VERIFY_PARAM_clear_flags(X509_VERIFY_PARAM *param, ++ unsigned long flags); ++unsigned long X509_VERIFY_PARAM_get_flags(X509_VERIFY_PARAM *param); ++int X509_VERIFY_PARAM_set_purpose(X509_VERIFY_PARAM *param, int purpose); ++int X509_VERIFY_PARAM_set_trust(X509_VERIFY_PARAM *param, int trust); ++void X509_VERIFY_PARAM_set_depth(X509_VERIFY_PARAM *param, int depth); ++void X509_VERIFY_PARAM_set_auth_level(X509_VERIFY_PARAM *param, int auth_level); ++time_t X509_VERIFY_PARAM_get_time(const X509_VERIFY_PARAM *param); ++void X509_VERIFY_PARAM_set_time(X509_VERIFY_PARAM *param, time_t t); ++int X509_VERIFY_PARAM_add0_policy(X509_VERIFY_PARAM *param, ++ ASN1_OBJECT *policy); ++int X509_VERIFY_PARAM_set1_policies(X509_VERIFY_PARAM *param, ++ STACK_OF(ASN1_OBJECT) *policies); ++ ++int X509_VERIFY_PARAM_set_inh_flags(X509_VERIFY_PARAM *param, ++ uint32_t flags); ++uint32_t X509_VERIFY_PARAM_get_inh_flags(const X509_VERIFY_PARAM *param); ++ ++int X509_VERIFY_PARAM_set1_host(X509_VERIFY_PARAM *param, ++ const char *name, size_t namelen); ++int X509_VERIFY_PARAM_add1_host(X509_VERIFY_PARAM *param, ++ const char *name, size_t namelen); ++void X509_VERIFY_PARAM_set_hostflags(X509_VERIFY_PARAM *param, ++ unsigned int flags); ++unsigned int X509_VERIFY_PARAM_get_hostflags(const X509_VERIFY_PARAM *param); ++char *X509_VERIFY_PARAM_get0_peername(X509_VERIFY_PARAM *); ++void X509_VERIFY_PARAM_move_peername(X509_VERIFY_PARAM *, X509_VERIFY_PARAM *); ++int X509_VERIFY_PARAM_set1_email(X509_VERIFY_PARAM *param, ++ const char *email, size_t emaillen); ++int X509_VERIFY_PARAM_set1_ip(X509_VERIFY_PARAM *param, ++ const unsigned char *ip, size_t iplen); ++int X509_VERIFY_PARAM_set1_ip_asc(X509_VERIFY_PARAM *param, ++ const char *ipasc); ++ ++int X509_VERIFY_PARAM_get_depth(const X509_VERIFY_PARAM *param); ++int X509_VERIFY_PARAM_get_auth_level(const X509_VERIFY_PARAM *param); ++const char *X509_VERIFY_PARAM_get0_name(const X509_VERIFY_PARAM *param); ++ ++int X509_VERIFY_PARAM_add0_table(X509_VERIFY_PARAM *param); ++int X509_VERIFY_PARAM_get_count(void); ++const X509_VERIFY_PARAM *X509_VERIFY_PARAM_get0(int id); ++const X509_VERIFY_PARAM *X509_VERIFY_PARAM_lookup(const char *name); ++void X509_VERIFY_PARAM_table_cleanup(void); ++ ++/* Non positive return values are errors */ ++#define X509_PCY_TREE_FAILURE -2 /* Failure to satisfy explicit policy */ ++#define X509_PCY_TREE_INVALID -1 /* Inconsistent or invalid extensions */ ++#define X509_PCY_TREE_INTERNAL 0 /* Internal error, most likely malloc */ ++ ++/* ++ * Positive return values form a bit mask, all but the first are internal to ++ * the library and don't appear in results from X509_policy_check(). ++ */ ++#define X509_PCY_TREE_VALID 1 /* The policy tree is valid */ ++#define X509_PCY_TREE_EMPTY 2 /* The policy tree is empty */ ++#define X509_PCY_TREE_EXPLICIT 4 /* Explicit policy required */ ++ ++int X509_policy_check(X509_POLICY_TREE **ptree, int *pexplicit_policy, ++ STACK_OF(X509) *certs, ++ STACK_OF(ASN1_OBJECT) *policy_oids, unsigned int flags); ++ ++void X509_policy_tree_free(X509_POLICY_TREE *tree); ++ ++int X509_policy_tree_level_count(const X509_POLICY_TREE *tree); ++X509_POLICY_LEVEL *X509_policy_tree_get0_level(const X509_POLICY_TREE *tree, ++ int i); ++ ++STACK_OF(X509_POLICY_NODE) *X509_policy_tree_get0_policies(const ++ X509_POLICY_TREE ++ *tree); ++ ++STACK_OF(X509_POLICY_NODE) *X509_policy_tree_get0_user_policies(const ++ X509_POLICY_TREE ++ *tree); ++ ++int X509_policy_level_node_count(X509_POLICY_LEVEL *level); ++ ++X509_POLICY_NODE *X509_policy_level_get0_node(X509_POLICY_LEVEL *level, ++ int i); ++ ++const ASN1_OBJECT *X509_policy_node_get0_policy(const X509_POLICY_NODE *node); ++ ++STACK_OF(POLICYQUALINFO) *X509_policy_node_get0_qualifiers(const ++ X509_POLICY_NODE ++ *node); ++const X509_POLICY_NODE *X509_policy_node_get0_parent(const X509_POLICY_NODE ++ *node); ++ ++#ifdef __cplusplus ++} ++#endif ++#endif +diff --git a/include/TA/openssl/openssl/x509err.h b/include/TA/openssl/openssl/x509err.h +new file mode 100644 +index 0000000..0a84ef0 +--- /dev/null ++++ b/include/TA/openssl/openssl/x509err.h +@@ -0,0 +1,134 @@ ++/* ++ * Generated by util/mkerr.pl DO NOT EDIT ++ * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved. ++ * ++ * Licensed under the OpenSSL license (the "License"). You may not use ++ * this file except in compliance with the License. You can obtain a copy ++ * in the file LICENSE in the source distribution or at ++ * https://www.openssl.org/source/license.html ++ */ ++ ++#ifndef HEADER_X509ERR_H ++# define HEADER_X509ERR_H ++ ++# include ++ ++# ifdef __cplusplus ++extern "C" ++# endif ++int ERR_load_X509_strings(void); ++ ++/* ++ * X509 function codes. ++ */ ++# define X509_F_ADD_CERT_DIR 100 ++# define X509_F_BUILD_CHAIN 106 ++# define X509_F_BY_FILE_CTRL 101 ++# define X509_F_CHECK_NAME_CONSTRAINTS 149 ++# define X509_F_CHECK_POLICY 145 ++# define X509_F_COMMON_VERIFY_SM2 165 ++# define X509_F_DANE_I2D 107 ++# define X509_F_DIR_CTRL 102 ++# define X509_F_GET_CERT_BY_SUBJECT 103 ++# define X509_F_I2D_X509_AUX 151 ++# define X509_F_LOOKUP_CERTS_SK 152 ++# define X509_F_NETSCAPE_SPKI_B64_DECODE 129 ++# define X509_F_NETSCAPE_SPKI_B64_ENCODE 130 ++# define X509_F_NEW_DIR 153 ++# define X509_F_X509AT_ADD1_ATTR 135 ++# define X509_F_X509V3_ADD_EXT 104 ++# define X509_F_X509_ATTRIBUTE_CREATE_BY_NID 136 ++# define X509_F_X509_ATTRIBUTE_CREATE_BY_OBJ 137 ++# define X509_F_X509_ATTRIBUTE_CREATE_BY_TXT 140 ++# define X509_F_X509_ATTRIBUTE_GET0_DATA 139 ++# define X509_F_X509_ATTRIBUTE_SET1_DATA 138 ++# define X509_F_X509_CHECK_PRIVATE_KEY 128 ++# define X509_F_X509_CRL_DIFF 105 ++# define X509_F_X509_CRL_METHOD_NEW 154 ++# define X509_F_X509_CRL_PRINT_FP 147 ++# define X509_F_X509_EXTENSION_CREATE_BY_NID 108 ++# define X509_F_X509_EXTENSION_CREATE_BY_OBJ 109 ++# define X509_F_X509_GET_PUBKEY_PARAMETERS 110 ++# define X509_F_X509_LOAD_CERT_CRL_FILE 132 ++# define X509_F_X509_LOAD_CERT_FILE 111 ++# define X509_F_X509_LOAD_CRL_FILE 112 ++# define X509_F_X509_LOOKUP_METH_NEW 160 ++# define X509_F_X509_LOOKUP_NEW 155 ++# define X509_F_X509_NAME_ADD_ENTRY 113 ++# define X509_F_X509_NAME_CANON 156 ++# define X509_F_X509_NAME_ENTRY_CREATE_BY_NID 114 ++# define X509_F_X509_NAME_ENTRY_CREATE_BY_TXT 131 ++# define X509_F_X509_NAME_ENTRY_SET_OBJECT 115 ++# define X509_F_X509_NAME_ONELINE 116 ++# define X509_F_X509_NAME_PRINT 117 ++# define X509_F_X509_OBJECT_NEW 150 ++# define X509_F_X509_PRINT_EX_FP 118 ++# define X509_F_X509_PUBKEY_DECODE 148 ++# define X509_F_X509_PUBKEY_GET 161 ++# define X509_F_X509_PUBKEY_GET0 119 ++# define X509_F_X509_PUBKEY_SET 120 ++# define X509_F_X509_REQ_CHECK_PRIVATE_KEY 144 ++# define X509_F_X509_REQ_PRINT_EX 121 ++# define X509_F_X509_REQ_PRINT_FP 122 ++# define X509_F_X509_REQ_TO_X509 123 ++# define X509_F_X509_REQ_VERIFY 163 ++# define X509_F_X509_REQ_VERIFY_SM2 164 ++# define X509_F_X509_STORE_ADD_CERT 124 ++# define X509_F_X509_STORE_ADD_CRL 125 ++# define X509_F_X509_STORE_ADD_LOOKUP 157 ++# define X509_F_X509_STORE_CTX_GET1_ISSUER 146 ++# define X509_F_X509_STORE_CTX_INIT 143 ++# define X509_F_X509_STORE_CTX_NEW 142 ++# define X509_F_X509_STORE_CTX_PURPOSE_INHERIT 134 ++# define X509_F_X509_STORE_NEW 158 ++# define X509_F_X509_TO_X509_REQ 126 ++# define X509_F_X509_TRUST_ADD 133 ++# define X509_F_X509_TRUST_SET 141 ++# define X509_F_X509_VERIFY 161 ++# define X509_F_X509_VERIFY_CERT 127 ++# define X509_F_X509_VERIFY_PARAM_NEW 159 ++# define X509_F_X509_VERIFY_SM2 162 ++ ++/* ++ * X509 reason codes. ++ */ ++# define X509_R_AKID_MISMATCH 110 ++# define X509_R_BAD_SELECTOR 133 ++# define X509_R_BAD_X509_FILETYPE 100 ++# define X509_R_BASE64_DECODE_ERROR 118 ++# define X509_R_CANT_CHECK_DH_KEY 114 ++# define X509_R_CERT_ALREADY_IN_HASH_TABLE 101 ++# define X509_R_CRL_ALREADY_DELTA 127 ++# define X509_R_CRL_VERIFY_FAILURE 131 ++# define X509_R_IDP_MISMATCH 128 ++# define X509_R_INVALID_ATTRIBUTES 138 ++# define X509_R_INVALID_DIRECTORY 113 ++# define X509_R_INVALID_FIELD_NAME 119 ++# define X509_R_INVALID_TRUST 123 ++# define X509_R_ISSUER_MISMATCH 129 ++# define X509_R_KEY_TYPE_MISMATCH 115 ++# define X509_R_KEY_VALUES_MISMATCH 116 ++# define X509_R_LOADING_CERT_DIR 103 ++# define X509_R_LOADING_DEFAULTS 104 ++# define X509_R_METHOD_NOT_SUPPORTED 124 ++# define X509_R_NAME_TOO_LONG 134 ++# define X509_R_NEWER_CRL_NOT_NEWER 132 ++# define X509_R_NO_CERTIFICATE_FOUND 135 ++# define X509_R_NO_CERTIFICATE_OR_CRL_FOUND 136 ++# define X509_R_NO_CERT_SET_FOR_US_TO_VERIFY 105 ++# define X509_R_NO_CRL_FOUND 137 ++# define X509_R_NO_CRL_NUMBER 130 ++# define X509_R_PUBLIC_KEY_DECODE_ERROR 125 ++# define X509_R_PUBLIC_KEY_ENCODE_ERROR 126 ++# define X509_R_SHOULD_RETRY 106 ++# define X509_R_UNABLE_TO_FIND_PARAMETERS_IN_CHAIN 107 ++# define X509_R_UNABLE_TO_GET_CERTS_PUBLIC_KEY 108 ++# define X509_R_UNKNOWN_KEY_TYPE 117 ++# define X509_R_UNKNOWN_NID 109 ++# define X509_R_UNKNOWN_PURPOSE_ID 121 ++# define X509_R_UNKNOWN_TRUST_ID 120 ++# define X509_R_UNSUPPORTED_ALGORITHM 111 ++# define X509_R_WRONG_LOOKUP_TYPE 112 ++# define X509_R_WRONG_TYPE 122 ++ ++#endif +-- +2.33.0 +