/* ssl/ssl.h */

/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)

* All rights reserved.

*

* This package is an SSL implementation written

* by Eric Young (eay@cryptsoft.com).

* The implementation was written so as to conform with Netscapes SSL.

*

* This library is free for commercial and non-commercial use as long as

* the following conditions are aheared to. The following conditions

* apply to all code found in this distribution, be it the RC4, RSA,

* lhash, DES, etc., code; not just the SSL code. The SSL documentation

* included with this distribution is covered by the same copyright terms

* except that the holder is Tim Hudson (tjh@cryptsoft.com).

*

* Copyright remains Eric Young's, and as such any Copyright notices in

* the code are not to be removed.

* If this package is used in a product, Eric Young should be given attribution

* as the author of the parts of the library used.

* This can be in the form of a textual message at program startup or

* in documentation (online or textual) provided with the package.

*

* 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 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.

* 3. All advertising materials mentioning features or use of this software

* must display the following acknowledgement:

* "This product includes cryptographic software written by

* Eric Young (eay@cryptsoft.com)"

* The word 'cryptographic' can be left out if the rouines from the library

* being used are not cryptographic related :-).

* 4. If you include any Windows specific code (or a derivative thereof) from

* the apps directory (application code) you must include an acknowledgement:

* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"

*

* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``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 AUTHOR 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.

*

* The licence and distribution terms for any publically available version or

* derivative of this code cannot be changed. i.e. this code cannot simply be

* copied and put under another distribution licence

* [including the GNU Public Licence.]

*/

/* ====================================================================

* Copyright (c) 1998-2007 The OpenSSL Project. 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.

*

* 3. All advertising materials mentioning features or use of this

* software must display the following acknowledgment:

* "This product includes software developed by the OpenSSL Project

* for use in the OpenSSL Toolkit. (http://www.openssl.org/)"

*

* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to

* endorse or promote products derived from this software without

* prior written permission. For written permission, please contact

* openssl-core@openssl.org.

*

* 5. Products derived from this software may not be called "OpenSSL"

* nor may "OpenSSL" appear in their names without prior written

* permission of the OpenSSL Project.

*

* 6. Redistributions of any form whatsoever must retain the following

* acknowledgment:

* "This product includes software developed by the OpenSSL Project

* for use in the OpenSSL Toolkit (http://www.openssl.org/)"

*

* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY

* EXPRESSED 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 OpenSSL PROJECT OR

* ITS 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.

* ====================================================================

*

* This product includes cryptographic software written by Eric Young

* (eay@cryptsoft.com). This product includes software written by Tim

* Hudson (tjh@cryptsoft.com).

*

*/

/* ====================================================================

* Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.

* ECC cipher suite support in OpenSSL originally developed by

* SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project.

*/

/* ====================================================================

* Copyright 2005 Nokia. All rights reserved.

*

* The portions of the attached software ("Contribution") is developed by

* Nokia Corporation and is licensed pursuant to the OpenSSL open source

* license.

*

* The Contribution, originally written by Mika Kousa and Pasi Eronen of

* Nokia Corporation, consists of the "PSK" (Pre-Shared Key) ciphersuites

* support (see RFC 4279) to OpenSSL.

*

* No patent licenses or other rights except those expressly stated in

* the OpenSSL open source license shall be deemed granted or received

* expressly, by implication, estoppel, or otherwise.

*

* No assurances are provided by Nokia that the Contribution does not

* infringe the patent or other intellectual property rights of any third

* party or that the license provides you with all the necessary rights

* to make use of the Contribution.

*

* THE SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND. IN

* ADDITION TO THE DISCLAIMERS INCLUDED IN THE LICENSE, NOKIA

* SPECIFICALLY DISCLAIMS ANY LIABILITY FOR CLAIMS BROUGHT BY YOU OR ANY

* OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS OR

* OTHERWISE.

*/

#ifndef HEADER_SSL_H

# define HEADER_SSL_H

# include <openssl/e_os2.h>

# include <openssl/comp.h>

# include <openssl/bio.h>

# ifdef OPENSSL_USE_DEPRECATED

# include <openssl/x509.h>

# include <openssl/crypto.h>

# include <openssl/lhash.h>

# include <openssl/buffer.h>

# endif

# include <openssl/pem.h>

# include <openssl/hmac.h>

# include <openssl/safestack.h>

# include <openssl/symhacks.h>

#ifdef __cplusplus

extern "C" {

#endif

/* SSLeay version number for ASN.1 encoding of the session information */

/*-

* Version 0 - initial version

* Version 1 - added the optional peer certificate

*/

# define SSL_SESSION_ASN1_VERSION 0x0001

# define SSL_MAX_SSL_SESSION_ID_LENGTH 32

# define SSL_MAX_SID_CTX_LENGTH 32

# define SSL_MIN_RSA_MODULUS_LENGTH_IN_BYTES (512/8)

# define SSL_MAX_KEY_ARG_LENGTH 8

# define SSL_MAX_MASTER_KEY_LENGTH 48

/* text strings for the ciphers */

/* These are used to specify which ciphers to use and not to use */

# define SSL_TXT_EXP40 "EXPORT40"

# define SSL_TXT_EXP56 "EXPORT56"

# define SSL_TXT_LOW "LOW"

# define SSL_TXT_MEDIUM "MEDIUM"

# define SSL_TXT_HIGH "HIGH"

# define SSL_TXT_FIPS "FIPS"

# define SSL_TXT_aNULL "aNULL"

# define SSL_TXT_eNULL "eNULL"

# define SSL_TXT_NULL "NULL"

# define SSL_TXT_kRSA "kRSA"

# define SSL_TXT_kDHr "kDHr"

# define SSL_TXT_kDHd "kDHd"

# define SSL_TXT_kDH "kDH"

# define SSL_TXT_kEDH "kEDH"/* alias for kDHE */

# define SSL_TXT_kDHE "kDHE"

# define SSL_TXT_kECDHr "kECDHr"

# define SSL_TXT_kECDHe "kECDHe"

# define SSL_TXT_kECDH "kECDH"

# define SSL_TXT_kEECDH "kEECDH"/* alias for kECDHE */

# define SSL_TXT_kECDHE "kECDHE"

# define SSL_TXT_kPSK "kPSK"

# define SSL_TXT_kRSAPSK "kRSAPSK"

# define SSL_TXT_kECDHEPSK "kECDHEPSK"

# define SSL_TXT_kDHEPSK "kDHEPSK"

# define SSL_TXT_kGOST "kGOST"

# define SSL_TXT_kSRP "kSRP"

# define SSL_TXT_aRSA "aRSA"

# define SSL_TXT_aDSS "aDSS"

# define SSL_TXT_aDH "aDH"

# define SSL_TXT_aECDH "aECDH"

# define SSL_TXT_aECDSA "aECDSA"

# define SSL_TXT_aPSK "aPSK"

# define SSL_TXT_aGOST94 "aGOST94"

# define SSL_TXT_aGOST01 "aGOST01"

# define SSL_TXT_aGOST "aGOST"

# define SSL_TXT_aSRP "aSRP"

# define SSL_TXT_DSS "DSS"

# define SSL_TXT_DH "DH"

# define SSL_TXT_DHE "DHE"/* same as "kDHE:-ADH" */

# define SSL_TXT_EDH "EDH"/* alias for DHE */

# define SSL_TXT_ADH "ADH"

# define SSL_TXT_RSA "RSA"

# define SSL_TXT_ECDH "ECDH"

# define SSL_TXT_EECDH "EECDH"/* alias for ECDHE" */

# define SSL_TXT_ECDHE "ECDHE"/* same as "kECDHE:-AECDH" */

# define SSL_TXT_AECDH "AECDH"

# define SSL_TXT_ECDSA "ECDSA"

# define SSL_TXT_PSK "PSK"

# define SSL_TXT_SRP "SRP"

# define SSL_TXT_DES "DES"

# define SSL_TXT_3DES "3DES"

# define SSL_TXT_RC4 "RC4"

# define SSL_TXT_RC2 "RC2"

# define SSL_TXT_IDEA "IDEA"

# define SSL_TXT_SEED "SEED"

# define SSL_TXT_AES128 "AES128"

# define SSL_TXT_AES256 "AES256"

# define SSL_TXT_AES "AES"

# define SSL_TXT_AES_GCM "AESGCM"

# define SSL_TXT_CAMELLIA128 "CAMELLIA128"

# define SSL_TXT_CAMELLIA256 "CAMELLIA256"

# define SSL_TXT_CAMELLIA "CAMELLIA"

# define SSL_TXT_MD5 "MD5"

# define SSL_TXT_SHA1 "SHA1"

# define SSL_TXT_SHA "SHA"/* same as "SHA1" */

# define SSL_TXT_GOST94 "GOST94"

# define SSL_TXT_GOST89MAC "GOST89MAC"

# define SSL_TXT_SHA256 "SHA256"

# define SSL_TXT_SHA384 "SHA384"

# define SSL_TXT_SSLV3 "SSLv3"

# define SSL_TXT_TLSV1 "TLSv1"

# define SSL_TXT_TLSV1_1 "TLSv1.1"

# define SSL_TXT_TLSV1_2 "TLSv1.2"

# define SSL_TXT_EXP "EXP"

# define SSL_TXT_EXPORT "EXPORT"

# define SSL_TXT_ALL "ALL"

/*-

* COMPLEMENTOF* definitions. These identifiers are used to (de-select)

* ciphers normally not being used.

* Example: "RC4" will activate all ciphers using RC4 including ciphers

* without authentication, which would normally disabled by DEFAULT (due

* the "!ADH" being part of default). Therefore "RC4:!COMPLEMENTOFDEFAULT"

* will make sure that it is also disabled in the specific selection.

* COMPLEMENTOF* identifiers are portable between version, as adjustments

* to the default cipher setup will also be included here.

*

* COMPLEMENTOFDEFAULT does not experience the same special treatment that

* DEFAULT gets, as only selection is being done and no sorting as needed

* for DEFAULT.

*/

# define SSL_TXT_CMPALL "COMPLEMENTOFALL"

# define SSL_TXT_CMPDEF "COMPLEMENTOFDEFAULT"

/*

* The following cipher list is used by default. It also is substituted when

* an application-defined cipher list string starts with 'DEFAULT'.

*/

# define SSL_DEFAULT_CIPHER_LIST "ALL:!aNULL:!eNULL"

/*

* As of OpenSSL 1.0.0, ssl_create_cipher_list() in ssl/ssl_ciph.c always

* starts with a reasonable order, and all we have to do for DEFAULT is

* throwing out anonymous and unencrypted ciphersuites! (The latter are not

* actually enabled by ALL, but "ALL:RSA" would enable some of them.)

*/

/* Used in SSL_set_shutdown()/SSL_get_shutdown(); */

# define SSL_SENT_SHUTDOWN 1

# define SSL_RECEIVED_SHUTDOWN 2

#ifdef __cplusplus

}

#endif

#ifdef __cplusplus

extern "C" {

#endif

# define SSL_FILETYPE_ASN1 X509_FILETYPE_ASN1

# define SSL_FILETYPE_PEM X509_FILETYPE_PEM

/*

* This is needed to stop compilers complaining about the 'struct ssl_st *'

* function parameters used to prototype callbacks in SSL_CTX.

*/

typedef struct ssl_st *ssl_crock_st;

typedef struct tls_session_ticket_ext_st TLS_SESSION_TICKET_EXT;

typedef struct ssl_method_st SSL_METHOD;

typedef struct ssl_cipher_st SSL_CIPHER;

typedef struct ssl_session_st SSL_SESSION;

typedef struct tls_sigalgs_st TLS_SIGALGS;

typedef struct ssl_conf_ctx_st SSL_CONF_CTX;

DECLARE_STACK_OF(SSL_CIPHER)

/* SRTP protection profiles for use with the use_srtp extension (RFC 5764)*/

typedef struct srtp_protection_profile_st {

const char *name;

unsigned long id;

} SRTP_PROTECTION_PROFILE;

DECLARE_STACK_OF(SRTP_PROTECTION_PROFILE)

typedef int (*tls_session_ticket_ext_cb_fn) (SSL *s,

const unsigned char *data,

int len, void *arg);

typedef int (*tls_session_secret_cb_fn) (SSL *s, void *secret,

int *secret_len,

STACK_OF(SSL_CIPHER) *peer_ciphers,

SSL_CIPHER **cipher, void *arg);

/* Typedefs for handling custom extensions */

typedef int (*custom_ext_add_cb) (SSL *s, unsigned int ext_type,

const unsigned char **out,

size_t *outlen, int *al, void *add_arg);

typedef void (*custom_ext_free_cb) (SSL *s, unsigned int ext_type,

const unsigned char *out, void *add_arg);

typedef int (*custom_ext_parse_cb) (SSL *s, unsigned int ext_type,

const unsigned char *in,

size_t inlen, int *al, void *parse_arg);

/* Allow initial connection to servers that don't support RI */

# define SSL_OP_LEGACY_SERVER_CONNECT 0x00000004L

/* Removed from OpenSSL 0.9.8q and 1.0.0c */

# define SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG 0x0L

# define SSL_OP_TLSEXT_PADDING 0x00000010L

# define SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER 0x00000020L

# define SSL_OP_SAFARI_ECDHE_ECDSA_BUG 0x00000040L

# define SSL_OP_SSLEAY_080_CLIENT_DH_BUG 0x00000080L

# define SSL_OP_TLS_D5_BUG 0x00000100L

/* Removed from OpenSSL 1.1.0 */

# define SSL_OP_TLS_BLOCK_PADDING_BUG 0x0L

/* Hasn't done anything since OpenSSL 0.9.7h, retained for compatibility */

# define SSL_OP_MSIE_SSLV2_RSA_PADDING 0x0

/* Refers to ancient SSLREF and SSLv2, retained for compatibility */

# define SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG 0x0

/* Related to removed SSLv2 */

# define SSL_OP_MICROSOFT_SESS_ID_BUG 0x0

# define SSL_OP_NETSCAPE_CHALLENGE_BUG 0x0

/*

* Disable SSL 3.0/TLS 1.0 CBC vulnerability workaround that was added in

* OpenSSL 0.9.6d. Usually (depending on the application protocol) the

* workaround is not needed. Unfortunately some broken SSL/TLS

* implementations cannot handle it at all, which is why we include it in

* SSL_OP_ALL.

*/

/* added in 0.9.6e */

# define SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS 0x00000800L

/*

* SSL_OP_ALL: various bug workarounds that should be rather harmless. This

* used to be 0x000FFFFFL before 0.9.7.

*/

# define SSL_OP_ALL 0x80000BFFL

/* DTLS options */

# define SSL_OP_NO_QUERY_MTU 0x00001000L

/* Turn on Cookie Exchange (on relevant for servers) */

# define SSL_OP_COOKIE_EXCHANGE 0x00002000L

/* Don't use RFC4507 ticket extension */

# define SSL_OP_NO_TICKET 0x00004000L

/* Use Cisco's "speshul" version of DTLS_BAD_VER (as client) */

# define SSL_OP_CISCO_ANYCONNECT 0x00008000L

/* As server, disallow session resumption on renegotiation */

# define SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION 0x00010000L

/* Don't use compression even if supported */

# define SSL_OP_NO_COMPRESSION 0x00020000L

/* Permit unsafe legacy renegotiation */

# define SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION 0x00040000L

/* If set, always create a new key when using tmp_ecdh parameters */

# define SSL_OP_SINGLE_ECDH_USE 0x00080000L

/* If set, always create a new key when using tmp_dh parameters */

# define SSL_OP_SINGLE_DH_USE 0x00100000L

/* Does nothing: retained for compatibiity */

# define SSL_OP_EPHEMERAL_RSA 0x0

/*

* Set on servers to choose the cipher according to the server's preferences

*/

# define SSL_OP_CIPHER_SERVER_PREFERENCE 0x00400000L

/*

* If set, a server will allow a client to issue a SSLv3.0 version number as

* latest version supported in the premaster secret, even when TLSv1.0

* (version 3.1) was announced in the client hello. Normally this is

* forbidden to prevent version rollback attacks.

*/

# define SSL_OP_TLS_ROLLBACK_BUG 0x00800000L

# define SSL_OP_NO_SSLv2 0x00000000L

# define SSL_OP_NO_SSLv3 0x02000000L

# define SSL_OP_NO_TLSv1 0x04000000L

# define SSL_OP_NO_TLSv1_2 0x08000000L

# define SSL_OP_NO_TLSv1_1 0x10000000L

# define SSL_OP_NO_DTLSv1 0x04000000L

# define SSL_OP_NO_DTLSv1_2 0x08000000L

# define SSL_OP_NO_SSL_MASK (SSL_OP_NO_SSLv3|\

SSL_OP_NO_TLSv1|SSL_OP_NO_TLSv1_1|SSL_OP_NO_TLSv1_2)

/*

* These next two were never actually used for anything since SSLeay zap so

* we have some more flags.

*/

/*

* The next flag deliberately changes the ciphertest, this is a check for the

* PKCS#1 attack

*/

# define SSL_OP_PKCS1_CHECK_1 0x0

# define SSL_OP_PKCS1_CHECK_2 0x0

/* Removed as of OpenSSL 1.1.0 */

# define SSL_OP_NETSCAPE_CA_DN_BUG 0x0

/* Removed as of OpenSSL 1.1.0 */

# define SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG 0x0L

/*

* Make server add server-hello extension from early version of cryptopro

* draft, when GOST ciphersuite is negotiated. Required for interoperability

* with CryptoPro CSP 3.x

*/

# define SSL_OP_CRYPTOPRO_TLSEXT_BUG 0x80000000L

/*

* Allow SSL_write(..., n) to return r with 0 < r < n (i.e. report success

* when just a single record has been written):

*/

# define SSL_MODE_ENABLE_PARTIAL_WRITE 0x00000001L

/*

* Make it possible to retry SSL_write() with changed buffer location (buffer

* contents must stay the same!); this is not the default to avoid the

* misconception that non-blocking SSL_write() behaves like non-blocking

* write():

*/

# define SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER 0x00000002L

/*

* Never bother the application with retries if the transport is blocking:

*/

# define SSL_MODE_AUTO_RETRY 0x00000004L

/* Don't attempt to automatically build certificate chain */

# define SSL_MODE_NO_AUTO_CHAIN 0x00000008L

/*

* Save RAM by releasing read and write buffers when they're empty. (SSL3 and

* TLS only.) "Released" buffers are put onto a free-list in the context or

* just freed (depending on the context's setting for freelist_max_len).

*/

# define SSL_MODE_RELEASE_BUFFERS 0x00000010L

/*

* Send the current time in the Random fields of the ClientHello and

* ServerHello records for compatibility with hypothetical implementations

* that require it.

*/

# define SSL_MODE_SEND_CLIENTHELLO_TIME 0x00000020L

# define SSL_MODE_SEND_SERVERHELLO_TIME 0x00000040L

/*

* Send TLS_FALLBACK_SCSV in the ClientHello. To be set only by applications

* that reconnect with a downgraded protocol version; see

* draft-ietf-tls-downgrade-scsv-00 for details. DO NOT ENABLE THIS if your

* application attempts a normal handshake. Only use this in explicit

* fallback retries, following the guidance in

* draft-ietf-tls-downgrade-scsv-00.

*/

# define SSL_MODE_SEND_FALLBACK_SCSV 0x00000080L

/* Cert related flags */

/*

* Many implementations ignore some aspects of the TLS standards such as

* enforcing certifcate chain algorithms. When this is set we enforce them.

*/

# define SSL_CERT_FLAG_TLS_STRICT 0x00000001L

/* Suite B modes, takes same values as certificate verify flags */

# define SSL_CERT_FLAG_SUITEB_128_LOS_ONLY 0x10000

/* Suite B 192 bit only mode */

# define SSL_CERT_FLAG_SUITEB_192_LOS 0x20000

/* Suite B 128 bit mode allowing 192 bit algorithms */

# define SSL_CERT_FLAG_SUITEB_128_LOS 0x30000

/* Perform all sorts of protocol violations for testing purposes */

# define SSL_CERT_FLAG_BROKEN_PROTOCOL 0x10000000

/* Flags for building certificate chains */

/* Treat any existing certificates as untrusted CAs */

# define SSL_BUILD_CHAIN_FLAG_UNTRUSTED 0x1

/* Don't include root CA in chain */

# define SSL_BUILD_CHAIN_FLAG_NO_ROOT 0x2

/* Just check certificates already there */

# define SSL_BUILD_CHAIN_FLAG_CHECK 0x4

/* Ignore verification errors */

# define SSL_BUILD_CHAIN_FLAG_IGNORE_ERROR 0x8

/* Clear verification errors from queue */

# define SSL_BUILD_CHAIN_FLAG_CLEAR_ERROR 0x10

/* Flags returned by SSL_check_chain */

/* Certificate can be used with this session */

# define CERT_PKEY_VALID 0x1

/* Certificate can also be used for signing */

# define CERT_PKEY_SIGN 0x2

/* EE certificate signing algorithm OK */

# define CERT_PKEY_EE_SIGNATURE 0x10

/* CA signature algorithms OK */

# define CERT_PKEY_CA_SIGNATURE 0x20

/* EE certificate parameters OK */

# define CERT_PKEY_EE_PARAM 0x40

/* CA certificate parameters OK */

# define CERT_PKEY_CA_PARAM 0x80

/* Signing explicitly allowed as opposed to SHA1 fallback */

# define CERT_PKEY_EXPLICIT_SIGN 0x100

/* Client CA issuer names match (always set for server cert) */

# define CERT_PKEY_ISSUER_NAME 0x200

/* Cert type matches client types (always set for server cert) */

# define CERT_PKEY_CERT_TYPE 0x400

/* Cert chain suitable to Suite B */

# define CERT_PKEY_SUITEB 0x800

# define SSL_CONF_FLAG_CMDLINE 0x1

# define SSL_CONF_FLAG_FILE 0x2

# define SSL_CONF_FLAG_CLIENT 0x4

# define SSL_CONF_FLAG_SERVER 0x8

# define SSL_CONF_FLAG_SHOW_ERRORS 0x10

# define SSL_CONF_FLAG_CERTIFICATE 0x20

# define SSL_CONF_FLAG_REQUIRE_PRIVATE 0x40

/* Configuration value types */

# define SSL_CONF_TYPE_UNKNOWN 0x0

# define SSL_CONF_TYPE_STRING 0x1

# define SSL_CONF_TYPE_FILE 0x2

# define SSL_CONF_TYPE_DIR 0x3

# define SSL_CONF_TYPE_NONE 0x4

/*

* Note: SSL[_CTX]_set_{options,mode} use |= op on the previous value, they

* cannot be used to clear bits.

*/

# define SSL_CTX_set_options(ctx,op) \

SSL_CTX_ctrl((ctx),SSL_CTRL_OPTIONS,(op),NULL)

# define SSL_CTX_clear_options(ctx,op) \

SSL_CTX_ctrl((ctx),SSL_CTRL_CLEAR_OPTIONS,(op),NULL)

# define SSL_CTX_get_options(ctx) \

SSL_CTX_ctrl((ctx),SSL_CTRL_OPTIONS,0,NULL)

# define SSL_set_options(ssl,op) \

SSL_ctrl((ssl),SSL_CTRL_OPTIONS,(op),NULL)

# define SSL_clear_options(ssl,op) \

SSL_ctrl((ssl),SSL_CTRL_CLEAR_OPTIONS,(op),NULL)

# define SSL_get_options(ssl) \

SSL_ctrl((ssl),SSL_CTRL_OPTIONS,0,NULL)

# define SSL_CTX_set_mode(ctx,op) \

SSL_CTX_ctrl((ctx),SSL_CTRL_MODE,(op),NULL)

# define SSL_CTX_clear_mode(ctx,op) \

SSL_CTX_ctrl((ctx),SSL_CTRL_CLEAR_MODE,(op),NULL)

# define SSL_CTX_get_mode(ctx) \

SSL_CTX_ctrl((ctx),SSL_CTRL_MODE,0,NULL)

# define SSL_clear_mode(ssl,op) \

SSL_ctrl((ssl),SSL_CTRL_CLEAR_MODE,(op),NULL)

# define SSL_set_mode(ssl,op) \

SSL_ctrl((ssl),SSL_CTRL_MODE,(op),NULL)

# define SSL_get_mode(ssl) \

SSL_ctrl((ssl),SSL_CTRL_MODE,0,NULL)

# define SSL_set_mtu(ssl, mtu) \

SSL_ctrl((ssl),SSL_CTRL_SET_MTU,(mtu),NULL)

# define DTLS_set_link_mtu(ssl, mtu) \

SSL_ctrl((ssl),DTLS_CTRL_SET_LINK_MTU,(mtu),NULL)

# define DTLS_get_link_min_mtu(ssl) \

SSL_ctrl((ssl),DTLS_CTRL_GET_LINK_MIN_MTU,0,NULL)

# define SSL_get_secure_renegotiation_support(ssl) \

SSL_ctrl((ssl), SSL_CTRL_GET_RI_SUPPORT, 0, NULL)

# ifndef OPENSSL_NO_HEARTBEATS

# define SSL_heartbeat(ssl) \

SSL_ctrl((ssl),SSL_CTRL_TLS_EXT_SEND_HEARTBEAT,0,NULL)

# endif

# define SSL_CTX_set_cert_flags(ctx,op) \

SSL_CTX_ctrl((ctx),SSL_CTRL_CERT_FLAGS,(op),NULL)

# define SSL_set_cert_flags(s,op) \

SSL_ctrl((s),SSL_CTRL_CERT_FLAGS,(op),NULL)

# define SSL_CTX_clear_cert_flags(ctx,op) \

SSL_CTX_ctrl((ctx),SSL_CTRL_CLEAR_CERT_FLAGS,(op),NULL)

# define SSL_clear_cert_flags(s,op) \

SSL_ctrl((s),SSL_CTRL_CLEAR_CERT_FLAGS,(op),NULL)

void SSL_CTX_set_msg_callback(SSL_CTX *ctx,

void (*cb) (int write_p, int version,

int content_type, const void *buf,

size_t len, SSL *ssl, void *arg));

void SSL_set_msg_callback(SSL *ssl,

void (*cb) (int write_p, int version,

int content_type, const void *buf,

size_t len, SSL *ssl, void *arg));

# define SSL_CTX_set_msg_callback_arg(ctx, arg) SSL_CTX_ctrl((ctx), SSL_CTRL_SET_MSG_CALLBACK_ARG, 0, (arg))

# define SSL_set_msg_callback_arg(ssl, arg) SSL_ctrl((ssl), SSL_CTRL_SET_MSG_CALLBACK_ARG, 0, (arg))

# define SSL_get_extms_support(s) \

SSL_ctrl((s),SSL_CTRL_GET_EXTMS_SUPPORT,0,NULL)

# ifndef OPENSSL_NO_SRP

/* see tls_srp.c */

__owur int SSL_SRP_CTX_init(SSL *s);

__owur int SSL_CTX_SRP_CTX_init(SSL_CTX *ctx);

int SSL_SRP_CTX_free(SSL *ctx);

int SSL_CTX_SRP_CTX_free(SSL_CTX *ctx);

__owur int SSL_srp_server_param_with_username(SSL *s, int *ad);

__owur int SRP_Calc_A_param(SSL *s);

# endif

# if defined(OPENSSL_SYS_MSDOS) && !defined(OPENSSL_SYS_WIN32)

# define SSL_MAX_CERT_LIST_DEFAULT 1024*30

/* 30k max cert list :-) */

# else

# define SSL_MAX_CERT_LIST_DEFAULT 1024*100

/* 100k max cert list :-) */

# endif

# define SSL_SESSION_CACHE_MAX_SIZE_DEFAULT (1024*20)

/*

* This callback type is used inside SSL_CTX, SSL, and in the functions that

* set them. It is used to override the generation of SSL/TLS session IDs in

* a server. Return value should be zero on an error, non-zero to proceed.

* Also, callbacks should themselves check if the id they generate is unique

* otherwise the SSL handshake will fail with an error - callbacks can do

* this using the 'ssl' value they're passed by;

* SSL_has_matching_session_id(ssl, id, *id_len) The length value passed in

* is set at the maximum size the session ID can be. In SSLv3/TLSv1 it is 32

* bytes. The callback can alter this length to be less if desired. It is

* also an error for the callback to set the size to zero.

*/

typedef int (*GEN_SESSION_CB) (const SSL *ssl, unsigned char *id,

unsigned int *id_len);

# define SSL_SESS_CACHE_OFF 0x0000

# define SSL_SESS_CACHE_CLIENT 0x0001

# define SSL_SESS_CACHE_SERVER 0x0002

# define SSL_SESS_CACHE_BOTH (SSL_SESS_CACHE_CLIENT|SSL_SESS_CACHE_SERVER)

# define SSL_SESS_CACHE_NO_AUTO_CLEAR 0x0080

/* enough comments already ... see SSL_CTX_set_session_cache_mode(3) */

# define SSL_SESS_CACHE_NO_INTERNAL_LOOKUP 0x0100

# define SSL_SESS_CACHE_NO_INTERNAL_STORE 0x0200

# define SSL_SESS_CACHE_NO_INTERNAL \

(SSL_SESS_CACHE_NO_INTERNAL_LOOKUP|SSL_SESS_CACHE_NO_INTERNAL_STORE)

LHASH_OF(SSL_SESSION) *SSL_CTX_sessions(SSL_CTX *ctx);

# define SSL_CTX_sess_number(ctx) \

SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_NUMBER,0,NULL)

# define SSL_CTX_sess_connect(ctx) \

SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_CONNECT,0,NULL)

# define SSL_CTX_sess_connect_good(ctx) \

SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_CONNECT_GOOD,0,NULL)

# define SSL_CTX_sess_connect_renegotiate(ctx) \

SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_CONNECT_RENEGOTIATE,0,NULL)

# define SSL_CTX_sess_accept(ctx) \

SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_ACCEPT,0,NULL)

# define SSL_CTX_sess_accept_renegotiate(ctx) \

SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_ACCEPT_RENEGOTIATE,0,NULL)

# define SSL_CTX_sess_accept_good(ctx) \

SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_ACCEPT_GOOD,0,NULL)

# define SSL_CTX_sess_hits(ctx) \

SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_HIT,0,NULL)

# define SSL_CTX_sess_cb_hits(ctx) \

SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_CB_HIT,0,NULL)

# define SSL_CTX_sess_misses(ctx) \

SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_MISSES,0,NULL)

# define SSL_CTX_sess_timeouts(ctx) \

SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_TIMEOUTS,0,NULL)

# define SSL_CTX_sess_cache_full(ctx) \

SSL_CTX_ctrl(ctx,SSL_CTRL_SESS_CACHE_FULL,0,NULL)

void SSL_CTX_sess_set_new_cb(SSL_CTX *ctx,

int (*new_session_cb) (struct ssl_st *ssl,

SSL_SESSION *sess));

int (*SSL_CTX_sess_get_new_cb(SSL_CTX *ctx)) (struct ssl_st *ssl,

SSL_SESSION *sess);

void SSL_CTX_sess_set_remove_cb(SSL_CTX *ctx,

*sess));

void (*SSL_CTX_sess_get_remove_cb(SSL_CTX *ctx)) (struct ssl_ctx_st *ctx,

SSL_SESSION *sess);

void SSL_CTX_sess_set_get_cb(SSL_CTX *ctx,

int *copy));

SSL_SESSION *(*SSL_CTX_sess_get_get_cb(SSL_CTX *ctx)) (struct ssl_st *ssl,

unsigned char *Data,

int len, int *copy);

void SSL_CTX_set_info_callback(SSL_CTX *ctx,

void (*cb) (const SSL *ssl, int type,

int val));

void (*SSL_CTX_get_info_callback(SSL_CTX *ctx)) (const SSL *ssl, int type,

int val);

void SSL_CTX_set_client_cert_cb(SSL_CTX *ctx,

int (*client_cert_cb) (SSL *ssl, X509 **x509,

EVP_PKEY **pkey));

int (*SSL_CTX_get_client_cert_cb(SSL_CTX *ctx)) (SSL *ssl, X509 **x509,

EVP_PKEY **pkey);

# ifndef OPENSSL_NO_ENGINE

__owur int SSL_CTX_set_client_cert_engine(SSL_CTX *ctx, ENGINE *e);

# endif

void SSL_CTX_set_cookie_generate_cb(SSL_CTX *ctx,

*cookie_len));

void SSL_CTX_set_cookie_verify_cb(SSL_CTX *ctx,

cookie_len));

# ifndef OPENSSL_NO_NEXTPROTONEG

void SSL_CTX_set_next_protos_advertised_cb(SSL_CTX *s,

void *arg), void *arg);

void SSL_CTX_set_next_proto_select_cb(SSL_CTX *s,

void *arg), void *arg);

void SSL_get0_next_proto_negotiated(const SSL *s, const unsigned char **data,

unsigned *len);

# endif

__owur int SSL_select_next_proto(unsigned char **out, unsigned char *outlen,

const unsigned char *in, unsigned int inlen,

const unsigned char *client,

unsigned int client_len);

# define OPENSSL_NPN_UNSUPPORTED 0

# define OPENSSL_NPN_NEGOTIATED 1

# define OPENSSL_NPN_NO_OVERLAP 2

__owur int SSL_CTX_set_alpn_protos(SSL_CTX *ctx, const unsigned char *protos,

unsigned protos_len);

__owur int SSL_set_alpn_protos(SSL *ssl, const unsigned char *protos,

unsigned protos_len);

void SSL_CTX_set_alpn_select_cb(SSL_CTX *ctx,

void *arg), void *arg);

void SSL_get0_alpn_selected(const SSL *ssl, const unsigned char **data,

unsigned *len);

# ifndef OPENSSL_NO_PSK

/*

* the maximum length of the buffer given to callbacks containing the

* resulting identity/psk

*/

# define PSK_MAX_IDENTITY_LEN 128

# define PSK_MAX_PSK_LEN 256

void SSL_CTX_set_psk_client_callback(SSL_CTX *ctx,

max_psk_len));

void SSL_set_psk_client_callback(SSL *ssl,

max_psk_len));

void SSL_CTX_set_psk_server_callback(SSL_CTX *ctx,

max_psk_len));

void SSL_set_psk_server_callback(SSL *ssl,

max_psk_len));

__owur int SSL_CTX_use_psk_identity_hint(SSL_CTX *ctx, const char *identity_hint);

__owur int SSL_use_psk_identity_hint(SSL *s, const char *identity_hint);

const char *SSL_get_psk_identity_hint(const SSL *s);

const char *SSL_get_psk_identity(const SSL *s);

# endif

/* Register callbacks to handle custom TLS Extensions for client or server. */

__owur int SSL_CTX_add_client_custom_ext(SSL_CTX *ctx, unsigned int ext_type,

void *parse_arg);

__owur int SSL_CTX_add_server_custom_ext(SSL_CTX *ctx, unsigned int ext_type,

void *parse_arg);

__owur int SSL_extension_supported(unsigned int ext_type);

# define SSL_NOTHING 1

# define SSL_WRITING 2

# define SSL_READING 3

# define SSL_X509_LOOKUP 4

/* These will only be used when doing non-blocking IO */

# define SSL_want_nothing(s) (SSL_want(s) == SSL_NOTHING)

# define SSL_want_read(s) (SSL_want(s) == SSL_READING)

# define SSL_want_write(s) (SSL_want(s) == SSL_WRITING)

# define SSL_want_x509_lookup(s) (SSL_want(s) == SSL_X509_LOOKUP)

# define SSL_MAC_FLAG_READ_MAC_STREAM 1

# define SSL_MAC_FLAG_WRITE_MAC_STREAM 2

#ifdef __cplusplus

}

#endif

# include <openssl/ssl2.h>

# include <openssl/ssl3.h>

# include <openssl/tls1.h> /* This is mostly sslv3 with a few tweaks */

# include <openssl/dtls1.h> /* Datagram TLS */

# include <openssl/srtp.h> /* Support for the use_srtp extension */

#ifdef __cplusplus

extern "C" {

#endif

/* compatibility */

# define SSL_set_app_data(s,arg) (SSL_set_ex_data(s,0,(char *)arg))

# define SSL_get_app_data(s) (SSL_get_ex_data(s,0))

# define SSL_SESSION_set_app_data(s,a) (SSL_SESSION_set_ex_data(s,0,(char *)a))

# define SSL_SESSION_get_app_data(s) (SSL_SESSION_get_ex_data(s,0))

# define SSL_CTX_get_app_data(ctx) (SSL_CTX_get_ex_data(ctx,0))

# define SSL_CTX_set_app_data(ctx,arg) (SSL_CTX_set_ex_data(ctx,0,(char *)arg))

/*

* The following are the possible values for ssl->state are are used to

* indicate where we are up to in the SSL connection establishment. The

* macros that follow are about the only things you should need to use and

* even then, only when using non-blocking IO. It can also be useful to work

* out where you were when the connection failed

*/

# define SSL_ST_CONNECT 0x1000

# define SSL_ST_ACCEPT 0x2000

# define SSL_ST_MASK 0x0FFF

# define SSL_ST_INIT (SSL_ST_CONNECT|SSL_ST_ACCEPT)

# define SSL_ST_BEFORE 0x4000

# define SSL_ST_OK 0x03

# define SSL_ST_RENEGOTIATE (0x04|SSL_ST_INIT)

# define SSL_ST_ERR 0x05

# define SSL_CB_LOOP 0x01

# define SSL_CB_EXIT 0x02

# define SSL_CB_READ 0x04

# define SSL_CB_WRITE 0x08

# define SSL_CB_ALERT 0x4000/* used in callback */

# define SSL_CB_READ_ALERT (SSL_CB_ALERT|SSL_CB_READ)

# define SSL_CB_WRITE_ALERT (SSL_CB_ALERT|SSL_CB_WRITE)

# define SSL_CB_ACCEPT_LOOP (SSL_ST_ACCEPT|SSL_CB_LOOP)

# define SSL_CB_ACCEPT_EXIT (SSL_ST_ACCEPT|SSL_CB_EXIT)

# define SSL_CB_CONNECT_LOOP (SSL_ST_CONNECT|SSL_CB_LOOP)

# define SSL_CB_CONNECT_EXIT (SSL_ST_CONNECT|SSL_CB_EXIT)

# define SSL_CB_HANDSHAKE_START 0x10

# define SSL_CB_HANDSHAKE_DONE 0x20

/* Is the SSL_connection established? */

# define SSL_get_state(a) SSL_state(a)

# define SSL_is_init_finished(a) (SSL_state(a) == SSL_ST_OK)

# define SSL_in_init(a) (SSL_state(a)&SSL_ST_INIT)

# define SSL_in_before(a) (SSL_state(a)&SSL_ST_BEFORE)

# define SSL_in_connect_init(a) (SSL_state(a)&SSL_ST_CONNECT)

# define SSL_in_accept_init(a) (SSL_state(a)&SSL_ST_ACCEPT)

/*

* The following 3 states are kept in ssl->rlayer.rstate when reads fail, you

* should not need these

*/

# define SSL_ST_READ_HEADER 0xF0

# define SSL_ST_READ_BODY 0xF1

# define SSL_ST_READ_DONE 0xF2

/*-

* Obtain latest Finished message

* -- that we sent (SSL_get_finished)

* -- that we expected from peer (SSL_get_peer_finished).

* Returns length (0 == no Finished so far), copies up to 'count' bytes.

*/

size_t SSL_get_finished(const SSL *s, void *buf, size_t count);

size_t SSL_get_peer_finished(const SSL *s, void *buf, size_t count);

/*

* use either SSL_VERIFY_NONE or SSL_VERIFY_PEER, the last 2 options are

* 'ored' with SSL_VERIFY_PEER if they are desired

*/

# define SSL_VERIFY_NONE 0x00

# define SSL_VERIFY_PEER 0x01

# define SSL_VERIFY_FAIL_IF_NO_PEER_CERT 0x02

# define SSL_VERIFY_CLIENT_ONCE 0x04

# define OpenSSL_add_ssl_algorithms() SSL_library_init()

# define SSLeay_add_ssl_algorithms() SSL_library_init()

/* More backward compatibility */

# define SSL_get_cipher(s) \

SSL_CIPHER_get_name(SSL_get_current_cipher(s))

# define SSL_get_cipher_bits(s,np) \

SSL_CIPHER_get_bits(SSL_get_current_cipher(s),np)

# define SSL_get_cipher_version(s) \

SSL_CIPHER_get_version(SSL_get_current_cipher(s))

# define SSL_get_cipher_name(s) \

SSL_CIPHER_get_name(SSL_get_current_cipher(s))

# define SSL_get_time(a) SSL_SESSION_get_time(a)

# define SSL_set_time(a,b) SSL_SESSION_set_time((a),(b))

# define SSL_get_timeout(a) SSL_SESSION_get_timeout(a)

# define SSL_set_timeout(a,b) SSL_SESSION_set_timeout((a),(b))