commit
757e776e1f
@ -0,0 +1 @@ |
||||
ippcp_example |
||||
@ -0,0 +1,16 @@ |
||||
/*
|
||||
* Copyright 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
|
||||
*/ |
||||
|
||||
/*
|
||||
* This file is only used by HP C on VMS, and is included automatically |
||||
* after each header file from this directory |
||||
*/ |
||||
|
||||
/* restore state. Must correspond to the save in __decc_include_prologue.h */ |
||||
#pragma names restore |
||||
@ -0,0 +1,20 @@ |
||||
/*
|
||||
* Copyright 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
|
||||
*/ |
||||
|
||||
/*
|
||||
* This file is only used by HP C on VMS, and is included automatically |
||||
* after each header file from this directory |
||||
*/ |
||||
|
||||
/* save state */ |
||||
#pragma names save |
||||
/* have the compiler shorten symbols larger than 31 chars to 23 chars
|
||||
* followed by a 8 hex char CRC |
||||
*/ |
||||
#pragma names as_is,shortened |
||||
@ -0,0 +1,50 @@ |
||||
/*
|
||||
* Copyright 2006-2018 The OpenSSL Project Authors. All Rights Reserved. |
||||
* Copyright (c) 2017, 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
|
||||
*/ |
||||
|
||||
/* Copyright (c) 2017 National Security Research Institute. All rights reserved. */ |
||||
|
||||
#ifndef OSSL_CRYPTO_ARIA_H |
||||
# define OSSL_CRYPTO_ARIA_H |
||||
|
||||
# include <openssl/opensslconf.h> |
||||
|
||||
# ifdef OPENSSL_NO_ARIA |
||||
# error ARIA is disabled. |
||||
# endif |
||||
|
||||
# define ARIA_ENCRYPT 1 |
||||
# define ARIA_DECRYPT 0 |
||||
|
||||
# define ARIA_BLOCK_SIZE 16 /* Size of each encryption/decryption block */ |
||||
# define ARIA_MAX_KEYS 17 /* Number of keys needed in the worst case */ |
||||
|
||||
typedef union { |
||||
unsigned char c[ARIA_BLOCK_SIZE]; |
||||
unsigned int u[ARIA_BLOCK_SIZE / sizeof(unsigned int)]; |
||||
} ARIA_u128; |
||||
|
||||
typedef unsigned char ARIA_c128[ARIA_BLOCK_SIZE]; |
||||
|
||||
struct aria_key_st { |
||||
ARIA_u128 rd_key[ARIA_MAX_KEYS]; |
||||
unsigned int rounds; |
||||
}; |
||||
typedef struct aria_key_st ARIA_KEY; |
||||
|
||||
|
||||
int aria_set_encrypt_key(const unsigned char *userKey, const int bits, |
||||
ARIA_KEY *key); |
||||
int aria_set_decrypt_key(const unsigned char *userKey, const int bits, |
||||
ARIA_KEY *key); |
||||
|
||||
void aria_encrypt(const unsigned char *in, unsigned char *out, |
||||
const ARIA_KEY *key); |
||||
|
||||
#endif |
||||
@ -0,0 +1,113 @@ |
||||
/*
|
||||
* 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 */ |
||||
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); |
||||
@ -0,0 +1,15 @@ |
||||
/*
|
||||
* 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 <openssl/async.h> |
||||
|
||||
int async_init(void); |
||||
void async_deinit(void); |
||||
void async_delete_thread_state(void); |
||||
|
||||
@ -0,0 +1,90 @@ |
||||
/*
|
||||
* Copyright 2014-2023 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 <openssl/bn.h> |
||||
# include <limits.h> |
||||
|
||||
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); |
||||
|
||||
#endif |
||||
@ -0,0 +1,27 @@ |
||||
{- join("\n",map { "/* $_ */" } @autowarntext) -} |
||||
/*
|
||||
* Copyright 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 OSSL_CRYPTO_BN_CONF_H |
||||
# define OSSL_CRYPTO_BN_CONF_H |
||||
|
||||
/*
|
||||
* The contents of this file are not used in the UEFI build, as |
||||
* both 32-bit and 64-bit builds are supported from a single run |
||||
* of the Configure script. |
||||
*/ |
||||
|
||||
/* Should we define BN_DIV2W here? */ |
||||
|
||||
/* Only one for the following should be defined */ |
||||
{- $config{b64l} ? "#define" : "#undef" -} SIXTY_FOUR_BIT_LONG |
||||
{- $config{b64} ? "#define" : "#undef" -} SIXTY_FOUR_BIT |
||||
{- $config{b32} ? "#define" : "#undef" -} THIRTY_TWO_BIT |
||||
|
||||
#endif |
||||
@ -0,0 +1,24 @@ |
||||
/*
|
||||
* Copyright 2015-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
|
||||
*/ |
||||
|
||||
#define declare_dh_bn(x) \ |
||||
extern const BIGNUM _bignum_dh##x##_p; \
|
||||
extern const BIGNUM _bignum_dh##x##_g; \
|
||||
extern const BIGNUM _bignum_dh##x##_q; |
||||
|
||||
declare_dh_bn(1024_160) |
||||
declare_dh_bn(2048_224) |
||||
declare_dh_bn(2048_256) |
||||
|
||||
extern const BIGNUM _bignum_ffdhe2048_p; |
||||
extern const BIGNUM _bignum_ffdhe3072_p; |
||||
extern const BIGNUM _bignum_ffdhe4096_p; |
||||
extern const BIGNUM _bignum_ffdhe6144_p; |
||||
extern const BIGNUM _bignum_ffdhe8192_p; |
||||
extern const BIGNUM _bignum_const_2; |
||||
@ -0,0 +1,32 @@ |
||||
/*
|
||||
* Copyright 2014-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 OPENSSL_NO_SRP |
||||
|
||||
extern const BIGNUM bn_group_1024; |
||||
|
||||
extern const BIGNUM bn_group_1536; |
||||
|
||||
extern const BIGNUM bn_group_2048; |
||||
|
||||
extern const BIGNUM bn_group_3072; |
||||
|
||||
extern const BIGNUM bn_group_4096; |
||||
|
||||
extern const BIGNUM bn_group_6144; |
||||
|
||||
extern const BIGNUM bn_group_8192; |
||||
|
||||
extern const BIGNUM bn_generator_19; |
||||
|
||||
extern const BIGNUM bn_generator_5; |
||||
|
||||
extern const BIGNUM bn_generator_2; |
||||
|
||||
#endif |
||||
@ -0,0 +1,42 @@ |
||||
/*
|
||||
* 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
|
||||
*/ |
||||
|
||||
#ifndef OSSL_CRYPTO_CHACHA_H |
||||
#define OSSL_CRYPTO_CHACHA_H |
||||
|
||||
#include <stddef.h> |
||||
|
||||
/*
|
||||
* ChaCha20_ctr32 encrypts |len| bytes from |inp| with the given key and |
||||
* nonce and writes the result to |out|, which may be equal to |inp|. |
||||
* The |key| is not 32 bytes of verbatim key material though, but the |
||||
* said material collected into 8 32-bit elements array in host byte |
||||
* order. Same approach applies to nonce: the |counter| argument is |
||||
* pointer to concatenated nonce and counter values collected into 4 |
||||
* 32-bit elements. This, passing crypto material collected into 32-bit |
||||
* elements as opposite to passing verbatim byte vectors, is chosen for |
||||
* efficiency in multi-call scenarios. |
||||
*/ |
||||
void ChaCha20_ctr32(unsigned char *out, const unsigned char *inp, |
||||
size_t len, const unsigned int key[8], |
||||
const unsigned int counter[4]); |
||||
/*
|
||||
* You can notice that there is no key setup procedure. Because it's |
||||
* as trivial as collecting bytes into 32-bit elements, it's reckoned |
||||
* that below macro is sufficient. |
||||
*/ |
||||
#define CHACHA_U8TOU32(p) ( \ |
||||
((unsigned int)(p)[0]) | ((unsigned int)(p)[1]<<8) | \
|
||||
((unsigned int)(p)[2]<<16) | ((unsigned int)(p)[3]<<24) ) |
||||
|
||||
#define CHACHA_KEY_SIZE 32 |
||||
#define CHACHA_CTR_SIZE 16 |
||||
#define CHACHA_BLK_SIZE 64 |
||||
|
||||
#endif |
||||
@ -0,0 +1,35 @@ |
||||
/*
|
||||
* 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 "internal/cryptlib.h" |
||||
|
||||
/* This file is not scanned by mkdef.pl, whereas cryptlib.h is */ |
||||
|
||||
struct thread_local_inits_st { |
||||
int async; |
||||
int err_state; |
||||
int rand; |
||||
}; |
||||
|
||||
int ossl_init_thread_start(uint64_t opts); |
||||
|
||||
/*
|
||||
* OPENSSL_INIT flags. The primary list of these is in crypto.h. Flags below |
||||
* are those omitted from crypto.h because they are "reserved for internal |
||||
* use". |
||||
*/ |
||||
# define OPENSSL_INIT_ZLIB 0x00010000L |
||||
# define OPENSSL_INIT_BASE_ONLY 0x00040000L |
||||
|
||||
/* OPENSSL_INIT_THREAD flags */ |
||||
# define OPENSSL_INIT_THREAD_ASYNC 0x01 |
||||
# define OPENSSL_INIT_THREAD_ERR_STATE 0x02 |
||||
# define OPENSSL_INIT_THREAD_RAND 0x04 |
||||
|
||||
void ossl_malloc_setup_failures(void); |
||||
@ -0,0 +1,82 @@ |
||||
/*
|
||||
* Copyright 2017-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
|
||||
*/ |
||||
|
||||
/*
|
||||
* This version of ctype.h provides a standardised and platform |
||||
* independent implementation that supports seven bit ASCII characters. |
||||
* The specific intent is to not pass extended ASCII characters (> 127) |
||||
* even if the host operating system would. |
||||
* |
||||
* There is EBCDIC support included for machines which use this. However, |
||||
* there are a number of concerns about how well EBCDIC is supported |
||||
* throughout the rest of the source code. Refer to issue #4154 for |
||||
* details. |
||||
*/ |
||||
#ifndef OSSL_CRYPTO_CTYPE_H |
||||
# define OSSL_CRYPTO_CTYPE_H |
||||
|
||||
# define CTYPE_MASK_lower 0x1 |
||||
# define CTYPE_MASK_upper 0x2 |
||||
# define CTYPE_MASK_digit 0x4 |
||||
# define CTYPE_MASK_space 0x8 |
||||
# define CTYPE_MASK_xdigit 0x10 |
||||
# define CTYPE_MASK_blank 0x20 |
||||
# define CTYPE_MASK_cntrl 0x40 |
||||
# define CTYPE_MASK_graph 0x80 |
||||
# define CTYPE_MASK_print 0x100 |
||||
# define CTYPE_MASK_punct 0x200 |
||||
# define CTYPE_MASK_base64 0x400 |
||||
# define CTYPE_MASK_asn1print 0x800 |
||||
|
||||
# define CTYPE_MASK_alpha (CTYPE_MASK_lower | CTYPE_MASK_upper) |
||||
# define CTYPE_MASK_alnum (CTYPE_MASK_alpha | CTYPE_MASK_digit) |
||||
|
||||
/*
|
||||
* The ascii mask assumes that any other classification implies that |
||||
* the character is ASCII and that there are no ASCII characters |
||||
* that aren't in any of the classifications. |
||||
* |
||||
* This assumption holds at the moment, but it might not in the future. |
||||
*/ |
||||
# define CTYPE_MASK_ascii (~0) |
||||
|
||||
# ifdef CHARSET_EBCDIC |
||||
int ossl_toascii(int c); |
||||
int ossl_fromascii(int c); |
||||
# else |
||||
# define ossl_toascii(c) (c) |
||||
# define ossl_fromascii(c) (c) |
||||
# endif |
||||
int ossl_ctype_check(int c, unsigned int mask); |
||||
int ossl_tolower(int c); |
||||
int ossl_toupper(int c); |
||||
|
||||
int ascii_isdigit(const char inchar); |
||||
|
||||
# define ossl_isalnum(c) (ossl_ctype_check((c), CTYPE_MASK_alnum)) |
||||
# define ossl_isalpha(c) (ossl_ctype_check((c), CTYPE_MASK_alpha)) |
||||
# ifdef CHARSET_EBCDIC |
||||
# define ossl_isascii(c) (ossl_ctype_check((c), CTYPE_MASK_ascii)) |
||||
# else |
||||
# define ossl_isascii(c) (((c) & ~127) == 0) |
||||
# endif |
||||
# define ossl_isblank(c) (ossl_ctype_check((c), CTYPE_MASK_blank)) |
||||
# define ossl_iscntrl(c) (ossl_ctype_check((c), CTYPE_MASK_cntrl)) |
||||
# define ossl_isdigit(c) (ossl_ctype_check((c), CTYPE_MASK_digit)) |
||||
# define ossl_isgraph(c) (ossl_ctype_check((c), CTYPE_MASK_graph)) |
||||
# define ossl_islower(c) (ossl_ctype_check((c), CTYPE_MASK_lower)) |
||||
# define ossl_isprint(c) (ossl_ctype_check((c), CTYPE_MASK_print)) |
||||
# define ossl_ispunct(c) (ossl_ctype_check((c), CTYPE_MASK_punct)) |
||||
# define ossl_isspace(c) (ossl_ctype_check((c), CTYPE_MASK_space)) |
||||
# define ossl_isupper(c) (ossl_ctype_check((c), CTYPE_MASK_upper)) |
||||
# define ossl_isxdigit(c) (ossl_ctype_check((c), CTYPE_MASK_xdigit)) |
||||
# define ossl_isbase64(c) (ossl_ctype_check((c), CTYPE_MASK_base64)) |
||||
# define ossl_isasn1print(c) (ossl_ctype_check((c), CTYPE_MASK_asn1print)) |
||||
|
||||
#endif |
||||
@ -0,0 +1,31 @@ |
||||
{- join("\n",map { "/* $_ */" } @autowarntext) -} |
||||
/*
|
||||
* Copyright 2016-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 OSSL_CRYPTO_DSO_CONF_H |
||||
# define OSSL_CRYPTO_DSO_CONF_H |
||||
{- # The DSO code currently always implements all functions so that no |
||||
# applications will have to worry about that from a compilation point |
||||
# of view. However, the "method"s may return zero unless that platform |
||||
# has support compiled in for them. Currently each method is enabled |
||||
# by a define "DSO_<name>" ... we translate the "dso_scheme" config |
||||
# string entry into using the following logic; |
||||
my $scheme = $disabled{dso} ? undef : uc $target{dso_scheme}; |
||||
if (!$scheme) { |
||||
$scheme = "NONE"; |
||||
} |
||||
my @macros = ( "DSO_$scheme" ); |
||||
if ($scheme eq 'DLFCN') { |
||||
@macros = ( "DSO_DLFCN", "HAVE_DLFCN_H" ); |
||||
} elsif ($scheme eq "DLFCN_NO_H") { |
||||
@macros = ( "DSO_DLFCN" ); |
||||
} |
||||
join("\n", map { "# define $_" } @macros); -} |
||||
# define DSO_EXTENSION "{- $target{dso_extension} -}" |
||||
#endif |
||||
@ -0,0 +1,53 @@ |
||||
/*
|
||||
* 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 <openssl/opensslconf.h> |
||||
|
||||
# ifndef OPENSSL_NO_EC |
||||
|
||||
# include <openssl/ec.h> |
||||
|
||||
/*-
|
||||
* 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); |
||||
|
||||
# endif /* OPENSSL_NO_EC */ |
||||
#endif |
||||
@ -0,0 +1,20 @@ |
||||
/*
|
||||
* Copyright 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
|
||||
*/ |
||||
|
||||
#include <openssl/engine.h> |
||||
|
||||
void engine_load_openssl_int(void); |
||||
void engine_load_devcrypto_int(void); |
||||
void engine_load_rdrand_int(void); |
||||
void engine_load_dynamic_int(void); |
||||
void engine_load_padlock_int(void); |
||||
void engine_load_capi_int(void); |
||||
void engine_load_dasync_int(void); |
||||
void engine_load_afalg_int(void); |
||||
void engine_cleanup_int(void); |
||||
@ -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 |
||||
@ -0,0 +1,442 @@ |
||||
/*
|
||||
* 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
|
||||
*/ |
||||
|
||||
#include <openssl/evp.h> |
||||
#include "internal/refcount.h" |
||||
|
||||
/*
|
||||
* Don't free up md_ctx->pctx in EVP_MD_CTX_reset, use the reserved flag |
||||
* values in evp.h |
||||
*/ |
||||
#define EVP_MD_CTX_FLAG_KEEP_PKEY_CTX 0x0400 |
||||
|
||||
struct evp_pkey_ctx_st { |
||||
/* Method associated with this operation */ |
||||
const EVP_PKEY_METHOD *pmeth; |
||||
/* Engine that implements this method or NULL if builtin */ |
||||
ENGINE *engine; |
||||
/* Key: may be NULL */ |
||||
EVP_PKEY *pkey; |
||||
/* Peer key for key agreement, may be NULL */ |
||||
EVP_PKEY *peerkey; |
||||
/* Actual operation */ |
||||
int operation; |
||||
/* Algorithm specific data */ |
||||
void *data; |
||||
/* Application specific data */ |
||||
void *app_data; |
||||
/* Keygen callback */ |
||||
EVP_PKEY_gen_cb *pkey_gencb; |
||||
/* implementation specific keygen data */ |
||||
int *keygen_info; |
||||
int keygen_info_count; |
||||
} /* EVP_PKEY_CTX */ ; |
||||
|
||||
#define EVP_PKEY_FLAG_DYNAMIC 1 |
||||
|
||||
struct evp_pkey_method_st { |
||||
int pkey_id; |
||||
int flags; |
||||
int (*init) (EVP_PKEY_CTX *ctx); |
||||
int (*copy) (EVP_PKEY_CTX *dst, EVP_PKEY_CTX *src); |
||||
void (*cleanup) (EVP_PKEY_CTX *ctx); |
||||
int (*paramgen_init) (EVP_PKEY_CTX *ctx); |
||||
int (*paramgen) (EVP_PKEY_CTX *ctx, EVP_PKEY *pkey); |
||||
int (*keygen_init) (EVP_PKEY_CTX *ctx); |
||||
int (*keygen) (EVP_PKEY_CTX *ctx, EVP_PKEY *pkey); |
||||
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); |
||||
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); |
||||
int (*verify_recover_init) (EVP_PKEY_CTX *ctx); |
||||
int (*verify_recover) (EVP_PKEY_CTX *ctx, |
||||
unsigned char *rout, size_t *routlen, |
||||
const unsigned char *sig, size_t siglen); |
||||
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); |
||||
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); |
||||
int (*encrypt_init) (EVP_PKEY_CTX *ctx); |
||||
int (*encrypt) (EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen, |
||||
const unsigned char *in, size_t inlen); |
||||
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); |
||||
int (*derive_init) (EVP_PKEY_CTX *ctx); |
||||
int (*derive) (EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen); |
||||
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); |
||||
int (*digestsign) (EVP_MD_CTX *ctx, unsigned char *sig, size_t *siglen, |
||||
const unsigned char *tbs, size_t tbslen); |
||||
int (*digestverify) (EVP_MD_CTX *ctx, const unsigned char *sig, |
||||
size_t siglen, const unsigned char *tbs, |
||||
size_t tbslen); |
||||
int (*check) (EVP_PKEY *pkey); |
||||
int (*public_check) (EVP_PKEY *pkey); |
||||
int (*param_check) (EVP_PKEY *pkey); |
||||
|
||||
int (*digest_custom) (EVP_PKEY_CTX *ctx, EVP_MD_CTX *mctx); |
||||
} /* EVP_PKEY_METHOD */ ; |
||||
|
||||
DEFINE_STACK_OF_CONST(EVP_PKEY_METHOD) |
||||
|
||||
void evp_pkey_set_cb_translate(BN_GENCB *cb, EVP_PKEY_CTX *ctx); |
||||
|
||||
extern const EVP_PKEY_METHOD cmac_pkey_meth; |
||||
extern const EVP_PKEY_METHOD dh_pkey_meth; |
||||
extern const EVP_PKEY_METHOD dhx_pkey_meth; |
||||
extern const EVP_PKEY_METHOD dsa_pkey_meth; |
||||
extern const EVP_PKEY_METHOD ec_pkey_meth; |
||||
extern const EVP_PKEY_METHOD sm2_pkey_meth; |
||||
extern const EVP_PKEY_METHOD ecx25519_pkey_meth; |
||||
extern const EVP_PKEY_METHOD ecx448_pkey_meth; |
||||
extern const EVP_PKEY_METHOD ed25519_pkey_meth; |
||||
extern const EVP_PKEY_METHOD ed448_pkey_meth; |
||||
extern const EVP_PKEY_METHOD hmac_pkey_meth; |
||||
extern const EVP_PKEY_METHOD rsa_pkey_meth; |
||||
extern const EVP_PKEY_METHOD rsa_pss_pkey_meth; |
||||
extern const EVP_PKEY_METHOD scrypt_pkey_meth; |
||||
extern const EVP_PKEY_METHOD tls1_prf_pkey_meth; |
||||
extern const EVP_PKEY_METHOD hkdf_pkey_meth; |
||||
extern const EVP_PKEY_METHOD poly1305_pkey_meth; |
||||
extern const EVP_PKEY_METHOD siphash_pkey_meth; |
||||
|
||||
struct evp_md_st { |
||||
int type; |
||||
int pkey_type; |
||||
int md_size; |
||||
unsigned long flags; |
||||
int (*init) (EVP_MD_CTX *ctx); |
||||
int (*update) (EVP_MD_CTX *ctx, const void *data, size_t count); |
||||
int (*final) (EVP_MD_CTX *ctx, unsigned char *md); |
||||
int (*copy) (EVP_MD_CTX *to, const EVP_MD_CTX *from); |
||||
int (*cleanup) (EVP_MD_CTX *ctx); |
||||
int block_size; |
||||
int ctx_size; /* how big does the ctx->md_data need to be */ |
||||
/* control function */ |
||||
int (*md_ctrl) (EVP_MD_CTX *ctx, int cmd, int p1, void *p2); |
||||
} /* EVP_MD */ ; |
||||
|
||||
struct evp_cipher_st { |
||||
int nid; |
||||
int block_size; |
||||
/* Default value for variable length ciphers */ |
||||
int key_len; |
||||
int iv_len; |
||||
/* Various flags */ |
||||
unsigned long flags; |
||||
/* init key */ |
||||
int (*init) (EVP_CIPHER_CTX *ctx, const unsigned char *key, |
||||
const unsigned char *iv, int enc); |
||||
/* encrypt/decrypt data */ |
||||
int (*do_cipher) (EVP_CIPHER_CTX *ctx, unsigned char *out, |
||||
const unsigned char *in, size_t inl); |
||||
/* cleanup ctx */ |
||||
int (*cleanup) (EVP_CIPHER_CTX *); |
||||
/* how big ctx->cipher_data needs to be */ |
||||
int ctx_size; |
||||
/* Populate a ASN1_TYPE with parameters */ |
||||
int (*set_asn1_parameters) (EVP_CIPHER_CTX *, ASN1_TYPE *); |
||||
/* Get parameters from a ASN1_TYPE */ |
||||
int (*get_asn1_parameters) (EVP_CIPHER_CTX *, ASN1_TYPE *); |
||||
/* Miscellaneous operations */ |
||||
int (*ctrl) (EVP_CIPHER_CTX *, int type, int arg, void *ptr); |
||||
/* Application data */ |
||||
void *app_data; |
||||
} /* EVP_CIPHER */ ; |
||||
|
||||
/* Macros to code block cipher wrappers */ |
||||
|
||||
/* Wrapper functions for each cipher mode */ |
||||
|
||||
#define EVP_C_DATA(kstruct, ctx) \ |
||||
((kstruct *)EVP_CIPHER_CTX_get_cipher_data(ctx)) |
||||
|
||||
#define BLOCK_CIPHER_ecb_loop() \ |
||||
size_t i, bl; \
|
||||
bl = EVP_CIPHER_CTX_cipher(ctx)->block_size; \
|
||||
if (inl < bl) return 1;\
|
||||
inl -= bl; \
|
||||
for (i=0; i <= inl; i+=bl) |
||||
|
||||
#define BLOCK_CIPHER_func_ecb(cname, cprefix, kstruct, ksched) \ |
||||
static int cname##_ecb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, size_t inl) \
|
||||
{\
|
||||
BLOCK_CIPHER_ecb_loop() \
|
||||
cprefix##_ecb_encrypt(in + i, out + i, &EVP_C_DATA(kstruct,ctx)->ksched, EVP_CIPHER_CTX_encrypting(ctx)); \
|
||||
return 1;\
|
||||
} |
||||
|
||||
#define EVP_MAXCHUNK ((size_t)1<<(sizeof(long)*8-2)) |
||||
|
||||
#define BLOCK_CIPHER_func_ofb(cname, cprefix, cbits, kstruct, ksched) \ |
||||
static int cname##_ofb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, size_t inl) \
|
||||
{\
|
||||
while(inl>=EVP_MAXCHUNK) {\
|
||||
int num = EVP_CIPHER_CTX_num(ctx);\
|
||||
cprefix##_ofb##cbits##_encrypt(in, out, (long)EVP_MAXCHUNK, &EVP_C_DATA(kstruct,ctx)->ksched, EVP_CIPHER_CTX_iv_noconst(ctx), &num); \
|
||||
EVP_CIPHER_CTX_set_num(ctx, num);\
|
||||
inl-=EVP_MAXCHUNK;\
|
||||
in +=EVP_MAXCHUNK;\
|
||||
out+=EVP_MAXCHUNK;\
|
||||
}\
|
||||
if (inl) {\
|
||||
int num = EVP_CIPHER_CTX_num(ctx);\
|
||||
cprefix##_ofb##cbits##_encrypt(in, out, (long)inl, &EVP_C_DATA(kstruct,ctx)->ksched, EVP_CIPHER_CTX_iv_noconst(ctx), &num); \
|
||||
EVP_CIPHER_CTX_set_num(ctx, num);\
|
||||
}\
|
||||
return 1;\
|
||||
} |
||||
|
||||
#define BLOCK_CIPHER_func_cbc(cname, cprefix, kstruct, ksched) \ |
||||
static int cname##_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, size_t inl) \
|
||||
{\
|
||||
while(inl>=EVP_MAXCHUNK) \
|
||||
{\
|
||||
cprefix##_cbc_encrypt(in, out, (long)EVP_MAXCHUNK, &EVP_C_DATA(kstruct,ctx)->ksched, EVP_CIPHER_CTX_iv_noconst(ctx), EVP_CIPHER_CTX_encrypting(ctx));\
|
||||
inl-=EVP_MAXCHUNK;\
|
||||
in +=EVP_MAXCHUNK;\
|
||||
out+=EVP_MAXCHUNK;\
|
||||
}\
|
||||
if (inl)\
|
||||
cprefix##_cbc_encrypt(in, out, (long)inl, &EVP_C_DATA(kstruct,ctx)->ksched, EVP_CIPHER_CTX_iv_noconst(ctx), EVP_CIPHER_CTX_encrypting(ctx));\
|
||||
return 1;\
|
||||
} |
||||
|
||||
#define BLOCK_CIPHER_func_cfb(cname, cprefix, cbits, kstruct, ksched) \ |
||||
static int cname##_cfb##cbits##_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, size_t inl) \
|
||||
{\
|
||||
size_t chunk = EVP_MAXCHUNK;\
|
||||
if (cbits == 1) chunk >>= 3;\
|
||||
if (inl < chunk) chunk = inl;\
|
||||
while (inl && inl >= chunk)\
|
||||
{\
|
||||
int num = EVP_CIPHER_CTX_num(ctx);\
|
||||
cprefix##_cfb##cbits##_encrypt(in, out, (long) \
|
||||
((cbits == 1) \
|
||||
&& !EVP_CIPHER_CTX_test_flags(ctx, EVP_CIPH_FLAG_LENGTH_BITS) \
|
||||
? chunk*8 : chunk), \
|
||||
&EVP_C_DATA(kstruct, ctx)->ksched, EVP_CIPHER_CTX_iv_noconst(ctx),\
|
||||
&num, EVP_CIPHER_CTX_encrypting(ctx));\
|
||||
EVP_CIPHER_CTX_set_num(ctx, num);\
|
||||
inl -= chunk;\
|
||||
in += chunk;\
|
||||
out += chunk;\
|
||||
if (inl < chunk) chunk = inl;\
|
||||
}\
|
||||
return 1;\
|
||||
} |
||||
|
||||
#define BLOCK_CIPHER_all_funcs(cname, cprefix, cbits, kstruct, ksched) \ |
||||
BLOCK_CIPHER_func_cbc(cname, cprefix, kstruct, ksched) \
|
||||
BLOCK_CIPHER_func_cfb(cname, cprefix, cbits, kstruct, ksched) \
|
||||
BLOCK_CIPHER_func_ecb(cname, cprefix, kstruct, ksched) \
|
||||
BLOCK_CIPHER_func_ofb(cname, cprefix, cbits, kstruct, ksched) |
||||
|
||||
#define BLOCK_CIPHER_def1(cname, nmode, mode, MODE, kstruct, nid, block_size, \ |
||||
key_len, iv_len, flags, init_key, cleanup, \
|
||||
set_asn1, get_asn1, ctrl) \
|
||||
static const EVP_CIPHER cname##_##mode = { \
|
||||
nid##_##nmode, block_size, key_len, iv_len, \
|
||||
flags | EVP_CIPH_##MODE##_MODE, \
|
||||
init_key, \
|
||||
cname##_##mode##_cipher, \
|
||||
cleanup, \
|
||||
sizeof(kstruct), \
|
||||
set_asn1, get_asn1,\
|
||||
ctrl, \
|
||||
NULL \
|
||||
}; \
|
||||
const EVP_CIPHER *EVP_##cname##_##mode(void) { return &cname##_##mode; } |
||||
|
||||
#define BLOCK_CIPHER_def_cbc(cname, kstruct, nid, block_size, key_len, \ |
||||
iv_len, flags, init_key, cleanup, set_asn1, \
|
||||
get_asn1, ctrl) \
|
||||
BLOCK_CIPHER_def1(cname, cbc, cbc, CBC, kstruct, nid, block_size, key_len, \
|
||||
iv_len, flags, init_key, cleanup, set_asn1, get_asn1, ctrl) |
||||
|
||||
#define BLOCK_CIPHER_def_cfb(cname, kstruct, nid, key_len, \ |
||||
iv_len, cbits, flags, init_key, cleanup, \
|
||||
set_asn1, get_asn1, ctrl) \
|
||||
BLOCK_CIPHER_def1(cname, cfb##cbits, cfb##cbits, CFB, kstruct, nid, 1, \
|
||||
key_len, iv_len, flags, init_key, cleanup, set_asn1, \
|
||||
get_asn1, ctrl) |
||||
|
||||
#define BLOCK_CIPHER_def_ofb(cname, kstruct, nid, key_len, \ |
||||
iv_len, cbits, flags, init_key, cleanup, \
|
||||
set_asn1, get_asn1, ctrl) \
|
||||
BLOCK_CIPHER_def1(cname, ofb##cbits, ofb, OFB, kstruct, nid, 1, \
|
||||
key_len, iv_len, flags, init_key, cleanup, set_asn1, \
|
||||
get_asn1, ctrl) |
||||
|
||||
#define BLOCK_CIPHER_def_ecb(cname, kstruct, nid, block_size, key_len, \ |
||||
flags, init_key, cleanup, set_asn1, \
|
||||
get_asn1, ctrl) \
|
||||
BLOCK_CIPHER_def1(cname, ecb, ecb, ECB, kstruct, nid, block_size, key_len, \
|
||||
0, flags, init_key, cleanup, set_asn1, get_asn1, ctrl) |
||||
|
||||
#define BLOCK_CIPHER_defs(cname, kstruct, \ |
||||
nid, block_size, key_len, iv_len, cbits, flags, \
|
||||
init_key, cleanup, set_asn1, get_asn1, ctrl) \
|
||||
BLOCK_CIPHER_def_cbc(cname, kstruct, nid, block_size, key_len, iv_len, flags, \
|
||||
init_key, cleanup, set_asn1, get_asn1, ctrl) \
|
||||
BLOCK_CIPHER_def_cfb(cname, kstruct, nid, key_len, iv_len, cbits, \
|
||||
flags, init_key, cleanup, set_asn1, get_asn1, ctrl) \
|
||||
BLOCK_CIPHER_def_ofb(cname, kstruct, nid, key_len, iv_len, cbits, \
|
||||
flags, init_key, cleanup, set_asn1, get_asn1, ctrl) \
|
||||
BLOCK_CIPHER_def_ecb(cname, kstruct, nid, block_size, key_len, flags, \
|
||||
init_key, cleanup, set_asn1, get_asn1, ctrl) |
||||
|
||||
/*-
|
||||
#define BLOCK_CIPHER_defs(cname, kstruct, \ |
||||
nid, block_size, key_len, iv_len, flags,\
|
||||
init_key, cleanup, set_asn1, get_asn1, ctrl)\
|
||||
static const EVP_CIPHER cname##_cbc = {\
|
||||
nid##_cbc, block_size, key_len, iv_len, \
|
||||
flags | EVP_CIPH_CBC_MODE,\
|
||||
init_key,\
|
||||
cname##_cbc_cipher,\
|
||||
cleanup,\
|
||||
sizeof(EVP_CIPHER_CTX)-sizeof((((EVP_CIPHER_CTX *)NULL)->c))+\
|
||||
sizeof((((EVP_CIPHER_CTX *)NULL)->c.kstruct)),\
|
||||
set_asn1, get_asn1,\
|
||||
ctrl, \
|
||||
NULL \
|
||||
};\
|
||||
const EVP_CIPHER *EVP_##cname##_cbc(void) { return &cname##_cbc; }\
|
||||
static const EVP_CIPHER cname##_cfb = {\
|
||||
nid##_cfb64, 1, key_len, iv_len, \
|
||||
flags | EVP_CIPH_CFB_MODE,\
|
||||
init_key,\
|
||||
cname##_cfb_cipher,\
|
||||
cleanup,\
|
||||
sizeof(EVP_CIPHER_CTX)-sizeof((((EVP_CIPHER_CTX *)NULL)->c))+\
|
||||
sizeof((((EVP_CIPHER_CTX *)NULL)->c.kstruct)),\
|
||||
set_asn1, get_asn1,\
|
||||
ctrl,\
|
||||
NULL \
|
||||
};\
|
||||
const EVP_CIPHER *EVP_##cname##_cfb(void) { return &cname##_cfb; }\
|
||||
static const EVP_CIPHER cname##_ofb = {\
|
||||
nid##_ofb64, 1, key_len, iv_len, \
|
||||
flags | EVP_CIPH_OFB_MODE,\
|
||||
init_key,\
|
||||
cname##_ofb_cipher,\
|
||||
cleanup,\
|
||||
sizeof(EVP_CIPHER_CTX)-sizeof((((EVP_CIPHER_CTX *)NULL)->c))+\
|
||||
sizeof((((EVP_CIPHER_CTX *)NULL)->c.kstruct)),\
|
||||
set_asn1, get_asn1,\
|
||||
ctrl,\
|
||||
NULL \
|
||||
};\
|
||||
const EVP_CIPHER *EVP_##cname##_ofb(void) { return &cname##_ofb; }\
|
||||
static const EVP_CIPHER cname##_ecb = {\
|
||||
nid##_ecb, block_size, key_len, iv_len, \
|
||||
flags | EVP_CIPH_ECB_MODE,\
|
||||
init_key,\
|
||||
cname##_ecb_cipher,\
|
||||
cleanup,\
|
||||
sizeof(EVP_CIPHER_CTX)-sizeof((((EVP_CIPHER_CTX *)NULL)->c))+\
|
||||
sizeof((((EVP_CIPHER_CTX *)NULL)->c.kstruct)),\
|
||||
set_asn1, get_asn1,\
|
||||
ctrl,\
|
||||
NULL \
|
||||
};\
|
||||
const EVP_CIPHER *EVP_##cname##_ecb(void) { return &cname##_ecb; } |
||||
*/ |
||||
|
||||
#define IMPLEMENT_BLOCK_CIPHER(cname, ksched, cprefix, kstruct, nid, \ |
||||
block_size, key_len, iv_len, cbits, \
|
||||
flags, init_key, \
|
||||
cleanup, set_asn1, get_asn1, ctrl) \
|
||||
BLOCK_CIPHER_all_funcs(cname, cprefix, cbits, kstruct, ksched) \
|
||||
BLOCK_CIPHER_defs(cname, kstruct, nid, block_size, key_len, iv_len, \
|
||||
cbits, flags, init_key, cleanup, set_asn1, \
|
||||
get_asn1, ctrl) |
||||
|
||||
#define IMPLEMENT_CFBR(cipher,cprefix,kstruct,ksched,keysize,cbits,iv_len,fl) \ |
||||
BLOCK_CIPHER_func_cfb(cipher##_##keysize,cprefix,cbits,kstruct,ksched) \
|
||||
BLOCK_CIPHER_def_cfb(cipher##_##keysize,kstruct, \
|
||||
NID_##cipher##_##keysize, keysize/8, iv_len, cbits, \
|
||||
(fl)|EVP_CIPH_FLAG_DEFAULT_ASN1, \
|
||||
cipher##_init_key, NULL, NULL, NULL, NULL) |
||||
|
||||
|
||||
# ifndef OPENSSL_NO_EC |
||||
|
||||
#define X25519_KEYLEN 32 |
||||
#define X448_KEYLEN 56 |
||||
#define ED448_KEYLEN 57 |
||||
|
||||
#define MAX_KEYLEN ED448_KEYLEN |
||||
|
||||
typedef struct { |
||||
unsigned char pubkey[MAX_KEYLEN]; |
||||
unsigned char *privkey; |
||||
} ECX_KEY; |
||||
|
||||
#endif |
||||
|
||||
/*
|
||||
* Type needs to be a bit field Sub-type needs to be for variations on the |
||||
* method, as in, can it do arbitrary encryption.... |
||||
*/ |
||||
struct evp_pkey_st { |
||||
int type; |
||||
int save_type; |
||||
CRYPTO_REF_COUNT references; |
||||
const EVP_PKEY_ASN1_METHOD *ameth; |
||||
ENGINE *engine; |
||||
ENGINE *pmeth_engine; /* If not NULL public key ENGINE to use */ |
||||
union { |
||||
void *ptr; |
||||
# ifndef OPENSSL_NO_RSA |
||||
struct rsa_st *rsa; /* RSA */ |
||||
# endif |
||||
# ifndef OPENSSL_NO_DSA |
||||
struct dsa_st *dsa; /* DSA */ |
||||
# endif |
||||
# ifndef OPENSSL_NO_DH |
||||
struct dh_st *dh; /* DH */ |
||||
# endif |
||||
# ifndef OPENSSL_NO_EC |
||||
struct ec_key_st *ec; /* ECC */ |
||||
ECX_KEY *ecx; /* X25519, X448, Ed25519, Ed448 */ |
||||
# endif |
||||
} pkey; |
||||
int save_parameters; |
||||
STACK_OF(X509_ATTRIBUTE) *attributes; /* [ 0 ] */ |
||||
CRYPTO_RWLOCK *lock; |
||||
} /* EVP_PKEY */ ; |
||||
|
||||
|
||||
void openssl_add_all_ciphers_int(void); |
||||
void openssl_add_all_digests_int(void); |
||||
void evp_cleanup_int(void); |
||||
void evp_app_cleanup_int(void); |
||||
|
||||
/* Pulling defines out of C source files */ |
||||
|
||||
#define EVP_RC4_KEY_SIZE 16 |
||||
#ifndef TLS1_1_VERSION |
||||
# define TLS1_1_VERSION 0x0302 |
||||
#endif |
||||
|
||||
void evp_encode_ctx_set_flags(EVP_ENCODE_CTX *ctx, unsigned int flags); |
||||
|
||||
/* EVP_ENCODE_CTX flags */ |
||||
/* Don't generate new lines when encoding */ |
||||
#define EVP_ENCODE_CTX_NO_NEWLINES 1 |
||||
/* Use the SRP base64 alphabet instead of the standard one */ |
||||
#define EVP_ENCODE_CTX_USE_SRP_ALPHABET 2 |
||||
@ -0,0 +1,15 @@ |
||||
/*
|
||||
* 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
|
||||
*/ |
||||
|
||||
#ifndef OSSL_CRYPTO_LHASH_H |
||||
# define OSSL_CRYPTO_LHASH_H |
||||
|
||||
unsigned long openssl_lh_strcasehash(const char *); |
||||
|
||||
#endif |
||||
@ -0,0 +1,256 @@ |
||||
/*
|
||||
* 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
|
||||
*/ |
||||
|
||||
/*-
|
||||
* This is a generic 32 bit "collector" for message digest algorithms. |
||||
* Whenever needed it collects input character stream into chunks of |
||||
* 32 bit values and invokes a block function that performs actual hash |
||||
* calculations. |
||||
* |
||||
* Porting guide. |
||||
* |
||||
* Obligatory macros: |
||||
* |
||||
* DATA_ORDER_IS_BIG_ENDIAN or DATA_ORDER_IS_LITTLE_ENDIAN |
||||
* this macro defines byte order of input stream. |
||||
* HASH_CBLOCK |
||||
* size of a unit chunk HASH_BLOCK operates on. |
||||
* HASH_LONG |
||||
* has to be at least 32 bit wide. |
||||
* HASH_CTX |
||||
* context structure that at least contains following |
||||
* members: |
||||
* typedef struct { |
||||
* ... |
||||
* HASH_LONG Nl,Nh; |
||||
* either { |
||||
* HASH_LONG data[HASH_LBLOCK]; |
||||
* unsigned char data[HASH_CBLOCK]; |
||||
* }; |
||||
* unsigned int num; |
||||
* ... |
||||
* } HASH_CTX; |
||||
* data[] vector is expected to be zeroed upon first call to |
||||
* HASH_UPDATE. |
||||
* HASH_UPDATE |
||||
* name of "Update" function, implemented here. |
||||
* HASH_TRANSFORM |
||||
* name of "Transform" function, implemented here. |
||||
* HASH_FINAL |
||||
* name of "Final" function, implemented here. |
||||
* HASH_BLOCK_DATA_ORDER |
||||
* name of "block" function capable of treating *unaligned* input |
||||
* message in original (data) byte order, implemented externally. |
||||
* HASH_MAKE_STRING |
||||
* macro converting context variables to an ASCII hash string. |
||||
* |
||||
* MD5 example: |
||||
* |
||||
* #define DATA_ORDER_IS_LITTLE_ENDIAN |
||||
* |
||||
* #define HASH_LONG MD5_LONG |
||||
* #define HASH_CTX MD5_CTX |
||||
* #define HASH_CBLOCK MD5_CBLOCK |
||||
* #define HASH_UPDATE MD5_Update |
||||
* #define HASH_TRANSFORM MD5_Transform |
||||
* #define HASH_FINAL MD5_Final |
||||
* #define HASH_BLOCK_DATA_ORDER md5_block_data_order |
||||
*/ |
||||
|
||||
#include <openssl/crypto.h> |
||||
|
||||
#if !defined(DATA_ORDER_IS_BIG_ENDIAN) && !defined(DATA_ORDER_IS_LITTLE_ENDIAN) |
||||
# error "DATA_ORDER must be defined!" |
||||
#endif |
||||
|
||||
#ifndef HASH_CBLOCK |
||||
# error "HASH_CBLOCK must be defined!" |
||||
#endif |
||||
#ifndef HASH_LONG |
||||
# error "HASH_LONG must be defined!" |
||||
#endif |
||||
#ifndef HASH_CTX |
||||
# error "HASH_CTX must be defined!" |
||||
#endif |
||||
|
||||
#ifndef HASH_UPDATE |
||||
# error "HASH_UPDATE must be defined!" |
||||
#endif |
||||
#ifndef HASH_TRANSFORM |
||||
# error "HASH_TRANSFORM must be defined!" |
||||
#endif |
||||
#ifndef HASH_FINAL |
||||
# error "HASH_FINAL must be defined!" |
||||
#endif |
||||
|
||||
#ifndef HASH_BLOCK_DATA_ORDER |
||||
# error "HASH_BLOCK_DATA_ORDER must be defined!" |
||||
#endif |
||||
|
||||
#define ROTATE(a,n) (((a)<<(n))|(((a)&0xffffffff)>>(32-(n)))) |
||||
|
||||
#if defined(DATA_ORDER_IS_BIG_ENDIAN) |
||||
|
||||
# define HOST_c2l(c,l) (l =(((unsigned long)(*((c)++)))<<24), \ |
||||
l|=(((unsigned long)(*((c)++)))<<16), \
|
||||
l|=(((unsigned long)(*((c)++)))<< 8), \
|
||||
l|=(((unsigned long)(*((c)++))) ) ) |
||||
# define HOST_l2c(l,c) (*((c)++)=(unsigned char)(((l)>>24)&0xff), \ |
||||
*((c)++)=(unsigned char)(((l)>>16)&0xff), \
|
||||
*((c)++)=(unsigned char)(((l)>> 8)&0xff), \
|
||||
*((c)++)=(unsigned char)(((l) )&0xff), \
|
||||
l) |
||||
|
||||
#elif defined(DATA_ORDER_IS_LITTLE_ENDIAN) |
||||
|
||||
# define HOST_c2l(c,l) (l =(((unsigned long)(*((c)++))) ), \ |
||||
l|=(((unsigned long)(*((c)++)))<< 8), \
|
||||
l|=(((unsigned long)(*((c)++)))<<16), \
|
||||
l|=(((unsigned long)(*((c)++)))<<24) ) |
||||
# define HOST_l2c(l,c) (*((c)++)=(unsigned char)(((l) )&0xff), \ |
||||
*((c)++)=(unsigned char)(((l)>> 8)&0xff), \
|
||||
*((c)++)=(unsigned char)(((l)>>16)&0xff), \
|
||||
*((c)++)=(unsigned char)(((l)>>24)&0xff), \
|
||||
l) |
||||
|
||||
#endif |
||||
|
||||
/*
|
||||
* Time for some action :-) |
||||
*/ |
||||
|
||||
int HASH_UPDATE(HASH_CTX *c, const void *data_, size_t len) |
||||
{ |
||||
const unsigned char *data = data_; |
||||
unsigned char *p; |
||||
HASH_LONG l; |
||||
size_t n; |
||||
|
||||
if (len == 0) |
||||
return 1; |
||||
|
||||
l = (c->Nl + (((HASH_LONG) len) << 3)) & 0xffffffffUL; |
||||
if (l < c->Nl) /* overflow */ |
||||
c->Nh++; |
||||
c->Nh += (HASH_LONG) (len >> 29); /* might cause compiler warning on
|
||||
* 16-bit */ |
||||
c->Nl = l; |
||||
|
||||
n = c->num; |
||||
if (n != 0) { |
||||
p = (unsigned char *)c->data; |
||||
|
||||
if (len >= HASH_CBLOCK || len + n >= HASH_CBLOCK) { |
||||
memcpy(p + n, data, HASH_CBLOCK - n); |
||||
HASH_BLOCK_DATA_ORDER(c, p, 1); |
||||
n = HASH_CBLOCK - n; |
||||
data += n; |
||||
len -= n; |
||||
c->num = 0; |
||||
/*
|
||||
* We use memset rather than OPENSSL_cleanse() here deliberately. |
||||
* Using OPENSSL_cleanse() here could be a performance issue. It |
||||
* will get properly cleansed on finalisation so this isn't a |
||||
* security problem. |
||||
*/ |
||||
memset(p, 0, HASH_CBLOCK); /* keep it zeroed */ |
||||
} else { |
||||
memcpy(p + n, data, len); |
||||
c->num += (unsigned int)len; |
||||
return 1; |
||||
} |
||||
} |
||||
|
||||
n = len / HASH_CBLOCK; |
||||
if (n > 0) { |
||||
HASH_BLOCK_DATA_ORDER(c, data, n); |
||||
n *= HASH_CBLOCK; |
||||
data += n; |
||||
len -= n; |
||||
} |
||||
|
||||
if (len != 0) { |
||||
p = (unsigned char *)c->data; |
||||
c->num = (unsigned int)len; |
||||
memcpy(p, data, len); |
||||
} |
||||
return 1; |
||||
} |
||||
|
||||
void HASH_TRANSFORM(HASH_CTX *c, const unsigned char *data) |
||||
{ |
||||
HASH_BLOCK_DATA_ORDER(c, data, 1); |
||||
} |
||||
|
||||
int HASH_FINAL(unsigned char *md, HASH_CTX *c) |
||||
{ |
||||
unsigned char *p = (unsigned char *)c->data; |
||||
size_t n = c->num; |
||||
|
||||
p[n] = 0x80; /* there is always room for one */ |
||||
n++; |
||||
|
||||
if (n > (HASH_CBLOCK - 8)) { |
||||
memset(p + n, 0, HASH_CBLOCK - n); |
||||
n = 0; |
||||
HASH_BLOCK_DATA_ORDER(c, p, 1); |
||||
} |
||||
memset(p + n, 0, HASH_CBLOCK - 8 - n); |
||||
|
||||
p += HASH_CBLOCK - 8; |
||||
#if defined(DATA_ORDER_IS_BIG_ENDIAN) |
||||
(void)HOST_l2c(c->Nh, p); |
||||
(void)HOST_l2c(c->Nl, p); |
||||
#elif defined(DATA_ORDER_IS_LITTLE_ENDIAN) |
||||
(void)HOST_l2c(c->Nl, p); |
||||
(void)HOST_l2c(c->Nh, p); |
||||
#endif |
||||
p -= HASH_CBLOCK; |
||||
HASH_BLOCK_DATA_ORDER(c, p, 1); |
||||
c->num = 0; |
||||
OPENSSL_cleanse(p, HASH_CBLOCK); |
||||
|
||||
#ifndef HASH_MAKE_STRING |
||||
# error "HASH_MAKE_STRING must be defined!" |
||||
#else |
||||
HASH_MAKE_STRING(c, md); |
||||
#endif |
||||
|
||||
return 1; |
||||
} |
||||
|
||||
#ifndef MD32_REG_T |
||||
# if defined(__alpha) || defined(__sparcv9) || defined(__mips) |
||||
# define MD32_REG_T long |
||||
/*
|
||||
* This comment was originally written for MD5, which is why it |
||||
* discusses A-D. But it basically applies to all 32-bit digests, |
||||
* which is why it was moved to common header file. |
||||
* |
||||
* In case you wonder why A-D are declared as long and not |
||||
* as MD5_LONG. Doing so results in slight performance |
||||
* boost on LP64 architectures. The catch is we don't |
||||
* really care if 32 MSBs of a 64-bit register get polluted |
||||
* with eventual overflows as we *save* only 32 LSBs in |
||||
* *either* case. Now declaring 'em long excuses the compiler |
||||
* from keeping 32 MSBs zeroed resulting in 13% performance |
||||
* improvement under SPARC Solaris7/64 and 5% under AlphaLinux. |
||||
* Well, to be honest it should say that this *prevents* |
||||
* performance degradation. |
||||
*/ |
||||
# else |
||||
/*
|
||||
* Above is not absolute and there are LP64 compilers that |
||||
* generate better code if MD32_REG_T is defined int. The above |
||||
* pre-processor condition reflects the circumstances under which |
||||
* the conclusion was made and is subject to further extension. |
||||
*/ |
||||
# define MD32_REG_T int |
||||
# endif |
||||
#endif |
||||
@ -0,0 +1,12 @@ |
||||
/*
|
||||
* Copyright 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
|
||||
*/ |
||||
|
||||
#include <openssl/objects.h> |
||||
|
||||
void obj_cleanup_int(void); |
||||
@ -0,0 +1,21 @@ |
||||
/*
|
||||
* Copyright 2015-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
|
||||
*/ |
||||
|
||||
#include <stddef.h> |
||||
|
||||
#define POLY1305_BLOCK_SIZE 16 |
||||
#define POLY1305_DIGEST_SIZE 16 |
||||
#define POLY1305_KEY_SIZE 32 |
||||
|
||||
typedef struct poly1305_context POLY1305; |
||||
|
||||
size_t Poly1305_ctx_size(void); |
||||
void Poly1305_Init(POLY1305 *ctx, const unsigned char key[32]); |
||||
void Poly1305_Update(POLY1305 *ctx, const unsigned char *inp, size_t len); |
||||
void Poly1305_Final(POLY1305 *ctx, unsigned char mac[16]); |
||||
@ -0,0 +1,144 @@ |
||||
/*
|
||||
* Copyright 2016-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
|
||||
*/ |
||||
|
||||
/*
|
||||
* Licensed under the OpenSSL licenses, (the "License"); |
||||
* you may not use this file except in compliance with the License. |
||||
* You may obtain a copy of the License at |
||||
* https://www.openssl.org/source/license.html
|
||||
* or in the file LICENSE in the source distribution. |
||||
*/ |
||||
|
||||
#ifndef OSSL_CRYPTO_RAND_H |
||||
# define OSSL_CRYPTO_RAND_H |
||||
|
||||
# include <openssl/rand.h> |
||||
|
||||
# if defined(__APPLE__) && !defined(OPENSSL_NO_APPLE_CRYPTO_RANDOM) |
||||
# include <Availability.h> |
||||
# if (defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && __MAC_OS_X_VERSION_MIN_REQUIRED >= 101200) || \ |
||||
(defined(__IPHONE_OS_VERSION_MIN_REQUIRED) && __IPHONE_OS_VERSION_MIN_REQUIRED >= 80000) |
||||
# define OPENSSL_APPLE_CRYPTO_RANDOM 1 |
||||
# include <CommonCrypto/CommonCryptoError.h> |
||||
# include <CommonCrypto/CommonRandom.h> |
||||
# endif |
||||
# endif |
||||
|
||||
/* forward declaration */ |
||||
typedef struct rand_pool_st RAND_POOL; |
||||
|
||||
void rand_cleanup_int(void); |
||||
void rand_drbg_cleanup_int(void); |
||||
void drbg_delete_thread_state(void); |
||||
|
||||
/* Hardware-based seeding functions. */ |
||||
size_t rand_acquire_entropy_from_tsc(RAND_POOL *pool); |
||||
size_t rand_acquire_entropy_from_cpu(RAND_POOL *pool); |
||||
|
||||
/* DRBG entropy callbacks. */ |
||||
size_t rand_drbg_get_entropy(RAND_DRBG *drbg, |
||||
unsigned char **pout, |
||||
int entropy, size_t min_len, size_t max_len, |
||||
int prediction_resistance); |
||||
void rand_drbg_cleanup_entropy(RAND_DRBG *drbg, |
||||
unsigned char *out, size_t outlen); |
||||
size_t rand_drbg_get_nonce(RAND_DRBG *drbg, |
||||
unsigned char **pout, |
||||
int entropy, size_t min_len, size_t max_len); |
||||
void rand_drbg_cleanup_nonce(RAND_DRBG *drbg, |
||||
unsigned char *out, size_t outlen); |
||||
|
||||
size_t rand_drbg_get_additional_data(RAND_POOL *pool, unsigned char **pout); |
||||
|
||||
void rand_drbg_cleanup_additional_data(RAND_POOL *pool, unsigned char *out); |
||||
|
||||
/*
|
||||
* RAND_POOL functions |
||||
*/ |
||||
RAND_POOL *rand_pool_new(int entropy_requested, int secure, |
||||
size_t min_len, size_t max_len); |
||||
RAND_POOL *rand_pool_attach(const unsigned char *buffer, size_t len, |
||||
size_t entropy); |
||||
void rand_pool_free(RAND_POOL *pool); |
||||
|
||||
const unsigned char *rand_pool_buffer(RAND_POOL *pool); |
||||
unsigned char *rand_pool_detach(RAND_POOL *pool); |
||||
void rand_pool_reattach(RAND_POOL *pool, unsigned char *buffer); |
||||
|
||||
size_t rand_pool_entropy(RAND_POOL *pool); |
||||
size_t rand_pool_length(RAND_POOL *pool); |
||||
|
||||
size_t rand_pool_entropy_available(RAND_POOL *pool); |
||||
size_t rand_pool_entropy_needed(RAND_POOL *pool); |
||||
/* |entropy_factor| expresses how many bits of data contain 1 bit of entropy */ |
||||
size_t rand_pool_bytes_needed(RAND_POOL *pool, unsigned int entropy_factor); |
||||
size_t rand_pool_bytes_remaining(RAND_POOL *pool); |
||||
|
||||
int rand_pool_add(RAND_POOL *pool, |
||||
const unsigned char *buffer, size_t len, size_t entropy); |
||||
unsigned char *rand_pool_add_begin(RAND_POOL *pool, size_t len); |
||||
int rand_pool_add_end(RAND_POOL *pool, size_t len, size_t entropy); |
||||
|
||||
|
||||
/*
|
||||
* Add random bytes to the pool to acquire requested amount of entropy |
||||
* |
||||
* This function is platform specific and tries to acquire the requested |
||||
* amount of entropy by polling platform specific entropy sources. |
||||
* |
||||
* If the function succeeds in acquiring at least |entropy_requested| bits |
||||
* of entropy, the total entropy count is returned. If it fails, it returns |
||||
* an entropy count of 0. |
||||
*/ |
||||
size_t rand_pool_acquire_entropy(RAND_POOL *pool); |
||||
|
||||
/*
|
||||
* Add some application specific nonce data |
||||
* |
||||
* This function is platform specific and adds some application specific |
||||
* data to the nonce used for instantiating the drbg. |
||||
* |
||||
* This data currently consists of the process and thread id, and a high |
||||
* resolution timestamp. The data does not include an atomic counter, |
||||
* because that is added by the calling function rand_drbg_get_nonce(). |
||||
* |
||||
* Returns 1 on success and 0 on failure. |
||||
*/ |
||||
int rand_pool_add_nonce_data(RAND_POOL *pool); |
||||
|
||||
|
||||
/*
|
||||
* Add some platform specific additional data |
||||
* |
||||
* This function is platform specific and adds some random noise to the |
||||
* additional data used for generating random bytes and for reseeding |
||||
* the drbg. |
||||
* |
||||
* Returns 1 on success and 0 on failure. |
||||
*/ |
||||
int rand_pool_add_additional_data(RAND_POOL *pool); |
||||
|
||||
/*
|
||||
* Initialise the random pool reseeding sources. |
||||
* |
||||
* Returns 1 on success and 0 on failure. |
||||
*/ |
||||
int rand_pool_init(void); |
||||
|
||||
/*
|
||||
* Finalise the random pool reseeding sources. |
||||
*/ |
||||
void rand_pool_cleanup(void); |
||||
|
||||
/*
|
||||
* Control the random pool use of open file descriptors. |
||||
*/ |
||||
void rand_pool_keep_random_devices_open(int keep); |
||||
|
||||
#endif |
||||
@ -0,0 +1,19 @@ |
||||
/*
|
||||
* Copyright 2018 The OpenSSL Project Authors. All Rights Reserved. |
||||
* Copyright (c) 2018, 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 OSSL_CRYPTO_SHA_H |
||||
# define OSSL_CRYPTO_SHA_H |
||||
|
||||
# include <openssl/opensslconf.h> |
||||
|
||||
int sha512_224_init(SHA512_CTX *); |
||||
int sha512_256_init(SHA512_CTX *); |
||||
|
||||
#endif |
||||
@ -0,0 +1,25 @@ |
||||
/*
|
||||
* Copyright 2017-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 <stddef.h> |
||||
|
||||
#define SIPHASH_BLOCK_SIZE 8 |
||||
#define SIPHASH_KEY_SIZE 16 |
||||
#define SIPHASH_MIN_DIGEST_SIZE 8 |
||||
#define SIPHASH_MAX_DIGEST_SIZE 16 |
||||
|
||||
typedef struct siphash_st SIPHASH; |
||||
|
||||
size_t SipHash_ctx_size(void); |
||||
size_t SipHash_hash_size(SIPHASH *ctx); |
||||
int SipHash_set_hash_size(SIPHASH *ctx, size_t hash_size); |
||||
int SipHash_Init(SIPHASH *ctx, const unsigned char *k, |
||||
int crounds, int drounds); |
||||
void SipHash_Update(SIPHASH *ctx, const unsigned char *in, size_t inlen); |
||||
int SipHash_Final(SIPHASH *ctx, unsigned char *out, size_t outlen); |
||||
@ -0,0 +1,77 @@ |
||||
/*
|
||||
* Copyright 2017-2021 The OpenSSL Project Authors. All Rights Reserved. |
||||
* Copyright 2017 Ribose Inc. All Rights Reserved. |
||||
* Ported from Ribose contributions from Botan. |
||||
* |
||||
* 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_SM2_H |
||||
# define OSSL_CRYPTO_SM2_H |
||||
# include <openssl/opensslconf.h> |
||||
|
||||
# ifndef OPENSSL_NO_SM2 |
||||
|
||||
# include <openssl/ec.h> |
||||
|
||||
/* The default user id as specified in GM/T 0009-2012 */ |
||||
# define SM2_DEFAULT_USERID "1234567812345678" |
||||
|
||||
int sm2_compute_z_digest(uint8_t *out, |
||||
const EVP_MD *digest, |
||||
const uint8_t *id, |
||||
const size_t id_len, |
||||
const EC_KEY *key); |
||||
|
||||
/*
|
||||
* SM2 signature operation. Computes Z and then signs H(Z || msg) using SM2 |
||||
*/ |
||||
ECDSA_SIG *sm2_do_sign(const EC_KEY *key, |
||||
const EVP_MD *digest, |
||||
const uint8_t *id, |
||||
const size_t id_len, |
||||
const uint8_t *msg, size_t msg_len); |
||||
|
||||
int sm2_do_verify(const EC_KEY *key, |
||||
const EVP_MD *digest, |
||||
const ECDSA_SIG *signature, |
||||
const uint8_t *id, |
||||
const size_t id_len, |
||||
const uint8_t *msg, size_t msg_len); |
||||
|
||||
/*
|
||||
* SM2 signature generation. |
||||
*/ |
||||
int sm2_sign(const unsigned char *dgst, int dgstlen, |
||||
unsigned char *sig, unsigned int *siglen, EC_KEY *eckey); |
||||
|
||||
/*
|
||||
* SM2 signature verification. |
||||
*/ |
||||
int sm2_verify(const unsigned char *dgst, int dgstlen, |
||||
const unsigned char *sig, int siglen, EC_KEY *eckey); |
||||
|
||||
/*
|
||||
* SM2 encryption |
||||
*/ |
||||
int sm2_ciphertext_size(const EC_KEY *key, const EVP_MD *digest, size_t msg_len, |
||||
size_t *ct_size); |
||||
|
||||
int sm2_plaintext_size(const unsigned char *ct, size_t ct_size, size_t *pt_size); |
||||
|
||||
int sm2_encrypt(const EC_KEY *key, |
||||
const EVP_MD *digest, |
||||
const uint8_t *msg, |
||||
size_t msg_len, |
||||
uint8_t *ciphertext_buf, size_t *ciphertext_len); |
||||
|
||||
int sm2_decrypt(const EC_KEY *key, |
||||
const EVP_MD *digest, |
||||
const uint8_t *ciphertext, |
||||
size_t ciphertext_len, uint8_t *ptext_buf, size_t *ptext_len); |
||||
|
||||
# endif /* OPENSSL_NO_SM2 */ |
||||
#endif |
||||
@ -0,0 +1,65 @@ |
||||
/*
|
||||
* 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 OSSL_CRYPTO_SM2ERR_H |
||||
# define OSSL_CRYPTO_SM2ERR_H |
||||
|
||||
# ifndef HEADER_SYMHACKS_H |
||||
# include <openssl/symhacks.h> |
||||
# endif |
||||
|
||||
# include <openssl/opensslconf.h> |
||||
|
||||
# ifndef OPENSSL_NO_SM2 |
||||
|
||||
# ifdef __cplusplus |
||||
extern "C" |
||||
# endif |
||||
int ERR_load_SM2_strings(void); |
||||
|
||||
/*
|
||||
* SM2 function codes. |
||||
*/ |
||||
# define SM2_F_PKEY_SM2_COPY 115 |
||||
# define SM2_F_PKEY_SM2_CTRL 109 |
||||
# define SM2_F_PKEY_SM2_CTRL_STR 110 |
||||
# define SM2_F_PKEY_SM2_DIGEST_CUSTOM 114 |
||||
# define SM2_F_PKEY_SM2_INIT 111 |
||||
# define SM2_F_PKEY_SM2_SIGN 112 |
||||
# define SM2_F_SM2_COMPUTE_MSG_HASH 100 |
||||
# define SM2_F_SM2_COMPUTE_USERID_DIGEST 101 |
||||
# define SM2_F_SM2_COMPUTE_Z_DIGEST 113 |
||||
# define SM2_F_SM2_DECRYPT 102 |
||||
# define SM2_F_SM2_ENCRYPT 103 |
||||
# define SM2_F_SM2_PLAINTEXT_SIZE 104 |
||||
# define SM2_F_SM2_SIGN 105 |
||||
# define SM2_F_SM2_SIG_GEN 106 |
||||
# define SM2_F_SM2_SIG_VERIFY 107 |
||||
# define SM2_F_SM2_VERIFY 108 |
||||
|
||||
/*
|
||||
* SM2 reason codes. |
||||
*/ |
||||
# define SM2_R_ASN1_ERROR 100 |
||||
# define SM2_R_BAD_SIGNATURE 101 |
||||
# define SM2_R_BUFFER_TOO_SMALL 107 |
||||
# define SM2_R_DIST_ID_TOO_LARGE 110 |
||||
# define SM2_R_ID_NOT_SET 112 |
||||
# define SM2_R_ID_TOO_LARGE 111 |
||||
# define SM2_R_INVALID_CURVE 108 |
||||
# define SM2_R_INVALID_DIGEST 102 |
||||
# define SM2_R_INVALID_DIGEST_TYPE 103 |
||||
# define SM2_R_INVALID_ENCODING 104 |
||||
# define SM2_R_INVALID_FIELD 105 |
||||
# define SM2_R_NO_PARAMETERS_SET 109 |
||||
# define SM2_R_USER_ID_TOO_LARGE 106 |
||||
|
||||
# endif |
||||
#endif |
||||
@ -0,0 +1,39 @@ |
||||
/*
|
||||
* Copyright 2017 The OpenSSL Project Authors. All Rights Reserved. |
||||
* Copyright 2017 Ribose Inc. 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_SM3_H |
||||
# define OSSL_CRYPTO_SM3_H |
||||
|
||||
# include <openssl/opensslconf.h> |
||||
|
||||
# ifdef OPENSSL_NO_SM3 |
||||
# error SM3 is disabled. |
||||
# endif |
||||
|
||||
# define SM3_DIGEST_LENGTH 32 |
||||
# define SM3_WORD unsigned int |
||||
|
||||
# define SM3_CBLOCK 64 |
||||
# define SM3_LBLOCK (SM3_CBLOCK/4) |
||||
|
||||
typedef struct SM3state_st { |
||||
SM3_WORD A, B, C, D, E, F, G, H; |
||||
SM3_WORD Nl, Nh; |
||||
SM3_WORD data[SM3_LBLOCK]; |
||||
unsigned int num; |
||||
} SM3_CTX; |
||||
|
||||
int sm3_init(SM3_CTX *c); |
||||
int sm3_update(SM3_CTX *c, const void *data, size_t len); |
||||
int sm3_final(unsigned char *md, SM3_CTX *c); |
||||
|
||||
void sm3_block_data_order(SM3_CTX *c, const void *p, size_t num); |
||||
|
||||
#endif |
||||
@ -0,0 +1,37 @@ |
||||
/*
|
||||
* Copyright 2017 The OpenSSL Project Authors. All Rights Reserved. |
||||
* Copyright 2017 Ribose Inc. 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_SM4_H |
||||
# define OSSL_CRYPTO_SM4_H |
||||
|
||||
# include <openssl/opensslconf.h> |
||||
# include <openssl/e_os2.h> |
||||
|
||||
# ifdef OPENSSL_NO_SM4 |
||||
# error SM4 is disabled. |
||||
# endif |
||||
|
||||
# define SM4_ENCRYPT 1 |
||||
# define SM4_DECRYPT 0 |
||||
|
||||
# define SM4_BLOCK_SIZE 16 |
||||
# define SM4_KEY_SCHEDULE 32 |
||||
|
||||
typedef struct SM4_KEY_st { |
||||
uint32_t rk[SM4_KEY_SCHEDULE]; |
||||
} SM4_KEY; |
||||
|
||||
int SM4_set_key(const uint8_t *key, SM4_KEY *ks); |
||||
|
||||
void SM4_encrypt(const uint8_t *in, uint8_t *out, const SM4_KEY *ks); |
||||
|
||||
void SM4_decrypt(const uint8_t *in, uint8_t *out, const SM4_KEY *ks); |
||||
|
||||
#endif |
||||
@ -0,0 +1,28 @@ |
||||
/*
|
||||
* Copyright 2016-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 OSSL_CRYPTO_STORE_H |
||||
# define OSSL_CRYPTO_STORE_H |
||||
|
||||
# include <openssl/bio.h> |
||||
# include <openssl/store.h> |
||||
# include <openssl/ui.h> |
||||
|
||||
/*
|
||||
* Two functions to read PEM data off an already opened BIO. To be used |
||||
* instead of OSSLSTORE_open() and OSSLSTORE_close(). Everything is done |
||||
* as usual with OSSLSTORE_load() and OSSLSTORE_eof(). |
||||
*/ |
||||
OSSL_STORE_CTX *ossl_store_attach_pem_bio(BIO *bp, const UI_METHOD *ui_method, |
||||
void *ui_data); |
||||
int ossl_store_detach_pem_bio(OSSL_STORE_CTX *ctx); |
||||
|
||||
void ossl_store_cleanup_int(void); |
||||
|
||||
#endif |
||||
@ -0,0 +1,291 @@ |
||||
/*
|
||||
* Copyright 2015-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
|
||||
*/ |
||||
|
||||
#include "internal/refcount.h" |
||||
#include <openssl/x509.h> |
||||
#include <openssl/conf.h> |
||||
|
||||
/* Internal X509 structures and functions: not for application use */ |
||||
|
||||
/* Note: unless otherwise stated a field pointer is mandatory and should
|
||||
* never be set to NULL: the ASN.1 code and accessors rely on mandatory |
||||
* fields never being NULL. |
||||
*/ |
||||
|
||||
/*
|
||||
* name entry structure, equivalent to AttributeTypeAndValue defined |
||||
* in RFC5280 et al. |
||||
*/ |
||||
struct X509_name_entry_st { |
||||
ASN1_OBJECT *object; /* AttributeType */ |
||||
ASN1_STRING *value; /* AttributeValue */ |
||||
int set; /* index of RDNSequence for this entry */ |
||||
int size; /* temp variable */ |
||||
}; |
||||
|
||||
/* Name from RFC 5280. */ |
||||
struct X509_name_st { |
||||
STACK_OF(X509_NAME_ENTRY) *entries; /* DN components */ |
||||
int modified; /* true if 'bytes' needs to be built */ |
||||
BUF_MEM *bytes; /* cached encoding: cannot be NULL */ |
||||
/* canonical encoding used for rapid Name comparison */ |
||||
unsigned char *canon_enc; |
||||
int canon_enclen; |
||||
} /* X509_NAME */ ; |
||||
|
||||
/* Signature info structure */ |
||||
|
||||
struct x509_sig_info_st { |
||||
/* NID of message digest */ |
||||
int mdnid; |
||||
/* NID of public key algorithm */ |
||||
int pknid; |
||||
/* Security bits */ |
||||
int secbits; |
||||
/* Various flags */ |
||||
uint32_t flags; |
||||
}; |
||||
|
||||
/* PKCS#10 certificate request */ |
||||
|
||||
struct X509_req_info_st { |
||||
ASN1_ENCODING enc; /* cached encoding of signed part */ |
||||
ASN1_INTEGER *version; /* version, defaults to v1(0) so can be NULL */ |
||||
X509_NAME *subject; /* certificate request DN */ |
||||
X509_PUBKEY *pubkey; /* public key of request */ |
||||
/*
|
||||
* Zero or more attributes. |
||||
* NB: although attributes is a mandatory field some broken |
||||
* encodings omit it so this may be NULL in that case. |
||||
*/ |
||||
STACK_OF(X509_ATTRIBUTE) *attributes; |
||||
}; |
||||
|
||||
struct X509_req_st { |
||||
X509_REQ_INFO req_info; /* signed certificate request data */ |
||||
X509_ALGOR sig_alg; /* signature algorithm */ |
||||
ASN1_BIT_STRING *signature; /* signature */ |
||||
CRYPTO_REF_COUNT references; |
||||
CRYPTO_RWLOCK *lock; |
||||
}; |
||||
|
||||
struct X509_crl_info_st { |
||||
ASN1_INTEGER *version; /* version: defaults to v1(0) so may be NULL */ |
||||
X509_ALGOR sig_alg; /* signature algorithm */ |
||||
X509_NAME *issuer; /* CRL issuer name */ |
||||
ASN1_TIME *lastUpdate; /* lastUpdate field */ |
||||
ASN1_TIME *nextUpdate; /* nextUpdate field: optional */ |
||||
STACK_OF(X509_REVOKED) *revoked; /* revoked entries: optional */ |
||||
STACK_OF(X509_EXTENSION) *extensions; /* extensions: optional */ |
||||
ASN1_ENCODING enc; /* encoding of signed portion of CRL */ |
||||
}; |
||||
|
||||
struct X509_crl_st { |
||||
X509_CRL_INFO crl; /* signed CRL data */ |
||||
X509_ALGOR sig_alg; /* CRL signature algorithm */ |
||||
ASN1_BIT_STRING signature; /* CRL signature */ |
||||
CRYPTO_REF_COUNT references; |
||||
int flags; |
||||
/*
|
||||
* Cached copies of decoded extension values, since extensions |
||||
* are optional any of these can be NULL. |
||||
*/ |
||||
AUTHORITY_KEYID *akid; |
||||
ISSUING_DIST_POINT *idp; |
||||
/* Convenient breakdown of IDP */ |
||||
int idp_flags; |
||||
int idp_reasons; |
||||
/* CRL and base CRL numbers for delta processing */ |
||||
ASN1_INTEGER *crl_number; |
||||
ASN1_INTEGER *base_crl_number; |
||||
STACK_OF(GENERAL_NAMES) *issuers; |
||||
/* hash of CRL */ |
||||
unsigned char sha1_hash[SHA_DIGEST_LENGTH]; |
||||
/* alternative method to handle this CRL */ |
||||
const X509_CRL_METHOD *meth; |
||||
void *meth_data; |
||||
CRYPTO_RWLOCK *lock; |
||||
}; |
||||
|
||||
struct x509_revoked_st { |
||||
ASN1_INTEGER serialNumber; /* revoked entry serial number */ |
||||
ASN1_TIME *revocationDate; /* revocation date */ |
||||
STACK_OF(X509_EXTENSION) *extensions; /* CRL entry extensions: optional */ |
||||
/* decoded value of CRLissuer extension: set if indirect CRL */ |
||||
STACK_OF(GENERAL_NAME) *issuer; |
||||
/* revocation reason: set to CRL_REASON_NONE if reason extension absent */ |
||||
int reason; |
||||
/*
|
||||
* CRL entries are reordered for faster lookup of serial numbers. This |
||||
* field contains the original load sequence for this entry. |
||||
*/ |
||||
int sequence; |
||||
}; |
||||
|
||||
/*
|
||||
* This stuff is certificate "auxiliary info": it contains details which are |
||||
* useful in certificate stores and databases. When used this is tagged onto |
||||
* the end of the certificate itself. OpenSSL specific structure not defined |
||||
* in any RFC. |
||||
*/ |
||||
|
||||
struct x509_cert_aux_st { |
||||
STACK_OF(ASN1_OBJECT) *trust; /* trusted uses */ |
||||
STACK_OF(ASN1_OBJECT) *reject; /* rejected uses */ |
||||
ASN1_UTF8STRING *alias; /* "friendly name" */ |
||||
ASN1_OCTET_STRING *keyid; /* key id of private key */ |
||||
STACK_OF(X509_ALGOR) *other; /* other unspecified info */ |
||||
}; |
||||
|
||||
struct x509_cinf_st { |
||||
ASN1_INTEGER *version; /* [ 0 ] default of v1 */ |
||||
ASN1_INTEGER serialNumber; |
||||
X509_ALGOR signature; |
||||
X509_NAME *issuer; |
||||
X509_VAL validity; |
||||
X509_NAME *subject; |
||||
X509_PUBKEY *key; |
||||
ASN1_BIT_STRING *issuerUID; /* [ 1 ] optional in v2 */ |
||||
ASN1_BIT_STRING *subjectUID; /* [ 2 ] optional in v2 */ |
||||
STACK_OF(X509_EXTENSION) *extensions; /* [ 3 ] optional in v3 */ |
||||
ASN1_ENCODING enc; |
||||
}; |
||||
|
||||
struct x509_st { |
||||
X509_CINF cert_info; |
||||
X509_ALGOR sig_alg; |
||||
ASN1_BIT_STRING signature; |
||||
X509_SIG_INFO siginf; |
||||
CRYPTO_REF_COUNT references; |
||||
CRYPTO_EX_DATA ex_data; |
||||
/* These contain copies of various extension values */ |
||||
long ex_pathlen; |
||||
long ex_pcpathlen; |
||||
uint32_t ex_flags; |
||||
uint32_t ex_kusage; |
||||
uint32_t ex_xkusage; |
||||
uint32_t ex_nscert; |
||||
ASN1_OCTET_STRING *skid; |
||||
AUTHORITY_KEYID *akid; |
||||
X509_POLICY_CACHE *policy_cache; |
||||
STACK_OF(DIST_POINT) *crldp; |
||||
STACK_OF(GENERAL_NAME) *altname; |
||||
NAME_CONSTRAINTS *nc; |
||||
#ifndef OPENSSL_NO_RFC3779 |
||||
STACK_OF(IPAddressFamily) *rfc3779_addr; |
||||
struct ASIdentifiers_st *rfc3779_asid; |
||||
# endif |
||||
unsigned char sha1_hash[SHA_DIGEST_LENGTH]; |
||||
X509_CERT_AUX *aux; |
||||
CRYPTO_RWLOCK *lock; |
||||
volatile int ex_cached; |
||||
} /* X509 */ ; |
||||
|
||||
/*
|
||||
* This is a used when verifying cert chains. Since the gathering of the |
||||
* cert chain can take some time (and have to be 'retried', this needs to be |
||||
* kept and passed around. |
||||
*/ |
||||
struct x509_store_ctx_st { /* X509_STORE_CTX */ |
||||
X509_STORE *ctx; |
||||
/* The following are set by the caller */ |
||||
/* The cert to check */ |
||||
X509 *cert; |
||||
/* chain of X509s - untrusted - passed in */ |
||||
STACK_OF(X509) *untrusted; |
||||
/* set of CRLs passed in */ |
||||
STACK_OF(X509_CRL) *crls; |
||||
X509_VERIFY_PARAM *param; |
||||
/* Other info for use with get_issuer() */ |
||||
void *other_ctx; |
||||
/* Callbacks for various operations */ |
||||
/* called to verify a certificate */ |
||||
int (*verify) (X509_STORE_CTX *ctx); |
||||
/* error callback */ |
||||
int (*verify_cb) (int ok, X509_STORE_CTX *ctx); |
||||
/* get issuers cert from ctx */ |
||||
int (*get_issuer) (X509 **issuer, X509_STORE_CTX *ctx, X509 *x); |
||||
/* check issued */ |
||||
int (*check_issued) (X509_STORE_CTX *ctx, X509 *x, X509 *issuer); |
||||
/* Check revocation status of chain */ |
||||
int (*check_revocation) (X509_STORE_CTX *ctx); |
||||
/* retrieve CRL */ |
||||
int (*get_crl) (X509_STORE_CTX *ctx, X509_CRL **crl, X509 *x); |
||||
/* Check CRL validity */ |
||||
int (*check_crl) (X509_STORE_CTX *ctx, X509_CRL *crl); |
||||
/* Check certificate against CRL */ |
||||
int (*cert_crl) (X509_STORE_CTX *ctx, X509_CRL *crl, X509 *x); |
||||
/* Check policy status of the chain */ |
||||
int (*check_policy) (X509_STORE_CTX *ctx); |
||||
STACK_OF(X509) *(*lookup_certs) (X509_STORE_CTX *ctx, X509_NAME *nm); |
||||
STACK_OF(X509_CRL) *(*lookup_crls) (X509_STORE_CTX *ctx, X509_NAME *nm); |
||||
int (*cleanup) (X509_STORE_CTX *ctx); |
||||
/* The following is built up */ |
||||
/* if 0, rebuild chain */ |
||||
int valid; |
||||
/* number of untrusted certs */ |
||||
int num_untrusted; |
||||
/* chain of X509s - built up and trusted */ |
||||
STACK_OF(X509) *chain; |
||||
/* Valid policy tree */ |
||||
X509_POLICY_TREE *tree; |
||||
/* Require explicit policy value */ |
||||
int explicit_policy; |
||||
/* When something goes wrong, this is why */ |
||||
int error_depth; |
||||
int error; |
||||
X509 *current_cert; |
||||
/* cert currently being tested as valid issuer */ |
||||
X509 *current_issuer; |
||||
/* current CRL */ |
||||
X509_CRL *current_crl; |
||||
/* score of current CRL */ |
||||
int current_crl_score; |
||||
/* Reason mask */ |
||||
unsigned int current_reasons; |
||||
/* For CRL path validation: parent context */ |
||||
X509_STORE_CTX *parent; |
||||
CRYPTO_EX_DATA ex_data; |
||||
SSL_DANE *dane; |
||||
/* signed via bare TA public key, rather than CA certificate */ |
||||
int bare_ta_signed; |
||||
}; |
||||
|
||||
/* PKCS#8 private key info structure */ |
||||
|
||||
struct pkcs8_priv_key_info_st { |
||||
ASN1_INTEGER *version; |
||||
X509_ALGOR *pkeyalg; |
||||
ASN1_OCTET_STRING *pkey; |
||||
STACK_OF(X509_ATTRIBUTE) *attributes; |
||||
}; |
||||
|
||||
struct X509_sig_st { |
||||
X509_ALGOR *algor; |
||||
ASN1_OCTET_STRING *digest; |
||||
}; |
||||
|
||||
struct x509_object_st { |
||||
/* one of the above types */ |
||||
X509_LOOKUP_TYPE type; |
||||
union { |
||||
char *ptr; |
||||
X509 *x509; |
||||
X509_CRL *crl; |
||||
EVP_PKEY *pkey; |
||||
} data; |
||||
}; |
||||
|
||||
int a2i_ipadd(unsigned char *ipout, const char *ipasc); |
||||
int x509_set1_time(ASN1_TIME **ptm, const ASN1_TIME *tm); |
||||
|
||||
void x509_init_sig_info(X509 *x); |
||||
|
||||
int x509v3_add_len_value_uchar(const char *name, const unsigned char *value, |
||||
size_t vallen, STACK_OF(CONF_VALUE) **extlist); |
||||
@ -0,0 +1,16 @@ |
||||
/*
|
||||
* Copyright 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
|
||||
*/ |
||||
|
||||
/*
|
||||
* This file is only used by HP C on VMS, and is included automatically |
||||
* after each header file from this directory |
||||
*/ |
||||
|
||||
/* restore state. Must correspond to the save in __decc_include_prologue.h */ |
||||
#pragma names restore |
||||
@ -0,0 +1,20 @@ |
||||
/*
|
||||
* Copyright 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
|
||||
*/ |
||||
|
||||
/*
|
||||
* This file is only used by HP C on VMS, and is included automatically |
||||
* after each header file from this directory |
||||
*/ |
||||
|
||||
/* save state */ |
||||
#pragma names save |
||||
/* have the compiler shorten symbols larger than 31 chars to 23 chars
|
||||
* followed by a 8 hex char CRC |
||||
*/ |
||||
#pragma names as_is,shortened |
||||
@ -0,0 +1,33 @@ |
||||
/*
|
||||
* 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 <openssl/bio.h> |
||||
|
||||
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); |
||||
|
||||
|
||||
/* 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); |
||||
@ -0,0 +1,12 @@ |
||||
/*
|
||||
* Copyright 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
|
||||
*/ |
||||
|
||||
#include <openssl/comp.h> |
||||
|
||||
void comp_zlib_cleanup_int(void); |
||||
@ -0,0 +1,30 @@ |
||||
/*
|
||||
* Copyright 2016-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 OSSL_INTERNAL_CONF_H |
||||
# define OSSL_INTERNAL_CONF_H |
||||
|
||||
#include <openssl/conf.h> |
||||
|
||||
#define DEFAULT_CONF_MFLAGS \ |
||||
(CONF_MFLAGS_DEFAULT_SECTION | \
|
||||
CONF_MFLAGS_IGNORE_MISSING_FILE | \
|
||||
CONF_MFLAGS_IGNORE_RETURN_CODES) |
||||
|
||||
struct ossl_init_settings_st { |
||||
char *filename; |
||||
char *appname; |
||||
unsigned long flags; |
||||
}; |
||||
|
||||
int openssl_config_int(const OPENSSL_INIT_SETTINGS *); |
||||
void openssl_no_config_int(void); |
||||
void conf_modules_free_int(void); |
||||
|
||||
#endif |
||||
@ -0,0 +1,387 @@ |
||||
/*
|
||||
* Copyright 2014-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 OSSL_INTERNAL_CONSTANT_TIME_H |
||||
# define OSSL_INTERNAL_CONSTANT_TIME_H |
||||
|
||||
# include <stdlib.h> |
||||
# include <string.h> |
||||
# include <openssl/e_os2.h> /* For 'ossl_inline' */ |
||||
|
||||
/*-
|
||||
* The boolean methods return a bitmask of all ones (0xff...f) for true |
||||
* and 0 for false. This is useful for choosing a value based on the result |
||||
* of a conditional in constant time. For example, |
||||
* if (a < b) { |
||||
* c = a; |
||||
* } else { |
||||
* c = b; |
||||
* } |
||||
* can be written as |
||||
* unsigned int lt = constant_time_lt(a, b); |
||||
* c = constant_time_select(lt, a, b); |
||||
*/ |
||||
|
||||
/* Returns the given value with the MSB copied to all the other bits. */ |
||||
static ossl_inline unsigned int constant_time_msb(unsigned int a); |
||||
/* Convenience method for uint32_t. */ |
||||
static ossl_inline uint32_t constant_time_msb_32(uint32_t a); |
||||
/* Convenience method for uint64_t. */ |
||||
static ossl_inline uint64_t constant_time_msb_64(uint64_t a); |
||||
|
||||
/* Returns 0xff..f if a < b and 0 otherwise. */ |
||||
static ossl_inline unsigned int constant_time_lt(unsigned int a, |
||||
unsigned int b); |
||||
/* Convenience method for getting an 8-bit mask. */ |
||||
static ossl_inline unsigned char constant_time_lt_8(unsigned int a, |
||||
unsigned int b); |
||||
/* Convenience method for uint64_t. */ |
||||
static ossl_inline uint64_t constant_time_lt_64(uint64_t a, uint64_t b); |
||||
|
||||
/* Returns 0xff..f if a >= b and 0 otherwise. */ |
||||
static ossl_inline unsigned int constant_time_ge(unsigned int a, |
||||
unsigned int b); |
||||
/* Convenience method for getting an 8-bit mask. */ |
||||
static ossl_inline unsigned char constant_time_ge_8(unsigned int a, |
||||
unsigned int b); |
||||
|
||||
/* Returns 0xff..f if a == 0 and 0 otherwise. */ |
||||
static ossl_inline unsigned int constant_time_is_zero(unsigned int a); |
||||
/* Convenience method for getting an 8-bit mask. */ |
||||
static ossl_inline unsigned char constant_time_is_zero_8(unsigned int a); |
||||
/* Convenience method for getting a 32-bit mask. */ |
||||
static ossl_inline uint32_t constant_time_is_zero_32(uint32_t a); |
||||
|
||||
/* Returns 0xff..f if a == b and 0 otherwise. */ |
||||
static ossl_inline unsigned int constant_time_eq(unsigned int a, |
||||
unsigned int b); |
||||
/* Convenience method for getting an 8-bit mask. */ |
||||
static ossl_inline unsigned char constant_time_eq_8(unsigned int a, |
||||
unsigned int b); |
||||
/* Signed integers. */ |
||||
static ossl_inline unsigned int constant_time_eq_int(int a, int b); |
||||
/* Convenience method for getting an 8-bit mask. */ |
||||
static ossl_inline unsigned char constant_time_eq_int_8(int a, int b); |
||||
|
||||
/*-
|
||||
* Returns (mask & a) | (~mask & b). |
||||
* |
||||
* When |mask| is all 1s or all 0s (as returned by the methods above), |
||||
* the select methods return either |a| (if |mask| is nonzero) or |b| |
||||
* (if |mask| is zero). |
||||
*/ |
||||
static ossl_inline unsigned int constant_time_select(unsigned int mask, |
||||
unsigned int a, |
||||
unsigned int b); |
||||
/* Convenience method for unsigned chars. */ |
||||
static ossl_inline unsigned char constant_time_select_8(unsigned char mask, |
||||
unsigned char a, |
||||
unsigned char b); |
||||
|
||||
/* Convenience method for uint32_t. */ |
||||
static ossl_inline uint32_t constant_time_select_32(uint32_t mask, uint32_t a, |
||||
uint32_t b); |
||||
|
||||
/* Convenience method for uint64_t. */ |
||||
static ossl_inline uint64_t constant_time_select_64(uint64_t mask, uint64_t a, |
||||
uint64_t b); |
||||
/* Convenience method for signed integers. */ |
||||
static ossl_inline int constant_time_select_int(unsigned int mask, int a, |
||||
int b); |
||||
|
||||
|
||||
static ossl_inline unsigned int constant_time_msb(unsigned int a) |
||||
{ |
||||
return 0 - (a >> (sizeof(a) * 8 - 1)); |
||||
} |
||||
|
||||
|
||||
static ossl_inline uint32_t constant_time_msb_32(uint32_t a) |
||||
{ |
||||
return 0 - (a >> 31); |
||||
} |
||||
|
||||
static ossl_inline uint64_t constant_time_msb_64(uint64_t a) |
||||
{ |
||||
return 0 - (a >> 63); |
||||
} |
||||
|
||||
static ossl_inline size_t constant_time_msb_s(size_t a) |
||||
{ |
||||
return 0 - (a >> (sizeof(a) * 8 - 1)); |
||||
} |
||||
|
||||
static ossl_inline unsigned int constant_time_lt(unsigned int a, |
||||
unsigned int b) |
||||
{ |
||||
return constant_time_msb(a ^ ((a ^ b) | ((a - b) ^ b))); |
||||
} |
||||
|
||||
static ossl_inline size_t constant_time_lt_s(size_t a, size_t b) |
||||
{ |
||||
return constant_time_msb_s(a ^ ((a ^ b) | ((a - b) ^ b))); |
||||
} |
||||
|
||||
static ossl_inline unsigned char constant_time_lt_8(unsigned int a, |
||||
unsigned int b) |
||||
{ |
||||
return (unsigned char)constant_time_lt(a, b); |
||||
} |
||||
|
||||
static ossl_inline uint64_t constant_time_lt_64(uint64_t a, uint64_t b) |
||||
{ |
||||
return constant_time_msb_64(a ^ ((a ^ b) | ((a - b) ^ b))); |
||||
} |
||||
|
||||
static ossl_inline unsigned int constant_time_ge(unsigned int a, |
||||
unsigned int b) |
||||
{ |
||||
return ~constant_time_lt(a, b); |
||||
} |
||||
|
||||
static ossl_inline size_t constant_time_ge_s(size_t a, size_t b) |
||||
{ |
||||
return ~constant_time_lt_s(a, b); |
||||
} |
||||
|
||||
static ossl_inline unsigned char constant_time_ge_8(unsigned int a, |
||||
unsigned int b) |
||||
{ |
||||
return (unsigned char)constant_time_ge(a, b); |
||||
} |
||||
|
||||
static ossl_inline unsigned char constant_time_ge_8_s(size_t a, size_t b) |
||||
{ |
||||
return (unsigned char)constant_time_ge_s(a, b); |
||||
} |
||||
|
||||
static ossl_inline unsigned int constant_time_is_zero(unsigned int a) |
||||
{ |
||||
return constant_time_msb(~a & (a - 1)); |
||||
} |
||||
|
||||
static ossl_inline size_t constant_time_is_zero_s(size_t a) |
||||
{ |
||||
return constant_time_msb_s(~a & (a - 1)); |
||||
} |
||||
|
||||
static ossl_inline unsigned char constant_time_is_zero_8(unsigned int a) |
||||
{ |
||||
return (unsigned char)constant_time_is_zero(a); |
||||
} |
||||
|
||||
static ossl_inline uint32_t constant_time_is_zero_32(uint32_t a) |
||||
{ |
||||
return constant_time_msb_32(~a & (a - 1)); |
||||
} |
||||
|
||||
static ossl_inline unsigned int constant_time_eq(unsigned int a, |
||||
unsigned int b) |
||||
{ |
||||
return constant_time_is_zero(a ^ b); |
||||
} |
||||
|
||||
static ossl_inline size_t constant_time_eq_s(size_t a, size_t b) |
||||
{ |
||||
return constant_time_is_zero_s(a ^ b); |
||||
} |
||||
|
||||
static ossl_inline unsigned char constant_time_eq_8(unsigned int a, |
||||
unsigned int b) |
||||
{ |
||||
return (unsigned char)constant_time_eq(a, b); |
||||
} |
||||
|
||||
static ossl_inline unsigned char constant_time_eq_8_s(size_t a, size_t b) |
||||
{ |
||||
return (unsigned char)constant_time_eq_s(a, b); |
||||
} |
||||
|
||||
static ossl_inline unsigned int constant_time_eq_int(int a, int b) |
||||
{ |
||||
return constant_time_eq((unsigned)(a), (unsigned)(b)); |
||||
} |
||||
|
||||
static ossl_inline unsigned char constant_time_eq_int_8(int a, int b) |
||||
{ |
||||
return constant_time_eq_8((unsigned)(a), (unsigned)(b)); |
||||
} |
||||
|
||||
/*
|
||||
* Returns the value unmodified, but avoids optimizations. |
||||
* The barriers prevent the compiler from narrowing down the |
||||
* possible value range of the mask and ~mask in the select |
||||
* statements, which avoids the recognition of the select |
||||
* and turning it into a conditional load or branch. |
||||
*/ |
||||
static ossl_inline unsigned int value_barrier(unsigned int a) |
||||
{ |
||||
#if !defined(OPENSSL_NO_ASM) && defined(__GNUC__) |
||||
unsigned int r; |
||||
__asm__("" : "=r"(r) : "0"(a)); |
||||
#else |
||||
volatile unsigned int r = a; |
||||
#endif |
||||
return r; |
||||
} |
||||
|
||||
/* Convenience method for uint32_t. */ |
||||
static ossl_inline uint32_t value_barrier_32(uint32_t a) |
||||
{ |
||||
#if !defined(OPENSSL_NO_ASM) && defined(__GNUC__) |
||||
uint32_t r; |
||||
__asm__("" : "=r"(r) : "0"(a)); |
||||
#else |
||||
volatile uint32_t r = a; |
||||
#endif |
||||
return r; |
||||
} |
||||
|
||||
/* Convenience method for uint64_t. */ |
||||
static ossl_inline uint64_t value_barrier_64(uint64_t a) |
||||
{ |
||||
#if !defined(OPENSSL_NO_ASM) && defined(__GNUC__) |
||||
uint64_t r; |
||||
__asm__("" : "=r"(r) : "0"(a)); |
||||
#else |
||||
volatile uint64_t r = a; |
||||
#endif |
||||
return r; |
||||
} |
||||
|
||||
/* Convenience method for size_t. */ |
||||
static ossl_inline size_t value_barrier_s(size_t a) |
||||
{ |
||||
#if !defined(OPENSSL_NO_ASM) && defined(__GNUC__) |
||||
size_t r; |
||||
__asm__("" : "=r"(r) : "0"(a)); |
||||
#else |
||||
volatile size_t r = a; |
||||
#endif |
||||
return r; |
||||
} |
||||
|
||||
static ossl_inline unsigned int constant_time_select(unsigned int mask, |
||||
unsigned int a, |
||||
unsigned int b) |
||||
{ |
||||
return (value_barrier(mask) & a) | (value_barrier(~mask) & b); |
||||
} |
||||
|
||||
static ossl_inline size_t constant_time_select_s(size_t mask, |
||||
size_t a, |
||||
size_t b) |
||||
{ |
||||
return (value_barrier_s(mask) & a) | (value_barrier_s(~mask) & b); |
||||
} |
||||
|
||||
static ossl_inline unsigned char constant_time_select_8(unsigned char mask, |
||||
unsigned char a, |
||||
unsigned char b) |
||||
{ |
||||
return (unsigned char)constant_time_select(mask, a, b); |
||||
} |
||||
|
||||
static ossl_inline int constant_time_select_int(unsigned int mask, int a, |
||||
int b) |
||||
{ |
||||
return (int)constant_time_select(mask, (unsigned)(a), (unsigned)(b)); |
||||
} |
||||
|
||||
static ossl_inline int constant_time_select_int_s(size_t mask, int a, int b) |
||||
{ |
||||
return (int)constant_time_select((unsigned)mask, (unsigned)(a), |
||||
(unsigned)(b)); |
||||
} |
||||
|
||||
static ossl_inline uint32_t constant_time_select_32(uint32_t mask, uint32_t a, |
||||
uint32_t b) |
||||
{ |
||||
return (value_barrier_32(mask) & a) | (value_barrier_32(~mask) & b); |
||||
} |
||||
|
||||
static ossl_inline uint64_t constant_time_select_64(uint64_t mask, uint64_t a, |
||||
uint64_t b) |
||||
{ |
||||
return (value_barrier_64(mask) & a) | (value_barrier_64(~mask) & b); |
||||
} |
||||
|
||||
/*
|
||||
* mask must be 0xFFFFFFFF or 0x00000000. |
||||
* |
||||
* if (mask) { |
||||
* uint32_t tmp = *a; |
||||
* |
||||
* *a = *b; |
||||
* *b = tmp; |
||||
* } |
||||
*/ |
||||
static ossl_inline void constant_time_cond_swap_32(uint32_t mask, uint32_t *a, |
||||
uint32_t *b) |
||||
{ |
||||
uint32_t xor = *a ^ *b; |
||||
|
||||
xor &= mask; |
||||
*a ^= xor; |
||||
*b ^= xor; |
||||
} |
||||
|
||||
/*
|
||||
* mask must be 0xFFFFFFFF or 0x00000000. |
||||
* |
||||
* if (mask) { |
||||
* uint64_t tmp = *a; |
||||
* |
||||
* *a = *b; |
||||
* *b = tmp; |
||||
* } |
||||
*/ |
||||
static ossl_inline void constant_time_cond_swap_64(uint64_t mask, uint64_t *a, |
||||
uint64_t *b) |
||||
{ |
||||
uint64_t xor = *a ^ *b; |
||||
|
||||
xor &= mask; |
||||
*a ^= xor; |
||||
*b ^= xor; |
||||
} |
||||
|
||||
/*
|
||||
* table is a two dimensional array of bytes. Each row has rowsize elements. |
||||
* Copies row number idx into out. rowsize and numrows are not considered |
||||
* private. |
||||
*/ |
||||
static ossl_inline void constant_time_lookup(void *out, |
||||
const void *table, |
||||
size_t rowsize, |
||||
size_t numrows, |
||||
size_t idx) |
||||
{ |
||||
size_t i, j; |
||||
const unsigned char *tablec = (const unsigned char *)table; |
||||
unsigned char *outc = (unsigned char *)out; |
||||
unsigned char mask; |
||||
|
||||
memset(out, 0, rowsize); |
||||
|
||||
/* Note idx may underflow - but that is well defined */ |
||||
for (i = 0; i < numrows; i++, idx--) { |
||||
mask = (unsigned char)constant_time_is_zero_s(idx); |
||||
for (j = 0; j < rowsize; j++) |
||||
*(outc + j) |= constant_time_select_8(mask, *(tablec++), 0); |
||||
} |
||||
} |
||||
|
||||
/*
|
||||
* Expected usage pattern is to unconditionally set error and then |
||||
* wipe it if there was no actual error. |clear| is 1 or 0. |
||||
*/ |
||||
void err_clear_last_constant_time(int clear); |
||||
|
||||
#endif /* OSSL_INTERNAL_CONSTANT_TIME_H */ |
||||
@ -0,0 +1,99 @@ |
||||
/*
|
||||
* 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 OSSL_INTERNAL_CRYPTLIB_H |
||||
# define OSSL_INTERNAL_CRYPTLIB_H |
||||
|
||||
# include <stdlib.h> |
||||
# include <string.h> |
||||
|
||||
# ifdef OPENSSL_USE_APPLINK |
||||
# undef BIO_FLAGS_UPLINK |
||||
# define BIO_FLAGS_UPLINK 0x8000 |
||||
# include "ms/uplink.h" |
||||
# endif |
||||
|
||||
# include <openssl/crypto.h> |
||||
# include <openssl/buffer.h> |
||||
# include <openssl/bio.h> |
||||
# include <openssl/err.h> |
||||
# include "internal/nelem.h" |
||||
|
||||
#ifdef NDEBUG |
||||
# define ossl_assert(x) ((x) != 0) |
||||
#else |
||||
__owur static ossl_inline int ossl_assert_int(int expr, const char *exprstr, |
||||
const char *file, int line) |
||||
{ |
||||
if (!expr) |
||||
OPENSSL_die(exprstr, file, line); |
||||
|
||||
return expr; |
||||
} |
||||
|
||||
# define ossl_assert(x) ossl_assert_int((x) != 0, "Assertion failed: "#x, \ |
||||
__FILE__, __LINE__) |
||||
|
||||
#endif |
||||
|
||||
typedef struct ex_callback_st EX_CALLBACK; |
||||
|
||||
DEFINE_STACK_OF(EX_CALLBACK) |
||||
|
||||
typedef struct app_mem_info_st APP_INFO; |
||||
|
||||
typedef struct mem_st MEM; |
||||
DEFINE_LHASH_OF(MEM); |
||||
|
||||
# define OPENSSL_CONF "openssl.cnf" |
||||
|
||||
# ifndef OPENSSL_SYS_VMS |
||||
# define X509_CERT_AREA OPENSSLDIR |
||||
# define X509_CERT_DIR OPENSSLDIR "/certs" |
||||
# define X509_CERT_FILE OPENSSLDIR "/cert.pem" |
||||
# define X509_PRIVATE_DIR OPENSSLDIR "/private" |
||||
# define CTLOG_FILE OPENSSLDIR "/ct_log_list.cnf" |
||||
# else |
||||
# define X509_CERT_AREA "OSSL$DATAROOT:[000000]" |
||||
# define X509_CERT_DIR "OSSL$DATAROOT:[CERTS]" |
||||
# define X509_CERT_FILE "OSSL$DATAROOT:[000000]cert.pem" |
||||
# define X509_PRIVATE_DIR "OSSL$DATAROOT:[PRIVATE]" |
||||
# define CTLOG_FILE "OSSL$DATAROOT:[000000]ct_log_list.cnf" |
||||
# endif |
||||
|
||||
# define X509_CERT_DIR_EVP "SSL_CERT_DIR" |
||||
# define X509_CERT_FILE_EVP "SSL_CERT_FILE" |
||||
# define CTLOG_FILE_EVP "CTLOG_FILE" |
||||
|
||||
/* size of string representations */ |
||||
# define DECIMAL_SIZE(type) ((sizeof(type)*8+2)/3+1) |
||||
# define HEX_SIZE(type) (sizeof(type)*2) |
||||
|
||||
void OPENSSL_cpuid_setup(void); |
||||
extern unsigned int OPENSSL_ia32cap_P[]; |
||||
void OPENSSL_showfatal(const char *fmta, ...); |
||||
void crypto_cleanup_all_ex_data_int(void); |
||||
int openssl_init_fork_handlers(void); |
||||
int openssl_get_fork_id(void); |
||||
|
||||
char *ossl_safe_getenv(const char *name); |
||||
|
||||
extern CRYPTO_RWLOCK *memdbg_lock; |
||||
int openssl_strerror_r(int errnum, char *buf, size_t buflen); |
||||
# if !defined(OPENSSL_NO_STDIO) |
||||
FILE *openssl_fopen(const char *filename, const char *mode); |
||||
# else |
||||
void *openssl_fopen(const char *filename, const char *mode); |
||||
# endif |
||||
|
||||
uint32_t OPENSSL_rdtsc(void); |
||||
size_t OPENSSL_instrument_bus(unsigned int *, size_t); |
||||
size_t OPENSSL_instrument_bus2(unsigned int *, size_t, size_t); |
||||
|
||||
#endif |
||||
@ -0,0 +1,103 @@ |
||||
/*
|
||||
* Copyright 2015-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 OSSL_INTERNAL_DANE_H |
||||
#define OSSL_INTERNAL_DANE_H |
||||
|
||||
#include <openssl/safestack.h> |
||||
|
||||
/*-
|
||||
* Certificate usages: |
||||
* https://tools.ietf.org/html/rfc6698#section-2.1.1
|
||||
*/ |
||||
#define DANETLS_USAGE_PKIX_TA 0 |
||||
#define DANETLS_USAGE_PKIX_EE 1 |
||||
#define DANETLS_USAGE_DANE_TA 2 |
||||
#define DANETLS_USAGE_DANE_EE 3 |
||||
#define DANETLS_USAGE_LAST DANETLS_USAGE_DANE_EE |
||||
|
||||
/*-
|
||||
* Selectors: |
||||
* https://tools.ietf.org/html/rfc6698#section-2.1.2
|
||||
*/ |
||||
#define DANETLS_SELECTOR_CERT 0 |
||||
#define DANETLS_SELECTOR_SPKI 1 |
||||
#define DANETLS_SELECTOR_LAST DANETLS_SELECTOR_SPKI |
||||
|
||||
/*-
|
||||
* Matching types: |
||||
* https://tools.ietf.org/html/rfc6698#section-2.1.3
|
||||
*/ |
||||
#define DANETLS_MATCHING_FULL 0 |
||||
#define DANETLS_MATCHING_2256 1 |
||||
#define DANETLS_MATCHING_2512 2 |
||||
#define DANETLS_MATCHING_LAST DANETLS_MATCHING_2512 |
||||
|
||||
typedef struct danetls_record_st { |
||||
uint8_t usage; |
||||
uint8_t selector; |
||||
uint8_t mtype; |
||||
unsigned char *data; |
||||
size_t dlen; |
||||
EVP_PKEY *spki; |
||||
} danetls_record; |
||||
|
||||
DEFINE_STACK_OF(danetls_record) |
||||
|
||||
/*
|
||||
* Shared DANE context |
||||
*/ |
||||
struct dane_ctx_st { |
||||
const EVP_MD **mdevp; /* mtype -> digest */ |
||||
uint8_t *mdord; /* mtype -> preference */ |
||||
uint8_t mdmax; /* highest supported mtype */ |
||||
unsigned long flags; /* feature bitmask */ |
||||
}; |
||||
|
||||
/*
|
||||
* Per connection DANE state |
||||
*/ |
||||
struct ssl_dane_st { |
||||
struct dane_ctx_st *dctx; |
||||
STACK_OF(danetls_record) *trecs; |
||||
STACK_OF(X509) *certs; /* DANE-TA(2) Cert(0) Full(0) certs */ |
||||
danetls_record *mtlsa; /* Matching TLSA record */ |
||||
X509 *mcert; /* DANE matched cert */ |
||||
uint32_t umask; /* Usages present */ |
||||
int mdpth; /* Depth of matched cert */ |
||||
int pdpth; /* Depth of PKIX trust */ |
||||
unsigned long flags; /* feature bitmask */ |
||||
}; |
||||
|
||||
#define DANETLS_ENABLED(dane) \ |
||||
((dane) != NULL && sk_danetls_record_num((dane)->trecs) > 0) |
||||
|
||||
#define DANETLS_USAGE_BIT(u) (((uint32_t)1) << u) |
||||
|
||||
#define DANETLS_PKIX_TA_MASK (DANETLS_USAGE_BIT(DANETLS_USAGE_PKIX_TA)) |
||||
#define DANETLS_PKIX_EE_MASK (DANETLS_USAGE_BIT(DANETLS_USAGE_PKIX_EE)) |
||||
#define DANETLS_DANE_TA_MASK (DANETLS_USAGE_BIT(DANETLS_USAGE_DANE_TA)) |
||||
#define DANETLS_DANE_EE_MASK (DANETLS_USAGE_BIT(DANETLS_USAGE_DANE_EE)) |
||||
|
||||
#define DANETLS_PKIX_MASK (DANETLS_PKIX_TA_MASK | DANETLS_PKIX_EE_MASK) |
||||
#define DANETLS_DANE_MASK (DANETLS_DANE_TA_MASK | DANETLS_DANE_EE_MASK) |
||||
#define DANETLS_TA_MASK (DANETLS_PKIX_TA_MASK | DANETLS_DANE_TA_MASK) |
||||
#define DANETLS_EE_MASK (DANETLS_PKIX_EE_MASK | DANETLS_DANE_EE_MASK) |
||||
|
||||
#define DANETLS_HAS_PKIX(dane) ((dane) && ((dane)->umask & DANETLS_PKIX_MASK)) |
||||
#define DANETLS_HAS_DANE(dane) ((dane) && ((dane)->umask & DANETLS_DANE_MASK)) |
||||
#define DANETLS_HAS_TA(dane) ((dane) && ((dane)->umask & DANETLS_TA_MASK)) |
||||
#define DANETLS_HAS_EE(dane) ((dane) && ((dane)->umask & DANETLS_EE_MASK)) |
||||
|
||||
#define DANETLS_HAS_PKIX_TA(dane) ((dane)&&((dane)->umask & DANETLS_PKIX_TA_MASK)) |
||||
#define DANETLS_HAS_PKIX_EE(dane) ((dane)&&((dane)->umask & DANETLS_PKIX_EE_MASK)) |
||||
#define DANETLS_HAS_DANE_TA(dane) ((dane)&&((dane)->umask & DANETLS_DANE_TA_MASK)) |
||||
#define DANETLS_HAS_DANE_EE(dane) ((dane)&&((dane)->umask & DANETLS_DANE_EE_MASK)) |
||||
|
||||
#endif /* OSSL_INTERNAL_DANE_H */ |
||||
@ -0,0 +1,165 @@ |
||||
/*
|
||||
* Copyright 2000-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_INTERNAL_DSO_H |
||||
# define OSSL_INTERNAL_DSO_H |
||||
|
||||
# include <openssl/crypto.h> |
||||
# include "internal/dsoerr.h" |
||||
|
||||
/* These values are used as commands to DSO_ctrl() */ |
||||
# define DSO_CTRL_GET_FLAGS 1 |
||||
# define DSO_CTRL_SET_FLAGS 2 |
||||
# define DSO_CTRL_OR_FLAGS 3 |
||||
|
||||
/*
|
||||
* By default, DSO_load() will translate the provided filename into a form |
||||
* typical for the platform using the dso_name_converter function of the |
||||
* method. Eg. win32 will transform "blah" into "blah.dll", and dlfcn will |
||||
* transform it into "libblah.so". This callback could even utilise the |
||||
* DSO_METHOD's converter too if it only wants to override behaviour for |
||||
* one or two possible DSO methods. However, the following flag can be |
||||
* set in a DSO to prevent *any* native name-translation at all - eg. if |
||||
* the caller has prompted the user for a path to a driver library so the |
||||
* filename should be interpreted as-is. |
||||
*/ |
||||
# define DSO_FLAG_NO_NAME_TRANSLATION 0x01 |
||||
/*
|
||||
* An extra flag to give if only the extension should be added as |
||||
* translation. This is obviously only of importance on Unix and other |
||||
* operating systems where the translation also may prefix the name with |
||||
* something, like 'lib', and ignored everywhere else. This flag is also |
||||
* ignored if DSO_FLAG_NO_NAME_TRANSLATION is used at the same time. |
||||
*/ |
||||
# define DSO_FLAG_NAME_TRANSLATION_EXT_ONLY 0x02 |
||||
|
||||
/*
|
||||
* Don't unload the DSO when we call DSO_free() |
||||
*/ |
||||
# define DSO_FLAG_NO_UNLOAD_ON_FREE 0x04 |
||||
|
||||
/*
|
||||
* This flag loads the library with public symbols. Meaning: The exported |
||||
* symbols of this library are public to all libraries loaded after this |
||||
* library. At the moment only implemented in unix. |
||||
*/ |
||||
# define DSO_FLAG_GLOBAL_SYMBOLS 0x20 |
||||
|
||||
typedef void (*DSO_FUNC_TYPE) (void); |
||||
|
||||
typedef struct dso_st DSO; |
||||
typedef struct dso_meth_st DSO_METHOD; |
||||
|
||||
/*
|
||||
* The function prototype used for method functions (or caller-provided |
||||
* callbacks) that transform filenames. They are passed a DSO structure |
||||
* pointer (or NULL if they are to be used independently of a DSO object) and |
||||
* a filename to transform. They should either return NULL (if there is an |
||||
* error condition) or a newly allocated string containing the transformed |
||||
* form that the caller will need to free with OPENSSL_free() when done. |
||||
*/ |
||||
typedef char *(*DSO_NAME_CONVERTER_FUNC)(DSO *, const char *); |
||||
/*
|
||||
* The function prototype used for method functions (or caller-provided |
||||
* callbacks) that merge two file specifications. They are passed a DSO |
||||
* structure pointer (or NULL if they are to be used independently of a DSO |
||||
* object) and two file specifications to merge. They should either return |
||||
* NULL (if there is an error condition) or a newly allocated string |
||||
* containing the result of merging that the caller will need to free with |
||||
* OPENSSL_free() when done. Here, merging means that bits and pieces are |
||||
* taken from each of the file specifications and added together in whatever |
||||
* fashion that is sensible for the DSO method in question. The only rule |
||||
* that really applies is that if the two specification contain pieces of the |
||||
* same type, the copy from the first string takes priority. One could see |
||||
* it as the first specification is the one given by the user and the second |
||||
* being a bunch of defaults to add on if they're missing in the first. |
||||
*/ |
||||
typedef char *(*DSO_MERGER_FUNC)(DSO *, const char *, const char *); |
||||
|
||||
DSO *DSO_new(void); |
||||
int DSO_free(DSO *dso); |
||||
int DSO_flags(DSO *dso); |
||||
int DSO_up_ref(DSO *dso); |
||||
long DSO_ctrl(DSO *dso, int cmd, long larg, void *parg); |
||||
|
||||
/*
|
||||
* These functions can be used to get/set the platform-independent filename |
||||
* used for a DSO. NB: set will fail if the DSO is already loaded. |
||||
*/ |
||||
const char *DSO_get_filename(DSO *dso); |
||||
int DSO_set_filename(DSO *dso, const char *filename); |
||||
/*
|
||||
* This function will invoke the DSO's name_converter callback to translate a |
||||
* filename, or if the callback isn't set it will instead use the DSO_METHOD's |
||||
* converter. If "filename" is NULL, the "filename" in the DSO itself will be |
||||
* used. If the DSO_FLAG_NO_NAME_TRANSLATION flag is set, then the filename is |
||||
* simply duplicated. NB: This function is usually called from within a |
||||
* DSO_METHOD during the processing of a DSO_load() call, and is exposed so |
||||
* that caller-created DSO_METHODs can do the same thing. A non-NULL return |
||||
* value will need to be OPENSSL_free()'d. |
||||
*/ |
||||
char *DSO_convert_filename(DSO *dso, const char *filename); |
||||
/*
|
||||
* This function will invoke the DSO's merger callback to merge two file |
||||
* specifications, or if the callback isn't set it will instead use the |
||||
* DSO_METHOD's merger. A non-NULL return value will need to be |
||||
* OPENSSL_free()'d. |
||||
*/ |
||||
char *DSO_merge(DSO *dso, const char *filespec1, const char *filespec2); |
||||
|
||||
/*
|
||||
* The all-singing all-dancing load function, you normally pass NULL for the |
||||
* first and third parameters. Use DSO_up_ref and DSO_free for subsequent |
||||
* reference count handling. Any flags passed in will be set in the |
||||
* constructed DSO after its init() function but before the load operation. |
||||
* If 'dso' is non-NULL, 'flags' is ignored. |
||||
*/ |
||||
DSO *DSO_load(DSO *dso, const char *filename, DSO_METHOD *meth, int flags); |
||||
|
||||
/* This function binds to a function inside a shared library. */ |
||||
DSO_FUNC_TYPE DSO_bind_func(DSO *dso, const char *symname); |
||||
|
||||
/*
|
||||
* This method is the default, but will beg, borrow, or steal whatever method |
||||
* should be the default on any particular platform (including |
||||
* DSO_METH_null() if necessary). |
||||
*/ |
||||
DSO_METHOD *DSO_METHOD_openssl(void); |
||||
|
||||
/*
|
||||
* This function writes null-terminated pathname of DSO module containing |
||||
* 'addr' into 'sz' large caller-provided 'path' and returns the number of |
||||
* characters [including trailing zero] written to it. If 'sz' is 0 or |
||||
* negative, 'path' is ignored and required amount of characters [including |
||||
* trailing zero] to accommodate pathname is returned. If 'addr' is NULL, then |
||||
* pathname of cryptolib itself is returned. Negative or zero return value |
||||
* denotes error. |
||||
*/ |
||||
int DSO_pathbyaddr(void *addr, char *path, int sz); |
||||
|
||||
/*
|
||||
* Like DSO_pathbyaddr() but instead returns a handle to the DSO for the symbol |
||||
* or NULL on error. |
||||
*/ |
||||
DSO *DSO_dsobyaddr(void *addr, int flags); |
||||
|
||||
/*
|
||||
* This function should be used with caution! It looks up symbols in *all* |
||||
* loaded modules and if module gets unloaded by somebody else attempt to |
||||
* dereference the pointer is doomed to have fatal consequences. Primary |
||||
* usage for this function is to probe *core* system functionality, e.g. |
||||
* check if getnameinfo(3) is available at run-time without bothering about |
||||
* OS-specific details such as libc.so.versioning or where does it actually |
||||
* reside: in libc itself or libsocket. |
||||
*/ |
||||
void *DSO_global_lookup(const char *name); |
||||
|
||||
int ERR_load_DSO_strings(void); |
||||
|
||||
#endif |
||||
@ -0,0 +1,82 @@ |
||||
/*
|
||||
* 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 OSSL_INTERNAL_DSOERR_H |
||||
# define OSSL_INTERNAL_DSOERR_H |
||||
|
||||
# ifndef HEADER_SYMHACKS_H |
||||
# include <openssl/symhacks.h> |
||||
# endif |
||||
|
||||
# ifdef __cplusplus |
||||
extern "C" |
||||
# endif |
||||
int ERR_load_DSO_strings(void); |
||||
|
||||
/*
|
||||
* DSO function codes. |
||||
*/ |
||||
# define DSO_F_DLFCN_BIND_FUNC 100 |
||||
# define DSO_F_DLFCN_LOAD 102 |
||||
# define DSO_F_DLFCN_MERGER 130 |
||||
# define DSO_F_DLFCN_NAME_CONVERTER 123 |
||||
# define DSO_F_DLFCN_UNLOAD 103 |
||||
# define DSO_F_DL_BIND_FUNC 104 |
||||
# define DSO_F_DL_LOAD 106 |
||||
# define DSO_F_DL_MERGER 131 |
||||
# define DSO_F_DL_NAME_CONVERTER 124 |
||||
# define DSO_F_DL_UNLOAD 107 |
||||
# define DSO_F_DSO_BIND_FUNC 108 |
||||
# define DSO_F_DSO_CONVERT_FILENAME 126 |
||||
# define DSO_F_DSO_CTRL 110 |
||||
# define DSO_F_DSO_FREE 111 |
||||
# define DSO_F_DSO_GET_FILENAME 127 |
||||
# define DSO_F_DSO_GLOBAL_LOOKUP 139 |
||||
# define DSO_F_DSO_LOAD 112 |
||||
# define DSO_F_DSO_MERGE 132 |
||||
# define DSO_F_DSO_NEW_METHOD 113 |
||||
# define DSO_F_DSO_PATHBYADDR 105 |
||||
# define DSO_F_DSO_SET_FILENAME 129 |
||||
# define DSO_F_DSO_UP_REF 114 |
||||
# define DSO_F_VMS_BIND_SYM 115 |
||||
# define DSO_F_VMS_LOAD 116 |
||||
# define DSO_F_VMS_MERGER 133 |
||||
# define DSO_F_VMS_UNLOAD 117 |
||||
# define DSO_F_WIN32_BIND_FUNC 101 |
||||
# define DSO_F_WIN32_GLOBALLOOKUP 142 |
||||
# define DSO_F_WIN32_JOINER 135 |
||||
# define DSO_F_WIN32_LOAD 120 |
||||
# define DSO_F_WIN32_MERGER 134 |
||||
# define DSO_F_WIN32_NAME_CONVERTER 125 |
||||
# define DSO_F_WIN32_PATHBYADDR 109 |
||||
# define DSO_F_WIN32_SPLITTER 136 |
||||
# define DSO_F_WIN32_UNLOAD 121 |
||||
|
||||
/*
|
||||
* DSO reason codes. |
||||
*/ |
||||
# define DSO_R_CTRL_FAILED 100 |
||||
# define DSO_R_DSO_ALREADY_LOADED 110 |
||||
# define DSO_R_EMPTY_FILE_STRUCTURE 113 |
||||
# define DSO_R_FAILURE 114 |
||||
# define DSO_R_FILENAME_TOO_BIG 101 |
||||
# define DSO_R_FINISH_FAILED 102 |
||||
# define DSO_R_INCORRECT_FILE_SYNTAX 115 |
||||
# define DSO_R_LOAD_FAILED 103 |
||||
# define DSO_R_NAME_TRANSLATION_FAILED 109 |
||||
# define DSO_R_NO_FILENAME 111 |
||||
# define DSO_R_NULL_HANDLE 104 |
||||
# define DSO_R_SET_FILENAME_FAILED 112 |
||||
# define DSO_R_STACK_ERROR 105 |
||||
# define DSO_R_SYM_FAILURE 106 |
||||
# define DSO_R_UNLOAD_FAILED 107 |
||||
# define DSO_R_UNSUPPORTED 108 |
||||
|
||||
#endif |
||||
@ -0,0 +1,15 @@ |
||||
/*
|
||||
* Copyright 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 OSSL_INTERNAL_ERR_H |
||||
# define OSSL_INTERNAL_ERR_H |
||||
|
||||
void err_free_strings_int(void); |
||||
|
||||
#endif |
||||
@ -0,0 +1,14 @@ |
||||
/*
|
||||
* Copyright 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 OSSL_INTERNAL_NELEM_H |
||||
# define OSSL_INTERNAL_NELEM_H |
||||
|
||||
# define OSSL_NELEM(x) (sizeof(x)/sizeof((x)[0])) |
||||
#endif |
||||
@ -0,0 +1,68 @@ |
||||
/*
|
||||
* Copyright 2015-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 OSSL_INTERNAL_NUMBERS_H |
||||
# define OSSL_INTERNAL_NUMBERS_H |
||||
|
||||
# include <limits.h> |
||||
|
||||
# if (-1 & 3) == 0x03 /* Two's complement */ |
||||
|
||||
# define __MAXUINT__(T) ((T) -1) |
||||
# define __MAXINT__(T) ((T) ((((T) 1) << ((sizeof(T) * CHAR_BIT) - 1)) ^ __MAXUINT__(T))) |
||||
# define __MININT__(T) (-__MAXINT__(T) - 1) |
||||
|
||||
# elif (-1 & 3) == 0x02 /* One's complement */ |
||||
|
||||
# define __MAXUINT__(T) (((T) -1) + 1) |
||||
# define __MAXINT__(T) ((T) ((((T) 1) << ((sizeof(T) * CHAR_BIT) - 1)) ^ __MAXUINT__(T))) |
||||
# define __MININT__(T) (-__MAXINT__(T)) |
||||
|
||||
# elif (-1 & 3) == 0x01 /* Sign/magnitude */ |
||||
|
||||
# define __MAXINT__(T) ((T) (((((T) 1) << ((sizeof(T) * CHAR_BIT) - 2)) - 1) | (((T) 1) << ((sizeof(T) * CHAR_BIT) - 2)))) |
||||
# define __MAXUINT__(T) ((T) (__MAXINT__(T) | (((T) 1) << ((sizeof(T) * CHAR_BIT) - 1)))) |
||||
# define __MININT__(T) (-__MAXINT__(T)) |
||||
|
||||
# else |
||||
|
||||
# error "do not know the integer encoding on this architecture" |
||||
|
||||
# endif |
||||
|
||||
# ifndef INT8_MAX |
||||
# define INT8_MIN __MININT__(int8_t) |
||||
# define INT8_MAX __MAXINT__(int8_t) |
||||
# define UINT8_MAX __MAXUINT__(uint8_t) |
||||
# endif |
||||
|
||||
# ifndef INT16_MAX |
||||
# define INT16_MIN __MININT__(int16_t) |
||||
# define INT16_MAX __MAXINT__(int16_t) |
||||
# define UINT16_MAX __MAXUINT__(uint16_t) |
||||
# endif |
||||
|
||||
# ifndef INT32_MAX |
||||
# define INT32_MIN __MININT__(int32_t) |
||||
# define INT32_MAX __MAXINT__(int32_t) |
||||
# define UINT32_MAX __MAXUINT__(uint32_t) |
||||
# endif |
||||
|
||||
# ifndef INT64_MAX |
||||
# define INT64_MIN __MININT__(int64_t) |
||||
# define INT64_MAX __MAXINT__(int64_t) |
||||
# define UINT64_MAX __MAXUINT__(uint64_t) |
||||
# endif |
||||
|
||||
# ifndef SIZE_MAX |
||||
# define SIZE_MAX __MAXUINT__(size_t) |
||||
# endif |
||||
|
||||
#endif |
||||
|
||||
@ -0,0 +1,52 @@ |
||||
/*
|
||||
* Copyright 2004-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
|
||||
*/ |
||||
|
||||
/*
|
||||
* This file is dual-licensed and is also available under the following |
||||
* terms: |
||||
* |
||||
* Copyright (c) 2004, Richard Levitte <richard@levitte.org> |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions |
||||
* are met: |
||||
* 1. Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* 2. Redistributions in binary form must reproduce the above copyright |
||||
* notice, this list of conditions and the following disclaimer in the |
||||
* documentation and/or other materials provided with the distribution. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND |
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE |
||||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
||||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
||||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
||||
* SUCH DAMAGE. |
||||
*/ |
||||
|
||||
#ifndef OSSL_INTERNAL_O_DIR_H |
||||
# define OSSL_INTERNAL_O_DIR_H |
||||
|
||||
typedef struct OPENSSL_dir_context_st OPENSSL_DIR_CTX; |
||||
|
||||
/*
|
||||
* returns NULL on error or end-of-directory. If it is end-of-directory, |
||||
* errno will be zero |
||||
*/ |
||||
const char *OPENSSL_DIR_read(OPENSSL_DIR_CTX **ctx, const char *directory); |
||||
/* returns 1 on success, 0 on error */ |
||||
int OPENSSL_DIR_end(OPENSSL_DIR_CTX **ctx); |
||||
|
||||
#endif /* LPDIR_H */ |
||||
@ -0,0 +1,17 @@ |
||||
/*
|
||||
* Copyright 2003-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 OSSL_INTERNAL_O_STR_H |
||||
# define OSSL_INTERNAL_O_STR_H |
||||
|
||||
# include <stddef.h> /* to get size_t */ |
||||
|
||||
int OPENSSL_memcmp(const void *p1, const void *p2, size_t n); |
||||
|
||||
#endif |
||||
@ -0,0 +1,153 @@ |
||||
/*
|
||||
* Copyright 2016-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 OSSL_INTERNAL_REFCOUNT_H |
||||
# define OSSL_INTERNAL_REFCOUNT_H |
||||
|
||||
/* Used to checking reference counts, most while doing perl5 stuff :-) */ |
||||
# if defined(OPENSSL_NO_STDIO) |
||||
# if defined(REF_PRINT) |
||||
# error "REF_PRINT requires stdio" |
||||
# endif |
||||
# endif |
||||
|
||||
# if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L \ |
||||
&& !defined(__STDC_NO_ATOMICS__) |
||||
# include <stdatomic.h> |
||||
# define HAVE_C11_ATOMICS |
||||
# endif |
||||
|
||||
# if defined(HAVE_C11_ATOMICS) && defined(ATOMIC_INT_LOCK_FREE) \ |
||||
&& ATOMIC_INT_LOCK_FREE > 0 |
||||
|
||||
# define HAVE_ATOMICS 1 |
||||
|
||||
typedef _Atomic int CRYPTO_REF_COUNT; |
||||
|
||||
static inline int CRYPTO_UP_REF(_Atomic int *val, int *ret, void *lock) |
||||
{ |
||||
*ret = atomic_fetch_add_explicit(val, 1, memory_order_relaxed) + 1; |
||||
return 1; |
||||
} |
||||
|
||||
/*
|
||||
* Changes to shared structure other than reference counter have to be |
||||
* serialized. And any kind of serialization implies a release fence. This |
||||
* means that by the time reference counter is decremented all other |
||||
* changes are visible on all processors. Hence decrement itself can be |
||||
* relaxed. In case it hits zero, object will be destructed. Since it's |
||||
* last use of the object, destructor programmer might reason that access |
||||
* to mutable members doesn't have to be serialized anymore, which would |
||||
* otherwise imply an acquire fence. Hence conditional acquire fence... |
||||
*/ |
||||
static inline int CRYPTO_DOWN_REF(_Atomic int *val, int *ret, void *lock) |
||||
{ |
||||
*ret = atomic_fetch_sub_explicit(val, 1, memory_order_relaxed) - 1; |
||||
if (*ret == 0) |
||||
atomic_thread_fence(memory_order_acquire); |
||||
return 1; |
||||
} |
||||
|
||||
# elif defined(__GNUC__) && defined(__ATOMIC_RELAXED) && __GCC_ATOMIC_INT_LOCK_FREE > 0 |
||||
|
||||
# define HAVE_ATOMICS 1 |
||||
#define UNUSED(x) (void)(x) |
||||
|
||||
typedef int CRYPTO_REF_COUNT; |
||||
|
||||
static __inline__ int CRYPTO_UP_REF(int *val, int *ret, void *lock) |
||||
{ |
||||
UNUSED(lock); |
||||
*ret = __atomic_fetch_add(val, 1, __ATOMIC_RELAXED) + 1; |
||||
return 1; |
||||
} |
||||
|
||||
static __inline__ int CRYPTO_DOWN_REF(int *val, int *ret, void *lock) |
||||
{ |
||||
UNUSED(lock); |
||||
*ret = __atomic_fetch_sub(val, 1, __ATOMIC_RELAXED) - 1; |
||||
if (*ret == 0) |
||||
__atomic_thread_fence(__ATOMIC_ACQUIRE); |
||||
return 1; |
||||
} |
||||
|
||||
# elif defined(_MSC_VER) && _MSC_VER>=1200 |
||||
|
||||
# define HAVE_ATOMICS 1 |
||||
|
||||
typedef volatile int CRYPTO_REF_COUNT; |
||||
|
||||
# if (defined(_M_ARM) && _M_ARM>=7 && !defined(_WIN32_WCE)) || defined(_M_ARM64) |
||||
# include <intrin.h> |
||||
# if defined(_M_ARM64) && !defined(_ARM_BARRIER_ISH) |
||||
# define _ARM_BARRIER_ISH _ARM64_BARRIER_ISH |
||||
# endif |
||||
|
||||
static __inline int CRYPTO_UP_REF(volatile int *val, int *ret, void *lock) |
||||
{ |
||||
*ret = _InterlockedExchangeAdd_nf(val, 1) + 1; |
||||
return 1; |
||||
} |
||||
|
||||
static __inline int CRYPTO_DOWN_REF(volatile int *val, int *ret, void *lock) |
||||
{ |
||||
*ret = _InterlockedExchangeAdd_nf(val, -1) - 1; |
||||
if (*ret == 0) |
||||
__dmb(_ARM_BARRIER_ISH); |
||||
return 1; |
||||
} |
||||
# else |
||||
# if !defined(_WIN32_WCE) |
||||
# pragma intrinsic(_InterlockedExchangeAdd) |
||||
# else |
||||
# if _WIN32_WCE >= 0x600 |
||||
extern long __cdecl _InterlockedExchangeAdd(long volatile*, long); |
||||
# else |
||||
/* under Windows CE we still have old-style Interlocked* functions */ |
||||
extern long __cdecl InterlockedExchangeAdd(long volatile*, long); |
||||
# define _InterlockedExchangeAdd InterlockedExchangeAdd |
||||
# endif |
||||
# endif |
||||
|
||||
static __inline int CRYPTO_UP_REF(volatile int *val, int *ret, void *lock) |
||||
{ |
||||
*ret = _InterlockedExchangeAdd(val, 1) + 1; |
||||
return 1; |
||||
} |
||||
|
||||
static __inline int CRYPTO_DOWN_REF(volatile int *val, int *ret, void *lock) |
||||
{ |
||||
*ret = _InterlockedExchangeAdd(val, -1) - 1; |
||||
return 1; |
||||
} |
||||
# endif |
||||
|
||||
# else |
||||
|
||||
typedef int CRYPTO_REF_COUNT; |
||||
|
||||
# define CRYPTO_UP_REF(val, ret, lock) CRYPTO_atomic_add(val, 1, ret, lock) |
||||
# define CRYPTO_DOWN_REF(val, ret, lock) CRYPTO_atomic_add(val, -1, ret, lock) |
||||
|
||||
# endif |
||||
|
||||
# if !defined(NDEBUG) && !defined(OPENSSL_NO_STDIO) |
||||
# define REF_ASSERT_ISNT(test) \ |
||||
(void)((test) ? (OPENSSL_die("refcount error", __FILE__, __LINE__), 1) : 0) |
||||
# else |
||||
# define REF_ASSERT_ISNT(i) |
||||
# endif |
||||
|
||||
# ifdef REF_PRINT |
||||
# define REF_PRINT_COUNT(a, b) \ |
||||
fprintf(stderr, "%p:%4d:%s\n", b, b->references, a) |
||||
# else |
||||
# define REF_PRINT_COUNT(a, b) |
||||
# endif |
||||
|
||||
#endif |
||||
@ -0,0 +1,157 @@ |
||||
/*
|
||||
* Copyright 1995-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
|
||||
*/ |
||||
|
||||
|
||||
#ifndef OSSL_INTERNAL_SOCKETS_H |
||||
# define OSSL_INTERNAL_SOCKETS_H |
||||
|
||||
# if defined(OPENSSL_SYS_VXWORKS) || defined(OPENSSL_SYS_UEFI) |
||||
# define NO_SYS_PARAM_H |
||||
# endif |
||||
# ifdef WIN32 |
||||
# define NO_SYS_UN_H |
||||
# endif |
||||
# ifdef OPENSSL_SYS_VMS |
||||
# define NO_SYS_PARAM_H |
||||
# define NO_SYS_UN_H |
||||
# endif |
||||
|
||||
# ifdef OPENSSL_NO_SOCK |
||||
|
||||
# elif defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_MSDOS) |
||||
# if defined(__DJGPP__) |
||||
# include <sys/socket.h> |
||||
# include <sys/un.h> |
||||
# include <tcp.h> |
||||
# include <netdb.h> |
||||
# include <arpa/inet.h> |
||||
# include <netinet/tcp.h> |
||||
# elif defined(_WIN32_WCE) && _WIN32_WCE<410 |
||||
# define getservbyname _masked_declaration_getservbyname |
||||
# endif |
||||
# if !defined(IPPROTO_IP) |
||||
/* winsock[2].h was included already? */ |
||||
# include <winsock.h> |
||||
# endif |
||||
# ifdef getservbyname |
||||
/* this is used to be wcecompat/include/winsock_extras.h */ |
||||
# undef getservbyname |
||||
struct servent *PASCAL getservbyname(const char *, const char *); |
||||
# endif |
||||
|
||||
# ifdef _WIN64 |
||||
/*
|
||||
* Even though sizeof(SOCKET) is 8, it's safe to cast it to int, because |
||||
* the value constitutes an index in per-process table of limited size |
||||
* and not a real pointer. And we also depend on fact that all processors |
||||
* Windows run on happen to be two's-complement, which allows to |
||||
* interchange INVALID_SOCKET and -1. |
||||
*/ |
||||
# define socket(d,t,p) ((int)socket(d,t,p)) |
||||
# define accept(s,f,l) ((int)accept(s,f,l)) |
||||
# endif |
||||
|
||||
# else |
||||
|
||||
# ifndef NO_SYS_PARAM_H |
||||
# include <sys/param.h> |
||||
# endif |
||||
# ifdef OPENSSL_SYS_VXWORKS |
||||
# include <time.h> |
||||
# endif |
||||
|
||||
# include <netdb.h> |
||||
# if defined(OPENSSL_SYS_VMS_NODECC) |
||||
# include <socket.h> |
||||
# include <in.h> |
||||
# include <inet.h> |
||||
# else |
||||
# include <sys/socket.h> |
||||
# ifndef NO_SYS_UN_H |
||||
# include <sys/un.h> |
||||
# ifndef UNIX_PATH_MAX |
||||
# define UNIX_PATH_MAX sizeof(((struct sockaddr_un *)NULL)->sun_path) |
||||
# endif |
||||
# endif |
||||
# ifdef FILIO_H |
||||
# include <sys/filio.h> /* FIONBIO in some SVR4, e.g. unixware, solaris */ |
||||
# endif |
||||
# include <netinet/in.h> |
||||
# include <arpa/inet.h> |
||||
# include <netinet/tcp.h> |
||||
# endif |
||||
|
||||
# ifdef OPENSSL_SYS_AIX |
||||
# include <sys/select.h> |
||||
# endif |
||||
|
||||
# ifndef VMS |
||||
# include <sys/ioctl.h> |
||||
# else |
||||
# if !defined(TCPIP_TYPE_SOCKETSHR) && defined(__VMS_VER) && (__VMS_VER > 70000000) |
||||
/* ioctl is only in VMS > 7.0 and when socketshr is not used */ |
||||
# include <sys/ioctl.h> |
||||
# endif |
||||
# include <unixio.h> |
||||
# if defined(TCPIP_TYPE_SOCKETSHR) |
||||
# include <socketshr.h> |
||||
# endif |
||||
# endif |
||||
|
||||
# ifndef INVALID_SOCKET |
||||
# define INVALID_SOCKET (-1) |
||||
# endif |
||||
# endif |
||||
|
||||
/*
|
||||
* Some IPv6 implementations are broken, you can disable them in known |
||||
* bad versions. |
||||
*/ |
||||
# if !defined(OPENSSL_USE_IPV6) |
||||
# if defined(AF_INET6) |
||||
# define OPENSSL_USE_IPV6 1 |
||||
# else |
||||
# define OPENSSL_USE_IPV6 0 |
||||
# endif |
||||
# endif |
||||
|
||||
# define get_last_socket_error() errno |
||||
# define clear_socket_error() errno=0 |
||||
|
||||
# if defined(OPENSSL_SYS_WINDOWS) |
||||
# undef get_last_socket_error |
||||
# undef clear_socket_error |
||||
# define get_last_socket_error() WSAGetLastError() |
||||
# define clear_socket_error() WSASetLastError(0) |
||||
# define readsocket(s,b,n) recv((s),(b),(n),0) |
||||
# define writesocket(s,b,n) send((s),(b),(n),0) |
||||
# elif defined(__DJGPP__) |
||||
# define WATT32 |
||||
# define WATT32_NO_OLDIES |
||||
# define closesocket(s) close_s(s) |
||||
# define readsocket(s,b,n) read_s(s,b,n) |
||||
# define writesocket(s,b,n) send(s,b,n,0) |
||||
# elif defined(OPENSSL_SYS_VMS) |
||||
# define ioctlsocket(a,b,c) ioctl(a,b,c) |
||||
# define closesocket(s) close(s) |
||||
# define readsocket(s,b,n) recv((s),(b),(n),0) |
||||
# define writesocket(s,b,n) send((s),(b),(n),0) |
||||
# elif defined(OPENSSL_SYS_VXWORKS) |
||||
# define ioctlsocket(a,b,c) ioctl((a),(b),(int)(c)) |
||||
# define closesocket(s) close(s) |
||||
# define readsocket(s,b,n) read((s),(b),(n)) |
||||
# define writesocket(s,b,n) write((s),(char *)(b),(n)) |
||||
# else |
||||
# define ioctlsocket(a,b,c) ioctl(a,b,c) |
||||
# define closesocket(s) close(s) |
||||
# define readsocket(s,b,n) read((s),(b),(n)) |
||||
# define writesocket(s,b,n) write((s),(b),(n)) |
||||
# endif |
||||
|
||||
#endif |
||||
@ -0,0 +1,20 @@ |
||||
/*
|
||||
* 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
|
||||
*/ |
||||
|
||||
#ifndef OSSL_INTERNAL_SSLCONF_H |
||||
# define OSSL_INTERNAL_SSLCONF_H |
||||
|
||||
typedef struct ssl_conf_cmd_st SSL_CONF_CMD; |
||||
|
||||
const SSL_CONF_CMD *conf_ssl_get(size_t idx, const char **name, size_t *cnt); |
||||
int conf_ssl_name_find(const char *name, size_t *idx); |
||||
void conf_ssl_get_cmd(const SSL_CONF_CMD *cmd, size_t idx, char **cmdstr, |
||||
char **arg); |
||||
|
||||
#endif |
||||
@ -0,0 +1,137 @@ |
||||
/*
|
||||
* 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
|
||||
*/ |
||||
|
||||
#include <openssl/crypto.h> |
||||
|
||||
/*
|
||||
* DEFINE_RUN_ONCE: Define an initialiser function that should be run exactly |
||||
* once. It takes no arguments and returns and int result (1 for success or |
||||
* 0 for failure). Typical usage might be: |
||||
* |
||||
* DEFINE_RUN_ONCE(myinitfunc) |
||||
* { |
||||
* do_some_initialisation(); |
||||
* if (init_is_successful()) |
||||
* return 1; |
||||
* |
||||
* return 0; |
||||
* } |
||||
*/ |
||||
#define DEFINE_RUN_ONCE(init) \ |
||||
static int init(void); \
|
||||
int init##_ossl_ret_ = 0; \
|
||||
void init##_ossl_(void) \
|
||||
{ \
|
||||
init##_ossl_ret_ = init(); \
|
||||
} \
|
||||
static int init(void) |
||||
|
||||
/*
|
||||
* DECLARE_RUN_ONCE: Declare an initialiser function that should be run exactly |
||||
* once that has been defined in another file via DEFINE_RUN_ONCE(). |
||||
*/ |
||||
#define DECLARE_RUN_ONCE(init) \ |
||||
extern int init##_ossl_ret_; \
|
||||
void init##_ossl_(void); |
||||
|
||||
/*
|
||||
* DEFINE_RUN_ONCE_STATIC: Define an initialiser function that should be run |
||||
* exactly once. This function will be declared as static within the file. It |
||||
* takes no arguments and returns and int result (1 for success or 0 for |
||||
* failure). Typical usage might be: |
||||
* |
||||
* DEFINE_RUN_ONCE_STATIC(myinitfunc) |
||||
* { |
||||
* do_some_initialisation(); |
||||
* if (init_is_successful()) |
||||
* return 1; |
||||
* |
||||
* return 0; |
||||
* } |
||||
*/ |
||||
#define DEFINE_RUN_ONCE_STATIC(init) \ |
||||
static int init(void); \
|
||||
static int init##_ossl_ret_ = 0; \
|
||||
static void init##_ossl_(void) \
|
||||
{ \
|
||||
init##_ossl_ret_ = init(); \
|
||||
} \
|
||||
static int init(void) |
||||
|
||||
/*
|
||||
* DEFINE_RUN_ONCE_STATIC_ALT: Define an alternative initialiser function. This |
||||
* function will be declared as static within the file. It takes no arguments |
||||
* and returns an int result (1 for success or 0 for failure). An alternative |
||||
* initialiser function is expected to be associated with a primary initialiser |
||||
* function defined via DEFINE_ONCE_STATIC where both functions use the same |
||||
* CRYPTO_ONCE object to synchronise. Where an alternative initialiser function |
||||
* is used only one of the primary or the alternative initialiser function will |
||||
* ever be called - and that function will be called exactly once. Definition |
||||
* of an alternative initialiser function MUST occur AFTER the definition of the |
||||
* primary initialiser function. |
||||
* |
||||
* Typical usage might be: |
||||
* |
||||
* DEFINE_RUN_ONCE_STATIC(myinitfunc) |
||||
* { |
||||
* do_some_initialisation(); |
||||
* if (init_is_successful()) |
||||
* return 1; |
||||
* |
||||
* return 0; |
||||
* } |
||||
* |
||||
* DEFINE_RUN_ONCE_STATIC_ALT(myaltinitfunc, myinitfunc) |
||||
* { |
||||
* do_some_alternative_initialisation(); |
||||
* if (init_is_successful()) |
||||
* return 1; |
||||
* |
||||
* return 0; |
||||
* } |
||||
*/ |
||||
#define DEFINE_RUN_ONCE_STATIC_ALT(initalt, init) \ |
||||
static int initalt(void); \
|
||||
static void initalt##_ossl_(void) \
|
||||
{ \
|
||||
init##_ossl_ret_ = initalt(); \
|
||||
} \
|
||||
static int initalt(void) |
||||
|
||||
/*
|
||||
* RUN_ONCE - use CRYPTO_THREAD_run_once, and check if the init succeeded |
||||
* @once: pointer to static object of type CRYPTO_ONCE |
||||
* @init: function name that was previously given to DEFINE_RUN_ONCE, |
||||
* DEFINE_RUN_ONCE_STATIC or DECLARE_RUN_ONCE. This function |
||||
* must return 1 for success or 0 for failure. |
||||
* |
||||
* The return value is 1 on success (*) or 0 in case of error. |
||||
* |
||||
* (*) by convention, since the init function must return 1 on success. |
||||
*/ |
||||
#define RUN_ONCE(once, init) \ |
||||
(CRYPTO_THREAD_run_once(once, init##_ossl_) ? init##_ossl_ret_ : 0) |
||||
|
||||
/*
|
||||
* RUN_ONCE_ALT - use CRYPTO_THREAD_run_once, to run an alternative initialiser |
||||
* function and check if that initialisation succeeded |
||||
* @once: pointer to static object of type CRYPTO_ONCE |
||||
* @initalt: alternative initialiser function name that was previously given to |
||||
* DEFINE_RUN_ONCE_STATIC_ALT. This function must return 1 for |
||||
* success or 0 for failure. |
||||
* @init: primary initialiser function name that was previously given to |
||||
* DEFINE_RUN_ONCE_STATIC. This function must return 1 for success or |
||||
* 0 for failure. |
||||
* |
||||
* The return value is 1 on success (*) or 0 in case of error. |
||||
* |
||||
* (*) by convention, since the init function must return 1 on success. |
||||
*/ |
||||
#define RUN_ONCE_ALT(once, initalt, init) \ |
||||
(CRYPTO_THREAD_run_once(once, initalt##_ossl_) ? init##_ossl_ret_ : 0) |
||||
@ -0,0 +1,144 @@ |
||||
/*
|
||||
* Copyright 2018-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
|
||||
*/ |
||||
|
||||
/*
|
||||
* Contemporary compilers implement lock-free atomic memory access |
||||
* primitives that facilitate writing "thread-opportunistic" or even real |
||||
* multi-threading low-overhead code. "Thread-opportunistic" is when |
||||
* exact result is not required, e.g. some statistics, or execution flow |
||||
* doesn't have to be unambiguous. Simplest example is lazy "constant" |
||||
* initialization when one can synchronize on variable itself, e.g. |
||||
* |
||||
* if (var == NOT_YET_INITIALIZED) |
||||
* var = function_returning_same_value(); |
||||
* |
||||
* This does work provided that loads and stores are single-instruction |
||||
* operations (and integer ones are on *all* supported platforms), but |
||||
* it upsets Thread Sanitizer. Suggested solution is |
||||
* |
||||
* if (tsan_load(&var) == NOT_YET_INITIALIZED) |
||||
* tsan_store(&var, function_returning_same_value()); |
||||
* |
||||
* Production machine code would be the same, so one can wonder why |
||||
* bother. Having Thread Sanitizer accept "thread-opportunistic" code |
||||
* allows to move on trouble-shooting real bugs. |
||||
* |
||||
* Resolving Thread Sanitizer nits was the initial purpose for this module, |
||||
* but it was later extended with more nuanced primitives that are useful |
||||
* even in "non-opportunistic" scenarios. Most notably verifying if a shared |
||||
* structure is fully initialized and bypassing the initialization lock. |
||||
* It's suggested to view macros defined in this module as "annotations" for |
||||
* thread-safe lock-free code, "Thread-Safe ANnotations"... |
||||
* |
||||
* It's assumed that ATOMIC_{LONG|INT}_LOCK_FREE are assigned same value as |
||||
* ATOMIC_POINTER_LOCK_FREE. And check for >= 2 ensures that corresponding |
||||
* code is inlined. It should be noted that statistics counters become |
||||
* accurate in such case. |
||||
* |
||||
* Special note about TSAN_QUALIFIER. It might be undesired to use it in |
||||
* a shared header. Because whether operation on specific variable or member |
||||
* is atomic or not might be irrelevant in other modules. In such case one |
||||
* can use TSAN_QUALIFIER in cast specifically when it has to count. |
||||
*/ |
||||
|
||||
#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L \ |
||||
&& !defined(__STDC_NO_ATOMICS__) |
||||
# include <stdatomic.h> |
||||
|
||||
# if defined(ATOMIC_POINTER_LOCK_FREE) \ |
||||
&& ATOMIC_POINTER_LOCK_FREE >= 2 |
||||
# define TSAN_QUALIFIER _Atomic |
||||
# define tsan_load(ptr) atomic_load_explicit((ptr), memory_order_relaxed) |
||||
# define tsan_store(ptr, val) atomic_store_explicit((ptr), (val), memory_order_relaxed) |
||||
# define tsan_counter(ptr) atomic_fetch_add_explicit((ptr), 1, memory_order_relaxed) |
||||
# define tsan_decr(ptr) atomic_fetch_add_explicit((ptr), -1, memory_order_relaxed) |
||||
# define tsan_ld_acq(ptr) atomic_load_explicit((ptr), memory_order_acquire) |
||||
# define tsan_st_rel(ptr, val) atomic_store_explicit((ptr), (val), memory_order_release) |
||||
# endif |
||||
|
||||
#elif defined(__GNUC__) && defined(__ATOMIC_RELAXED) |
||||
|
||||
# if defined(__GCC_ATOMIC_POINTER_LOCK_FREE) \ |
||||
&& __GCC_ATOMIC_POINTER_LOCK_FREE >= 2 |
||||
# define TSAN_QUALIFIER volatile |
||||
# define tsan_load(ptr) __atomic_load_n((ptr), __ATOMIC_RELAXED) |
||||
# define tsan_store(ptr, val) __atomic_store_n((ptr), (val), __ATOMIC_RELAXED) |
||||
# define tsan_counter(ptr) __atomic_fetch_add((ptr), 1, __ATOMIC_RELAXED) |
||||
# define tsan_decr(ptr) __atomic_fetch_add((ptr), -1, __ATOMIC_RELAXED) |
||||
# define tsan_ld_acq(ptr) __atomic_load_n((ptr), __ATOMIC_ACQUIRE) |
||||
# define tsan_st_rel(ptr, val) __atomic_store_n((ptr), (val), __ATOMIC_RELEASE) |
||||
# endif |
||||
|
||||
#elif defined(_MSC_VER) && _MSC_VER>=1200 \ |
||||
&& (defined(_M_IX86) || defined(_M_AMD64) || defined(_M_X64) || \
|
||||
defined(_M_ARM64) || (defined(_M_ARM) && _M_ARM >= 7 && !defined(_WIN32_WCE))) |
||||
/*
|
||||
* There is subtle dependency on /volatile:<iso|ms> command-line option. |
||||
* "ms" implies same semantic as memory_order_acquire for loads and |
||||
* memory_order_release for stores, while "iso" - memory_order_relaxed for |
||||
* either. Real complication is that defaults are different on x86 and ARM. |
||||
* There is explanation for that, "ms" is backward compatible with earlier |
||||
* compiler versions, while multi-processor ARM can be viewed as brand new |
||||
* platform to MSC and its users, and with non-relaxed semantic taking toll |
||||
* with additional instructions and penalties, it kind of makes sense to |
||||
* default to "iso"... |
||||
*/ |
||||
# define TSAN_QUALIFIER volatile |
||||
# if defined(_M_ARM) || defined(_M_ARM64) |
||||
# define _InterlockedExchangeAdd _InterlockedExchangeAdd_nf |
||||
# pragma intrinsic(_InterlockedExchangeAdd_nf) |
||||
# pragma intrinsic(__iso_volatile_load32, __iso_volatile_store32) |
||||
# ifdef _WIN64 |
||||
# define _InterlockedExchangeAdd64 _InterlockedExchangeAdd64_nf |
||||
# pragma intrinsic(_InterlockedExchangeAdd64_nf) |
||||
# pragma intrinsic(__iso_volatile_load64, __iso_volatile_store64) |
||||
# define tsan_load(ptr) (sizeof(*(ptr)) == 8 ? __iso_volatile_load64(ptr) \ |
||||
: __iso_volatile_load32(ptr)) |
||||
# define tsan_store(ptr, val) (sizeof(*(ptr)) == 8 ? __iso_volatile_store64((ptr), (val)) \ |
||||
: __iso_volatile_store32((ptr), (val))) |
||||
# else |
||||
# define tsan_load(ptr) __iso_volatile_load32(ptr) |
||||
# define tsan_store(ptr, val) __iso_volatile_store32((ptr), (val)) |
||||
# endif |
||||
# else |
||||
# define tsan_load(ptr) (*(ptr)) |
||||
# define tsan_store(ptr, val) (*(ptr) = (val)) |
||||
# endif |
||||
# pragma intrinsic(_InterlockedExchangeAdd) |
||||
# ifdef _WIN64 |
||||
# pragma intrinsic(_InterlockedExchangeAdd64) |
||||
# define tsan_counter(ptr) (sizeof(*(ptr)) == 8 ? _InterlockedExchangeAdd64((ptr), 1) \ |
||||
: _InterlockedExchangeAdd((ptr), 1)) |
||||
# define tsan_decr(ptr) (sizeof(*(ptr)) == 8 ? _InterlockedExchangeAdd64((ptr), -1) \ |
||||
: _InterlockedExchangeAdd((ptr), -1)) |
||||
# else |
||||
# define tsan_counter(ptr) _InterlockedExchangeAdd((ptr), 1) |
||||
# define tsan_decr(ptr) _InterlockedExchangeAdd((ptr), -1) |
||||
# endif |
||||
# if !defined(_ISO_VOLATILE) |
||||
# define tsan_ld_acq(ptr) (*(ptr)) |
||||
# define tsan_st_rel(ptr, val) (*(ptr) = (val)) |
||||
# endif |
||||
|
||||
#endif |
||||
|
||||
#ifndef TSAN_QUALIFIER |
||||
|
||||
# define TSAN_QUALIFIER volatile |
||||
# define tsan_load(ptr) (*(ptr)) |
||||
# define tsan_store(ptr, val) (*(ptr) = (val)) |
||||
# define tsan_counter(ptr) ((*(ptr))++) |
||||
# define tsan_decr(ptr) ((*(ptr))--) |
||||
/*
|
||||
* Lack of tsan_ld_acq and tsan_ld_rel means that compiler support is not |
||||
* sophisticated enough to support them. Code that relies on them should be |
||||
* protected with #ifdef tsan_ld_acq with locked fallback. |
||||
*/ |
||||
|
||||
#endif |
||||
@ -0,0 +1,22 @@ |
||||
/*
|
||||
* Copyright 2016-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
|
||||
*/ |
||||
|
||||
/*
|
||||
* This file is only used by HP C/C++ on VMS, and is included automatically |
||||
* after each header file from this directory |
||||
*/ |
||||
|
||||
/*
|
||||
* The C++ compiler doesn't understand these pragmas, even though it |
||||
* understands the corresponding command line qualifier. |
||||
*/ |
||||
#ifndef __cplusplus |
||||
/* restore state. Must correspond to the save in __decc_include_prologue.h */ |
||||
# pragma names restore |
||||
#endif |
||||
@ -0,0 +1,26 @@ |
||||
/*
|
||||
* Copyright 2016-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
|
||||
*/ |
||||
|
||||
/*
|
||||
* This file is only used by HP C/C++ on VMS, and is included automatically |
||||
* after each header file from this directory |
||||
*/ |
||||
|
||||
/*
|
||||
* The C++ compiler doesn't understand these pragmas, even though it |
||||
* understands the corresponding command line qualifier. |
||||
*/ |
||||
#ifndef __cplusplus |
||||
/* save state */ |
||||
# pragma names save |
||||
/* have the compiler shorten symbols larger than 31 chars to 23 chars
|
||||
* followed by a 8 hex char CRC |
||||
*/ |
||||
# pragma names as_is,shortened |
||||
#endif |
||||
@ -0,0 +1,92 @@ |
||||
/*
|
||||
* 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 HEADER_AES_H |
||||
# define HEADER_AES_H |
||||
|
||||
# include <openssl/opensslconf.h> |
||||
|
||||
# include <stddef.h> |
||||
# ifdef __cplusplus |
||||
extern "C" { |
||||
# endif |
||||
|
||||
# define AES_ENCRYPT 1 |
||||
# define AES_DECRYPT 0 |
||||
|
||||
/*
|
||||
* Because array size can't be a const in C, the following two are macros. |
||||
* Both sizes are in bytes. |
||||
*/ |
||||
# define AES_MAXNR 14 |
||||
# define AES_BLOCK_SIZE 16 |
||||
|
||||
/* This should be a hidden type, but EVP requires that the size be known */ |
||||
struct aes_key_st { |
||||
# ifdef AES_LONG |
||||
unsigned long rd_key[4 * (AES_MAXNR + 1)]; |
||||
# else |
||||
unsigned int rd_key[4 * (AES_MAXNR + 1)]; |
||||
# endif |
||||
int rounds; |
||||
}; |
||||
typedef struct aes_key_st AES_KEY; |
||||
|
||||
const char *AES_options(void); |
||||
|
||||
int AES_set_encrypt_key(const unsigned char *userKey, const int bits, |
||||
AES_KEY *key); |
||||
int AES_set_decrypt_key(const unsigned char *userKey, const int bits, |
||||
AES_KEY *key); |
||||
|
||||
void AES_encrypt(const unsigned char *in, unsigned char *out, |
||||
const AES_KEY *key); |
||||
void AES_decrypt(const unsigned char *in, unsigned char *out, |
||||
const AES_KEY *key); |
||||
|
||||
void AES_ecb_encrypt(const unsigned char *in, unsigned char *out, |
||||
const AES_KEY *key, const int enc); |
||||
void AES_cbc_encrypt(const unsigned char *in, unsigned char *out, |
||||
size_t length, const AES_KEY *key, |
||||
unsigned char *ivec, const int enc); |
||||
void AES_cfb128_encrypt(const unsigned char *in, unsigned char *out, |
||||
size_t length, const AES_KEY *key, |
||||
unsigned char *ivec, int *num, const int enc); |
||||
void AES_cfb1_encrypt(const unsigned char *in, unsigned char *out, |
||||
size_t length, const AES_KEY *key, |
||||
unsigned char *ivec, int *num, const int enc); |
||||
void AES_cfb8_encrypt(const unsigned char *in, unsigned char *out, |
||||
size_t length, const AES_KEY *key, |
||||
unsigned char *ivec, int *num, const int enc); |
||||
void AES_ofb128_encrypt(const unsigned char *in, unsigned char *out, |
||||
size_t length, const AES_KEY *key, |
||||
unsigned char *ivec, int *num); |
||||
/* NB: the IV is _two_ blocks long */ |
||||
void AES_ige_encrypt(const unsigned char *in, unsigned char *out, |
||||
size_t length, const AES_KEY *key, |
||||
unsigned char *ivec, const int enc); |
||||
/* NB: the IV is _four_ blocks long */ |
||||
void AES_bi_ige_encrypt(const unsigned char *in, unsigned char *out, |
||||
size_t length, const AES_KEY *key, |
||||
const AES_KEY *key2, const unsigned char *ivec, |
||||
const int enc); |
||||
|
||||
int AES_wrap_key(AES_KEY *key, const unsigned char *iv, |
||||
unsigned char *out, |
||||
const unsigned char *in, unsigned int inlen); |
||||
int AES_unwrap_key(AES_KEY *key, const unsigned char *iv, |
||||
unsigned char *out, |
||||
const unsigned char *in, unsigned int inlen); |
||||
|
||||
|
||||
# ifdef __cplusplus |
||||
} |
||||
# endif |
||||
|
||||
#endif |
||||
@ -0,0 +1,886 @@ |
||||
/*
|
||||
* 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 <time.h> |
||||
# include <openssl/e_os2.h> |
||||
# include <openssl/opensslconf.h> |
||||
# include <openssl/bio.h> |
||||
# include <openssl/safestack.h> |
||||
# include <openssl/asn1err.h> |
||||
# include <openssl/symhacks.h> |
||||
|
||||
# include <openssl/ossl_typ.h> |
||||
# if OPENSSL_API_COMPAT < 0x10100000L |
||||
# include <openssl/bn.h> |
||||
# 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_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 |
||||
@ -0,0 +1,10 @@ |
||||
/*
|
||||
* Copyright 2015-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
|
||||
*/ |
||||
|
||||
#error "This file is obsolete; please update your software." |
||||
@ -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 <openssl/symhacks.h> |
||||
|
||||
# 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 |
||||
@ -0,0 +1,945 @@ |
||||
/*
|
||||
* 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 <stddef.h> |
||||
# include <openssl/e_os2.h> |
||||
# include <openssl/asn1.h> |
||||
|
||||
# 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)); \
|
||||
} |
||||
|
||||
/*
|
||||
* 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 |
||||
@ -0,0 +1,76 @@ |
||||
/*
|
||||
* 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
|
||||
*/ |
||||
|
||||
#include <stdlib.h> |
||||
|
||||
#ifndef HEADER_ASYNC_H |
||||
# define HEADER_ASYNC_H |
||||
|
||||
#if defined(_WIN32) |
||||
# if defined(BASETYPES) || defined(_WINDEF_H) |
||||
/* application has to include <windows.h> to use this */ |
||||
#define OSSL_ASYNC_FD HANDLE |
||||
#define OSSL_BAD_ASYNC_FD INVALID_HANDLE_VALUE |
||||
# endif |
||||
#else |
||||
#define OSSL_ASYNC_FD int |
||||
#define OSSL_BAD_ASYNC_FD -1 |
||||
#endif |
||||
# include <openssl/asyncerr.h> |
||||
|
||||
|
||||
# ifdef __cplusplus |
||||
extern "C" { |
||||
# endif |
||||
|
||||
typedef struct async_job_st ASYNC_JOB; |
||||
typedef struct async_wait_ctx_st ASYNC_WAIT_CTX; |
||||
|
||||
#define ASYNC_ERR 0 |
||||
#define ASYNC_NO_JOBS 1 |
||||
#define ASYNC_PAUSE 2 |
||||
#define ASYNC_FINISH 3 |
||||
|
||||
int ASYNC_init_thread(size_t max_size, size_t init_size); |
||||
void ASYNC_cleanup_thread(void); |
||||
|
||||
#ifdef OSSL_ASYNC_FD |
||||
ASYNC_WAIT_CTX *ASYNC_WAIT_CTX_new(void); |
||||
void ASYNC_WAIT_CTX_free(ASYNC_WAIT_CTX *ctx); |
||||
int ASYNC_WAIT_CTX_set_wait_fd(ASYNC_WAIT_CTX *ctx, const void *key, |
||||
OSSL_ASYNC_FD fd, |
||||
void *custom_data, |
||||
void (*cleanup)(ASYNC_WAIT_CTX *, const void *, |
||||
OSSL_ASYNC_FD, void *)); |
||||
int ASYNC_WAIT_CTX_get_fd(ASYNC_WAIT_CTX *ctx, const void *key, |
||||
OSSL_ASYNC_FD *fd, void **custom_data); |
||||
int ASYNC_WAIT_CTX_get_all_fds(ASYNC_WAIT_CTX *ctx, OSSL_ASYNC_FD *fd, |
||||
size_t *numfds); |
||||
int ASYNC_WAIT_CTX_get_changed_fds(ASYNC_WAIT_CTX *ctx, OSSL_ASYNC_FD *addfd, |
||||
size_t *numaddfds, OSSL_ASYNC_FD *delfd, |
||||
size_t *numdelfds); |
||||
int ASYNC_WAIT_CTX_clear_fd(ASYNC_WAIT_CTX *ctx, const void *key); |
||||
#endif |
||||
|
||||
int ASYNC_is_capable(void); |
||||
|
||||
int ASYNC_start_job(ASYNC_JOB **job, ASYNC_WAIT_CTX *ctx, int *ret, |
||||
int (*func)(void *), void *args, size_t size); |
||||
int ASYNC_pause_job(void); |
||||
|
||||
ASYNC_JOB *ASYNC_get_current_job(void); |
||||
ASYNC_WAIT_CTX *ASYNC_get_wait_ctx(ASYNC_JOB *job); |
||||
void ASYNC_block_pause(void); |
||||
void ASYNC_unblock_pause(void); |
||||
|
||||
|
||||
# ifdef __cplusplus |
||||
} |
||||
# endif |
||||
#endif |
||||
@ -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_ASYNCERR_H |
||||
# define HEADER_ASYNCERR_H |
||||
|
||||
# ifndef HEADER_SYMHACKS_H |
||||
# include <openssl/symhacks.h> |
||||
# endif |
||||
|
||||
# ifdef __cplusplus |
||||
extern "C" |
||||
# endif |
||||
int ERR_load_ASYNC_strings(void); |
||||
|
||||
/*
|
||||
* ASYNC function codes. |
||||
*/ |
||||
# define ASYNC_F_ASYNC_CTX_NEW 100 |
||||
# define ASYNC_F_ASYNC_INIT_THREAD 101 |
||||
# define ASYNC_F_ASYNC_JOB_NEW 102 |
||||
# define ASYNC_F_ASYNC_PAUSE_JOB 103 |
||||
# define ASYNC_F_ASYNC_START_FUNC 104 |
||||
# define ASYNC_F_ASYNC_START_JOB 105 |
||||
# define ASYNC_F_ASYNC_WAIT_CTX_SET_WAIT_FD 106 |
||||
|
||||
/*
|
||||
* ASYNC reason codes. |
||||
*/ |
||||
# define ASYNC_R_FAILED_TO_SET_POOL 101 |
||||
# define ASYNC_R_FAILED_TO_SWAP_CONTEXT 102 |
||||
# define ASYNC_R_INIT_FAILED 105 |
||||
# define ASYNC_R_INVALID_POOL_SIZE 103 |
||||
|
||||
#endif |
||||
@ -0,0 +1,801 @@ |
||||
/*
|
||||
* 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 <openssl/e_os2.h> |
||||
|
||||
# ifndef OPENSSL_NO_STDIO |
||||
# include <stdio.h> |
||||
# endif |
||||
# include <stdarg.h> |
||||
|
||||
# include <openssl/crypto.h> |
||||
# include <openssl/bioerr.h> |
||||
|
||||
#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 |
||||
|
||||
/* 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_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 |
||||
@ -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 <openssl/symhacks.h> |
||||
# 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 |
||||
@ -0,0 +1,61 @@ |
||||
/*
|
||||
* 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_BLOWFISH_H |
||||
# define HEADER_BLOWFISH_H |
||||
|
||||
# include <openssl/opensslconf.h> |
||||
|
||||
# ifndef OPENSSL_NO_BF |
||||
# include <openssl/e_os2.h> |
||||
# ifdef __cplusplus |
||||
extern "C" { |
||||
# endif |
||||
|
||||
# define BF_ENCRYPT 1 |
||||
# define BF_DECRYPT 0 |
||||
|
||||
/*-
|
||||
* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! |
||||
* ! BF_LONG has to be at least 32 bits wide. ! |
||||
* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! |
||||
*/ |
||||
# define BF_LONG unsigned int |
||||
|
||||
# define BF_ROUNDS 16 |
||||
# define BF_BLOCK 8 |
||||
|
||||
typedef struct bf_key_st { |
||||
BF_LONG P[BF_ROUNDS + 2]; |
||||
BF_LONG S[4 * 256]; |
||||
} BF_KEY; |
||||
|
||||
void BF_set_key(BF_KEY *key, int len, const unsigned char *data); |
||||
|
||||
void BF_encrypt(BF_LONG *data, const BF_KEY *key); |
||||
void BF_decrypt(BF_LONG *data, const BF_KEY *key); |
||||
|
||||
void BF_ecb_encrypt(const unsigned char *in, unsigned char *out, |
||||
const BF_KEY *key, int enc); |
||||
void BF_cbc_encrypt(const unsigned char *in, unsigned char *out, long length, |
||||
const BF_KEY *schedule, unsigned char *ivec, int enc); |
||||
void BF_cfb64_encrypt(const unsigned char *in, unsigned char *out, |
||||
long length, const BF_KEY *schedule, |
||||
unsigned char *ivec, int *num, int enc); |
||||
void BF_ofb64_encrypt(const unsigned char *in, unsigned char *out, |
||||
long length, const BF_KEY *schedule, |
||||
unsigned char *ivec, int *num); |
||||
const char *BF_options(void); |
||||
|
||||
# ifdef __cplusplus |
||||
} |
||||
# endif |
||||
# endif |
||||
|
||||
#endif |
||||
@ -0,0 +1,539 @@ |
||||
/*
|
||||
* 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 |
||||
|
||||
# include <openssl/e_os2.h> |
||||
# ifndef OPENSSL_NO_STDIO |
||||
# include <stdio.h> |
||||
# endif |
||||
# include <openssl/opensslconf.h> |
||||
# include <openssl/ossl_typ.h> |
||||
# include <openssl/crypto.h> |
||||
# include <openssl/bnerr.h> |
||||
|
||||
#ifdef __cplusplus |
||||
extern "C" { |
||||
#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 OPENSSL_NO_STDIO |
||||
int BN_print_fp(FILE *fp, const BIGNUM *a); |
||||
# endif |
||||
int BN_print(BIO *bio, const BIGNUM *a); |
||||
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); |
||||
|
||||
/* 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)) |
||||
|
||||
/* 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); |
||||
BN_MONT_CTX *BN_MONT_CTX_set_locked(BN_MONT_CTX **pmont, CRYPTO_RWLOCK *lock, |
||||
const BIGNUM *mod, BN_CTX *ctx); |
||||
|
||||
/* 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); |
||||
|
||||
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 */ |
||||
|
||||
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 __cplusplus |
||||
} |
||||
# endif |
||||
#endif |
||||
@ -0,0 +1,101 @@ |
||||
/*
|
||||
* Generated by util/mkerr.pl DO NOT EDIT |
||||
* Copyright 1995-2023 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 <openssl/symhacks.h> |
||||
# 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 |
||||
@ -0,0 +1,58 @@ |
||||
/*
|
||||
* 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 <openssl/ossl_typ.h> |
||||
# ifndef HEADER_CRYPTO_H |
||||
# include <openssl/crypto.h> |
||||
# endif |
||||
# include <openssl/buffererr.h> |
||||
|
||||
|
||||
#ifdef __cplusplus |
||||
extern "C" { |
||||
#endif |
||||
|
||||
# include <stddef.h> |
||||
# include <sys/types.h> |
||||
|
||||
/*
|
||||
* 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 |
||||
@ -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 <openssl/symhacks.h> |
||||
# 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 |
||||
@ -0,0 +1,83 @@ |
||||
/*
|
||||
* Copyright 2006-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_CAMELLIA_H |
||||
# define HEADER_CAMELLIA_H |
||||
|
||||
# include <openssl/opensslconf.h> |
||||
|
||||
# ifndef OPENSSL_NO_CAMELLIA |
||||
# include <stddef.h> |
||||
#ifdef __cplusplus |
||||
extern "C" { |
||||
#endif |
||||
|
||||
# define CAMELLIA_ENCRYPT 1 |
||||
# define CAMELLIA_DECRYPT 0 |
||||
|
||||
/*
|
||||
* Because array size can't be a const in C, the following two are macros. |
||||
* Both sizes are in bytes. |
||||
*/ |
||||
|
||||
/* This should be a hidden type, but EVP requires that the size be known */ |
||||
|
||||
# define CAMELLIA_BLOCK_SIZE 16 |
||||
# define CAMELLIA_TABLE_BYTE_LEN 272 |
||||
# define CAMELLIA_TABLE_WORD_LEN (CAMELLIA_TABLE_BYTE_LEN / 4) |
||||
|
||||
typedef unsigned int KEY_TABLE_TYPE[CAMELLIA_TABLE_WORD_LEN]; /* to match
|
||||
* with WORD */ |
||||
|
||||
struct camellia_key_st { |
||||
union { |
||||
double d; /* ensures 64-bit align */ |
||||
KEY_TABLE_TYPE rd_key; |
||||
} u; |
||||
int grand_rounds; |
||||
}; |
||||
typedef struct camellia_key_st CAMELLIA_KEY; |
||||
|
||||
int Camellia_set_key(const unsigned char *userKey, const int bits, |
||||
CAMELLIA_KEY *key); |
||||
|
||||
void Camellia_encrypt(const unsigned char *in, unsigned char *out, |
||||
const CAMELLIA_KEY *key); |
||||
void Camellia_decrypt(const unsigned char *in, unsigned char *out, |
||||
const CAMELLIA_KEY *key); |
||||
|
||||
void Camellia_ecb_encrypt(const unsigned char *in, unsigned char *out, |
||||
const CAMELLIA_KEY *key, const int enc); |
||||
void Camellia_cbc_encrypt(const unsigned char *in, unsigned char *out, |
||||
size_t length, const CAMELLIA_KEY *key, |
||||
unsigned char *ivec, const int enc); |
||||
void Camellia_cfb128_encrypt(const unsigned char *in, unsigned char *out, |
||||
size_t length, const CAMELLIA_KEY *key, |
||||
unsigned char *ivec, int *num, const int enc); |
||||
void Camellia_cfb1_encrypt(const unsigned char *in, unsigned char *out, |
||||
size_t length, const CAMELLIA_KEY *key, |
||||
unsigned char *ivec, int *num, const int enc); |
||||
void Camellia_cfb8_encrypt(const unsigned char *in, unsigned char *out, |
||||
size_t length, const CAMELLIA_KEY *key, |
||||
unsigned char *ivec, int *num, const int enc); |
||||
void Camellia_ofb128_encrypt(const unsigned char *in, unsigned char *out, |
||||
size_t length, const CAMELLIA_KEY *key, |
||||
unsigned char *ivec, int *num); |
||||
void Camellia_ctr128_encrypt(const unsigned char *in, unsigned char *out, |
||||
size_t length, const CAMELLIA_KEY *key, |
||||
unsigned char ivec[CAMELLIA_BLOCK_SIZE], |
||||
unsigned char ecount_buf[CAMELLIA_BLOCK_SIZE], |
||||
unsigned int *num); |
||||
|
||||
# ifdef __cplusplus |
||||
} |
||||
# endif |
||||
# endif |
||||
|
||||
#endif |
||||
@ -0,0 +1,53 @@ |
||||
/*
|
||||
* 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_CAST_H |
||||
# define HEADER_CAST_H |
||||
|
||||
# include <openssl/opensslconf.h> |
||||
|
||||
# ifndef OPENSSL_NO_CAST |
||||
# ifdef __cplusplus |
||||
extern "C" { |
||||
# endif |
||||
|
||||
# define CAST_ENCRYPT 1 |
||||
# define CAST_DECRYPT 0 |
||||
|
||||
# define CAST_LONG unsigned int |
||||
|
||||
# define CAST_BLOCK 8 |
||||
# define CAST_KEY_LENGTH 16 |
||||
|
||||
typedef struct cast_key_st { |
||||
CAST_LONG data[32]; |
||||
int short_key; /* Use reduced rounds for short key */ |
||||
} CAST_KEY; |
||||
|
||||
void CAST_set_key(CAST_KEY *key, int len, const unsigned char *data); |
||||
void CAST_ecb_encrypt(const unsigned char *in, unsigned char *out, |
||||
const CAST_KEY *key, int enc); |
||||
void CAST_encrypt(CAST_LONG *data, const CAST_KEY *key); |
||||
void CAST_decrypt(CAST_LONG *data, const CAST_KEY *key); |
||||
void CAST_cbc_encrypt(const unsigned char *in, unsigned char *out, |
||||
long length, const CAST_KEY *ks, unsigned char *iv, |
||||
int enc); |
||||
void CAST_cfb64_encrypt(const unsigned char *in, unsigned char *out, |
||||
long length, const CAST_KEY *schedule, |
||||
unsigned char *ivec, int *num, int enc); |
||||
void CAST_ofb64_encrypt(const unsigned char *in, unsigned char *out, |
||||
long length, const CAST_KEY *schedule, |
||||
unsigned char *ivec, int *num); |
||||
|
||||
# ifdef __cplusplus |
||||
} |
||||
# endif |
||||
# endif |
||||
|
||||
#endif |
||||
@ -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 <openssl/evp.h> |
||||
|
||||
/* 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 |
||||
@ -0,0 +1,339 @@ |
||||
/*
|
||||
* Copyright 2008-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_CMS_H |
||||
# define HEADER_CMS_H |
||||
|
||||
# include <openssl/opensslconf.h> |
||||
|
||||
# ifndef OPENSSL_NO_CMS |
||||
# include <openssl/x509.h> |
||||
# include <openssl/x509v3.h> |
||||
# include <openssl/cmserr.h> |
||||
# ifdef __cplusplus |
||||
extern "C" { |
||||
# endif |
||||
|
||||
typedef struct CMS_ContentInfo_st CMS_ContentInfo; |
||||
typedef struct CMS_SignerInfo_st CMS_SignerInfo; |
||||
typedef struct CMS_CertificateChoices CMS_CertificateChoices; |
||||
typedef struct CMS_RevocationInfoChoice_st CMS_RevocationInfoChoice; |
||||
typedef struct CMS_RecipientInfo_st CMS_RecipientInfo; |
||||
typedef struct CMS_ReceiptRequest_st CMS_ReceiptRequest; |
||||
typedef struct CMS_Receipt_st CMS_Receipt; |
||||
typedef struct CMS_RecipientEncryptedKey_st CMS_RecipientEncryptedKey; |
||||
typedef struct CMS_OtherKeyAttribute_st CMS_OtherKeyAttribute; |
||||
|
||||
DEFINE_STACK_OF(CMS_SignerInfo) |
||||
DEFINE_STACK_OF(CMS_RecipientEncryptedKey) |
||||
DEFINE_STACK_OF(CMS_RecipientInfo) |
||||
DEFINE_STACK_OF(CMS_RevocationInfoChoice) |
||||
DECLARE_ASN1_FUNCTIONS(CMS_ContentInfo) |
||||
DECLARE_ASN1_FUNCTIONS(CMS_ReceiptRequest) |
||||
DECLARE_ASN1_PRINT_FUNCTION(CMS_ContentInfo) |
||||
|
||||
# define CMS_SIGNERINFO_ISSUER_SERIAL 0 |
||||
# define CMS_SIGNERINFO_KEYIDENTIFIER 1 |
||||
|
||||
# define CMS_RECIPINFO_NONE -1 |
||||
# define CMS_RECIPINFO_TRANS 0 |
||||
# define CMS_RECIPINFO_AGREE 1 |
||||
# define CMS_RECIPINFO_KEK 2 |
||||
# define CMS_RECIPINFO_PASS 3 |
||||
# define CMS_RECIPINFO_OTHER 4 |
||||
|
||||
/* S/MIME related flags */ |
||||
|
||||
# define CMS_TEXT 0x1 |
||||
# define CMS_NOCERTS 0x2 |
||||
# define CMS_NO_CONTENT_VERIFY 0x4 |
||||
# define CMS_NO_ATTR_VERIFY 0x8 |
||||
# define CMS_NOSIGS \ |
||||
(CMS_NO_CONTENT_VERIFY|CMS_NO_ATTR_VERIFY) |
||||
# define CMS_NOINTERN 0x10 |
||||
# define CMS_NO_SIGNER_CERT_VERIFY 0x20 |
||||
# define CMS_NOVERIFY 0x20 |
||||
# define CMS_DETACHED 0x40 |
||||
# define CMS_BINARY 0x80 |
||||
# define CMS_NOATTR 0x100 |
||||
# define CMS_NOSMIMECAP 0x200 |
||||
# define CMS_NOOLDMIMETYPE 0x400 |
||||
# define CMS_CRLFEOL 0x800 |
||||
# define CMS_STREAM 0x1000 |
||||
# define CMS_NOCRL 0x2000 |
||||
# define CMS_PARTIAL 0x4000 |
||||
# define CMS_REUSE_DIGEST 0x8000 |
||||
# define CMS_USE_KEYID 0x10000 |
||||
# define CMS_DEBUG_DECRYPT 0x20000 |
||||
# define CMS_KEY_PARAM 0x40000 |
||||
# define CMS_ASCIICRLF 0x80000 |
||||
|
||||
const ASN1_OBJECT *CMS_get0_type(const CMS_ContentInfo *cms); |
||||
|
||||
BIO *CMS_dataInit(CMS_ContentInfo *cms, BIO *icont); |
||||
int CMS_dataFinal(CMS_ContentInfo *cms, BIO *bio); |
||||
|
||||
ASN1_OCTET_STRING **CMS_get0_content(CMS_ContentInfo *cms); |
||||
int CMS_is_detached(CMS_ContentInfo *cms); |
||||
int CMS_set_detached(CMS_ContentInfo *cms, int detached); |
||||
|
||||
# ifdef HEADER_PEM_H |
||||
DECLARE_PEM_rw_const(CMS, CMS_ContentInfo) |
||||
# endif |
||||
int CMS_stream(unsigned char ***boundary, CMS_ContentInfo *cms); |
||||
CMS_ContentInfo *d2i_CMS_bio(BIO *bp, CMS_ContentInfo **cms); |
||||
int i2d_CMS_bio(BIO *bp, CMS_ContentInfo *cms); |
||||
|
||||
BIO *BIO_new_CMS(BIO *out, CMS_ContentInfo *cms); |
||||
int i2d_CMS_bio_stream(BIO *out, CMS_ContentInfo *cms, BIO *in, int flags); |
||||
int PEM_write_bio_CMS_stream(BIO *out, CMS_ContentInfo *cms, BIO *in, |
||||
int flags); |
||||
CMS_ContentInfo *SMIME_read_CMS(BIO *bio, BIO **bcont); |
||||
int SMIME_write_CMS(BIO *bio, CMS_ContentInfo *cms, BIO *data, int flags); |
||||
|
||||
int CMS_final(CMS_ContentInfo *cms, BIO *data, BIO *dcont, |
||||
unsigned int flags); |
||||
|
||||
CMS_ContentInfo *CMS_sign(X509 *signcert, EVP_PKEY *pkey, |
||||
STACK_OF(X509) *certs, BIO *data, |
||||
unsigned int flags); |
||||
|
||||
CMS_ContentInfo *CMS_sign_receipt(CMS_SignerInfo *si, |
||||
X509 *signcert, EVP_PKEY *pkey, |
||||
STACK_OF(X509) *certs, unsigned int flags); |
||||
|
||||
int CMS_data(CMS_ContentInfo *cms, BIO *out, unsigned int flags); |
||||
CMS_ContentInfo *CMS_data_create(BIO *in, unsigned int flags); |
||||
|
||||
int CMS_digest_verify(CMS_ContentInfo *cms, BIO *dcont, BIO *out, |
||||
unsigned int flags); |
||||
CMS_ContentInfo *CMS_digest_create(BIO *in, const EVP_MD *md, |
||||
unsigned int flags); |
||||
|
||||
int CMS_EncryptedData_decrypt(CMS_ContentInfo *cms, |
||||
const unsigned char *key, size_t keylen, |
||||
BIO *dcont, BIO *out, unsigned int flags); |
||||
|
||||
CMS_ContentInfo *CMS_EncryptedData_encrypt(BIO *in, const EVP_CIPHER *cipher, |
||||
const unsigned char *key, |
||||
size_t keylen, unsigned int flags); |
||||
|
||||
int CMS_EncryptedData_set1_key(CMS_ContentInfo *cms, const EVP_CIPHER *ciph, |
||||
const unsigned char *key, size_t keylen); |
||||
|
||||
int CMS_verify(CMS_ContentInfo *cms, STACK_OF(X509) *certs, |
||||
X509_STORE *store, BIO *dcont, BIO *out, unsigned int flags); |
||||
|
||||
int CMS_verify_receipt(CMS_ContentInfo *rcms, CMS_ContentInfo *ocms, |
||||
STACK_OF(X509) *certs, |
||||
X509_STORE *store, unsigned int flags); |
||||
|
||||
STACK_OF(X509) *CMS_get0_signers(CMS_ContentInfo *cms); |
||||
|
||||
CMS_ContentInfo *CMS_encrypt(STACK_OF(X509) *certs, BIO *in, |
||||
const EVP_CIPHER *cipher, unsigned int flags); |
||||
|
||||
int CMS_decrypt(CMS_ContentInfo *cms, EVP_PKEY *pkey, X509 *cert, |
||||
BIO *dcont, BIO *out, unsigned int flags); |
||||
|
||||
int CMS_decrypt_set1_pkey(CMS_ContentInfo *cms, EVP_PKEY *pk, X509 *cert); |
||||
int CMS_decrypt_set1_key(CMS_ContentInfo *cms, |
||||
unsigned char *key, size_t keylen, |
||||
const unsigned char *id, size_t idlen); |
||||
int CMS_decrypt_set1_password(CMS_ContentInfo *cms, |
||||
unsigned char *pass, ossl_ssize_t passlen); |
||||
|
||||
STACK_OF(CMS_RecipientInfo) *CMS_get0_RecipientInfos(CMS_ContentInfo *cms); |
||||
int CMS_RecipientInfo_type(CMS_RecipientInfo *ri); |
||||
EVP_PKEY_CTX *CMS_RecipientInfo_get0_pkey_ctx(CMS_RecipientInfo *ri); |
||||
CMS_ContentInfo *CMS_EnvelopedData_create(const EVP_CIPHER *cipher); |
||||
CMS_RecipientInfo *CMS_add1_recipient_cert(CMS_ContentInfo *cms, |
||||
X509 *recip, unsigned int flags); |
||||
int CMS_RecipientInfo_set0_pkey(CMS_RecipientInfo *ri, EVP_PKEY *pkey); |
||||
int CMS_RecipientInfo_ktri_cert_cmp(CMS_RecipientInfo *ri, X509 *cert); |
||||
int CMS_RecipientInfo_ktri_get0_algs(CMS_RecipientInfo *ri, |
||||
EVP_PKEY **pk, X509 **recip, |
||||
X509_ALGOR **palg); |
||||
int CMS_RecipientInfo_ktri_get0_signer_id(CMS_RecipientInfo *ri, |
||||
ASN1_OCTET_STRING **keyid, |
||||
X509_NAME **issuer, |
||||
ASN1_INTEGER **sno); |
||||
|
||||
CMS_RecipientInfo *CMS_add0_recipient_key(CMS_ContentInfo *cms, int nid, |
||||
unsigned char *key, size_t keylen, |
||||
unsigned char *id, size_t idlen, |
||||
ASN1_GENERALIZEDTIME *date, |
||||
ASN1_OBJECT *otherTypeId, |
||||
ASN1_TYPE *otherType); |
||||
|
||||
int CMS_RecipientInfo_kekri_get0_id(CMS_RecipientInfo *ri, |
||||
X509_ALGOR **palg, |
||||
ASN1_OCTET_STRING **pid, |
||||
ASN1_GENERALIZEDTIME **pdate, |
||||
ASN1_OBJECT **potherid, |
||||
ASN1_TYPE **pothertype); |
||||
|
||||
int CMS_RecipientInfo_set0_key(CMS_RecipientInfo *ri, |
||||
unsigned char *key, size_t keylen); |
||||
|
||||
int CMS_RecipientInfo_kekri_id_cmp(CMS_RecipientInfo *ri, |
||||
const unsigned char *id, size_t idlen); |
||||
|
||||
int CMS_RecipientInfo_set0_password(CMS_RecipientInfo *ri, |
||||
unsigned char *pass, |
||||
ossl_ssize_t passlen); |
||||
|
||||
CMS_RecipientInfo *CMS_add0_recipient_password(CMS_ContentInfo *cms, |
||||
int iter, int wrap_nid, |
||||
int pbe_nid, |
||||
unsigned char *pass, |
||||
ossl_ssize_t passlen, |
||||
const EVP_CIPHER *kekciph); |
||||
|
||||
int CMS_RecipientInfo_decrypt(CMS_ContentInfo *cms, CMS_RecipientInfo *ri); |
||||
int CMS_RecipientInfo_encrypt(CMS_ContentInfo *cms, CMS_RecipientInfo *ri); |
||||
|
||||
int CMS_uncompress(CMS_ContentInfo *cms, BIO *dcont, BIO *out, |
||||
unsigned int flags); |
||||
CMS_ContentInfo *CMS_compress(BIO *in, int comp_nid, unsigned int flags); |
||||
|
||||
int CMS_set1_eContentType(CMS_ContentInfo *cms, const ASN1_OBJECT *oid); |
||||
const ASN1_OBJECT *CMS_get0_eContentType(CMS_ContentInfo *cms); |
||||
|
||||
CMS_CertificateChoices *CMS_add0_CertificateChoices(CMS_ContentInfo *cms); |
||||
int CMS_add0_cert(CMS_ContentInfo *cms, X509 *cert); |
||||
int CMS_add1_cert(CMS_ContentInfo *cms, X509 *cert); |
||||
STACK_OF(X509) *CMS_get1_certs(CMS_ContentInfo *cms); |
||||
|
||||
CMS_RevocationInfoChoice *CMS_add0_RevocationInfoChoice(CMS_ContentInfo *cms); |
||||
int CMS_add0_crl(CMS_ContentInfo *cms, X509_CRL *crl); |
||||
int CMS_add1_crl(CMS_ContentInfo *cms, X509_CRL *crl); |
||||
STACK_OF(X509_CRL) *CMS_get1_crls(CMS_ContentInfo *cms); |
||||
|
||||
int CMS_SignedData_init(CMS_ContentInfo *cms); |
||||
CMS_SignerInfo *CMS_add1_signer(CMS_ContentInfo *cms, |
||||
X509 *signer, EVP_PKEY *pk, const EVP_MD *md, |
||||
unsigned int flags); |
||||
EVP_PKEY_CTX *CMS_SignerInfo_get0_pkey_ctx(CMS_SignerInfo *si); |
||||
EVP_MD_CTX *CMS_SignerInfo_get0_md_ctx(CMS_SignerInfo *si); |
||||
STACK_OF(CMS_SignerInfo) *CMS_get0_SignerInfos(CMS_ContentInfo *cms); |
||||
|
||||
void CMS_SignerInfo_set1_signer_cert(CMS_SignerInfo *si, X509 *signer); |
||||
int CMS_SignerInfo_get0_signer_id(CMS_SignerInfo *si, |
||||
ASN1_OCTET_STRING **keyid, |
||||
X509_NAME **issuer, ASN1_INTEGER **sno); |
||||
int CMS_SignerInfo_cert_cmp(CMS_SignerInfo *si, X509 *cert); |
||||
int CMS_set1_signers_certs(CMS_ContentInfo *cms, STACK_OF(X509) *certs, |
||||
unsigned int flags); |
||||
void CMS_SignerInfo_get0_algs(CMS_SignerInfo *si, EVP_PKEY **pk, |
||||
X509 **signer, X509_ALGOR **pdig, |
||||
X509_ALGOR **psig); |
||||
ASN1_OCTET_STRING *CMS_SignerInfo_get0_signature(CMS_SignerInfo *si); |
||||
int CMS_SignerInfo_sign(CMS_SignerInfo *si); |
||||
int CMS_SignerInfo_verify(CMS_SignerInfo *si); |
||||
int CMS_SignerInfo_verify_content(CMS_SignerInfo *si, BIO *chain); |
||||
|
||||
int CMS_add_smimecap(CMS_SignerInfo *si, STACK_OF(X509_ALGOR) *algs); |
||||
int CMS_add_simple_smimecap(STACK_OF(X509_ALGOR) **algs, |
||||
int algnid, int keysize); |
||||
int CMS_add_standard_smimecap(STACK_OF(X509_ALGOR) **smcap); |
||||
|
||||
int CMS_signed_get_attr_count(const CMS_SignerInfo *si); |
||||
int CMS_signed_get_attr_by_NID(const CMS_SignerInfo *si, int nid, |
||||
int lastpos); |
||||
int CMS_signed_get_attr_by_OBJ(const CMS_SignerInfo *si, const ASN1_OBJECT *obj, |
||||
int lastpos); |
||||
X509_ATTRIBUTE *CMS_signed_get_attr(const CMS_SignerInfo *si, int loc); |
||||
X509_ATTRIBUTE *CMS_signed_delete_attr(CMS_SignerInfo *si, int loc); |
||||
int CMS_signed_add1_attr(CMS_SignerInfo *si, X509_ATTRIBUTE *attr); |
||||
int CMS_signed_add1_attr_by_OBJ(CMS_SignerInfo *si, |
||||
const ASN1_OBJECT *obj, int type, |
||||
const void *bytes, int len); |
||||
int CMS_signed_add1_attr_by_NID(CMS_SignerInfo *si, |
||||
int nid, int type, |
||||
const void *bytes, int len); |
||||
int CMS_signed_add1_attr_by_txt(CMS_SignerInfo *si, |
||||
const char *attrname, int type, |
||||
const void *bytes, int len); |
||||
void *CMS_signed_get0_data_by_OBJ(CMS_SignerInfo *si, const ASN1_OBJECT *oid, |
||||
int lastpos, int type); |
||||
|
||||
int CMS_unsigned_get_attr_count(const CMS_SignerInfo *si); |
||||
int CMS_unsigned_get_attr_by_NID(const CMS_SignerInfo *si, int nid, |
||||
int lastpos); |
||||
int CMS_unsigned_get_attr_by_OBJ(const CMS_SignerInfo *si, |
||||
const ASN1_OBJECT *obj, int lastpos); |
||||
X509_ATTRIBUTE *CMS_unsigned_get_attr(const CMS_SignerInfo *si, int loc); |
||||
X509_ATTRIBUTE *CMS_unsigned_delete_attr(CMS_SignerInfo *si, int loc); |
||||
int CMS_unsigned_add1_attr(CMS_SignerInfo *si, X509_ATTRIBUTE *attr); |
||||
int CMS_unsigned_add1_attr_by_OBJ(CMS_SignerInfo *si, |
||||
const ASN1_OBJECT *obj, int type, |
||||
const void *bytes, int len); |
||||
int CMS_unsigned_add1_attr_by_NID(CMS_SignerInfo *si, |
||||
int nid, int type, |
||||
const void *bytes, int len); |
||||
int CMS_unsigned_add1_attr_by_txt(CMS_SignerInfo *si, |
||||
const char *attrname, int type, |
||||
const void *bytes, int len); |
||||
void *CMS_unsigned_get0_data_by_OBJ(CMS_SignerInfo *si, ASN1_OBJECT *oid, |
||||
int lastpos, int type); |
||||
|
||||
int CMS_get1_ReceiptRequest(CMS_SignerInfo *si, CMS_ReceiptRequest **prr); |
||||
CMS_ReceiptRequest *CMS_ReceiptRequest_create0(unsigned char *id, int idlen, |
||||
int allorfirst, |
||||
STACK_OF(GENERAL_NAMES) |
||||
*receiptList, STACK_OF(GENERAL_NAMES) |
||||
*receiptsTo); |
||||
int CMS_add1_ReceiptRequest(CMS_SignerInfo *si, CMS_ReceiptRequest *rr); |
||||
void CMS_ReceiptRequest_get0_values(CMS_ReceiptRequest *rr, |
||||
ASN1_STRING **pcid, |
||||
int *pallorfirst, |
||||
STACK_OF(GENERAL_NAMES) **plist, |
||||
STACK_OF(GENERAL_NAMES) **prto); |
||||
int CMS_RecipientInfo_kari_get0_alg(CMS_RecipientInfo *ri, |
||||
X509_ALGOR **palg, |
||||
ASN1_OCTET_STRING **pukm); |
||||
STACK_OF(CMS_RecipientEncryptedKey) |
||||
*CMS_RecipientInfo_kari_get0_reks(CMS_RecipientInfo *ri); |
||||
|
||||
int CMS_RecipientInfo_kari_get0_orig_id(CMS_RecipientInfo *ri, |
||||
X509_ALGOR **pubalg, |
||||
ASN1_BIT_STRING **pubkey, |
||||
ASN1_OCTET_STRING **keyid, |
||||
X509_NAME **issuer, |
||||
ASN1_INTEGER **sno); |
||||
|
||||
int CMS_RecipientInfo_kari_orig_id_cmp(CMS_RecipientInfo *ri, X509 *cert); |
||||
|
||||
int CMS_RecipientEncryptedKey_get0_id(CMS_RecipientEncryptedKey *rek, |
||||
ASN1_OCTET_STRING **keyid, |
||||
ASN1_GENERALIZEDTIME **tm, |
||||
CMS_OtherKeyAttribute **other, |
||||
X509_NAME **issuer, ASN1_INTEGER **sno); |
||||
int CMS_RecipientEncryptedKey_cert_cmp(CMS_RecipientEncryptedKey *rek, |
||||
X509 *cert); |
||||
int CMS_RecipientInfo_kari_set0_pkey(CMS_RecipientInfo *ri, EVP_PKEY *pk); |
||||
EVP_CIPHER_CTX *CMS_RecipientInfo_kari_get0_ctx(CMS_RecipientInfo *ri); |
||||
int CMS_RecipientInfo_kari_decrypt(CMS_ContentInfo *cms, |
||||
CMS_RecipientInfo *ri, |
||||
CMS_RecipientEncryptedKey *rek); |
||||
|
||||
int CMS_SharedInfo_encode(unsigned char **pder, X509_ALGOR *kekalg, |
||||
ASN1_OCTET_STRING *ukm, int keylen); |
||||
|
||||
/* Backward compatibility for spelling errors. */ |
||||
# define CMS_R_UNKNOWN_DIGEST_ALGORITM CMS_R_UNKNOWN_DIGEST_ALGORITHM |
||||
# define CMS_R_UNSUPPORTED_RECPIENTINFO_TYPE \ |
||||
CMS_R_UNSUPPORTED_RECIPIENTINFO_TYPE |
||||
|
||||
# ifdef __cplusplus |
||||
} |
||||
# endif |
||||
# endif |
||||
#endif |
||||
@ -0,0 +1,203 @@ |
||||
/*
|
||||
* 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_CMSERR_H |
||||
# define HEADER_CMSERR_H |
||||
|
||||
# ifndef HEADER_SYMHACKS_H |
||||
# include <openssl/symhacks.h> |
||||
# endif |
||||
|
||||
# include <openssl/opensslconf.h> |
||||
|
||||
# ifndef OPENSSL_NO_CMS |
||||
|
||||
# ifdef __cplusplus |
||||
extern "C" |
||||
# endif |
||||
int ERR_load_CMS_strings(void); |
||||
|
||||
/*
|
||||
* CMS function codes. |
||||
*/ |
||||
# define CMS_F_CHECK_CONTENT 99 |
||||
# define CMS_F_CMS_ADD0_CERT 164 |
||||
# define CMS_F_CMS_ADD0_RECIPIENT_KEY 100 |
||||
# define CMS_F_CMS_ADD0_RECIPIENT_PASSWORD 165 |
||||
# define CMS_F_CMS_ADD1_RECEIPTREQUEST 158 |
||||
# define CMS_F_CMS_ADD1_RECIPIENT_CERT 101 |
||||
# define CMS_F_CMS_ADD1_SIGNER 102 |
||||
# define CMS_F_CMS_ADD1_SIGNINGTIME 103 |
||||
# define CMS_F_CMS_COMPRESS 104 |
||||
# define CMS_F_CMS_COMPRESSEDDATA_CREATE 105 |
||||
# define CMS_F_CMS_COMPRESSEDDATA_INIT_BIO 106 |
||||
# define CMS_F_CMS_COPY_CONTENT 107 |
||||
# define CMS_F_CMS_COPY_MESSAGEDIGEST 108 |
||||
# define CMS_F_CMS_DATA 109 |
||||
# define CMS_F_CMS_DATAFINAL 110 |
||||
# define CMS_F_CMS_DATAINIT 111 |
||||
# define CMS_F_CMS_DECRYPT 112 |
||||
# define CMS_F_CMS_DECRYPT_SET1_KEY 113 |
||||
# define CMS_F_CMS_DECRYPT_SET1_PASSWORD 166 |
||||
# define CMS_F_CMS_DECRYPT_SET1_PKEY 114 |
||||
# define CMS_F_CMS_DIGESTALGORITHM_FIND_CTX 115 |
||||
# define CMS_F_CMS_DIGESTALGORITHM_INIT_BIO 116 |
||||
# define CMS_F_CMS_DIGESTEDDATA_DO_FINAL 117 |
||||
# define CMS_F_CMS_DIGEST_VERIFY 118 |
||||
# define CMS_F_CMS_ENCODE_RECEIPT 161 |
||||
# define CMS_F_CMS_ENCRYPT 119 |
||||
# define CMS_F_CMS_ENCRYPTEDCONTENT_INIT 179 |
||||
# define CMS_F_CMS_ENCRYPTEDCONTENT_INIT_BIO 120 |
||||
# define CMS_F_CMS_ENCRYPTEDDATA_DECRYPT 121 |
||||
# define CMS_F_CMS_ENCRYPTEDDATA_ENCRYPT 122 |
||||
# define CMS_F_CMS_ENCRYPTEDDATA_SET1_KEY 123 |
||||
# define CMS_F_CMS_ENVELOPEDDATA_CREATE 124 |
||||
# define CMS_F_CMS_ENVELOPEDDATA_INIT_BIO 125 |
||||
# define CMS_F_CMS_ENVELOPED_DATA_INIT 126 |
||||
# define CMS_F_CMS_ENV_ASN1_CTRL 171 |
||||
# define CMS_F_CMS_FINAL 127 |
||||
# define CMS_F_CMS_GET0_CERTIFICATE_CHOICES 128 |
||||
# define CMS_F_CMS_GET0_CONTENT 129 |
||||
# define CMS_F_CMS_GET0_ECONTENT_TYPE 130 |
||||
# define CMS_F_CMS_GET0_ENVELOPED 131 |
||||
# define CMS_F_CMS_GET0_REVOCATION_CHOICES 132 |
||||
# define CMS_F_CMS_GET0_SIGNED 133 |
||||
# define CMS_F_CMS_MSGSIGDIGEST_ADD1 162 |
||||
# define CMS_F_CMS_RECEIPTREQUEST_CREATE0 159 |
||||
# define CMS_F_CMS_RECEIPT_VERIFY 160 |
||||
# define CMS_F_CMS_RECIPIENTINFO_DECRYPT 134 |
||||
# define CMS_F_CMS_RECIPIENTINFO_ENCRYPT 169 |
||||
# define CMS_F_CMS_RECIPIENTINFO_KARI_ENCRYPT 178 |
||||
# define CMS_F_CMS_RECIPIENTINFO_KARI_GET0_ALG 175 |
||||
# define CMS_F_CMS_RECIPIENTINFO_KARI_GET0_ORIG_ID 173 |
||||
# define CMS_F_CMS_RECIPIENTINFO_KARI_GET0_REKS 172 |
||||
# define CMS_F_CMS_RECIPIENTINFO_KARI_ORIG_ID_CMP 174 |
||||
# define CMS_F_CMS_RECIPIENTINFO_KEKRI_DECRYPT 135 |
||||
# define CMS_F_CMS_RECIPIENTINFO_KEKRI_ENCRYPT 136 |
||||
# define CMS_F_CMS_RECIPIENTINFO_KEKRI_GET0_ID 137 |
||||
# define CMS_F_CMS_RECIPIENTINFO_KEKRI_ID_CMP 138 |
||||
# define CMS_F_CMS_RECIPIENTINFO_KTRI_CERT_CMP 139 |
||||
# define CMS_F_CMS_RECIPIENTINFO_KTRI_DECRYPT 140 |
||||
# define CMS_F_CMS_RECIPIENTINFO_KTRI_ENCRYPT 141 |
||||
# define CMS_F_CMS_RECIPIENTINFO_KTRI_GET0_ALGS 142 |
||||
# define CMS_F_CMS_RECIPIENTINFO_KTRI_GET0_SIGNER_ID 143 |
||||
# define CMS_F_CMS_RECIPIENTINFO_PWRI_CRYPT 167 |
||||
# define CMS_F_CMS_RECIPIENTINFO_SET0_KEY 144 |
||||
# define CMS_F_CMS_RECIPIENTINFO_SET0_PASSWORD 168 |
||||
# define CMS_F_CMS_RECIPIENTINFO_SET0_PKEY 145 |
||||
# define CMS_F_CMS_SD_ASN1_CTRL 170 |
||||
# define CMS_F_CMS_SET1_IAS 176 |
||||
# define CMS_F_CMS_SET1_KEYID 177 |
||||
# define CMS_F_CMS_SET1_SIGNERIDENTIFIER 146 |
||||
# define CMS_F_CMS_SET_DETACHED 147 |
||||
# define CMS_F_CMS_SIGN 148 |
||||
# define CMS_F_CMS_SIGNED_DATA_INIT 149 |
||||
# define CMS_F_CMS_SIGNERINFO_CONTENT_SIGN 150 |
||||
# define CMS_F_CMS_SIGNERINFO_SIGN 151 |
||||
# define CMS_F_CMS_SIGNERINFO_VERIFY 152 |
||||
# define CMS_F_CMS_SIGNERINFO_VERIFY_CERT 153 |
||||
# define CMS_F_CMS_SIGNERINFO_VERIFY_CONTENT 154 |
||||
# define CMS_F_CMS_SIGN_RECEIPT 163 |
||||
# define CMS_F_CMS_SI_CHECK_ATTRIBUTES 183 |
||||
# define CMS_F_CMS_STREAM 155 |
||||
# define CMS_F_CMS_UNCOMPRESS 156 |
||||
# define CMS_F_CMS_VERIFY 157 |
||||
# define CMS_F_KEK_UNWRAP_KEY 180 |
||||
|
||||
/*
|
||||
* CMS reason codes. |
||||
*/ |
||||
# define CMS_R_ADD_SIGNER_ERROR 99 |
||||
# define CMS_R_ATTRIBUTE_ERROR 161 |
||||
# define CMS_R_CERTIFICATE_ALREADY_PRESENT 175 |
||||
# define CMS_R_CERTIFICATE_HAS_NO_KEYID 160 |
||||
# define CMS_R_CERTIFICATE_VERIFY_ERROR 100 |
||||
# define CMS_R_CIPHER_INITIALISATION_ERROR 101 |
||||
# define CMS_R_CIPHER_PARAMETER_INITIALISATION_ERROR 102 |
||||
# define CMS_R_CMS_DATAFINAL_ERROR 103 |
||||
# define CMS_R_CMS_LIB 104 |
||||
# define CMS_R_CONTENTIDENTIFIER_MISMATCH 170 |
||||
# define CMS_R_CONTENT_NOT_FOUND 105 |
||||
# define CMS_R_CONTENT_TYPE_MISMATCH 171 |
||||
# define CMS_R_CONTENT_TYPE_NOT_COMPRESSED_DATA 106 |
||||
# define CMS_R_CONTENT_TYPE_NOT_ENVELOPED_DATA 107 |
||||
# define CMS_R_CONTENT_TYPE_NOT_SIGNED_DATA 108 |
||||
# define CMS_R_CONTENT_VERIFY_ERROR 109 |
||||
# define CMS_R_CTRL_ERROR 110 |
||||
# define CMS_R_CTRL_FAILURE 111 |
||||
# define CMS_R_DECRYPT_ERROR 112 |
||||
# define CMS_R_ERROR_GETTING_PUBLIC_KEY 113 |
||||
# define CMS_R_ERROR_READING_MESSAGEDIGEST_ATTRIBUTE 114 |
||||
# define CMS_R_ERROR_SETTING_KEY 115 |
||||
# define CMS_R_ERROR_SETTING_RECIPIENTINFO 116 |
||||
# define CMS_R_INVALID_ENCRYPTED_KEY_LENGTH 117 |
||||
# define CMS_R_INVALID_KEY_ENCRYPTION_PARAMETER 176 |
||||
# define CMS_R_INVALID_KEY_LENGTH 118 |
||||
# define CMS_R_MD_BIO_INIT_ERROR 119 |
||||
# define CMS_R_MESSAGEDIGEST_ATTRIBUTE_WRONG_LENGTH 120 |
||||
# define CMS_R_MESSAGEDIGEST_WRONG_LENGTH 121 |
||||
# define CMS_R_MSGSIGDIGEST_ERROR 172 |
||||
# define CMS_R_MSGSIGDIGEST_VERIFICATION_FAILURE 162 |
||||
# define CMS_R_MSGSIGDIGEST_WRONG_LENGTH 163 |
||||
# define CMS_R_NEED_ONE_SIGNER 164 |
||||
# define CMS_R_NOT_A_SIGNED_RECEIPT 165 |
||||
# define CMS_R_NOT_ENCRYPTED_DATA 122 |
||||
# define CMS_R_NOT_KEK 123 |
||||
# define CMS_R_NOT_KEY_AGREEMENT 181 |
||||
# define CMS_R_NOT_KEY_TRANSPORT 124 |
||||
# define CMS_R_NOT_PWRI 177 |
||||
# define CMS_R_NOT_SUPPORTED_FOR_THIS_KEY_TYPE 125 |
||||
# define CMS_R_NO_CIPHER 126 |
||||
# define CMS_R_NO_CONTENT 127 |
||||
# define CMS_R_NO_CONTENT_TYPE 173 |
||||
# define CMS_R_NO_DEFAULT_DIGEST 128 |
||||
# define CMS_R_NO_DIGEST_SET 129 |
||||
# define CMS_R_NO_KEY 130 |
||||
# define CMS_R_NO_KEY_OR_CERT 174 |
||||
# define CMS_R_NO_MATCHING_DIGEST 131 |
||||
# define CMS_R_NO_MATCHING_RECIPIENT 132 |
||||
# define CMS_R_NO_MATCHING_SIGNATURE 166 |
||||
# define CMS_R_NO_MSGSIGDIGEST 167 |
||||
# define CMS_R_NO_PASSWORD 178 |
||||
# define CMS_R_NO_PRIVATE_KEY 133 |
||||
# define CMS_R_NO_PUBLIC_KEY 134 |
||||
# define CMS_R_NO_RECEIPT_REQUEST 168 |
||||
# define CMS_R_NO_SIGNERS 135 |
||||
# define CMS_R_PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE 136 |
||||
# define CMS_R_RECEIPT_DECODE_ERROR 169 |
||||
# define CMS_R_RECIPIENT_ERROR 137 |
||||
# define CMS_R_SIGNER_CERTIFICATE_NOT_FOUND 138 |
||||
# define CMS_R_SIGNFINAL_ERROR 139 |
||||
# define CMS_R_SMIME_TEXT_ERROR 140 |
||||
# define CMS_R_STORE_INIT_ERROR 141 |
||||
# define CMS_R_TYPE_NOT_COMPRESSED_DATA 142 |
||||
# define CMS_R_TYPE_NOT_DATA 143 |
||||
# define CMS_R_TYPE_NOT_DIGESTED_DATA 144 |
||||
# define CMS_R_TYPE_NOT_ENCRYPTED_DATA 145 |
||||
# define CMS_R_TYPE_NOT_ENVELOPED_DATA 146 |
||||
# define CMS_R_UNABLE_TO_FINALIZE_CONTEXT 147 |
||||
# define CMS_R_UNKNOWN_CIPHER 148 |
||||
# define CMS_R_UNKNOWN_DIGEST_ALGORITHM 149 |
||||
# define CMS_R_UNKNOWN_ID 150 |
||||
# define CMS_R_UNSUPPORTED_COMPRESSION_ALGORITHM 151 |
||||
# define CMS_R_UNSUPPORTED_CONTENT_ENCRYPTION_ALGORITHM 194 |
||||
# define CMS_R_UNSUPPORTED_CONTENT_TYPE 152 |
||||
# define CMS_R_UNSUPPORTED_KEK_ALGORITHM 153 |
||||
# define CMS_R_UNSUPPORTED_KEY_ENCRYPTION_ALGORITHM 179 |
||||
# define CMS_R_UNSUPPORTED_RECIPIENTINFO_TYPE 155 |
||||
# define CMS_R_UNSUPPORTED_RECIPIENT_TYPE 154 |
||||
# define CMS_R_UNSUPPORTED_TYPE 156 |
||||
# define CMS_R_UNWRAP_ERROR 157 |
||||
# define CMS_R_UNWRAP_FAILURE 180 |
||||
# define CMS_R_VERIFICATION_FAILURE 158 |
||||
# define CMS_R_WRAP_ERROR 159 |
||||
|
||||
# endif |
||||
#endif |
||||
@ -0,0 +1,53 @@ |
||||
/*
|
||||
* 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
|
||||
*/ |
||||
|
||||
#ifndef HEADER_COMP_H |
||||
# define HEADER_COMP_H |
||||
|
||||
# include <openssl/opensslconf.h> |
||||
|
||||
# ifndef OPENSSL_NO_COMP |
||||
# include <openssl/crypto.h> |
||||
# include <openssl/comperr.h> |
||||
# ifdef __cplusplus |
||||
extern "C" { |
||||
# endif |
||||
|
||||
|
||||
|
||||
COMP_CTX *COMP_CTX_new(COMP_METHOD *meth); |
||||
const COMP_METHOD *COMP_CTX_get_method(const COMP_CTX *ctx); |
||||
int COMP_CTX_get_type(const COMP_CTX* comp); |
||||
int COMP_get_type(const COMP_METHOD *meth); |
||||
const char *COMP_get_name(const COMP_METHOD *meth); |
||||
void COMP_CTX_free(COMP_CTX *ctx); |
||||
|
||||
int COMP_compress_block(COMP_CTX *ctx, unsigned char *out, int olen, |
||||
unsigned char *in, int ilen); |
||||
int COMP_expand_block(COMP_CTX *ctx, unsigned char *out, int olen, |
||||
unsigned char *in, int ilen); |
||||
|
||||
COMP_METHOD *COMP_zlib(void); |
||||
|
||||
#if OPENSSL_API_COMPAT < 0x10100000L |
||||
#define COMP_zlib_cleanup() while(0) continue |
||||
#endif |
||||
|
||||
# ifdef HEADER_BIO_H |
||||
# ifdef ZLIB |
||||
const BIO_METHOD *BIO_f_zlib(void); |
||||
# endif |
||||
# endif |
||||
|
||||
|
||||
# ifdef __cplusplus |
||||
} |
||||
# endif |
||||
# endif |
||||
#endif |
||||
@ -0,0 +1,44 @@ |
||||
/*
|
||||
* 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_COMPERR_H |
||||
# define HEADER_COMPERR_H |
||||
|
||||
# ifndef HEADER_SYMHACKS_H |
||||
# include <openssl/symhacks.h> |
||||
# endif |
||||
|
||||
# include <openssl/opensslconf.h> |
||||
|
||||
# ifndef OPENSSL_NO_COMP |
||||
|
||||
# ifdef __cplusplus |
||||
extern "C" |
||||
# endif |
||||
int ERR_load_COMP_strings(void); |
||||
|
||||
/*
|
||||
* COMP function codes. |
||||
*/ |
||||
# define COMP_F_BIO_ZLIB_FLUSH 99 |
||||
# define COMP_F_BIO_ZLIB_NEW 100 |
||||
# define COMP_F_BIO_ZLIB_READ 101 |
||||
# define COMP_F_BIO_ZLIB_WRITE 102 |
||||
# define COMP_F_COMP_CTX_NEW 103 |
||||
|
||||
/*
|
||||
* COMP reason codes. |
||||
*/ |
||||
# define COMP_R_ZLIB_DEFLATE_ERROR 99 |
||||
# define COMP_R_ZLIB_INFLATE_ERROR 100 |
||||
# define COMP_R_ZLIB_NOT_SUPPORTED 101 |
||||
|
||||
# endif |
||||
#endif |
||||
@ -0,0 +1,168 @@ |
||||
/*
|
||||
* 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_CONF_H |
||||
# define HEADER_CONF_H |
||||
|
||||
# include <openssl/bio.h> |
||||
# include <openssl/lhash.h> |
||||
# include <openssl/safestack.h> |
||||
# include <openssl/e_os2.h> |
||||
# include <openssl/ossl_typ.h> |
||||
# include <openssl/conferr.h> |
||||
|
||||
#ifdef __cplusplus |
||||
extern "C" { |
||||
#endif |
||||
|
||||
typedef struct { |
||||
char *section; |
||||
char *name; |
||||
char *value; |
||||
} CONF_VALUE; |
||||
|
||||
DEFINE_STACK_OF(CONF_VALUE) |
||||
DEFINE_LHASH_OF(CONF_VALUE); |
||||
|
||||
struct conf_st; |
||||
struct conf_method_st; |
||||
typedef struct conf_method_st CONF_METHOD; |
||||
|
||||
struct conf_method_st { |
||||
const char *name; |
||||
CONF *(*create) (CONF_METHOD *meth); |
||||
int (*init) (CONF *conf); |
||||
int (*destroy) (CONF *conf); |
||||
int (*destroy_data) (CONF *conf); |
||||
int (*load_bio) (CONF *conf, BIO *bp, long *eline); |
||||
int (*dump) (const CONF *conf, BIO *bp); |
||||
int (*is_number) (const CONF *conf, char c); |
||||
int (*to_int) (const CONF *conf, char c); |
||||
int (*load) (CONF *conf, const char *name, long *eline); |
||||
}; |
||||
|
||||
/* Module definitions */ |
||||
|
||||
typedef struct conf_imodule_st CONF_IMODULE; |
||||
typedef struct conf_module_st CONF_MODULE; |
||||
|
||||
DEFINE_STACK_OF(CONF_MODULE) |
||||
DEFINE_STACK_OF(CONF_IMODULE) |
||||
|
||||
/* DSO module function typedefs */ |
||||
typedef int conf_init_func (CONF_IMODULE *md, const CONF *cnf); |
||||
typedef void conf_finish_func (CONF_IMODULE *md); |
||||
|
||||
# define CONF_MFLAGS_IGNORE_ERRORS 0x1 |
||||
# define CONF_MFLAGS_IGNORE_RETURN_CODES 0x2 |
||||
# define CONF_MFLAGS_SILENT 0x4 |
||||
# define CONF_MFLAGS_NO_DSO 0x8 |
||||
# define CONF_MFLAGS_IGNORE_MISSING_FILE 0x10 |
||||
# define CONF_MFLAGS_DEFAULT_SECTION 0x20 |
||||
|
||||
int CONF_set_default_method(CONF_METHOD *meth); |
||||
void CONF_set_nconf(CONF *conf, LHASH_OF(CONF_VALUE) *hash); |
||||
LHASH_OF(CONF_VALUE) *CONF_load(LHASH_OF(CONF_VALUE) *conf, const char *file, |
||||
long *eline); |
||||
# ifndef OPENSSL_NO_STDIO |
||||
LHASH_OF(CONF_VALUE) *CONF_load_fp(LHASH_OF(CONF_VALUE) *conf, FILE *fp, |
||||
long *eline); |
||||
# endif |
||||
LHASH_OF(CONF_VALUE) *CONF_load_bio(LHASH_OF(CONF_VALUE) *conf, BIO *bp, |
||||
long *eline); |
||||
STACK_OF(CONF_VALUE) *CONF_get_section(LHASH_OF(CONF_VALUE) *conf, |
||||
const char *section); |
||||
char *CONF_get_string(LHASH_OF(CONF_VALUE) *conf, const char *group, |
||||
const char *name); |
||||
long CONF_get_number(LHASH_OF(CONF_VALUE) *conf, const char *group, |
||||
const char *name); |
||||
void CONF_free(LHASH_OF(CONF_VALUE) *conf); |
||||
#ifndef OPENSSL_NO_STDIO |
||||
int CONF_dump_fp(LHASH_OF(CONF_VALUE) *conf, FILE *out); |
||||
#endif |
||||
int CONF_dump_bio(LHASH_OF(CONF_VALUE) *conf, BIO *out); |
||||
|
||||
DEPRECATEDIN_1_1_0(void OPENSSL_config(const char *config_name)) |
||||
|
||||
#if OPENSSL_API_COMPAT < 0x10100000L |
||||
# define OPENSSL_no_config() \ |
||||
OPENSSL_init_crypto(OPENSSL_INIT_NO_LOAD_CONFIG, NULL) |
||||
#endif |
||||
|
||||
/*
|
||||
* New conf code. The semantics are different from the functions above. If |
||||
* that wasn't the case, the above functions would have been replaced |
||||
*/ |
||||
|
||||
struct conf_st { |
||||
CONF_METHOD *meth; |
||||
void *meth_data; |
||||
LHASH_OF(CONF_VALUE) *data; |
||||
}; |
||||
|
||||
CONF *NCONF_new(CONF_METHOD *meth); |
||||
CONF_METHOD *NCONF_default(void); |
||||
CONF_METHOD *NCONF_WIN32(void); |
||||
void NCONF_free(CONF *conf); |
||||
void NCONF_free_data(CONF *conf); |
||||
|
||||
int NCONF_load(CONF *conf, const char *file, long *eline); |
||||
# ifndef OPENSSL_NO_STDIO |
||||
int NCONF_load_fp(CONF *conf, FILE *fp, long *eline); |
||||
# endif |
||||
int NCONF_load_bio(CONF *conf, BIO *bp, long *eline); |
||||
STACK_OF(CONF_VALUE) *NCONF_get_section(const CONF *conf, |
||||
const char *section); |
||||
char *NCONF_get_string(const CONF *conf, const char *group, const char *name); |
||||
int NCONF_get_number_e(const CONF *conf, const char *group, const char *name, |
||||
long *result); |
||||
#ifndef OPENSSL_NO_STDIO |
||||
int NCONF_dump_fp(const CONF *conf, FILE *out); |
||||
#endif |
||||
int NCONF_dump_bio(const CONF *conf, BIO *out); |
||||
|
||||
#define NCONF_get_number(c,g,n,r) NCONF_get_number_e(c,g,n,r) |
||||
|
||||
/* Module functions */ |
||||
|
||||
int CONF_modules_load(const CONF *cnf, const char *appname, |
||||
unsigned long flags); |
||||
int CONF_modules_load_file(const char *filename, const char *appname, |
||||
unsigned long flags); |
||||
void CONF_modules_unload(int all); |
||||
void CONF_modules_finish(void); |
||||
#if OPENSSL_API_COMPAT < 0x10100000L |
||||
# define CONF_modules_free() while(0) continue |
||||
#endif |
||||
int CONF_module_add(const char *name, conf_init_func *ifunc, |
||||
conf_finish_func *ffunc); |
||||
|
||||
const char *CONF_imodule_get_name(const CONF_IMODULE *md); |
||||
const char *CONF_imodule_get_value(const CONF_IMODULE *md); |
||||
void *CONF_imodule_get_usr_data(const CONF_IMODULE *md); |
||||
void CONF_imodule_set_usr_data(CONF_IMODULE *md, void *usr_data); |
||||
CONF_MODULE *CONF_imodule_get_module(const CONF_IMODULE *md); |
||||
unsigned long CONF_imodule_get_flags(const CONF_IMODULE *md); |
||||
void CONF_imodule_set_flags(CONF_IMODULE *md, unsigned long flags); |
||||
void *CONF_module_get_usr_data(CONF_MODULE *pmod); |
||||
void CONF_module_set_usr_data(CONF_MODULE *pmod, void *usr_data); |
||||
|
||||
char *CONF_get1_default_config_file(void); |
||||
|
||||
int CONF_parse_list(const char *list, int sep, int nospc, |
||||
int (*list_cb) (const char *elem, int len, void *usr), |
||||
void *arg); |
||||
|
||||
void OPENSSL_load_builtin_modules(void); |
||||
|
||||
|
||||
# ifdef __cplusplus |
||||
} |
||||
# endif |
||||
#endif |
||||
@ -0,0 +1,40 @@ |
||||
/*
|
||||
* 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_CONF_API_H |
||||
# define HEADER_CONF_API_H |
||||
|
||||
# include <openssl/lhash.h> |
||||
# include <openssl/conf.h> |
||||
|
||||
#ifdef __cplusplus |
||||
extern "C" { |
||||
#endif |
||||
|
||||
/* Up until OpenSSL 0.9.5a, this was new_section */ |
||||
CONF_VALUE *_CONF_new_section(CONF *conf, const char *section); |
||||
/* Up until OpenSSL 0.9.5a, this was get_section */ |
||||
CONF_VALUE *_CONF_get_section(const CONF *conf, const char *section); |
||||
/* Up until OpenSSL 0.9.5a, this was CONF_get_section */ |
||||
STACK_OF(CONF_VALUE) *_CONF_get_section_values(const CONF *conf, |
||||
const char *section); |
||||
|
||||
int _CONF_add_string(CONF *conf, CONF_VALUE *section, CONF_VALUE *value); |
||||
char *_CONF_get_string(const CONF *conf, const char *section, |
||||
const char *name); |
||||
long _CONF_get_number(const CONF *conf, const char *section, |
||||
const char *name); |
||||
|
||||
int _CONF_new_data(CONF *conf); |
||||
void _CONF_free_data(CONF *conf); |
||||
|
||||
#ifdef __cplusplus |
||||
} |
||||
#endif |
||||
#endif |
||||
@ -0,0 +1,76 @@ |
||||
/*
|
||||
* 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_CONFERR_H |
||||
# define HEADER_CONFERR_H |
||||
|
||||
# ifndef HEADER_SYMHACKS_H |
||||
# include <openssl/symhacks.h> |
||||
# endif |
||||
|
||||
# ifdef __cplusplus |
||||
extern "C" |
||||
# endif |
||||
int ERR_load_CONF_strings(void); |
||||
|
||||
/*
|
||||
* CONF function codes. |
||||
*/ |
||||
# define CONF_F_CONF_DUMP_FP 104 |
||||
# define CONF_F_CONF_LOAD 100 |
||||
# define CONF_F_CONF_LOAD_FP 103 |
||||
# define CONF_F_CONF_PARSE_LIST 119 |
||||
# define CONF_F_DEF_LOAD 120 |
||||
# define CONF_F_DEF_LOAD_BIO 121 |
||||
# define CONF_F_GET_NEXT_FILE 107 |
||||
# define CONF_F_MODULE_ADD 122 |
||||
# define CONF_F_MODULE_INIT 115 |
||||
# define CONF_F_MODULE_LOAD_DSO 117 |
||||
# define CONF_F_MODULE_RUN 118 |
||||
# define CONF_F_NCONF_DUMP_BIO 105 |
||||
# define CONF_F_NCONF_DUMP_FP 106 |
||||
# define CONF_F_NCONF_GET_NUMBER_E 112 |
||||
# define CONF_F_NCONF_GET_SECTION 108 |
||||
# define CONF_F_NCONF_GET_STRING 109 |
||||
# define CONF_F_NCONF_LOAD 113 |
||||
# define CONF_F_NCONF_LOAD_BIO 110 |
||||
# define CONF_F_NCONF_LOAD_FP 114 |
||||
# define CONF_F_NCONF_NEW 111 |
||||
# define CONF_F_PROCESS_INCLUDE 116 |
||||
# define CONF_F_SSL_MODULE_INIT 123 |
||||
# define CONF_F_STR_COPY 101 |
||||
|
||||
/*
|
||||
* CONF reason codes. |
||||
*/ |
||||
# define CONF_R_ERROR_LOADING_DSO 110 |
||||
# define CONF_R_LIST_CANNOT_BE_NULL 115 |
||||
# define CONF_R_MISSING_CLOSE_SQUARE_BRACKET 100 |
||||
# define CONF_R_MISSING_EQUAL_SIGN 101 |
||||
# define CONF_R_MISSING_INIT_FUNCTION 112 |
||||
# define CONF_R_MODULE_INITIALIZATION_ERROR 109 |
||||
# define CONF_R_NO_CLOSE_BRACE 102 |
||||
# define CONF_R_NO_CONF 105 |
||||
# define CONF_R_NO_CONF_OR_ENVIRONMENT_VARIABLE 106 |
||||
# define CONF_R_NO_SECTION 107 |
||||
# define CONF_R_NO_SUCH_FILE 114 |
||||
# define CONF_R_NO_VALUE 108 |
||||
# define CONF_R_NUMBER_TOO_LARGE 121 |
||||
# define CONF_R_RECURSIVE_DIRECTORY_INCLUDE 111 |
||||
# define CONF_R_SSL_COMMAND_SECTION_EMPTY 117 |
||||
# define CONF_R_SSL_COMMAND_SECTION_NOT_FOUND 118 |
||||
# define CONF_R_SSL_SECTION_EMPTY 119 |
||||
# define CONF_R_SSL_SECTION_NOT_FOUND 120 |
||||
# define CONF_R_UNABLE_TO_CREATE_NEW_SECTION 103 |
||||
# define CONF_R_UNKNOWN_MODULE_NAME 113 |
||||
# define CONF_R_VARIABLE_EXPANSION_TOO_LONG 116 |
||||
# define CONF_R_VARIABLE_HAS_NO_VALUE 104 |
||||
|
||||
#endif |
||||
@ -0,0 +1,445 @@ |
||||
/*
|
||||
* 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 <stdlib.h> |
||||
# include <time.h> |
||||
|
||||
# include <openssl/e_os2.h> |
||||
|
||||
# ifndef OPENSSL_NO_STDIO |
||||
# include <stdio.h> |
||||
# endif |
||||
|
||||
# include <openssl/safestack.h> |
||||
# include <openssl/opensslv.h> |
||||
# include <openssl/ossl_typ.h> |
||||
# include <openssl/opensslconf.h> |
||||
# include <openssl/cryptoerr.h> |
||||
|
||||
# ifdef CHARSET_EBCDIC |
||||
# include <openssl/ebcdic.h> |
||||
# endif |
||||
|
||||
/*
|
||||
* Resolve problems on some operating systems with symbol names that clash |
||||
* one way or another |
||||
*/ |
||||
# include <openssl/symhacks.h> |
||||
|
||||
# if OPENSSL_API_COMPAT < 0x10100000L |
||||
# include <openssl/opensslv.h> |
||||
# 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__COUNT 16 |
||||
|
||||
/* 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 |
||||
|
||||
/* 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)) |
||||
|
||||
int OPENSSL_isservice(void); |
||||
|
||||
int FIPS_mode(void); |
||||
int FIPS_mode_set(int r); |
||||
|
||||
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 <windows.h> 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 <pthread.h> |
||||
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); |
||||
|
||||
|
||||
# ifdef __cplusplus |
||||
} |
||||
# endif |
||||
#endif |
||||
@ -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 <openssl/symhacks.h> |
||||
# 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 |
||||
@ -0,0 +1,474 @@ |
||||
/*
|
||||
* 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_CT_H |
||||
# define HEADER_CT_H |
||||
|
||||
# include <openssl/opensslconf.h> |
||||
|
||||
# ifndef OPENSSL_NO_CT |
||||
# include <openssl/ossl_typ.h> |
||||
# include <openssl/safestack.h> |
||||
# include <openssl/x509.h> |
||||
# include <openssl/cterr.h> |
||||
# ifdef __cplusplus |
||||
extern "C" { |
||||
# endif |
||||
|
||||
|
||||
/* Minimum RSA key size, from RFC6962 */ |
||||
# define SCT_MIN_RSA_BITS 2048 |
||||
|
||||
/* All hashes are SHA256 in v1 of Certificate Transparency */ |
||||
# define CT_V1_HASHLEN SHA256_DIGEST_LENGTH |
||||
|
||||
typedef enum { |
||||
CT_LOG_ENTRY_TYPE_NOT_SET = -1, |
||||
CT_LOG_ENTRY_TYPE_X509 = 0, |
||||
CT_LOG_ENTRY_TYPE_PRECERT = 1 |
||||
} ct_log_entry_type_t; |
||||
|
||||
typedef enum { |
||||
SCT_VERSION_NOT_SET = -1, |
||||
SCT_VERSION_V1 = 0 |
||||
} sct_version_t; |
||||
|
||||
typedef enum { |
||||
SCT_SOURCE_UNKNOWN, |
||||
SCT_SOURCE_TLS_EXTENSION, |
||||
SCT_SOURCE_X509V3_EXTENSION, |
||||
SCT_SOURCE_OCSP_STAPLED_RESPONSE |
||||
} sct_source_t; |
||||
|
||||
typedef enum { |
||||
SCT_VALIDATION_STATUS_NOT_SET, |
||||
SCT_VALIDATION_STATUS_UNKNOWN_LOG, |
||||
SCT_VALIDATION_STATUS_VALID, |
||||
SCT_VALIDATION_STATUS_INVALID, |
||||
SCT_VALIDATION_STATUS_UNVERIFIED, |
||||
SCT_VALIDATION_STATUS_UNKNOWN_VERSION |
||||
} sct_validation_status_t; |
||||
|
||||
DEFINE_STACK_OF(SCT) |
||||
DEFINE_STACK_OF(CTLOG) |
||||
|
||||
/******************************************
|
||||
* CT policy evaluation context functions * |
||||
******************************************/ |
||||
|
||||
/*
|
||||
* Creates a new, empty policy evaluation context. |
||||
* The caller is responsible for calling CT_POLICY_EVAL_CTX_free when finished |
||||
* with the CT_POLICY_EVAL_CTX. |
||||
*/ |
||||
CT_POLICY_EVAL_CTX *CT_POLICY_EVAL_CTX_new(void); |
||||
|
||||
/* Deletes a policy evaluation context and anything it owns. */ |
||||
void CT_POLICY_EVAL_CTX_free(CT_POLICY_EVAL_CTX *ctx); |
||||
|
||||
/* Gets the peer certificate that the SCTs are for */ |
||||
X509* CT_POLICY_EVAL_CTX_get0_cert(const CT_POLICY_EVAL_CTX *ctx); |
||||
|
||||
/*
|
||||
* Sets the certificate associated with the received SCTs. |
||||
* Increments the reference count of cert. |
||||
* Returns 1 on success, 0 otherwise. |
||||
*/ |
||||
int CT_POLICY_EVAL_CTX_set1_cert(CT_POLICY_EVAL_CTX *ctx, X509 *cert); |
||||
|
||||
/* Gets the issuer of the aforementioned certificate */ |
||||
X509* CT_POLICY_EVAL_CTX_get0_issuer(const CT_POLICY_EVAL_CTX *ctx); |
||||
|
||||
/*
|
||||
* Sets the issuer of the certificate associated with the received SCTs. |
||||
* Increments the reference count of issuer. |
||||
* Returns 1 on success, 0 otherwise. |
||||
*/ |
||||
int CT_POLICY_EVAL_CTX_set1_issuer(CT_POLICY_EVAL_CTX *ctx, X509 *issuer); |
||||
|
||||
/* Gets the CT logs that are trusted sources of SCTs */ |
||||
const CTLOG_STORE *CT_POLICY_EVAL_CTX_get0_log_store(const CT_POLICY_EVAL_CTX *ctx); |
||||
|
||||
/* Sets the log store that is in use. It must outlive the CT_POLICY_EVAL_CTX. */ |
||||
void CT_POLICY_EVAL_CTX_set_shared_CTLOG_STORE(CT_POLICY_EVAL_CTX *ctx, |
||||
CTLOG_STORE *log_store); |
||||
|
||||
/*
|
||||
* Gets the time, in milliseconds since the Unix epoch, that will be used as the |
||||
* current time when checking whether an SCT was issued in the future. |
||||
* Such SCTs will fail validation, as required by RFC6962. |
||||
*/ |
||||
uint64_t CT_POLICY_EVAL_CTX_get_time(const CT_POLICY_EVAL_CTX *ctx); |
||||
|
||||
/*
|
||||
* Sets the time to evaluate SCTs against, in milliseconds since the Unix epoch. |
||||
* If an SCT's timestamp is after this time, it will be interpreted as having |
||||
* been issued in the future. RFC6962 states that "TLS clients MUST reject SCTs |
||||
* whose timestamp is in the future", so an SCT will not validate in this case. |
||||
*/ |
||||
void CT_POLICY_EVAL_CTX_set_time(CT_POLICY_EVAL_CTX *ctx, uint64_t time_in_ms); |
||||
|
||||
/*****************
|
||||
* SCT functions * |
||||
*****************/ |
||||
|
||||
/*
|
||||
* Creates a new, blank SCT. |
||||
* The caller is responsible for calling SCT_free when finished with the SCT. |
||||
*/ |
||||
SCT *SCT_new(void); |
||||
|
||||
/*
|
||||
* Creates a new SCT from some base64-encoded strings. |
||||
* The caller is responsible for calling SCT_free when finished with the SCT. |
||||
*/ |
||||
SCT *SCT_new_from_base64(unsigned char version, |
||||
const char *logid_base64, |
||||
ct_log_entry_type_t entry_type, |
||||
uint64_t timestamp, |
||||
const char *extensions_base64, |
||||
const char *signature_base64); |
||||
|
||||
/*
|
||||
* Frees the SCT and the underlying data structures. |
||||
*/ |
||||
void SCT_free(SCT *sct); |
||||
|
||||
/*
|
||||
* Free a stack of SCTs, and the underlying SCTs themselves. |
||||
* Intended to be compatible with X509V3_EXT_FREE. |
||||
*/ |
||||
void SCT_LIST_free(STACK_OF(SCT) *a); |
||||
|
||||
/*
|
||||
* Returns the version of the SCT. |
||||
*/ |
||||
sct_version_t SCT_get_version(const SCT *sct); |
||||
|
||||
/*
|
||||
* Set the version of an SCT. |
||||
* Returns 1 on success, 0 if the version is unrecognized. |
||||
*/ |
||||
__owur int SCT_set_version(SCT *sct, sct_version_t version); |
||||
|
||||
/*
|
||||
* Returns the log entry type of the SCT. |
||||
*/ |
||||
ct_log_entry_type_t SCT_get_log_entry_type(const SCT *sct); |
||||
|
||||
/*
|
||||
* Set the log entry type of an SCT. |
||||
* Returns 1 on success, 0 otherwise. |
||||
*/ |
||||
__owur int SCT_set_log_entry_type(SCT *sct, ct_log_entry_type_t entry_type); |
||||
|
||||
/*
|
||||
* Gets the ID of the log that an SCT came from. |
||||
* Ownership of the log ID remains with the SCT. |
||||
* Returns the length of the log ID. |
||||
*/ |
||||
size_t SCT_get0_log_id(const SCT *sct, unsigned char **log_id); |
||||
|
||||
/*
|
||||
* Set the log ID of an SCT to point directly to the *log_id specified. |
||||
* The SCT takes ownership of the specified pointer. |
||||
* Returns 1 on success, 0 otherwise. |
||||
*/ |
||||
__owur int SCT_set0_log_id(SCT *sct, unsigned char *log_id, size_t log_id_len); |
||||
|
||||
/*
|
||||
* Set the log ID of an SCT. |
||||
* This makes a copy of the log_id. |
||||
* Returns 1 on success, 0 otherwise. |
||||
*/ |
||||
__owur int SCT_set1_log_id(SCT *sct, const unsigned char *log_id, |
||||
size_t log_id_len); |
||||
|
||||
/*
|
||||
* Returns the timestamp for the SCT (epoch time in milliseconds). |
||||
*/ |
||||
uint64_t SCT_get_timestamp(const SCT *sct); |
||||
|
||||
/*
|
||||
* Set the timestamp of an SCT (epoch time in milliseconds). |
||||
*/ |
||||
void SCT_set_timestamp(SCT *sct, uint64_t timestamp); |
||||
|
||||
/*
|
||||
* Return the NID for the signature used by the SCT. |
||||
* For CT v1, this will be either NID_sha256WithRSAEncryption or |
||||
* NID_ecdsa_with_SHA256 (or NID_undef if incorrect/unset). |
||||
*/ |
||||
int SCT_get_signature_nid(const SCT *sct); |
||||
|
||||
/*
|
||||
* Set the signature type of an SCT |
||||
* For CT v1, this should be either NID_sha256WithRSAEncryption or |
||||
* NID_ecdsa_with_SHA256. |
||||
* Returns 1 on success, 0 otherwise. |
||||
*/ |
||||
__owur int SCT_set_signature_nid(SCT *sct, int nid); |
||||
|
||||
/*
|
||||
* Set *ext to point to the extension data for the SCT. ext must not be NULL. |
||||
* The SCT retains ownership of this pointer. |
||||
* Returns length of the data pointed to. |
||||
*/ |
||||
size_t SCT_get0_extensions(const SCT *sct, unsigned char **ext); |
||||
|
||||
/*
|
||||
* Set the extensions of an SCT to point directly to the *ext specified. |
||||
* The SCT takes ownership of the specified pointer. |
||||
*/ |
||||
void SCT_set0_extensions(SCT *sct, unsigned char *ext, size_t ext_len); |
||||
|
||||
/*
|
||||
* Set the extensions of an SCT. |
||||
* This takes a copy of the ext. |
||||
* Returns 1 on success, 0 otherwise. |
||||
*/ |
||||
__owur int SCT_set1_extensions(SCT *sct, const unsigned char *ext, |
||||
size_t ext_len); |
||||
|
||||
/*
|
||||
* Set *sig to point to the signature for the SCT. sig must not be NULL. |
||||
* The SCT retains ownership of this pointer. |
||||
* Returns length of the data pointed to. |
||||
*/ |
||||
size_t SCT_get0_signature(const SCT *sct, unsigned char **sig); |
||||
|
||||
/*
|
||||
* Set the signature of an SCT to point directly to the *sig specified. |
||||
* The SCT takes ownership of the specified pointer. |
||||
*/ |
||||
void SCT_set0_signature(SCT *sct, unsigned char *sig, size_t sig_len); |
||||
|
||||
/*
|
||||
* Set the signature of an SCT to be a copy of the *sig specified. |
||||
* Returns 1 on success, 0 otherwise. |
||||
*/ |
||||
__owur int SCT_set1_signature(SCT *sct, const unsigned char *sig, |
||||
size_t sig_len); |
||||
|
||||
/*
|
||||
* The origin of this SCT, e.g. TLS extension, OCSP response, etc. |
||||
*/ |
||||
sct_source_t SCT_get_source(const SCT *sct); |
||||
|
||||
/*
|
||||
* Set the origin of this SCT, e.g. TLS extension, OCSP response, etc. |
||||
* Returns 1 on success, 0 otherwise. |
||||
*/ |
||||
__owur int SCT_set_source(SCT *sct, sct_source_t source); |
||||
|
||||
/*
|
||||
* Returns a text string describing the validation status of |sct|. |
||||
*/ |
||||
const char *SCT_validation_status_string(const SCT *sct); |
||||
|
||||
/*
|
||||
* Pretty-prints an |sct| to |out|. |
||||
* It will be indented by the number of spaces specified by |indent|. |
||||
* If |logs| is not NULL, it will be used to lookup the CT log that the SCT came |
||||
* from, so that the log name can be printed. |
||||
*/ |
||||
void SCT_print(const SCT *sct, BIO *out, int indent, const CTLOG_STORE *logs); |
||||
|
||||
/*
|
||||
* Pretty-prints an |sct_list| to |out|. |
||||
* It will be indented by the number of spaces specified by |indent|. |
||||
* SCTs will be delimited by |separator|. |
||||
* If |logs| is not NULL, it will be used to lookup the CT log that each SCT |
||||
* came from, so that the log names can be printed. |
||||
*/ |
||||
void SCT_LIST_print(const STACK_OF(SCT) *sct_list, BIO *out, int indent, |
||||
const char *separator, const CTLOG_STORE *logs); |
||||
|
||||
/*
|
||||
* Gets the last result of validating this SCT. |
||||
* If it has not been validated yet, returns SCT_VALIDATION_STATUS_NOT_SET. |
||||
*/ |
||||
sct_validation_status_t SCT_get_validation_status(const SCT *sct); |
||||
|
||||
/*
|
||||
* Validates the given SCT with the provided context. |
||||
* Sets the "validation_status" field of the SCT. |
||||
* Returns 1 if the SCT is valid and the signature verifies. |
||||
* Returns 0 if the SCT is invalid or could not be verified. |
||||
* Returns -1 if an error occurs. |
||||
*/ |
||||
__owur int SCT_validate(SCT *sct, const CT_POLICY_EVAL_CTX *ctx); |
||||
|
||||
/*
|
||||
* Validates the given list of SCTs with the provided context. |
||||
* Sets the "validation_status" field of each SCT. |
||||
* Returns 1 if there are no invalid SCTs and all signatures verify. |
||||
* Returns 0 if at least one SCT is invalid or could not be verified. |
||||
* Returns a negative integer if an error occurs. |
||||
*/ |
||||
__owur int SCT_LIST_validate(const STACK_OF(SCT) *scts, |
||||
CT_POLICY_EVAL_CTX *ctx); |
||||
|
||||
|
||||
/*********************************
|
||||
* SCT parsing and serialisation * |
||||
*********************************/ |
||||
|
||||
/*
|
||||
* Serialize (to TLS format) a stack of SCTs and return the length. |
||||
* "a" must not be NULL. |
||||
* If "pp" is NULL, just return the length of what would have been serialized. |
||||
* If "pp" is not NULL and "*pp" is null, function will allocate a new pointer |
||||
* for data that caller is responsible for freeing (only if function returns |
||||
* successfully). |
||||
* If "pp" is NULL and "*pp" is not NULL, caller is responsible for ensuring |
||||
* that "*pp" is large enough to accept all of the serialized data. |
||||
* Returns < 0 on error, >= 0 indicating bytes written (or would have been) |
||||
* on success. |
||||
*/ |
||||
__owur int i2o_SCT_LIST(const STACK_OF(SCT) *a, unsigned char **pp); |
||||
|
||||
/*
|
||||
* Convert TLS format SCT list to a stack of SCTs. |
||||
* If "a" or "*a" is NULL, a new stack will be created that the caller is |
||||
* responsible for freeing (by calling SCT_LIST_free). |
||||
* "**pp" and "*pp" must not be NULL. |
||||
* Upon success, "*pp" will point to after the last bytes read, and a stack |
||||
* will be returned. |
||||
* Upon failure, a NULL pointer will be returned, and the position of "*pp" is |
||||
* not defined. |
||||
*/ |
||||
STACK_OF(SCT) *o2i_SCT_LIST(STACK_OF(SCT) **a, const unsigned char **pp, |
||||
size_t len); |
||||
|
||||
/*
|
||||
* Serialize (to DER format) a stack of SCTs and return the length. |
||||
* "a" must not be NULL. |
||||
* If "pp" is NULL, just returns the length of what would have been serialized. |
||||
* If "pp" is not NULL and "*pp" is null, function will allocate a new pointer |
||||
* for data that caller is responsible for freeing (only if function returns |
||||
* successfully). |
||||
* If "pp" is NULL and "*pp" is not NULL, caller is responsible for ensuring |
||||
* that "*pp" is large enough to accept all of the serialized data. |
||||
* Returns < 0 on error, >= 0 indicating bytes written (or would have been) |
||||
* on success. |
||||
*/ |
||||
__owur int i2d_SCT_LIST(const STACK_OF(SCT) *a, unsigned char **pp); |
||||
|
||||
/*
|
||||
* Parses an SCT list in DER format and returns it. |
||||
* If "a" or "*a" is NULL, a new stack will be created that the caller is |
||||
* responsible for freeing (by calling SCT_LIST_free). |
||||
* "**pp" and "*pp" must not be NULL. |
||||
* Upon success, "*pp" will point to after the last bytes read, and a stack |
||||
* will be returned. |
||||
* Upon failure, a NULL pointer will be returned, and the position of "*pp" is |
||||
* not defined. |
||||
*/ |
||||
STACK_OF(SCT) *d2i_SCT_LIST(STACK_OF(SCT) **a, const unsigned char **pp, |
||||
long len); |
||||
|
||||
/*
|
||||
* Serialize (to TLS format) an |sct| and write it to |out|. |
||||
* If |out| is null, no SCT will be output but the length will still be returned. |
||||
* If |out| points to a null pointer, a string will be allocated to hold the |
||||
* TLS-format SCT. It is the responsibility of the caller to free it. |
||||
* If |out| points to an allocated string, the TLS-format SCT will be written |
||||
* to it. |
||||
* The length of the SCT in TLS format will be returned. |
||||
*/ |
||||
__owur int i2o_SCT(const SCT *sct, unsigned char **out); |
||||
|
||||
/*
|
||||
* Parses an SCT in TLS format and returns it. |
||||
* If |psct| is not null, it will end up pointing to the parsed SCT. If it |
||||
* already points to a non-null pointer, the pointer will be free'd. |
||||
* |in| should be a pointer to a string containing the TLS-format SCT. |
||||
* |in| will be advanced to the end of the SCT if parsing succeeds. |
||||
* |len| should be the length of the SCT in |in|. |
||||
* Returns NULL if an error occurs. |
||||
* If the SCT is an unsupported version, only the SCT's 'sct' and 'sct_len' |
||||
* fields will be populated (with |in| and |len| respectively). |
||||
*/ |
||||
SCT *o2i_SCT(SCT **psct, const unsigned char **in, size_t len); |
||||
|
||||
/********************
|
||||
* CT log functions * |
||||
********************/ |
||||
|
||||
/*
|
||||
* Creates a new CT log instance with the given |public_key| and |name|. |
||||
* Takes ownership of |public_key| but copies |name|. |
||||
* Returns NULL if malloc fails or if |public_key| cannot be converted to DER. |
||||
* Should be deleted by the caller using CTLOG_free when no longer needed. |
||||
*/ |
||||
CTLOG *CTLOG_new(EVP_PKEY *public_key, const char *name); |
||||
|
||||
/*
|
||||
* Creates a new CTLOG instance with the base64-encoded SubjectPublicKeyInfo DER |
||||
* in |pkey_base64|. The |name| is a string to help users identify this log. |
||||
* Returns 1 on success, 0 on failure. |
||||
* Should be deleted by the caller using CTLOG_free when no longer needed. |
||||
*/ |
||||
int CTLOG_new_from_base64(CTLOG ** ct_log, |
||||
const char *pkey_base64, const char *name); |
||||
|
||||
/*
|
||||
* Deletes a CT log instance and its fields. |
||||
*/ |
||||
void CTLOG_free(CTLOG *log); |
||||
|
||||
/* Gets the name of the CT log */ |
||||
const char *CTLOG_get0_name(const CTLOG *log); |
||||
/* Gets the ID of the CT log */ |
||||
void CTLOG_get0_log_id(const CTLOG *log, const uint8_t **log_id, |
||||
size_t *log_id_len); |
||||
/* Gets the public key of the CT log */ |
||||
EVP_PKEY *CTLOG_get0_public_key(const CTLOG *log); |
||||
|
||||
/**************************
|
||||
* CT log store functions * |
||||
**************************/ |
||||
|
||||
/*
|
||||
* Creates a new CT log store. |
||||
* Should be deleted by the caller using CTLOG_STORE_free when no longer needed. |
||||
*/ |
||||
CTLOG_STORE *CTLOG_STORE_new(void); |
||||
|
||||
/*
|
||||
* Deletes a CT log store and all of the CT log instances held within. |
||||
*/ |
||||
void CTLOG_STORE_free(CTLOG_STORE *store); |
||||
|
||||
/*
|
||||
* Finds a CT log in the store based on its log ID. |
||||
* Returns the CT log, or NULL if no match is found. |
||||
*/ |
||||
const CTLOG *CTLOG_STORE_get0_log_by_id(const CTLOG_STORE *store, |
||||
const uint8_t *log_id, |
||||
size_t log_id_len); |
||||
|
||||
/*
|
||||
* Loads a CT log list into a |store| from a |file|. |
||||
* Returns 1 if loading is successful, or 0 otherwise. |
||||
*/ |
||||
__owur int CTLOG_STORE_load_file(CTLOG_STORE *store, const char *file); |
||||
|
||||
/*
|
||||
* Loads the default CT log list into a |store|. |
||||
* Returns 1 if loading is successful, or 0 otherwise. |
||||
*/ |
||||
__owur int CTLOG_STORE_load_default_file(CTLOG_STORE *store); |
||||
|
||||
# ifdef __cplusplus |
||||
} |
||||
# endif |
||||
# endif |
||||
#endif |
||||
@ -0,0 +1,80 @@ |
||||
/*
|
||||
* 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_CTERR_H |
||||
# define HEADER_CTERR_H |
||||
|
||||
# ifndef HEADER_SYMHACKS_H |
||||
# include <openssl/symhacks.h> |
||||
# endif |
||||
|
||||
# include <openssl/opensslconf.h> |
||||
|
||||
# ifndef OPENSSL_NO_CT |
||||
|
||||
# ifdef __cplusplus |
||||
extern "C" |
||||
# endif |
||||
int ERR_load_CT_strings(void); |
||||
|
||||
/*
|
||||
* CT function codes. |
||||
*/ |
||||
# define CT_F_CTLOG_NEW 117 |
||||
# define CT_F_CTLOG_NEW_FROM_BASE64 118 |
||||
# define CT_F_CTLOG_NEW_FROM_CONF 119 |
||||
# define CT_F_CTLOG_STORE_LOAD_CTX_NEW 122 |
||||
# define CT_F_CTLOG_STORE_LOAD_FILE 123 |
||||
# define CT_F_CTLOG_STORE_LOAD_LOG 130 |
||||
# define CT_F_CTLOG_STORE_NEW 131 |
||||
# define CT_F_CT_BASE64_DECODE 124 |
||||
# define CT_F_CT_POLICY_EVAL_CTX_NEW 133 |
||||
# define CT_F_CT_V1_LOG_ID_FROM_PKEY 125 |
||||
# define CT_F_I2O_SCT 107 |
||||
# define CT_F_I2O_SCT_LIST 108 |
||||
# define CT_F_I2O_SCT_SIGNATURE 109 |
||||
# define CT_F_O2I_SCT 110 |
||||
# define CT_F_O2I_SCT_LIST 111 |
||||
# define CT_F_O2I_SCT_SIGNATURE 112 |
||||
# define CT_F_SCT_CTX_NEW 126 |
||||
# define CT_F_SCT_CTX_VERIFY 128 |
||||
# define CT_F_SCT_NEW 100 |
||||
# define CT_F_SCT_NEW_FROM_BASE64 127 |
||||
# define CT_F_SCT_SET0_LOG_ID 101 |
||||
# define CT_F_SCT_SET1_EXTENSIONS 114 |
||||
# define CT_F_SCT_SET1_LOG_ID 115 |
||||
# define CT_F_SCT_SET1_SIGNATURE 116 |
||||
# define CT_F_SCT_SET_LOG_ENTRY_TYPE 102 |
||||
# define CT_F_SCT_SET_SIGNATURE_NID 103 |
||||
# define CT_F_SCT_SET_VERSION 104 |
||||
|
||||
/*
|
||||
* CT reason codes. |
||||
*/ |
||||
# define CT_R_BASE64_DECODE_ERROR 108 |
||||
# define CT_R_INVALID_LOG_ID_LENGTH 100 |
||||
# define CT_R_LOG_CONF_INVALID 109 |
||||
# define CT_R_LOG_CONF_INVALID_KEY 110 |
||||
# define CT_R_LOG_CONF_MISSING_DESCRIPTION 111 |
||||
# define CT_R_LOG_CONF_MISSING_KEY 112 |
||||
# define CT_R_LOG_KEY_INVALID 113 |
||||
# define CT_R_SCT_FUTURE_TIMESTAMP 116 |
||||
# define CT_R_SCT_INVALID 104 |
||||
# define CT_R_SCT_INVALID_SIGNATURE 107 |
||||
# define CT_R_SCT_LIST_INVALID 105 |
||||
# define CT_R_SCT_LOG_ID_MISMATCH 114 |
||||
# define CT_R_SCT_NOT_SET 106 |
||||
# define CT_R_SCT_UNSUPPORTED_VERSION 115 |
||||
# define CT_R_UNRECOGNIZED_SIGNATURE_NID 101 |
||||
# define CT_R_UNSUPPORTED_ENTRY_TYPE 102 |
||||
# define CT_R_UNSUPPORTED_VERSION 103 |
||||
|
||||
# endif |
||||
#endif |
||||
@ -0,0 +1,174 @@ |
||||
/*
|
||||
* 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_DES_H |
||||
# define HEADER_DES_H |
||||
|
||||
# include <openssl/opensslconf.h> |
||||
|
||||
# ifndef OPENSSL_NO_DES |
||||
# ifdef __cplusplus |
||||
extern "C" { |
||||
# endif |
||||
# include <openssl/e_os2.h> |
||||
|
||||
typedef unsigned int DES_LONG; |
||||
|
||||
# ifdef OPENSSL_BUILD_SHLIBCRYPTO |
||||
# undef OPENSSL_EXTERN |
||||
# define OPENSSL_EXTERN OPENSSL_EXPORT |
||||
# endif |
||||
|
||||
typedef unsigned char DES_cblock[8]; |
||||
typedef /* const */ unsigned char const_DES_cblock[8]; |
||||
/*
|
||||
* With "const", gcc 2.8.1 on Solaris thinks that DES_cblock * and |
||||
* const_DES_cblock * are incompatible pointer types. |
||||
*/ |
||||
|
||||
typedef struct DES_ks { |
||||
union { |
||||
DES_cblock cblock; |
||||
/*
|
||||
* make sure things are correct size on machines with 8 byte longs |
||||
*/ |
||||
DES_LONG deslong[2]; |
||||
} ks[16]; |
||||
} DES_key_schedule; |
||||
|
||||
# define DES_KEY_SZ (sizeof(DES_cblock)) |
||||
# define DES_SCHEDULE_SZ (sizeof(DES_key_schedule)) |
||||
|
||||
# define DES_ENCRYPT 1 |
||||
# define DES_DECRYPT 0 |
||||
|
||||
# define DES_CBC_MODE 0 |
||||
# define DES_PCBC_MODE 1 |
||||
|
||||
# define DES_ecb2_encrypt(i,o,k1,k2,e) \ |
||||
DES_ecb3_encrypt((i),(o),(k1),(k2),(k1),(e)) |
||||
|
||||
# define DES_ede2_cbc_encrypt(i,o,l,k1,k2,iv,e) \ |
||||
DES_ede3_cbc_encrypt((i),(o),(l),(k1),(k2),(k1),(iv),(e)) |
||||
|
||||
# define DES_ede2_cfb64_encrypt(i,o,l,k1,k2,iv,n,e) \ |
||||
DES_ede3_cfb64_encrypt((i),(o),(l),(k1),(k2),(k1),(iv),(n),(e)) |
||||
|
||||
# define DES_ede2_ofb64_encrypt(i,o,l,k1,k2,iv,n) \ |
||||
DES_ede3_ofb64_encrypt((i),(o),(l),(k1),(k2),(k1),(iv),(n)) |
||||
|
||||
OPENSSL_DECLARE_GLOBAL(int, DES_check_key); /* defaults to false */ |
||||
# define DES_check_key OPENSSL_GLOBAL_REF(DES_check_key) |
||||
|
||||
const char *DES_options(void); |
||||
void DES_ecb3_encrypt(const_DES_cblock *input, DES_cblock *output, |
||||
DES_key_schedule *ks1, DES_key_schedule *ks2, |
||||
DES_key_schedule *ks3, int enc); |
||||
DES_LONG DES_cbc_cksum(const unsigned char *input, DES_cblock *output, |
||||
long length, DES_key_schedule *schedule, |
||||
const_DES_cblock *ivec); |
||||
/* DES_cbc_encrypt does not update the IV! Use DES_ncbc_encrypt instead. */ |
||||
void DES_cbc_encrypt(const unsigned char *input, unsigned char *output, |
||||
long length, DES_key_schedule *schedule, |
||||
DES_cblock *ivec, int enc); |
||||
void DES_ncbc_encrypt(const unsigned char *input, unsigned char *output, |
||||
long length, DES_key_schedule *schedule, |
||||
DES_cblock *ivec, int enc); |
||||
void DES_xcbc_encrypt(const unsigned char *input, unsigned char *output, |
||||
long length, DES_key_schedule *schedule, |
||||
DES_cblock *ivec, const_DES_cblock *inw, |
||||
const_DES_cblock *outw, int enc); |
||||
void DES_cfb_encrypt(const unsigned char *in, unsigned char *out, int numbits, |
||||
long length, DES_key_schedule *schedule, |
||||
DES_cblock *ivec, int enc); |
||||
void DES_ecb_encrypt(const_DES_cblock *input, DES_cblock *output, |
||||
DES_key_schedule *ks, int enc); |
||||
|
||||
/*
|
||||
* This is the DES encryption function that gets called by just about every |
||||
* other DES routine in the library. You should not use this function except |
||||
* to implement 'modes' of DES. I say this because the functions that call |
||||
* this routine do the conversion from 'char *' to long, and this needs to be |
||||
* done to make sure 'non-aligned' memory access do not occur. The |
||||
* characters are loaded 'little endian'. Data is a pointer to 2 unsigned |
||||
* long's and ks is the DES_key_schedule to use. enc, is non zero specifies |
||||
* encryption, zero if decryption. |
||||
*/ |
||||
void DES_encrypt1(DES_LONG *data, DES_key_schedule *ks, int enc); |
||||
|
||||
/*
|
||||
* This functions is the same as DES_encrypt1() except that the DES initial |
||||
* permutation (IP) and final permutation (FP) have been left out. As for |
||||
* DES_encrypt1(), you should not use this function. It is used by the |
||||
* routines in the library that implement triple DES. IP() DES_encrypt2() |
||||
* DES_encrypt2() DES_encrypt2() FP() is the same as DES_encrypt1() |
||||
* DES_encrypt1() DES_encrypt1() except faster :-). |
||||
*/ |
||||
void DES_encrypt2(DES_LONG *data, DES_key_schedule *ks, int enc); |
||||
|
||||
void DES_encrypt3(DES_LONG *data, DES_key_schedule *ks1, |
||||
DES_key_schedule *ks2, DES_key_schedule *ks3); |
||||
void DES_decrypt3(DES_LONG *data, DES_key_schedule *ks1, |
||||
DES_key_schedule *ks2, DES_key_schedule *ks3); |
||||
void DES_ede3_cbc_encrypt(const unsigned char *input, unsigned char *output, |
||||
long length, |
||||
DES_key_schedule *ks1, DES_key_schedule *ks2, |
||||
DES_key_schedule *ks3, DES_cblock *ivec, int enc); |
||||
void DES_ede3_cfb64_encrypt(const unsigned char *in, unsigned char *out, |
||||
long length, DES_key_schedule *ks1, |
||||
DES_key_schedule *ks2, DES_key_schedule *ks3, |
||||
DES_cblock *ivec, int *num, int enc); |
||||
void DES_ede3_cfb_encrypt(const unsigned char *in, unsigned char *out, |
||||
int numbits, long length, DES_key_schedule *ks1, |
||||
DES_key_schedule *ks2, DES_key_schedule *ks3, |
||||
DES_cblock *ivec, int enc); |
||||
void DES_ede3_ofb64_encrypt(const unsigned char *in, unsigned char *out, |
||||
long length, DES_key_schedule *ks1, |
||||
DES_key_schedule *ks2, DES_key_schedule *ks3, |
||||
DES_cblock *ivec, int *num); |
||||
char *DES_fcrypt(const char *buf, const char *salt, char *ret); |
||||
char *DES_crypt(const char *buf, const char *salt); |
||||
void DES_ofb_encrypt(const unsigned char *in, unsigned char *out, int numbits, |
||||
long length, DES_key_schedule *schedule, |
||||
DES_cblock *ivec); |
||||
void DES_pcbc_encrypt(const unsigned char *input, unsigned char *output, |
||||
long length, DES_key_schedule *schedule, |
||||
DES_cblock *ivec, int enc); |
||||
DES_LONG DES_quad_cksum(const unsigned char *input, DES_cblock output[], |
||||
long length, int out_count, DES_cblock *seed); |
||||
int DES_random_key(DES_cblock *ret); |
||||
void DES_set_odd_parity(DES_cblock *key); |
||||
int DES_check_key_parity(const_DES_cblock *key); |
||||
int DES_is_weak_key(const_DES_cblock *key); |
||||
/*
|
||||
* DES_set_key (= set_key = DES_key_sched = key_sched) calls |
||||
* DES_set_key_checked if global variable DES_check_key is set, |
||||
* DES_set_key_unchecked otherwise. |
||||
*/ |
||||
int DES_set_key(const_DES_cblock *key, DES_key_schedule *schedule); |
||||
int DES_key_sched(const_DES_cblock *key, DES_key_schedule *schedule); |
||||
int DES_set_key_checked(const_DES_cblock *key, DES_key_schedule *schedule); |
||||
void DES_set_key_unchecked(const_DES_cblock *key, DES_key_schedule *schedule); |
||||
void DES_string_to_key(const char *str, DES_cblock *key); |
||||
void DES_string_to_2keys(const char *str, DES_cblock *key1, DES_cblock *key2); |
||||
void DES_cfb64_encrypt(const unsigned char *in, unsigned char *out, |
||||
long length, DES_key_schedule *schedule, |
||||
DES_cblock *ivec, int *num, int enc); |
||||
void DES_ofb64_encrypt(const unsigned char *in, unsigned char *out, |
||||
long length, DES_key_schedule *schedule, |
||||
DES_cblock *ivec, int *num); |
||||
|
||||
# define DES_fixup_key_parity DES_set_odd_parity |
||||
|
||||
# ifdef __cplusplus |
||||
} |
||||
# endif |
||||
# endif |
||||
|
||||
#endif |
||||
@ -0,0 +1,343 @@ |
||||
/*
|
||||
* Copyright 1995-2023 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 <openssl/opensslconf.h> |
||||
|
||||
# ifndef OPENSSL_NO_DH |
||||
# include <openssl/e_os2.h> |
||||
# include <openssl/bio.h> |
||||
# include <openssl/asn1.h> |
||||
# include <openssl/ossl_typ.h> |
||||
# if OPENSSL_API_COMPAT < 0x10100000L |
||||
# include <openssl/bn.h> |
||||
# endif |
||||
# include <openssl/dherr.h> |
||||
|
||||
# ifdef __cplusplus |
||||
extern "C" { |
||||
# endif |
||||
|
||||
# ifndef OPENSSL_DH_MAX_MODULUS_BITS |
||||
# define OPENSSL_DH_MAX_MODULUS_BITS 10000 |
||||
# endif |
||||
# ifndef OPENSSL_DH_CHECK_MAX_MODULUS_BITS |
||||
# define OPENSSL_DH_CHECK_MAX_MODULUS_BITS 32768 |
||||
# endif |
||||
|
||||
# define OPENSSL_DH_FIPS_MIN_MODULUS_BITS 1024 |
||||
|
||||
# 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 |
||||
@ -0,0 +1,89 @@ |
||||
/*
|
||||
* Generated by util/mkerr.pl DO NOT EDIT |
||||
* Copyright 1995-2023 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_DHERR_H |
||||
# define HEADER_DHERR_H |
||||
|
||||
# ifndef HEADER_SYMHACKS_H |
||||
# include <openssl/symhacks.h> |
||||
# endif |
||||
|
||||
# include <openssl/opensslconf.h> |
||||
|
||||
# ifndef OPENSSL_NO_DH |
||||
|
||||
# ifdef __cplusplus |
||||
extern "C" |
||||
# endif |
||||
int ERR_load_DH_strings(void); |
||||
|
||||
/*
|
||||
* DH function codes. |
||||
*/ |
||||
# define DH_F_COMPUTE_KEY 102 |
||||
# define DH_F_DHPARAMS_PRINT_FP 101 |
||||
# define DH_F_DH_BUILTIN_GENPARAMS 106 |
||||
# define DH_F_DH_CHECK 126 |
||||
# define DH_F_DH_CHECK_EX 121 |
||||
# define DH_F_DH_CHECK_PARAMS_EX 122 |
||||
# define DH_F_DH_CHECK_PUB_KEY_EX 123 |
||||
# define DH_F_DH_CMS_DECRYPT 114 |
||||
# define DH_F_DH_CMS_SET_PEERKEY 115 |
||||
# define DH_F_DH_CMS_SET_SHARED_INFO 116 |
||||
# define DH_F_DH_METH_DUP 117 |
||||
# define DH_F_DH_METH_NEW 118 |
||||
# define DH_F_DH_METH_SET1_NAME 119 |
||||
# define DH_F_DH_NEW_BY_NID 104 |
||||
# define DH_F_DH_NEW_METHOD 105 |
||||
# define DH_F_DH_PARAM_DECODE 107 |
||||
# define DH_F_DH_PKEY_PUBLIC_CHECK 124 |
||||
# define DH_F_DH_PRIV_DECODE 110 |
||||
# define DH_F_DH_PRIV_ENCODE 111 |
||||
# define DH_F_DH_PUB_DECODE 108 |
||||
# define DH_F_DH_PUB_ENCODE 109 |
||||
# define DH_F_DO_DH_PRINT 100 |
||||
# define DH_F_GENERATE_KEY 103 |
||||
# define DH_F_PKEY_DH_CTRL_STR 120 |
||||
# define DH_F_PKEY_DH_DERIVE 112 |
||||
# define DH_F_PKEY_DH_INIT 125 |
||||
# define DH_F_PKEY_DH_KEYGEN 113 |
||||
|
||||
/*
|
||||
* DH reason codes. |
||||
*/ |
||||
# define DH_R_BAD_GENERATOR 101 |
||||
# define DH_R_BN_DECODE_ERROR 109 |
||||
# define DH_R_BN_ERROR 106 |
||||
# define DH_R_CHECK_INVALID_J_VALUE 115 |
||||
# define DH_R_CHECK_INVALID_Q_VALUE 116 |
||||
# define DH_R_CHECK_PUBKEY_INVALID 122 |
||||
# define DH_R_CHECK_PUBKEY_TOO_LARGE 123 |
||||
# define DH_R_CHECK_PUBKEY_TOO_SMALL 124 |
||||
# define DH_R_CHECK_P_NOT_PRIME 117 |
||||
# define DH_R_CHECK_P_NOT_SAFE_PRIME 118 |
||||
# define DH_R_CHECK_Q_NOT_PRIME 119 |
||||
# define DH_R_DECODE_ERROR 104 |
||||
# define DH_R_INVALID_PARAMETER_NAME 110 |
||||
# define DH_R_INVALID_PARAMETER_NID 114 |
||||
# define DH_R_INVALID_PUBKEY 102 |
||||
# define DH_R_KDF_PARAMETER_ERROR 112 |
||||
# define DH_R_KEYS_NOT_SET 108 |
||||
# define DH_R_MISSING_PUBKEY 125 |
||||
# define DH_R_MODULUS_TOO_LARGE 103 |
||||
# define DH_R_NOT_SUITABLE_GENERATOR 120 |
||||
# define DH_R_NO_PARAMETERS_SET 107 |
||||
# define DH_R_NO_PRIVATE_VALUE 100 |
||||
# define DH_R_PARAMETER_ENCODING_ERROR 105 |
||||
# define DH_R_PEER_KEY_ERROR 111 |
||||
# define DH_R_SHARED_INFO_ERROR 113 |
||||
# define DH_R_UNABLE_TO_CHECK_GENERATOR 121 |
||||
|
||||
# endif |
||||
#endif |
||||
@ -0,0 +1,244 @@ |
||||
/*
|
||||
* 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 <openssl/opensslconf.h> |
||||
|
||||
# ifndef OPENSSL_NO_DSA |
||||
# ifdef __cplusplus |
||||
extern "C" { |
||||
# endif |
||||
# include <openssl/e_os2.h> |
||||
# include <openssl/bio.h> |
||||
# include <openssl/crypto.h> |
||||
# include <openssl/ossl_typ.h> |
||||
# include <openssl/bn.h> |
||||
# if OPENSSL_API_COMPAT < 0x10100000L |
||||
# include <openssl/dh.h> |
||||
# endif |
||||
# include <openssl/dsaerr.h> |
||||
|
||||
# ifndef OPENSSL_DSA_MAX_MODULUS_BITS |
||||
# define OPENSSL_DSA_MAX_MODULUS_BITS 10000 |
||||
# endif |
||||
|
||||
# define OPENSSL_DSA_FIPS_MIN_MODULUS_BITS 1024 |
||||
|
||||
# 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 |
||||
@ -0,0 +1,72 @@ |
||||
/*
|
||||
* 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_DSAERR_H |
||||
# define HEADER_DSAERR_H |
||||
|
||||
# ifndef HEADER_SYMHACKS_H |
||||
# include <openssl/symhacks.h> |
||||
# endif |
||||
|
||||
# include <openssl/opensslconf.h> |
||||
|
||||
# ifndef OPENSSL_NO_DSA |
||||
|
||||
# ifdef __cplusplus |
||||
extern "C" |
||||
# endif |
||||
int ERR_load_DSA_strings(void); |
||||
|
||||
/*
|
||||
* DSA function codes. |
||||
*/ |
||||
# define DSA_F_DSAPARAMS_PRINT 100 |
||||
# define DSA_F_DSAPARAMS_PRINT_FP 101 |
||||
# define DSA_F_DSA_BUILTIN_PARAMGEN 125 |
||||
# define DSA_F_DSA_BUILTIN_PARAMGEN2 126 |
||||
# define DSA_F_DSA_DO_SIGN 112 |
||||
# define DSA_F_DSA_DO_VERIFY 113 |
||||
# define DSA_F_DSA_METH_DUP 127 |
||||
# define DSA_F_DSA_METH_NEW 128 |
||||
# define DSA_F_DSA_METH_SET1_NAME 129 |
||||
# define DSA_F_DSA_NEW_METHOD 103 |
||||
# define DSA_F_DSA_PARAM_DECODE 119 |
||||
# define DSA_F_DSA_PRINT_FP 105 |
||||
# define DSA_F_DSA_PRIV_DECODE 115 |
||||
# define DSA_F_DSA_PRIV_ENCODE 116 |
||||
# define DSA_F_DSA_PUB_DECODE 117 |
||||
# define DSA_F_DSA_PUB_ENCODE 118 |
||||
# define DSA_F_DSA_SIGN 106 |
||||
# define DSA_F_DSA_SIGN_SETUP 107 |
||||
# define DSA_F_DSA_SIG_NEW 102 |
||||
# define DSA_F_OLD_DSA_PRIV_DECODE 122 |
||||
# define DSA_F_PKEY_DSA_CTRL 120 |
||||
# define DSA_F_PKEY_DSA_CTRL_STR 104 |
||||
# define DSA_F_PKEY_DSA_KEYGEN 121 |
||||
|
||||
/*
|
||||
* DSA reason codes. |
||||
*/ |
||||
# define DSA_R_BAD_Q_VALUE 102 |
||||
# define DSA_R_BN_DECODE_ERROR 108 |
||||
# define DSA_R_BN_ERROR 109 |
||||
# define DSA_R_DECODE_ERROR 104 |
||||
# define DSA_R_INVALID_DIGEST_TYPE 106 |
||||
# define DSA_R_INVALID_PARAMETERS 112 |
||||
# define DSA_R_MISSING_PARAMETERS 101 |
||||
# define DSA_R_MISSING_PRIVATE_KEY 111 |
||||
# define DSA_R_MODULUS_TOO_LARGE 103 |
||||
# define DSA_R_NO_PARAMETERS_SET 107 |
||||
# define DSA_R_PARAMETER_ENCODING_ERROR 105 |
||||
# define DSA_R_Q_NOT_PRIME 113 |
||||
# define DSA_R_SEED_LEN_SMALL 110 |
||||
|
||||
# endif |
||||
#endif |
||||
@ -0,0 +1,55 @@ |
||||
/*
|
||||
* Copyright 2005-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_DTLS1_H |
||||
# define HEADER_DTLS1_H |
||||
|
||||
#ifdef __cplusplus |
||||
extern "C" { |
||||
#endif |
||||
|
||||
# define DTLS1_VERSION 0xFEFF |
||||
# define DTLS1_2_VERSION 0xFEFD |
||||
# define DTLS_MIN_VERSION DTLS1_VERSION |
||||
# define DTLS_MAX_VERSION DTLS1_2_VERSION |
||||
# define DTLS1_VERSION_MAJOR 0xFE |
||||
|
||||
# define DTLS1_BAD_VER 0x0100 |
||||
|
||||
/* Special value for method supporting multiple versions */ |
||||
# define DTLS_ANY_VERSION 0x1FFFF |
||||
|
||||
/* lengths of messages */ |
||||
/*
|
||||
* Actually the max cookie length in DTLS is 255. But we can't change this now |
||||
* due to compatibility concerns. |
||||
*/ |
||||
# define DTLS1_COOKIE_LENGTH 256 |
||||
|
||||
# define DTLS1_RT_HEADER_LENGTH 13 |
||||
|
||||
# define DTLS1_HM_HEADER_LENGTH 12 |
||||
|
||||
# define DTLS1_HM_BAD_FRAGMENT -2 |
||||
# define DTLS1_HM_FRAGMENT_RETRY -3 |
||||
|
||||
# define DTLS1_CCS_HEADER_LENGTH 1 |
||||
|
||||
# define DTLS1_AL_HEADER_LENGTH 2 |
||||
|
||||
/* Timeout multipliers */ |
||||
# define DTLS1_TMO_READ_COUNT 2 |
||||
# define DTLS1_TMO_WRITE_COUNT 2 |
||||
|
||||
# define DTLS1_TMO_ALERT_COUNT 12 |
||||
|
||||
#ifdef __cplusplus |
||||
} |
||||
#endif |
||||
#endif |
||||
@ -0,0 +1,301 @@ |
||||
/*
|
||||
* 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 <openssl/opensslconf.h> |
||||
|
||||
#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) |
||||
# 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 <io.h> |
||||
# 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) |
||||
# 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(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || \ |
||||
defined(__osf__) || defined(__sgi) || defined(__hpux) || \
|
||||
defined(OPENSSL_SYS_VMS) || defined (__OpenBSD__) |
||||
# include <inttypes.h> |
||||
# 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; |
||||
# else |
||||
# include <stdint.h> |
||||
# 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 |
||||
@ -0,0 +1,33 @@ |
||||
/*
|
||||
* Copyright 1999-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_EBCDIC_H |
||||
# define HEADER_EBCDIC_H |
||||
|
||||
# include <stdlib.h> |
||||
|
||||
#ifdef __cplusplus |
||||
extern "C" { |
||||
#endif |
||||
|
||||
/* Avoid name clashes with other applications */ |
||||
# define os_toascii _openssl_os_toascii |
||||
# define os_toebcdic _openssl_os_toebcdic |
||||
# define ebcdic2ascii _openssl_ebcdic2ascii |
||||
# define ascii2ebcdic _openssl_ascii2ebcdic |
||||
|
||||
extern const unsigned char os_toascii[256]; |
||||
extern const unsigned char os_toebcdic[256]; |
||||
void *ebcdic2ascii(void *dest, const void *srce, size_t count); |
||||
void *ascii2ebcdic(void *dest, const void *srce, size_t count); |
||||
|
||||
#ifdef __cplusplus |
||||
} |
||||
#endif |
||||
#endif |
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,10 @@ |
||||
/*
|
||||
* 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
|
||||
*/ |
||||
|
||||
#include <openssl/ec.h> |
||||
@ -0,0 +1,10 @@ |
||||
/*
|
||||
* 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
|
||||
*/ |
||||
|
||||
#include <openssl/ec.h> |
||||
@ -0,0 +1,276 @@ |
||||
/*
|
||||
* 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 <openssl/symhacks.h> |
||||
# endif |
||||
|
||||
# include <openssl/opensslconf.h> |
||||
|
||||
# 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_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_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 |
||||
|
||||
# endif |
||||
#endif |
||||
@ -0,0 +1,752 @@ |
||||
/*
|
||||
* Copyright 2000-2022 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_ENGINE_H |
||||
# define HEADER_ENGINE_H |
||||
|
||||
# include <openssl/opensslconf.h> |
||||
|
||||
# ifndef OPENSSL_NO_ENGINE |
||||
# if OPENSSL_API_COMPAT < 0x10100000L |
||||
# include <openssl/bn.h> |
||||
# include <openssl/rsa.h> |
||||
# include <openssl/dsa.h> |
||||
# include <openssl/dh.h> |
||||
# include <openssl/ec.h> |
||||
# include <openssl/rand.h> |
||||
# include <openssl/ui.h> |
||||
# include <openssl/err.h> |
||||
# endif |
||||
# include <openssl/ossl_typ.h> |
||||
# include <openssl/symhacks.h> |
||||
# include <openssl/x509.h> |
||||
# include <openssl/engineerr.h> |
||||
# ifdef __cplusplus |
||||
extern "C" { |
||||
# endif |
||||
|
||||
/*
|
||||
* These flags are used to control combinations of algorithm (methods) by |
||||
* bitwise "OR"ing. |
||||
*/ |
||||
# define ENGINE_METHOD_RSA (unsigned int)0x0001 |
||||
# define ENGINE_METHOD_DSA (unsigned int)0x0002 |
||||
# define ENGINE_METHOD_DH (unsigned int)0x0004 |
||||
# define ENGINE_METHOD_RAND (unsigned int)0x0008 |
||||
# define ENGINE_METHOD_CIPHERS (unsigned int)0x0040 |
||||
# define ENGINE_METHOD_DIGESTS (unsigned int)0x0080 |
||||
# define ENGINE_METHOD_PKEY_METHS (unsigned int)0x0200 |
||||
# define ENGINE_METHOD_PKEY_ASN1_METHS (unsigned int)0x0400 |
||||
# define ENGINE_METHOD_EC (unsigned int)0x0800 |
||||
/* Obvious all-or-nothing cases. */ |
||||
# define ENGINE_METHOD_ALL (unsigned int)0xFFFF |
||||
# define ENGINE_METHOD_NONE (unsigned int)0x0000 |
||||
|
||||
/*
|
||||
* This(ese) flag(s) controls behaviour of the ENGINE_TABLE mechanism used |
||||
* internally to control registration of ENGINE implementations, and can be |
||||
* set by ENGINE_set_table_flags(). The "NOINIT" flag prevents attempts to |
||||
* initialise registered ENGINEs if they are not already initialised. |
||||
*/ |
||||
# define ENGINE_TABLE_FLAG_NOINIT (unsigned int)0x0001 |
||||
|
||||
/* ENGINE flags that can be set by ENGINE_set_flags(). */ |
||||
/* Not used */ |
||||
/* #define ENGINE_FLAGS_MALLOCED 0x0001 */ |
||||
|
||||
/*
|
||||
* This flag is for ENGINEs that wish to handle the various 'CMD'-related |
||||
* control commands on their own. Without this flag, ENGINE_ctrl() handles |
||||
* these control commands on behalf of the ENGINE using their "cmd_defns" |
||||
* data. |
||||
*/ |
||||
# define ENGINE_FLAGS_MANUAL_CMD_CTRL (int)0x0002 |
||||
|
||||
/*
|
||||
* This flag is for ENGINEs who return new duplicate structures when found |
||||
* via "ENGINE_by_id()". When an ENGINE must store state (eg. if |
||||
* ENGINE_ctrl() commands are called in sequence as part of some stateful |
||||
* process like key-generation setup and execution), it can set this flag - |
||||
* then each attempt to obtain the ENGINE will result in it being copied into |
||||
* a new structure. Normally, ENGINEs don't declare this flag so |
||||
* ENGINE_by_id() just increments the existing ENGINE's structural reference |
||||
* count. |
||||
*/ |
||||
# define ENGINE_FLAGS_BY_ID_COPY (int)0x0004 |
||||
|
||||
/*
|
||||
* This flag if for an ENGINE that does not want its methods registered as |
||||
* part of ENGINE_register_all_complete() for example if the methods are not |
||||
* usable as default methods. |
||||
*/ |
||||
|
||||
# define ENGINE_FLAGS_NO_REGISTER_ALL (int)0x0008 |
||||
|
||||
/*
|
||||
* ENGINEs can support their own command types, and these flags are used in |
||||
* ENGINE_CTRL_GET_CMD_FLAGS to indicate to the caller what kind of input |
||||
* each command expects. Currently only numeric and string input is |
||||
* supported. If a control command supports none of the _NUMERIC, _STRING, or |
||||
* _NO_INPUT options, then it is regarded as an "internal" control command - |
||||
* and not for use in config setting situations. As such, they're not |
||||
* available to the ENGINE_ctrl_cmd_string() function, only raw ENGINE_ctrl() |
||||
* access. Changes to this list of 'command types' should be reflected |
||||
* carefully in ENGINE_cmd_is_executable() and ENGINE_ctrl_cmd_string(). |
||||
*/ |
||||
|
||||
/* accepts a 'long' input value (3rd parameter to ENGINE_ctrl) */ |
||||
# define ENGINE_CMD_FLAG_NUMERIC (unsigned int)0x0001 |
||||
/*
|
||||
* accepts string input (cast from 'void*' to 'const char *', 4th parameter |
||||
* to ENGINE_ctrl) |
||||
*/ |
||||
# define ENGINE_CMD_FLAG_STRING (unsigned int)0x0002 |
||||
/*
|
||||
* Indicates that the control command takes *no* input. Ie. the control |
||||
* command is unparameterised. |
||||
*/ |
||||
# define ENGINE_CMD_FLAG_NO_INPUT (unsigned int)0x0004 |
||||
/*
|
||||
* Indicates that the control command is internal. This control command won't |
||||
* be shown in any output, and is only usable through the ENGINE_ctrl_cmd() |
||||
* function. |
||||
*/ |
||||
# define ENGINE_CMD_FLAG_INTERNAL (unsigned int)0x0008 |
||||
|
||||
/*
|
||||
* NB: These 3 control commands are deprecated and should not be used. |
||||
* ENGINEs relying on these commands should compile conditional support for |
||||
* compatibility (eg. if these symbols are defined) but should also migrate |
||||
* the same functionality to their own ENGINE-specific control functions that |
||||
* can be "discovered" by calling applications. The fact these control |
||||
* commands wouldn't be "executable" (ie. usable by text-based config) |
||||
* doesn't change the fact that application code can find and use them |
||||
* without requiring per-ENGINE hacking. |
||||
*/ |
||||
|
||||
/*
|
||||
* These flags are used to tell the ctrl function what should be done. All |
||||
* command numbers are shared between all engines, even if some don't make |
||||
* sense to some engines. In such a case, they do nothing but return the |
||||
* error ENGINE_R_CTRL_COMMAND_NOT_IMPLEMENTED. |
||||
*/ |
||||
# define ENGINE_CTRL_SET_LOGSTREAM 1 |
||||
# define ENGINE_CTRL_SET_PASSWORD_CALLBACK 2 |
||||
# define ENGINE_CTRL_HUP 3/* Close and reinitialise |
||||
* any handles/connections |
||||
* etc. */ |
||||
# define ENGINE_CTRL_SET_USER_INTERFACE 4/* Alternative to callback */ |
||||
# define ENGINE_CTRL_SET_CALLBACK_DATA 5/* User-specific data, used |
||||
* when calling the password |
||||
* callback and the user |
||||
* interface */ |
||||
# define ENGINE_CTRL_LOAD_CONFIGURATION 6/* Load a configuration, |
||||
* given a string that |
||||
* represents a file name |
||||
* or so */ |
||||
# define ENGINE_CTRL_LOAD_SECTION 7/* Load data from a given |
||||
* section in the already |
||||
* loaded configuration */ |
||||
|
||||
/*
|
||||
* These control commands allow an application to deal with an arbitrary |
||||
* engine in a dynamic way. Warn: Negative return values indicate errors FOR |
||||
* THESE COMMANDS because zero is used to indicate 'end-of-list'. Other |
||||
* commands, including ENGINE-specific command types, return zero for an |
||||
* error. An ENGINE can choose to implement these ctrl functions, and can |
||||
* internally manage things however it chooses - it does so by setting the |
||||
* ENGINE_FLAGS_MANUAL_CMD_CTRL flag (using ENGINE_set_flags()). Otherwise |
||||
* the ENGINE_ctrl() code handles this on the ENGINE's behalf using the |
||||
* cmd_defns data (set using ENGINE_set_cmd_defns()). This means an ENGINE's |
||||
* ctrl() handler need only implement its own commands - the above "meta" |
||||
* commands will be taken care of. |
||||
*/ |
||||
|
||||
/*
|
||||
* Returns non-zero if the supplied ENGINE has a ctrl() handler. If "not", |
||||
* then all the remaining control commands will return failure, so it is |
||||
* worth checking this first if the caller is trying to "discover" the |
||||
* engine's capabilities and doesn't want errors generated unnecessarily. |
||||
*/ |
||||
# define ENGINE_CTRL_HAS_CTRL_FUNCTION 10 |
||||
/*
|
||||
* Returns a positive command number for the first command supported by the |
||||
* engine. Returns zero if no ctrl commands are supported. |
||||
*/ |
||||
# define ENGINE_CTRL_GET_FIRST_CMD_TYPE 11 |
||||
/*
|
||||
* The 'long' argument specifies a command implemented by the engine, and the |
||||
* return value is the next command supported, or zero if there are no more. |
||||
*/ |
||||
# define ENGINE_CTRL_GET_NEXT_CMD_TYPE 12 |
||||
/*
|
||||
* The 'void*' argument is a command name (cast from 'const char *'), and the |
||||
* return value is the command that corresponds to it. |
||||
*/ |
||||
# define ENGINE_CTRL_GET_CMD_FROM_NAME 13 |
||||
/*
|
||||
* The next two allow a command to be converted into its corresponding string |
||||
* form. In each case, the 'long' argument supplies the command. In the |
||||
* NAME_LEN case, the return value is the length of the command name (not |
||||
* counting a trailing EOL). In the NAME case, the 'void*' argument must be a |
||||
* string buffer large enough, and it will be populated with the name of the |
||||
* command (WITH a trailing EOL). |
||||
*/ |
||||
# define ENGINE_CTRL_GET_NAME_LEN_FROM_CMD 14 |
||||
# define ENGINE_CTRL_GET_NAME_FROM_CMD 15 |
||||
/* The next two are similar but give a "short description" of a command. */ |
||||
# define ENGINE_CTRL_GET_DESC_LEN_FROM_CMD 16 |
||||
# define ENGINE_CTRL_GET_DESC_FROM_CMD 17 |
||||
/*
|
||||
* With this command, the return value is the OR'd combination of |
||||
* ENGINE_CMD_FLAG_*** values that indicate what kind of input a given |
||||
* engine-specific ctrl command expects. |
||||
*/ |
||||
# define ENGINE_CTRL_GET_CMD_FLAGS 18 |
||||
|
||||
/*
|
||||
* ENGINE implementations should start the numbering of their own control |
||||
* commands from this value. (ie. ENGINE_CMD_BASE, ENGINE_CMD_BASE + 1, etc). |
||||
*/ |
||||
# define ENGINE_CMD_BASE 200 |
||||
|
||||
/*
|
||||
* NB: These 2 nCipher "chil" control commands are deprecated, and their |
||||
* functionality is now available through ENGINE-specific control commands |
||||
* (exposed through the above-mentioned 'CMD'-handling). Code using these 2 |
||||
* commands should be migrated to the more general command handling before |
||||
* these are removed. |
||||
*/ |
||||
|
||||
/* Flags specific to the nCipher "chil" engine */ |
||||
# define ENGINE_CTRL_CHIL_SET_FORKCHECK 100 |
||||
/*
|
||||
* Depending on the value of the (long)i argument, this sets or |
||||
* unsets the SimpleForkCheck flag in the CHIL API to enable or |
||||
* disable checking and workarounds for applications that fork(). |
||||
*/ |
||||
# define ENGINE_CTRL_CHIL_NO_LOCKING 101 |
||||
/*
|
||||
* This prevents the initialisation function from providing mutex |
||||
* callbacks to the nCipher library. |
||||
*/ |
||||
|
||||
/*
|
||||
* If an ENGINE supports its own specific control commands and wishes the |
||||
* framework to handle the above 'ENGINE_CMD_***'-manipulation commands on |
||||
* its behalf, it should supply a null-terminated array of ENGINE_CMD_DEFN |
||||
* entries to ENGINE_set_cmd_defns(). It should also implement a ctrl() |
||||
* handler that supports the stated commands (ie. the "cmd_num" entries as |
||||
* described by the array). NB: The array must be ordered in increasing order |
||||
* of cmd_num. "null-terminated" means that the last ENGINE_CMD_DEFN element |
||||
* has cmd_num set to zero and/or cmd_name set to NULL. |
||||
*/ |
||||
typedef struct ENGINE_CMD_DEFN_st { |
||||
unsigned int cmd_num; /* The command number */ |
||||
const char *cmd_name; /* The command name itself */ |
||||
const char *cmd_desc; /* A short description of the command */ |
||||
unsigned int cmd_flags; /* The input the command expects */ |
||||
} ENGINE_CMD_DEFN; |
||||
|
||||
/* Generic function pointer */ |
||||
typedef int (*ENGINE_GEN_FUNC_PTR) (void); |
||||
/* Generic function pointer taking no arguments */ |
||||
typedef int (*ENGINE_GEN_INT_FUNC_PTR) (ENGINE *); |
||||
/* Specific control function pointer */ |
||||
typedef int (*ENGINE_CTRL_FUNC_PTR) (ENGINE *, int, long, void *, |
||||
void (*f) (void)); |
||||
/* Generic load_key function pointer */ |
||||
typedef EVP_PKEY *(*ENGINE_LOAD_KEY_PTR)(ENGINE *, const char *, |
||||
UI_METHOD *ui_method, |
||||
void *callback_data); |
||||
typedef int (*ENGINE_SSL_CLIENT_CERT_PTR) (ENGINE *, SSL *ssl, |
||||
STACK_OF(X509_NAME) *ca_dn, |
||||
X509 **pcert, EVP_PKEY **pkey, |
||||
STACK_OF(X509) **pother, |
||||
UI_METHOD *ui_method, |
||||
void *callback_data); |
||||
/*-
|
||||
* These callback types are for an ENGINE's handler for cipher and digest logic. |
||||
* These handlers have these prototypes; |
||||
* int foo(ENGINE *e, const EVP_CIPHER **cipher, const int **nids, int nid); |
||||
* int foo(ENGINE *e, const EVP_MD **digest, const int **nids, int nid); |
||||
* Looking at how to implement these handlers in the case of cipher support, if |
||||
* the framework wants the EVP_CIPHER for 'nid', it will call; |
||||
* foo(e, &p_evp_cipher, NULL, nid); (return zero for failure) |
||||
* If the framework wants a list of supported 'nid's, it will call; |
||||
* foo(e, NULL, &p_nids, 0); (returns number of 'nids' or -1 for error) |
||||
*/ |
||||
/*
|
||||
* Returns to a pointer to the array of supported cipher 'nid's. If the |
||||
* second parameter is non-NULL it is set to the size of the returned array. |
||||
*/ |
||||
typedef int (*ENGINE_CIPHERS_PTR) (ENGINE *, const EVP_CIPHER **, |
||||
const int **, int); |
||||
typedef int (*ENGINE_DIGESTS_PTR) (ENGINE *, const EVP_MD **, const int **, |
||||
int); |
||||
typedef int (*ENGINE_PKEY_METHS_PTR) (ENGINE *, EVP_PKEY_METHOD **, |
||||
const int **, int); |
||||
typedef int (*ENGINE_PKEY_ASN1_METHS_PTR) (ENGINE *, EVP_PKEY_ASN1_METHOD **, |
||||
const int **, int); |
||||
/*
|
||||
* STRUCTURE functions ... all of these functions deal with pointers to |
||||
* ENGINE structures where the pointers have a "structural reference". This |
||||
* means that their reference is to allowed access to the structure but it |
||||
* does not imply that the structure is functional. To simply increment or |
||||
* decrement the structural reference count, use ENGINE_by_id and |
||||
* ENGINE_free. NB: This is not required when iterating using ENGINE_get_next |
||||
* as it will automatically decrement the structural reference count of the |
||||
* "current" ENGINE and increment the structural reference count of the |
||||
* ENGINE it returns (unless it is NULL). |
||||
*/ |
||||
|
||||
/* Get the first/last "ENGINE" type available. */ |
||||
ENGINE *ENGINE_get_first(void); |
||||
ENGINE *ENGINE_get_last(void); |
||||
/* Iterate to the next/previous "ENGINE" type (NULL = end of the list). */ |
||||
ENGINE *ENGINE_get_next(ENGINE *e); |
||||
ENGINE *ENGINE_get_prev(ENGINE *e); |
||||
/* Add another "ENGINE" type into the array. */ |
||||
int ENGINE_add(ENGINE *e); |
||||
/* Remove an existing "ENGINE" type from the array. */ |
||||
int ENGINE_remove(ENGINE *e); |
||||
/* Retrieve an engine from the list by its unique "id" value. */ |
||||
ENGINE *ENGINE_by_id(const char *id); |
||||
|
||||
#if OPENSSL_API_COMPAT < 0x10100000L |
||||
# define ENGINE_load_openssl() \ |
||||
OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_OPENSSL, NULL) |
||||
# define ENGINE_load_dynamic() \ |
||||
OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_DYNAMIC, NULL) |
||||
# ifndef OPENSSL_NO_STATIC_ENGINE |
||||
# define ENGINE_load_padlock() \ |
||||
OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_PADLOCK, NULL) |
||||
# define ENGINE_load_capi() \ |
||||
OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_CAPI, NULL) |
||||
# define ENGINE_load_afalg() \ |
||||
OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_AFALG, NULL) |
||||
# endif |
||||
# define ENGINE_load_cryptodev() \ |
||||
OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_CRYPTODEV, NULL) |
||||
# define ENGINE_load_rdrand() \ |
||||
OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_RDRAND, NULL) |
||||
#endif |
||||
void ENGINE_load_builtin_engines(void); |
||||
|
||||
/*
|
||||
* Get and set global flags (ENGINE_TABLE_FLAG_***) for the implementation |
||||
* "registry" handling. |
||||
*/ |
||||
unsigned int ENGINE_get_table_flags(void); |
||||
void ENGINE_set_table_flags(unsigned int flags); |
||||
|
||||
/*- Manage registration of ENGINEs per "table". For each type, there are 3
|
||||
* functions; |
||||
* ENGINE_register_***(e) - registers the implementation from 'e' (if it has one) |
||||
* ENGINE_unregister_***(e) - unregister the implementation from 'e' |
||||
* ENGINE_register_all_***() - call ENGINE_register_***() for each 'e' in the list |
||||
* Cleanup is automatically registered from each table when required. |
||||
*/ |
||||
|
||||
int ENGINE_register_RSA(ENGINE *e); |
||||
void ENGINE_unregister_RSA(ENGINE *e); |
||||
void ENGINE_register_all_RSA(void); |
||||
|
||||
int ENGINE_register_DSA(ENGINE *e); |
||||
void ENGINE_unregister_DSA(ENGINE *e); |
||||
void ENGINE_register_all_DSA(void); |
||||
|
||||
int ENGINE_register_EC(ENGINE *e); |
||||
void ENGINE_unregister_EC(ENGINE *e); |
||||
void ENGINE_register_all_EC(void); |
||||
|
||||
int ENGINE_register_DH(ENGINE *e); |
||||
void ENGINE_unregister_DH(ENGINE *e); |
||||
void ENGINE_register_all_DH(void); |
||||
|
||||
int ENGINE_register_RAND(ENGINE *e); |
||||
void ENGINE_unregister_RAND(ENGINE *e); |
||||
void ENGINE_register_all_RAND(void); |
||||
|
||||
int ENGINE_register_ciphers(ENGINE *e); |
||||
void ENGINE_unregister_ciphers(ENGINE *e); |
||||
void ENGINE_register_all_ciphers(void); |
||||
|
||||
int ENGINE_register_digests(ENGINE *e); |
||||
void ENGINE_unregister_digests(ENGINE *e); |
||||
void ENGINE_register_all_digests(void); |
||||
|
||||
int ENGINE_register_pkey_meths(ENGINE *e); |
||||
void ENGINE_unregister_pkey_meths(ENGINE *e); |
||||
void ENGINE_register_all_pkey_meths(void); |
||||
|
||||
int ENGINE_register_pkey_asn1_meths(ENGINE *e); |
||||
void ENGINE_unregister_pkey_asn1_meths(ENGINE *e); |
||||
void ENGINE_register_all_pkey_asn1_meths(void); |
||||
|
||||
/*
|
||||
* These functions register all support from the above categories. Note, use |
||||
* of these functions can result in static linkage of code your application |
||||
* may not need. If you only need a subset of functionality, consider using |
||||
* more selective initialisation. |
||||
*/ |
||||
int ENGINE_register_complete(ENGINE *e); |
||||
int ENGINE_register_all_complete(void); |
||||
|
||||
/*
|
||||
* Send parameterised control commands to the engine. The possibilities to |
||||
* send down an integer, a pointer to data or a function pointer are |
||||
* provided. Any of the parameters may or may not be NULL, depending on the |
||||
* command number. In actuality, this function only requires a structural |
||||
* (rather than functional) reference to an engine, but many control commands |
||||
* may require the engine be functional. The caller should be aware of trying |
||||
* commands that require an operational ENGINE, and only use functional |
||||
* references in such situations. |
||||
*/ |
||||
int ENGINE_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f) (void)); |
||||
|
||||
/*
|
||||
* This function tests if an ENGINE-specific command is usable as a |
||||
* "setting". Eg. in an application's config file that gets processed through |
||||
* ENGINE_ctrl_cmd_string(). If this returns zero, it is not available to |
||||
* ENGINE_ctrl_cmd_string(), only ENGINE_ctrl(). |
||||
*/ |
||||
int ENGINE_cmd_is_executable(ENGINE *e, int cmd); |
||||
|
||||
/*
|
||||
* This function works like ENGINE_ctrl() with the exception of taking a |
||||
* command name instead of a command number, and can handle optional |
||||
* commands. See the comment on ENGINE_ctrl_cmd_string() for an explanation |
||||
* on how to use the cmd_name and cmd_optional. |
||||
*/ |
||||
int ENGINE_ctrl_cmd(ENGINE *e, const char *cmd_name, |
||||
long i, void *p, void (*f) (void), int cmd_optional); |
||||
|
||||
/*
|
||||
* This function passes a command-name and argument to an ENGINE. The |
||||
* cmd_name is converted to a command number and the control command is |
||||
* called using 'arg' as an argument (unless the ENGINE doesn't support such |
||||
* a command, in which case no control command is called). The command is |
||||
* checked for input flags, and if necessary the argument will be converted |
||||
* to a numeric value. If cmd_optional is non-zero, then if the ENGINE |
||||
* doesn't support the given cmd_name the return value will be success |
||||
* anyway. This function is intended for applications to use so that users |
||||
* (or config files) can supply engine-specific config data to the ENGINE at |
||||
* run-time to control behaviour of specific engines. As such, it shouldn't |
||||
* be used for calling ENGINE_ctrl() functions that return data, deal with |
||||
* binary data, or that are otherwise supposed to be used directly through |
||||
* ENGINE_ctrl() in application code. Any "return" data from an ENGINE_ctrl() |
||||
* operation in this function will be lost - the return value is interpreted |
||||
* as failure if the return value is zero, success otherwise, and this |
||||
* function returns a boolean value as a result. In other words, vendors of |
||||
* 'ENGINE'-enabled devices should write ENGINE implementations with |
||||
* parameterisations that work in this scheme, so that compliant ENGINE-based |
||||
* applications can work consistently with the same configuration for the |
||||
* same ENGINE-enabled devices, across applications. |
||||
*/ |
||||
int ENGINE_ctrl_cmd_string(ENGINE *e, const char *cmd_name, const char *arg, |
||||
int cmd_optional); |
||||
|
||||
/*
|
||||
* These functions are useful for manufacturing new ENGINE structures. They |
||||
* don't address reference counting at all - one uses them to populate an |
||||
* ENGINE structure with personalised implementations of things prior to |
||||
* using it directly or adding it to the builtin ENGINE list in OpenSSL. |
||||
* These are also here so that the ENGINE structure doesn't have to be |
||||
* exposed and break binary compatibility! |
||||
*/ |
||||
ENGINE *ENGINE_new(void); |
||||
int ENGINE_free(ENGINE *e); |
||||
int ENGINE_up_ref(ENGINE *e); |
||||
int ENGINE_set_id(ENGINE *e, const char *id); |
||||
int ENGINE_set_name(ENGINE *e, const char *name); |
||||
int ENGINE_set_RSA(ENGINE *e, const RSA_METHOD *rsa_meth); |
||||
int ENGINE_set_DSA(ENGINE *e, const DSA_METHOD *dsa_meth); |
||||
int ENGINE_set_EC(ENGINE *e, const EC_KEY_METHOD *ecdsa_meth); |
||||
int ENGINE_set_DH(ENGINE *e, const DH_METHOD *dh_meth); |
||||
int ENGINE_set_RAND(ENGINE *e, const RAND_METHOD *rand_meth); |
||||
int ENGINE_set_destroy_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR destroy_f); |
||||
int ENGINE_set_init_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR init_f); |
||||
int ENGINE_set_finish_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR finish_f); |
||||
int ENGINE_set_ctrl_function(ENGINE *e, ENGINE_CTRL_FUNC_PTR ctrl_f); |
||||
int ENGINE_set_load_privkey_function(ENGINE *e, |
||||
ENGINE_LOAD_KEY_PTR loadpriv_f); |
||||
int ENGINE_set_load_pubkey_function(ENGINE *e, ENGINE_LOAD_KEY_PTR loadpub_f); |
||||
int ENGINE_set_load_ssl_client_cert_function(ENGINE *e, |
||||
ENGINE_SSL_CLIENT_CERT_PTR |
||||
loadssl_f); |
||||
int ENGINE_set_ciphers(ENGINE *e, ENGINE_CIPHERS_PTR f); |
||||
int ENGINE_set_digests(ENGINE *e, ENGINE_DIGESTS_PTR f); |
||||
int ENGINE_set_pkey_meths(ENGINE *e, ENGINE_PKEY_METHS_PTR f); |
||||
int ENGINE_set_pkey_asn1_meths(ENGINE *e, ENGINE_PKEY_ASN1_METHS_PTR f); |
||||
int ENGINE_set_flags(ENGINE *e, int flags); |
||||
int ENGINE_set_cmd_defns(ENGINE *e, const ENGINE_CMD_DEFN *defns); |
||||
/* These functions allow control over any per-structure ENGINE data. */ |
||||
#define ENGINE_get_ex_new_index(l, p, newf, dupf, freef) \ |
||||
CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_ENGINE, l, p, newf, dupf, freef) |
||||
int ENGINE_set_ex_data(ENGINE *e, int idx, void *arg); |
||||
void *ENGINE_get_ex_data(const ENGINE *e, int idx); |
||||
|
||||
#if OPENSSL_API_COMPAT < 0x10100000L |
||||
/*
|
||||
* This function previously cleaned up anything that needs it. Auto-deinit will |
||||
* now take care of it so it is no longer required to call this function. |
||||
*/ |
||||
# define ENGINE_cleanup() while(0) continue |
||||
#endif |
||||
|
||||
/*
|
||||
* These return values from within the ENGINE structure. These can be useful |
||||
* with functional references as well as structural references - it depends |
||||
* which you obtained. Using the result for functional purposes if you only |
||||
* obtained a structural reference may be problematic! |
||||
*/ |
||||
const char *ENGINE_get_id(const ENGINE *e); |
||||
const char *ENGINE_get_name(const ENGINE *e); |
||||
const RSA_METHOD *ENGINE_get_RSA(const ENGINE *e); |
||||
const DSA_METHOD *ENGINE_get_DSA(const ENGINE *e); |
||||
const EC_KEY_METHOD *ENGINE_get_EC(const ENGINE *e); |
||||
const DH_METHOD *ENGINE_get_DH(const ENGINE *e); |
||||
const RAND_METHOD *ENGINE_get_RAND(const ENGINE *e); |
||||
ENGINE_GEN_INT_FUNC_PTR ENGINE_get_destroy_function(const ENGINE *e); |
||||
ENGINE_GEN_INT_FUNC_PTR ENGINE_get_init_function(const ENGINE *e); |
||||
ENGINE_GEN_INT_FUNC_PTR ENGINE_get_finish_function(const ENGINE *e); |
||||
ENGINE_CTRL_FUNC_PTR ENGINE_get_ctrl_function(const ENGINE *e); |
||||
ENGINE_LOAD_KEY_PTR ENGINE_get_load_privkey_function(const ENGINE *e); |
||||
ENGINE_LOAD_KEY_PTR ENGINE_get_load_pubkey_function(const ENGINE *e); |
||||
ENGINE_SSL_CLIENT_CERT_PTR ENGINE_get_ssl_client_cert_function(const ENGINE |
||||
*e); |
||||
ENGINE_CIPHERS_PTR ENGINE_get_ciphers(const ENGINE *e); |
||||
ENGINE_DIGESTS_PTR ENGINE_get_digests(const ENGINE *e); |
||||
ENGINE_PKEY_METHS_PTR ENGINE_get_pkey_meths(const ENGINE *e); |
||||
ENGINE_PKEY_ASN1_METHS_PTR ENGINE_get_pkey_asn1_meths(const ENGINE *e); |
||||
const EVP_CIPHER *ENGINE_get_cipher(ENGINE *e, int nid); |
||||
const EVP_MD *ENGINE_get_digest(ENGINE *e, int nid); |
||||
const EVP_PKEY_METHOD *ENGINE_get_pkey_meth(ENGINE *e, int nid); |
||||
const EVP_PKEY_ASN1_METHOD *ENGINE_get_pkey_asn1_meth(ENGINE *e, int nid); |
||||
const EVP_PKEY_ASN1_METHOD *ENGINE_get_pkey_asn1_meth_str(ENGINE *e, |
||||
const char *str, |
||||
int len); |
||||
const EVP_PKEY_ASN1_METHOD *ENGINE_pkey_asn1_find_str(ENGINE **pe, |
||||
const char *str, |
||||
int len); |
||||
const ENGINE_CMD_DEFN *ENGINE_get_cmd_defns(const ENGINE *e); |
||||
int ENGINE_get_flags(const ENGINE *e); |
||||
|
||||
/*
|
||||
* FUNCTIONAL functions. These functions deal with ENGINE structures that |
||||
* have (or will) be initialised for use. Broadly speaking, the structural |
||||
* functions are useful for iterating the list of available engine types, |
||||
* creating new engine types, and other "list" operations. These functions |
||||
* actually deal with ENGINEs that are to be used. As such these functions |
||||
* can fail (if applicable) when particular engines are unavailable - eg. if |
||||
* a hardware accelerator is not attached or not functioning correctly. Each |
||||
* ENGINE has 2 reference counts; structural and functional. Every time a |
||||
* functional reference is obtained or released, a corresponding structural |
||||
* reference is automatically obtained or released too. |
||||
*/ |
||||
|
||||
/*
|
||||
* Initialise a engine type for use (or up its reference count if it's |
||||
* already in use). This will fail if the engine is not currently operational |
||||
* and cannot initialise. |
||||
*/ |
||||
int ENGINE_init(ENGINE *e); |
||||
/*
|
||||
* Free a functional reference to a engine type. This does not require a |
||||
* corresponding call to ENGINE_free as it also releases a structural |
||||
* reference. |
||||
*/ |
||||
int ENGINE_finish(ENGINE *e); |
||||
|
||||
/*
|
||||
* The following functions handle keys that are stored in some secondary |
||||
* location, handled by the engine. The storage may be on a card or |
||||
* whatever. |
||||
*/ |
||||
EVP_PKEY *ENGINE_load_private_key(ENGINE *e, const char *key_id, |
||||
UI_METHOD *ui_method, void *callback_data); |
||||
EVP_PKEY *ENGINE_load_public_key(ENGINE *e, const char *key_id, |
||||
UI_METHOD *ui_method, void *callback_data); |
||||
int ENGINE_load_ssl_client_cert(ENGINE *e, SSL *s, |
||||
STACK_OF(X509_NAME) *ca_dn, X509 **pcert, |
||||
EVP_PKEY **ppkey, STACK_OF(X509) **pother, |
||||
UI_METHOD *ui_method, void *callback_data); |
||||
|
||||
/*
|
||||
* This returns a pointer for the current ENGINE structure that is (by |
||||
* default) performing any RSA operations. The value returned is an |
||||
* incremented reference, so it should be free'd (ENGINE_finish) before it is |
||||
* discarded. |
||||
*/ |
||||
ENGINE *ENGINE_get_default_RSA(void); |
||||
/* Same for the other "methods" */ |
||||
ENGINE *ENGINE_get_default_DSA(void); |
||||
ENGINE *ENGINE_get_default_EC(void); |
||||
ENGINE *ENGINE_get_default_DH(void); |
||||
ENGINE *ENGINE_get_default_RAND(void); |
||||
/*
|
||||
* These functions can be used to get a functional reference to perform |
||||
* ciphering or digesting corresponding to "nid". |
||||
*/ |
||||
ENGINE *ENGINE_get_cipher_engine(int nid); |
||||
ENGINE *ENGINE_get_digest_engine(int nid); |
||||
ENGINE *ENGINE_get_pkey_meth_engine(int nid); |
||||
ENGINE *ENGINE_get_pkey_asn1_meth_engine(int nid); |
||||
|
||||
/*
|
||||
* This sets a new default ENGINE structure for performing RSA operations. If |
||||
* the result is non-zero (success) then the ENGINE structure will have had |
||||
* its reference count up'd so the caller should still free their own |
||||
* reference 'e'. |
||||
*/ |
||||
int ENGINE_set_default_RSA(ENGINE *e); |
||||
int ENGINE_set_default_string(ENGINE *e, const char *def_list); |
||||
/* Same for the other "methods" */ |
||||
int ENGINE_set_default_DSA(ENGINE *e); |
||||
int ENGINE_set_default_EC(ENGINE *e); |
||||
int ENGINE_set_default_DH(ENGINE *e); |
||||
int ENGINE_set_default_RAND(ENGINE *e); |
||||
int ENGINE_set_default_ciphers(ENGINE *e); |
||||
int ENGINE_set_default_digests(ENGINE *e); |
||||
int ENGINE_set_default_pkey_meths(ENGINE *e); |
||||
int ENGINE_set_default_pkey_asn1_meths(ENGINE *e); |
||||
|
||||
/*
|
||||
* The combination "set" - the flags are bitwise "OR"d from the |
||||
* ENGINE_METHOD_*** defines above. As with the "ENGINE_register_complete()" |
||||
* function, this function can result in unnecessary static linkage. If your |
||||
* application requires only specific functionality, consider using more |
||||
* selective functions. |
||||
*/ |
||||
int ENGINE_set_default(ENGINE *e, unsigned int flags); |
||||
|
||||
void ENGINE_add_conf_module(void); |
||||
|
||||
/* Deprecated functions ... */ |
||||
/* int ENGINE_clear_defaults(void); */ |
||||
|
||||
/**************************/ |
||||
/* DYNAMIC ENGINE SUPPORT */ |
||||
/**************************/ |
||||
|
||||
/* Binary/behaviour compatibility levels */ |
||||
# define OSSL_DYNAMIC_VERSION (unsigned long)0x00030000 |
||||
/*
|
||||
* Binary versions older than this are too old for us (whether we're a loader |
||||
* or a loadee) |
||||
*/ |
||||
# define OSSL_DYNAMIC_OLDEST (unsigned long)0x00030000 |
||||
|
||||
/*
|
||||
* When compiling an ENGINE entirely as an external shared library, loadable |
||||
* by the "dynamic" ENGINE, these types are needed. The 'dynamic_fns' |
||||
* structure type provides the calling application's (or library's) error |
||||
* functionality and memory management function pointers to the loaded |
||||
* library. These should be used/set in the loaded library code so that the |
||||
* loading application's 'state' will be used/changed in all operations. The |
||||
* 'static_state' pointer allows the loaded library to know if it shares the |
||||
* same static data as the calling application (or library), and thus whether |
||||
* these callbacks need to be set or not. |
||||
*/ |
||||
typedef void *(*dyn_MEM_malloc_fn) (size_t, const char *, int); |
||||
typedef void *(*dyn_MEM_realloc_fn) (void *, size_t, const char *, int); |
||||
typedef void (*dyn_MEM_free_fn) (void *, const char *, int); |
||||
typedef struct st_dynamic_MEM_fns { |
||||
dyn_MEM_malloc_fn malloc_fn; |
||||
dyn_MEM_realloc_fn realloc_fn; |
||||
dyn_MEM_free_fn free_fn; |
||||
} dynamic_MEM_fns; |
||||
/*
|
||||
* FIXME: Perhaps the memory and locking code (crypto.h) should declare and |
||||
* use these types so we (and any other dependent code) can simplify a bit?? |
||||
*/ |
||||
/* The top-level structure */ |
||||
typedef struct st_dynamic_fns { |
||||
void *static_state; |
||||
dynamic_MEM_fns mem_fns; |
||||
} dynamic_fns; |
||||
|
||||
/*
|
||||
* The version checking function should be of this prototype. NB: The |
||||
* ossl_version value passed in is the OSSL_DYNAMIC_VERSION of the loading |
||||
* code. If this function returns zero, it indicates a (potential) version |
||||
* incompatibility and the loaded library doesn't believe it can proceed. |
||||
* Otherwise, the returned value is the (latest) version supported by the |
||||
* loading library. The loader may still decide that the loaded code's |
||||
* version is unsatisfactory and could veto the load. The function is |
||||
* expected to be implemented with the symbol name "v_check", and a default |
||||
* implementation can be fully instantiated with |
||||
* IMPLEMENT_DYNAMIC_CHECK_FN(). |
||||
*/ |
||||
typedef unsigned long (*dynamic_v_check_fn) (unsigned long ossl_version); |
||||
# define IMPLEMENT_DYNAMIC_CHECK_FN() \ |
||||
OPENSSL_EXPORT unsigned long v_check(unsigned long v); \
|
||||
OPENSSL_EXPORT unsigned long v_check(unsigned long v) { \
|
||||
if (v >= OSSL_DYNAMIC_OLDEST) return OSSL_DYNAMIC_VERSION; \
|
||||
return 0; } |
||||
|
||||
/*
|
||||
* This function is passed the ENGINE structure to initialise with its own |
||||
* function and command settings. It should not adjust the structural or |
||||
* functional reference counts. If this function returns zero, (a) the load |
||||
* will be aborted, (b) the previous ENGINE state will be memcpy'd back onto |
||||
* the structure, and (c) the shared library will be unloaded. So |
||||
* implementations should do their own internal cleanup in failure |
||||
* circumstances otherwise they could leak. The 'id' parameter, if non-NULL, |
||||
* represents the ENGINE id that the loader is looking for. If this is NULL, |
||||
* the shared library can choose to return failure or to initialise a |
||||
* 'default' ENGINE. If non-NULL, the shared library must initialise only an |
||||
* ENGINE matching the passed 'id'. The function is expected to be |
||||
* implemented with the symbol name "bind_engine". A standard implementation |
||||
* can be instantiated with IMPLEMENT_DYNAMIC_BIND_FN(fn) where the parameter |
||||
* 'fn' is a callback function that populates the ENGINE structure and |
||||
* returns an int value (zero for failure). 'fn' should have prototype; |
||||
* [static] int fn(ENGINE *e, const char *id); |
||||
*/ |
||||
typedef int (*dynamic_bind_engine) (ENGINE *e, const char *id, |
||||
const dynamic_fns *fns); |
||||
# define IMPLEMENT_DYNAMIC_BIND_FN(fn) \ |
||||
OPENSSL_EXPORT \
|
||||
int bind_engine(ENGINE *e, const char *id, const dynamic_fns *fns); \
|
||||
OPENSSL_EXPORT \
|
||||
int bind_engine(ENGINE *e, const char *id, const dynamic_fns *fns) { \
|
||||
if (ENGINE_get_static_state() == fns->static_state) goto skip_cbs; \
|
||||
CRYPTO_set_mem_functions(fns->mem_fns.malloc_fn, \
|
||||
fns->mem_fns.realloc_fn, \
|
||||
fns->mem_fns.free_fn); \
|
||||
OPENSSL_init_crypto(OPENSSL_INIT_NO_ATEXIT, NULL); \
|
||||
skip_cbs: \
|
||||
if (!fn(e, id)) return 0; \
|
||||
return 1; } |
||||
|
||||
/*
|
||||
* If the loading application (or library) and the loaded ENGINE library |
||||
* share the same static data (eg. they're both dynamically linked to the |
||||
* same libcrypto.so) we need a way to avoid trying to set system callbacks - |
||||
* this would fail, and for the same reason that it's unnecessary to try. If |
||||
* the loaded ENGINE has (or gets from through the loader) its own copy of |
||||
* the libcrypto static data, we will need to set the callbacks. The easiest |
||||
* way to detect this is to have a function that returns a pointer to some |
||||
* static data and let the loading application and loaded ENGINE compare |
||||
* their respective values. |
||||
*/ |
||||
void *ENGINE_get_static_state(void); |
||||
|
||||
# if defined(__OpenBSD__) || defined(__FreeBSD__) || defined(__DragonFly__) |
||||
DEPRECATEDIN_1_1_0(void ENGINE_setup_bsd_cryptodev(void)) |
||||
# endif |
||||
|
||||
|
||||
# ifdef __cplusplus |
||||
} |
||||
# endif |
||||
# endif |
||||
#endif |
||||
@ -0,0 +1,111 @@ |
||||
/*
|
||||
* 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_ENGINEERR_H |
||||
# define HEADER_ENGINEERR_H |
||||
|
||||
# ifndef HEADER_SYMHACKS_H |
||||
# include <openssl/symhacks.h> |
||||
# endif |
||||
|
||||
# include <openssl/opensslconf.h> |
||||
|
||||
# ifndef OPENSSL_NO_ENGINE |
||||
|
||||
# ifdef __cplusplus |
||||
extern "C" |
||||
# endif |
||||
int ERR_load_ENGINE_strings(void); |
||||
|
||||
/*
|
||||
* ENGINE function codes. |
||||
*/ |
||||
# define ENGINE_F_DIGEST_UPDATE 198 |
||||
# define ENGINE_F_DYNAMIC_CTRL 180 |
||||
# define ENGINE_F_DYNAMIC_GET_DATA_CTX 181 |
||||
# define ENGINE_F_DYNAMIC_LOAD 182 |
||||
# define ENGINE_F_DYNAMIC_SET_DATA_CTX 183 |
||||
# define ENGINE_F_ENGINE_ADD 105 |
||||
# define ENGINE_F_ENGINE_BY_ID 106 |
||||
# define ENGINE_F_ENGINE_CMD_IS_EXECUTABLE 170 |
||||
# define ENGINE_F_ENGINE_CTRL 142 |
||||
# define ENGINE_F_ENGINE_CTRL_CMD 178 |
||||
# define ENGINE_F_ENGINE_CTRL_CMD_STRING 171 |
||||
# define ENGINE_F_ENGINE_FINISH 107 |
||||
# define ENGINE_F_ENGINE_GET_CIPHER 185 |
||||
# define ENGINE_F_ENGINE_GET_DIGEST 186 |
||||
# define ENGINE_F_ENGINE_GET_FIRST 195 |
||||
# define ENGINE_F_ENGINE_GET_LAST 196 |
||||
# define ENGINE_F_ENGINE_GET_NEXT 115 |
||||
# define ENGINE_F_ENGINE_GET_PKEY_ASN1_METH 193 |
||||
# define ENGINE_F_ENGINE_GET_PKEY_METH 192 |
||||
# define ENGINE_F_ENGINE_GET_PREV 116 |
||||
# define ENGINE_F_ENGINE_INIT 119 |
||||
# define ENGINE_F_ENGINE_LIST_ADD 120 |
||||
# define ENGINE_F_ENGINE_LIST_REMOVE 121 |
||||
# define ENGINE_F_ENGINE_LOAD_PRIVATE_KEY 150 |
||||
# define ENGINE_F_ENGINE_LOAD_PUBLIC_KEY 151 |
||||
# define ENGINE_F_ENGINE_LOAD_SSL_CLIENT_CERT 194 |
||||
# define ENGINE_F_ENGINE_NEW 122 |
||||
# define ENGINE_F_ENGINE_PKEY_ASN1_FIND_STR 197 |
||||
# define ENGINE_F_ENGINE_REMOVE 123 |
||||
# define ENGINE_F_ENGINE_SET_DEFAULT_STRING 189 |
||||
# define ENGINE_F_ENGINE_SET_ID 129 |
||||
# define ENGINE_F_ENGINE_SET_NAME 130 |
||||
# define ENGINE_F_ENGINE_TABLE_REGISTER 184 |
||||
# define ENGINE_F_ENGINE_UNLOCKED_FINISH 191 |
||||
# define ENGINE_F_ENGINE_UP_REF 190 |
||||
# define ENGINE_F_INT_CLEANUP_ITEM 199 |
||||
# define ENGINE_F_INT_CTRL_HELPER 172 |
||||
# define ENGINE_F_INT_ENGINE_CONFIGURE 188 |
||||
# define ENGINE_F_INT_ENGINE_MODULE_INIT 187 |
||||
# define ENGINE_F_OSSL_HMAC_INIT 200 |
||||
|
||||
/*
|
||||
* ENGINE reason codes. |
||||
*/ |
||||
# define ENGINE_R_ALREADY_LOADED 100 |
||||
# define ENGINE_R_ARGUMENT_IS_NOT_A_NUMBER 133 |
||||
# define ENGINE_R_CMD_NOT_EXECUTABLE 134 |
||||
# define ENGINE_R_COMMAND_TAKES_INPUT 135 |
||||
# define ENGINE_R_COMMAND_TAKES_NO_INPUT 136 |
||||
# define ENGINE_R_CONFLICTING_ENGINE_ID 103 |
||||
# define ENGINE_R_CTRL_COMMAND_NOT_IMPLEMENTED 119 |
||||
# define ENGINE_R_DSO_FAILURE 104 |
||||
# define ENGINE_R_DSO_NOT_FOUND 132 |
||||
# define ENGINE_R_ENGINES_SECTION_ERROR 148 |
||||
# define ENGINE_R_ENGINE_CONFIGURATION_ERROR 102 |
||||
# define ENGINE_R_ENGINE_IS_NOT_IN_LIST 105 |
||||
# define ENGINE_R_ENGINE_SECTION_ERROR 149 |
||||
# define ENGINE_R_FAILED_LOADING_PRIVATE_KEY 128 |
||||
# define ENGINE_R_FAILED_LOADING_PUBLIC_KEY 129 |
||||
# define ENGINE_R_FINISH_FAILED 106 |
||||
# define ENGINE_R_ID_OR_NAME_MISSING 108 |
||||
# define ENGINE_R_INIT_FAILED 109 |
||||
# define ENGINE_R_INTERNAL_LIST_ERROR 110 |
||||
# define ENGINE_R_INVALID_ARGUMENT 143 |
||||
# define ENGINE_R_INVALID_CMD_NAME 137 |
||||
# define ENGINE_R_INVALID_CMD_NUMBER 138 |
||||
# define ENGINE_R_INVALID_INIT_VALUE 151 |
||||
# define ENGINE_R_INVALID_STRING 150 |
||||
# define ENGINE_R_NOT_INITIALISED 117 |
||||
# define ENGINE_R_NOT_LOADED 112 |
||||
# define ENGINE_R_NO_CONTROL_FUNCTION 120 |
||||
# define ENGINE_R_NO_INDEX 144 |
||||
# define ENGINE_R_NO_LOAD_FUNCTION 125 |
||||
# define ENGINE_R_NO_REFERENCE 130 |
||||
# define ENGINE_R_NO_SUCH_ENGINE 116 |
||||
# define ENGINE_R_UNIMPLEMENTED_CIPHER 146 |
||||
# define ENGINE_R_UNIMPLEMENTED_DIGEST 147 |
||||
# define ENGINE_R_UNIMPLEMENTED_PUBLIC_KEY_METHOD 101 |
||||
# define ENGINE_R_VERSION_INCOMPATIBILITY 145 |
||||
|
||||
# endif |
||||
#endif |
||||
@ -0,0 +1,274 @@ |
||||
/*
|
||||
* 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 <openssl/e_os2.h> |
||||
|
||||
# ifndef OPENSSL_NO_STDIO |
||||
# include <stdio.h> |
||||
# include <stdlib.h> |
||||
# endif |
||||
|
||||
# include <openssl/ossl_typ.h> |
||||
# include <openssl/bio.h> |
||||
# include <openssl/lhash.h> |
||||
|
||||
#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 <errno.h> |
||||
|
||||
# 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_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 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 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_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 |
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,204 @@ |
||||
/*
|
||||
* 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 <openssl/symhacks.h> |
||||
|
||||
# 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 |
||||
|
||||
/*
|
||||
* 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 |
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue