35863 lines
1 MiB
35863 lines
1 MiB
/* ssl.c
|
|
*
|
|
* Copyright (C) 2006-2023 wolfSSL Inc.
|
|
*
|
|
* This file is part of wolfSSL.
|
|
*
|
|
* wolfSSL is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* wolfSSL is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA
|
|
*/
|
|
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include <config.h>
|
|
#endif
|
|
|
|
#include <wolfssl/wolfcrypt/settings.h>
|
|
#if defined(OPENSSL_EXTRA) && !defined(_WIN32)
|
|
/* turn on GNU extensions for XISASCII */
|
|
#undef _GNU_SOURCE
|
|
#define _GNU_SOURCE
|
|
#endif
|
|
|
|
#if !defined(WOLFCRYPT_ONLY) || defined(OPENSSL_EXTRA) || \
|
|
defined(OPENSSL_EXTRA_X509_SMALL)
|
|
|
|
#include <wolfssl/internal.h>
|
|
#include <wolfssl/error-ssl.h>
|
|
#include <wolfssl/wolfcrypt/coding.h>
|
|
#include <wolfssl/wolfcrypt/kdf.h>
|
|
#ifdef NO_INLINE
|
|
#include <wolfssl/wolfcrypt/misc.h>
|
|
#else
|
|
#define WOLFSSL_MISC_INCLUDED
|
|
#include <wolfcrypt/src/misc.c>
|
|
#endif
|
|
|
|
#ifdef HAVE_ERRNO_H
|
|
#include <errno.h>
|
|
#endif
|
|
|
|
|
|
#if !defined(WOLFSSL_ALLOW_NO_SUITES) && !defined(WOLFCRYPT_ONLY)
|
|
#if defined(NO_DH) && !defined(HAVE_ECC) && !defined(WOLFSSL_STATIC_RSA) \
|
|
&& !defined(WOLFSSL_STATIC_DH) && !defined(WOLFSSL_STATIC_PSK) \
|
|
&& !defined(HAVE_CURVE25519) && !defined(HAVE_CURVE448)
|
|
#error "No cipher suites defined because DH disabled, ECC disabled, and no static suites defined. Please see top of README"
|
|
#endif
|
|
#ifdef WOLFSSL_CERT_GEN
|
|
/* need access to Cert struct for creating certificate */
|
|
#include <wolfssl/wolfcrypt/asn_public.h>
|
|
#endif
|
|
#endif
|
|
|
|
#if !defined(WOLFCRYPT_ONLY) && (defined(OPENSSL_EXTRA) \
|
|
|| defined(OPENSSL_EXTRA_X509_SMALL) \
|
|
|| defined(HAVE_WEBSERVER) || defined(WOLFSSL_KEY_GEN))
|
|
#include <wolfssl/openssl/evp.h>
|
|
/* openssl headers end, wolfssl internal headers next */
|
|
#endif
|
|
|
|
#include <wolfssl/wolfcrypt/wc_encrypt.h>
|
|
|
|
#ifndef NO_RSA
|
|
#include <wolfssl/wolfcrypt/rsa.h>
|
|
#endif
|
|
|
|
#ifdef OPENSSL_EXTRA
|
|
/* openssl headers begin */
|
|
#include <wolfssl/openssl/ssl.h>
|
|
#include <wolfssl/openssl/aes.h>
|
|
#ifndef WOLFCRYPT_ONLY
|
|
#include <wolfssl/openssl/hmac.h>
|
|
#include <wolfssl/openssl/cmac.h>
|
|
#endif
|
|
#include <wolfssl/openssl/crypto.h>
|
|
#include <wolfssl/openssl/des.h>
|
|
#include <wolfssl/openssl/bn.h>
|
|
#include <wolfssl/openssl/buffer.h>
|
|
#include <wolfssl/openssl/dh.h>
|
|
#include <wolfssl/openssl/rsa.h>
|
|
#include <wolfssl/openssl/fips_rand.h>
|
|
#include <wolfssl/openssl/pem.h>
|
|
#include <wolfssl/openssl/ec.h>
|
|
#include <wolfssl/openssl/ec25519.h>
|
|
#include <wolfssl/openssl/ed25519.h>
|
|
#include <wolfssl/openssl/ec448.h>
|
|
#include <wolfssl/openssl/ed448.h>
|
|
#include <wolfssl/openssl/ecdsa.h>
|
|
#include <wolfssl/openssl/ecdh.h>
|
|
#include <wolfssl/openssl/err.h>
|
|
#include <wolfssl/openssl/modes.h>
|
|
#include <wolfssl/openssl/opensslv.h>
|
|
#include <wolfssl/openssl/rc4.h>
|
|
#include <wolfssl/openssl/stack.h>
|
|
#include <wolfssl/openssl/x509_vfy.h>
|
|
/* openssl headers end, wolfssl internal headers next */
|
|
#include <wolfssl/wolfcrypt/hmac.h>
|
|
#include <wolfssl/wolfcrypt/random.h>
|
|
#include <wolfssl/wolfcrypt/des3.h>
|
|
#include <wolfssl/wolfcrypt/ecc.h>
|
|
#include <wolfssl/wolfcrypt/md4.h>
|
|
#include <wolfssl/wolfcrypt/md5.h>
|
|
#include <wolfssl/wolfcrypt/arc4.h>
|
|
#include <wolfssl/wolfcrypt/curve25519.h>
|
|
#include <wolfssl/wolfcrypt/ed25519.h>
|
|
#include <wolfssl/wolfcrypt/curve448.h>
|
|
#if defined(HAVE_PQC)
|
|
#if defined(HAVE_FALCON)
|
|
#include <wolfssl/wolfcrypt/falcon.h>
|
|
#endif /* HAVE_FALCON */
|
|
#if defined(HAVE_DILITHIUM)
|
|
#include <wolfssl/wolfcrypt/dilithium.h>
|
|
#endif /* HAVE_DILITHIUM */
|
|
#endif /* HAVE_PQC */
|
|
#if defined(OPENSSL_ALL) || defined(HAVE_STUNNEL)
|
|
#ifdef HAVE_OCSP
|
|
#include <wolfssl/openssl/ocsp.h>
|
|
#endif
|
|
#include <wolfssl/openssl/lhash.h>
|
|
#include <wolfssl/openssl/txt_db.h>
|
|
#endif /* WITH_STUNNEL */
|
|
#if defined(WOLFSSL_SHA512) || defined(WOLFSSL_SHA384)
|
|
#include <wolfssl/wolfcrypt/sha512.h>
|
|
#endif
|
|
#if defined(WOLFCRYPT_HAVE_SRP) && !defined(NO_SHA256) \
|
|
&& !defined(WC_NO_RNG)
|
|
#include <wolfssl/wolfcrypt/srp.h>
|
|
#endif
|
|
#if defined(HAVE_FIPS) || defined(HAVE_SELFTEST)
|
|
#include <wolfssl/wolfcrypt/pkcs7.h>
|
|
#endif
|
|
#if defined(OPENSSL_ALL) && defined(HAVE_PKCS7)
|
|
#include <wolfssl/openssl/pkcs7.h>
|
|
#endif /* OPENSSL_ALL && HAVE_PKCS7 */
|
|
#endif
|
|
|
|
#if defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL)
|
|
#include <wolfssl/openssl/x509v3.h>
|
|
int wolfssl_bn_get_value(WOLFSSL_BIGNUM* bn, mp_int* mpi);
|
|
int wolfssl_bn_set_value(WOLFSSL_BIGNUM** bn, mp_int* mpi);
|
|
#endif
|
|
|
|
#if defined(WOLFSSL_QT)
|
|
#include <wolfssl/wolfcrypt/sha.h>
|
|
#endif
|
|
|
|
#ifdef NO_ASN
|
|
#include <wolfssl/wolfcrypt/dh.h>
|
|
#endif
|
|
#endif /* !WOLFCRYPT_ONLY || OPENSSL_EXTRA */
|
|
|
|
#ifdef WOLFSSL_SYS_CA_CERTS
|
|
|
|
#ifdef _WIN32
|
|
#include <windows.h>
|
|
#include <wincrypt.h>
|
|
|
|
/* mingw gcc does not support pragma comment, and the
|
|
* linking with crypt32 is handled in configure.ac */
|
|
#if !defined(__MINGW32__) && !defined(__MINGW64__)
|
|
#pragma comment(lib, "crypt32")
|
|
#endif
|
|
#endif
|
|
|
|
#if defined(__APPLE__) && defined(HAVE_SECURITY_SECTRUSTSETTINGS_H)
|
|
#include <Security/SecTrustSettings.h>
|
|
#endif
|
|
|
|
#endif /* WOLFSSL_SYS_CA_CERTS */
|
|
|
|
/*
|
|
* OPENSSL_COMPATIBLE_DEFAULTS:
|
|
* Enable default behaviour that is compatible with OpenSSL. For example
|
|
* SSL_CTX by default doesn't verify the loaded certs. Enabling this
|
|
* should make porting to new projects easier.
|
|
* WOLFSSL_CHECK_ALERT_ON_ERR:
|
|
* Check for alerts during the handshake in the event of an error.
|
|
* NO_SESSION_CACHE_REF:
|
|
* wolfSSL_get_session on a client will return a reference to the internal
|
|
* ClientCache by default for backwards compatibility. This define will
|
|
* make wolfSSL_get_session return a reference to ssl->session. The returned
|
|
* pointer will be freed with the related WOLFSSL object.
|
|
* SESSION_CACHE_DYNAMIC_MEM:
|
|
* Dynamically allocate sessions for the session cache from the heap, as
|
|
* opposed to the default which allocates from the stack. Allocates
|
|
* memory only when a session is added to the cache, frees memory after the
|
|
* session is no longer being used. Recommended for memory-constrained
|
|
* systems.
|
|
* WOLFSSL_SYS_CA_CERTS
|
|
* Enables ability to load system CA certs from the OS via
|
|
* wolfSSL_CTX_load_system_CA_certs.
|
|
*/
|
|
|
|
#define WOLFSSL_SSL_MISC_INCLUDED
|
|
#include "src/ssl_misc.c"
|
|
|
|
#define WOLFSSL_EVP_INCLUDED
|
|
#include "wolfcrypt/src/evp.c"
|
|
|
|
/* Crypto code uses EVP APIs. */
|
|
#define WOLFSSL_SSL_CRYPTO_INCLUDED
|
|
#include "src/ssl_crypto.c"
|
|
|
|
#ifndef WOLFCRYPT_ONLY
|
|
#define WOLFSSL_SSL_CERTMAN_INCLUDED
|
|
#include "src/ssl_certman.c"
|
|
#endif
|
|
|
|
#if (defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL)) && \
|
|
!defined(WOLFCRYPT_ONLY)
|
|
/* Convert shortname to NID.
|
|
*
|
|
* For OpenSSL compatibility.
|
|
*
|
|
* This function shouldn't exist!
|
|
* Uses defines in wolfssl/openssl/evp.h.
|
|
* Uses EccEnumToNID which uses defines in wolfssl/openssl/ec.h.
|
|
*
|
|
* @param [in] sn Short name of OID.
|
|
* @return NID corresponding to shortname on success.
|
|
* @return NID_undef when not recognized.
|
|
*/
|
|
int wc_OBJ_sn2nid(const char *sn)
|
|
{
|
|
const struct {
|
|
const char *sn;
|
|
int nid;
|
|
} sn2nid[] = {
|
|
#ifndef NO_CERTS
|
|
{WOLFSSL_COMMON_NAME, NID_commonName},
|
|
{WOLFSSL_COUNTRY_NAME, NID_countryName},
|
|
{WOLFSSL_LOCALITY_NAME, NID_localityName},
|
|
{WOLFSSL_STATE_NAME, NID_stateOrProvinceName},
|
|
{WOLFSSL_ORG_NAME, NID_organizationName},
|
|
{WOLFSSL_ORGUNIT_NAME, NID_organizationalUnitName},
|
|
#ifdef WOLFSSL_CERT_NAME_ALL
|
|
{WOLFSSL_NAME, NID_name},
|
|
{WOLFSSL_INITIALS, NID_initials},
|
|
{WOLFSSL_GIVEN_NAME, NID_givenName},
|
|
{WOLFSSL_DNQUALIFIER, NID_dnQualifier},
|
|
#endif
|
|
{WOLFSSL_EMAIL_ADDR, NID_emailAddress},
|
|
#endif
|
|
{"SHA1", NID_sha1},
|
|
{NULL, -1}};
|
|
int i;
|
|
#ifdef HAVE_ECC
|
|
char curveName[ECC_MAXNAME + 1];
|
|
int eccEnum;
|
|
#endif
|
|
|
|
WOLFSSL_ENTER("wc_OBJ_sn2nid");
|
|
|
|
for(i=0; sn2nid[i].sn != NULL; i++) {
|
|
if (XSTRCMP(sn, sn2nid[i].sn) == 0) {
|
|
return sn2nid[i].nid;
|
|
}
|
|
}
|
|
|
|
#ifdef HAVE_ECC
|
|
if (XSTRLEN(sn) > ECC_MAXNAME)
|
|
return NID_undef;
|
|
|
|
/* Nginx uses this OpenSSL string. */
|
|
if (XSTRCMP(sn, "prime256v1") == 0)
|
|
sn = "SECP256R1";
|
|
/* OpenSSL allows lowercase curve names */
|
|
for (i = 0; i < (int)(sizeof(curveName) - 1) && *sn; i++) {
|
|
curveName[i] = (char)XTOUPPER((unsigned char) *sn++);
|
|
}
|
|
curveName[i] = '\0';
|
|
/* find based on name and return NID */
|
|
for (i = 0;
|
|
#ifndef WOLFSSL_ECC_CURVE_STATIC
|
|
ecc_sets[i].size != 0 && ecc_sets[i].name != NULL;
|
|
#else
|
|
ecc_sets[i].size != 0;
|
|
#endif
|
|
i++) {
|
|
if (XSTRCMP(curveName, ecc_sets[i].name) == 0) {
|
|
eccEnum = ecc_sets[i].id;
|
|
/* Convert enum value in ecc_curve_id to OpenSSL NID */
|
|
return EccEnumToNID(eccEnum);
|
|
}
|
|
}
|
|
#endif /* HAVE_ECC */
|
|
|
|
return NID_undef;
|
|
}
|
|
#endif /* OPENSSL_EXTRA || OPENSSL_EXTRA_X509_SMALL */
|
|
|
|
#ifndef WOLFCRYPT_ONLY
|
|
|
|
#if !defined(NO_RSA) || !defined(NO_DH) || defined(HAVE_ECC) || \
|
|
(defined(OPENSSL_EXTRA) && defined(WOLFSSL_KEY_GEN) && !defined(NO_DSA))
|
|
|
|
#define HAVE_GLOBAL_RNG /* consolidate flags for using globalRNG */
|
|
static WC_RNG globalRNG;
|
|
static int initGlobalRNG = 0;
|
|
|
|
static wolfSSL_Mutex globalRNGMutex;
|
|
static int globalRNGMutex_valid = 0;
|
|
|
|
#if defined(OPENSSL_EXTRA) && defined(HAVE_HASHDRBG)
|
|
static WOLFSSL_DRBG_CTX* gDrbgDefCtx = NULL;
|
|
#endif
|
|
|
|
WC_RNG* wolfssl_get_global_rng(void)
|
|
{
|
|
WC_RNG* ret = NULL;
|
|
|
|
if (initGlobalRNG == 0)
|
|
WOLFSSL_MSG("Global RNG no Init");
|
|
else
|
|
ret = &globalRNG;
|
|
|
|
return ret;
|
|
}
|
|
|
|
/* Make a global RNG and return.
|
|
*
|
|
* @return Global RNG on success.
|
|
* @return NULL on error.
|
|
*/
|
|
WC_RNG* wolfssl_make_global_rng(void)
|
|
{
|
|
WC_RNG* ret;
|
|
|
|
#ifdef HAVE_GLOBAL_RNG
|
|
/* Get the global random number generator instead. */
|
|
ret = wolfssl_get_global_rng();
|
|
#ifdef OPENSSL_EXTRA
|
|
if (ret == NULL) {
|
|
/* Create a global random if possible. */
|
|
(void)wolfSSL_RAND_Init();
|
|
ret = wolfssl_get_global_rng();
|
|
}
|
|
#endif
|
|
#else
|
|
WOLFSSL_ERROR_MSG("Bad RNG Init");
|
|
ret = NULL;
|
|
#endif
|
|
|
|
return ret;
|
|
}
|
|
|
|
/* Too many defines to check explicitly - prototype it and always include
|
|
* for RSA, DH, ECC and DSA for BN. */
|
|
WC_RNG* wolfssl_make_rng(WC_RNG* rng, int* local);
|
|
|
|
/* Make a random number generator or get global if possible.
|
|
*
|
|
* Global may not be available and NULL will be returned.
|
|
*
|
|
* @param [in, out] rng Local random number generator.
|
|
* @param [out] local Local random number generator returned.
|
|
* @return NULL on failure.
|
|
* @return A random number generator object.
|
|
*/
|
|
WC_RNG* wolfssl_make_rng(WC_RNG* rng, int* local)
|
|
{
|
|
WC_RNG* ret = NULL;
|
|
|
|
/* Assume not local until one created. */
|
|
*local = 0;
|
|
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
/* Allocate RNG object . */
|
|
rng = (WC_RNG*)XMALLOC(sizeof(WC_RNG), NULL, DYNAMIC_TYPE_RNG);
|
|
#endif
|
|
/* Check we have a local RNG object and initialize. */
|
|
if ((rng != NULL) && (wc_InitRng(rng) == 0)) {
|
|
ret = rng;
|
|
*local = 1;
|
|
}
|
|
if (ret == NULL) {
|
|
#ifdef HAVE_GLOBAL_RNG
|
|
WOLFSSL_MSG("Bad RNG Init, trying global");
|
|
#endif
|
|
ret = wolfssl_make_global_rng();
|
|
}
|
|
|
|
if (ret != rng) {
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
XFREE(rng, NULL, DYNAMIC_TYPE_RNG);
|
|
#endif
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
#endif
|
|
|
|
#ifdef OPENSSL_EXTRA
|
|
/* WOLFSSL_NO_OPENSSL_RAND_CB: Allows way to reduce code size for
|
|
* OPENSSL_EXTRA where RAND callbacks are not used */
|
|
#ifndef WOLFSSL_NO_OPENSSL_RAND_CB
|
|
static const WOLFSSL_RAND_METHOD* gRandMethods = NULL;
|
|
static int gRandMethodsInit = 0;
|
|
static wolfSSL_Mutex gRandMethodMutex;
|
|
#endif /* !WOLFSSL_NO_OPENSSL_RAND_CB */
|
|
#endif /* OPENSSL_EXTRA */
|
|
|
|
#define WOLFSSL_SSL_BN_INCLUDED
|
|
#include "src/ssl_bn.c"
|
|
|
|
#ifndef OPENSSL_EXTRA_NO_ASN1
|
|
#define WOLFSSL_SSL_ASN1_INCLUDED
|
|
#include "src/ssl_asn1.c"
|
|
#endif /* OPENSSL_EXTRA_NO_ASN1 */
|
|
|
|
#define WOLFSSL_PK_INCLUDED
|
|
#include "src/pk.c"
|
|
|
|
#include <wolfssl/wolfcrypt/hpke.h>
|
|
|
|
#if defined(OPENSSL_EXTRA) && defined(HAVE_ECC)
|
|
const WOLF_EC_NIST_NAME kNistCurves[] = {
|
|
{XSTR_SIZEOF("P-192"), "P-192", NID_X9_62_prime192v1},
|
|
{XSTR_SIZEOF("P-256"), "P-256", NID_X9_62_prime256v1},
|
|
{XSTR_SIZEOF("P-112"), "P-112", NID_secp112r1},
|
|
{XSTR_SIZEOF("P-112-2"), "P-112-2", NID_secp112r2},
|
|
{XSTR_SIZEOF("P-128"), "P-128", NID_secp128r1},
|
|
{XSTR_SIZEOF("P-128-2"), "P-128-2", NID_secp128r2},
|
|
{XSTR_SIZEOF("P-160"), "P-160", NID_secp160r1},
|
|
{XSTR_SIZEOF("P-160-2"), "P-160-2", NID_secp160r2},
|
|
{XSTR_SIZEOF("P-224"), "P-224", NID_secp224r1},
|
|
{XSTR_SIZEOF("P-384"), "P-384", NID_secp384r1},
|
|
{XSTR_SIZEOF("P-521"), "P-521", NID_secp521r1},
|
|
{XSTR_SIZEOF("K-160"), "K-160", NID_secp160k1},
|
|
{XSTR_SIZEOF("K-192"), "K-192", NID_secp192k1},
|
|
{XSTR_SIZEOF("K-224"), "K-224", NID_secp224k1},
|
|
{XSTR_SIZEOF("K-256"), "K-256", NID_secp256k1},
|
|
{XSTR_SIZEOF("B-160"), "B-160", NID_brainpoolP160r1},
|
|
{XSTR_SIZEOF("B-192"), "B-192", NID_brainpoolP192r1},
|
|
{XSTR_SIZEOF("B-224"), "B-224", NID_brainpoolP224r1},
|
|
{XSTR_SIZEOF("B-256"), "B-256", NID_brainpoolP256r1},
|
|
{XSTR_SIZEOF("B-320"), "B-320", NID_brainpoolP320r1},
|
|
{XSTR_SIZEOF("B-384"), "B-384", NID_brainpoolP384r1},
|
|
{XSTR_SIZEOF("B-512"), "B-512", NID_brainpoolP512r1},
|
|
#ifdef HAVE_PQC
|
|
{XSTR_SIZEOF("KYBER_LEVEL1"), "KYBER_LEVEL1", WOLFSSL_KYBER_LEVEL1},
|
|
{XSTR_SIZEOF("KYBER_LEVEL3"), "KYBER_LEVEL3", WOLFSSL_KYBER_LEVEL3},
|
|
{XSTR_SIZEOF("KYBER_LEVEL5"), "KYBER_LEVEL5", WOLFSSL_KYBER_LEVEL5},
|
|
#ifdef HAVE_LIBOQS
|
|
{XSTR_SIZEOF("P256_KYBER_LEVEL1"), "P256_KYBER_LEVEL1", WOLFSSL_P256_KYBER_LEVEL1},
|
|
{XSTR_SIZEOF("P384_KYBER_LEVEL3"), "P384_KYBER_LEVEL3", WOLFSSL_P384_KYBER_LEVEL3},
|
|
{XSTR_SIZEOF("P521_KYBER_LEVEL5"), "P521_KYBER_LEVEL5", WOLFSSL_P521_KYBER_LEVEL5},
|
|
#endif
|
|
#endif
|
|
#ifdef WOLFSSL_SM2
|
|
{XSTR_SIZEOF("SM2"), "SM2", NID_sm2},
|
|
#endif
|
|
{0, NULL, 0},
|
|
};
|
|
#endif
|
|
|
|
#if defined(WOLFSSL_TLS13) && defined(HAVE_ECH)
|
|
/* create the hpke key and ech config to send to clients */
|
|
int wolfSSL_CTX_GenerateEchConfig(WOLFSSL_CTX* ctx, const char* publicName,
|
|
word16 kemId, word16 kdfId, word16 aeadId)
|
|
{
|
|
int ret = 0;
|
|
word16 encLen = DHKEM_X25519_ENC_LEN;
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
Hpke* hpke = NULL;
|
|
WC_RNG* rng;
|
|
#else
|
|
Hpke hpke[1];
|
|
WC_RNG rng[1];
|
|
#endif
|
|
|
|
if (ctx == NULL || publicName == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
rng = (WC_RNG*)XMALLOC(sizeof(WC_RNG), ctx->heap, DYNAMIC_TYPE_RNG);
|
|
if (rng == NULL)
|
|
return MEMORY_E;
|
|
#endif
|
|
ret = wc_InitRng(rng);
|
|
if (ret != 0) {
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
XFREE(rng, ctx->heap, DYNAMIC_TYPE_RNG);
|
|
#endif
|
|
return ret;
|
|
}
|
|
|
|
ctx->echConfigs = (WOLFSSL_EchConfig*)XMALLOC(sizeof(WOLFSSL_EchConfig),
|
|
ctx->heap, DYNAMIC_TYPE_TMP_BUFFER);
|
|
if (ctx->echConfigs == NULL)
|
|
ret = MEMORY_E;
|
|
else
|
|
XMEMSET(ctx->echConfigs, 0, sizeof(WOLFSSL_EchConfig));
|
|
|
|
/* set random config id */
|
|
if (ret == 0)
|
|
ret = wc_RNG_GenerateByte(rng, &ctx->echConfigs->configId);
|
|
|
|
/* if 0 is selected for algorithms use default, may change with draft */
|
|
if (kemId == 0)
|
|
kemId = DHKEM_X25519_HKDF_SHA256;
|
|
|
|
if (kdfId == 0)
|
|
kdfId = HKDF_SHA256;
|
|
|
|
if (aeadId == 0)
|
|
aeadId = HPKE_AES_128_GCM;
|
|
|
|
if (ret == 0) {
|
|
/* set the kem id */
|
|
ctx->echConfigs->kemId = kemId;
|
|
|
|
/* set the cipher suite, only 1 for now */
|
|
ctx->echConfigs->numCipherSuites = 1;
|
|
ctx->echConfigs->cipherSuites = (EchCipherSuite*)XMALLOC(
|
|
sizeof(EchCipherSuite), ctx->heap, DYNAMIC_TYPE_TMP_BUFFER);
|
|
|
|
if (ctx->echConfigs->cipherSuites == NULL) {
|
|
ret = MEMORY_E;
|
|
}
|
|
else {
|
|
ctx->echConfigs->cipherSuites[0].kdfId = kdfId;
|
|
ctx->echConfigs->cipherSuites[0].aeadId = aeadId;
|
|
}
|
|
}
|
|
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
if (ret == 0) {
|
|
hpke = (Hpke*)XMALLOC(sizeof(Hpke), ctx->heap, DYNAMIC_TYPE_TMP_BUFFER);
|
|
if (hpke == NULL)
|
|
ret = MEMORY_E;
|
|
}
|
|
#endif
|
|
|
|
if (ret == 0)
|
|
ret = wc_HpkeInit(hpke, kemId, kdfId, aeadId, ctx->heap);
|
|
|
|
/* generate the receiver private key */
|
|
if (ret == 0)
|
|
ret = wc_HpkeGenerateKeyPair(hpke, &ctx->echConfigs->receiverPrivkey,
|
|
rng);
|
|
|
|
/* done with RNG */
|
|
wc_FreeRng(rng);
|
|
|
|
/* serialize the receiver key */
|
|
if (ret == 0)
|
|
ret = wc_HpkeSerializePublicKey(hpke, ctx->echConfigs->receiverPrivkey,
|
|
ctx->echConfigs->receiverPubkey, &encLen);
|
|
|
|
if (ret == 0) {
|
|
ctx->echConfigs->publicName = (char*)XMALLOC(XSTRLEN(publicName) + 1,
|
|
ctx->heap, DYNAMIC_TYPE_TMP_BUFFER);
|
|
if (ctx->echConfigs->publicName == NULL) {
|
|
ret = MEMORY_E;
|
|
}
|
|
else {
|
|
XMEMCPY(ctx->echConfigs->publicName, publicName,
|
|
XSTRLEN(publicName) + 1);
|
|
}
|
|
}
|
|
|
|
if (ret != 0) {
|
|
if (ctx->echConfigs) {
|
|
XFREE(ctx->echConfigs->cipherSuites, ctx->heap,
|
|
DYNAMIC_TYPE_TMP_BUFFER);
|
|
XFREE(ctx->echConfigs->publicName, ctx->heap,
|
|
DYNAMIC_TYPE_TMP_BUFFER);
|
|
XFREE(ctx->echConfigs, ctx->heap, DYNAMIC_TYPE_TMP_BUFFER);
|
|
/* set to null to avoid double free in cleanup */
|
|
ctx->echConfigs = NULL;
|
|
}
|
|
}
|
|
|
|
if (ret == 0)
|
|
ret = WOLFSSL_SUCCESS;
|
|
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
XFREE(hpke, ctx->heap, DYNAMIC_TYPE_TMP_BUFFER);
|
|
XFREE(rng, ctx->heap, DYNAMIC_TYPE_RNG);
|
|
#endif
|
|
|
|
return ret;
|
|
}
|
|
|
|
/* get the ech configs that the server context is using */
|
|
int wolfSSL_CTX_GetEchConfigs(WOLFSSL_CTX* ctx, byte* output,
|
|
word32* outputLen) {
|
|
if (ctx == NULL || outputLen == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
/* if we don't have ech configs */
|
|
if (ctx->echConfigs == NULL) {
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
|
|
return GetEchConfigsEx(ctx->echConfigs, output, outputLen);
|
|
}
|
|
|
|
/* set the ech config from base64 for our client ssl object, base64 is the
|
|
* format ech configs are sent using dns records */
|
|
int wolfSSL_SetEchConfigsBase64(WOLFSSL* ssl, char* echConfigs64,
|
|
word32 echConfigs64Len)
|
|
{
|
|
int ret = 0;
|
|
word32 decodedLen = echConfigs64Len * 3 / 4 + 1;
|
|
byte* decodedConfigs;
|
|
|
|
if (ssl == NULL || echConfigs64 == NULL || echConfigs64Len == 0)
|
|
return BAD_FUNC_ARG;
|
|
|
|
/* already have ech configs */
|
|
if (ssl->options.useEch == 1) {
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
|
|
decodedConfigs = (byte*)XMALLOC(decodedLen, ssl->heap,
|
|
DYNAMIC_TYPE_TMP_BUFFER);
|
|
|
|
if (decodedConfigs == NULL)
|
|
return MEMORY_E;
|
|
|
|
decodedConfigs[decodedLen - 1] = 0;
|
|
|
|
/* decode the echConfigs */
|
|
ret = Base64_Decode((byte*)echConfigs64, echConfigs64Len,
|
|
decodedConfigs, &decodedLen);
|
|
|
|
if (ret != 0) {
|
|
XFREE(decodedConfigs, ssl->heap, DYNAMIC_TYPE_TMP_BUFFER);
|
|
return ret;
|
|
}
|
|
|
|
ret = wolfSSL_SetEchConfigs(ssl, decodedConfigs, decodedLen);
|
|
|
|
XFREE(decodedConfigs, ssl->heap, DYNAMIC_TYPE_TMP_BUFFER);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/* set the ech config from a raw buffer, this is the format ech configs are
|
|
* sent using retry_configs from the ech server */
|
|
int wolfSSL_SetEchConfigs(WOLFSSL* ssl, const byte* echConfigs,
|
|
word32 echConfigsLen)
|
|
{
|
|
int ret = 0;
|
|
int i;
|
|
int j;
|
|
word16 totalLength;
|
|
word16 version;
|
|
word16 length;
|
|
word16 hpkePubkeyLen;
|
|
word16 cipherSuitesLen;
|
|
word16 publicNameLen;
|
|
WOLFSSL_EchConfig* configList = NULL;
|
|
WOLFSSL_EchConfig* workingConfig = NULL;
|
|
WOLFSSL_EchConfig* lastConfig = NULL;
|
|
byte* echConfig = NULL;
|
|
|
|
if (ssl == NULL || echConfigs == NULL || echConfigsLen == 0)
|
|
return BAD_FUNC_ARG;
|
|
|
|
/* already have ech configs */
|
|
if (ssl->options.useEch == 1) {
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
|
|
/* check that the total length is well formed */
|
|
ato16(echConfigs, &totalLength);
|
|
|
|
if (totalLength != echConfigsLen - 2) {
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
|
|
/* skip the total length uint16_t */
|
|
i = 2;
|
|
|
|
do {
|
|
echConfig = (byte*)echConfigs + i;
|
|
ato16(echConfig, &version);
|
|
ato16(echConfig + 2, &length);
|
|
|
|
/* if the version does not match */
|
|
if (version != TLSX_ECH) {
|
|
/* we hit the end of the configs */
|
|
if ( (word32)i + 2 >= echConfigsLen ) {
|
|
break;
|
|
}
|
|
|
|
/* skip this config, +4 for version and length */
|
|
i += length + 4;
|
|
continue;
|
|
}
|
|
|
|
/* check if the length will overrun the buffer */
|
|
if ((word32)i + length + 4 > echConfigsLen) {
|
|
break;
|
|
}
|
|
|
|
if (workingConfig == NULL) {
|
|
workingConfig =
|
|
(WOLFSSL_EchConfig*)XMALLOC(sizeof(WOLFSSL_EchConfig),
|
|
ssl->heap, DYNAMIC_TYPE_TMP_BUFFER);
|
|
configList = workingConfig;
|
|
if (workingConfig != NULL) {
|
|
workingConfig->next = NULL;
|
|
}
|
|
}
|
|
else {
|
|
lastConfig = workingConfig;
|
|
workingConfig->next =
|
|
(WOLFSSL_EchConfig*)XMALLOC(sizeof(WOLFSSL_EchConfig),
|
|
ssl->heap, DYNAMIC_TYPE_TMP_BUFFER);
|
|
workingConfig = workingConfig->next;
|
|
}
|
|
|
|
if (workingConfig == NULL) {
|
|
ret = MEMORY_E;
|
|
break;
|
|
}
|
|
|
|
XMEMSET(workingConfig, 0, sizeof(WOLFSSL_EchConfig));
|
|
|
|
/* rawLen */
|
|
workingConfig->rawLen = length + 4;
|
|
|
|
/* raw body */
|
|
workingConfig->raw = (byte*)XMALLOC(workingConfig->rawLen,
|
|
ssl->heap, DYNAMIC_TYPE_TMP_BUFFER);
|
|
if (workingConfig->raw == NULL) {
|
|
ret = MEMORY_E;
|
|
break;
|
|
}
|
|
|
|
XMEMCPY(workingConfig->raw, echConfig, workingConfig->rawLen);
|
|
|
|
/* skip over version and length */
|
|
echConfig += 4;
|
|
|
|
/* configId, 1 byte */
|
|
workingConfig->configId = *(echConfig);
|
|
echConfig++;
|
|
/* kemId, 2 bytes */
|
|
ato16(echConfig, &workingConfig->kemId);
|
|
echConfig += 2;
|
|
/* hpke public_key length, 2 bytes */
|
|
ato16(echConfig, &hpkePubkeyLen);
|
|
echConfig += 2;
|
|
/* hpke public_key */
|
|
XMEMCPY(workingConfig->receiverPubkey, echConfig, hpkePubkeyLen);
|
|
echConfig += hpkePubkeyLen;
|
|
/* cipherSuitesLen */
|
|
ato16(echConfig, &cipherSuitesLen);
|
|
|
|
workingConfig->cipherSuites = (EchCipherSuite*)XMALLOC(cipherSuitesLen,
|
|
ssl->heap, DYNAMIC_TYPE_TMP_BUFFER);
|
|
if (workingConfig->cipherSuites == NULL) {
|
|
ret = MEMORY_E;
|
|
break;
|
|
}
|
|
|
|
echConfig += 2;
|
|
workingConfig->numCipherSuites = cipherSuitesLen / 4;
|
|
/* cipherSuites */
|
|
for (j = 0; j < workingConfig->numCipherSuites; j++) {
|
|
ato16(echConfig + j * 4, &workingConfig->cipherSuites[j].kdfId);
|
|
ato16(echConfig + j * 4 + 2,
|
|
&workingConfig->cipherSuites[j].aeadId);
|
|
}
|
|
echConfig += cipherSuitesLen;
|
|
/* publicNameLen */
|
|
ato16(echConfig, &publicNameLen);
|
|
workingConfig->publicName = (char*)XMALLOC(publicNameLen + 1,
|
|
ssl->heap, DYNAMIC_TYPE_TMP_BUFFER);
|
|
if (workingConfig->publicName == NULL) {
|
|
ret = MEMORY_E;
|
|
break;
|
|
}
|
|
|
|
echConfig += 2;
|
|
/* publicName */
|
|
XMEMCPY(workingConfig->publicName, echConfig, publicNameLen);
|
|
/* null terminated */
|
|
workingConfig->publicName[publicNameLen] = 0;
|
|
|
|
/* add length to go to next config, +4 for version and length */
|
|
i += length + 4;
|
|
|
|
/* check that we support this config */
|
|
for (j = 0; j < HPKE_SUPPORTED_KEM_LEN; j++) {
|
|
if (hpkeSupportedKem[j] == workingConfig->kemId)
|
|
break;
|
|
}
|
|
|
|
/* if we don't support the kem or at least one cipher suite */
|
|
if (j >= HPKE_SUPPORTED_KEM_LEN ||
|
|
EchConfigGetSupportedCipherSuite(workingConfig) < 0)
|
|
{
|
|
XFREE(workingConfig->cipherSuites, ssl->heap,
|
|
DYNAMIC_TYPE_TMP_BUFFER);
|
|
XFREE(workingConfig->publicName, ssl->heap,
|
|
DYNAMIC_TYPE_TMP_BUFFER);
|
|
XFREE(workingConfig->raw, ssl->heap, DYNAMIC_TYPE_TMP_BUFFER);
|
|
workingConfig = lastConfig;
|
|
}
|
|
} while ((word32)i < echConfigsLen);
|
|
|
|
/* if we found valid configs */
|
|
if (ret == 0 && configList != NULL) {
|
|
ssl->options.useEch = 1;
|
|
ssl->echConfigs = configList;
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
workingConfig = configList;
|
|
|
|
while (workingConfig != NULL) {
|
|
lastConfig = workingConfig;
|
|
workingConfig = workingConfig->next;
|
|
|
|
XFREE(lastConfig->cipherSuites, ssl->heap, DYNAMIC_TYPE_TMP_BUFFER);
|
|
XFREE(lastConfig->publicName, ssl->heap, DYNAMIC_TYPE_TMP_BUFFER);
|
|
XFREE(lastConfig->raw, ssl->heap, DYNAMIC_TYPE_TMP_BUFFER);
|
|
|
|
XFREE(lastConfig, ssl->heap, DYNAMIC_TYPE_TMP_BUFFER);
|
|
}
|
|
|
|
if (ret == 0)
|
|
return WOLFSSL_FATAL_ERROR;
|
|
|
|
return ret;
|
|
}
|
|
|
|
/* get the raw ech config from our struct */
|
|
int GetEchConfig(WOLFSSL_EchConfig* config, byte* output, word32* outputLen)
|
|
{
|
|
int i;
|
|
word16 totalLen = 0;
|
|
|
|
if (config == NULL || (output == NULL && outputLen == NULL))
|
|
return BAD_FUNC_ARG;
|
|
|
|
/* 2 for version */
|
|
totalLen += 2;
|
|
/* 2 for length */
|
|
totalLen += 2;
|
|
/* 1 for configId */
|
|
totalLen += 1;
|
|
/* 2 for kemId */
|
|
totalLen += 2;
|
|
/* 2 for hpke_len */
|
|
totalLen += 2;
|
|
|
|
/* hpke_pub_key */
|
|
switch (config->kemId) {
|
|
case DHKEM_P256_HKDF_SHA256:
|
|
totalLen += DHKEM_P256_ENC_LEN;
|
|
break;
|
|
case DHKEM_P384_HKDF_SHA384:
|
|
totalLen += DHKEM_P384_ENC_LEN;
|
|
break;
|
|
case DHKEM_P521_HKDF_SHA512:
|
|
totalLen += DHKEM_P521_ENC_LEN;
|
|
break;
|
|
case DHKEM_X25519_HKDF_SHA256:
|
|
totalLen += DHKEM_X25519_ENC_LEN;
|
|
break;
|
|
case DHKEM_X448_HKDF_SHA512:
|
|
totalLen += DHKEM_X448_ENC_LEN;
|
|
break;
|
|
}
|
|
|
|
/* cipherSuitesLen */
|
|
totalLen += 2;
|
|
/* cipherSuites */
|
|
totalLen += config->numCipherSuites * 4;
|
|
/* public name len */
|
|
totalLen += 2;
|
|
|
|
/* public name */
|
|
totalLen += XSTRLEN(config->publicName);
|
|
/* trailing zeros */
|
|
totalLen += 2;
|
|
|
|
if (output == NULL) {
|
|
*outputLen = totalLen;
|
|
return LENGTH_ONLY_E;
|
|
}
|
|
|
|
if (totalLen > *outputLen) {
|
|
*outputLen = totalLen;
|
|
return INPUT_SIZE_E;
|
|
}
|
|
|
|
/* version */
|
|
c16toa(TLSX_ECH, output);
|
|
output += 2;
|
|
|
|
/* length - 4 for version and length itself */
|
|
c16toa(totalLen - 4, output);
|
|
output += 2;
|
|
|
|
/* configId */
|
|
*output = config->configId;
|
|
output++;
|
|
/* kemId */
|
|
c16toa(config->kemId, output);
|
|
output += 2;
|
|
|
|
/* length and key itself */
|
|
switch (config->kemId) {
|
|
case DHKEM_P256_HKDF_SHA256:
|
|
c16toa(DHKEM_P256_ENC_LEN, output);
|
|
output += 2;
|
|
XMEMCPY(output, config->receiverPubkey, DHKEM_P256_ENC_LEN);
|
|
output += DHKEM_P256_ENC_LEN;
|
|
break;
|
|
case DHKEM_P384_HKDF_SHA384:
|
|
c16toa(DHKEM_P384_ENC_LEN, output);
|
|
output += 2;
|
|
XMEMCPY(output, config->receiverPubkey, DHKEM_P384_ENC_LEN);
|
|
output += DHKEM_P384_ENC_LEN;
|
|
break;
|
|
case DHKEM_P521_HKDF_SHA512:
|
|
c16toa(DHKEM_P521_ENC_LEN, output);
|
|
output += 2;
|
|
XMEMCPY(output, config->receiverPubkey, DHKEM_P521_ENC_LEN);
|
|
output += DHKEM_P521_ENC_LEN;
|
|
break;
|
|
case DHKEM_X25519_HKDF_SHA256:
|
|
c16toa(DHKEM_X25519_ENC_LEN, output);
|
|
output += 2;
|
|
XMEMCPY(output, config->receiverPubkey, DHKEM_X25519_ENC_LEN);
|
|
output += DHKEM_X25519_ENC_LEN;
|
|
break;
|
|
case DHKEM_X448_HKDF_SHA512:
|
|
c16toa(DHKEM_X448_ENC_LEN, output);
|
|
output += 2;
|
|
XMEMCPY(output, config->receiverPubkey, DHKEM_X448_ENC_LEN);
|
|
output += DHKEM_X448_ENC_LEN;
|
|
break;
|
|
}
|
|
|
|
/* cipherSuites len */
|
|
c16toa(config->numCipherSuites * 4, output);
|
|
output += 2;
|
|
|
|
/* cipherSuites */
|
|
for (i = 0; i < config->numCipherSuites; i++) {
|
|
c16toa(config->cipherSuites[i].kdfId, output);
|
|
output += 2;
|
|
c16toa(config->cipherSuites[i].aeadId, output);
|
|
output += 2;
|
|
}
|
|
|
|
/* publicName len */
|
|
c16toa(XSTRLEN(config->publicName), output);
|
|
output += 2;
|
|
|
|
/* publicName */
|
|
XMEMCPY(output, config->publicName,
|
|
XSTRLEN(config->publicName));
|
|
output += XSTRLEN(config->publicName);
|
|
|
|
/* terminating zeros */
|
|
c16toa(0, output);
|
|
/* output += 2; */
|
|
|
|
*outputLen = totalLen;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* wrapper function to get ech configs from application code */
|
|
int wolfSSL_GetEchConfigs(WOLFSSL* ssl, byte* output, word32* outputLen)
|
|
{
|
|
if (ssl == NULL || outputLen == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
/* if we don't have ech configs */
|
|
if (ssl->options.useEch != 1) {
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
|
|
return GetEchConfigsEx(ssl->echConfigs, output, outputLen);
|
|
}
|
|
|
|
/* get the raw ech configs from our linked list of ech config structs */
|
|
int GetEchConfigsEx(WOLFSSL_EchConfig* configs, byte* output, word32* outputLen)
|
|
{
|
|
int ret = 0;
|
|
WOLFSSL_EchConfig* workingConfig = NULL;
|
|
byte* outputStart = output;
|
|
word32 totalLen = 2;
|
|
word32 workingOutputLen;
|
|
|
|
if (configs == NULL || outputLen == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
workingOutputLen = *outputLen - totalLen;
|
|
|
|
/* skip over total length which we fill in later */
|
|
if (output != NULL)
|
|
output += 2;
|
|
|
|
workingConfig = configs;
|
|
|
|
while (workingConfig != NULL) {
|
|
/* get this config */
|
|
ret = GetEchConfig(workingConfig, output, &workingOutputLen);
|
|
|
|
if (output != NULL)
|
|
output += workingOutputLen;
|
|
|
|
/* add this config's length to the total length */
|
|
totalLen += workingOutputLen;
|
|
|
|
if (totalLen > *outputLen)
|
|
workingOutputLen = 0;
|
|
else
|
|
workingOutputLen = *outputLen - totalLen;
|
|
|
|
/* only error we break on, other 2 we need to keep finding length */
|
|
if (ret == BAD_FUNC_ARG)
|
|
return BAD_FUNC_ARG;
|
|
|
|
workingConfig = workingConfig->next;
|
|
}
|
|
|
|
if (output == NULL) {
|
|
*outputLen = totalLen;
|
|
return LENGTH_ONLY_E;
|
|
}
|
|
|
|
if (totalLen > *outputLen) {
|
|
*outputLen = totalLen;
|
|
return INPUT_SIZE_E;
|
|
}
|
|
|
|
/* total size -2 for size itself */
|
|
c16toa(totalLen - 2, outputStart);
|
|
|
|
*outputLen = totalLen;
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
#endif /* WOLFSSL_TLS13 && HAVE_ECH */
|
|
|
|
|
|
#if defined(WOLFSSL_RENESAS_TSIP_TLS) || defined(WOLFSSL_RENESAS_FSPSM_TLS)
|
|
#include <wolfssl/wolfcrypt/port/Renesas/renesas_cmn.h>
|
|
#endif
|
|
|
|
#ifdef WOLFSSL_SESSION_EXPORT
|
|
/* Used to import a serialized TLS session.
|
|
* WARNING: buf contains sensitive information about the state and is best to be
|
|
* encrypted before storing if stored.
|
|
*
|
|
* @param ssl WOLFSSL structure to import the session into
|
|
* @param buf serialized session
|
|
* @param sz size of buffer 'buf'
|
|
* @return the number of bytes read from buffer 'buf'
|
|
*/
|
|
int wolfSSL_tls_import(WOLFSSL* ssl, const unsigned char* buf, unsigned int sz)
|
|
{
|
|
if (ssl == NULL || buf == NULL) {
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
return wolfSSL_session_import_internal(ssl, buf, sz, WOLFSSL_EXPORT_TLS);
|
|
}
|
|
|
|
|
|
/* Used to export a serialized TLS session.
|
|
* WARNING: buf contains sensitive information about the state and is best to be
|
|
* encrypted before storing if stored.
|
|
*
|
|
* @param ssl WOLFSSL structure to export the session from
|
|
* @param buf output of serialized session
|
|
* @param sz size in bytes set in 'buf'
|
|
* @return the number of bytes written into buffer 'buf'
|
|
*/
|
|
int wolfSSL_tls_export(WOLFSSL* ssl, unsigned char* buf, unsigned int* sz)
|
|
{
|
|
if (ssl == NULL || sz == NULL) {
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
return wolfSSL_session_export_internal(ssl, buf, sz, WOLFSSL_EXPORT_TLS);
|
|
}
|
|
|
|
#ifdef WOLFSSL_DTLS
|
|
int wolfSSL_dtls_import(WOLFSSL* ssl, const unsigned char* buf, unsigned int sz)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_session_import");
|
|
|
|
if (ssl == NULL || buf == NULL) {
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
/* sanity checks on buffer and protocol are done in internal function */
|
|
return wolfSSL_session_import_internal(ssl, buf, sz, WOLFSSL_EXPORT_DTLS);
|
|
}
|
|
|
|
|
|
/* Sets the function to call for serializing the session. This function is
|
|
* called right after the handshake is completed. */
|
|
int wolfSSL_CTX_dtls_set_export(WOLFSSL_CTX* ctx, wc_dtls_export func)
|
|
{
|
|
|
|
WOLFSSL_ENTER("wolfSSL_CTX_dtls_set_export");
|
|
|
|
/* purposefully allow func to be NULL */
|
|
if (ctx == NULL) {
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
ctx->dtls_export = func;
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
|
|
/* Sets the function in WOLFSSL struct to call for serializing the session. This
|
|
* function is called right after the handshake is completed. */
|
|
int wolfSSL_dtls_set_export(WOLFSSL* ssl, wc_dtls_export func)
|
|
{
|
|
|
|
WOLFSSL_ENTER("wolfSSL_dtls_set_export");
|
|
|
|
/* purposefully allow func to be NULL */
|
|
if (ssl == NULL) {
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
ssl->dtls_export = func;
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
|
|
/* This function allows for directly serializing a session rather than using
|
|
* callbacks. It has less overhead by removing a temporary buffer and gives
|
|
* control over when the session gets serialized. When using callbacks the
|
|
* session is always serialized immediately after the handshake is finished.
|
|
*
|
|
* buf is the argument to contain the serialized session
|
|
* sz is the size of the buffer passed in
|
|
* ssl is the WOLFSSL struct to serialize
|
|
* returns the size of serialized session on success, 0 on no action, and
|
|
* negative value on error */
|
|
int wolfSSL_dtls_export(WOLFSSL* ssl, unsigned char* buf, unsigned int* sz)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_dtls_export");
|
|
|
|
if (ssl == NULL || sz == NULL) {
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
if (buf == NULL) {
|
|
*sz = MAX_EXPORT_BUFFER;
|
|
return 0;
|
|
}
|
|
|
|
/* if not DTLS do nothing */
|
|
if (!ssl->options.dtls) {
|
|
WOLFSSL_MSG("Currently only DTLS export is supported");
|
|
return 0;
|
|
}
|
|
|
|
/* copy over keys, options, and dtls state struct */
|
|
return wolfSSL_session_export_internal(ssl, buf, sz, WOLFSSL_EXPORT_DTLS);
|
|
}
|
|
|
|
|
|
/* This function is similar to wolfSSL_dtls_export but only exports the portion
|
|
* of the WOLFSSL structure related to the state of the connection, i.e. peer
|
|
* sequence number, epoch, AEAD state etc.
|
|
*
|
|
* buf is the argument to contain the serialized state, if null then set "sz" to
|
|
* buffer size required
|
|
* sz is the size of the buffer passed in
|
|
* ssl is the WOLFSSL struct to serialize
|
|
* returns the size of serialized session on success, 0 on no action, and
|
|
* negative value on error */
|
|
int wolfSSL_dtls_export_state_only(WOLFSSL* ssl, unsigned char* buf,
|
|
unsigned int* sz)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_dtls_export_state_only");
|
|
|
|
if (ssl == NULL || sz == NULL) {
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
if (buf == NULL) {
|
|
*sz = MAX_EXPORT_STATE_BUFFER;
|
|
return 0;
|
|
}
|
|
|
|
/* if not DTLS do nothing */
|
|
if (!ssl->options.dtls) {
|
|
WOLFSSL_MSG("Currently only DTLS export state is supported");
|
|
return 0;
|
|
}
|
|
|
|
/* copy over keys, options, and dtls state struct */
|
|
return wolfSSL_dtls_export_state_internal(ssl, buf, *sz);
|
|
}
|
|
|
|
|
|
/* returns 0 on success */
|
|
int wolfSSL_send_session(WOLFSSL* ssl)
|
|
{
|
|
int ret;
|
|
byte* buf;
|
|
word32 bufSz = MAX_EXPORT_BUFFER;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_send_session");
|
|
|
|
if (ssl == NULL) {
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
buf = (byte*)XMALLOC(bufSz, ssl->heap, DYNAMIC_TYPE_TMP_BUFFER);
|
|
if (buf == NULL) {
|
|
return MEMORY_E;
|
|
}
|
|
|
|
/* if not DTLS do nothing */
|
|
if (!ssl->options.dtls) {
|
|
XFREE(buf, ssl->heap, DYNAMIC_TYPE_TMP_BUFFER);
|
|
WOLFSSL_MSG("Currently only DTLS export is supported");
|
|
return 0;
|
|
}
|
|
|
|
/* copy over keys, options, and dtls state struct */
|
|
ret = wolfSSL_session_export_internal(ssl, buf, &bufSz, WOLFSSL_EXPORT_DTLS);
|
|
if (ret < 0) {
|
|
XFREE(buf, ssl->heap, DYNAMIC_TYPE_TMP_BUFFER);
|
|
return ret;
|
|
}
|
|
|
|
/* if no error ret has size of buffer */
|
|
ret = ssl->dtls_export(ssl, buf, ret, NULL);
|
|
if (ret != WOLFSSL_SUCCESS) {
|
|
XFREE(buf, ssl->heap, DYNAMIC_TYPE_TMP_BUFFER);
|
|
return ret;
|
|
}
|
|
|
|
XFREE(buf, ssl->heap, DYNAMIC_TYPE_TMP_BUFFER);
|
|
return 0;
|
|
}
|
|
#endif /* WOLFSSL_DTLS */
|
|
#endif /* WOLFSSL_SESSION_EXPORT */
|
|
|
|
/* prevent multiple mutex initializations */
|
|
static volatile WOLFSSL_GLOBAL int initRefCount = 0;
|
|
#ifdef WOLFSSL_MUTEX_INITIALIZER
|
|
static WOLFSSL_GLOBAL wolfSSL_Mutex count_mutex = WOLFSSL_MUTEX_INITIALIZER;
|
|
#else
|
|
static WOLFSSL_GLOBAL wolfSSL_Mutex count_mutex; /* init ref count mutex */
|
|
static WOLFSSL_GLOBAL int count_mutex_valid = 0;
|
|
#endif
|
|
|
|
/* Create a new WOLFSSL_CTX struct and return the pointer to created struct.
|
|
WOLFSSL_METHOD pointer passed in is given to ctx to manage.
|
|
This function frees the passed in WOLFSSL_METHOD struct on failure and on
|
|
success is freed when ctx is freed.
|
|
*/
|
|
WOLFSSL_CTX* wolfSSL_CTX_new_ex(WOLFSSL_METHOD* method, void* heap)
|
|
{
|
|
WOLFSSL_CTX* ctx = NULL;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_CTX_new_ex");
|
|
|
|
if (initRefCount == 0) {
|
|
/* user no longer forced to call Init themselves */
|
|
int ret = wolfSSL_Init();
|
|
if (ret != WOLFSSL_SUCCESS) {
|
|
WOLFSSL_MSG("wolfSSL_Init failed");
|
|
WOLFSSL_LEAVE("wolfSSL_CTX_new_ex", 0);
|
|
if (method != NULL) {
|
|
XFREE(method, heap, DYNAMIC_TYPE_METHOD);
|
|
}
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
if (method == NULL)
|
|
return ctx;
|
|
|
|
ctx = (WOLFSSL_CTX*)XMALLOC(sizeof(WOLFSSL_CTX), heap, DYNAMIC_TYPE_CTX);
|
|
if (ctx) {
|
|
int ret;
|
|
|
|
ret = InitSSL_Ctx(ctx, method, heap);
|
|
#ifdef WOLFSSL_STATIC_MEMORY
|
|
if (heap != NULL) {
|
|
ctx->onHeapHint = 1; /* free the memory back to heap when done */
|
|
}
|
|
#endif
|
|
if (ret < 0) {
|
|
WOLFSSL_MSG("Init CTX failed");
|
|
wolfSSL_CTX_free(ctx);
|
|
ctx = NULL;
|
|
}
|
|
#if defined(OPENSSL_EXTRA) && defined(WOLFCRYPT_HAVE_SRP) \
|
|
&& !defined(NO_SHA256) && !defined(WC_NO_RNG)
|
|
else {
|
|
ctx->srp = (Srp*)XMALLOC(sizeof(Srp), heap, DYNAMIC_TYPE_SRP);
|
|
if (ctx->srp == NULL){
|
|
WOLFSSL_MSG("Init CTX failed");
|
|
wolfSSL_CTX_free(ctx);
|
|
return NULL;
|
|
}
|
|
XMEMSET(ctx->srp, 0, sizeof(Srp));
|
|
}
|
|
#endif
|
|
}
|
|
else {
|
|
WOLFSSL_MSG("Alloc CTX failed, method freed");
|
|
XFREE(method, heap, DYNAMIC_TYPE_METHOD);
|
|
}
|
|
|
|
#ifdef OPENSSL_COMPATIBLE_DEFAULTS
|
|
if (ctx) {
|
|
wolfSSL_CTX_set_verify(ctx, SSL_VERIFY_NONE, NULL);
|
|
wolfSSL_CTX_set_mode(ctx, SSL_MODE_AUTO_RETRY);
|
|
if (wolfSSL_CTX_set_min_proto_version(ctx,
|
|
(method->version.major == DTLS_MAJOR) ?
|
|
DTLS1_VERSION : SSL3_VERSION) != WOLFSSL_SUCCESS ||
|
|
#ifdef HAVE_ANON
|
|
wolfSSL_CTX_allow_anon_cipher(ctx) != WOLFSSL_SUCCESS ||
|
|
#endif
|
|
wolfSSL_CTX_set_group_messages(ctx) != WOLFSSL_SUCCESS) {
|
|
WOLFSSL_MSG("Setting OpenSSL CTX defaults failed");
|
|
wolfSSL_CTX_free(ctx);
|
|
ctx = NULL;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
WOLFSSL_LEAVE("wolfSSL_CTX_new_ex", 0);
|
|
return ctx;
|
|
}
|
|
|
|
|
|
WOLFSSL_ABI
|
|
WOLFSSL_CTX* wolfSSL_CTX_new(WOLFSSL_METHOD* method)
|
|
{
|
|
#ifdef WOLFSSL_HEAP_TEST
|
|
/* if testing the heap hint then set top level CTX to have test value */
|
|
return wolfSSL_CTX_new_ex(method, (void*)WOLFSSL_HEAP_TEST);
|
|
#else
|
|
return wolfSSL_CTX_new_ex(method, NULL);
|
|
#endif
|
|
}
|
|
|
|
/* increases CTX reference count to track proper time to "free" */
|
|
int wolfSSL_CTX_up_ref(WOLFSSL_CTX* ctx)
|
|
{
|
|
int ret;
|
|
wolfSSL_RefInc(&ctx->ref, &ret);
|
|
#ifdef WOLFSSL_REFCNT_ERROR_RETURN
|
|
return ((ret == 0) ? WOLFSSL_SUCCESS : WOLFSSL_FAILURE);
|
|
#else
|
|
(void)ret;
|
|
return WOLFSSL_SUCCESS;
|
|
#endif
|
|
}
|
|
|
|
WOLFSSL_ABI
|
|
void wolfSSL_CTX_free(WOLFSSL_CTX* ctx)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_free");
|
|
if (ctx) {
|
|
#if defined(OPENSSL_EXTRA) && defined(WOLFCRYPT_HAVE_SRP) \
|
|
&& !defined(NO_SHA256) && !defined(WC_NO_RNG)
|
|
if (ctx->srp != NULL) {
|
|
if (ctx->srp_password != NULL){
|
|
XFREE(ctx->srp_password, ctx->heap, DYNAMIC_TYPE_SRP);
|
|
ctx->srp_password = NULL;
|
|
}
|
|
wc_SrpTerm(ctx->srp);
|
|
XFREE(ctx->srp, ctx->heap, DYNAMIC_TYPE_SRP);
|
|
ctx->srp = NULL;
|
|
}
|
|
#endif
|
|
FreeSSL_Ctx(ctx);
|
|
}
|
|
|
|
WOLFSSL_LEAVE("wolfSSL_CTX_free", 0);
|
|
}
|
|
|
|
|
|
#ifdef HAVE_ENCRYPT_THEN_MAC
|
|
/**
|
|
* Sets whether Encrypt-Then-MAC extension can be negotiated against context.
|
|
* The default value: enabled.
|
|
*
|
|
* ctx SSL/TLS context.
|
|
* set Whether to allow or not: 1 is allow and 0 is disallow.
|
|
* returns WOLFSSL_SUCCESS
|
|
*/
|
|
int wolfSSL_CTX_AllowEncryptThenMac(WOLFSSL_CTX *ctx, int set)
|
|
{
|
|
ctx->disallowEncThenMac = !set;
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
* Sets whether Encrypt-Then-MAC extension can be negotiated against context.
|
|
* The default value comes from context.
|
|
*
|
|
* ctx SSL/TLS context.
|
|
* set Whether to allow or not: 1 is allow and 0 is disallow.
|
|
* returns WOLFSSL_SUCCESS
|
|
*/
|
|
int wolfSSL_AllowEncryptThenMac(WOLFSSL *ssl, int set)
|
|
{
|
|
ssl->options.disallowEncThenMac = !set;
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
#endif
|
|
|
|
#ifdef SINGLE_THREADED
|
|
/* no locking in single threaded mode, allow a CTX level rng to be shared with
|
|
* WOLFSSL objects, WOLFSSL_SUCCESS on ok */
|
|
int wolfSSL_CTX_new_rng(WOLFSSL_CTX* ctx)
|
|
{
|
|
WC_RNG* rng;
|
|
int ret;
|
|
|
|
if (ctx == NULL) {
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
rng = (WC_RNG*)XMALLOC(sizeof(WC_RNG), ctx->heap, DYNAMIC_TYPE_RNG);
|
|
if (rng == NULL) {
|
|
return MEMORY_E;
|
|
}
|
|
|
|
#ifndef HAVE_FIPS
|
|
ret = wc_InitRng_ex(rng, ctx->heap, ctx->devId);
|
|
#else
|
|
ret = wc_InitRng(rng);
|
|
#endif
|
|
if (ret != 0) {
|
|
XFREE(rng, ctx->heap, DYNAMIC_TYPE_RNG);
|
|
return ret;
|
|
}
|
|
|
|
ctx->rng = rng;
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
#endif
|
|
|
|
|
|
WOLFSSL_ABI
|
|
WOLFSSL* wolfSSL_new(WOLFSSL_CTX* ctx)
|
|
{
|
|
WOLFSSL* ssl = NULL;
|
|
int ret = 0;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_new");
|
|
|
|
if (ctx == NULL)
|
|
return ssl;
|
|
|
|
ssl = (WOLFSSL*) XMALLOC(sizeof(WOLFSSL), ctx->heap, DYNAMIC_TYPE_SSL);
|
|
if (ssl)
|
|
if ( (ret = InitSSL(ssl, ctx, 0)) < 0) {
|
|
FreeSSL(ssl, ctx->heap);
|
|
ssl = 0;
|
|
}
|
|
|
|
WOLFSSL_LEAVE("wolfSSL_new", ret);
|
|
(void)ret;
|
|
|
|
return ssl;
|
|
}
|
|
|
|
|
|
WOLFSSL_ABI
|
|
void wolfSSL_free(WOLFSSL* ssl)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_free");
|
|
if (ssl)
|
|
FreeSSL(ssl, ssl->ctx->heap);
|
|
WOLFSSL_LEAVE("wolfSSL_free", 0);
|
|
}
|
|
|
|
|
|
int wolfSSL_is_server(WOLFSSL* ssl)
|
|
{
|
|
if (ssl == NULL)
|
|
return BAD_FUNC_ARG;
|
|
return ssl->options.side == WOLFSSL_SERVER_END;
|
|
}
|
|
|
|
#ifdef HAVE_WRITE_DUP
|
|
|
|
/*
|
|
* Release resources around WriteDup object
|
|
*
|
|
* ssl WOLFSSL object
|
|
*
|
|
* no return, destruction so make best attempt
|
|
*/
|
|
void FreeWriteDup(WOLFSSL* ssl)
|
|
{
|
|
int doFree = 0;
|
|
|
|
WOLFSSL_ENTER("FreeWriteDup");
|
|
|
|
if (ssl->dupWrite) {
|
|
if (wc_LockMutex(&ssl->dupWrite->dupMutex) == 0) {
|
|
ssl->dupWrite->dupCount--;
|
|
if (ssl->dupWrite->dupCount == 0) {
|
|
doFree = 1;
|
|
} else {
|
|
WOLFSSL_MSG("WriteDup count not zero, no full free");
|
|
}
|
|
wc_UnLockMutex(&ssl->dupWrite->dupMutex);
|
|
}
|
|
}
|
|
|
|
if (doFree) {
|
|
WOLFSSL_MSG("Doing WriteDup full free, count to zero");
|
|
wc_FreeMutex(&ssl->dupWrite->dupMutex);
|
|
XFREE(ssl->dupWrite, ssl->heap, DYNAMIC_TYPE_WRITEDUP);
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* duplicate existing ssl members into dup needed for writing
|
|
*
|
|
* dup write only WOLFSSL
|
|
* ssl existing WOLFSSL
|
|
*
|
|
* 0 on success
|
|
*/
|
|
static int DupSSL(WOLFSSL* dup, WOLFSSL* ssl)
|
|
{
|
|
word16 tmp_weOwnRng;
|
|
|
|
/* shared dupWrite setup */
|
|
ssl->dupWrite = (WriteDup*)XMALLOC(sizeof(WriteDup), ssl->heap,
|
|
DYNAMIC_TYPE_WRITEDUP);
|
|
if (ssl->dupWrite == NULL) {
|
|
return MEMORY_E;
|
|
}
|
|
XMEMSET(ssl->dupWrite, 0, sizeof(WriteDup));
|
|
|
|
if (wc_InitMutex(&ssl->dupWrite->dupMutex) != 0) {
|
|
XFREE(ssl->dupWrite, ssl->heap, DYNAMIC_TYPE_WRITEDUP);
|
|
ssl->dupWrite = NULL;
|
|
return BAD_MUTEX_E;
|
|
}
|
|
ssl->dupWrite->dupCount = 2; /* both sides have a count to start */
|
|
dup->dupWrite = ssl->dupWrite; /* each side uses */
|
|
|
|
tmp_weOwnRng = dup->options.weOwnRng;
|
|
|
|
/* copy write parts over to dup writer */
|
|
XMEMCPY(&dup->specs, &ssl->specs, sizeof(CipherSpecs));
|
|
XMEMCPY(&dup->options, &ssl->options, sizeof(Options));
|
|
XMEMCPY(&dup->keys, &ssl->keys, sizeof(Keys));
|
|
XMEMCPY(&dup->encrypt, &ssl->encrypt, sizeof(Ciphers));
|
|
XMEMCPY(&dup->version, &ssl->version, sizeof(ProtocolVersion));
|
|
XMEMCPY(&dup->chVersion, &ssl->chVersion, sizeof(ProtocolVersion));
|
|
|
|
/* dup side now owns encrypt/write ciphers */
|
|
XMEMSET(&ssl->encrypt, 0, sizeof(Ciphers));
|
|
|
|
dup->IOCB_WriteCtx = ssl->IOCB_WriteCtx;
|
|
dup->CBIOSend = ssl->CBIOSend;
|
|
#ifdef OPENSSL_EXTRA
|
|
dup->cbioFlag = ssl->cbioFlag;
|
|
#endif
|
|
dup->wfd = ssl->wfd;
|
|
dup->wflags = ssl->wflags;
|
|
#ifndef WOLFSSL_AEAD_ONLY
|
|
dup->hmac = ssl->hmac;
|
|
#endif
|
|
#ifdef HAVE_TRUNCATED_HMAC
|
|
dup->truncated_hmac = ssl->truncated_hmac;
|
|
#endif
|
|
|
|
/* Restore rng option */
|
|
dup->options.weOwnRng = tmp_weOwnRng;
|
|
|
|
/* unique side dup setup */
|
|
dup->dupSide = WRITE_DUP_SIDE;
|
|
ssl->dupSide = READ_DUP_SIDE;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*
|
|
* duplicate a WOLFSSL object post handshake for writing only
|
|
* turn existing object into read only. Allows concurrent access from two
|
|
* different threads.
|
|
*
|
|
* ssl existing WOLFSSL object
|
|
*
|
|
* return dup'd WOLFSSL object on success
|
|
*/
|
|
WOLFSSL* wolfSSL_write_dup(WOLFSSL* ssl)
|
|
{
|
|
WOLFSSL* dup = NULL;
|
|
int ret = 0;
|
|
|
|
(void)ret;
|
|
WOLFSSL_ENTER("wolfSSL_write_dup");
|
|
|
|
if (ssl == NULL) {
|
|
return ssl;
|
|
}
|
|
|
|
if (ssl->options.handShakeDone == 0) {
|
|
WOLFSSL_MSG("wolfSSL_write_dup called before handshake complete");
|
|
return NULL;
|
|
}
|
|
|
|
if (ssl->dupWrite) {
|
|
WOLFSSL_MSG("wolfSSL_write_dup already called once");
|
|
return NULL;
|
|
}
|
|
|
|
dup = (WOLFSSL*) XMALLOC(sizeof(WOLFSSL), ssl->ctx->heap, DYNAMIC_TYPE_SSL);
|
|
if (dup) {
|
|
if ( (ret = InitSSL(dup, ssl->ctx, 1)) < 0) {
|
|
FreeSSL(dup, ssl->ctx->heap);
|
|
dup = NULL;
|
|
} else if ( (ret = DupSSL(dup, ssl)) < 0) {
|
|
FreeSSL(dup, ssl->ctx->heap);
|
|
dup = NULL;
|
|
}
|
|
}
|
|
|
|
WOLFSSL_LEAVE("wolfSSL_write_dup", ret);
|
|
|
|
return dup;
|
|
}
|
|
|
|
|
|
/*
|
|
* Notify write dup side of fatal error or close notify
|
|
*
|
|
* ssl WOLFSSL object
|
|
* err Notify err
|
|
*
|
|
* 0 on success
|
|
*/
|
|
int NotifyWriteSide(WOLFSSL* ssl, int err)
|
|
{
|
|
int ret;
|
|
|
|
WOLFSSL_ENTER("NotifyWriteSide");
|
|
|
|
ret = wc_LockMutex(&ssl->dupWrite->dupMutex);
|
|
if (ret == 0) {
|
|
ssl->dupWrite->dupErr = err;
|
|
ret = wc_UnLockMutex(&ssl->dupWrite->dupMutex);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
#endif /* HAVE_WRITE_DUP */
|
|
|
|
|
|
#ifdef HAVE_POLY1305
|
|
/* set if to use old poly 1 for yes 0 to use new poly */
|
|
int wolfSSL_use_old_poly(WOLFSSL* ssl, int value)
|
|
{
|
|
(void)ssl;
|
|
(void)value;
|
|
|
|
#ifndef WOLFSSL_NO_TLS12
|
|
WOLFSSL_ENTER("wolfSSL_use_old_poly");
|
|
WOLFSSL_MSG("Warning SSL connection auto detects old/new and this function"
|
|
"is depreciated");
|
|
ssl->options.oldPoly = (word16)value;
|
|
WOLFSSL_LEAVE("wolfSSL_use_old_poly", 0);
|
|
#endif
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
|
|
WOLFSSL_ABI
|
|
int wolfSSL_set_fd(WOLFSSL* ssl, int fd)
|
|
{
|
|
int ret;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_set_fd");
|
|
|
|
if (ssl == NULL) {
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
ret = wolfSSL_set_read_fd(ssl, fd);
|
|
if (ret == WOLFSSL_SUCCESS) {
|
|
ret = wolfSSL_set_write_fd(ssl, fd);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
#ifdef WOLFSSL_DTLS
|
|
int wolfSSL_set_dtls_fd_connected(WOLFSSL* ssl, int fd)
|
|
{
|
|
int ret;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_set_dtls_fd_connected");
|
|
|
|
if (ssl == NULL) {
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
ret = wolfSSL_set_fd(ssl, fd);
|
|
if (ret == WOLFSSL_SUCCESS)
|
|
ssl->buffers.dtlsCtx.connected = 1;
|
|
|
|
return ret;
|
|
}
|
|
#endif
|
|
|
|
|
|
int wolfSSL_set_read_fd(WOLFSSL* ssl, int fd)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_set_read_fd");
|
|
|
|
if (ssl == NULL) {
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
ssl->rfd = fd; /* not used directly to allow IO callbacks */
|
|
ssl->IOCB_ReadCtx = &ssl->rfd;
|
|
|
|
#ifdef WOLFSSL_DTLS
|
|
ssl->buffers.dtlsCtx.connected = 0;
|
|
if (ssl->options.dtls) {
|
|
ssl->IOCB_ReadCtx = &ssl->buffers.dtlsCtx;
|
|
ssl->buffers.dtlsCtx.rfd = fd;
|
|
}
|
|
#endif
|
|
|
|
WOLFSSL_LEAVE("wolfSSL_set_read_fd", WOLFSSL_SUCCESS);
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
|
|
int wolfSSL_set_write_fd(WOLFSSL* ssl, int fd)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_set_write_fd");
|
|
|
|
if (ssl == NULL) {
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
ssl->wfd = fd; /* not used directly to allow IO callbacks */
|
|
ssl->IOCB_WriteCtx = &ssl->wfd;
|
|
|
|
#ifdef WOLFSSL_DTLS
|
|
ssl->buffers.dtlsCtx.connected = 0;
|
|
if (ssl->options.dtls) {
|
|
ssl->IOCB_WriteCtx = &ssl->buffers.dtlsCtx;
|
|
ssl->buffers.dtlsCtx.wfd = fd;
|
|
}
|
|
#endif
|
|
|
|
WOLFSSL_LEAVE("wolfSSL_set_write_fd", WOLFSSL_SUCCESS);
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
|
|
/**
|
|
* Get the name of cipher at priority level passed in.
|
|
*/
|
|
char* wolfSSL_get_cipher_list(int priority)
|
|
{
|
|
const CipherSuiteInfo* ciphers = GetCipherNames();
|
|
|
|
if (priority >= GetCipherNamesSize() || priority < 0) {
|
|
return 0;
|
|
}
|
|
|
|
return (char*)ciphers[priority].name;
|
|
}
|
|
|
|
|
|
/**
|
|
* Get the name of cipher at priority level passed in.
|
|
*/
|
|
char* wolfSSL_get_cipher_list_ex(WOLFSSL* ssl, int priority)
|
|
{
|
|
|
|
if (ssl == NULL) {
|
|
return NULL;
|
|
}
|
|
else {
|
|
const char* cipher;
|
|
|
|
if ((cipher = wolfSSL_get_cipher_name_internal(ssl)) != NULL) {
|
|
if (priority == 0) {
|
|
return (char*)cipher;
|
|
}
|
|
else {
|
|
return NULL;
|
|
}
|
|
}
|
|
else {
|
|
return wolfSSL_get_cipher_list(priority);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
int wolfSSL_get_ciphers(char* buf, int len)
|
|
{
|
|
const CipherSuiteInfo* ciphers = GetCipherNames();
|
|
int ciphersSz = GetCipherNamesSize();
|
|
int i;
|
|
|
|
if (buf == NULL || len <= 0)
|
|
return BAD_FUNC_ARG;
|
|
|
|
/* Add each member to the buffer delimited by a : */
|
|
for (i = 0; i < ciphersSz; i++) {
|
|
int cipherNameSz = (int)XSTRLEN(ciphers[i].name);
|
|
if (cipherNameSz + 1 < len) {
|
|
XSTRNCPY(buf, ciphers[i].name, len);
|
|
buf += cipherNameSz;
|
|
|
|
if (i < ciphersSz - 1)
|
|
*buf++ = ':';
|
|
*buf = 0;
|
|
|
|
len -= cipherNameSz + 1;
|
|
}
|
|
else
|
|
return BUFFER_E;
|
|
}
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
|
|
#ifndef NO_ERROR_STRINGS
|
|
/* places a list of all supported cipher suites in TLS_* format into "buf"
|
|
* return WOLFSSL_SUCCESS on success */
|
|
int wolfSSL_get_ciphers_iana(char* buf, int len)
|
|
{
|
|
const CipherSuiteInfo* ciphers = GetCipherNames();
|
|
int ciphersSz = GetCipherNamesSize();
|
|
int i;
|
|
int cipherNameSz;
|
|
|
|
if (buf == NULL || len <= 0)
|
|
return BAD_FUNC_ARG;
|
|
|
|
/* Add each member to the buffer delimited by a : */
|
|
for (i = 0; i < ciphersSz; i++) {
|
|
#ifndef NO_CIPHER_SUITE_ALIASES
|
|
if (ciphers[i].flags & WOLFSSL_CIPHER_SUITE_FLAG_NAMEALIAS)
|
|
continue;
|
|
#endif
|
|
cipherNameSz = (int)XSTRLEN(ciphers[i].name_iana);
|
|
if (cipherNameSz + 1 < len) {
|
|
XSTRNCPY(buf, ciphers[i].name_iana, len);
|
|
buf += cipherNameSz;
|
|
|
|
if (i < ciphersSz - 1)
|
|
*buf++ = ':';
|
|
*buf = 0;
|
|
|
|
len -= cipherNameSz + 1;
|
|
}
|
|
else
|
|
return BUFFER_E;
|
|
}
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
#endif /* NO_ERROR_STRINGS */
|
|
|
|
|
|
const char* wolfSSL_get_shared_ciphers(WOLFSSL* ssl, char* buf, int len)
|
|
{
|
|
const char* cipher;
|
|
|
|
if (ssl == NULL)
|
|
return NULL;
|
|
|
|
cipher = wolfSSL_get_cipher_name_iana(ssl);
|
|
len = min(len, (int)(XSTRLEN(cipher) + 1));
|
|
XMEMCPY(buf, cipher, len);
|
|
return buf;
|
|
}
|
|
|
|
int wolfSSL_get_fd(const WOLFSSL* ssl)
|
|
{
|
|
int fd = -1;
|
|
WOLFSSL_ENTER("wolfSSL_get_fd");
|
|
if (ssl) {
|
|
fd = ssl->rfd;
|
|
}
|
|
WOLFSSL_LEAVE("wolfSSL_get_fd", fd);
|
|
return fd;
|
|
}
|
|
|
|
|
|
int wolfSSL_dtls(WOLFSSL* ssl)
|
|
{
|
|
int dtlsOpt = 0;
|
|
if (ssl)
|
|
dtlsOpt = ssl->options.dtls;
|
|
return dtlsOpt;
|
|
}
|
|
|
|
#if !defined(NO_CERTS)
|
|
/* Set whether mutual authentication is required for connections.
|
|
* Server side only.
|
|
*
|
|
* ctx The SSL/TLS CTX object.
|
|
* req 1 to indicate required and 0 when not.
|
|
* returns BAD_FUNC_ARG when ctx is NULL, SIDE_ERROR when not a server and
|
|
* 0 on success.
|
|
*/
|
|
int wolfSSL_CTX_mutual_auth(WOLFSSL_CTX* ctx, int req)
|
|
{
|
|
if (ctx == NULL)
|
|
return BAD_FUNC_ARG;
|
|
if (ctx->method->side == WOLFSSL_CLIENT_END)
|
|
return SIDE_ERROR;
|
|
|
|
ctx->mutualAuth = (byte)req;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* Set whether mutual authentication is required for the connection.
|
|
* Server side only.
|
|
*
|
|
* ssl The SSL/TLS object.
|
|
* req 1 to indicate required and 0 when not.
|
|
* returns BAD_FUNC_ARG when ssl is NULL, or not using TLS v1.3,
|
|
* SIDE_ERROR when not a client and 0 on success.
|
|
*/
|
|
int wolfSSL_mutual_auth(WOLFSSL* ssl, int req)
|
|
{
|
|
if (ssl == NULL)
|
|
return BAD_FUNC_ARG;
|
|
if (ssl->options.side == WOLFSSL_SERVER_END)
|
|
return SIDE_ERROR;
|
|
|
|
ssl->options.mutualAuth = (word16)req;
|
|
|
|
return 0;
|
|
}
|
|
#endif /* NO_CERTS */
|
|
|
|
#ifdef WOLFSSL_WOLFSENTRY_HOOKS
|
|
|
|
int wolfSSL_CTX_set_AcceptFilter(
|
|
WOLFSSL_CTX *ctx,
|
|
NetworkFilterCallback_t AcceptFilter,
|
|
void *AcceptFilter_arg)
|
|
{
|
|
if (ctx == NULL)
|
|
return BAD_FUNC_ARG;
|
|
ctx->AcceptFilter = AcceptFilter;
|
|
ctx->AcceptFilter_arg = AcceptFilter_arg;
|
|
return 0;
|
|
}
|
|
|
|
int wolfSSL_set_AcceptFilter(
|
|
WOLFSSL *ssl,
|
|
NetworkFilterCallback_t AcceptFilter,
|
|
void *AcceptFilter_arg)
|
|
{
|
|
if (ssl == NULL)
|
|
return BAD_FUNC_ARG;
|
|
ssl->AcceptFilter = AcceptFilter;
|
|
ssl->AcceptFilter_arg = AcceptFilter_arg;
|
|
return 0;
|
|
}
|
|
|
|
int wolfSSL_CTX_set_ConnectFilter(
|
|
WOLFSSL_CTX *ctx,
|
|
NetworkFilterCallback_t ConnectFilter,
|
|
void *ConnectFilter_arg)
|
|
{
|
|
if (ctx == NULL)
|
|
return BAD_FUNC_ARG;
|
|
ctx->ConnectFilter = ConnectFilter;
|
|
ctx->ConnectFilter_arg = ConnectFilter_arg;
|
|
return 0;
|
|
}
|
|
|
|
int wolfSSL_set_ConnectFilter(
|
|
WOLFSSL *ssl,
|
|
NetworkFilterCallback_t ConnectFilter,
|
|
void *ConnectFilter_arg)
|
|
{
|
|
if (ssl == NULL)
|
|
return BAD_FUNC_ARG;
|
|
ssl->ConnectFilter = ConnectFilter;
|
|
ssl->ConnectFilter_arg = ConnectFilter_arg;
|
|
return 0;
|
|
}
|
|
|
|
#endif /* WOLFSSL_WOLFSENTRY_HOOKS */
|
|
|
|
#ifndef WOLFSSL_LEANPSK
|
|
#if defined(WOLFSSL_DTLS) && defined(XINET_PTON) && \
|
|
!defined(WOLFSSL_NO_SOCK) && defined(HAVE_SOCKADDR)
|
|
void* wolfSSL_dtls_create_peer(int port, char* ip)
|
|
{
|
|
SOCKADDR_IN *addr;
|
|
addr = (SOCKADDR_IN*)XMALLOC(sizeof(*addr), NULL,
|
|
DYNAMIC_TYPE_SOCKADDR);
|
|
if (addr == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
addr->sin_family = AF_INET;
|
|
addr->sin_port = XHTONS((word16)port);
|
|
if (XINET_PTON(AF_INET, ip, &addr->sin_addr) < 1) {
|
|
XFREE(addr, NULL, DYNAMIC_TYPE_SOCKADDR);
|
|
return NULL;
|
|
}
|
|
|
|
return addr;
|
|
}
|
|
|
|
int wolfSSL_dtls_free_peer(void* addr)
|
|
{
|
|
XFREE(addr, NULL, DYNAMIC_TYPE_SOCKADDR);
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
#endif
|
|
|
|
int wolfSSL_dtls_set_peer(WOLFSSL* ssl, void* peer, unsigned int peerSz)
|
|
{
|
|
#ifdef WOLFSSL_DTLS
|
|
void* sa;
|
|
|
|
if (ssl == NULL)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
if (peer == NULL || peerSz == 0) {
|
|
if (ssl->buffers.dtlsCtx.peer.sa != NULL)
|
|
XFREE(ssl->buffers.dtlsCtx.peer.sa,ssl->heap,DYNAMIC_TYPE_SOCKADDR);
|
|
ssl->buffers.dtlsCtx.peer.sa = NULL;
|
|
ssl->buffers.dtlsCtx.peer.sz = 0;
|
|
ssl->buffers.dtlsCtx.peer.bufSz = 0;
|
|
ssl->buffers.dtlsCtx.userSet = 0;
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
sa = (void*)XMALLOC(peerSz, ssl->heap, DYNAMIC_TYPE_SOCKADDR);
|
|
if (sa != NULL) {
|
|
if (ssl->buffers.dtlsCtx.peer.sa != NULL) {
|
|
XFREE(ssl->buffers.dtlsCtx.peer.sa,ssl->heap,DYNAMIC_TYPE_SOCKADDR);
|
|
ssl->buffers.dtlsCtx.peer.sa = NULL;
|
|
}
|
|
XMEMCPY(sa, peer, peerSz);
|
|
ssl->buffers.dtlsCtx.peer.sa = sa;
|
|
ssl->buffers.dtlsCtx.peer.sz = peerSz;
|
|
ssl->buffers.dtlsCtx.peer.bufSz = peerSz;
|
|
ssl->buffers.dtlsCtx.userSet = 1;
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
return WOLFSSL_FAILURE;
|
|
#else
|
|
(void)ssl;
|
|
(void)peer;
|
|
(void)peerSz;
|
|
return WOLFSSL_NOT_IMPLEMENTED;
|
|
#endif
|
|
}
|
|
|
|
int wolfSSL_dtls_get_peer(WOLFSSL* ssl, void* peer, unsigned int* peerSz)
|
|
{
|
|
#ifdef WOLFSSL_DTLS
|
|
if (ssl == NULL) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
if (peer != NULL && peerSz != NULL
|
|
&& *peerSz >= ssl->buffers.dtlsCtx.peer.sz
|
|
&& ssl->buffers.dtlsCtx.peer.sa != NULL) {
|
|
*peerSz = ssl->buffers.dtlsCtx.peer.sz;
|
|
XMEMCPY(peer, ssl->buffers.dtlsCtx.peer.sa, *peerSz);
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
return WOLFSSL_FAILURE;
|
|
#else
|
|
(void)ssl;
|
|
(void)peer;
|
|
(void)peerSz;
|
|
return WOLFSSL_NOT_IMPLEMENTED;
|
|
#endif
|
|
}
|
|
|
|
|
|
#if defined(WOLFSSL_SCTP) && defined(WOLFSSL_DTLS)
|
|
|
|
int wolfSSL_CTX_dtls_set_sctp(WOLFSSL_CTX* ctx)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_dtls_set_sctp");
|
|
|
|
if (ctx == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
ctx->dtlsSctp = 1;
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
|
|
int wolfSSL_dtls_set_sctp(WOLFSSL* ssl)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_dtls_set_sctp");
|
|
|
|
if (ssl == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
ssl->options.dtlsSctp = 1;
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
#endif /* WOLFSSL_DTLS && WOLFSSL_SCTP */
|
|
|
|
#if (defined(WOLFSSL_SCTP) || defined(WOLFSSL_DTLS_MTU)) && \
|
|
defined(WOLFSSL_DTLS)
|
|
|
|
int wolfSSL_CTX_dtls_set_mtu(WOLFSSL_CTX* ctx, word16 newMtu)
|
|
{
|
|
if (ctx == NULL || newMtu > MAX_RECORD_SIZE)
|
|
return BAD_FUNC_ARG;
|
|
|
|
ctx->dtlsMtuSz = newMtu;
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
|
|
int wolfSSL_dtls_set_mtu(WOLFSSL* ssl, word16 newMtu)
|
|
{
|
|
if (ssl == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
if (newMtu > MAX_RECORD_SIZE) {
|
|
ssl->error = BAD_FUNC_ARG;
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
ssl->dtlsMtuSz = newMtu;
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
#endif /* WOLFSSL_DTLS && (WOLFSSL_SCTP || WOLFSSL_DTLS_MTU) */
|
|
|
|
#ifdef WOLFSSL_SRTP
|
|
|
|
static const WOLFSSL_SRTP_PROTECTION_PROFILE gSrtpProfiles[] = {
|
|
/* AES CCM 128, Salt:112-bits, Auth HMAC-SHA1 Tag: 80-bits
|
|
* (master_key:128bits + master_salt:112bits) * 2 = 480 bits (60) */
|
|
{"SRTP_AES128_CM_SHA1_80", SRTP_AES128_CM_SHA1_80, (((128 + 112) * 2) / 8) },
|
|
/* AES CCM 128, Salt:112-bits, Auth HMAC-SHA1 Tag: 32-bits
|
|
* (master_key:128bits + master_salt:112bits) * 2 = 480 bits (60) */
|
|
{"SRTP_AES128_CM_SHA1_32", SRTP_AES128_CM_SHA1_32, (((128 + 112) * 2) / 8) },
|
|
/* NULL Cipher, Salt:112-bits, Auth HMAC-SHA1 Tag 80-bits */
|
|
{"SRTP_NULL_SHA1_80", SRTP_NULL_SHA1_80, ((112 * 2) / 8)},
|
|
/* NULL Cipher, Salt:112-bits, Auth HMAC-SHA1 Tag 32-bits */
|
|
{"SRTP_NULL_SHA1_32", SRTP_NULL_SHA1_32, ((112 * 2) / 8)},
|
|
/* AES GCM 128, Salt: 96-bits, Auth GCM Tag 128-bits
|
|
* (master_key:128bits + master_salt:96bits) * 2 = 448 bits (56) */
|
|
{"SRTP_AEAD_AES_128_GCM", SRTP_AEAD_AES_128_GCM, (((128 + 96) * 2) / 8) },
|
|
/* AES GCM 256, Salt: 96-bits, Auth GCM Tag 128-bits
|
|
* (master_key:256bits + master_salt:96bits) * 2 = 704 bits (88) */
|
|
{"SRTP_AEAD_AES_256_GCM", SRTP_AEAD_AES_256_GCM, (((256 + 96) * 2) / 8) },
|
|
};
|
|
|
|
static const WOLFSSL_SRTP_PROTECTION_PROFILE* DtlsSrtpFindProfile(
|
|
const char* profile_str, word32 profile_str_len, unsigned long id)
|
|
{
|
|
int i;
|
|
const WOLFSSL_SRTP_PROTECTION_PROFILE* profile = NULL;
|
|
for (i=0;
|
|
i<(int)(sizeof(gSrtpProfiles)/sizeof(WOLFSSL_SRTP_PROTECTION_PROFILE));
|
|
i++) {
|
|
if (profile_str != NULL) {
|
|
word32 srtp_profile_len = (word32)XSTRLEN(gSrtpProfiles[i].name);
|
|
if (srtp_profile_len == profile_str_len &&
|
|
XMEMCMP(gSrtpProfiles[i].name, profile_str, profile_str_len)
|
|
== 0) {
|
|
profile = &gSrtpProfiles[i];
|
|
break;
|
|
}
|
|
}
|
|
else if (id != 0 && gSrtpProfiles[i].id == id) {
|
|
profile = &gSrtpProfiles[i];
|
|
break;
|
|
}
|
|
}
|
|
return profile;
|
|
}
|
|
|
|
/* profile_str: accepts ":" colon separated list of SRTP profiles */
|
|
static int DtlsSrtpSelProfiles(word16* id, const char* profile_str)
|
|
{
|
|
const WOLFSSL_SRTP_PROTECTION_PROFILE* profile;
|
|
const char *current, *next = NULL;
|
|
word32 length = 0, current_length;
|
|
|
|
*id = 0; /* reset destination ID's */
|
|
|
|
if (profile_str == NULL) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
/* loop on end of line or colon ":" */
|
|
next = profile_str;
|
|
length = (word32)XSTRLEN(profile_str);
|
|
do {
|
|
current = next;
|
|
next = XSTRSTR(current, ":");
|
|
if (next) {
|
|
current_length = (word32)(next - current);
|
|
++next; /* ++ needed to skip ':' */
|
|
} else {
|
|
current_length = (word32)XSTRLEN(current);
|
|
}
|
|
if (current_length < length)
|
|
length = current_length;
|
|
profile = DtlsSrtpFindProfile(current, current_length, 0);
|
|
if (profile != NULL) {
|
|
*id |= (1 << profile->id); /* selected bit based on ID */
|
|
}
|
|
} while (next != NULL);
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
int wolfSSL_CTX_set_tlsext_use_srtp(WOLFSSL_CTX* ctx, const char* profile_str)
|
|
{
|
|
int ret = WOLFSSL_FAILURE;
|
|
if (ctx != NULL) {
|
|
ret = DtlsSrtpSelProfiles(&ctx->dtlsSrtpProfiles, profile_str);
|
|
}
|
|
return ret;
|
|
}
|
|
int wolfSSL_set_tlsext_use_srtp(WOLFSSL* ssl, const char* profile_str)
|
|
{
|
|
int ret = WOLFSSL_FAILURE;
|
|
if (ssl != NULL) {
|
|
ret = DtlsSrtpSelProfiles(&ssl->dtlsSrtpProfiles, profile_str);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
const WOLFSSL_SRTP_PROTECTION_PROFILE* wolfSSL_get_selected_srtp_profile(
|
|
WOLFSSL* ssl)
|
|
{
|
|
const WOLFSSL_SRTP_PROTECTION_PROFILE* profile = NULL;
|
|
if (ssl) {
|
|
profile = DtlsSrtpFindProfile(NULL, 0, ssl->dtlsSrtpId);
|
|
}
|
|
return profile;
|
|
}
|
|
#ifndef NO_WOLFSSL_STUB
|
|
WOLF_STACK_OF(WOLFSSL_SRTP_PROTECTION_PROFILE)* wolfSSL_get_srtp_profiles(
|
|
WOLFSSL* ssl)
|
|
{
|
|
/* Not yet implemented - should return list of available SRTP profiles
|
|
* ssl->dtlsSrtpProfiles */
|
|
(void)ssl;
|
|
return NULL;
|
|
}
|
|
#endif
|
|
|
|
#define DTLS_SRTP_KEYING_MATERIAL_LABEL "EXTRACTOR-dtls_srtp"
|
|
|
|
int wolfSSL_export_dtls_srtp_keying_material(WOLFSSL* ssl,
|
|
unsigned char* out, size_t* olen)
|
|
{
|
|
const WOLFSSL_SRTP_PROTECTION_PROFILE* profile = NULL;
|
|
|
|
if (ssl == NULL || olen == NULL) {
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
profile = DtlsSrtpFindProfile(NULL, 0, ssl->dtlsSrtpId);
|
|
if (profile == NULL) {
|
|
WOLFSSL_MSG("Not using DTLS SRTP");
|
|
return EXT_MISSING;
|
|
}
|
|
if (out == NULL) {
|
|
*olen = profile->kdfBits;
|
|
return LENGTH_ONLY_E;
|
|
}
|
|
|
|
if (*olen < (size_t)profile->kdfBits) {
|
|
return BUFFER_E;
|
|
}
|
|
|
|
return wolfSSL_export_keying_material(ssl, out, profile->kdfBits,
|
|
DTLS_SRTP_KEYING_MATERIAL_LABEL,
|
|
XSTR_SIZEOF(DTLS_SRTP_KEYING_MATERIAL_LABEL), NULL, 0, 0);
|
|
}
|
|
|
|
#endif /* WOLFSSL_SRTP */
|
|
|
|
|
|
#ifdef WOLFSSL_DTLS_DROP_STATS
|
|
|
|
int wolfSSL_dtls_get_drop_stats(WOLFSSL* ssl,
|
|
word32* macDropCount, word32* replayDropCount)
|
|
{
|
|
int ret;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_dtls_get_drop_stats");
|
|
|
|
if (ssl == NULL)
|
|
ret = BAD_FUNC_ARG;
|
|
else {
|
|
ret = WOLFSSL_SUCCESS;
|
|
if (macDropCount != NULL)
|
|
*macDropCount = ssl->macDropCount;
|
|
if (replayDropCount != NULL)
|
|
*replayDropCount = ssl->replayDropCount;
|
|
}
|
|
|
|
WOLFSSL_LEAVE("wolfSSL_dtls_get_drop_stats", ret);
|
|
return ret;
|
|
}
|
|
|
|
#endif /* WOLFSSL_DTLS_DROP_STATS */
|
|
|
|
|
|
#if defined(WOLFSSL_MULTICAST)
|
|
|
|
int wolfSSL_CTX_mcast_set_member_id(WOLFSSL_CTX* ctx, word16 id)
|
|
{
|
|
int ret = 0;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_CTX_mcast_set_member_id");
|
|
|
|
if (ctx == NULL || id > 255)
|
|
ret = BAD_FUNC_ARG;
|
|
|
|
if (ret == 0) {
|
|
ctx->haveEMS = 0;
|
|
ctx->haveMcast = 1;
|
|
ctx->mcastID = (byte)id;
|
|
#ifndef WOLFSSL_USER_IO
|
|
ctx->CBIORecv = EmbedReceiveFromMcast;
|
|
#endif /* WOLFSSL_USER_IO */
|
|
|
|
ret = WOLFSSL_SUCCESS;
|
|
}
|
|
WOLFSSL_LEAVE("wolfSSL_CTX_mcast_set_member_id", ret);
|
|
return ret;
|
|
}
|
|
|
|
int wolfSSL_mcast_get_max_peers(void)
|
|
{
|
|
return WOLFSSL_MULTICAST_PEERS;
|
|
}
|
|
|
|
#ifdef WOLFSSL_DTLS
|
|
static WC_INLINE word32 UpdateHighwaterMark(word32 cur, word32 first,
|
|
word32 second, word32 high)
|
|
{
|
|
word32 newCur = 0;
|
|
|
|
if (cur < first)
|
|
newCur = first;
|
|
else if (cur < second)
|
|
newCur = second;
|
|
else if (cur < high)
|
|
newCur = high;
|
|
|
|
return newCur;
|
|
}
|
|
#endif /* WOLFSSL_DTLS */
|
|
|
|
|
|
int wolfSSL_set_secret(WOLFSSL* ssl, word16 epoch,
|
|
const byte* preMasterSecret, word32 preMasterSz,
|
|
const byte* clientRandom, const byte* serverRandom,
|
|
const byte* suite)
|
|
{
|
|
int ret = 0;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_set_secret");
|
|
|
|
if (ssl == NULL || preMasterSecret == NULL ||
|
|
preMasterSz == 0 || preMasterSz > ENCRYPT_LEN ||
|
|
clientRandom == NULL || serverRandom == NULL || suite == NULL) {
|
|
|
|
ret = BAD_FUNC_ARG;
|
|
}
|
|
|
|
if (ret == 0 && ssl->arrays->preMasterSecret == NULL) {
|
|
ssl->arrays->preMasterSz = ENCRYPT_LEN;
|
|
ssl->arrays->preMasterSecret = (byte*)XMALLOC(ENCRYPT_LEN, ssl->heap,
|
|
DYNAMIC_TYPE_SECRET);
|
|
if (ssl->arrays->preMasterSecret == NULL) {
|
|
ret = MEMORY_E;
|
|
}
|
|
}
|
|
|
|
if (ret == 0) {
|
|
XMEMCPY(ssl->arrays->preMasterSecret, preMasterSecret, preMasterSz);
|
|
XMEMSET(ssl->arrays->preMasterSecret + preMasterSz, 0, ENCRYPT_LEN - preMasterSz);
|
|
ssl->arrays->preMasterSz = preMasterSz;
|
|
XMEMCPY(ssl->arrays->clientRandom, clientRandom, RAN_LEN);
|
|
XMEMCPY(ssl->arrays->serverRandom, serverRandom, RAN_LEN);
|
|
ssl->options.cipherSuite0 = suite[0];
|
|
ssl->options.cipherSuite = suite[1];
|
|
|
|
ret = SetCipherSpecs(ssl);
|
|
}
|
|
|
|
if (ret == 0)
|
|
ret = MakeTlsMasterSecret(ssl);
|
|
|
|
if (ret == 0) {
|
|
ssl->keys.encryptionOn = 1;
|
|
ret = SetKeysSide(ssl, ENCRYPT_AND_DECRYPT_SIDE);
|
|
}
|
|
|
|
if (ret == 0) {
|
|
if (ssl->options.dtls) {
|
|
#ifdef WOLFSSL_DTLS
|
|
WOLFSSL_DTLS_PEERSEQ* peerSeq;
|
|
int i;
|
|
|
|
ssl->keys.dtls_epoch = epoch;
|
|
for (i = 0, peerSeq = ssl->keys.peerSeq;
|
|
i < WOLFSSL_DTLS_PEERSEQ_SZ;
|
|
i++, peerSeq++) {
|
|
|
|
peerSeq->nextEpoch = epoch;
|
|
peerSeq->prevSeq_lo = peerSeq->nextSeq_lo;
|
|
peerSeq->prevSeq_hi = peerSeq->nextSeq_hi;
|
|
peerSeq->nextSeq_lo = 0;
|
|
peerSeq->nextSeq_hi = 0;
|
|
XMEMCPY(peerSeq->prevWindow, peerSeq->window, DTLS_SEQ_SZ);
|
|
XMEMSET(peerSeq->window, 0, DTLS_SEQ_SZ);
|
|
peerSeq->highwaterMark = UpdateHighwaterMark(0,
|
|
ssl->ctx->mcastFirstSeq,
|
|
ssl->ctx->mcastSecondSeq,
|
|
ssl->ctx->mcastMaxSeq);
|
|
}
|
|
#else
|
|
(void)epoch;
|
|
#endif
|
|
}
|
|
FreeHandshakeResources(ssl);
|
|
ret = WOLFSSL_SUCCESS;
|
|
}
|
|
else {
|
|
if (ssl)
|
|
ssl->error = ret;
|
|
ret = WOLFSSL_FATAL_ERROR;
|
|
}
|
|
WOLFSSL_LEAVE("wolfSSL_set_secret", ret);
|
|
return ret;
|
|
}
|
|
|
|
|
|
#ifdef WOLFSSL_DTLS
|
|
|
|
int wolfSSL_mcast_peer_add(WOLFSSL* ssl, word16 peerId, int sub)
|
|
{
|
|
WOLFSSL_DTLS_PEERSEQ* p = NULL;
|
|
int ret = WOLFSSL_SUCCESS;
|
|
int i;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_mcast_peer_add");
|
|
if (ssl == NULL || peerId > 255)
|
|
return BAD_FUNC_ARG;
|
|
|
|
if (!sub) {
|
|
/* Make sure it isn't already present, while keeping the first
|
|
* open spot. */
|
|
for (i = 0; i < WOLFSSL_DTLS_PEERSEQ_SZ; i++) {
|
|
if (ssl->keys.peerSeq[i].peerId == INVALID_PEER_ID)
|
|
p = &ssl->keys.peerSeq[i];
|
|
if (ssl->keys.peerSeq[i].peerId == peerId) {
|
|
WOLFSSL_MSG("Peer ID already in multicast peer list.");
|
|
p = NULL;
|
|
}
|
|
}
|
|
|
|
if (p != NULL) {
|
|
XMEMSET(p, 0, sizeof(WOLFSSL_DTLS_PEERSEQ));
|
|
p->peerId = peerId;
|
|
p->highwaterMark = UpdateHighwaterMark(0,
|
|
ssl->ctx->mcastFirstSeq,
|
|
ssl->ctx->mcastSecondSeq,
|
|
ssl->ctx->mcastMaxSeq);
|
|
}
|
|
else {
|
|
WOLFSSL_MSG("No room in peer list.");
|
|
ret = -1;
|
|
}
|
|
}
|
|
else {
|
|
for (i = 0; i < WOLFSSL_DTLS_PEERSEQ_SZ; i++) {
|
|
if (ssl->keys.peerSeq[i].peerId == peerId)
|
|
p = &ssl->keys.peerSeq[i];
|
|
}
|
|
|
|
if (p != NULL) {
|
|
p->peerId = INVALID_PEER_ID;
|
|
}
|
|
else {
|
|
WOLFSSL_MSG("Peer not found in list.");
|
|
}
|
|
}
|
|
|
|
WOLFSSL_LEAVE("wolfSSL_mcast_peer_add", ret);
|
|
return ret;
|
|
}
|
|
|
|
|
|
/* If peerId is in the list of peers and its last sequence number is non-zero,
|
|
* return 1, otherwise return 0. */
|
|
int wolfSSL_mcast_peer_known(WOLFSSL* ssl, unsigned short peerId)
|
|
{
|
|
int known = 0;
|
|
int i;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_mcast_peer_known");
|
|
|
|
if (ssl == NULL || peerId > 255) {
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
for (i = 0; i < WOLFSSL_DTLS_PEERSEQ_SZ; i++) {
|
|
if (ssl->keys.peerSeq[i].peerId == peerId) {
|
|
if (ssl->keys.peerSeq[i].nextSeq_hi ||
|
|
ssl->keys.peerSeq[i].nextSeq_lo) {
|
|
|
|
known = 1;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
WOLFSSL_LEAVE("wolfSSL_mcast_peer_known", known);
|
|
return known;
|
|
}
|
|
|
|
|
|
int wolfSSL_CTX_mcast_set_highwater_cb(WOLFSSL_CTX* ctx, word32 maxSeq,
|
|
word32 first, word32 second,
|
|
CallbackMcastHighwater cb)
|
|
{
|
|
if (ctx == NULL || (second && first > second) ||
|
|
first > maxSeq || second > maxSeq || cb == NULL) {
|
|
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
ctx->mcastHwCb = cb;
|
|
ctx->mcastFirstSeq = first;
|
|
ctx->mcastSecondSeq = second;
|
|
ctx->mcastMaxSeq = maxSeq;
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
|
|
int wolfSSL_mcast_set_highwater_ctx(WOLFSSL* ssl, void* ctx)
|
|
{
|
|
if (ssl == NULL || ctx == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
ssl->mcastHwCbCtx = ctx;
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
#endif /* WOLFSSL_DTLS */
|
|
|
|
#endif /* WOLFSSL_MULTICAST */
|
|
|
|
|
|
#endif /* WOLFSSL_LEANPSK */
|
|
|
|
|
|
/* return underlying connect or accept, WOLFSSL_SUCCESS on ok */
|
|
int wolfSSL_negotiate(WOLFSSL* ssl)
|
|
{
|
|
int err = WOLFSSL_FATAL_ERROR;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_negotiate");
|
|
|
|
if (ssl == NULL)
|
|
return WOLFSSL_FATAL_ERROR;
|
|
|
|
#ifndef NO_WOLFSSL_SERVER
|
|
if (ssl->options.side == WOLFSSL_SERVER_END) {
|
|
#ifdef WOLFSSL_TLS13
|
|
if (IsAtLeastTLSv1_3(ssl->version))
|
|
err = wolfSSL_accept_TLSv13(ssl);
|
|
else
|
|
#endif
|
|
err = wolfSSL_accept(ssl);
|
|
}
|
|
#endif
|
|
|
|
#ifndef NO_WOLFSSL_CLIENT
|
|
if (ssl->options.side == WOLFSSL_CLIENT_END) {
|
|
#ifdef WOLFSSL_TLS13
|
|
if (IsAtLeastTLSv1_3(ssl->version))
|
|
err = wolfSSL_connect_TLSv13(ssl);
|
|
else
|
|
#endif
|
|
err = wolfSSL_connect(ssl);
|
|
}
|
|
#endif
|
|
|
|
(void)ssl;
|
|
|
|
WOLFSSL_LEAVE("wolfSSL_negotiate", err);
|
|
|
|
return err;
|
|
}
|
|
|
|
|
|
WOLFSSL_ABI
|
|
WC_RNG* wolfSSL_GetRNG(WOLFSSL* ssl)
|
|
{
|
|
if (ssl) {
|
|
return ssl->rng;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
#ifndef WOLFSSL_LEANPSK
|
|
/* object size based on build */
|
|
int wolfSSL_GetObjectSize(void)
|
|
{
|
|
#ifdef SHOW_SIZES
|
|
printf("sizeof suites = %lu\n", (unsigned long)sizeof(Suites));
|
|
printf("sizeof ciphers(2) = %lu\n", (unsigned long)sizeof(Ciphers));
|
|
#ifndef NO_RC4
|
|
printf("\tsizeof arc4 = %lu\n", (unsigned long)sizeof(Arc4));
|
|
#endif
|
|
printf("\tsizeof aes = %lu\n", (unsigned long)sizeof(Aes));
|
|
#ifndef NO_DES3
|
|
printf("\tsizeof des3 = %lu\n", (unsigned long)sizeof(Des3));
|
|
#endif
|
|
#ifdef HAVE_CHACHA
|
|
printf("\tsizeof chacha = %lu\n", (unsigned long)sizeof(ChaCha));
|
|
#endif
|
|
#ifdef WOLFSSL_SM4
|
|
printf("\tsizeof sm4 = %lu\n", (unsigned long)sizeof(Sm4));
|
|
#endif
|
|
printf("sizeof cipher specs = %lu\n", (unsigned long)sizeof(CipherSpecs));
|
|
printf("sizeof keys = %lu\n", (unsigned long)sizeof(Keys));
|
|
printf("sizeof Hashes(2) = %lu\n", (unsigned long)sizeof(Hashes));
|
|
#ifndef NO_MD5
|
|
printf("\tsizeof MD5 = %lu\n", (unsigned long)sizeof(wc_Md5));
|
|
#endif
|
|
#ifndef NO_SHA
|
|
printf("\tsizeof SHA = %lu\n", (unsigned long)sizeof(wc_Sha));
|
|
#endif
|
|
#ifdef WOLFSSL_SHA224
|
|
printf("\tsizeof SHA224 = %lu\n", (unsigned long)sizeof(wc_Sha224));
|
|
#endif
|
|
#ifndef NO_SHA256
|
|
printf("\tsizeof SHA256 = %lu\n", (unsigned long)sizeof(wc_Sha256));
|
|
#endif
|
|
#ifdef WOLFSSL_SHA384
|
|
printf("\tsizeof SHA384 = %lu\n", (unsigned long)sizeof(wc_Sha384));
|
|
#endif
|
|
#ifdef WOLFSSL_SHA384
|
|
printf("\tsizeof SHA512 = %lu\n", (unsigned long)sizeof(wc_Sha512));
|
|
#endif
|
|
#ifdef WOLFSSL_SM3
|
|
printf("\tsizeof sm3 = %lu\n", (unsigned long)sizeof(Sm3));
|
|
#endif
|
|
printf("sizeof Buffers = %lu\n", (unsigned long)sizeof(Buffers));
|
|
printf("sizeof Options = %lu\n", (unsigned long)sizeof(Options));
|
|
printf("sizeof Arrays = %lu\n", (unsigned long)sizeof(Arrays));
|
|
#ifndef NO_RSA
|
|
printf("sizeof RsaKey = %lu\n", (unsigned long)sizeof(RsaKey));
|
|
#endif
|
|
#ifdef HAVE_ECC
|
|
printf("sizeof ecc_key = %lu\n", (unsigned long)sizeof(ecc_key));
|
|
#endif
|
|
printf("sizeof WOLFSSL_CIPHER = %lu\n", (unsigned long)sizeof(WOLFSSL_CIPHER));
|
|
printf("sizeof WOLFSSL_SESSION = %lu\n", (unsigned long)sizeof(WOLFSSL_SESSION));
|
|
printf("sizeof WOLFSSL = %lu\n", (unsigned long)sizeof(WOLFSSL));
|
|
printf("sizeof WOLFSSL_CTX = %lu\n", (unsigned long)sizeof(WOLFSSL_CTX));
|
|
#endif
|
|
|
|
return sizeof(WOLFSSL);
|
|
}
|
|
|
|
int wolfSSL_CTX_GetObjectSize(void)
|
|
{
|
|
return sizeof(WOLFSSL_CTX);
|
|
}
|
|
|
|
int wolfSSL_METHOD_GetObjectSize(void)
|
|
{
|
|
return sizeof(WOLFSSL_METHOD);
|
|
}
|
|
#endif
|
|
|
|
|
|
#ifdef WOLFSSL_STATIC_MEMORY
|
|
|
|
int wolfSSL_CTX_load_static_memory(WOLFSSL_CTX** ctx, wolfSSL_method_func method,
|
|
unsigned char* buf, unsigned int sz,
|
|
int flag, int maxSz)
|
|
{
|
|
WOLFSSL_HEAP* heap;
|
|
WOLFSSL_HEAP_HINT* hint;
|
|
word32 idx = 0;
|
|
|
|
if (ctx == NULL || buf == NULL) {
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
if (*ctx == NULL && method == NULL) {
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
if (*ctx == NULL || (*ctx)->heap == NULL) {
|
|
if (sizeof(WOLFSSL_HEAP) + sizeof(WOLFSSL_HEAP_HINT) > sz - idx) {
|
|
return BUFFER_E; /* not enough memory for structures */
|
|
}
|
|
heap = (WOLFSSL_HEAP*)buf;
|
|
idx += sizeof(WOLFSSL_HEAP);
|
|
if (wolfSSL_init_memory_heap(heap) != 0) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
hint = (WOLFSSL_HEAP_HINT*)(buf + idx);
|
|
idx += sizeof(WOLFSSL_HEAP_HINT);
|
|
XMEMSET(hint, 0, sizeof(WOLFSSL_HEAP_HINT));
|
|
hint->memory = heap;
|
|
|
|
if (*ctx && (*ctx)->heap == NULL) {
|
|
(*ctx)->heap = (void*)hint;
|
|
}
|
|
}
|
|
else {
|
|
#ifdef WOLFSSL_HEAP_TEST
|
|
/* do not load in memory if test has been set */
|
|
if ((*ctx)->heap == (void*)WOLFSSL_HEAP_TEST) {
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
#endif
|
|
hint = (WOLFSSL_HEAP_HINT*)((*ctx)->heap);
|
|
heap = hint->memory;
|
|
}
|
|
|
|
if (wolfSSL_load_static_memory(buf + idx, sz - idx, flag, heap) != 1) {
|
|
WOLFSSL_MSG("Error partitioning memory");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
/* create ctx if needed */
|
|
if (*ctx == NULL) {
|
|
*ctx = wolfSSL_CTX_new_ex(method(hint), hint);
|
|
if (*ctx == NULL) {
|
|
WOLFSSL_MSG("Error creating ctx");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
}
|
|
|
|
/* determine what max applies too */
|
|
if (flag & WOLFMEM_IO_POOL || flag & WOLFMEM_IO_POOL_FIXED) {
|
|
heap->maxIO = maxSz;
|
|
}
|
|
else { /* general memory used in handshakes */
|
|
heap->maxHa = maxSz;
|
|
}
|
|
|
|
heap->flag |= flag;
|
|
|
|
(void)maxSz;
|
|
(void)method;
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
|
|
int wolfSSL_is_static_memory(WOLFSSL* ssl, WOLFSSL_MEM_CONN_STATS* mem_stats)
|
|
{
|
|
if (ssl == NULL) {
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
WOLFSSL_ENTER("wolfSSL_is_static_memory");
|
|
|
|
/* fill out statistics if wanted and WOLFMEM_TRACK_STATS flag */
|
|
if (mem_stats != NULL && ssl->heap != NULL) {
|
|
WOLFSSL_HEAP_HINT* hint = ((WOLFSSL_HEAP_HINT*)(ssl->heap));
|
|
WOLFSSL_HEAP* heap = hint->memory;
|
|
if (heap->flag & WOLFMEM_TRACK_STATS && hint->stats != NULL) {
|
|
XMEMCPY(mem_stats, hint->stats, sizeof(WOLFSSL_MEM_CONN_STATS));
|
|
}
|
|
}
|
|
|
|
return (ssl->heap) ? 1 : 0;
|
|
}
|
|
|
|
|
|
int wolfSSL_CTX_is_static_memory(WOLFSSL_CTX* ctx, WOLFSSL_MEM_STATS* mem_stats)
|
|
{
|
|
if (ctx == NULL) {
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
WOLFSSL_ENTER("wolfSSL_CTX_is_static_memory");
|
|
|
|
/* fill out statistics if wanted */
|
|
if (mem_stats != NULL && ctx->heap != NULL) {
|
|
WOLFSSL_HEAP* heap = ((WOLFSSL_HEAP_HINT*)(ctx->heap))->memory;
|
|
if (wolfSSL_GetMemStats(heap, mem_stats) != 1) {
|
|
return MEMORY_E;
|
|
}
|
|
}
|
|
|
|
return (ctx->heap) ? 1 : 0;
|
|
}
|
|
|
|
#endif /* WOLFSSL_STATIC_MEMORY */
|
|
|
|
|
|
/* return max record layer size plaintext input size */
|
|
int wolfSSL_GetMaxOutputSize(WOLFSSL* ssl)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_GetMaxOutputSize");
|
|
|
|
if (ssl == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
if (ssl->options.handShakeState != HANDSHAKE_DONE) {
|
|
WOLFSSL_MSG("Handshake not complete yet");
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
return wolfSSL_GetMaxFragSize(ssl, OUTPUT_RECORD_SIZE);
|
|
}
|
|
|
|
|
|
/* return record layer size of plaintext input size */
|
|
int wolfSSL_GetOutputSize(WOLFSSL* ssl, int inSz)
|
|
{
|
|
int maxSize;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_GetOutputSize");
|
|
|
|
if (inSz < 0)
|
|
return BAD_FUNC_ARG;
|
|
|
|
maxSize = wolfSSL_GetMaxOutputSize(ssl);
|
|
if (maxSize < 0)
|
|
return maxSize; /* error */
|
|
if (inSz > maxSize)
|
|
return INPUT_SIZE_E;
|
|
|
|
return BuildMessage(ssl, NULL, 0, NULL, inSz, application_data, 0, 1, 0, CUR_ORDER);
|
|
}
|
|
|
|
|
|
#ifdef HAVE_ECC
|
|
int wolfSSL_CTX_SetMinEccKey_Sz(WOLFSSL_CTX* ctx, short keySz)
|
|
{
|
|
if (ctx == NULL || keySz < 0 || keySz % 8 != 0) {
|
|
WOLFSSL_MSG("Key size must be divisible by 8 or ctx was null");
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
ctx->minEccKeySz = keySz / 8;
|
|
#ifndef NO_CERTS
|
|
ctx->cm->minEccKeySz = keySz / 8;
|
|
#endif
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
|
|
int wolfSSL_SetMinEccKey_Sz(WOLFSSL* ssl, short keySz)
|
|
{
|
|
if (ssl == NULL || keySz < 0 || keySz % 8 != 0) {
|
|
WOLFSSL_MSG("Key size must be divisible by 8 or ssl was null");
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
ssl->options.minEccKeySz = keySz / 8;
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
#endif /* HAVE_ECC */
|
|
|
|
#ifndef NO_RSA
|
|
int wolfSSL_CTX_SetMinRsaKey_Sz(WOLFSSL_CTX* ctx, short keySz)
|
|
{
|
|
if (ctx == NULL || keySz < 0 || keySz % 8 != 0) {
|
|
WOLFSSL_MSG("Key size must be divisible by 8 or ctx was null");
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
ctx->minRsaKeySz = keySz / 8;
|
|
ctx->cm->minRsaKeySz = keySz / 8;
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
|
|
int wolfSSL_SetMinRsaKey_Sz(WOLFSSL* ssl, short keySz)
|
|
{
|
|
if (ssl == NULL || keySz < 0 || keySz % 8 != 0) {
|
|
WOLFSSL_MSG("Key size must be divisible by 8 or ssl was null");
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
ssl->options.minRsaKeySz = keySz / 8;
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
#endif /* !NO_RSA */
|
|
|
|
#ifndef NO_DH
|
|
|
|
#ifdef OPENSSL_EXTRA
|
|
long wolfSSL_set_tmp_dh(WOLFSSL *ssl, WOLFSSL_DH *dh)
|
|
{
|
|
int pSz, gSz;
|
|
byte *p, *g;
|
|
int ret = 0;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_set_tmp_dh");
|
|
|
|
if (!ssl || !dh)
|
|
return BAD_FUNC_ARG;
|
|
|
|
/* Get needed size for p and g */
|
|
pSz = wolfSSL_BN_bn2bin(dh->p, NULL);
|
|
gSz = wolfSSL_BN_bn2bin(dh->g, NULL);
|
|
|
|
if (pSz <= 0 || gSz <= 0)
|
|
return -1;
|
|
|
|
p = (byte*)XMALLOC(pSz, ssl->heap, DYNAMIC_TYPE_PUBLIC_KEY);
|
|
if (!p)
|
|
return MEMORY_E;
|
|
|
|
g = (byte*)XMALLOC(gSz, ssl->heap, DYNAMIC_TYPE_PUBLIC_KEY);
|
|
if (!g) {
|
|
XFREE(p, ssl->heap, DYNAMIC_TYPE_PUBLIC_KEY);
|
|
return MEMORY_E;
|
|
}
|
|
|
|
pSz = wolfSSL_BN_bn2bin(dh->p, p);
|
|
gSz = wolfSSL_BN_bn2bin(dh->g, g);
|
|
|
|
if (pSz >= 0 && gSz >= 0) /* Conversion successful */
|
|
ret = wolfSSL_SetTmpDH(ssl, p, pSz, g, gSz);
|
|
|
|
XFREE(p, ssl->heap, DYNAMIC_TYPE_PUBLIC_KEY);
|
|
XFREE(g, ssl->heap, DYNAMIC_TYPE_PUBLIC_KEY);
|
|
|
|
return pSz > 0 && gSz > 0 ? ret : -1;
|
|
}
|
|
#endif /* OPENSSL_EXTRA */
|
|
|
|
/* server Diffie-Hellman parameters, WOLFSSL_SUCCESS on ok */
|
|
int wolfSSL_SetTmpDH(WOLFSSL* ssl, const unsigned char* p, int pSz,
|
|
const unsigned char* g, int gSz)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_SetTmpDH");
|
|
|
|
if (ssl == NULL || p == NULL || g == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
if ((word16)pSz < ssl->options.minDhKeySz)
|
|
return DH_KEY_SIZE_E;
|
|
if ((word16)pSz > ssl->options.maxDhKeySz)
|
|
return DH_KEY_SIZE_E;
|
|
|
|
/* this function is for server only */
|
|
if (ssl->options.side == WOLFSSL_CLIENT_END)
|
|
return SIDE_ERROR;
|
|
|
|
#if !defined(WOLFSSL_OLD_PRIME_CHECK) && !defined(HAVE_FIPS) && \
|
|
!defined(HAVE_SELFTEST)
|
|
ssl->options.dhKeyTested = 0;
|
|
ssl->options.dhDoKeyTest = 1;
|
|
#endif
|
|
|
|
if (ssl->buffers.serverDH_P.buffer && ssl->buffers.weOwnDH) {
|
|
XFREE(ssl->buffers.serverDH_P.buffer, ssl->heap, DYNAMIC_TYPE_PUBLIC_KEY);
|
|
ssl->buffers.serverDH_P.buffer = NULL;
|
|
}
|
|
if (ssl->buffers.serverDH_G.buffer && ssl->buffers.weOwnDH) {
|
|
XFREE(ssl->buffers.serverDH_G.buffer, ssl->heap, DYNAMIC_TYPE_PUBLIC_KEY);
|
|
ssl->buffers.serverDH_G.buffer = NULL;
|
|
}
|
|
|
|
ssl->buffers.weOwnDH = 1; /* SSL owns now */
|
|
ssl->buffers.serverDH_P.buffer = (byte*)XMALLOC(pSz, ssl->heap,
|
|
DYNAMIC_TYPE_PUBLIC_KEY);
|
|
if (ssl->buffers.serverDH_P.buffer == NULL)
|
|
return MEMORY_E;
|
|
|
|
ssl->buffers.serverDH_G.buffer = (byte*)XMALLOC(gSz, ssl->heap,
|
|
DYNAMIC_TYPE_PUBLIC_KEY);
|
|
if (ssl->buffers.serverDH_G.buffer == NULL) {
|
|
XFREE(ssl->buffers.serverDH_P.buffer, ssl->heap, DYNAMIC_TYPE_PUBLIC_KEY);
|
|
ssl->buffers.serverDH_P.buffer = NULL;
|
|
return MEMORY_E;
|
|
}
|
|
|
|
ssl->buffers.serverDH_P.length = pSz;
|
|
ssl->buffers.serverDH_G.length = gSz;
|
|
|
|
XMEMCPY(ssl->buffers.serverDH_P.buffer, p, pSz);
|
|
XMEMCPY(ssl->buffers.serverDH_G.buffer, g, gSz);
|
|
|
|
ssl->options.haveDH = 1;
|
|
|
|
if (ssl->options.side != WOLFSSL_NEITHER_END) {
|
|
word16 havePSK;
|
|
word16 haveRSA;
|
|
int keySz = 0;
|
|
int ret;
|
|
|
|
#ifndef NO_PSK
|
|
havePSK = ssl->options.havePSK;
|
|
#else
|
|
havePSK = 0;
|
|
#endif
|
|
#ifdef NO_RSA
|
|
haveRSA = 0;
|
|
#else
|
|
haveRSA = 1;
|
|
#endif
|
|
#ifndef NO_CERTS
|
|
keySz = ssl->buffers.keySz;
|
|
#endif
|
|
ret = AllocateSuites(ssl);
|
|
if (ret != 0)
|
|
return ret;
|
|
InitSuites(ssl->suites, ssl->version, keySz, haveRSA, havePSK,
|
|
ssl->options.haveDH, ssl->options.haveECDSAsig,
|
|
ssl->options.haveECC, TRUE, ssl->options.haveStaticECC,
|
|
ssl->options.haveFalconSig, ssl->options.haveDilithiumSig,
|
|
ssl->options.haveAnon, TRUE, ssl->options.side);
|
|
}
|
|
|
|
WOLFSSL_LEAVE("wolfSSL_SetTmpDH", 0);
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
|
|
#if !defined(WOLFSSL_OLD_PRIME_CHECK) && !defined(HAVE_FIPS) && \
|
|
!defined(HAVE_SELFTEST)
|
|
/* Enables or disables the session's DH key prime test. */
|
|
int wolfSSL_SetEnableDhKeyTest(WOLFSSL* ssl, int enable)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_SetEnableDhKeyTest");
|
|
|
|
if (ssl == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
if (!enable)
|
|
ssl->options.dhDoKeyTest = 0;
|
|
else
|
|
ssl->options.dhDoKeyTest = 1;
|
|
|
|
WOLFSSL_LEAVE("wolfSSL_SetEnableDhKeyTest", WOLFSSL_SUCCESS);
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
#endif
|
|
|
|
|
|
/* server ctx Diffie-Hellman parameters, WOLFSSL_SUCCESS on ok */
|
|
int wolfSSL_CTX_SetTmpDH(WOLFSSL_CTX* ctx, const unsigned char* p, int pSz,
|
|
const unsigned char* g, int gSz)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_SetTmpDH");
|
|
if (ctx == NULL || p == NULL || g == NULL) return BAD_FUNC_ARG;
|
|
|
|
if ((word16)pSz < ctx->minDhKeySz)
|
|
return DH_KEY_SIZE_E;
|
|
if ((word16)pSz > ctx->maxDhKeySz)
|
|
return DH_KEY_SIZE_E;
|
|
|
|
#if !defined(WOLFSSL_OLD_PRIME_CHECK) && !defined(HAVE_FIPS) && \
|
|
!defined(HAVE_SELFTEST)
|
|
{
|
|
WC_RNG rng;
|
|
int error, freeKey = 0;
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
DhKey *checkKey = (DhKey*)XMALLOC(sizeof(DhKey), NULL, DYNAMIC_TYPE_DH);
|
|
if (checkKey == NULL)
|
|
return MEMORY_E;
|
|
#else
|
|
DhKey checkKey[1];
|
|
#endif
|
|
|
|
error = wc_InitRng(&rng);
|
|
if (!error)
|
|
error = wc_InitDhKey(checkKey);
|
|
if (!error) {
|
|
freeKey = 1;
|
|
error = wc_DhSetCheckKey(checkKey,
|
|
p, pSz, g, gSz, NULL, 0, 0, &rng);
|
|
}
|
|
if (freeKey)
|
|
wc_FreeDhKey(checkKey);
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
XFREE(checkKey, NULL, DYNAMIC_TYPE_DH);
|
|
#endif
|
|
wc_FreeRng(&rng);
|
|
if (error)
|
|
return error;
|
|
|
|
ctx->dhKeyTested = 1;
|
|
}
|
|
#endif
|
|
|
|
XFREE(ctx->serverDH_P.buffer, ctx->heap, DYNAMIC_TYPE_PUBLIC_KEY);
|
|
ctx->serverDH_P.buffer = NULL;
|
|
XFREE(ctx->serverDH_G.buffer, ctx->heap, DYNAMIC_TYPE_PUBLIC_KEY);
|
|
ctx->serverDH_G.buffer = NULL;
|
|
|
|
ctx->serverDH_P.buffer = (byte*)XMALLOC(pSz, ctx->heap, DYNAMIC_TYPE_PUBLIC_KEY);
|
|
if (ctx->serverDH_P.buffer == NULL)
|
|
return MEMORY_E;
|
|
|
|
ctx->serverDH_G.buffer = (byte*)XMALLOC(gSz, ctx->heap, DYNAMIC_TYPE_PUBLIC_KEY);
|
|
if (ctx->serverDH_G.buffer == NULL) {
|
|
XFREE(ctx->serverDH_P.buffer, ctx->heap, DYNAMIC_TYPE_PUBLIC_KEY);
|
|
ctx->serverDH_P.buffer = NULL;
|
|
return MEMORY_E;
|
|
}
|
|
|
|
ctx->serverDH_P.length = pSz;
|
|
ctx->serverDH_G.length = gSz;
|
|
|
|
XMEMCPY(ctx->serverDH_P.buffer, p, pSz);
|
|
XMEMCPY(ctx->serverDH_G.buffer, g, gSz);
|
|
|
|
ctx->haveDH = 1;
|
|
|
|
WOLFSSL_LEAVE("wolfSSL_CTX_SetTmpDH", 0);
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
|
|
int wolfSSL_CTX_SetMinDhKey_Sz(WOLFSSL_CTX* ctx, word16 keySz_bits)
|
|
{
|
|
if (ctx == NULL || keySz_bits > 16000 || keySz_bits % 8 != 0)
|
|
return BAD_FUNC_ARG;
|
|
|
|
ctx->minDhKeySz = keySz_bits / 8;
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
|
|
int wolfSSL_SetMinDhKey_Sz(WOLFSSL* ssl, word16 keySz_bits)
|
|
{
|
|
if (ssl == NULL || keySz_bits > 16000 || keySz_bits % 8 != 0)
|
|
return BAD_FUNC_ARG;
|
|
|
|
ssl->options.minDhKeySz = keySz_bits / 8;
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
|
|
int wolfSSL_CTX_SetMaxDhKey_Sz(WOLFSSL_CTX* ctx, word16 keySz_bits)
|
|
{
|
|
if (ctx == NULL || keySz_bits > 16000 || keySz_bits % 8 != 0)
|
|
return BAD_FUNC_ARG;
|
|
|
|
ctx->maxDhKeySz = keySz_bits / 8;
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
|
|
int wolfSSL_SetMaxDhKey_Sz(WOLFSSL* ssl, word16 keySz_bits)
|
|
{
|
|
if (ssl == NULL || keySz_bits > 16000 || keySz_bits % 8 != 0)
|
|
return BAD_FUNC_ARG;
|
|
|
|
ssl->options.maxDhKeySz = keySz_bits / 8;
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
|
|
int wolfSSL_GetDhKey_Sz(WOLFSSL* ssl)
|
|
{
|
|
if (ssl == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
return (ssl->options.dhKeySz * 8);
|
|
}
|
|
|
|
#endif /* !NO_DH */
|
|
|
|
|
|
WOLFSSL_ABI
|
|
int wolfSSL_write(WOLFSSL* ssl, const void* data, int sz)
|
|
{
|
|
int ret;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_write");
|
|
|
|
if (ssl == NULL || data == NULL || sz < 0)
|
|
return BAD_FUNC_ARG;
|
|
|
|
#ifdef WOLFSSL_QUIC
|
|
if (WOLFSSL_IS_QUIC(ssl)) {
|
|
WOLFSSL_MSG("SSL_write() on QUIC not allowed");
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
#endif
|
|
#ifdef WOLFSSL_EARLY_DATA
|
|
if (IsAtLeastTLSv1_3(ssl->version) &&
|
|
ssl->options.side == WOLFSSL_SERVER_END &&
|
|
ssl->options.acceptState >= TLS13_ACCEPT_FINISHED_SENT) {
|
|
/* We can send data without waiting on peer finished msg */
|
|
WOLFSSL_MSG("server sending data before receiving client finished");
|
|
}
|
|
else if (ssl->earlyData != no_early_data &&
|
|
(ret = wolfSSL_negotiate(ssl)) < 0) {
|
|
ssl->error = ret;
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
ssl->earlyData = no_early_data;
|
|
#endif
|
|
|
|
#ifdef HAVE_WRITE_DUP
|
|
{ /* local variable scope */
|
|
int dupErr = 0; /* local copy */
|
|
|
|
ret = 0;
|
|
|
|
if (ssl->dupWrite && ssl->dupSide == READ_DUP_SIDE) {
|
|
WOLFSSL_MSG("Read dup side cannot write");
|
|
return WRITE_DUP_WRITE_E;
|
|
}
|
|
if (ssl->dupWrite) {
|
|
if (wc_LockMutex(&ssl->dupWrite->dupMutex) != 0) {
|
|
return BAD_MUTEX_E;
|
|
}
|
|
dupErr = ssl->dupWrite->dupErr;
|
|
ret = wc_UnLockMutex(&ssl->dupWrite->dupMutex);
|
|
}
|
|
|
|
if (ret != 0) {
|
|
ssl->error = ret; /* high priority fatal error */
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
if (dupErr != 0) {
|
|
WOLFSSL_MSG("Write dup error from other side");
|
|
ssl->error = dupErr;
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#ifdef HAVE_ERRNO_H
|
|
errno = 0;
|
|
#endif
|
|
|
|
#ifdef OPENSSL_EXTRA
|
|
if (ssl->CBIS != NULL) {
|
|
ssl->CBIS(ssl, SSL_CB_WRITE, WOLFSSL_SUCCESS);
|
|
ssl->cbmode = SSL_CB_WRITE;
|
|
}
|
|
#endif
|
|
ret = SendData(ssl, data, sz);
|
|
|
|
WOLFSSL_LEAVE("wolfSSL_write", ret);
|
|
|
|
if (ret < 0)
|
|
return WOLFSSL_FATAL_ERROR;
|
|
else
|
|
return ret;
|
|
}
|
|
|
|
static int wolfSSL_read_internal(WOLFSSL* ssl, void* data, int sz, int peek)
|
|
{
|
|
int ret;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_read_internal");
|
|
|
|
if (ssl == NULL || data == NULL || sz < 0)
|
|
return BAD_FUNC_ARG;
|
|
|
|
#ifdef WOLFSSL_QUIC
|
|
if (WOLFSSL_IS_QUIC(ssl)) {
|
|
WOLFSSL_MSG("SSL_read() on QUIC not allowed");
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
#endif
|
|
#if defined(WOLFSSL_ERROR_CODE_OPENSSL) && defined(OPENSSL_EXTRA)
|
|
/* This additional logic is meant to simulate following openSSL behavior:
|
|
* After bidirectional SSL_shutdown complete, SSL_read returns 0 and
|
|
* SSL_get_error_code returns SSL_ERROR_ZERO_RETURN.
|
|
* This behavior is used to know the disconnect of the underlying
|
|
* transport layer.
|
|
*
|
|
* In this logic, CBIORecv is called with a read size of 0 to check the
|
|
* transport layer status. It also returns WOLFSSL_FAILURE so that
|
|
* SSL_read does not return a positive number on failure.
|
|
*/
|
|
|
|
/* make sure bidirectional TLS shutdown completes */
|
|
if (ssl->error == WOLFSSL_ERROR_SYSCALL || ssl->options.shutdownDone) {
|
|
/* ask the underlying transport the connection is closed */
|
|
if (ssl->CBIORecv(ssl, (char*)data, 0, ssl->IOCB_ReadCtx) ==
|
|
WOLFSSL_CBIO_ERR_CONN_CLOSE) {
|
|
ssl->options.isClosed = 1;
|
|
ssl->error = WOLFSSL_ERROR_ZERO_RETURN;
|
|
}
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
#endif
|
|
|
|
#ifdef HAVE_WRITE_DUP
|
|
if (ssl->dupWrite && ssl->dupSide == WRITE_DUP_SIDE) {
|
|
WOLFSSL_MSG("Write dup side cannot read");
|
|
return WRITE_DUP_READ_E;
|
|
}
|
|
#endif
|
|
|
|
#ifdef HAVE_ERRNO_H
|
|
errno = 0;
|
|
#endif
|
|
|
|
ret = ReceiveData(ssl, (byte*)data, sz, peek);
|
|
|
|
#ifdef HAVE_WRITE_DUP
|
|
if (ssl->dupWrite) {
|
|
if (ssl->error != 0 && ssl->error != WANT_READ
|
|
#ifdef WOLFSSL_ASYNC_CRYPT
|
|
&& ssl->error != WC_PENDING_E
|
|
#endif
|
|
) {
|
|
int notifyErr;
|
|
|
|
WOLFSSL_MSG("Notifying write side of fatal read error");
|
|
notifyErr = NotifyWriteSide(ssl, ssl->error);
|
|
if (notifyErr < 0) {
|
|
ret = ssl->error = notifyErr;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
WOLFSSL_LEAVE("wolfSSL_read_internal", ret);
|
|
|
|
if (ret < 0)
|
|
return WOLFSSL_FATAL_ERROR;
|
|
else
|
|
return ret;
|
|
}
|
|
|
|
|
|
int wolfSSL_peek(WOLFSSL* ssl, void* data, int sz)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_peek");
|
|
|
|
return wolfSSL_read_internal(ssl, data, sz, TRUE);
|
|
}
|
|
|
|
|
|
WOLFSSL_ABI
|
|
int wolfSSL_read(WOLFSSL* ssl, void* data, int sz)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_read");
|
|
|
|
#ifdef OPENSSL_EXTRA
|
|
if (ssl == NULL) {
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
if (ssl->CBIS != NULL) {
|
|
ssl->CBIS(ssl, SSL_CB_READ, WOLFSSL_SUCCESS);
|
|
ssl->cbmode = SSL_CB_READ;
|
|
}
|
|
#endif
|
|
return wolfSSL_read_internal(ssl, data, sz, FALSE);
|
|
}
|
|
|
|
|
|
#ifdef WOLFSSL_MULTICAST
|
|
|
|
int wolfSSL_mcast_read(WOLFSSL* ssl, word16* id, void* data, int sz)
|
|
{
|
|
int ret = 0;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_mcast_read");
|
|
|
|
if (ssl == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
ret = wolfSSL_read_internal(ssl, data, sz, FALSE);
|
|
if (ssl->options.dtls && ssl->options.haveMcast && id != NULL)
|
|
*id = ssl->keys.curPeerId;
|
|
return ret;
|
|
}
|
|
|
|
#endif /* WOLFSSL_MULTICAST */
|
|
|
|
|
|
/* helpers to set the device id, WOLFSSL_SUCCESS on ok */
|
|
WOLFSSL_ABI
|
|
int wolfSSL_SetDevId(WOLFSSL* ssl, int devId)
|
|
{
|
|
if (ssl == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
ssl->devId = devId;
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
WOLFSSL_ABI
|
|
int wolfSSL_CTX_SetDevId(WOLFSSL_CTX* ctx, int devId)
|
|
{
|
|
if (ctx == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
ctx->devId = devId;
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
/* helpers to get device id and heap */
|
|
WOLFSSL_ABI
|
|
int wolfSSL_CTX_GetDevId(WOLFSSL_CTX* ctx, WOLFSSL* ssl)
|
|
{
|
|
int devId = INVALID_DEVID;
|
|
if (ssl != NULL)
|
|
devId = ssl->devId;
|
|
if (ctx != NULL && devId == INVALID_DEVID)
|
|
devId = ctx->devId;
|
|
return devId;
|
|
}
|
|
void* wolfSSL_CTX_GetHeap(WOLFSSL_CTX* ctx, WOLFSSL* ssl)
|
|
{
|
|
void* heap = NULL;
|
|
if (ctx != NULL)
|
|
heap = ctx->heap;
|
|
else if (ssl != NULL)
|
|
heap = ssl->heap;
|
|
return heap;
|
|
}
|
|
|
|
|
|
#ifdef HAVE_SNI
|
|
|
|
WOLFSSL_ABI
|
|
int wolfSSL_UseSNI(WOLFSSL* ssl, byte type, const void* data, word16 size)
|
|
{
|
|
if (ssl == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
return TLSX_UseSNI(&ssl->extensions, type, data, size, ssl->heap);
|
|
}
|
|
|
|
|
|
WOLFSSL_ABI
|
|
int wolfSSL_CTX_UseSNI(WOLFSSL_CTX* ctx, byte type, const void* data,
|
|
word16 size)
|
|
{
|
|
if (ctx == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
return TLSX_UseSNI(&ctx->extensions, type, data, size, ctx->heap);
|
|
}
|
|
|
|
#ifndef NO_WOLFSSL_SERVER
|
|
|
|
void wolfSSL_SNI_SetOptions(WOLFSSL* ssl, byte type, byte options)
|
|
{
|
|
if (ssl && ssl->extensions)
|
|
TLSX_SNI_SetOptions(ssl->extensions, type, options);
|
|
}
|
|
|
|
|
|
void wolfSSL_CTX_SNI_SetOptions(WOLFSSL_CTX* ctx, byte type, byte options)
|
|
{
|
|
if (ctx && ctx->extensions)
|
|
TLSX_SNI_SetOptions(ctx->extensions, type, options);
|
|
}
|
|
|
|
|
|
byte wolfSSL_SNI_Status(WOLFSSL* ssl, byte type)
|
|
{
|
|
return TLSX_SNI_Status(ssl ? ssl->extensions : NULL, type);
|
|
}
|
|
|
|
|
|
word16 wolfSSL_SNI_GetRequest(WOLFSSL* ssl, byte type, void** data)
|
|
{
|
|
if (data)
|
|
*data = NULL;
|
|
|
|
if (ssl && ssl->extensions)
|
|
return TLSX_SNI_GetRequest(ssl->extensions, type, data);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int wolfSSL_SNI_GetFromBuffer(const byte* clientHello, word32 helloSz,
|
|
byte type, byte* sni, word32* inOutSz)
|
|
{
|
|
if (clientHello && helloSz > 0 && sni && inOutSz && *inOutSz > 0)
|
|
return TLSX_SNI_GetFromBuffer(clientHello, helloSz, type, sni, inOutSz);
|
|
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
#endif /* NO_WOLFSSL_SERVER */
|
|
|
|
#endif /* HAVE_SNI */
|
|
|
|
|
|
#ifdef HAVE_TRUSTED_CA
|
|
|
|
int wolfSSL_UseTrustedCA(WOLFSSL* ssl, byte type,
|
|
const byte* certId, word32 certIdSz)
|
|
{
|
|
if (ssl == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
if (type == WOLFSSL_TRUSTED_CA_PRE_AGREED) {
|
|
if (certId != NULL || certIdSz != 0)
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
else if (type == WOLFSSL_TRUSTED_CA_X509_NAME) {
|
|
if (certId == NULL || certIdSz == 0)
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
#ifndef NO_SHA
|
|
else if (type == WOLFSSL_TRUSTED_CA_KEY_SHA1 ||
|
|
type == WOLFSSL_TRUSTED_CA_CERT_SHA1) {
|
|
if (certId == NULL || certIdSz != WC_SHA_DIGEST_SIZE)
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
#endif
|
|
else
|
|
return BAD_FUNC_ARG;
|
|
|
|
return TLSX_UseTrustedCA(&ssl->extensions,
|
|
type, certId, certIdSz, ssl->heap);
|
|
}
|
|
|
|
#endif /* HAVE_TRUSTED_CA */
|
|
|
|
|
|
#ifdef HAVE_MAX_FRAGMENT
|
|
#ifndef NO_WOLFSSL_CLIENT
|
|
|
|
int wolfSSL_UseMaxFragment(WOLFSSL* ssl, byte mfl)
|
|
{
|
|
if (ssl == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
#ifdef WOLFSSL_ALLOW_MAX_FRAGMENT_ADJUST
|
|
/* The following is a non-standard way to reconfigure the max packet size
|
|
post-handshake for wolfSSL_write/wolfSSL_read */
|
|
if (ssl->options.handShakeState == HANDSHAKE_DONE) {
|
|
switch (mfl) {
|
|
case WOLFSSL_MFL_2_8 : ssl->max_fragment = 256; break;
|
|
case WOLFSSL_MFL_2_9 : ssl->max_fragment = 512; break;
|
|
case WOLFSSL_MFL_2_10: ssl->max_fragment = 1024; break;
|
|
case WOLFSSL_MFL_2_11: ssl->max_fragment = 2048; break;
|
|
case WOLFSSL_MFL_2_12: ssl->max_fragment = 4096; break;
|
|
case WOLFSSL_MFL_2_13: ssl->max_fragment = 8192; break;
|
|
default: ssl->max_fragment = MAX_RECORD_SIZE; break;
|
|
}
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
#endif /* WOLFSSL_MAX_FRAGMENT_ADJUST */
|
|
|
|
/* This call sets the max fragment TLS extension, which gets sent to server.
|
|
The server_hello response is what sets the `ssl->max_fragment` in
|
|
TLSX_MFL_Parse */
|
|
return TLSX_UseMaxFragment(&ssl->extensions, mfl, ssl->heap);
|
|
}
|
|
|
|
|
|
int wolfSSL_CTX_UseMaxFragment(WOLFSSL_CTX* ctx, byte mfl)
|
|
{
|
|
if (ctx == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
return TLSX_UseMaxFragment(&ctx->extensions, mfl, ctx->heap);
|
|
}
|
|
|
|
#endif /* NO_WOLFSSL_CLIENT */
|
|
#endif /* HAVE_MAX_FRAGMENT */
|
|
|
|
#ifdef HAVE_TRUNCATED_HMAC
|
|
#ifndef NO_WOLFSSL_CLIENT
|
|
|
|
int wolfSSL_UseTruncatedHMAC(WOLFSSL* ssl)
|
|
{
|
|
if (ssl == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
return TLSX_UseTruncatedHMAC(&ssl->extensions, ssl->heap);
|
|
}
|
|
|
|
|
|
int wolfSSL_CTX_UseTruncatedHMAC(WOLFSSL_CTX* ctx)
|
|
{
|
|
if (ctx == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
return TLSX_UseTruncatedHMAC(&ctx->extensions, ctx->heap);
|
|
}
|
|
|
|
#endif /* NO_WOLFSSL_CLIENT */
|
|
#endif /* HAVE_TRUNCATED_HMAC */
|
|
|
|
#ifdef HAVE_CERTIFICATE_STATUS_REQUEST
|
|
|
|
int wolfSSL_UseOCSPStapling(WOLFSSL* ssl, byte status_type, byte options)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_UseOCSPStapling");
|
|
|
|
if (ssl == NULL || ssl->options.side != WOLFSSL_CLIENT_END)
|
|
return BAD_FUNC_ARG;
|
|
|
|
return TLSX_UseCertificateStatusRequest(&ssl->extensions, status_type,
|
|
options, NULL, ssl->heap, ssl->devId);
|
|
}
|
|
|
|
|
|
int wolfSSL_CTX_UseOCSPStapling(WOLFSSL_CTX* ctx, byte status_type,
|
|
byte options)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_UseOCSPStapling");
|
|
|
|
if (ctx == NULL || ctx->method->side != WOLFSSL_CLIENT_END)
|
|
return BAD_FUNC_ARG;
|
|
|
|
return TLSX_UseCertificateStatusRequest(&ctx->extensions, status_type,
|
|
options, NULL, ctx->heap, ctx->devId);
|
|
}
|
|
|
|
#endif /* HAVE_CERTIFICATE_STATUS_REQUEST */
|
|
|
|
#ifdef HAVE_CERTIFICATE_STATUS_REQUEST_V2
|
|
|
|
int wolfSSL_UseOCSPStaplingV2(WOLFSSL* ssl, byte status_type, byte options)
|
|
{
|
|
if (ssl == NULL || ssl->options.side != WOLFSSL_CLIENT_END)
|
|
return BAD_FUNC_ARG;
|
|
|
|
return TLSX_UseCertificateStatusRequestV2(&ssl->extensions, status_type,
|
|
options, ssl->heap, ssl->devId);
|
|
}
|
|
|
|
|
|
int wolfSSL_CTX_UseOCSPStaplingV2(WOLFSSL_CTX* ctx, byte status_type,
|
|
byte options)
|
|
{
|
|
if (ctx == NULL || ctx->method->side != WOLFSSL_CLIENT_END)
|
|
return BAD_FUNC_ARG;
|
|
|
|
return TLSX_UseCertificateStatusRequestV2(&ctx->extensions, status_type,
|
|
options, ctx->heap, ctx->devId);
|
|
}
|
|
|
|
#endif /* HAVE_CERTIFICATE_STATUS_REQUEST_V2 */
|
|
|
|
/* Elliptic Curves */
|
|
#if defined(HAVE_SUPPORTED_CURVES)
|
|
|
|
static int isValidCurveGroup(word16 name)
|
|
{
|
|
switch (name) {
|
|
case WOLFSSL_ECC_SECP160K1:
|
|
case WOLFSSL_ECC_SECP160R1:
|
|
case WOLFSSL_ECC_SECP160R2:
|
|
case WOLFSSL_ECC_SECP192K1:
|
|
case WOLFSSL_ECC_SECP192R1:
|
|
case WOLFSSL_ECC_SECP224K1:
|
|
case WOLFSSL_ECC_SECP224R1:
|
|
case WOLFSSL_ECC_SECP256K1:
|
|
case WOLFSSL_ECC_SECP256R1:
|
|
case WOLFSSL_ECC_SECP384R1:
|
|
case WOLFSSL_ECC_SECP521R1:
|
|
case WOLFSSL_ECC_BRAINPOOLP256R1:
|
|
case WOLFSSL_ECC_BRAINPOOLP384R1:
|
|
case WOLFSSL_ECC_BRAINPOOLP512R1:
|
|
case WOLFSSL_ECC_SM2P256V1:
|
|
case WOLFSSL_ECC_X25519:
|
|
case WOLFSSL_ECC_X448:
|
|
|
|
case WOLFSSL_FFDHE_2048:
|
|
case WOLFSSL_FFDHE_3072:
|
|
case WOLFSSL_FFDHE_4096:
|
|
case WOLFSSL_FFDHE_6144:
|
|
case WOLFSSL_FFDHE_8192:
|
|
|
|
#ifdef HAVE_PQC
|
|
case WOLFSSL_KYBER_LEVEL1:
|
|
case WOLFSSL_KYBER_LEVEL3:
|
|
case WOLFSSL_KYBER_LEVEL5:
|
|
#ifdef HAVE_LIBOQS
|
|
case WOLFSSL_P256_KYBER_LEVEL1:
|
|
case WOLFSSL_P384_KYBER_LEVEL3:
|
|
case WOLFSSL_P521_KYBER_LEVEL5:
|
|
#endif
|
|
#endif
|
|
return 1;
|
|
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
int wolfSSL_UseSupportedCurve(WOLFSSL* ssl, word16 name)
|
|
{
|
|
if (ssl == NULL || !isValidCurveGroup(name))
|
|
return BAD_FUNC_ARG;
|
|
|
|
ssl->options.userCurves = 1;
|
|
#if defined(NO_TLS)
|
|
return WOLFSSL_FAILURE;
|
|
#else
|
|
return TLSX_UseSupportedCurve(&ssl->extensions, name, ssl->heap);
|
|
#endif /* NO_TLS */
|
|
}
|
|
|
|
|
|
int wolfSSL_CTX_UseSupportedCurve(WOLFSSL_CTX* ctx, word16 name)
|
|
{
|
|
if (ctx == NULL || !isValidCurveGroup(name))
|
|
return BAD_FUNC_ARG;
|
|
|
|
ctx->userCurves = 1;
|
|
#if defined(NO_TLS)
|
|
return WOLFSSL_FAILURE;
|
|
#else
|
|
return TLSX_UseSupportedCurve(&ctx->extensions, name, ctx->heap);
|
|
#endif /* NO_TLS */
|
|
}
|
|
|
|
#if defined(OPENSSL_EXTRA) && defined(WOLFSSL_TLS13)
|
|
int wolfSSL_CTX_set1_groups(WOLFSSL_CTX* ctx, int* groups,
|
|
int count)
|
|
{
|
|
int i;
|
|
int _groups[WOLFSSL_MAX_GROUP_COUNT];
|
|
WOLFSSL_ENTER("wolfSSL_CTX_set1_groups");
|
|
if (count == 0) {
|
|
WOLFSSL_MSG("Group count is zero");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
for (i = 0; i < count; i++) {
|
|
if (isValidCurveGroup((word16)groups[i])) {
|
|
_groups[i] = groups[i];
|
|
}
|
|
#ifdef HAVE_ECC
|
|
else {
|
|
/* groups may be populated with curve NIDs */
|
|
int oid = nid2oid(groups[i], oidCurveType);
|
|
int name = (int)GetCurveByOID(oid);
|
|
if (name == 0) {
|
|
WOLFSSL_MSG("Invalid group name");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
_groups[i] = name;
|
|
}
|
|
#else
|
|
else {
|
|
WOLFSSL_MSG("Invalid group name");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
#endif
|
|
}
|
|
return wolfSSL_CTX_set_groups(ctx, _groups, count) == WOLFSSL_SUCCESS ?
|
|
WOLFSSL_SUCCESS : WOLFSSL_FAILURE;
|
|
}
|
|
|
|
int wolfSSL_set1_groups(WOLFSSL* ssl, int* groups, int count)
|
|
{
|
|
int i;
|
|
int _groups[WOLFSSL_MAX_GROUP_COUNT];
|
|
WOLFSSL_ENTER("wolfSSL_CTX_set1_groups");
|
|
if (count == 0) {
|
|
WOLFSSL_MSG("Group count is zero");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
for (i = 0; i < count; i++) {
|
|
if (isValidCurveGroup((word16)groups[i])) {
|
|
_groups[i] = groups[i];
|
|
}
|
|
#ifdef HAVE_ECC
|
|
else {
|
|
/* groups may be populated with curve NIDs */
|
|
int oid = nid2oid(groups[i], oidCurveType);
|
|
int name = (int)GetCurveByOID(oid);
|
|
if (name == 0) {
|
|
WOLFSSL_MSG("Invalid group name");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
_groups[i] = name;
|
|
}
|
|
#else
|
|
else {
|
|
WOLFSSL_MSG("Invalid group name");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
#endif
|
|
}
|
|
return wolfSSL_set_groups(ssl, _groups, count) == WOLFSSL_SUCCESS ?
|
|
WOLFSSL_SUCCESS : WOLFSSL_FAILURE;
|
|
}
|
|
#endif /* OPENSSL_EXTRA && WOLFSSL_TLS13 */
|
|
#endif /* HAVE_SUPPORTED_CURVES */
|
|
|
|
/* Application-Layer Protocol Negotiation */
|
|
#ifdef HAVE_ALPN
|
|
|
|
WOLFSSL_ABI
|
|
int wolfSSL_UseALPN(WOLFSSL* ssl, char *protocol_name_list,
|
|
word32 protocol_name_listSz, byte options)
|
|
{
|
|
char *list, *ptr, **token;
|
|
word16 len;
|
|
int idx = 0;
|
|
int ret = WOLFSSL_FAILURE;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_UseALPN");
|
|
|
|
if (ssl == NULL || protocol_name_list == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
if (protocol_name_listSz > (WOLFSSL_MAX_ALPN_NUMBER *
|
|
WOLFSSL_MAX_ALPN_PROTO_NAME_LEN +
|
|
WOLFSSL_MAX_ALPN_NUMBER)) {
|
|
WOLFSSL_MSG("Invalid arguments, protocol name list too long");
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
if (!(options & WOLFSSL_ALPN_CONTINUE_ON_MISMATCH) &&
|
|
!(options & WOLFSSL_ALPN_FAILED_ON_MISMATCH)) {
|
|
WOLFSSL_MSG("Invalid arguments, options not supported");
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
|
|
list = (char *)XMALLOC(protocol_name_listSz+1, ssl->heap,
|
|
DYNAMIC_TYPE_ALPN);
|
|
if (list == NULL) {
|
|
WOLFSSL_MSG("Memory failure");
|
|
return MEMORY_ERROR;
|
|
}
|
|
|
|
token = (char **)XMALLOC(sizeof(char *) * (WOLFSSL_MAX_ALPN_NUMBER+1), ssl->heap, DYNAMIC_TYPE_ALPN);
|
|
if (token == NULL) {
|
|
XFREE(list, ssl->heap, DYNAMIC_TYPE_ALPN);
|
|
WOLFSSL_MSG("Memory failure");
|
|
return MEMORY_ERROR;
|
|
}
|
|
XMEMSET(token, 0, sizeof(char *) * (WOLFSSL_MAX_ALPN_NUMBER+1));
|
|
|
|
XSTRNCPY(list, protocol_name_list, protocol_name_listSz);
|
|
list[protocol_name_listSz] = '\0';
|
|
|
|
/* read all protocol name from the list */
|
|
token[idx] = XSTRTOK(list, ",", &ptr);
|
|
while (idx < WOLFSSL_MAX_ALPN_NUMBER && token[idx] != NULL)
|
|
token[++idx] = XSTRTOK(NULL, ",", &ptr);
|
|
|
|
/* add protocol name list in the TLS extension in reverse order */
|
|
while ((idx--) > 0) {
|
|
len = (word16)XSTRLEN(token[idx]);
|
|
|
|
ret = TLSX_UseALPN(&ssl->extensions, token[idx], len, options,
|
|
ssl->heap);
|
|
if (ret != WOLFSSL_SUCCESS) {
|
|
WOLFSSL_MSG("TLSX_UseALPN failure");
|
|
break;
|
|
}
|
|
}
|
|
|
|
XFREE(token, ssl->heap, DYNAMIC_TYPE_ALPN);
|
|
XFREE(list, ssl->heap, DYNAMIC_TYPE_ALPN);
|
|
|
|
return ret;
|
|
}
|
|
|
|
int wolfSSL_ALPN_GetProtocol(WOLFSSL* ssl, char **protocol_name, word16 *size)
|
|
{
|
|
return TLSX_ALPN_GetRequest(ssl ? ssl->extensions : NULL,
|
|
(void **)protocol_name, size);
|
|
}
|
|
|
|
int wolfSSL_ALPN_GetPeerProtocol(WOLFSSL* ssl, char **list, word16 *listSz)
|
|
{
|
|
int i, len;
|
|
char *p;
|
|
byte *s;
|
|
|
|
if (ssl == NULL || list == NULL || listSz == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
if (ssl->alpn_peer_requested == NULL
|
|
|| ssl->alpn_peer_requested_length == 0)
|
|
return BUFFER_ERROR;
|
|
|
|
/* ssl->alpn_peer_requested are the original bytes sent in a ClientHello,
|
|
* formatted as (len-byte chars+)+. To turn n protocols into a
|
|
* comma-separated C string, one needs (n-1) commas and a final 0 byte
|
|
* which has the same length as the original.
|
|
* The returned length is the strlen() of the C string, so -1 of that. */
|
|
*listSz = ssl->alpn_peer_requested_length-1;
|
|
*list = p = (char *)XMALLOC(ssl->alpn_peer_requested_length, ssl->heap,
|
|
DYNAMIC_TYPE_TLSX);
|
|
if (p == NULL)
|
|
return MEMORY_ERROR;
|
|
|
|
for (i = 0, s = ssl->alpn_peer_requested;
|
|
i < ssl->alpn_peer_requested_length;
|
|
p += len, i += len)
|
|
{
|
|
if (i)
|
|
*p++ = ',';
|
|
len = s[i++];
|
|
/* guard against bad length bytes. */
|
|
if (i + len > ssl->alpn_peer_requested_length) {
|
|
XFREE(*list, ssl->heap, DYNAMIC_TYPE_TLSX);
|
|
*list = NULL;
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
XMEMCPY(p, s + i, len);
|
|
}
|
|
*p = 0;
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
|
|
/* used to free memory allocated by wolfSSL_ALPN_GetPeerProtocol */
|
|
int wolfSSL_ALPN_FreePeerProtocol(WOLFSSL* ssl, char **list)
|
|
{
|
|
if (ssl == NULL) {
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
XFREE(*list, ssl->heap, DYNAMIC_TYPE_TLSX);
|
|
*list = NULL;
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
#endif /* HAVE_ALPN */
|
|
|
|
/* Secure Renegotiation */
|
|
#ifdef HAVE_SERVER_RENEGOTIATION_INFO
|
|
|
|
/* user is forcing ability to use secure renegotiation, we discourage it */
|
|
int wolfSSL_UseSecureRenegotiation(WOLFSSL* ssl)
|
|
{
|
|
int ret = BAD_FUNC_ARG;
|
|
#if defined(NO_TLS)
|
|
(void)ssl;
|
|
#else
|
|
if (ssl)
|
|
ret = TLSX_UseSecureRenegotiation(&ssl->extensions, ssl->heap);
|
|
|
|
if (ret == WOLFSSL_SUCCESS) {
|
|
TLSX* extension = TLSX_Find(ssl->extensions, TLSX_RENEGOTIATION_INFO);
|
|
|
|
if (extension)
|
|
ssl->secure_renegotiation = (SecureRenegotiation*)extension->data;
|
|
}
|
|
#endif /* !NO_TLS */
|
|
return ret;
|
|
}
|
|
|
|
int wolfSSL_CTX_UseSecureRenegotiation(WOLFSSL_CTX* ctx)
|
|
{
|
|
if (ctx == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
ctx->useSecureReneg = 1;
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
#ifdef HAVE_SECURE_RENEGOTIATION
|
|
/* do a secure renegotiation handshake, user forced, we discourage */
|
|
static int _Rehandshake(WOLFSSL* ssl)
|
|
{
|
|
int ret;
|
|
|
|
if (ssl == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
if (IsAtLeastTLSv1_3(ssl->version)) {
|
|
WOLFSSL_MSG("Secure Renegotiation not supported in TLS 1.3");
|
|
return SECURE_RENEGOTIATION_E;
|
|
}
|
|
|
|
if (ssl->secure_renegotiation == NULL) {
|
|
WOLFSSL_MSG("Secure Renegotiation not forced on by user");
|
|
return SECURE_RENEGOTIATION_E;
|
|
}
|
|
|
|
if (ssl->secure_renegotiation->enabled == 0) {
|
|
WOLFSSL_MSG("Secure Renegotiation not enabled at extension level");
|
|
return SECURE_RENEGOTIATION_E;
|
|
}
|
|
|
|
#ifdef WOLFSSL_DTLS
|
|
if (ssl->options.dtls && ssl->keys.dtls_epoch == 0xFFFF) {
|
|
WOLFSSL_MSG("Secure Renegotiation not allowed. Epoch would wrap");
|
|
return SECURE_RENEGOTIATION_E;
|
|
}
|
|
#endif
|
|
|
|
/* If the client started the renegotiation, the server will already
|
|
* have processed the client's hello. */
|
|
if (ssl->options.side != WOLFSSL_SERVER_END ||
|
|
ssl->options.acceptState != ACCEPT_FIRST_REPLY_DONE) {
|
|
|
|
if (ssl->options.handShakeState != HANDSHAKE_DONE) {
|
|
if (!ssl->options.handShakeDone) {
|
|
WOLFSSL_MSG("Can't renegotiate until initial "
|
|
"handshake complete");
|
|
return SECURE_RENEGOTIATION_E;
|
|
}
|
|
else {
|
|
WOLFSSL_MSG("Renegotiation already started. "
|
|
"Moving it forward.");
|
|
ret = wolfSSL_negotiate(ssl);
|
|
if (ret == WOLFSSL_SUCCESS)
|
|
ssl->secure_rene_count++;
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/* reset handshake states */
|
|
ssl->options.sendVerify = 0;
|
|
ssl->options.serverState = NULL_STATE;
|
|
ssl->options.clientState = NULL_STATE;
|
|
ssl->options.connectState = CONNECT_BEGIN;
|
|
ssl->options.acceptState = ACCEPT_BEGIN_RENEG;
|
|
ssl->options.handShakeState = NULL_STATE;
|
|
ssl->options.processReply = 0; /* TODO, move states in internal.h */
|
|
|
|
XMEMSET(&ssl->msgsReceived, 0, sizeof(ssl->msgsReceived));
|
|
|
|
ssl->secure_renegotiation->cache_status = SCR_CACHE_NEEDED;
|
|
|
|
#if !defined(NO_WOLFSSL_SERVER)
|
|
if (ssl->options.side == WOLFSSL_SERVER_END) {
|
|
ret = SendHelloRequest(ssl);
|
|
if (ret != 0) {
|
|
ssl->error = ret;
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
}
|
|
#endif /* !NO_WOLFSSL_SERVER */
|
|
|
|
ret = InitHandshakeHashes(ssl);
|
|
if (ret != 0) {
|
|
ssl->error = ret;
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
}
|
|
ret = wolfSSL_negotiate(ssl);
|
|
if (ret == WOLFSSL_SUCCESS)
|
|
ssl->secure_rene_count++;
|
|
return ret;
|
|
}
|
|
|
|
|
|
/* do a secure renegotiation handshake, user forced, we discourage */
|
|
int wolfSSL_Rehandshake(WOLFSSL* ssl)
|
|
{
|
|
int ret;
|
|
WOLFSSL_ENTER("wolfSSL_Rehandshake");
|
|
|
|
if (ssl == NULL)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
#ifdef HAVE_SESSION_TICKET
|
|
ret = WOLFSSL_SUCCESS;
|
|
#endif
|
|
|
|
if (ssl->options.side == WOLFSSL_SERVER_END) {
|
|
/* Reset option to send certificate verify. */
|
|
ssl->options.sendVerify = 0;
|
|
/* Reset resuming flag to do full secure handshake. */
|
|
ssl->options.resuming = 0;
|
|
}
|
|
else {
|
|
/* Reset resuming flag to do full secure handshake. */
|
|
ssl->options.resuming = 0;
|
|
#if defined(HAVE_SESSION_TICKET) && !defined(NO_WOLFSSL_CLIENT)
|
|
/* Clearing the ticket. */
|
|
ret = wolfSSL_UseSessionTicket(ssl);
|
|
#endif
|
|
}
|
|
/* CLIENT/SERVER: Reset peer authentication for full secure handshake. */
|
|
ssl->options.peerAuthGood = 0;
|
|
|
|
#ifdef HAVE_SESSION_TICKET
|
|
if (ret == WOLFSSL_SUCCESS)
|
|
#endif
|
|
ret = _Rehandshake(ssl);
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
#ifndef NO_WOLFSSL_CLIENT
|
|
|
|
/* do a secure resumption handshake, user forced, we discourage */
|
|
int wolfSSL_SecureResume(WOLFSSL* ssl)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_SecureResume");
|
|
|
|
if (ssl == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
if (ssl->options.side == WOLFSSL_SERVER_END) {
|
|
ssl->error = SIDE_ERROR;
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
|
|
return _Rehandshake(ssl);
|
|
}
|
|
|
|
#endif /* NO_WOLFSSL_CLIENT */
|
|
|
|
#endif /* HAVE_SECURE_RENEGOTIATION */
|
|
|
|
long wolfSSL_SSL_get_secure_renegotiation_support(WOLFSSL* ssl)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_SSL_get_secure_renegotiation_support");
|
|
|
|
if (!ssl || !ssl->secure_renegotiation)
|
|
return WOLFSSL_FAILURE;
|
|
return ssl->secure_renegotiation->enabled;
|
|
}
|
|
|
|
#endif /* HAVE_SECURE_RENEGOTIATION_INFO */
|
|
|
|
#if defined(HAVE_SESSION_TICKET)
|
|
/* Session Ticket */
|
|
|
|
#if !defined(NO_WOLFSSL_SERVER)
|
|
int wolfSSL_CTX_NoTicketTLSv12(WOLFSSL_CTX* ctx)
|
|
{
|
|
if (ctx == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
ctx->noTicketTls12 = 1;
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
int wolfSSL_NoTicketTLSv12(WOLFSSL* ssl)
|
|
{
|
|
if (ssl == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
ssl->options.noTicketTls12 = 1;
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
/* WOLFSSL_SUCCESS on ok */
|
|
int wolfSSL_CTX_set_TicketEncCb(WOLFSSL_CTX* ctx, SessionTicketEncCb cb)
|
|
{
|
|
if (ctx == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
ctx->ticketEncCb = cb;
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
/* set hint interval, WOLFSSL_SUCCESS on ok */
|
|
int wolfSSL_CTX_set_TicketHint(WOLFSSL_CTX* ctx, int hint)
|
|
{
|
|
if (ctx == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
ctx->ticketHint = hint;
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
/* set user context, WOLFSSL_SUCCESS on ok */
|
|
int wolfSSL_CTX_set_TicketEncCtx(WOLFSSL_CTX* ctx, void* userCtx)
|
|
{
|
|
if (ctx == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
ctx->ticketEncCtx = userCtx;
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
/* get user context - returns userCtx on success, NULL on failure */
|
|
void* wolfSSL_CTX_get_TicketEncCtx(WOLFSSL_CTX* ctx)
|
|
{
|
|
if (ctx == NULL)
|
|
return NULL;
|
|
|
|
return ctx->ticketEncCtx;
|
|
}
|
|
|
|
#ifdef WOLFSSL_TLS13
|
|
/* set the maximum number of tickets to send
|
|
* return WOLFSSL_SUCCESS on success and WOLFSSL_FAILURE on fail
|
|
*/
|
|
int wolfSSL_CTX_set_num_tickets(WOLFSSL_CTX* ctx, size_t mxTickets)
|
|
{
|
|
if (ctx == NULL)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
ctx->maxTicketTls13 = (unsigned int)mxTickets;
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
/* get the maximum number of tickets to send
|
|
* return number of tickets set to be sent
|
|
*/
|
|
size_t wolfSSL_CTX_get_num_tickets(WOLFSSL_CTX* ctx)
|
|
{
|
|
if (ctx == NULL)
|
|
return 0;
|
|
|
|
return (size_t)ctx->maxTicketTls13;
|
|
}
|
|
#endif /* WOLFSSL_TLS13 */
|
|
#endif /* !NO_WOLFSSL_SERVER */
|
|
|
|
#if !defined(NO_WOLFSSL_CLIENT)
|
|
int wolfSSL_UseSessionTicket(WOLFSSL* ssl)
|
|
{
|
|
if (ssl == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
return TLSX_UseSessionTicket(&ssl->extensions, NULL, ssl->heap);
|
|
}
|
|
|
|
int wolfSSL_CTX_UseSessionTicket(WOLFSSL_CTX* ctx)
|
|
{
|
|
if (ctx == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
return TLSX_UseSessionTicket(&ctx->extensions, NULL, ctx->heap);
|
|
}
|
|
|
|
int wolfSSL_get_SessionTicket(WOLFSSL* ssl, byte* buf, word32* bufSz)
|
|
{
|
|
if (ssl == NULL || buf == NULL || bufSz == NULL || *bufSz == 0)
|
|
return BAD_FUNC_ARG;
|
|
|
|
if (ssl->session->ticketLen <= *bufSz) {
|
|
XMEMCPY(buf, ssl->session->ticket, ssl->session->ticketLen);
|
|
*bufSz = ssl->session->ticketLen;
|
|
}
|
|
else
|
|
*bufSz = 0;
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
int wolfSSL_set_SessionTicket(WOLFSSL* ssl, const byte* buf,
|
|
word32 bufSz)
|
|
{
|
|
if (ssl == NULL || (buf == NULL && bufSz > 0))
|
|
return BAD_FUNC_ARG;
|
|
|
|
if (bufSz > 0) {
|
|
/* Ticket will fit into static ticket */
|
|
if (bufSz <= SESSION_TICKET_LEN) {
|
|
if (ssl->session->ticketLenAlloc > 0) {
|
|
XFREE(ssl->session->ticket, ssl->session->heap,
|
|
DYNAMIC_TYPE_SESSION_TICK);
|
|
ssl->session->ticketLenAlloc = 0;
|
|
ssl->session->ticket = ssl->session->staticTicket;
|
|
}
|
|
}
|
|
else { /* Ticket requires dynamic ticket storage */
|
|
if (ssl->session->ticketLen < bufSz) { /* is dyn buffer big enough */
|
|
if (ssl->session->ticketLenAlloc > 0) {
|
|
XFREE(ssl->session->ticket, ssl->session->heap,
|
|
DYNAMIC_TYPE_SESSION_TICK);
|
|
}
|
|
ssl->session->ticket = (byte*)XMALLOC(bufSz, ssl->session->heap,
|
|
DYNAMIC_TYPE_SESSION_TICK);
|
|
if(ssl->session->ticket == NULL) {
|
|
ssl->session->ticket = ssl->session->staticTicket;
|
|
ssl->session->ticketLenAlloc = 0;
|
|
return MEMORY_ERROR;
|
|
}
|
|
ssl->session->ticketLenAlloc = (word16)bufSz;
|
|
}
|
|
}
|
|
XMEMCPY(ssl->session->ticket, buf, bufSz);
|
|
}
|
|
ssl->session->ticketLen = (word16)bufSz;
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
|
|
int wolfSSL_set_SessionTicket_cb(WOLFSSL* ssl,
|
|
CallbackSessionTicket cb, void* ctx)
|
|
{
|
|
if (ssl == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
ssl->session_ticket_cb = cb;
|
|
ssl->session_ticket_ctx = ctx;
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
#endif /* !NO_WOLFSSL_CLIENT */
|
|
|
|
#endif /* HAVE_SESSION_TICKET */
|
|
|
|
|
|
#ifdef HAVE_EXTENDED_MASTER
|
|
#ifndef NO_WOLFSSL_CLIENT
|
|
|
|
int wolfSSL_CTX_DisableExtendedMasterSecret(WOLFSSL_CTX* ctx)
|
|
{
|
|
if (ctx == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
ctx->haveEMS = 0;
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
|
|
int wolfSSL_DisableExtendedMasterSecret(WOLFSSL* ssl)
|
|
{
|
|
if (ssl == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
ssl->options.haveEMS = 0;
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
#endif
|
|
#endif
|
|
|
|
|
|
#ifndef WOLFSSL_LEANPSK
|
|
|
|
int wolfSSL_send(WOLFSSL* ssl, const void* data, int sz, int flags)
|
|
{
|
|
int ret;
|
|
int oldFlags;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_send");
|
|
|
|
if (ssl == NULL || data == NULL || sz < 0)
|
|
return BAD_FUNC_ARG;
|
|
|
|
oldFlags = ssl->wflags;
|
|
|
|
ssl->wflags = flags;
|
|
ret = wolfSSL_write(ssl, data, sz);
|
|
ssl->wflags = oldFlags;
|
|
|
|
WOLFSSL_LEAVE("wolfSSL_send", ret);
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
int wolfSSL_recv(WOLFSSL* ssl, void* data, int sz, int flags)
|
|
{
|
|
int ret;
|
|
int oldFlags;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_recv");
|
|
|
|
if (ssl == NULL || data == NULL || sz < 0)
|
|
return BAD_FUNC_ARG;
|
|
|
|
oldFlags = ssl->rflags;
|
|
|
|
ssl->rflags = flags;
|
|
ret = wolfSSL_read(ssl, data, sz);
|
|
ssl->rflags = oldFlags;
|
|
|
|
WOLFSSL_LEAVE("wolfSSL_recv", ret);
|
|
|
|
return ret;
|
|
}
|
|
#endif
|
|
|
|
|
|
/* WOLFSSL_SUCCESS on ok */
|
|
WOLFSSL_ABI
|
|
int wolfSSL_shutdown(WOLFSSL* ssl)
|
|
{
|
|
int ret = WOLFSSL_FATAL_ERROR;
|
|
WOLFSSL_ENTER("wolfSSL_shutdown");
|
|
|
|
if (ssl == NULL)
|
|
return WOLFSSL_FATAL_ERROR;
|
|
|
|
if (ssl->options.quietShutdown) {
|
|
WOLFSSL_MSG("quiet shutdown, no close notify sent");
|
|
ret = WOLFSSL_SUCCESS;
|
|
}
|
|
else {
|
|
/* try to send close notify, not an error if can't */
|
|
if (!ssl->options.isClosed && !ssl->options.connReset &&
|
|
!ssl->options.sentNotify) {
|
|
ssl->error = SendAlert(ssl, alert_warning, close_notify);
|
|
if (ssl->error < 0) {
|
|
WOLFSSL_ERROR(ssl->error);
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
ssl->options.sentNotify = 1; /* don't send close_notify twice */
|
|
if (ssl->options.closeNotify) {
|
|
ret = WOLFSSL_SUCCESS;
|
|
ssl->options.shutdownDone = 1;
|
|
}
|
|
else {
|
|
ret = WOLFSSL_SHUTDOWN_NOT_DONE;
|
|
WOLFSSL_LEAVE("wolfSSL_shutdown", ret);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
#ifdef WOLFSSL_SHUTDOWNONCE
|
|
if (ssl->options.isClosed || ssl->options.connReset) {
|
|
/* Shutdown has already occurred.
|
|
* Caller is free to ignore this error. */
|
|
return SSL_SHUTDOWN_ALREADY_DONE_E;
|
|
}
|
|
#endif
|
|
|
|
/* call wolfSSL_shutdown again for bidirectional shutdown */
|
|
if (ssl->options.sentNotify && !ssl->options.closeNotify) {
|
|
ret = ProcessReply(ssl);
|
|
if ((ret == ZERO_RETURN) || (ret == SOCKET_ERROR_E)) {
|
|
/* simulate OpenSSL behavior */
|
|
ssl->options.shutdownDone = 1;
|
|
/* Clear error */
|
|
ssl->error = WOLFSSL_ERROR_NONE;
|
|
ret = WOLFSSL_SUCCESS;
|
|
} else if (ret == MEMORY_E) {
|
|
ret = WOLFSSL_FATAL_ERROR;
|
|
} else if (ssl->error == WOLFSSL_ERROR_NONE) {
|
|
ret = WOLFSSL_SHUTDOWN_NOT_DONE;
|
|
} else {
|
|
WOLFSSL_ERROR(ssl->error);
|
|
ret = WOLFSSL_FATAL_ERROR;
|
|
}
|
|
}
|
|
}
|
|
|
|
#if defined(OPENSSL_EXTRA) || defined(WOLFSSL_WPAS_SMALL)
|
|
/* reset WOLFSSL structure state for possible reuse */
|
|
if (ret == WOLFSSL_SUCCESS) {
|
|
if (wolfSSL_clear(ssl) != WOLFSSL_SUCCESS) {
|
|
WOLFSSL_MSG("could not clear WOLFSSL");
|
|
ret = WOLFSSL_FATAL_ERROR;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
WOLFSSL_LEAVE("wolfSSL_shutdown", ret);
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
/* get current error state value */
|
|
int wolfSSL_state(WOLFSSL* ssl)
|
|
{
|
|
if (ssl == NULL) {
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
return ssl->error;
|
|
}
|
|
|
|
|
|
WOLFSSL_ABI
|
|
int wolfSSL_get_error(WOLFSSL* ssl, int ret)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_get_error");
|
|
|
|
if (ret > 0)
|
|
return WOLFSSL_ERROR_NONE;
|
|
if (ssl == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
WOLFSSL_LEAVE("wolfSSL_get_error", ssl->error);
|
|
|
|
/* make sure converted types are handled in SetErrorString() too */
|
|
if (ssl->error == WANT_READ)
|
|
return WOLFSSL_ERROR_WANT_READ; /* convert to OpenSSL type */
|
|
else if (ssl->error == WANT_WRITE)
|
|
return WOLFSSL_ERROR_WANT_WRITE; /* convert to OpenSSL type */
|
|
else if (ssl->error == ZERO_RETURN || ssl->options.shutdownDone)
|
|
return WOLFSSL_ERROR_ZERO_RETURN; /* convert to OpenSSL type */
|
|
#ifdef OPENSSL_EXTRA
|
|
else if (ssl->error == SOCKET_PEER_CLOSED_E)
|
|
return WOLFSSL_ERROR_SYSCALL; /* convert to OpenSSL type */
|
|
#endif
|
|
#if defined(WOLFSSL_HAPROXY)
|
|
return GetX509Error(ssl->error);
|
|
#else
|
|
return (ssl->error);
|
|
#endif
|
|
}
|
|
|
|
|
|
/* retrieve alert history, WOLFSSL_SUCCESS on ok */
|
|
int wolfSSL_get_alert_history(WOLFSSL* ssl, WOLFSSL_ALERT_HISTORY *h)
|
|
{
|
|
if (ssl && h) {
|
|
*h = ssl->alert_history;
|
|
}
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
#ifdef OPENSSL_EXTRA
|
|
/* returns SSL_WRITING, SSL_READING or SSL_NOTHING */
|
|
int wolfSSL_want(WOLFSSL* ssl)
|
|
{
|
|
int rw_state = SSL_NOTHING;
|
|
if (ssl) {
|
|
if (ssl->error == WANT_READ)
|
|
rw_state = SSL_READING;
|
|
else if (ssl->error == WANT_WRITE)
|
|
rw_state = SSL_WRITING;
|
|
}
|
|
return rw_state;
|
|
}
|
|
#endif
|
|
|
|
/* return TRUE if current error is want read */
|
|
int wolfSSL_want_read(WOLFSSL* ssl)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_want_read");
|
|
if (ssl->error == WANT_READ)
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
/* return TRUE if current error is want write */
|
|
int wolfSSL_want_write(WOLFSSL* ssl)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_want_write");
|
|
if (ssl->error == WANT_WRITE)
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
char* wolfSSL_ERR_error_string(unsigned long errNumber, char* data)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_ERR_error_string");
|
|
if (data) {
|
|
SetErrorString((int)errNumber, data);
|
|
return data;
|
|
}
|
|
else {
|
|
static char tmp[WOLFSSL_MAX_ERROR_SZ] = {0};
|
|
SetErrorString((int)errNumber, tmp);
|
|
return tmp;
|
|
}
|
|
}
|
|
|
|
|
|
void wolfSSL_ERR_error_string_n(unsigned long e, char* buf, unsigned long len)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_ERR_error_string_n");
|
|
if (len >= WOLFSSL_MAX_ERROR_SZ)
|
|
wolfSSL_ERR_error_string(e, buf);
|
|
else {
|
|
WOLFSSL_MSG("Error buffer too short, truncating");
|
|
if (len) {
|
|
char tmp[WOLFSSL_MAX_ERROR_SZ];
|
|
wolfSSL_ERR_error_string(e, tmp);
|
|
XMEMCPY(buf, tmp, len-1);
|
|
buf[len-1] = '\0';
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/* don't free temporary arrays at end of handshake */
|
|
void wolfSSL_KeepArrays(WOLFSSL* ssl)
|
|
{
|
|
if (ssl)
|
|
ssl->options.saveArrays = 1;
|
|
}
|
|
|
|
|
|
/* user doesn't need temporary arrays anymore, Free */
|
|
void wolfSSL_FreeArrays(WOLFSSL* ssl)
|
|
{
|
|
if (ssl && ssl->options.handShakeState == HANDSHAKE_DONE) {
|
|
ssl->options.saveArrays = 0;
|
|
FreeArrays(ssl, 1);
|
|
}
|
|
}
|
|
|
|
/* Set option to indicate that the resources are not to be freed after
|
|
* handshake.
|
|
*
|
|
* ssl The SSL/TLS object.
|
|
* returns BAD_FUNC_ARG when ssl is NULL and 0 on success.
|
|
*/
|
|
int wolfSSL_KeepHandshakeResources(WOLFSSL* ssl)
|
|
{
|
|
if (ssl == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
ssl->options.keepResources = 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* Free the handshake resources after handshake.
|
|
*
|
|
* ssl The SSL/TLS object.
|
|
* returns BAD_FUNC_ARG when ssl is NULL and 0 on success.
|
|
*/
|
|
int wolfSSL_FreeHandshakeResources(WOLFSSL* ssl)
|
|
{
|
|
if (ssl == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
FreeHandshakeResources(ssl);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* Use the client's order of preference when matching cipher suites.
|
|
*
|
|
* ssl The SSL/TLS context object.
|
|
* returns BAD_FUNC_ARG when ssl is NULL and 0 on success.
|
|
*/
|
|
int wolfSSL_CTX_UseClientSuites(WOLFSSL_CTX* ctx)
|
|
{
|
|
if (ctx == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
ctx->useClientOrder = 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* Use the client's order of preference when matching cipher suites.
|
|
*
|
|
* ssl The SSL/TLS object.
|
|
* returns BAD_FUNC_ARG when ssl is NULL and 0 on success.
|
|
*/
|
|
int wolfSSL_UseClientSuites(WOLFSSL* ssl)
|
|
{
|
|
if (ssl == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
ssl->options.useClientOrder = 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
#ifdef WOLFSSL_DTLS
|
|
const byte* wolfSSL_GetDtlsMacSecret(WOLFSSL* ssl, int verify, int epochOrder)
|
|
{
|
|
#ifndef WOLFSSL_AEAD_ONLY
|
|
Keys* keys = NULL;
|
|
|
|
(void)epochOrder;
|
|
|
|
if (ssl == NULL)
|
|
return NULL;
|
|
|
|
#ifdef HAVE_SECURE_RENEGOTIATION
|
|
switch (epochOrder) {
|
|
case PEER_ORDER:
|
|
if (IsDtlsMsgSCRKeys(ssl))
|
|
keys = &ssl->secure_renegotiation->tmp_keys;
|
|
else
|
|
keys = &ssl->keys;
|
|
break;
|
|
case PREV_ORDER:
|
|
keys = &ssl->keys;
|
|
break;
|
|
case CUR_ORDER:
|
|
if (DtlsUseSCRKeys(ssl))
|
|
keys = &ssl->secure_renegotiation->tmp_keys;
|
|
else
|
|
keys = &ssl->keys;
|
|
break;
|
|
default:
|
|
WOLFSSL_MSG("Unknown epoch order");
|
|
return NULL;
|
|
}
|
|
#else
|
|
keys = &ssl->keys;
|
|
#endif
|
|
|
|
if ( (ssl->options.side == WOLFSSL_CLIENT_END && !verify) ||
|
|
(ssl->options.side == WOLFSSL_SERVER_END && verify) )
|
|
return keys->client_write_MAC_secret;
|
|
else
|
|
return keys->server_write_MAC_secret;
|
|
#else
|
|
(void)ssl;
|
|
(void)verify;
|
|
(void)epochOrder;
|
|
|
|
return NULL;
|
|
#endif
|
|
}
|
|
#endif /* WOLFSSL_DTLS */
|
|
|
|
const byte* wolfSSL_GetMacSecret(WOLFSSL* ssl, int verify)
|
|
{
|
|
#ifndef WOLFSSL_AEAD_ONLY
|
|
if (ssl == NULL)
|
|
return NULL;
|
|
|
|
if ( (ssl->options.side == WOLFSSL_CLIENT_END && !verify) ||
|
|
(ssl->options.side == WOLFSSL_SERVER_END && verify) )
|
|
return ssl->keys.client_write_MAC_secret;
|
|
else
|
|
return ssl->keys.server_write_MAC_secret;
|
|
#else
|
|
(void)ssl;
|
|
(void)verify;
|
|
|
|
return NULL;
|
|
#endif
|
|
}
|
|
|
|
int wolfSSL_GetSide(WOLFSSL* ssl)
|
|
{
|
|
if (ssl)
|
|
return ssl->options.side;
|
|
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
#ifdef ATOMIC_USER
|
|
|
|
void wolfSSL_CTX_SetMacEncryptCb(WOLFSSL_CTX* ctx, CallbackMacEncrypt cb)
|
|
{
|
|
if (ctx)
|
|
ctx->MacEncryptCb = cb;
|
|
}
|
|
|
|
|
|
void wolfSSL_SetMacEncryptCtx(WOLFSSL* ssl, void *ctx)
|
|
{
|
|
if (ssl)
|
|
ssl->MacEncryptCtx = ctx;
|
|
}
|
|
|
|
|
|
void* wolfSSL_GetMacEncryptCtx(WOLFSSL* ssl)
|
|
{
|
|
if (ssl)
|
|
return ssl->MacEncryptCtx;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
void wolfSSL_CTX_SetDecryptVerifyCb(WOLFSSL_CTX* ctx, CallbackDecryptVerify cb)
|
|
{
|
|
if (ctx)
|
|
ctx->DecryptVerifyCb = cb;
|
|
}
|
|
|
|
|
|
void wolfSSL_SetDecryptVerifyCtx(WOLFSSL* ssl, void *ctx)
|
|
{
|
|
if (ssl)
|
|
ssl->DecryptVerifyCtx = ctx;
|
|
}
|
|
|
|
|
|
void* wolfSSL_GetDecryptVerifyCtx(WOLFSSL* ssl)
|
|
{
|
|
if (ssl)
|
|
return ssl->DecryptVerifyCtx;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
#if defined(HAVE_ENCRYPT_THEN_MAC) && !defined(WOLFSSL_AEAD_ONLY)
|
|
/**
|
|
* Set the callback, against the context, that encrypts then MACs.
|
|
*
|
|
* ctx SSL/TLS context.
|
|
* cb Callback function to use with Encrypt-Then-MAC.
|
|
*/
|
|
void wolfSSL_CTX_SetEncryptMacCb(WOLFSSL_CTX* ctx, CallbackEncryptMac cb)
|
|
{
|
|
if (ctx)
|
|
ctx->EncryptMacCb = cb;
|
|
}
|
|
|
|
/**
|
|
* Set the context to use with callback that encrypts then MACs.
|
|
*
|
|
* ssl SSL/TLS object.
|
|
* ctx Callback function's context.
|
|
*/
|
|
void wolfSSL_SetEncryptMacCtx(WOLFSSL* ssl, void *ctx)
|
|
{
|
|
if (ssl)
|
|
ssl->EncryptMacCtx = ctx;
|
|
}
|
|
|
|
/**
|
|
* Get the context being used with callback that encrypts then MACs.
|
|
*
|
|
* ssl SSL/TLS object.
|
|
* returns callback function's context or NULL if SSL/TLS object is NULL.
|
|
*/
|
|
void* wolfSSL_GetEncryptMacCtx(WOLFSSL* ssl)
|
|
{
|
|
if (ssl)
|
|
return ssl->EncryptMacCtx;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
/**
|
|
* Set the callback, against the context, that MAC verifies then decrypts.
|
|
*
|
|
* ctx SSL/TLS context.
|
|
* cb Callback function to use with Encrypt-Then-MAC.
|
|
*/
|
|
void wolfSSL_CTX_SetVerifyDecryptCb(WOLFSSL_CTX* ctx, CallbackVerifyDecrypt cb)
|
|
{
|
|
if (ctx)
|
|
ctx->VerifyDecryptCb = cb;
|
|
}
|
|
|
|
/**
|
|
* Set the context to use with callback that MAC verifies then decrypts.
|
|
*
|
|
* ssl SSL/TLS object.
|
|
* ctx Callback function's context.
|
|
*/
|
|
void wolfSSL_SetVerifyDecryptCtx(WOLFSSL* ssl, void *ctx)
|
|
{
|
|
if (ssl)
|
|
ssl->VerifyDecryptCtx = ctx;
|
|
}
|
|
|
|
/**
|
|
* Get the context being used with callback that MAC verifies then decrypts.
|
|
*
|
|
* ssl SSL/TLS object.
|
|
* returns callback function's context or NULL if SSL/TLS object is NULL.
|
|
*/
|
|
void* wolfSSL_GetVerifyDecryptCtx(WOLFSSL* ssl)
|
|
{
|
|
if (ssl)
|
|
return ssl->VerifyDecryptCtx;
|
|
|
|
return NULL;
|
|
}
|
|
#endif /* HAVE_ENCRYPT_THEN_MAC !WOLFSSL_AEAD_ONLY */
|
|
|
|
|
|
|
|
const byte* wolfSSL_GetClientWriteKey(WOLFSSL* ssl)
|
|
{
|
|
if (ssl)
|
|
return ssl->keys.client_write_key;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
const byte* wolfSSL_GetClientWriteIV(WOLFSSL* ssl)
|
|
{
|
|
if (ssl)
|
|
return ssl->keys.client_write_IV;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
const byte* wolfSSL_GetServerWriteKey(WOLFSSL* ssl)
|
|
{
|
|
if (ssl)
|
|
return ssl->keys.server_write_key;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
const byte* wolfSSL_GetServerWriteIV(WOLFSSL* ssl)
|
|
{
|
|
if (ssl)
|
|
return ssl->keys.server_write_IV;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
int wolfSSL_GetKeySize(WOLFSSL* ssl)
|
|
{
|
|
if (ssl)
|
|
return ssl->specs.key_size;
|
|
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
|
|
int wolfSSL_GetIVSize(WOLFSSL* ssl)
|
|
{
|
|
if (ssl)
|
|
return ssl->specs.iv_size;
|
|
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
|
|
int wolfSSL_GetBulkCipher(WOLFSSL* ssl)
|
|
{
|
|
if (ssl)
|
|
return ssl->specs.bulk_cipher_algorithm;
|
|
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
|
|
int wolfSSL_GetCipherType(WOLFSSL* ssl)
|
|
{
|
|
if (ssl == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
#ifndef WOLFSSL_AEAD_ONLY
|
|
if (ssl->specs.cipher_type == block)
|
|
return WOLFSSL_BLOCK_TYPE;
|
|
if (ssl->specs.cipher_type == stream)
|
|
return WOLFSSL_STREAM_TYPE;
|
|
#endif
|
|
if (ssl->specs.cipher_type == aead)
|
|
return WOLFSSL_AEAD_TYPE;
|
|
|
|
return -1;
|
|
}
|
|
|
|
|
|
int wolfSSL_GetCipherBlockSize(WOLFSSL* ssl)
|
|
{
|
|
if (ssl == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
return ssl->specs.block_size;
|
|
}
|
|
|
|
|
|
int wolfSSL_GetAeadMacSize(WOLFSSL* ssl)
|
|
{
|
|
if (ssl == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
return ssl->specs.aead_mac_size;
|
|
}
|
|
|
|
|
|
int wolfSSL_IsTLSv1_1(WOLFSSL* ssl)
|
|
{
|
|
if (ssl == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
if (ssl->options.tls1_1)
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
int wolfSSL_GetHmacSize(WOLFSSL* ssl)
|
|
{
|
|
/* AEAD ciphers don't have HMAC keys */
|
|
if (ssl)
|
|
return (ssl->specs.cipher_type != aead) ? ssl->specs.hash_size : 0;
|
|
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
#ifdef WORD64_AVAILABLE
|
|
int wolfSSL_GetPeerSequenceNumber(WOLFSSL* ssl, word64 *seq)
|
|
{
|
|
if ((ssl == NULL) || (seq == NULL))
|
|
return BAD_FUNC_ARG;
|
|
|
|
*seq = ((word64)ssl->keys.peer_sequence_number_hi << 32) |
|
|
ssl->keys.peer_sequence_number_lo;
|
|
return !(*seq);
|
|
}
|
|
|
|
int wolfSSL_GetSequenceNumber(WOLFSSL* ssl, word64 *seq)
|
|
{
|
|
if ((ssl == NULL) || (seq == NULL))
|
|
return BAD_FUNC_ARG;
|
|
|
|
*seq = ((word64)ssl->keys.sequence_number_hi << 32) |
|
|
ssl->keys.sequence_number_lo;
|
|
return !(*seq);
|
|
}
|
|
#endif
|
|
|
|
#endif /* ATOMIC_USER */
|
|
|
|
#ifndef NO_CERTS
|
|
WOLFSSL_CERT_MANAGER* wolfSSL_CTX_GetCertManager(WOLFSSL_CTX* ctx)
|
|
{
|
|
WOLFSSL_CERT_MANAGER* cm = NULL;
|
|
if (ctx)
|
|
cm = ctx->cm;
|
|
return cm;
|
|
}
|
|
#endif /* NO_CERTS */
|
|
|
|
#if !defined(NO_FILESYSTEM) && !defined(NO_STDIO_FILESYSTEM) \
|
|
&& defined(XFPRINTF)
|
|
|
|
void wolfSSL_ERR_print_errors_fp(XFILE fp, int err)
|
|
{
|
|
char data[WOLFSSL_MAX_ERROR_SZ + 1];
|
|
|
|
WOLFSSL_ENTER("wolfSSL_ERR_print_errors_fp");
|
|
SetErrorString(err, data);
|
|
if (XFPRINTF(fp, "%s", data) < 0)
|
|
WOLFSSL_MSG("fprintf failed in wolfSSL_ERR_print_errors_fp");
|
|
}
|
|
|
|
#if defined(OPENSSL_EXTRA) || defined(DEBUG_WOLFSSL_VERBOSE)
|
|
void wolfSSL_ERR_dump_errors_fp(XFILE fp)
|
|
{
|
|
wc_ERR_print_errors_fp(fp);
|
|
}
|
|
|
|
void wolfSSL_ERR_print_errors_cb (int (*cb)(const char *str, size_t len,
|
|
void *u), void *u)
|
|
{
|
|
wc_ERR_print_errors_cb(cb, u);
|
|
}
|
|
#endif
|
|
#endif /* !NO_FILESYSTEM && !NO_STDIO_FILESYSTEM && XFPRINTF */
|
|
|
|
/*
|
|
* TODO This ssl parameter needs to be changed to const once our ABI checker
|
|
* stops flagging qualifier additions as ABI breaking.
|
|
*/
|
|
WOLFSSL_ABI
|
|
int wolfSSL_pending(WOLFSSL* ssl)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_pending");
|
|
if (ssl == NULL)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
return ssl->buffers.clearOutputBuffer.length;
|
|
}
|
|
|
|
int wolfSSL_has_pending(const WOLFSSL* ssl)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_has_pending");
|
|
if (ssl == NULL)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
return ssl->buffers.clearOutputBuffer.length > 0;
|
|
}
|
|
|
|
#ifndef WOLFSSL_LEANPSK
|
|
/* turn on handshake group messages for context */
|
|
int wolfSSL_CTX_set_group_messages(WOLFSSL_CTX* ctx)
|
|
{
|
|
if (ctx == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
ctx->groupMessages = 1;
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
#endif
|
|
|
|
|
|
#ifndef NO_WOLFSSL_CLIENT
|
|
/* connect enough to get peer cert chain */
|
|
int wolfSSL_connect_cert(WOLFSSL* ssl)
|
|
{
|
|
int ret;
|
|
|
|
if (ssl == NULL)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
ssl->options.certOnly = 1;
|
|
ret = wolfSSL_connect(ssl);
|
|
ssl->options.certOnly = 0;
|
|
|
|
return ret;
|
|
}
|
|
#endif
|
|
|
|
|
|
#ifndef WOLFSSL_LEANPSK
|
|
/* turn on handshake group messages for ssl object */
|
|
int wolfSSL_set_group_messages(WOLFSSL* ssl)
|
|
{
|
|
if (ssl == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
ssl->options.groupMessages = 1;
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
|
|
/* make minVersion the internal equivalent SSL version */
|
|
static int SetMinVersionHelper(byte* minVersion, int version)
|
|
{
|
|
#ifdef NO_TLS
|
|
(void)minVersion;
|
|
#endif
|
|
|
|
switch (version) {
|
|
#if defined(WOLFSSL_ALLOW_SSLV3) && !defined(NO_OLD_TLS)
|
|
case WOLFSSL_SSLV3:
|
|
*minVersion = SSLv3_MINOR;
|
|
break;
|
|
#endif
|
|
|
|
#ifndef NO_TLS
|
|
#ifndef NO_OLD_TLS
|
|
#ifdef WOLFSSL_ALLOW_TLSV10
|
|
case WOLFSSL_TLSV1:
|
|
*minVersion = TLSv1_MINOR;
|
|
break;
|
|
#endif
|
|
|
|
case WOLFSSL_TLSV1_1:
|
|
*minVersion = TLSv1_1_MINOR;
|
|
break;
|
|
#endif
|
|
#ifndef WOLFSSL_NO_TLS12
|
|
case WOLFSSL_TLSV1_2:
|
|
*minVersion = TLSv1_2_MINOR;
|
|
break;
|
|
#endif
|
|
#endif
|
|
#ifdef WOLFSSL_TLS13
|
|
case WOLFSSL_TLSV1_3:
|
|
*minVersion = TLSv1_3_MINOR;
|
|
break;
|
|
#endif
|
|
|
|
#ifdef WOLFSSL_DTLS
|
|
case WOLFSSL_DTLSV1:
|
|
*minVersion = DTLS_MINOR;
|
|
break;
|
|
case WOLFSSL_DTLSV1_2:
|
|
*minVersion = DTLSv1_2_MINOR;
|
|
break;
|
|
#ifdef WOLFSSL_DTLS13
|
|
case WOLFSSL_DTLSV1_3:
|
|
*minVersion = DTLSv1_3_MINOR;
|
|
break;
|
|
#endif /* WOLFSSL_DTLS13 */
|
|
#endif /* WOLFSSL_DTLS */
|
|
|
|
default:
|
|
WOLFSSL_MSG("Bad function argument");
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
|
|
/* Set minimum downgrade version allowed, WOLFSSL_SUCCESS on ok */
|
|
WOLFSSL_ABI
|
|
int wolfSSL_CTX_SetMinVersion(WOLFSSL_CTX* ctx, int version)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_SetMinVersion");
|
|
|
|
if (ctx == NULL) {
|
|
WOLFSSL_MSG("Bad function argument");
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
return SetMinVersionHelper(&ctx->minDowngrade, version);
|
|
}
|
|
|
|
|
|
/* Set minimum downgrade version allowed, WOLFSSL_SUCCESS on ok */
|
|
int wolfSSL_SetMinVersion(WOLFSSL* ssl, int version)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_SetMinVersion");
|
|
|
|
if (ssl == NULL) {
|
|
WOLFSSL_MSG("Bad function argument");
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
return SetMinVersionHelper(&ssl->options.minDowngrade, version);
|
|
}
|
|
|
|
|
|
/* Function to get version as WOLFSSL_ enum value for wolfSSL_SetVersion */
|
|
int wolfSSL_GetVersion(const WOLFSSL* ssl)
|
|
{
|
|
if (ssl == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
if (ssl->version.major == SSLv3_MAJOR) {
|
|
switch (ssl->version.minor) {
|
|
case SSLv3_MINOR :
|
|
return WOLFSSL_SSLV3;
|
|
case TLSv1_MINOR :
|
|
return WOLFSSL_TLSV1;
|
|
case TLSv1_1_MINOR :
|
|
return WOLFSSL_TLSV1_1;
|
|
case TLSv1_2_MINOR :
|
|
return WOLFSSL_TLSV1_2;
|
|
case TLSv1_3_MINOR :
|
|
return WOLFSSL_TLSV1_3;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
return VERSION_ERROR;
|
|
}
|
|
|
|
int wolfSSL_SetVersion(WOLFSSL* ssl, int version)
|
|
{
|
|
word16 haveRSA = 1;
|
|
word16 havePSK = 0;
|
|
int keySz = 0;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_SetVersion");
|
|
|
|
if (ssl == NULL) {
|
|
WOLFSSL_MSG("Bad function argument");
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
switch (version) {
|
|
#if defined(WOLFSSL_ALLOW_SSLV3) && !defined(NO_OLD_TLS)
|
|
case WOLFSSL_SSLV3:
|
|
ssl->version = MakeSSLv3();
|
|
break;
|
|
#endif
|
|
|
|
#ifndef NO_TLS
|
|
#ifndef NO_OLD_TLS
|
|
#ifdef WOLFSSL_ALLOW_TLSV10
|
|
case WOLFSSL_TLSV1:
|
|
ssl->version = MakeTLSv1();
|
|
break;
|
|
#endif
|
|
|
|
case WOLFSSL_TLSV1_1:
|
|
ssl->version = MakeTLSv1_1();
|
|
break;
|
|
#endif
|
|
#ifndef WOLFSSL_NO_TLS12
|
|
case WOLFSSL_TLSV1_2:
|
|
ssl->version = MakeTLSv1_2();
|
|
break;
|
|
#endif
|
|
|
|
#ifdef WOLFSSL_TLS13
|
|
case WOLFSSL_TLSV1_3:
|
|
ssl->version = MakeTLSv1_3();
|
|
break;
|
|
#endif /* WOLFSSL_TLS13 */
|
|
#endif
|
|
|
|
default:
|
|
WOLFSSL_MSG("Bad function argument");
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
#ifdef NO_RSA
|
|
haveRSA = 0;
|
|
#endif
|
|
#ifndef NO_PSK
|
|
havePSK = ssl->options.havePSK;
|
|
#endif
|
|
#ifndef NO_CERTS
|
|
keySz = ssl->buffers.keySz;
|
|
#endif
|
|
|
|
if (AllocateSuites(ssl) != 0)
|
|
return WOLFSSL_FAILURE;
|
|
InitSuites(ssl->suites, ssl->version, keySz, haveRSA, havePSK,
|
|
ssl->options.haveDH, ssl->options.haveECDSAsig,
|
|
ssl->options.haveECC, TRUE, ssl->options.haveStaticECC,
|
|
ssl->options.haveFalconSig, ssl->options.haveDilithiumSig,
|
|
ssl->options.haveAnon, TRUE, ssl->options.side);
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
#endif /* !leanpsk */
|
|
|
|
#ifndef NO_CERTS
|
|
|
|
/* hash is the SHA digest of name, just use first 32 bits as hash */
|
|
static WC_INLINE word32 HashSigner(const byte* hash)
|
|
{
|
|
return MakeWordFromHash(hash) % CA_TABLE_SIZE;
|
|
}
|
|
|
|
|
|
/* does CA already exist on signer list */
|
|
int AlreadySigner(WOLFSSL_CERT_MANAGER* cm, byte* hash)
|
|
{
|
|
Signer* signers;
|
|
int ret = 0;
|
|
word32 row;
|
|
|
|
if (cm == NULL || hash == NULL) {
|
|
return ret;
|
|
}
|
|
|
|
row = HashSigner(hash);
|
|
|
|
if (wc_LockMutex(&cm->caLock) != 0) {
|
|
return ret;
|
|
}
|
|
signers = cm->caTable[row];
|
|
while (signers) {
|
|
byte* subjectHash;
|
|
|
|
#ifndef NO_SKID
|
|
subjectHash = signers->subjectKeyIdHash;
|
|
#else
|
|
subjectHash = signers->subjectNameHash;
|
|
#endif
|
|
|
|
if (XMEMCMP(hash, subjectHash, SIGNER_DIGEST_SIZE) == 0) {
|
|
ret = 1; /* success */
|
|
break;
|
|
}
|
|
signers = signers->next;
|
|
}
|
|
wc_UnLockMutex(&cm->caLock);
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
#ifdef WOLFSSL_TRUST_PEER_CERT
|
|
/* hash is the SHA digest of name, just use first 32 bits as hash */
|
|
static WC_INLINE word32 TrustedPeerHashSigner(const byte* hash)
|
|
{
|
|
return MakeWordFromHash(hash) % TP_TABLE_SIZE;
|
|
}
|
|
|
|
/* does trusted peer already exist on signer list */
|
|
int AlreadyTrustedPeer(WOLFSSL_CERT_MANAGER* cm, DecodedCert* cert)
|
|
{
|
|
TrustedPeerCert* tp;
|
|
int ret = 0;
|
|
word32 row = TrustedPeerHashSigner(cert->subjectHash);
|
|
|
|
if (wc_LockMutex(&cm->tpLock) != 0)
|
|
return ret;
|
|
tp = cm->tpTable[row];
|
|
while (tp) {
|
|
if (XMEMCMP(cert->subjectHash, tp->subjectNameHash,
|
|
SIGNER_DIGEST_SIZE) == 0)
|
|
ret = 1;
|
|
#ifndef NO_SKID
|
|
if (cert->extSubjKeyIdSet) {
|
|
/* Compare SKID as well if available */
|
|
if (ret == 1 && XMEMCMP(cert->extSubjKeyId, tp->subjectKeyIdHash,
|
|
SIGNER_DIGEST_SIZE) != 0)
|
|
ret = 0;
|
|
}
|
|
#endif
|
|
if (ret == 1)
|
|
break;
|
|
tp = tp->next;
|
|
}
|
|
wc_UnLockMutex(&cm->tpLock);
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
/* return Trusted Peer if found, otherwise NULL
|
|
type is what to match on
|
|
*/
|
|
TrustedPeerCert* GetTrustedPeer(void* vp, DecodedCert* cert)
|
|
{
|
|
WOLFSSL_CERT_MANAGER* cm = (WOLFSSL_CERT_MANAGER*)vp;
|
|
TrustedPeerCert* ret = NULL;
|
|
TrustedPeerCert* tp = NULL;
|
|
word32 row;
|
|
|
|
if (cm == NULL || cert == NULL)
|
|
return NULL;
|
|
|
|
row = TrustedPeerHashSigner(cert->subjectHash);
|
|
|
|
if (wc_LockMutex(&cm->tpLock) != 0)
|
|
return ret;
|
|
|
|
tp = cm->tpTable[row];
|
|
while (tp) {
|
|
if (XMEMCMP(cert->subjectHash, tp->subjectNameHash,
|
|
SIGNER_DIGEST_SIZE) == 0)
|
|
ret = tp;
|
|
#ifndef NO_SKID
|
|
if (cert->extSubjKeyIdSet) {
|
|
/* Compare SKID as well if available */
|
|
if (ret != NULL && XMEMCMP(cert->extSubjKeyId, tp->subjectKeyIdHash,
|
|
SIGNER_DIGEST_SIZE) != 0)
|
|
ret = NULL;
|
|
}
|
|
#endif
|
|
if (ret != NULL)
|
|
break;
|
|
tp = tp->next;
|
|
}
|
|
wc_UnLockMutex(&cm->tpLock);
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
int MatchTrustedPeer(TrustedPeerCert* tp, DecodedCert* cert)
|
|
{
|
|
if (tp == NULL || cert == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
/* subject key id or subject hash has been compared when searching
|
|
tpTable for the cert from function GetTrustedPeer */
|
|
|
|
/* compare signatures */
|
|
if (tp->sigLen == cert->sigLength) {
|
|
if (XMEMCMP(tp->sig, cert->signature, cert->sigLength)) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
}
|
|
else {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
#endif /* WOLFSSL_TRUST_PEER_CERT */
|
|
|
|
|
|
/* return CA if found, otherwise NULL */
|
|
Signer* GetCA(void* vp, byte* hash)
|
|
{
|
|
WOLFSSL_CERT_MANAGER* cm = (WOLFSSL_CERT_MANAGER*)vp;
|
|
Signer* ret = NULL;
|
|
Signer* signers;
|
|
word32 row = 0;
|
|
|
|
if (cm == NULL || hash == NULL)
|
|
return NULL;
|
|
|
|
row = HashSigner(hash);
|
|
|
|
if (wc_LockMutex(&cm->caLock) != 0)
|
|
return ret;
|
|
|
|
signers = cm->caTable[row];
|
|
while (signers) {
|
|
byte* subjectHash;
|
|
#ifndef NO_SKID
|
|
subjectHash = signers->subjectKeyIdHash;
|
|
#else
|
|
subjectHash = signers->subjectNameHash;
|
|
#endif
|
|
if (XMEMCMP(hash, subjectHash, SIGNER_DIGEST_SIZE) == 0) {
|
|
ret = signers;
|
|
break;
|
|
}
|
|
signers = signers->next;
|
|
}
|
|
wc_UnLockMutex(&cm->caLock);
|
|
|
|
return ret;
|
|
}
|
|
|
|
#ifdef WOLFSSL_AKID_NAME
|
|
Signer* GetCAByAKID(void* vp, const byte* issuer, word32 issuerSz,
|
|
const byte* serial, word32 serialSz)
|
|
{
|
|
WOLFSSL_CERT_MANAGER* cm = (WOLFSSL_CERT_MANAGER*)vp;
|
|
Signer* ret = NULL;
|
|
Signer* signers;
|
|
byte nameHash[SIGNER_DIGEST_SIZE];
|
|
byte serialHash[SIGNER_DIGEST_SIZE];
|
|
word32 row;
|
|
|
|
if (cm == NULL || issuer == NULL || issuerSz == 0 ||
|
|
serial == NULL || serialSz == 0)
|
|
return NULL;
|
|
|
|
if (CalcHashId(issuer, issuerSz, nameHash) != 0 ||
|
|
CalcHashId(serial, serialSz, serialHash) != 0)
|
|
return NULL;
|
|
|
|
if (wc_LockMutex(&cm->caLock) != 0)
|
|
return ret;
|
|
|
|
/* Unfortunately we need to look through the entire table */
|
|
for (row = 0; row < CA_TABLE_SIZE && ret == NULL; row++) {
|
|
for (signers = cm->caTable[row]; signers != NULL;
|
|
signers = signers->next) {
|
|
if (XMEMCMP(signers->subjectNameHash, nameHash, SIGNER_DIGEST_SIZE)
|
|
== 0 && XMEMCMP(signers->serialHash, serialHash,
|
|
SIGNER_DIGEST_SIZE) == 0) {
|
|
ret = signers;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
wc_UnLockMutex(&cm->caLock);
|
|
|
|
return ret;
|
|
}
|
|
#endif
|
|
|
|
#ifndef NO_SKID
|
|
/* return CA if found, otherwise NULL. Walk through hash table. */
|
|
Signer* GetCAByName(void* vp, byte* hash)
|
|
{
|
|
WOLFSSL_CERT_MANAGER* cm = (WOLFSSL_CERT_MANAGER*)vp;
|
|
Signer* ret = NULL;
|
|
Signer* signers;
|
|
word32 row;
|
|
|
|
if (cm == NULL)
|
|
return NULL;
|
|
|
|
if (wc_LockMutex(&cm->caLock) != 0)
|
|
return ret;
|
|
|
|
for (row = 0; row < CA_TABLE_SIZE && ret == NULL; row++) {
|
|
signers = cm->caTable[row];
|
|
while (signers && ret == NULL) {
|
|
if (XMEMCMP(hash, signers->subjectNameHash,
|
|
SIGNER_DIGEST_SIZE) == 0) {
|
|
ret = signers;
|
|
}
|
|
signers = signers->next;
|
|
}
|
|
}
|
|
wc_UnLockMutex(&cm->caLock);
|
|
|
|
return ret;
|
|
}
|
|
#endif
|
|
|
|
|
|
#ifdef WOLFSSL_TRUST_PEER_CERT
|
|
/* add a trusted peer cert to linked list */
|
|
int AddTrustedPeer(WOLFSSL_CERT_MANAGER* cm, DerBuffer** pDer, int verify)
|
|
{
|
|
int ret, row;
|
|
TrustedPeerCert* peerCert;
|
|
DecodedCert* cert;
|
|
DerBuffer* der = *pDer;
|
|
|
|
WOLFSSL_MSG("Adding a Trusted Peer Cert");
|
|
|
|
cert = (DecodedCert*)XMALLOC(sizeof(DecodedCert), cm->heap,
|
|
DYNAMIC_TYPE_DCERT);
|
|
if (cert == NULL) {
|
|
FreeDer(&der);
|
|
return MEMORY_E;
|
|
}
|
|
|
|
InitDecodedCert(cert, der->buffer, der->length, cm->heap);
|
|
if ((ret = ParseCert(cert, TRUSTED_PEER_TYPE, verify, cm)) != 0) {
|
|
FreeDecodedCert(cert);
|
|
XFREE(cert, NULL, DYNAMIC_TYPE_DCERT);
|
|
FreeDer(&der);
|
|
return ret;
|
|
}
|
|
WOLFSSL_MSG("\tParsed new trusted peer cert");
|
|
|
|
peerCert = (TrustedPeerCert*)XMALLOC(sizeof(TrustedPeerCert), cm->heap,
|
|
DYNAMIC_TYPE_CERT);
|
|
if (peerCert == NULL) {
|
|
FreeDecodedCert(cert);
|
|
XFREE(cert, cm->heap, DYNAMIC_TYPE_DCERT);
|
|
FreeDer(&der);
|
|
return MEMORY_E;
|
|
}
|
|
XMEMSET(peerCert, 0, sizeof(TrustedPeerCert));
|
|
|
|
#ifndef IGNORE_NAME_CONSTRAINTS
|
|
if (peerCert->permittedNames)
|
|
FreeNameSubtrees(peerCert->permittedNames, cm->heap);
|
|
if (peerCert->excludedNames)
|
|
FreeNameSubtrees(peerCert->excludedNames, cm->heap);
|
|
#endif
|
|
|
|
if (AlreadyTrustedPeer(cm, cert)) {
|
|
WOLFSSL_MSG("\tAlready have this CA, not adding again");
|
|
FreeTrustedPeer(peerCert, cm->heap);
|
|
(void)ret;
|
|
}
|
|
else {
|
|
/* add trusted peer signature */
|
|
peerCert->sigLen = cert->sigLength;
|
|
peerCert->sig = (byte *)XMALLOC(cert->sigLength, cm->heap,
|
|
DYNAMIC_TYPE_SIGNATURE);
|
|
if (peerCert->sig == NULL) {
|
|
FreeDecodedCert(cert);
|
|
XFREE(cert, cm->heap, DYNAMIC_TYPE_DCERT);
|
|
FreeTrustedPeer(peerCert, cm->heap);
|
|
FreeDer(&der);
|
|
return MEMORY_E;
|
|
}
|
|
XMEMCPY(peerCert->sig, cert->signature, cert->sigLength);
|
|
|
|
/* add trusted peer name */
|
|
peerCert->nameLen = cert->subjectCNLen;
|
|
peerCert->name = cert->subjectCN;
|
|
#ifndef IGNORE_NAME_CONSTRAINTS
|
|
peerCert->permittedNames = cert->permittedNames;
|
|
peerCert->excludedNames = cert->excludedNames;
|
|
#endif
|
|
|
|
/* add SKID when available and hash of name */
|
|
#ifndef NO_SKID
|
|
XMEMCPY(peerCert->subjectKeyIdHash, cert->extSubjKeyId,
|
|
SIGNER_DIGEST_SIZE);
|
|
#endif
|
|
XMEMCPY(peerCert->subjectNameHash, cert->subjectHash,
|
|
SIGNER_DIGEST_SIZE);
|
|
peerCert->next = NULL; /* If Key Usage not set, all uses valid. */
|
|
cert->subjectCN = 0;
|
|
#ifndef IGNORE_NAME_CONSTRAINTS
|
|
cert->permittedNames = NULL;
|
|
cert->excludedNames = NULL;
|
|
#endif
|
|
|
|
row = TrustedPeerHashSigner(peerCert->subjectNameHash);
|
|
|
|
if (wc_LockMutex(&cm->tpLock) == 0) {
|
|
peerCert->next = cm->tpTable[row];
|
|
cm->tpTable[row] = peerCert; /* takes ownership */
|
|
wc_UnLockMutex(&cm->tpLock);
|
|
}
|
|
else {
|
|
WOLFSSL_MSG("\tTrusted Peer Cert Mutex Lock failed");
|
|
FreeDecodedCert(cert);
|
|
XFREE(cert, cm->heap, DYNAMIC_TYPE_DCERT);
|
|
FreeTrustedPeer(peerCert, cm->heap);
|
|
FreeDer(&der);
|
|
return BAD_MUTEX_E;
|
|
}
|
|
}
|
|
|
|
WOLFSSL_MSG("\tFreeing parsed trusted peer cert");
|
|
FreeDecodedCert(cert);
|
|
XFREE(cert, cm->heap, DYNAMIC_TYPE_DCERT);
|
|
WOLFSSL_MSG("\tFreeing der trusted peer cert");
|
|
FreeDer(&der);
|
|
WOLFSSL_MSG("\t\tOK Freeing der trusted peer cert");
|
|
WOLFSSL_LEAVE("AddTrustedPeer", ret);
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
#endif /* WOLFSSL_TRUST_PEER_CERT */
|
|
|
|
|
|
/* owns der, internal now uses too */
|
|
/* type flag ids from user or from chain received during verify
|
|
don't allow chain ones to be added w/o isCA extension */
|
|
int AddCA(WOLFSSL_CERT_MANAGER* cm, DerBuffer** pDer, int type, int verify)
|
|
{
|
|
int ret;
|
|
Signer* signer = NULL;
|
|
word32 row;
|
|
byte* subjectHash;
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
DecodedCert* cert = NULL;
|
|
#else
|
|
DecodedCert cert[1];
|
|
#endif
|
|
DerBuffer* der = *pDer;
|
|
|
|
WOLFSSL_MSG("Adding a CA");
|
|
|
|
if (cm == NULL) {
|
|
FreeDer(pDer);
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
cert = (DecodedCert*)XMALLOC(sizeof(DecodedCert), NULL,
|
|
DYNAMIC_TYPE_DCERT);
|
|
if (cert == NULL) {
|
|
FreeDer(pDer);
|
|
return MEMORY_E;
|
|
}
|
|
#endif
|
|
|
|
InitDecodedCert(cert, der->buffer, der->length, cm->heap);
|
|
ret = ParseCert(cert, CA_TYPE, verify, cm);
|
|
WOLFSSL_MSG("\tParsed new CA");
|
|
|
|
#ifndef NO_SKID
|
|
subjectHash = cert->extSubjKeyId;
|
|
#else
|
|
subjectHash = cert->subjectHash;
|
|
#endif
|
|
|
|
/* check CA key size */
|
|
if (verify) {
|
|
switch (cert->keyOID) {
|
|
#ifndef NO_RSA
|
|
#ifdef WC_RSA_PSS
|
|
case RSAPSSk:
|
|
#endif
|
|
case RSAk:
|
|
if (cm->minRsaKeySz < 0 ||
|
|
cert->pubKeySize < (word16)cm->minRsaKeySz) {
|
|
ret = RSA_KEY_SIZE_E;
|
|
WOLFSSL_MSG("\tCA RSA key size error");
|
|
}
|
|
break;
|
|
#endif /* !NO_RSA */
|
|
#ifdef HAVE_ECC
|
|
case ECDSAk:
|
|
if (cm->minEccKeySz < 0 ||
|
|
cert->pubKeySize < (word16)cm->minEccKeySz) {
|
|
ret = ECC_KEY_SIZE_E;
|
|
WOLFSSL_MSG("\tCA ECC key size error");
|
|
}
|
|
break;
|
|
#endif /* HAVE_ECC */
|
|
#ifdef HAVE_ED25519
|
|
case ED25519k:
|
|
if (cm->minEccKeySz < 0 ||
|
|
ED25519_KEY_SIZE < (word16)cm->minEccKeySz) {
|
|
ret = ECC_KEY_SIZE_E;
|
|
WOLFSSL_MSG("\tCA ECC key size error");
|
|
}
|
|
break;
|
|
#endif /* HAVE_ED25519 */
|
|
#ifdef HAVE_ED448
|
|
case ED448k:
|
|
if (cm->minEccKeySz < 0 ||
|
|
ED448_KEY_SIZE < (word16)cm->minEccKeySz) {
|
|
ret = ECC_KEY_SIZE_E;
|
|
WOLFSSL_MSG("\tCA ECC key size error");
|
|
}
|
|
break;
|
|
#endif /* HAVE_ED448 */
|
|
#if defined(HAVE_PQC)
|
|
#if defined(HAVE_FALCON)
|
|
case FALCON_LEVEL1k:
|
|
if (cm->minFalconKeySz < 0 ||
|
|
FALCON_LEVEL1_KEY_SIZE < (word16)cm->minFalconKeySz) {
|
|
ret = FALCON_KEY_SIZE_E;
|
|
WOLFSSL_MSG("\tCA Falcon level 1 key size error");
|
|
}
|
|
break;
|
|
case FALCON_LEVEL5k:
|
|
if (cm->minFalconKeySz < 0 ||
|
|
FALCON_LEVEL5_KEY_SIZE < (word16)cm->minFalconKeySz) {
|
|
ret = FALCON_KEY_SIZE_E;
|
|
WOLFSSL_MSG("\tCA Falcon level 5 key size error");
|
|
}
|
|
break;
|
|
#endif /* HAVE_FALCON */
|
|
#if defined(HAVE_DILITHIUM)
|
|
case DILITHIUM_LEVEL2k:
|
|
if (cm->minDilithiumKeySz < 0 ||
|
|
DILITHIUM_LEVEL2_KEY_SIZE < (word16)cm->minDilithiumKeySz) {
|
|
ret = DILITHIUM_KEY_SIZE_E;
|
|
WOLFSSL_MSG("\tCA Dilithium level 2 key size error");
|
|
}
|
|
break;
|
|
case DILITHIUM_LEVEL3k:
|
|
if (cm->minDilithiumKeySz < 0 ||
|
|
DILITHIUM_LEVEL3_KEY_SIZE < (word16)cm->minDilithiumKeySz) {
|
|
ret = DILITHIUM_KEY_SIZE_E;
|
|
WOLFSSL_MSG("\tCA Dilithium level 3 key size error");
|
|
}
|
|
break;
|
|
case DILITHIUM_LEVEL5k:
|
|
if (cm->minDilithiumKeySz < 0 ||
|
|
DILITHIUM_LEVEL5_KEY_SIZE < (word16)cm->minDilithiumKeySz) {
|
|
ret = DILITHIUM_KEY_SIZE_E;
|
|
WOLFSSL_MSG("\tCA Dilithium level 5 key size error");
|
|
}
|
|
break;
|
|
#endif /* HAVE_DILITHIUM */
|
|
#endif /* HAVE_PQC */
|
|
|
|
default:
|
|
WOLFSSL_MSG("\tNo key size check done on CA");
|
|
break; /* no size check if key type is not in switch */
|
|
}
|
|
}
|
|
|
|
if (ret == 0 && cert->isCA == 0 && type != WOLFSSL_USER_CA) {
|
|
WOLFSSL_MSG("\tCan't add as CA if not actually one");
|
|
ret = NOT_CA_ERROR;
|
|
}
|
|
#ifndef ALLOW_INVALID_CERTSIGN
|
|
else if (ret == 0 && cert->isCA == 1 && type != WOLFSSL_USER_CA &&
|
|
!cert->selfSigned && (cert->extKeyUsage & KEYUSE_KEY_CERT_SIGN) == 0) {
|
|
/* Intermediate CA certs are required to have the keyCertSign
|
|
* extension set. User loaded root certs are not. */
|
|
WOLFSSL_MSG("\tDoesn't have key usage certificate signing");
|
|
ret = NOT_CA_ERROR;
|
|
}
|
|
#endif
|
|
else if (ret == 0 && AlreadySigner(cm, subjectHash)) {
|
|
WOLFSSL_MSG("\tAlready have this CA, not adding again");
|
|
(void)ret;
|
|
}
|
|
else if (ret == 0) {
|
|
/* take over signer parts */
|
|
signer = MakeSigner(cm->heap);
|
|
if (!signer)
|
|
ret = MEMORY_ERROR;
|
|
}
|
|
#if defined(WOLFSSL_AKID_NAME) || defined(HAVE_CRL)
|
|
if (ret == 0 && signer != NULL)
|
|
ret = CalcHashId(cert->serial, cert->serialSz, signer->serialHash);
|
|
#endif
|
|
if (ret == 0 && signer != NULL) {
|
|
#ifdef WOLFSSL_SIGNER_DER_CERT
|
|
ret = AllocDer(&signer->derCert, der->length, der->type, NULL);
|
|
}
|
|
if (ret == 0 && signer != NULL) {
|
|
XMEMCPY(signer->derCert->buffer, der->buffer, der->length);
|
|
#endif
|
|
signer->keyOID = cert->keyOID;
|
|
if (cert->pubKeyStored) {
|
|
signer->publicKey = cert->publicKey;
|
|
signer->pubKeySize = cert->pubKeySize;
|
|
}
|
|
if (cert->subjectCNStored) {
|
|
signer->nameLen = cert->subjectCNLen;
|
|
signer->name = cert->subjectCN;
|
|
}
|
|
signer->maxPathLen = cert->maxPathLen;
|
|
signer->selfSigned = cert->selfSigned;
|
|
#ifndef IGNORE_NAME_CONSTRAINTS
|
|
signer->permittedNames = cert->permittedNames;
|
|
signer->excludedNames = cert->excludedNames;
|
|
#endif
|
|
#ifndef NO_SKID
|
|
XMEMCPY(signer->subjectKeyIdHash, cert->extSubjKeyId,
|
|
SIGNER_DIGEST_SIZE);
|
|
#endif
|
|
XMEMCPY(signer->subjectNameHash, cert->subjectHash,
|
|
SIGNER_DIGEST_SIZE);
|
|
#if defined(HAVE_OCSP) || defined(HAVE_CRL)
|
|
XMEMCPY(signer->issuerNameHash, cert->issuerHash,
|
|
SIGNER_DIGEST_SIZE);
|
|
#endif
|
|
#ifdef HAVE_OCSP
|
|
XMEMCPY(signer->subjectKeyHash, cert->subjectKeyHash,
|
|
KEYID_SIZE);
|
|
#endif
|
|
signer->keyUsage = cert->extKeyUsageSet ? cert->extKeyUsage
|
|
: 0xFFFF;
|
|
signer->next = NULL; /* If Key Usage not set, all uses valid. */
|
|
cert->publicKey = 0; /* in case lock fails don't free here. */
|
|
cert->subjectCN = 0;
|
|
#ifndef IGNORE_NAME_CONSTRAINTS
|
|
cert->permittedNames = NULL;
|
|
cert->excludedNames = NULL;
|
|
#endif
|
|
|
|
#ifndef NO_SKID
|
|
row = HashSigner(signer->subjectKeyIdHash);
|
|
#else
|
|
row = HashSigner(signer->subjectNameHash);
|
|
#endif
|
|
|
|
if (wc_LockMutex(&cm->caLock) == 0) {
|
|
signer->next = cm->caTable[row];
|
|
cm->caTable[row] = signer; /* takes ownership */
|
|
wc_UnLockMutex(&cm->caLock);
|
|
if (cm->caCacheCallback)
|
|
cm->caCacheCallback(der->buffer, (int)der->length, type);
|
|
}
|
|
else {
|
|
WOLFSSL_MSG("\tCA Mutex Lock failed");
|
|
ret = BAD_MUTEX_E;
|
|
}
|
|
}
|
|
#if defined(WOLFSSL_RENESAS_TSIP_TLS) || defined(WOLFSSL_RENESAS_FSPSM_TLS)
|
|
/* Verify CA by TSIP so that generated tsip key is going to be able to */
|
|
/* be used for peer's cert verification */
|
|
/* TSIP is only able to handle USER CA, and only one CA. */
|
|
/* Therefore, it doesn't need to call TSIP again if there is already */
|
|
/* verified CA. */
|
|
if ( ret == 0 && signer != NULL ) {
|
|
signer->cm_idx = row;
|
|
if (type == WOLFSSL_USER_CA) {
|
|
if ((ret = wc_Renesas_cmn_RootCertVerify(cert->source, cert->maxIdx,
|
|
cert->sigCtx.CertAtt.pubkey_n_start,
|
|
cert->sigCtx.CertAtt.pubkey_n_len - 1,
|
|
cert->sigCtx.CertAtt.pubkey_e_start,
|
|
cert->sigCtx.CertAtt.pubkey_e_len - 1,
|
|
row/* cm index */))
|
|
< 0)
|
|
WOLFSSL_MSG("Renesas_RootCertVerify() failed");
|
|
else
|
|
WOLFSSL_MSG("Renesas_RootCertVerify() succeed or skipped");
|
|
}
|
|
}
|
|
#endif /* TSIP or SCE */
|
|
|
|
WOLFSSL_MSG("\tFreeing Parsed CA");
|
|
FreeDecodedCert(cert);
|
|
if (ret != 0 && signer != NULL)
|
|
FreeSigner(signer, cm->heap);
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
XFREE(cert, NULL, DYNAMIC_TYPE_DCERT);
|
|
#endif
|
|
WOLFSSL_MSG("\tFreeing der CA");
|
|
FreeDer(pDer);
|
|
WOLFSSL_MSG("\t\tOK Freeing der CA");
|
|
|
|
WOLFSSL_LEAVE("AddCA", ret);
|
|
|
|
return ret == 0 ? WOLFSSL_SUCCESS : ret;
|
|
}
|
|
|
|
#endif /* !NO_CERTS */
|
|
|
|
|
|
#ifndef NO_SESSION_CACHE
|
|
|
|
/* basic config gives a cache with 33 sessions, adequate for clients and
|
|
embedded servers
|
|
|
|
TITAN_SESSION_CACHE allows just over 2 million sessions, for servers
|
|
with titanic amounts of memory with long session ID timeouts and high
|
|
levels of traffic.
|
|
|
|
ENABLE_SESSION_CACHE_ROW_LOCK: Allows row level locking for increased
|
|
performance with large session caches
|
|
|
|
HUGE_SESSION_CACHE yields 65,791 sessions, for servers under heavy load,
|
|
allows over 13,000 new sessions per minute or over 200 new sessions per
|
|
second
|
|
|
|
BIG_SESSION_CACHE yields 20,027 sessions
|
|
|
|
MEDIUM_SESSION_CACHE allows 1055 sessions, adequate for servers that
|
|
aren't under heavy load, basically allows 200 new sessions per minute
|
|
|
|
SMALL_SESSION_CACHE only stores 6 sessions, good for embedded clients
|
|
or systems where the default of nearly 3kB is too much RAM, this define
|
|
uses less than 500 bytes RAM
|
|
|
|
default SESSION_CACHE stores 33 sessions (no XXX_SESSION_CACHE defined)
|
|
*/
|
|
#if defined(TITAN_SESSION_CACHE)
|
|
#define SESSIONS_PER_ROW 31
|
|
#define SESSION_ROWS 64937
|
|
#ifndef ENABLE_SESSION_CACHE_ROW_LOCK
|
|
#define ENABLE_SESSION_CACHE_ROW_LOCK
|
|
#endif
|
|
#elif defined(HUGE_SESSION_CACHE)
|
|
#define SESSIONS_PER_ROW 11
|
|
#define SESSION_ROWS 5981
|
|
#elif defined(BIG_SESSION_CACHE)
|
|
#define SESSIONS_PER_ROW 7
|
|
#define SESSION_ROWS 2861
|
|
#elif defined(MEDIUM_SESSION_CACHE)
|
|
#define SESSIONS_PER_ROW 5
|
|
#define SESSION_ROWS 211
|
|
#elif defined(SMALL_SESSION_CACHE)
|
|
#define SESSIONS_PER_ROW 2
|
|
#define SESSION_ROWS 3
|
|
#else
|
|
#define SESSIONS_PER_ROW 3
|
|
#define SESSION_ROWS 11
|
|
#endif
|
|
#define INVALID_SESSION_ROW (-1)
|
|
|
|
#ifdef NO_SESSION_CACHE_ROW_LOCK
|
|
#undef ENABLE_SESSION_CACHE_ROW_LOCK
|
|
#endif
|
|
|
|
typedef struct SessionRow {
|
|
int nextIdx; /* where to place next one */
|
|
int totalCount; /* sessions ever on this row */
|
|
#ifdef SESSION_CACHE_DYNAMIC_MEM
|
|
WOLFSSL_SESSION* Sessions[SESSIONS_PER_ROW];
|
|
void* heap;
|
|
#else
|
|
WOLFSSL_SESSION Sessions[SESSIONS_PER_ROW];
|
|
#endif
|
|
|
|
#ifdef ENABLE_SESSION_CACHE_ROW_LOCK
|
|
/* not included in import/export */
|
|
wolfSSL_RwLock row_lock;
|
|
int lock_valid;
|
|
#endif
|
|
} SessionRow;
|
|
#define SIZEOF_SESSION_ROW (sizeof(WOLFSSL_SESSION) + (sizeof(int) * 2))
|
|
|
|
static WOLFSSL_GLOBAL SessionRow SessionCache[SESSION_ROWS];
|
|
|
|
#if defined(WOLFSSL_SESSION_STATS) && defined(WOLFSSL_PEAK_SESSIONS)
|
|
static WOLFSSL_GLOBAL word32 PeakSessions;
|
|
#endif
|
|
|
|
#ifdef ENABLE_SESSION_CACHE_ROW_LOCK
|
|
#define SESSION_ROW_RD_LOCK(row) wc_LockRwLock_Rd(&(row)->row_lock)
|
|
#define SESSION_ROW_WR_LOCK(row) wc_LockRwLock_Wr(&(row)->row_lock)
|
|
#define SESSION_ROW_UNLOCK(row) wc_UnLockRwLock(&(row)->row_lock);
|
|
#else
|
|
static WOLFSSL_GLOBAL wolfSSL_RwLock session_lock; /* SessionCache lock */
|
|
static WOLFSSL_GLOBAL int session_lock_valid = 0;
|
|
#define SESSION_ROW_RD_LOCK(row) wc_LockRwLock_Rd(&session_lock)
|
|
#define SESSION_ROW_WR_LOCK(row) wc_LockRwLock_Wr(&session_lock)
|
|
#define SESSION_ROW_UNLOCK(row) wc_UnLockRwLock(&session_lock);
|
|
#endif
|
|
|
|
#if !defined(NO_SESSION_CACHE_REF) && defined(NO_CLIENT_CACHE)
|
|
#error ClientCache is required when not using NO_SESSION_CACHE_REF
|
|
#endif
|
|
|
|
#ifndef NO_CLIENT_CACHE
|
|
|
|
#ifndef CLIENT_SESSIONS_MULTIPLIER
|
|
#ifdef NO_SESSION_CACHE_REF
|
|
#define CLIENT_SESSIONS_MULTIPLIER 1
|
|
#else
|
|
/* ClientSession objects are lightweight (compared to
|
|
* WOLFSSL_SESSION) so to decrease chance that user will reuse
|
|
* the wrong session, increase the ClientCache size. This will
|
|
* make the entire ClientCache about the size of one
|
|
* WOLFSSL_SESSION object. */
|
|
#define CLIENT_SESSIONS_MULTIPLIER 8
|
|
#endif
|
|
#endif
|
|
#define CLIENT_SESSIONS_PER_ROW \
|
|
(SESSIONS_PER_ROW * CLIENT_SESSIONS_MULTIPLIER)
|
|
#define CLIENT_SESSION_ROWS (SESSION_ROWS * CLIENT_SESSIONS_MULTIPLIER)
|
|
|
|
#if CLIENT_SESSIONS_PER_ROW > 65535
|
|
#error CLIENT_SESSIONS_PER_ROW too big
|
|
#endif
|
|
#if CLIENT_SESSION_ROWS > 65535
|
|
#error CLIENT_SESSION_ROWS too big
|
|
#endif
|
|
|
|
struct ClientSession {
|
|
word16 serverRow; /* SessionCache Row id */
|
|
word16 serverIdx; /* SessionCache Idx (column) */
|
|
word32 sessionIDHash;
|
|
};
|
|
#ifndef WOLFSSL_CLIENT_SESSION_DEFINED
|
|
typedef struct ClientSession ClientSession;
|
|
#define WOLFSSL_CLIENT_SESSION_DEFINED
|
|
#endif
|
|
|
|
typedef struct ClientRow {
|
|
int nextIdx; /* where to place next one */
|
|
int totalCount; /* sessions ever on this row */
|
|
ClientSession Clients[CLIENT_SESSIONS_PER_ROW];
|
|
} ClientRow;
|
|
|
|
static WOLFSSL_GLOBAL ClientRow ClientCache[CLIENT_SESSION_ROWS];
|
|
/* Client Cache */
|
|
/* uses session mutex */
|
|
|
|
static WOLFSSL_GLOBAL wolfSSL_Mutex clisession_mutex; /* ClientCache mutex */
|
|
static WOLFSSL_GLOBAL int clisession_mutex_valid = 0;
|
|
#endif /* !NO_CLIENT_CACHE */
|
|
|
|
void EvictSessionFromCache(WOLFSSL_SESSION* session)
|
|
{
|
|
#ifdef HAVE_EX_DATA
|
|
int save_ownExData = session->ownExData;
|
|
session->ownExData = 1; /* Make sure ex_data access doesn't lead back
|
|
* into the cache. */
|
|
#endif
|
|
#if defined(HAVE_EXT_CACHE) || defined(HAVE_EX_DATA)
|
|
if (session->rem_sess_cb != NULL) {
|
|
session->rem_sess_cb(NULL, session);
|
|
session->rem_sess_cb = NULL;
|
|
}
|
|
#endif
|
|
ForceZero(session->masterSecret, SECRET_LEN);
|
|
XMEMSET(session->sessionID, 0, ID_LEN);
|
|
session->sessionIDSz = 0;
|
|
#ifdef HAVE_SESSION_TICKET
|
|
if (session->ticketLenAlloc > 0) {
|
|
XFREE(session->ticket, NULL, DYNAMIC_TYPE_SESSION_TICK);
|
|
session->ticket = session->staticTicket;
|
|
session->ticketLen = 0;
|
|
session->ticketLenAlloc = 0;
|
|
}
|
|
#endif
|
|
#ifdef HAVE_EX_DATA
|
|
session->ownExData = save_ownExData;
|
|
#endif
|
|
}
|
|
|
|
#endif /* !NO_SESSION_CACHE */
|
|
|
|
#if defined(OPENSSL_EXTRA) && !defined(WOLFSSL_NO_OPENSSL_RAND_CB)
|
|
static int wolfSSL_RAND_InitMutex(void);
|
|
#endif
|
|
|
|
#if defined(OPENSSL_EXTRA) && defined(HAVE_ATEXIT)
|
|
static void AtExitCleanup(void)
|
|
{
|
|
if (initRefCount > 0) {
|
|
initRefCount = 1;
|
|
(void)wolfSSL_Cleanup();
|
|
}
|
|
}
|
|
#endif
|
|
|
|
WOLFSSL_ABI
|
|
int wolfSSL_Init(void)
|
|
{
|
|
int ret = WOLFSSL_SUCCESS;
|
|
#if !defined(NO_SESSION_CACHE) && defined(ENABLE_SESSION_CACHE_ROW_LOCK)
|
|
int i;
|
|
#endif
|
|
|
|
WOLFSSL_ENTER("wolfSSL_Init");
|
|
|
|
#if FIPS_VERSION_GE(5,1)
|
|
ret = wolfCrypt_SetPrivateKeyReadEnable_fips(1, WC_KEYTYPE_ALL);
|
|
if (ret != 0)
|
|
return ret;
|
|
else
|
|
ret = WOLFSSL_SUCCESS;
|
|
#endif
|
|
|
|
if (initRefCount == 0) {
|
|
/* Initialize crypto for use with TLS connection */
|
|
if (wolfCrypt_Init() != 0) {
|
|
WOLFSSL_MSG("Bad wolfCrypt Init");
|
|
ret = WC_INIT_E;
|
|
}
|
|
|
|
#ifdef HAVE_GLOBAL_RNG
|
|
if (ret == WOLFSSL_SUCCESS) {
|
|
if (wc_InitMutex(&globalRNGMutex) != 0) {
|
|
WOLFSSL_MSG("Bad Init Mutex rng");
|
|
ret = BAD_MUTEX_E;
|
|
}
|
|
else {
|
|
globalRNGMutex_valid = 1;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#ifdef WC_RNG_SEED_CB
|
|
wc_SetSeed_Cb(wc_GenerateSeed);
|
|
#endif
|
|
|
|
#ifdef OPENSSL_EXTRA
|
|
#ifndef WOLFSSL_NO_OPENSSL_RAND_CB
|
|
if ((ret == WOLFSSL_SUCCESS) && (wolfSSL_RAND_InitMutex() != 0)) {
|
|
ret = BAD_MUTEX_E;
|
|
}
|
|
#endif
|
|
if ((ret == WOLFSSL_SUCCESS) &&
|
|
(wolfSSL_RAND_seed(NULL, 0) != WOLFSSL_SUCCESS)) {
|
|
WOLFSSL_MSG("wolfSSL_RAND_seed failed");
|
|
ret = WC_INIT_E;
|
|
}
|
|
#endif
|
|
|
|
#ifndef NO_SESSION_CACHE
|
|
#ifdef ENABLE_SESSION_CACHE_ROW_LOCK
|
|
for (i = 0; i < SESSION_ROWS; ++i) {
|
|
SessionCache[i].lock_valid = 0;
|
|
}
|
|
for (i = 0; (ret == WOLFSSL_SUCCESS) && (i < SESSION_ROWS); ++i) {
|
|
if (wc_InitRwLock(&SessionCache[i].row_lock) != 0) {
|
|
WOLFSSL_MSG("Bad Init Mutex session");
|
|
ret = BAD_MUTEX_E;
|
|
}
|
|
else {
|
|
SessionCache[i].lock_valid = 1;
|
|
}
|
|
}
|
|
#else
|
|
if (ret == WOLFSSL_SUCCESS) {
|
|
if (wc_InitRwLock(&session_lock) != 0) {
|
|
WOLFSSL_MSG("Bad Init Mutex session");
|
|
ret = BAD_MUTEX_E;
|
|
}
|
|
else {
|
|
session_lock_valid = 1;
|
|
}
|
|
}
|
|
#endif
|
|
#ifndef NO_CLIENT_CACHE
|
|
if (ret == WOLFSSL_SUCCESS) {
|
|
if (wc_InitMutex(&clisession_mutex) != 0) {
|
|
WOLFSSL_MSG("Bad Init Mutex session");
|
|
ret = BAD_MUTEX_E;
|
|
}
|
|
else {
|
|
clisession_mutex_valid = 1;
|
|
}
|
|
}
|
|
#endif
|
|
#endif
|
|
#ifndef WOLFSSL_MUTEX_INITIALIZER
|
|
if (ret == WOLFSSL_SUCCESS) {
|
|
if (wc_InitMutex(&count_mutex) != 0) {
|
|
WOLFSSL_MSG("Bad Init Mutex count");
|
|
ret = BAD_MUTEX_E;
|
|
}
|
|
else {
|
|
count_mutex_valid = 1;
|
|
}
|
|
}
|
|
#endif /* !WOLFSSL_MUTEX_INITIALIZER */
|
|
#if defined(OPENSSL_EXTRA) && defined(HAVE_ATEXIT)
|
|
/* OpenSSL registers cleanup using atexit */
|
|
if ((ret == WOLFSSL_SUCCESS) && (atexit(AtExitCleanup) != 0)) {
|
|
WOLFSSL_MSG("Bad atexit registration");
|
|
ret = WC_INIT_E;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
if (ret == WOLFSSL_SUCCESS) {
|
|
if (wc_LockMutex(&count_mutex) != 0) {
|
|
WOLFSSL_MSG("Bad Lock Mutex count");
|
|
ret = BAD_MUTEX_E;
|
|
}
|
|
else {
|
|
initRefCount++;
|
|
wc_UnLockMutex(&count_mutex);
|
|
}
|
|
}
|
|
|
|
if (ret != WOLFSSL_SUCCESS) {
|
|
initRefCount = 1; /* Force cleanup */
|
|
(void)wolfSSL_Cleanup(); /* Ignore any error from cleanup */
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
#ifndef NO_CERTS
|
|
|
|
/* process user cert chain to pass during the handshake */
|
|
static int ProcessUserChain(WOLFSSL_CTX* ctx, const unsigned char* buff,
|
|
long sz, int format, int type, WOLFSSL* ssl,
|
|
long* used, EncryptedInfo* info, int verify)
|
|
{
|
|
int ret = 0;
|
|
void* heap = wolfSSL_CTX_GetHeap(ctx, ssl);
|
|
|
|
if ((type == CA_TYPE) && (ctx == NULL)) {
|
|
WOLFSSL_MSG("Need context for CA load");
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
/* we may have a user cert chain, try to consume */
|
|
if ((type == CERT_TYPE || type == CHAIN_CERT_TYPE || type == CA_TYPE) &&
|
|
(info->consumed < sz)) {
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
byte staticBuffer[1]; /* force heap usage */
|
|
#else
|
|
byte staticBuffer[FILE_BUFFER_SIZE]; /* tmp chain buffer */
|
|
#endif
|
|
byte* chainBuffer = staticBuffer;
|
|
int dynamicBuffer = 0;
|
|
word32 bufferSz;
|
|
long consumed = info->consumed;
|
|
word32 idx = 0;
|
|
int gotOne = 0;
|
|
#ifdef WOLFSSL_TLS13
|
|
int cnt = 0;
|
|
#endif
|
|
|
|
/* Calculate max possible size, including max headers */
|
|
bufferSz = (word32)(sz - consumed) + (CERT_HEADER_SZ * MAX_CHAIN_DEPTH);
|
|
if (bufferSz > sizeof(staticBuffer)) {
|
|
WOLFSSL_MSG("Growing Tmp Chain Buffer");
|
|
/* will shrink to actual size */
|
|
chainBuffer = (byte*)XMALLOC(bufferSz, heap, DYNAMIC_TYPE_FILE);
|
|
if (chainBuffer == NULL) {
|
|
return MEMORY_E;
|
|
}
|
|
dynamicBuffer = 1;
|
|
}
|
|
|
|
WOLFSSL_MSG("Processing Cert Chain");
|
|
while (consumed < sz) {
|
|
DerBuffer* part = NULL;
|
|
word32 remain = (word32)(sz - consumed);
|
|
info->consumed = 0;
|
|
|
|
if (format == WOLFSSL_FILETYPE_PEM) {
|
|
#ifdef WOLFSSL_PEM_TO_DER
|
|
ret = PemToDer(buff + consumed, remain, type, &part,
|
|
heap, info, NULL);
|
|
#else
|
|
ret = NOT_COMPILED_IN;
|
|
#endif
|
|
}
|
|
else {
|
|
int length = remain;
|
|
if (format == WOLFSSL_FILETYPE_ASN1) {
|
|
/* get length of der (read sequence) */
|
|
word32 inOutIdx = 0;
|
|
if (GetSequence(buff + consumed, &inOutIdx, &length,
|
|
remain) < 0) {
|
|
ret = ASN_NO_PEM_HEADER;
|
|
}
|
|
length += inOutIdx; /* include leading sequence */
|
|
}
|
|
info->consumed = length;
|
|
if (ret == 0) {
|
|
ret = AllocDer(&part, length, type, heap);
|
|
if (ret == 0) {
|
|
XMEMCPY(part->buffer, buff + consumed, length);
|
|
}
|
|
}
|
|
}
|
|
if (ret == 0) {
|
|
gotOne = 1;
|
|
#ifdef WOLFSSL_TLS13
|
|
cnt++;
|
|
#endif
|
|
if ((idx + part->length + CERT_HEADER_SZ) > bufferSz) {
|
|
WOLFSSL_MSG(" Cert Chain bigger than buffer. "
|
|
"Consider increasing MAX_CHAIN_DEPTH");
|
|
ret = BUFFER_E;
|
|
}
|
|
else {
|
|
c32to24(part->length, &chainBuffer[idx]);
|
|
idx += CERT_HEADER_SZ;
|
|
XMEMCPY(&chainBuffer[idx], part->buffer, part->length);
|
|
idx += part->length;
|
|
consumed += info->consumed;
|
|
if (used)
|
|
*used += info->consumed;
|
|
}
|
|
|
|
/* add CA's to certificate manager */
|
|
if (ret == 0 && type == CA_TYPE) {
|
|
/* verify CA unless user set to no verify */
|
|
ret = AddCA(ctx->cm, &part, WOLFSSL_USER_CA, verify);
|
|
if (ret == WOLFSSL_SUCCESS) {
|
|
ret = 0; /* converted success case */
|
|
}
|
|
gotOne = 0; /* don't exit loop for CA type */
|
|
}
|
|
}
|
|
|
|
FreeDer(&part);
|
|
|
|
if (ret == ASN_NO_PEM_HEADER && gotOne) {
|
|
WOLFSSL_MSG("We got one good cert, so stuff at end ok");
|
|
break;
|
|
}
|
|
|
|
if (ret < 0) {
|
|
WOLFSSL_MSG(" Error in Cert in Chain");
|
|
if (dynamicBuffer)
|
|
XFREE(chainBuffer, heap, DYNAMIC_TYPE_FILE);
|
|
return ret;
|
|
}
|
|
WOLFSSL_MSG(" Consumed another Cert in Chain");
|
|
}
|
|
WOLFSSL_MSG("Finished Processing Cert Chain");
|
|
|
|
/* only retain actual size used */
|
|
ret = 0;
|
|
if (idx > 0) {
|
|
if (ssl) {
|
|
if (ssl->buffers.weOwnCertChain) {
|
|
FreeDer(&ssl->buffers.certChain);
|
|
}
|
|
ret = AllocDer(&ssl->buffers.certChain, idx, type, heap);
|
|
if (ret == 0) {
|
|
XMEMCPY(ssl->buffers.certChain->buffer, chainBuffer,
|
|
idx);
|
|
ssl->buffers.weOwnCertChain = 1;
|
|
}
|
|
#ifdef WOLFSSL_TLS13
|
|
ssl->buffers.certChainCnt = cnt;
|
|
#endif
|
|
} else if (ctx) {
|
|
FreeDer(&ctx->certChain);
|
|
ret = AllocDer(&ctx->certChain, idx, type, heap);
|
|
if (ret == 0) {
|
|
XMEMCPY(ctx->certChain->buffer, chainBuffer, idx);
|
|
}
|
|
#ifdef WOLFSSL_TLS13
|
|
ctx->certChainCnt = cnt;
|
|
#endif
|
|
}
|
|
}
|
|
|
|
if (dynamicBuffer)
|
|
XFREE(chainBuffer, heap, DYNAMIC_TYPE_FILE);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
#ifndef NO_RSA
|
|
#if !defined(HAVE_FIPS) || (defined(HAVE_FIPS_VERSION) && \
|
|
(HAVE_FIPS_VERSION > 2))
|
|
static int ProcessBufferTryDecodeRsa(WOLFSSL_CTX* ctx, WOLFSSL* ssl,
|
|
DerBuffer* der, int* keySz, word32* idx, int* resetSuites, int* keyFormat,
|
|
int devId)
|
|
{
|
|
int ret;
|
|
|
|
(void)devId;
|
|
|
|
*idx = 0;
|
|
ret = wc_RsaPrivateKeyValidate(der->buffer, idx, keySz, der->length);
|
|
#ifdef WOLF_PRIVATE_KEY_ID
|
|
if ((ret != 0) && (devId != INVALID_DEVID
|
|
#ifdef HAVE_PK_CALLBACKS
|
|
|| ((ssl == NULL) ? wolfSSL_CTX_IsPrivatePkSet(ctx) :
|
|
wolfSSL_CTX_IsPrivatePkSet(ssl->ctx))
|
|
#endif
|
|
)) {
|
|
word32 nSz;
|
|
|
|
/* if using crypto or PK callbacks, try public key decode */
|
|
*idx = 0;
|
|
ret = wc_RsaPublicKeyDecode_ex(der->buffer, idx, der->length, NULL,
|
|
&nSz, NULL, NULL);
|
|
if (ret == 0) {
|
|
*keySz = (int)nSz;
|
|
}
|
|
}
|
|
#endif
|
|
if (ret != 0) {
|
|
#if !defined(HAVE_ECC) && !defined(HAVE_ED25519) && \
|
|
!defined(HAVE_ED448) && !defined(HAVE_PQC)
|
|
WOLFSSL_MSG("RSA decode failed and other algorithms "
|
|
"not enabled to try");
|
|
ret = WOLFSSL_BAD_FILE;
|
|
#else
|
|
ret = 0; /* continue trying other algorithms */
|
|
#endif
|
|
}
|
|
else {
|
|
/* check that the size of the RSA key is enough */
|
|
int minRsaSz = ssl ? ssl->options.minRsaKeySz : ctx->minRsaKeySz;
|
|
if (*keySz < minRsaSz) {
|
|
ret = RSA_KEY_SIZE_E;
|
|
WOLFSSL_MSG("Private Key size too small");
|
|
}
|
|
|
|
if (ssl) {
|
|
ssl->buffers.keyType = rsa_sa_algo;
|
|
ssl->buffers.keySz = *keySz;
|
|
}
|
|
else {
|
|
ctx->privateKeyType = rsa_sa_algo;
|
|
ctx->privateKeySz = *keySz;
|
|
}
|
|
|
|
*keyFormat = RSAk;
|
|
|
|
if (ssl && ssl->options.side == WOLFSSL_SERVER_END) {
|
|
ssl->options.haveStaticECC = 0;
|
|
*resetSuites = 1;
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
#else
|
|
static int ProcessBufferTryDecodeRsa(WOLFSSL_CTX* ctx, WOLFSSL* ssl,
|
|
DerBuffer* der, int* keySz, word32* idx, int* resetSuites, int* keyFormat,
|
|
void* heap, int devId)
|
|
{
|
|
int ret;
|
|
|
|
/* make sure RSA key can be used */
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
RsaKey* key;
|
|
#else
|
|
RsaKey key[1];
|
|
#endif
|
|
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
key = (RsaKey*)XMALLOC(sizeof(RsaKey), heap, DYNAMIC_TYPE_RSA);
|
|
if (key == NULL)
|
|
return MEMORY_E;
|
|
#endif
|
|
|
|
ret = wc_InitRsaKey_ex(key, heap, devId);
|
|
if (ret == 0) {
|
|
*idx = 0;
|
|
ret = wc_RsaPrivateKeyDecode(der->buffer, idx, key, der->length);
|
|
#ifdef WOLF_PRIVATE_KEY_ID
|
|
if (ret != 0 && (devId != INVALID_DEVID
|
|
#ifdef HAVE_PK_CALLBACKS
|
|
|| ((ssl == NULL) ? wolfSSL_CTX_IsPrivatePkSet(ctx) :
|
|
wolfSSL_CTX_IsPrivatePkSet(ssl->ctx))
|
|
#endif
|
|
)) {
|
|
/* if using crypto or PK callbacks, try public key decode */
|
|
*idx = 0;
|
|
ret = wc_RsaPublicKeyDecode(der->buffer, idx, key, der->length);
|
|
}
|
|
#endif
|
|
if (ret != 0) {
|
|
#if !defined(HAVE_ECC) && !defined(HAVE_ED25519) && \
|
|
!defined(HAVE_ED448) && !defined(HAVE_PQC)
|
|
WOLFSSL_MSG("RSA decode failed and other algorithms "
|
|
"not enabled to try");
|
|
ret = WOLFSSL_BAD_FILE;
|
|
#else
|
|
ret = 0; /* continue trying other algorithms */
|
|
#endif
|
|
}
|
|
else {
|
|
/* check that the size of the RSA key is enough */
|
|
int minRsaSz = ssl ? ssl->options.minRsaKeySz : ctx->minRsaKeySz;
|
|
*keySz = wc_RsaEncryptSize((RsaKey*)key);
|
|
if (*keySz < minRsaSz) {
|
|
ret = RSA_KEY_SIZE_E;
|
|
WOLFSSL_MSG("Private Key size too small");
|
|
}
|
|
|
|
if (ssl) {
|
|
ssl->buffers.keyType = rsa_sa_algo;
|
|
ssl->buffers.keySz = *keySz;
|
|
}
|
|
else {
|
|
ctx->privateKeyType = rsa_sa_algo;
|
|
ctx->privateKeySz = *keySz;
|
|
}
|
|
|
|
*keyFormat = RSAk;
|
|
|
|
if (ssl && ssl->options.side == WOLFSSL_SERVER_END) {
|
|
ssl->options.haveStaticECC = 0;
|
|
*resetSuites = 1;
|
|
}
|
|
}
|
|
|
|
wc_FreeRsaKey(key);
|
|
}
|
|
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
XFREE(key, heap, DYNAMIC_TYPE_RSA);
|
|
#endif
|
|
|
|
return ret;
|
|
}
|
|
#endif
|
|
#endif /* !NO_RSA */
|
|
|
|
#ifdef HAVE_ECC
|
|
static int ProcessBufferTryDecodeEcc(WOLFSSL_CTX* ctx, WOLFSSL* ssl,
|
|
DerBuffer* der, int* keySz, word32* idx, int* resetSuites, int* keyFormat,
|
|
void* heap, int devId)
|
|
{
|
|
int ret = 0;
|
|
/* make sure ECC key can be used */
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
ecc_key* key;
|
|
#else
|
|
ecc_key key[1];
|
|
#endif
|
|
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
key = (ecc_key*)XMALLOC(sizeof(ecc_key), heap, DYNAMIC_TYPE_ECC);
|
|
if (key == NULL)
|
|
return MEMORY_E;
|
|
#endif
|
|
|
|
if (wc_ecc_init_ex(key, heap, devId) == 0) {
|
|
*idx = 0;
|
|
ret = wc_EccPrivateKeyDecode(der->buffer, idx, key, der->length);
|
|
#ifdef WOLF_PRIVATE_KEY_ID
|
|
if (ret != 0 && (devId != INVALID_DEVID
|
|
#ifdef HAVE_PK_CALLBACKS
|
|
|| ((ssl == NULL) ? wolfSSL_CTX_IsPrivatePkSet(ctx) :
|
|
wolfSSL_CTX_IsPrivatePkSet(ssl->ctx))
|
|
#endif
|
|
)) {
|
|
/* if using crypto or PK callbacks, try public key decode */
|
|
*idx = 0;
|
|
ret = wc_EccPublicKeyDecode(der->buffer, idx, key, der->length);
|
|
}
|
|
#endif
|
|
if (ret == 0) {
|
|
/* check for minimum ECC key size and then free */
|
|
int minKeySz = ssl ? ssl->options.minEccKeySz : ctx->minEccKeySz;
|
|
*keySz = wc_ecc_size(key);
|
|
if (*keySz < minKeySz) {
|
|
WOLFSSL_MSG("ECC private key too small");
|
|
ret = ECC_KEY_SIZE_E;
|
|
}
|
|
|
|
*keyFormat = ECDSAk;
|
|
if (ssl) {
|
|
ssl->options.haveStaticECC = 1;
|
|
ssl->buffers.keyType = ecc_dsa_sa_algo;
|
|
#ifdef WOLFSSL_SM2
|
|
if (key->dp->id == ECC_SM2P256V1)
|
|
ssl->buffers.keyType = sm2_sa_algo;
|
|
else
|
|
#endif
|
|
ssl->buffers.keyType = ecc_dsa_sa_algo;
|
|
ssl->buffers.keySz = *keySz;
|
|
}
|
|
else {
|
|
ctx->haveStaticECC = 1;
|
|
ctx->privateKeyType = ecc_dsa_sa_algo;
|
|
#ifdef WOLFSSL_SM2
|
|
if (key->dp->id == ECC_SM2P256V1)
|
|
ctx->privateKeyType = sm2_sa_algo;
|
|
else
|
|
#endif
|
|
ctx->privateKeyType = ecc_dsa_sa_algo;
|
|
ctx->privateKeySz = *keySz;
|
|
}
|
|
|
|
if (ssl && ssl->options.side == WOLFSSL_SERVER_END) {
|
|
*resetSuites = 1;
|
|
}
|
|
}
|
|
else {
|
|
ret = 0; /* continue trying other algorithms */
|
|
}
|
|
|
|
wc_ecc_free(key);
|
|
}
|
|
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
XFREE(key, heap, DYNAMIC_TYPE_ECC);
|
|
#endif
|
|
return ret;
|
|
}
|
|
#endif /* HAVE_ECC */
|
|
|
|
#if defined(HAVE_ED25519) && defined(HAVE_ED25519_KEY_IMPORT)
|
|
static int ProcessBufferTryDecodeEd25519(WOLFSSL_CTX* ctx, WOLFSSL* ssl,
|
|
DerBuffer* der, int* keySz, word32* idx, int* resetSuites, int* keyFormat,
|
|
void* heap, int devId)
|
|
{
|
|
int ret;
|
|
/* make sure Ed25519 key can be used */
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
ed25519_key* key;
|
|
#else
|
|
ed25519_key key[1];
|
|
#endif
|
|
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
key = (ed25519_key*)XMALLOC(sizeof(ed25519_key), heap,
|
|
DYNAMIC_TYPE_ED25519);
|
|
if (key == NULL)
|
|
return MEMORY_E;
|
|
#endif
|
|
|
|
ret = wc_ed25519_init_ex(key, heap, devId);
|
|
if (ret == 0) {
|
|
*idx = 0;
|
|
ret = wc_Ed25519PrivateKeyDecode(der->buffer, idx, key, der->length);
|
|
#ifdef WOLF_PRIVATE_KEY_ID
|
|
if (ret != 0 && (devId != INVALID_DEVID
|
|
#ifdef HAVE_PK_CALLBACKS
|
|
|| ((ssl == NULL) ? wolfSSL_CTX_IsPrivatePkSet(ctx) :
|
|
wolfSSL_CTX_IsPrivatePkSet(ssl->ctx))
|
|
#endif
|
|
)) {
|
|
/* if using crypto or PK callbacks, try public key decode */
|
|
*idx = 0;
|
|
ret = wc_Ed25519PublicKeyDecode(der->buffer, idx, key, der->length);
|
|
}
|
|
#endif
|
|
if (ret == 0) {
|
|
/* check for minimum key size and then free */
|
|
int minKeySz = ssl ? ssl->options.minEccKeySz : ctx->minEccKeySz;
|
|
*keySz = ED25519_KEY_SIZE;
|
|
if (*keySz < minKeySz) {
|
|
WOLFSSL_MSG("ED25519 private key too small");
|
|
ret = ECC_KEY_SIZE_E;
|
|
}
|
|
if (ret == 0) {
|
|
if (ssl) {
|
|
ssl->buffers.keyType = ed25519_sa_algo;
|
|
ssl->buffers.keySz = *keySz;
|
|
}
|
|
else if (ctx) {
|
|
ctx->privateKeyType = ed25519_sa_algo;
|
|
ctx->privateKeySz = *keySz;
|
|
}
|
|
|
|
*keyFormat = ED25519k;
|
|
if (ssl != NULL) {
|
|
#if !defined(WOLFSSL_NO_CLIENT_AUTH) && !defined(NO_ED25519_CLIENT_AUTH)
|
|
/* ED25519 requires caching enabled for tracking message
|
|
* hash used in EdDSA_Update for signing */
|
|
ssl->options.cacheMessages = 1;
|
|
#endif
|
|
if (ssl->options.side == WOLFSSL_SERVER_END) {
|
|
*resetSuites = 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
ret = 0; /* continue trying other algorithms */
|
|
}
|
|
|
|
wc_ed25519_free(key);
|
|
}
|
|
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
XFREE(key, heap, DYNAMIC_TYPE_ED25519);
|
|
#endif
|
|
return ret;
|
|
}
|
|
#endif /* HAVE_ED25519 && HAVE_ED25519_KEY_IMPORT */
|
|
|
|
#if defined(HAVE_ED448) && defined(HAVE_ED448_KEY_IMPORT)
|
|
static int ProcessBufferTryDecodeEd448(WOLFSSL_CTX* ctx, WOLFSSL* ssl,
|
|
DerBuffer* der, int* keySz, word32* idx, int* resetSuites, int* keyFormat,
|
|
void* heap, int devId)
|
|
{
|
|
int ret;
|
|
/* make sure Ed448 key can be used */
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
ed448_key* key = NULL;
|
|
#else
|
|
ed448_key key[1];
|
|
#endif
|
|
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
key = (ed448_key*)XMALLOC(sizeof(ed448_key), heap, DYNAMIC_TYPE_ED448);
|
|
if (key == NULL)
|
|
return MEMORY_E;
|
|
#endif
|
|
|
|
ret = wc_ed448_init_ex(key, heap, devId);
|
|
if (ret == 0) {
|
|
*idx = 0;
|
|
ret = wc_Ed448PrivateKeyDecode(der->buffer, idx, key, der->length);
|
|
#ifdef WOLF_PRIVATE_KEY_ID
|
|
if (ret != 0 && (devId != INVALID_DEVID
|
|
#ifdef HAVE_PK_CALLBACKS
|
|
|| ((ssl == NULL) ? wolfSSL_CTX_IsPrivatePkSet(ctx) :
|
|
wolfSSL_CTX_IsPrivatePkSet(ssl->ctx))
|
|
#endif
|
|
)) {
|
|
/* if using crypto or PK callbacks, try public key decode */
|
|
*idx = 0;
|
|
ret = wc_Ed448PublicKeyDecode(der->buffer, idx, key, der->length);
|
|
}
|
|
#endif
|
|
if (ret == 0) {
|
|
/* check for minimum key size and then free */
|
|
int minKeySz = ssl ? ssl->options.minEccKeySz : ctx->minEccKeySz;
|
|
*keySz = ED448_KEY_SIZE;
|
|
if (*keySz < minKeySz) {
|
|
WOLFSSL_MSG("ED448 private key too small");
|
|
ret = ECC_KEY_SIZE_E;
|
|
}
|
|
}
|
|
if (ret == 0) {
|
|
if (ssl) {
|
|
ssl->buffers.keyType = ed448_sa_algo;
|
|
ssl->buffers.keySz = *keySz;
|
|
}
|
|
else if (ctx) {
|
|
ctx->privateKeyType = ed448_sa_algo;
|
|
ctx->privateKeySz = *keySz;
|
|
}
|
|
|
|
*keyFormat = ED448k;
|
|
if (ssl != NULL) {
|
|
/* ED448 requires caching enabled for tracking message
|
|
* hash used in EdDSA_Update for signing */
|
|
ssl->options.cacheMessages = 1;
|
|
if (ssl->options.side == WOLFSSL_SERVER_END) {
|
|
*resetSuites = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
wc_ed448_free(key);
|
|
}
|
|
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
XFREE(key, heap, DYNAMIC_TYPE_ED448);
|
|
#endif
|
|
return ret;
|
|
}
|
|
#endif /* HAVE_ED448 && HAVE_ED448_KEY_IMPORT */
|
|
|
|
#if defined(HAVE_PQC)
|
|
#if defined(HAVE_FALCON)
|
|
static int ProcessBufferTryDecodeFalcon(WOLFSSL_CTX* ctx, WOLFSSL* ssl,
|
|
DerBuffer* der, int* keySz, word32* idx, int* resetSuites, int* keyFormat,
|
|
void* heap)
|
|
{
|
|
int ret;
|
|
/* make sure Falcon key can be used */
|
|
falcon_key* key = (falcon_key*)XMALLOC(sizeof(falcon_key), heap,
|
|
DYNAMIC_TYPE_FALCON);
|
|
if (key == NULL) {
|
|
return MEMORY_E;
|
|
}
|
|
ret = wc_falcon_init(key);
|
|
if (ret == 0) {
|
|
if (*keyFormat == FALCON_LEVEL1k) {
|
|
ret = wc_falcon_set_level(key, 1);
|
|
}
|
|
else if (*keyFormat == FALCON_LEVEL5k) {
|
|
ret = wc_falcon_set_level(key, 5);
|
|
}
|
|
else {
|
|
/* What if *keyformat is 0? We might want to do something more
|
|
* graceful here. */
|
|
wc_falcon_free(key);
|
|
ret = ALGO_ID_E;
|
|
}
|
|
}
|
|
|
|
if (ret == 0) {
|
|
*idx = 0;
|
|
ret = wc_falcon_import_private_only(der->buffer, der->length, key);
|
|
if (ret == 0) {
|
|
/* check for minimum key size and then free */
|
|
int minKeySz = ssl ? ssl->options.minFalconKeySz :
|
|
ctx->minFalconKeySz;
|
|
*keySz = FALCON_MAX_KEY_SIZE;
|
|
if (*keySz < minKeySz) {
|
|
WOLFSSL_MSG("Falcon private key too small");
|
|
ret = FALCON_KEY_SIZE_E;
|
|
}
|
|
if (ssl) {
|
|
if (*keyFormat == FALCON_LEVEL1k) {
|
|
ssl->buffers.keyType = falcon_level1_sa_algo;
|
|
}
|
|
else {
|
|
ssl->buffers.keyType = falcon_level5_sa_algo;
|
|
}
|
|
ssl->buffers.keySz = *keySz;
|
|
}
|
|
else {
|
|
if (*keyFormat == FALCON_LEVEL1k) {
|
|
ctx->privateKeyType = falcon_level1_sa_algo;
|
|
}
|
|
else {
|
|
ctx->privateKeyType = falcon_level5_sa_algo;
|
|
}
|
|
ctx->privateKeySz = *keySz;
|
|
}
|
|
|
|
if (ssl && ssl->options.side == WOLFSSL_SERVER_END) {
|
|
*resetSuites = 1;
|
|
}
|
|
}
|
|
wc_falcon_free(key);
|
|
}
|
|
XFREE(key, heap, DYNAMIC_TYPE_FALCON);
|
|
return ret;
|
|
}
|
|
#endif
|
|
|
|
#if defined(HAVE_DILITHIUM)
|
|
static int ProcessBufferTryDecodeDilithium(WOLFSSL_CTX* ctx, WOLFSSL* ssl,
|
|
DerBuffer* der, int* keySz, word32* idx, int* resetSuites, int* keyFormat,
|
|
void* heap)
|
|
{
|
|
int ret;
|
|
/* make sure Dilithium key can be used */
|
|
dilithium_key* key = (dilithium_key*)XMALLOC(sizeof(dilithium_key), heap,
|
|
DYNAMIC_TYPE_DILITHIUM);
|
|
if (key == NULL) {
|
|
return MEMORY_E;
|
|
}
|
|
ret = wc_dilithium_init(key);
|
|
if (ret == 0) {
|
|
if (*keyFormat == DILITHIUM_LEVEL2k) {
|
|
ret = wc_dilithium_set_level(key, 2);
|
|
}
|
|
else if (*keyFormat == DILITHIUM_LEVEL3k) {
|
|
ret = wc_dilithium_set_level(key, 3);
|
|
}
|
|
else if (*keyFormat == DILITHIUM_LEVEL5k) {
|
|
ret = wc_dilithium_set_level(key, 5);
|
|
}
|
|
else {
|
|
/* What if *keyformat is 0? We might want to do something more
|
|
* graceful here. */
|
|
wc_dilithium_free(key);
|
|
ret = ALGO_ID_E;
|
|
}
|
|
}
|
|
|
|
if (ret == 0) {
|
|
*idx = 0;
|
|
ret = wc_dilithium_import_private_only(der->buffer, der->length, key);
|
|
if (ret == 0) {
|
|
/* check for minimum key size and then free */
|
|
int minKeySz = ssl ? ssl->options.minDilithiumKeySz :
|
|
ctx->minDilithiumKeySz;
|
|
*keySz = DILITHIUM_MAX_KEY_SIZE;
|
|
if (*keySz < minKeySz) {
|
|
WOLFSSL_MSG("Dilithium private key too small");
|
|
ret = DILITHIUM_KEY_SIZE_E;
|
|
}
|
|
if (ssl) {
|
|
if (*keyFormat == DILITHIUM_LEVEL2k) {
|
|
ssl->buffers.keyType = dilithium_level2_sa_algo;
|
|
}
|
|
else if (*keyFormat == DILITHIUM_LEVEL3k) {
|
|
ssl->buffers.keyType = dilithium_level3_sa_algo;
|
|
}
|
|
else if (*keyFormat == DILITHIUM_LEVEL5k) {
|
|
ssl->buffers.keyType = dilithium_level5_sa_algo;
|
|
}
|
|
ssl->buffers.keySz = *keySz;
|
|
}
|
|
else {
|
|
if (*keyFormat == DILITHIUM_LEVEL2k) {
|
|
ctx->privateKeyType = dilithium_level2_sa_algo;
|
|
}
|
|
else if (*keyFormat == DILITHIUM_LEVEL3k) {
|
|
ctx->privateKeyType = dilithium_level3_sa_algo;
|
|
}
|
|
else if (*keyFormat == DILITHIUM_LEVEL5k) {
|
|
ctx->privateKeyType = dilithium_level5_sa_algo;
|
|
}
|
|
ctx->privateKeySz = *keySz;
|
|
}
|
|
|
|
if (ssl && ssl->options.side == WOLFSSL_SERVER_END) {
|
|
*resetSuites = 1;
|
|
}
|
|
}
|
|
wc_dilithium_free(key);
|
|
}
|
|
XFREE(key, heap, DYNAMIC_TYPE_DILITHIUM);
|
|
|
|
return ret;
|
|
}
|
|
#endif /* HAVE_DILITHIUM */
|
|
#endif /* HAVE_PQC */
|
|
|
|
static int ProcessBufferTryDecode(WOLFSSL_CTX* ctx, WOLFSSL* ssl,
|
|
DerBuffer* der, int* keySz, word32* idx, int* resetSuites, int* keyFormat,
|
|
void* heap, int devId)
|
|
{
|
|
int ret = 0;
|
|
|
|
(void)heap;
|
|
(void)devId;
|
|
|
|
if (ctx == NULL && ssl == NULL)
|
|
return BAD_FUNC_ARG;
|
|
if (!der || !keySz || !idx || !resetSuites || !keyFormat)
|
|
return BAD_FUNC_ARG;
|
|
|
|
#ifndef NO_RSA
|
|
if ((*keyFormat == 0 || *keyFormat == RSAk)) {
|
|
#if !defined(HAVE_FIPS) || (defined(HAVE_FIPS_VERSION) && \
|
|
(HAVE_FIPS_VERSION > 2))
|
|
ret = ProcessBufferTryDecodeRsa(ctx, ssl, der, keySz, idx, resetSuites,
|
|
keyFormat, devId);
|
|
#else
|
|
ret = ProcessBufferTryDecodeRsa(ctx, ssl, der, keySz, idx, resetSuites,
|
|
keyFormat, heap, devId);
|
|
#endif
|
|
if (ret != 0)
|
|
return ret;
|
|
}
|
|
#endif
|
|
#ifdef HAVE_ECC
|
|
if ((*keyFormat == 0) || (*keyFormat == ECDSAk)
|
|
#ifdef WOLFSSL_SM2
|
|
|| (*keyFormat == SM2k)
|
|
#endif
|
|
) {
|
|
ret = ProcessBufferTryDecodeEcc(ctx, ssl, der, keySz, idx, resetSuites,
|
|
keyFormat, heap, devId);
|
|
if (ret != 0)
|
|
return ret;
|
|
}
|
|
#endif /* HAVE_ECC */
|
|
#if defined(HAVE_ED25519) && defined(HAVE_ED25519_KEY_IMPORT)
|
|
if ((*keyFormat == 0 || *keyFormat == ED25519k)) {
|
|
ret = ProcessBufferTryDecodeEd25519(ctx, ssl, der, keySz, idx,
|
|
resetSuites, keyFormat, heap, devId);
|
|
if (ret != 0)
|
|
return ret;
|
|
}
|
|
#endif /* HAVE_ED25519 && HAVE_ED25519_KEY_IMPORT */
|
|
#if defined(HAVE_ED448) && defined(HAVE_ED448_KEY_IMPORT)
|
|
if ((*keyFormat == 0 || *keyFormat == ED448k)) {
|
|
ret = ProcessBufferTryDecodeEd448(ctx, ssl, der, keySz, idx,
|
|
resetSuites, keyFormat, heap, devId);
|
|
if (ret != 0)
|
|
return ret;
|
|
}
|
|
#endif /* HAVE_ED448 && HAVE_ED448_KEY_IMPORT */
|
|
#if defined(HAVE_PQC)
|
|
#if defined(HAVE_FALCON)
|
|
if (((*keyFormat == 0) || (*keyFormat == FALCON_LEVEL1k) ||
|
|
(*keyFormat == FALCON_LEVEL5k))) {
|
|
ret = ProcessBufferTryDecodeFalcon(ctx, ssl, der, keySz, idx,
|
|
resetSuites, keyFormat, heap);
|
|
if (ret != 0)
|
|
return ret;
|
|
}
|
|
#endif /* HAVE_FALCON */
|
|
#if defined(HAVE_DILITHIUM)
|
|
if ((*keyFormat == 0) ||
|
|
(*keyFormat == DILITHIUM_LEVEL2k) ||
|
|
(*keyFormat == DILITHIUM_LEVEL3k) ||
|
|
(*keyFormat == DILITHIUM_LEVEL5k)) {
|
|
ret = ProcessBufferTryDecodeDilithium(ctx, ssl, der, keySz, idx,
|
|
resetSuites, keyFormat, heap);
|
|
if (ret != 0) {
|
|
return ret;
|
|
}
|
|
}
|
|
#endif /* HAVE_DILITHIUM */
|
|
#endif /* HAVE_PQC */
|
|
return ret;
|
|
}
|
|
|
|
/* process the buffer buff, length sz, into ctx of format and type
|
|
used tracks bytes consumed, userChain specifies a user cert chain
|
|
to pass during the handshake */
|
|
int ProcessBuffer(WOLFSSL_CTX* ctx, const unsigned char* buff,
|
|
long sz, int format, int type, WOLFSSL* ssl,
|
|
long* used, int userChain, int verify)
|
|
{
|
|
DerBuffer* der = NULL;
|
|
int ret = 0;
|
|
int done = 0;
|
|
int keyFormat = 0;
|
|
int resetSuites = 0;
|
|
void* heap = wolfSSL_CTX_GetHeap(ctx, ssl);
|
|
int devId = wolfSSL_CTX_GetDevId(ctx, ssl);
|
|
word32 idx = 0;
|
|
int keySz = 0;
|
|
#if (defined(WOLFSSL_ENCRYPTED_KEYS) && !defined(NO_PWDBASED)) || \
|
|
defined(HAVE_PKCS8)
|
|
word32 algId = 0;
|
|
#endif
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
EncryptedInfo* info = NULL;
|
|
#else
|
|
EncryptedInfo info[1];
|
|
#endif
|
|
|
|
(void)devId;
|
|
(void)idx;
|
|
(void)keySz;
|
|
|
|
if (used)
|
|
*used = sz; /* used bytes default to sz, PEM chain may shorten*/
|
|
|
|
/* check args */
|
|
if (format != WOLFSSL_FILETYPE_ASN1 && format != WOLFSSL_FILETYPE_PEM)
|
|
return WOLFSSL_BAD_FILETYPE;
|
|
|
|
if (ctx == NULL && ssl == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
/* This API does not handle CHAIN_CERT_TYPE */
|
|
if (type == CHAIN_CERT_TYPE)
|
|
return BAD_FUNC_ARG;
|
|
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
info = (EncryptedInfo*)XMALLOC(sizeof(EncryptedInfo), heap,
|
|
DYNAMIC_TYPE_ENCRYPTEDINFO);
|
|
if (info == NULL)
|
|
return MEMORY_E;
|
|
#endif
|
|
|
|
XMEMSET(info, 0, sizeof(EncryptedInfo));
|
|
#if defined(WOLFSSL_ENCRYPTED_KEYS) && !defined(NO_PWDBASED)
|
|
if (ctx) {
|
|
info->passwd_cb = ctx->passwd_cb;
|
|
info->passwd_userdata = ctx->passwd_userdata;
|
|
}
|
|
#endif
|
|
|
|
if (format == WOLFSSL_FILETYPE_PEM) {
|
|
#ifdef WOLFSSL_PEM_TO_DER
|
|
ret = PemToDer(buff, sz, type, &der, heap, info, &keyFormat);
|
|
#else
|
|
ret = NOT_COMPILED_IN;
|
|
#endif
|
|
}
|
|
else {
|
|
/* ASN1 (DER) */
|
|
int length = (int)sz;
|
|
word32 inOutIdx = 0;
|
|
/* get length of der (read sequence or octet string) */
|
|
if (GetSequence(buff, &inOutIdx, &length, (word32)sz) >= 0) {
|
|
length += inOutIdx; /* include leading sequence */
|
|
}
|
|
/* get length using octet string (allowed for private key types) */
|
|
else if (type == PRIVATEKEY_TYPE &&
|
|
GetOctetString(buff, &inOutIdx, &length, (word32)sz) >= 0) {
|
|
length += inOutIdx; /* include leading oct string */
|
|
}
|
|
else {
|
|
ret = ASN_PARSE_E;
|
|
}
|
|
|
|
info->consumed = length;
|
|
|
|
if (ret == 0) {
|
|
ret = AllocDer(&der, (word32)length, type, heap);
|
|
if (ret == 0) {
|
|
XMEMCPY(der->buffer, buff, length);
|
|
}
|
|
|
|
#ifdef HAVE_PKCS8
|
|
/* if private key try and remove PKCS8 header */
|
|
if (ret == 0 && type == PRIVATEKEY_TYPE) {
|
|
if ((ret = ToTraditional_ex(der->buffer, der->length,
|
|
&algId)) > 0) {
|
|
/* Found PKCS8 header */
|
|
/* ToTraditional_ex moves buff and returns adjusted length */
|
|
der->length = ret;
|
|
keyFormat = algId;
|
|
}
|
|
ret = 0; /* failures should be ignored */
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
|
|
if (used) {
|
|
*used = info->consumed;
|
|
}
|
|
|
|
/* process user chain */
|
|
if (ret >= 0) {
|
|
/* Chain should have server cert first, then intermediates, then root.
|
|
* First certificate in chain is processed below after ProcessUserChain
|
|
* and is loaded into ssl->buffers.certificate.
|
|
* Remainder are processed using ProcessUserChain and are loaded into
|
|
* ssl->buffers.certChain. */
|
|
if (userChain) {
|
|
ret = ProcessUserChain(ctx, buff, sz, format, CHAIN_CERT_TYPE, ssl,
|
|
used, info, verify);
|
|
if (ret == ASN_NO_PEM_HEADER) { /* Additional chain is optional */
|
|
unsigned long pemErr = 0;
|
|
CLEAR_ASN_NO_PEM_HEADER_ERROR(pemErr);
|
|
ret = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* info is only used for private key with DER or PEM, so free now */
|
|
if (ret < 0 || type != PRIVATEKEY_TYPE) {
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
XFREE(info, heap, DYNAMIC_TYPE_ENCRYPTEDINFO);
|
|
#endif
|
|
}
|
|
|
|
/* check for error */
|
|
if (ret < 0) {
|
|
FreeDer(&der);
|
|
done = 1;
|
|
}
|
|
|
|
if (done == 1) {
|
|
/* No operation, just skip the next section */
|
|
}
|
|
/* Handle DER owner */
|
|
else if (type == CA_TYPE) {
|
|
if (ctx == NULL) {
|
|
WOLFSSL_MSG("Need context for CA load");
|
|
FreeDer(&der);
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
/* verify CA unless user set to no verify */
|
|
ret = AddCA(ctx->cm, &der, WOLFSSL_USER_CA, verify);
|
|
done = 1;
|
|
}
|
|
#ifdef WOLFSSL_TRUST_PEER_CERT
|
|
else if (type == TRUSTED_PEER_TYPE) {
|
|
/* add trusted peer cert. der is freed within */
|
|
if (ctx != NULL)
|
|
ret = AddTrustedPeer(ctx->cm, &der, verify);
|
|
else {
|
|
SSL_CM_WARNING(ssl);
|
|
ret = AddTrustedPeer(SSL_CM(ssl), &der, verify);
|
|
}
|
|
if (ret != WOLFSSL_SUCCESS) {
|
|
WOLFSSL_MSG("Error adding trusted peer");
|
|
}
|
|
done = 1;
|
|
}
|
|
#endif /* WOLFSSL_TRUST_PEER_CERT */
|
|
else if (type == CERT_TYPE) {
|
|
if (ssl != NULL) {
|
|
/* Make sure previous is free'd */
|
|
if (ssl->buffers.weOwnCert) {
|
|
FreeDer(&ssl->buffers.certificate);
|
|
#ifdef KEEP_OUR_CERT
|
|
wolfSSL_X509_free(ssl->ourCert);
|
|
ssl->ourCert = NULL;
|
|
#endif
|
|
}
|
|
ssl->buffers.certificate = der;
|
|
#ifdef KEEP_OUR_CERT
|
|
ssl->keepCert = 1; /* hold cert for ssl lifetime */
|
|
#endif
|
|
ssl->buffers.weOwnCert = 1;
|
|
}
|
|
else if (ctx != NULL) {
|
|
FreeDer(&ctx->certificate); /* Make sure previous is free'd */
|
|
#ifdef KEEP_OUR_CERT
|
|
if (ctx->ourCert) {
|
|
if (ctx->ownOurCert)
|
|
wolfSSL_X509_free(ctx->ourCert);
|
|
ctx->ourCert = NULL;
|
|
}
|
|
#endif
|
|
ctx->certificate = der;
|
|
}
|
|
}
|
|
else if (type == PRIVATEKEY_TYPE) {
|
|
if (ssl != NULL) {
|
|
/* Make sure previous is free'd */
|
|
if (ssl->buffers.weOwnKey) {
|
|
ForceZero(ssl->buffers.key->buffer, ssl->buffers.key->length);
|
|
FreeDer(&ssl->buffers.key);
|
|
}
|
|
ssl->buffers.key = der;
|
|
#ifdef WOLFSSL_CHECK_MEM_ZERO
|
|
wc_MemZero_Add("SSL Buffers key", der->buffer, der->length);
|
|
#endif
|
|
ssl->buffers.weOwnKey = 1;
|
|
}
|
|
else if (ctx != NULL) {
|
|
if (ctx->privateKey != NULL && ctx->privateKey->buffer != NULL) {
|
|
ForceZero(ctx->privateKey->buffer, ctx->privateKey->length);
|
|
}
|
|
FreeDer(&ctx->privateKey);
|
|
ctx->privateKey = der;
|
|
#ifdef WOLFSSL_CHECK_MEM_ZERO
|
|
wc_MemZero_Add("CTX private key", der->buffer, der->length);
|
|
#endif
|
|
}
|
|
}
|
|
else {
|
|
FreeDer(&der);
|
|
return WOLFSSL_BAD_CERTTYPE;
|
|
}
|
|
|
|
if (done == 1) {
|
|
/* No operation, just skip the next section */
|
|
}
|
|
else if (type == PRIVATEKEY_TYPE) {
|
|
ret = ProcessBufferTryDecode(ctx, ssl, der, &keySz, &idx, &resetSuites,
|
|
&keyFormat, heap, devId);
|
|
|
|
#if defined(WOLFSSL_ENCRYPTED_KEYS) && !defined(NO_PWDBASED)
|
|
/* for WOLFSSL_FILETYPE_PEM, PemToDer manages the decryption */
|
|
/* If private key type PKCS8 header wasn't already removed (algoId == 0) */
|
|
if ((ret != 0 || keyFormat == 0)
|
|
&& format != WOLFSSL_FILETYPE_PEM && info->passwd_cb && algId == 0)
|
|
{
|
|
int passwordSz = NAME_SZ;
|
|
#ifndef WOLFSSL_SMALL_STACK
|
|
char password[NAME_SZ];
|
|
#else
|
|
char* password = (char*)XMALLOC(passwordSz, heap, DYNAMIC_TYPE_STRING);
|
|
if (password == NULL) {
|
|
XFREE(info, heap, DYNAMIC_TYPE_ENCRYPTEDINFO);
|
|
FreeDer(&der);
|
|
return MEMORY_E;
|
|
}
|
|
#endif
|
|
/* get password */
|
|
ret = info->passwd_cb(password, passwordSz, PEM_PASS_READ,
|
|
info->passwd_userdata);
|
|
if (ret >= 0) {
|
|
passwordSz = ret;
|
|
#ifdef WOLFSSL_CHECK_MEM_ZERO
|
|
wc_MemZero_Add("ProcessBuffer password", password, passwordSz);
|
|
#endif
|
|
|
|
/* PKCS8 decrypt */
|
|
ret = ToTraditionalEnc(der->buffer, der->length,
|
|
password, passwordSz, &algId);
|
|
if (ret >= 0) {
|
|
ForceZero(der->buffer + ret, der->length - ret);
|
|
der->length = ret;
|
|
}
|
|
/* ignore failures and try parsing as unencrypted */
|
|
|
|
ForceZero(password, passwordSz);
|
|
}
|
|
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
XFREE(password, heap, DYNAMIC_TYPE_STRING);
|
|
#elif defined(WOLFSSL_CHECK_MEM_ZERO)
|
|
wc_MemZero_Check(password, NAME_SZ);
|
|
#endif
|
|
ret = ProcessBufferTryDecode(ctx, ssl, der, &keySz, &idx,
|
|
&resetSuites, &keyFormat, heap, devId);
|
|
}
|
|
#endif /* WOLFSSL_ENCRYPTED_KEYS && !NO_PWDBASED */
|
|
|
|
if (ret != 0) {
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
XFREE(info, heap, DYNAMIC_TYPE_ENCRYPTEDINFO);
|
|
#endif
|
|
return ret;
|
|
}
|
|
if (keyFormat == 0) {
|
|
#ifdef OPENSSL_EXTRA
|
|
/* Reaching this point probably means that the
|
|
* decryption password is wrong */
|
|
if (info->passwd_cb)
|
|
EVPerr(0, EVP_R_BAD_DECRYPT);
|
|
#endif
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
XFREE(info, heap, DYNAMIC_TYPE_ENCRYPTEDINFO);
|
|
#endif
|
|
WOLFSSL_ERROR(WOLFSSL_BAD_FILE);
|
|
return WOLFSSL_BAD_FILE;
|
|
}
|
|
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
XFREE(info, heap, DYNAMIC_TYPE_ENCRYPTEDINFO);
|
|
#endif
|
|
|
|
(void)devId;
|
|
}
|
|
else if (type == CERT_TYPE) {
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
DecodedCert* cert;
|
|
#else
|
|
DecodedCert cert[1];
|
|
#endif
|
|
#ifdef WOLF_PRIVATE_KEY_ID
|
|
int keyType = 0;
|
|
#endif
|
|
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
cert = (DecodedCert*)XMALLOC(sizeof(DecodedCert), heap,
|
|
DYNAMIC_TYPE_DCERT);
|
|
if (cert == NULL)
|
|
return MEMORY_E;
|
|
#endif
|
|
|
|
WOLFSSL_MSG("Checking cert signature type");
|
|
InitDecodedCert_ex(cert, der->buffer, der->length, heap, devId);
|
|
|
|
if (DecodeToKey(cert, 0) < 0) {
|
|
WOLFSSL_MSG("Decode to key failed");
|
|
FreeDecodedCert(cert);
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
XFREE(cert, heap, DYNAMIC_TYPE_DCERT);
|
|
#endif
|
|
return WOLFSSL_BAD_FILE;
|
|
}
|
|
#if defined(HAVE_RPK)
|
|
if (ssl) {
|
|
ssl->options.rpkState.isRPKLoaded = 0;
|
|
if (cert->isRPK) {
|
|
ssl->options.rpkState.isRPKLoaded = 1;
|
|
}
|
|
}
|
|
else if (ctx) {
|
|
ctx->rpkState.isRPKLoaded = 0;
|
|
if (cert->isRPK) {
|
|
ctx->rpkState.isRPKLoaded = 1;
|
|
}
|
|
}
|
|
#endif /* HAVE_RPK */
|
|
|
|
if (ssl) {
|
|
if (ssl->options.side == WOLFSSL_SERVER_END)
|
|
resetSuites = 1;
|
|
}
|
|
else if (ctx && ctx->method->side == WOLFSSL_SERVER_END) {
|
|
resetSuites = 1;
|
|
}
|
|
if (ssl && ssl->ctx->haveECDSAsig) {
|
|
WOLFSSL_MSG("SSL layer setting cert, CTX had ECDSA, turning off");
|
|
ssl->options.haveECDSAsig = 0; /* may turn back on next */
|
|
}
|
|
|
|
switch (cert->signatureOID) {
|
|
case CTC_SHAwECDSA:
|
|
case CTC_SHA256wECDSA:
|
|
case CTC_SHA384wECDSA:
|
|
case CTC_SHA512wECDSA:
|
|
case CTC_ED25519:
|
|
case CTC_ED448:
|
|
#if defined(WOLFSSL_SM2) && defined(WOLFSSL_SM3)
|
|
case CTC_SM3wSM2:
|
|
#endif
|
|
WOLFSSL_MSG("ECDSA/ED25519/ED448 cert signature");
|
|
if (ssl)
|
|
ssl->options.haveECDSAsig = 1;
|
|
else if (ctx)
|
|
ctx->haveECDSAsig = 1;
|
|
break;
|
|
case CTC_FALCON_LEVEL1:
|
|
case CTC_FALCON_LEVEL5:
|
|
WOLFSSL_MSG("Falcon cert signature");
|
|
if (ssl)
|
|
ssl->options.haveFalconSig = 1;
|
|
else if (ctx)
|
|
ctx->haveFalconSig = 1;
|
|
break;
|
|
case CTC_DILITHIUM_LEVEL2:
|
|
case CTC_DILITHIUM_LEVEL3:
|
|
case CTC_DILITHIUM_LEVEL5:
|
|
WOLFSSL_MSG("Dilithium cert signature");
|
|
if (ssl)
|
|
ssl->options.haveDilithiumSig = 1;
|
|
else if (ctx)
|
|
ctx->haveDilithiumSig = 1;
|
|
break;
|
|
default:
|
|
WOLFSSL_MSG("Not ECDSA cert signature");
|
|
break;
|
|
}
|
|
|
|
#if defined(HAVE_ECC) || defined(HAVE_ED25519) || defined(HAVE_ED448) || \
|
|
(defined(HAVE_PQC) && defined(HAVE_LIBOQS)) || !defined(NO_RSA)
|
|
if (ssl) {
|
|
#if defined(HAVE_ECC) || defined(HAVE_ED25519) || \
|
|
(defined(HAVE_CURVE448) && defined(HAVE_ED448))
|
|
ssl->pkCurveOID = cert->pkCurveOID;
|
|
#endif
|
|
#ifndef WC_STRICT_SIG
|
|
if (cert->keyOID == ECDSAk) {
|
|
ssl->options.haveECC = 1;
|
|
}
|
|
#ifndef NO_RSA
|
|
else if (cert->keyOID == RSAk) {
|
|
ssl->options.haveRSA = 1;
|
|
}
|
|
#ifdef WC_RSA_PSS
|
|
else if (cert->keyOID == RSAPSSk) {
|
|
ssl->options.haveRSA = 1;
|
|
}
|
|
#endif
|
|
#endif
|
|
#if defined(WOLFSSL_SM2) && defined(WOLFSSL_SM3)
|
|
else if (cert->keyOID == SM2k) {
|
|
ssl->options.haveECC = 1;
|
|
}
|
|
#endif
|
|
#ifdef HAVE_ED25519
|
|
else if (cert->keyOID == ED25519k) {
|
|
ssl->options.haveECC = 1;
|
|
}
|
|
#endif
|
|
#ifdef HAVE_ED448
|
|
else if (cert->keyOID == ED448k) {
|
|
ssl->options.haveECC = 1;
|
|
}
|
|
#endif
|
|
#ifdef HAVE_PQC
|
|
#ifdef HAVE_FALCON
|
|
else if (cert->keyOID == FALCON_LEVEL1k ||
|
|
cert->keyOID == FALCON_LEVEL5k) {
|
|
ssl->options.haveFalconSig = 1;
|
|
}
|
|
#endif /* HAVE_FALCON */
|
|
#ifdef HAVE_DILITHIUM
|
|
else if (cert->keyOID == DILITHIUM_LEVEL2k ||
|
|
cert->keyOID == DILITHIUM_LEVEL3k ||
|
|
cert->keyOID == DILITHIUM_LEVEL5k) {
|
|
ssl->options.haveDilithiumSig = 1;
|
|
}
|
|
#endif /* HAVE_DILITHIUM */
|
|
#endif /* HAVE_PQC */
|
|
#else
|
|
ssl->options.haveECC = ssl->options.haveECDSAsig;
|
|
#endif
|
|
}
|
|
else if (ctx) {
|
|
#if defined(HAVE_ECC) || defined(HAVE_ED25519) || defined(HAVE_ED448)
|
|
ctx->pkCurveOID = cert->pkCurveOID;
|
|
#endif
|
|
#ifndef WC_STRICT_SIG
|
|
if (cert->keyOID == ECDSAk) {
|
|
ctx->haveECC = 1;
|
|
}
|
|
#ifndef NO_RSA
|
|
else if (cert->keyOID == RSAk) {
|
|
ctx->haveRSA = 1;
|
|
}
|
|
#ifdef WC_RSA_PSS
|
|
else if (cert->keyOID == RSAPSSk) {
|
|
ctx->haveRSA = 1;
|
|
}
|
|
#endif
|
|
#endif
|
|
#if defined(WOLFSSL_SM2) && defined(WOLFSSL_SM3)
|
|
else if (cert->keyOID == SM2k) {
|
|
ctx->haveECC = 1;
|
|
}
|
|
#endif
|
|
#ifdef HAVE_ED25519
|
|
else if (cert->keyOID == ED25519k) {
|
|
ctx->haveECC = 1;
|
|
}
|
|
#endif
|
|
#ifdef HAVE_ED448
|
|
else if (cert->keyOID == ED448k) {
|
|
ctx->haveECC = 1;
|
|
}
|
|
#endif
|
|
#ifdef HAVE_PQC
|
|
#ifdef HAVE_FALCON
|
|
else if (cert->keyOID == FALCON_LEVEL1k ||
|
|
cert->keyOID == FALCON_LEVEL5k) {
|
|
ctx->haveFalconSig = 1;
|
|
}
|
|
#endif /* HAVE_FALCON */
|
|
#ifdef HAVE_DILITHIUM
|
|
else if (cert->keyOID == DILITHIUM_LEVEL2k ||
|
|
cert->keyOID == DILITHIUM_LEVEL3k ||
|
|
cert->keyOID == DILITHIUM_LEVEL5k) {
|
|
ctx->haveDilithiumSig = 1;
|
|
}
|
|
#endif /* HAVE_DILITHIUM */
|
|
#endif /* HAVE_PQC */
|
|
#else
|
|
ctx->haveECC = ctx->haveECDSAsig;
|
|
#endif
|
|
}
|
|
#endif
|
|
|
|
/* check key size of cert unless specified not to */
|
|
switch (cert->keyOID) {
|
|
#ifndef NO_RSA
|
|
#ifdef WC_RSA_PSS
|
|
case RSAPSSk:
|
|
#endif
|
|
case RSAk:
|
|
#ifdef WOLF_PRIVATE_KEY_ID
|
|
keyType = rsa_sa_algo;
|
|
#endif
|
|
/* Determine RSA key size by parsing public key */
|
|
idx = 0;
|
|
ret = wc_RsaPublicKeyDecode_ex(cert->publicKey, &idx,
|
|
cert->pubKeySize, NULL, (word32*)&keySz, NULL, NULL);
|
|
if (ret < 0)
|
|
break;
|
|
|
|
if (ssl && !ssl->options.verifyNone) {
|
|
if (ssl->options.minRsaKeySz < 0 ||
|
|
keySz < (int)ssl->options.minRsaKeySz ||
|
|
keySz > (RSA_MAX_SIZE / 8)) {
|
|
ret = RSA_KEY_SIZE_E;
|
|
WOLFSSL_MSG("Certificate RSA key size too small");
|
|
}
|
|
}
|
|
else if (ctx && !ctx->verifyNone) {
|
|
if (ctx->minRsaKeySz < 0 ||
|
|
keySz < (int)ctx->minRsaKeySz ||
|
|
keySz > (RSA_MAX_SIZE / 8)) {
|
|
ret = RSA_KEY_SIZE_E;
|
|
WOLFSSL_MSG("Certificate RSA key size too small");
|
|
}
|
|
}
|
|
break;
|
|
#endif /* !NO_RSA */
|
|
#ifdef HAVE_ECC
|
|
case ECDSAk:
|
|
#ifdef WOLF_PRIVATE_KEY_ID
|
|
keyType = ecc_dsa_sa_algo;
|
|
#endif
|
|
/* Determine ECC key size based on curve */
|
|
#ifdef WOLFSSL_CUSTOM_CURVES
|
|
if (cert->pkCurveOID == 0 && cert->pkCurveSize != 0) {
|
|
keySz = cert->pkCurveSize * 8;
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
keySz = wc_ecc_get_curve_size_from_id(
|
|
wc_ecc_get_oid(cert->pkCurveOID, NULL, NULL));
|
|
}
|
|
|
|
if (ssl && !ssl->options.verifyNone) {
|
|
if (ssl->options.minEccKeySz < 0 ||
|
|
keySz < (int)ssl->options.minEccKeySz) {
|
|
ret = ECC_KEY_SIZE_E;
|
|
WOLFSSL_MSG("Certificate ECC key size error");
|
|
}
|
|
}
|
|
else if (ctx && !ctx->verifyNone) {
|
|
if (ctx->minEccKeySz < 0 ||
|
|
keySz < (int)ctx->minEccKeySz) {
|
|
ret = ECC_KEY_SIZE_E;
|
|
WOLFSSL_MSG("Certificate ECC key size error");
|
|
}
|
|
}
|
|
break;
|
|
#endif /* HAVE_ECC */
|
|
#if defined(WOLFSSL_SM2) && defined(WOLFSSL_SM3)
|
|
case SM2k:
|
|
#ifdef WOLF_PRIVATE_KEY_ID
|
|
keyType = sm2_sa_algo;
|
|
#endif
|
|
/* Determine ECC key size based on curve */
|
|
keySz = wc_ecc_get_curve_size_from_id(
|
|
wc_ecc_get_oid(cert->pkCurveOID, NULL, NULL));
|
|
if (ssl && !ssl->options.verifyNone) {
|
|
if (ssl->options.minEccKeySz < 0 ||
|
|
keySz < (int)ssl->options.minEccKeySz) {
|
|
ret = ECC_KEY_SIZE_E;
|
|
WOLFSSL_MSG("Certificate Ed key size error");
|
|
}
|
|
}
|
|
else if (ctx && !ctx->verifyNone) {
|
|
if (ctx->minEccKeySz < 0 ||
|
|
keySz < (int)ctx->minEccKeySz) {
|
|
ret = ECC_KEY_SIZE_E;
|
|
WOLFSSL_MSG("Certificate ECC key size error");
|
|
}
|
|
}
|
|
break;
|
|
#endif /* HAVE_ED25519 */
|
|
#ifdef HAVE_ED25519
|
|
case ED25519k:
|
|
#ifdef WOLF_PRIVATE_KEY_ID
|
|
keyType = ed25519_sa_algo;
|
|
#endif
|
|
/* ED25519 is fixed key size */
|
|
keySz = ED25519_KEY_SIZE;
|
|
if (ssl && !ssl->options.verifyNone) {
|
|
if (ssl->options.minEccKeySz < 0 ||
|
|
keySz < (int)ssl->options.minEccKeySz) {
|
|
ret = ECC_KEY_SIZE_E;
|
|
WOLFSSL_MSG("Certificate Ed key size error");
|
|
}
|
|
}
|
|
else if (ctx && !ctx->verifyNone) {
|
|
if (ctx->minEccKeySz < 0 ||
|
|
keySz < (int)ctx->minEccKeySz) {
|
|
ret = ECC_KEY_SIZE_E;
|
|
WOLFSSL_MSG("Certificate ECC key size error");
|
|
}
|
|
}
|
|
break;
|
|
#endif /* HAVE_ED25519 */
|
|
#ifdef HAVE_ED448
|
|
case ED448k:
|
|
#ifdef WOLF_PRIVATE_KEY_ID
|
|
keyType = ed448_sa_algo;
|
|
#endif
|
|
/* ED448 is fixed key size */
|
|
keySz = ED448_KEY_SIZE;
|
|
if (ssl && !ssl->options.verifyNone) {
|
|
if (ssl->options.minEccKeySz < 0 ||
|
|
keySz < (int)ssl->options.minEccKeySz) {
|
|
ret = ECC_KEY_SIZE_E;
|
|
WOLFSSL_MSG("Certificate Ed key size error");
|
|
}
|
|
}
|
|
else if (ctx && !ctx->verifyNone) {
|
|
if (ctx->minEccKeySz < 0 ||
|
|
keySz < (int)ctx->minEccKeySz) {
|
|
ret = ECC_KEY_SIZE_E;
|
|
WOLFSSL_MSG("Certificate ECC key size error");
|
|
}
|
|
}
|
|
break;
|
|
#endif /* HAVE_ED448 */
|
|
#if defined(HAVE_PQC)
|
|
#if defined(HAVE_FALCON)
|
|
case FALCON_LEVEL1k:
|
|
case FALCON_LEVEL5k:
|
|
/* Falcon is fixed key size */
|
|
keySz = FALCON_MAX_KEY_SIZE;
|
|
if (ssl && !ssl->options.verifyNone) {
|
|
if (ssl->options.minFalconKeySz < 0 ||
|
|
keySz < (int)ssl->options.minFalconKeySz) {
|
|
ret = FALCON_KEY_SIZE_E;
|
|
WOLFSSL_MSG("Certificate Falcon key size error");
|
|
}
|
|
}
|
|
else if (ctx && !ctx->verifyNone) {
|
|
if (ctx->minFalconKeySz < 0 ||
|
|
keySz < (int)ctx->minFalconKeySz) {
|
|
ret = FALCON_KEY_SIZE_E;
|
|
WOLFSSL_MSG("Certificate Falcon key size error");
|
|
}
|
|
}
|
|
break;
|
|
#endif /* HAVE_FALCON */
|
|
#if defined(HAVE_DILITHIUM)
|
|
case DILITHIUM_LEVEL2k:
|
|
case DILITHIUM_LEVEL3k:
|
|
case DILITHIUM_LEVEL5k:
|
|
/* Dilithium is fixed key size */
|
|
keySz = DILITHIUM_MAX_KEY_SIZE;
|
|
if (ssl && !ssl->options.verifyNone) {
|
|
if (ssl->options.minDilithiumKeySz < 0 ||
|
|
keySz < (int)ssl->options.minDilithiumKeySz) {
|
|
ret = DILITHIUM_KEY_SIZE_E;
|
|
WOLFSSL_MSG("Certificate Dilithium key size error");
|
|
}
|
|
}
|
|
else if (ctx && !ctx->verifyNone) {
|
|
if (ctx->minDilithiumKeySz < 0 ||
|
|
keySz < (int)ctx->minDilithiumKeySz) {
|
|
ret = DILITHIUM_KEY_SIZE_E;
|
|
WOLFSSL_MSG("Certificate Dilithium key size error");
|
|
}
|
|
}
|
|
break;
|
|
#endif /* HAVE_DILITHIUM */
|
|
#endif /* HAVE_PQC */
|
|
|
|
default:
|
|
WOLFSSL_MSG("No key size check done on certificate");
|
|
break; /* do no check if not a case for the key */
|
|
}
|
|
|
|
#ifdef WOLF_PRIVATE_KEY_ID
|
|
if (ssl != NULL) {
|
|
ssl->buffers.keyType = (byte)keyType;
|
|
ssl->buffers.keySz = keySz;
|
|
}
|
|
else if (ctx != NULL) {
|
|
ctx->privateKeyType = (byte)keyType;
|
|
ctx->privateKeySz = keySz;
|
|
}
|
|
#endif
|
|
|
|
FreeDecodedCert(cert);
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
XFREE(cert, heap, DYNAMIC_TYPE_DCERT);
|
|
#endif
|
|
|
|
if (ret != 0) {
|
|
done = 1;
|
|
}
|
|
}
|
|
|
|
if (done == 1) {
|
|
#if !defined(NO_WOLFSSL_CM_VERIFY) && (!defined(NO_WOLFSSL_CLIENT) || \
|
|
!defined(WOLFSSL_NO_CLIENT_AUTH))
|
|
if ((type == CA_TYPE) || (type == CERT_TYPE)) {
|
|
/* Call to over-ride status */
|
|
if ((ctx != NULL) && (ctx->cm != NULL) &&
|
|
(ctx->cm->verifyCallback != NULL)) {
|
|
ret = CM_VerifyBuffer_ex(ctx->cm, buff,
|
|
sz, format, (ret == WOLFSSL_SUCCESS ? 0 : ret));
|
|
}
|
|
}
|
|
#endif /* NO_WOLFSSL_CM_VERIFY */
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
if (ssl && resetSuites) {
|
|
word16 havePSK = 0;
|
|
word16 haveRSA = 0;
|
|
|
|
#if defined(HAVE_SESSION_TICKET) || !defined(NO_PSK)
|
|
if (ssl->options.havePSK) {
|
|
havePSK = 1;
|
|
}
|
|
#endif
|
|
#ifndef NO_RSA
|
|
haveRSA = 1;
|
|
#endif
|
|
keySz = ssl->buffers.keySz;
|
|
|
|
if (AllocateSuites(ssl) != 0)
|
|
return WOLFSSL_FAILURE;
|
|
/* let's reset suites */
|
|
InitSuites(ssl->suites, ssl->version, keySz, haveRSA,
|
|
havePSK, ssl->options.haveDH, ssl->options.haveECDSAsig,
|
|
ssl->options.haveECC, TRUE, ssl->options.haveStaticECC,
|
|
ssl->options.haveFalconSig, ssl->options.haveDilithiumSig,
|
|
ssl->options.haveAnon, TRUE, ssl->options.side);
|
|
}
|
|
else if (ctx && resetSuites) {
|
|
word16 havePSK = 0;
|
|
word16 haveRSA = 0;
|
|
|
|
#if defined(HAVE_SESSION_TICKET) || !defined(NO_PSK)
|
|
if (ctx->havePSK) {
|
|
havePSK = 1;
|
|
}
|
|
#endif
|
|
#ifndef NO_RSA
|
|
haveRSA = 1;
|
|
#endif
|
|
keySz = ctx->privateKeySz;
|
|
|
|
if (AllocateCtxSuites(ctx) != 0)
|
|
return WOLFSSL_FAILURE;
|
|
/* let's reset suites */
|
|
InitSuites(ctx->suites, ctx->method->version, keySz, haveRSA,
|
|
havePSK, ctx->haveDH, ctx->haveECDSAsig,
|
|
ctx->haveECC, TRUE, ctx->haveStaticECC,
|
|
ctx->haveFalconSig, ctx->haveDilithiumSig,
|
|
#ifdef HAVE_ANON
|
|
ctx->haveAnon,
|
|
#else
|
|
FALSE,
|
|
#endif
|
|
TRUE, ctx->method->side);
|
|
}
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
|
|
/* CA PEM file for verification, may have multiple/chain certs to process */
|
|
static int ProcessChainBuffer(WOLFSSL_CTX* ctx, const unsigned char* buff,
|
|
long sz, int format, int type, WOLFSSL* ssl, int verify)
|
|
{
|
|
long used = 0;
|
|
int ret = 0;
|
|
int gotOne = 0;
|
|
|
|
WOLFSSL_MSG("Processing CA PEM file");
|
|
while (used < sz) {
|
|
long consumed = 0;
|
|
|
|
ret = ProcessBuffer(ctx, buff + used, sz - used, format, type, ssl,
|
|
&consumed, 0, verify);
|
|
|
|
if (ret == MEMORY_E) {
|
|
return ret;
|
|
}
|
|
else if (ret < 0) {
|
|
#if defined(WOLFSSL_WPAS) && defined(HAVE_CRL)
|
|
DerBuffer* der = NULL;
|
|
EncryptedInfo info;
|
|
|
|
WOLFSSL_MSG("Trying a CRL");
|
|
if (PemToDer(buff + used, sz - used, CRL_TYPE, &der, NULL, &info,
|
|
NULL) == 0) {
|
|
WOLFSSL_MSG(" Processed a CRL");
|
|
wolfSSL_CertManagerLoadCRLBuffer(ctx->cm, der->buffer,
|
|
der->length, WOLFSSL_FILETYPE_ASN1);
|
|
FreeDer(&der);
|
|
used += info.consumed;
|
|
continue;
|
|
}
|
|
#endif
|
|
|
|
if (consumed > 0) { /* Made progress in file */
|
|
WOLFSSL_ERROR(ret);
|
|
WOLFSSL_MSG("CA Parse failed, with progress in file.");
|
|
WOLFSSL_MSG("Search for other certs in file");
|
|
}
|
|
else {
|
|
WOLFSSL_MSG("CA Parse failed, no progress in file.");
|
|
WOLFSSL_MSG("Do not continue search for other certs in file");
|
|
break;
|
|
}
|
|
}
|
|
else {
|
|
WOLFSSL_MSG(" Processed a CA");
|
|
gotOne = 1;
|
|
}
|
|
used += consumed;
|
|
}
|
|
|
|
if (gotOne) {
|
|
WOLFSSL_MSG("Processed at least one valid CA. Other stuff OK");
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
|
|
#ifdef HAVE_CRL
|
|
|
|
int wolfSSL_CTX_LoadCRLBuffer(WOLFSSL_CTX* ctx, const unsigned char* buff,
|
|
long sz, int type)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_LoadCRLBuffer");
|
|
|
|
if (ctx == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
return wolfSSL_CertManagerLoadCRLBuffer(ctx->cm, buff, sz, type);
|
|
}
|
|
|
|
|
|
int wolfSSL_LoadCRLBuffer(WOLFSSL* ssl, const unsigned char* buff,
|
|
long sz, int type)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_LoadCRLBuffer");
|
|
|
|
if (ssl == NULL || ssl->ctx == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
SSL_CM_WARNING(ssl);
|
|
return wolfSSL_CertManagerLoadCRLBuffer(SSL_CM(ssl), buff, sz, type);
|
|
}
|
|
|
|
#endif /* HAVE_CRL */
|
|
|
|
#ifdef HAVE_OCSP
|
|
int wolfSSL_EnableOCSP(WOLFSSL* ssl, int options)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_EnableOCSP");
|
|
if (ssl) {
|
|
SSL_CM_WARNING(ssl);
|
|
return wolfSSL_CertManagerEnableOCSP(SSL_CM(ssl), options);
|
|
}
|
|
else
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
int wolfSSL_DisableOCSP(WOLFSSL* ssl)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_DisableOCSP");
|
|
if (ssl) {
|
|
SSL_CM_WARNING(ssl);
|
|
return wolfSSL_CertManagerDisableOCSP(SSL_CM(ssl));
|
|
}
|
|
else
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
|
|
int wolfSSL_EnableOCSPStapling(WOLFSSL* ssl)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_EnableOCSPStapling");
|
|
if (ssl) {
|
|
SSL_CM_WARNING(ssl);
|
|
return wolfSSL_CertManagerEnableOCSPStapling(SSL_CM(ssl));
|
|
}
|
|
else
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
int wolfSSL_DisableOCSPStapling(WOLFSSL* ssl)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_DisableOCSPStapling");
|
|
if (ssl) {
|
|
SSL_CM_WARNING(ssl);
|
|
return wolfSSL_CertManagerDisableOCSPStapling(SSL_CM(ssl));
|
|
}
|
|
else
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
int wolfSSL_SetOCSP_OverrideURL(WOLFSSL* ssl, const char* url)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_SetOCSP_OverrideURL");
|
|
if (ssl) {
|
|
SSL_CM_WARNING(ssl);
|
|
return wolfSSL_CertManagerSetOCSPOverrideURL(SSL_CM(ssl), url);
|
|
}
|
|
else
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
|
|
int wolfSSL_SetOCSP_Cb(WOLFSSL* ssl,
|
|
CbOCSPIO ioCb, CbOCSPRespFree respFreeCb, void* ioCbCtx)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_SetOCSP_Cb");
|
|
if (ssl) {
|
|
SSL_CM_WARNING(ssl);
|
|
ssl->ocspIOCtx = ioCbCtx; /* use SSL specific ioCbCtx */
|
|
return wolfSSL_CertManagerSetOCSP_Cb(SSL_CM(ssl),
|
|
ioCb, respFreeCb, NULL);
|
|
}
|
|
else
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
|
|
int wolfSSL_CTX_EnableOCSP(WOLFSSL_CTX* ctx, int options)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_EnableOCSP");
|
|
if (ctx)
|
|
return wolfSSL_CertManagerEnableOCSP(ctx->cm, options);
|
|
else
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
|
|
int wolfSSL_CTX_DisableOCSP(WOLFSSL_CTX* ctx)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_DisableOCSP");
|
|
if (ctx)
|
|
return wolfSSL_CertManagerDisableOCSP(ctx->cm);
|
|
else
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
|
|
int wolfSSL_CTX_SetOCSP_OverrideURL(WOLFSSL_CTX* ctx, const char* url)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_SetOCSP_OverrideURL");
|
|
if (ctx)
|
|
return wolfSSL_CertManagerSetOCSPOverrideURL(ctx->cm, url);
|
|
else
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
|
|
int wolfSSL_CTX_SetOCSP_Cb(WOLFSSL_CTX* ctx, CbOCSPIO ioCb,
|
|
CbOCSPRespFree respFreeCb, void* ioCbCtx)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_SetOCSP_Cb");
|
|
if (ctx)
|
|
return wolfSSL_CertManagerSetOCSP_Cb(ctx->cm, ioCb,
|
|
respFreeCb, ioCbCtx);
|
|
else
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
#if defined(HAVE_CERTIFICATE_STATUS_REQUEST) \
|
|
|| defined(HAVE_CERTIFICATE_STATUS_REQUEST_V2)
|
|
int wolfSSL_CTX_EnableOCSPStapling(WOLFSSL_CTX* ctx)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_EnableOCSPStapling");
|
|
if (ctx)
|
|
return wolfSSL_CertManagerEnableOCSPStapling(ctx->cm);
|
|
else
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
int wolfSSL_CTX_DisableOCSPStapling(WOLFSSL_CTX* ctx)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_DisableOCSPStapling");
|
|
if (ctx)
|
|
return wolfSSL_CertManagerDisableOCSPStapling(ctx->cm);
|
|
else
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
int wolfSSL_CTX_EnableOCSPMustStaple(WOLFSSL_CTX* ctx)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_EnableOCSPMustStaple");
|
|
if (ctx)
|
|
return wolfSSL_CertManagerEnableOCSPMustStaple(ctx->cm);
|
|
else
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
int wolfSSL_CTX_DisableOCSPMustStaple(WOLFSSL_CTX* ctx)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_DisableOCSPMustStaple");
|
|
if (ctx)
|
|
return wolfSSL_CertManagerDisableOCSPMustStaple(ctx->cm);
|
|
else
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
#endif /* HAVE_CERTIFICATE_STATUS_REQUEST || HAVE_CERTIFICATE_STATUS_REQUEST_V2 */
|
|
|
|
#endif /* HAVE_OCSP */
|
|
|
|
/* macro to get verify settings for AddCA */
|
|
#define GET_VERIFY_SETTING_CTX(ctx) \
|
|
((ctx) && (ctx)->verifyNone ? NO_VERIFY : VERIFY)
|
|
#define GET_VERIFY_SETTING_SSL(ssl) \
|
|
((ssl)->options.verifyNone ? NO_VERIFY : VERIFY)
|
|
|
|
#ifndef NO_FILESYSTEM
|
|
|
|
/* process a file with name fname into ctx of format and type
|
|
userChain specifies a user certificate chain to pass during handshake */
|
|
int ProcessFile(WOLFSSL_CTX* ctx, const char* fname, int format, int type,
|
|
WOLFSSL* ssl, int userChain, WOLFSSL_CRL* crl, int verify)
|
|
{
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
byte staticBuffer[1]; /* force heap usage */
|
|
#else
|
|
byte staticBuffer[FILE_BUFFER_SIZE];
|
|
#endif
|
|
byte* myBuffer = staticBuffer;
|
|
int dynamic = 0;
|
|
int ret;
|
|
long sz = 0;
|
|
XFILE file;
|
|
void* heapHint = wolfSSL_CTX_GetHeap(ctx, ssl);
|
|
#ifndef NO_CODING
|
|
const char* header = NULL;
|
|
const char* footer = NULL;
|
|
#endif
|
|
|
|
(void)crl;
|
|
(void)heapHint;
|
|
|
|
if (fname == NULL) return WOLFSSL_BAD_FILE;
|
|
|
|
file = XFOPEN(fname, "rb");
|
|
if (file == XBADFILE) return WOLFSSL_BAD_FILE;
|
|
if (XFSEEK(file, 0, XSEEK_END) != 0) {
|
|
XFCLOSE(file);
|
|
return WOLFSSL_BAD_FILE;
|
|
}
|
|
sz = XFTELL(file);
|
|
if (XFSEEK(file, 0, XSEEK_SET) != 0) {
|
|
XFCLOSE(file);
|
|
return WOLFSSL_BAD_FILE;
|
|
}
|
|
|
|
if (sz > MAX_WOLFSSL_FILE_SIZE || sz <= 0) {
|
|
WOLFSSL_MSG("ProcessFile file size error");
|
|
XFCLOSE(file);
|
|
return WOLFSSL_BAD_FILE;
|
|
}
|
|
|
|
if (sz > (long)sizeof(staticBuffer)) {
|
|
WOLFSSL_MSG("Getting dynamic buffer");
|
|
myBuffer = (byte*)XMALLOC(sz, heapHint, DYNAMIC_TYPE_FILE);
|
|
if (myBuffer == NULL) {
|
|
XFCLOSE(file);
|
|
return WOLFSSL_BAD_FILE;
|
|
}
|
|
dynamic = 1;
|
|
}
|
|
|
|
if ((size_t)XFREAD(myBuffer, 1, sz, file) != (size_t)sz)
|
|
ret = WOLFSSL_BAD_FILE;
|
|
else {
|
|
/* Try to detect type by parsing cert header and footer */
|
|
if (type == DETECT_CERT_TYPE) {
|
|
#ifndef NO_CODING
|
|
if (wc_PemGetHeaderFooter(CA_TYPE, &header, &footer) == 0 &&
|
|
(XSTRNSTR((char*)myBuffer, header, (int)sz) != NULL)) {
|
|
type = CA_TYPE;
|
|
}
|
|
#ifdef HAVE_CRL
|
|
else if (wc_PemGetHeaderFooter(CRL_TYPE, &header, &footer) == 0 &&
|
|
(XSTRNSTR((char*)myBuffer, header, (int)sz) != NULL)) {
|
|
type = CRL_TYPE;
|
|
}
|
|
#endif
|
|
else if (wc_PemGetHeaderFooter(CERT_TYPE, &header, &footer) == 0 &&
|
|
(XSTRNSTR((char*)myBuffer, header, (int)sz) != NULL)) {
|
|
type = CERT_TYPE;
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
WOLFSSL_MSG("Failed to detect certificate type");
|
|
if (dynamic)
|
|
XFREE(myBuffer, heapHint, DYNAMIC_TYPE_FILE);
|
|
XFCLOSE(file);
|
|
return WOLFSSL_BAD_CERTTYPE;
|
|
}
|
|
}
|
|
if ((type == CA_TYPE || type == TRUSTED_PEER_TYPE)
|
|
&& format == WOLFSSL_FILETYPE_PEM) {
|
|
ret = ProcessChainBuffer(ctx, myBuffer, sz, format, type, ssl,
|
|
verify);
|
|
}
|
|
#ifdef HAVE_CRL
|
|
else if (type == CRL_TYPE)
|
|
ret = BufferLoadCRL(crl, myBuffer, sz, format, verify);
|
|
#endif
|
|
else
|
|
ret = ProcessBuffer(ctx, myBuffer, sz, format, type, ssl, NULL,
|
|
userChain, verify);
|
|
}
|
|
|
|
XFCLOSE(file);
|
|
if (dynamic)
|
|
XFREE(myBuffer, heapHint, DYNAMIC_TYPE_FILE);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/* loads file then loads each file in path, no c_rehash */
|
|
int wolfSSL_CTX_load_verify_locations_ex(WOLFSSL_CTX* ctx, const char* file,
|
|
const char* path, word32 flags)
|
|
{
|
|
int ret = WOLFSSL_SUCCESS;
|
|
#ifndef NO_WOLFSSL_DIR
|
|
int successCount = 0;
|
|
#endif
|
|
int verify;
|
|
|
|
WOLFSSL_MSG("wolfSSL_CTX_load_verify_locations_ex");
|
|
|
|
if (ctx == NULL || (file == NULL && path == NULL)) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
verify = GET_VERIFY_SETTING_CTX(ctx);
|
|
if (flags & WOLFSSL_LOAD_FLAG_DATE_ERR_OKAY)
|
|
verify = VERIFY_SKIP_DATE;
|
|
|
|
if (file) {
|
|
ret = ProcessFile(ctx, file, WOLFSSL_FILETYPE_PEM, CA_TYPE, NULL, 0,
|
|
NULL, verify);
|
|
#ifndef NO_WOLFSSL_DIR
|
|
if (ret == WOLFSSL_SUCCESS)
|
|
successCount++;
|
|
#endif
|
|
#if defined(WOLFSSL_TRUST_PEER_CERT) && defined(OPENSSL_COMPATIBLE_DEFAULTS)
|
|
ret = wolfSSL_CTX_trust_peer_cert(ctx, file, WOLFSSL_FILETYPE_PEM);
|
|
if (ret != WOLFSSL_SUCCESS) {
|
|
WOLFSSL_MSG("wolfSSL_CTX_trust_peer_cert error");
|
|
}
|
|
#endif
|
|
}
|
|
|
|
if (ret == WOLFSSL_SUCCESS && path) {
|
|
#ifndef NO_WOLFSSL_DIR
|
|
char* name = NULL;
|
|
int fileRet;
|
|
int failCount = 0;
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
ReadDirCtx* readCtx;
|
|
readCtx = (ReadDirCtx*)XMALLOC(sizeof(ReadDirCtx), ctx->heap,
|
|
DYNAMIC_TYPE_DIRCTX);
|
|
if (readCtx == NULL)
|
|
return MEMORY_E;
|
|
#else
|
|
ReadDirCtx readCtx[1];
|
|
#endif
|
|
|
|
/* try to load each regular file in path */
|
|
fileRet = wc_ReadDirFirst(readCtx, path, &name);
|
|
while (fileRet == 0 && name) {
|
|
WOLFSSL_MSG(name); /* log file name */
|
|
ret = ProcessFile(ctx, name, WOLFSSL_FILETYPE_PEM, CA_TYPE,
|
|
NULL, 0, NULL, verify);
|
|
if (ret != WOLFSSL_SUCCESS) {
|
|
/* handle flags for ignoring errors, skipping expired certs or
|
|
by PEM certificate header error */
|
|
if ( (flags & WOLFSSL_LOAD_FLAG_IGNORE_ERR) ||
|
|
((flags & WOLFSSL_LOAD_FLAG_PEM_CA_ONLY) &&
|
|
(ret == ASN_NO_PEM_HEADER))) {
|
|
/* Do not fail here if a certificate fails to load,
|
|
continue to next file */
|
|
unsigned long err = 0;
|
|
CLEAR_ASN_NO_PEM_HEADER_ERROR(err);
|
|
#if defined(WOLFSSL_QT)
|
|
ret = WOLFSSL_SUCCESS;
|
|
#endif
|
|
}
|
|
else {
|
|
WOLFSSL_ERROR(ret);
|
|
WOLFSSL_MSG("Load CA file failed, continuing");
|
|
failCount++;
|
|
}
|
|
}
|
|
else {
|
|
#if defined(WOLFSSL_TRUST_PEER_CERT) && defined(OPENSSL_COMPATIBLE_DEFAULTS)
|
|
ret = wolfSSL_CTX_trust_peer_cert(ctx, file, WOLFSSL_FILETYPE_PEM);
|
|
if (ret != WOLFSSL_SUCCESS) {
|
|
WOLFSSL_MSG("wolfSSL_CTX_trust_peer_cert error. Ignoring"
|
|
"this error.");
|
|
}
|
|
#endif
|
|
successCount++;
|
|
}
|
|
fileRet = wc_ReadDirNext(readCtx, path, &name);
|
|
}
|
|
wc_ReadDirClose(readCtx);
|
|
|
|
/* pass directory read failure to response code */
|
|
if (fileRet != WC_READDIR_NOFILE) {
|
|
ret = fileRet;
|
|
#if defined(WOLFSSL_QT) || defined(WOLFSSL_IGNORE_BAD_CERT_PATH)
|
|
if (ret == BAD_PATH_ERROR &&
|
|
flags & WOLFSSL_LOAD_FLAG_IGNORE_BAD_PATH_ERR) {
|
|
/* QSslSocket always loads certs in system folder
|
|
* when it is initialized.
|
|
* Compliant with OpenSSL when flag sets.
|
|
*/
|
|
ret = WOLFSSL_SUCCESS;
|
|
}
|
|
else {
|
|
/* qssl socket wants to know errors. */
|
|
WOLFSSL_ERROR(ret);
|
|
}
|
|
#endif
|
|
}
|
|
/* report failure if no files were loaded or there were failures */
|
|
else if (successCount == 0 || failCount > 0) {
|
|
/* use existing error code if exists */
|
|
#if defined(WOLFSSL_QT)
|
|
/* compliant with OpenSSL when flag sets*/
|
|
if (!(flags & WOLFSSL_LOAD_FLAG_IGNORE_ZEROFILE))
|
|
#endif
|
|
{
|
|
ret = WOLFSSL_FAILURE;
|
|
}
|
|
}
|
|
else {
|
|
ret = WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
XFREE(readCtx, ctx->heap, DYNAMIC_TYPE_DIRCTX);
|
|
#endif
|
|
#else
|
|
ret = NOT_COMPILED_IN;
|
|
(void)flags;
|
|
#endif
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
WOLFSSL_ABI
|
|
int wolfSSL_CTX_load_verify_locations(WOLFSSL_CTX* ctx, const char* file,
|
|
const char* path)
|
|
{
|
|
int ret = wolfSSL_CTX_load_verify_locations_ex(ctx, file, path,
|
|
WOLFSSL_LOAD_VERIFY_DEFAULT_FLAGS);
|
|
|
|
return WS_RETURN_CODE(ret,WOLFSSL_FAILURE);
|
|
}
|
|
|
|
#ifdef WOLFSSL_SYS_CA_CERTS
|
|
|
|
#ifdef USE_WINDOWS_API
|
|
|
|
static int LoadSystemCaCertsWindows(WOLFSSL_CTX* ctx, byte* loaded)
|
|
{
|
|
int ret = WOLFSSL_SUCCESS;
|
|
word32 i;
|
|
HANDLE handle = NULL;
|
|
PCCERT_CONTEXT certCtx = NULL;
|
|
LPCSTR storeNames[2] = {"ROOT", "CA"};
|
|
HCRYPTPROV_LEGACY hProv = (HCRYPTPROV_LEGACY)NULL;
|
|
|
|
if (ctx == NULL || loaded == NULL) {
|
|
ret = WOLFSSL_FAILURE;
|
|
}
|
|
|
|
for (i = 0; ret == WOLFSSL_SUCCESS &&
|
|
i < sizeof(storeNames)/sizeof(*storeNames); ++i) {
|
|
handle = CertOpenSystemStoreA(hProv, storeNames[i]);
|
|
if (handle != NULL) {
|
|
while ((certCtx = CertEnumCertificatesInStore(handle, certCtx))
|
|
!= NULL) {
|
|
if (certCtx->dwCertEncodingType == X509_ASN_ENCODING) {
|
|
if (ProcessBuffer(ctx, certCtx->pbCertEncoded,
|
|
certCtx->cbCertEncoded, WOLFSSL_FILETYPE_ASN1,
|
|
CA_TYPE, NULL, NULL, 0,
|
|
GET_VERIFY_SETTING_CTX(ctx)) == WOLFSSL_SUCCESS) {
|
|
/*
|
|
* Set "loaded" as long as we've loaded one CA
|
|
* cert.
|
|
*/
|
|
*loaded = 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
WOLFSSL_MSG_EX("Failed to open cert store %s.", storeNames[i]);
|
|
}
|
|
|
|
if (handle != NULL && !CertCloseStore(handle, 0)) {
|
|
WOLFSSL_MSG_EX("Failed to close cert store %s.", storeNames[i]);
|
|
ret = WOLFSSL_FAILURE;
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
#elif defined(__APPLE__)
|
|
|
|
#if defined(HAVE_SECURITY_SECTRUSTSETTINGS_H) \
|
|
&& !defined(WOLFSSL_APPLE_NATIVE_CERT_VALIDATION)
|
|
/*
|
|
* Manually obtains certificates from the system trust store and loads them
|
|
* directly into wolfSSL "the old way".
|
|
*
|
|
* As of MacOS 14.0 we are still able to use this method to access system
|
|
* certificates. Accessibility of this API is indicated by the presence of the
|
|
* Security/SecTrustSettings.h header. In the likely event that Apple removes
|
|
* access to this API on Macs, this function should be removed and the
|
|
* DoAppleNativeCertValidation() routine should be used for all devices.
|
|
*/
|
|
static int LoadSystemCaCertsMac(WOLFSSL_CTX* ctx, byte* loaded)
|
|
{
|
|
int ret = WOLFSSL_SUCCESS;
|
|
word32 i;
|
|
const unsigned int trustDomains[] = {
|
|
kSecTrustSettingsDomainUser,
|
|
kSecTrustSettingsDomainAdmin,
|
|
kSecTrustSettingsDomainSystem
|
|
};
|
|
CFArrayRef certs;
|
|
OSStatus stat;
|
|
CFIndex numCerts;
|
|
CFDataRef der;
|
|
CFIndex j;
|
|
|
|
if (ctx == NULL || loaded == NULL) {
|
|
ret = WOLFSSL_FAILURE;
|
|
}
|
|
|
|
for (i = 0; ret == WOLFSSL_SUCCESS &&
|
|
i < sizeof(trustDomains)/sizeof(*trustDomains); ++i) {
|
|
stat = SecTrustSettingsCopyCertificates(
|
|
(SecTrustSettingsDomain)trustDomains[i], &certs);
|
|
if (stat == errSecSuccess) {
|
|
numCerts = CFArrayGetCount(certs);
|
|
for (j = 0; j < numCerts; ++j) {
|
|
der = SecCertificateCopyData((SecCertificateRef)
|
|
CFArrayGetValueAtIndex(certs, j));
|
|
if (der != NULL) {
|
|
if (ProcessBuffer(ctx, CFDataGetBytePtr(der),
|
|
CFDataGetLength(der), WOLFSSL_FILETYPE_ASN1,
|
|
CA_TYPE, NULL, NULL, 0,
|
|
GET_VERIFY_SETTING_CTX(ctx)) == WOLFSSL_SUCCESS) {
|
|
/*
|
|
* Set "loaded" as long as we've loaded one CA
|
|
* cert.
|
|
*/
|
|
*loaded = 1;
|
|
}
|
|
|
|
CFRelease(der);
|
|
}
|
|
}
|
|
|
|
CFRelease(certs);
|
|
}
|
|
else if (stat == errSecNoTrustSettings) {
|
|
WOLFSSL_MSG_EX("No trust settings for domain %d, moving to next "
|
|
"domain.", trustDomains[i]);
|
|
}
|
|
else {
|
|
WOLFSSL_MSG_EX("SecTrustSettingsCopyCertificates failed with"
|
|
" status %d.", stat);
|
|
ret = WOLFSSL_FAILURE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
#endif /* defined(HAVE_SECURITY_SECTRUSTSETTINGS_H) */
|
|
|
|
#else
|
|
|
|
/* Potential system CA certs directories on Linux/Unix distros. */
|
|
static const char* systemCaDirs[] = {
|
|
#if defined(__ANDROID__) || defined(ANDROID)
|
|
"/system/etc/security/cacerts" /* Android */
|
|
#else
|
|
"/etc/ssl/certs", /* Debian, Ubuntu, Gentoo, others */
|
|
"/etc/pki/ca-trust/source/anchors", /* Fedora, RHEL */
|
|
"/etc/pki/tls/certs" /* Older RHEL */
|
|
#endif
|
|
};
|
|
|
|
const char** wolfSSL_get_system_CA_dirs(word32* num)
|
|
{
|
|
const char** ret;
|
|
|
|
if (num == NULL) {
|
|
ret = NULL;
|
|
}
|
|
else {
|
|
ret = systemCaDirs;
|
|
*num = sizeof(systemCaDirs)/sizeof(*systemCaDirs);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int LoadSystemCaCertsNix(WOLFSSL_CTX* ctx, byte* loaded) {
|
|
int ret = WOLFSSL_SUCCESS;
|
|
word32 i;
|
|
|
|
if (ctx == NULL || loaded == NULL) {
|
|
ret = WOLFSSL_FAILURE;
|
|
}
|
|
|
|
for (i = 0; ret == WOLFSSL_SUCCESS &&
|
|
i < sizeof(systemCaDirs)/sizeof(*systemCaDirs); ++i) {
|
|
WOLFSSL_MSG_EX("Attempting to load system CA certs from %s.",
|
|
systemCaDirs[i]);
|
|
/*
|
|
* We want to keep trying to load more CAs even if one cert in
|
|
* the directory is bad and can't be used (e.g. if one is expired),
|
|
* so we use WOLFSSL_LOAD_FLAG_IGNORE_ERR.
|
|
*/
|
|
if (wolfSSL_CTX_load_verify_locations_ex(ctx, NULL, systemCaDirs[i],
|
|
WOLFSSL_LOAD_FLAG_IGNORE_ERR) != WOLFSSL_SUCCESS) {
|
|
WOLFSSL_MSG_EX("Failed to load CA certs from %s, trying "
|
|
"next possible location.", systemCaDirs[i]);
|
|
}
|
|
else {
|
|
WOLFSSL_MSG_EX("Loaded CA certs from %s.",
|
|
systemCaDirs[i]);
|
|
*loaded = 1;
|
|
/* Stop searching after we've loaded one directory. */
|
|
break;
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
#endif
|
|
|
|
int wolfSSL_CTX_load_system_CA_certs(WOLFSSL_CTX* ctx)
|
|
{
|
|
int ret;
|
|
byte loaded = 0;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_CTX_load_system_CA_certs");
|
|
|
|
#ifdef USE_WINDOWS_API
|
|
|
|
ret = LoadSystemCaCertsWindows(ctx, &loaded);
|
|
|
|
#elif defined(__APPLE__)
|
|
|
|
#if defined(HAVE_SECURITY_SECTRUSTSETTINGS_H) \
|
|
&& !defined(WOLFSSL_APPLE_NATIVE_CERT_VALIDATION)
|
|
/* As of MacOS 14.0 we are still able to access system certificates and
|
|
* load them manually into wolfSSL "the old way". Accessibility of this API
|
|
* is indicated by the presence of the Security/SecTrustSettings.h header */
|
|
ret = LoadSystemCaCertsMac(ctx, &loaded);
|
|
#elif defined(WOLFSSL_APPLE_NATIVE_CERT_VALIDATION)
|
|
/* For other Apple devices, Apple has removed the ability to obtain
|
|
* certificates from the trust store, so we can't use wolfSSL's built-in
|
|
* certificate validation mechanisms anymore. We instead must call into the
|
|
* Security Framework APIs to authenticate peer certificates when received.
|
|
* (see src/internal.c:DoAppleNativeCertValidation()).
|
|
* Thus, there is no CA "loading" required, but to keep behavior consistent
|
|
* with the current API (not using system CA certs unless this function has
|
|
* been called), we simply set a flag indicating that the new apple trust
|
|
* verification routine should be used later */
|
|
ctx->doAppleNativeCertValidationFlag = 1;
|
|
ret = WOLFSSL_SUCCESS;
|
|
loaded = 1;
|
|
|
|
#if FIPS_VERSION_GE(2,0) /* Gate back to cert 3389 FIPS modules */
|
|
#warning "Cryptographic operations may occur outside the FIPS module boundary" \
|
|
"Please review FIPS claims for cryptography on this Apple device"
|
|
#endif /* FIPS_VERSION_GE(2,0) */
|
|
|
|
#else
|
|
/* HAVE_SECURITY_SECXXX_H macros are set by autotools or CMake when searching
|
|
* system for the required SDK headers. If building with user_settings.h, you
|
|
* will need to manually define WOLFSSL_APPLE_NATIVE_CERT_VALIDATION
|
|
* and ensure the appropriate Security.framework headers and libraries are
|
|
* visible to your compiler */
|
|
#error "WOLFSSL_SYS_CA_CERTS on Apple devices requires Security.framework" \
|
|
" header files to be detected, or a manual override with" \
|
|
" WOLFSSL_APPLE_NATIVE_CERT_VALIDATION"
|
|
#endif
|
|
|
|
#else
|
|
|
|
ret = LoadSystemCaCertsNix(ctx, &loaded);
|
|
|
|
#endif
|
|
|
|
if (ret == WOLFSSL_SUCCESS && !loaded) {
|
|
ret = WOLFSSL_BAD_PATH;
|
|
}
|
|
|
|
WOLFSSL_LEAVE("wolfSSL_CTX_load_system_CA_certs", ret);
|
|
|
|
return ret;
|
|
}
|
|
|
|
#endif /* WOLFSSL_SYS_CA_CERTS */
|
|
|
|
#ifdef WOLFSSL_TRUST_PEER_CERT
|
|
/* Used to specify a peer cert to match when connecting
|
|
ctx : the ctx structure to load in peer cert
|
|
file: the string name of cert file
|
|
type: type of format such as PEM/DER
|
|
*/
|
|
int wolfSSL_CTX_trust_peer_cert(WOLFSSL_CTX* ctx, const char* file, int type)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_trust_peer_cert");
|
|
|
|
if (ctx == NULL || file == NULL) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
return ProcessFile(ctx, file, type, TRUSTED_PEER_TYPE, NULL, 0, NULL,
|
|
GET_VERIFY_SETTING_CTX(ctx));
|
|
}
|
|
|
|
int wolfSSL_trust_peer_cert(WOLFSSL* ssl, const char* file, int type)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_trust_peer_cert");
|
|
|
|
if (ssl == NULL || file == NULL) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
return ProcessFile(NULL, file, type, TRUSTED_PEER_TYPE, ssl, 0, NULL,
|
|
GET_VERIFY_SETTING_SSL(ssl));
|
|
}
|
|
#endif /* WOLFSSL_TRUST_PEER_CERT */
|
|
|
|
#endif /* NO_FILESYSTEM */
|
|
|
|
#ifdef HAVE_CRL
|
|
|
|
int wolfSSL_EnableCRL(WOLFSSL* ssl, int options)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_EnableCRL");
|
|
if (ssl) {
|
|
SSL_CM_WARNING(ssl);
|
|
return wolfSSL_CertManagerEnableCRL(SSL_CM(ssl), options);
|
|
}
|
|
else
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
|
|
int wolfSSL_DisableCRL(WOLFSSL* ssl)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_DisableCRL");
|
|
if (ssl) {
|
|
SSL_CM_WARNING(ssl);
|
|
return wolfSSL_CertManagerDisableCRL(SSL_CM(ssl));
|
|
}
|
|
else
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
#ifndef NO_FILESYSTEM
|
|
int wolfSSL_LoadCRL(WOLFSSL* ssl, const char* path, int type, int monitor)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_LoadCRL");
|
|
if (ssl) {
|
|
SSL_CM_WARNING(ssl);
|
|
return wolfSSL_CertManagerLoadCRL(SSL_CM(ssl), path, type, monitor);
|
|
}
|
|
else
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
int wolfSSL_LoadCRLFile(WOLFSSL* ssl, const char* file, int type)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_LoadCRLFile");
|
|
if (ssl) {
|
|
SSL_CM_WARNING(ssl);
|
|
return wolfSSL_CertManagerLoadCRLFile(SSL_CM(ssl), file, type);
|
|
}
|
|
else
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
#endif
|
|
|
|
|
|
int wolfSSL_SetCRL_Cb(WOLFSSL* ssl, CbMissingCRL cb)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_SetCRL_Cb");
|
|
if (ssl) {
|
|
SSL_CM_WARNING(ssl);
|
|
return wolfSSL_CertManagerSetCRL_Cb(SSL_CM(ssl), cb);
|
|
}
|
|
else
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
#ifdef HAVE_CRL_IO
|
|
int wolfSSL_SetCRL_IOCb(WOLFSSL* ssl, CbCrlIO cb)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_SetCRL_Cb");
|
|
if (ssl) {
|
|
SSL_CM_WARNING(ssl);
|
|
return wolfSSL_CertManagerSetCRL_IOCb(SSL_CM(ssl), cb);
|
|
}
|
|
else
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
#endif
|
|
|
|
int wolfSSL_CTX_EnableCRL(WOLFSSL_CTX* ctx, int options)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_EnableCRL");
|
|
if (ctx)
|
|
return wolfSSL_CertManagerEnableCRL(ctx->cm, options);
|
|
else
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
|
|
int wolfSSL_CTX_DisableCRL(WOLFSSL_CTX* ctx)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_DisableCRL");
|
|
if (ctx)
|
|
return wolfSSL_CertManagerDisableCRL(ctx->cm);
|
|
else
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
|
|
#ifndef NO_FILESYSTEM
|
|
int wolfSSL_CTX_LoadCRL(WOLFSSL_CTX* ctx, const char* path,
|
|
int type, int monitor)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_LoadCRL");
|
|
if (ctx)
|
|
return wolfSSL_CertManagerLoadCRL(ctx->cm, path, type, monitor);
|
|
else
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
int wolfSSL_CTX_LoadCRLFile(WOLFSSL_CTX* ctx, const char* file,
|
|
int type)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_LoadCRL");
|
|
if (ctx)
|
|
return wolfSSL_CertManagerLoadCRLFile(ctx->cm, file, type);
|
|
else
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
#endif
|
|
|
|
|
|
int wolfSSL_CTX_SetCRL_Cb(WOLFSSL_CTX* ctx, CbMissingCRL cb)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_SetCRL_Cb");
|
|
if (ctx)
|
|
return wolfSSL_CertManagerSetCRL_Cb(ctx->cm, cb);
|
|
else
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
#ifdef HAVE_CRL_IO
|
|
int wolfSSL_CTX_SetCRL_IOCb(WOLFSSL_CTX* ctx, CbCrlIO cb)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_SetCRL_IOCb");
|
|
if (ctx)
|
|
return wolfSSL_CertManagerSetCRL_IOCb(ctx->cm, cb);
|
|
else
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
#endif
|
|
|
|
|
|
#endif /* HAVE_CRL */
|
|
|
|
|
|
#ifndef NO_FILESYSTEM
|
|
|
|
|
|
#ifdef WOLFSSL_DER_LOAD
|
|
|
|
/* Add format parameter to allow DER load of CA files */
|
|
int wolfSSL_CTX_der_load_verify_locations(WOLFSSL_CTX* ctx, const char* file,
|
|
int format)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_der_load_verify_locations");
|
|
if (ctx == NULL || file == NULL)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
if (ProcessFile(ctx, file, format, CA_TYPE, NULL, 0, NULL,
|
|
GET_VERIFY_SETTING_CTX(ctx)) == WOLFSSL_SUCCESS) {
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
#endif /* WOLFSSL_DER_LOAD */
|
|
|
|
|
|
|
|
WOLFSSL_ABI
|
|
int wolfSSL_CTX_use_certificate_file(WOLFSSL_CTX* ctx, const char* file,
|
|
int format)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_use_certificate_file");
|
|
|
|
if (ProcessFile(ctx, file, format, CERT_TYPE, NULL, 0, NULL,
|
|
GET_VERIFY_SETTING_CTX(ctx)) == WOLFSSL_SUCCESS) {
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
|
|
WOLFSSL_ABI
|
|
int wolfSSL_CTX_use_PrivateKey_file(WOLFSSL_CTX* ctx, const char* file,
|
|
int format)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_use_PrivateKey_file");
|
|
|
|
if (ProcessFile(ctx, file, format, PRIVATEKEY_TYPE, NULL, 0, NULL,
|
|
GET_VERIFY_SETTING_CTX(ctx)) == WOLFSSL_SUCCESS) {
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
|
|
#endif /* NO_FILESYSTEM */
|
|
|
|
|
|
/* Sets the max chain depth when verifying a certificate chain. Default depth
|
|
* is set to MAX_CHAIN_DEPTH.
|
|
*
|
|
* ctx WOLFSSL_CTX structure to set depth in
|
|
* depth max depth
|
|
*/
|
|
void wolfSSL_CTX_set_verify_depth(WOLFSSL_CTX *ctx, int depth) {
|
|
WOLFSSL_ENTER("wolfSSL_CTX_set_verify_depth");
|
|
|
|
if (ctx == NULL || depth < 0 || depth > MAX_CHAIN_DEPTH) {
|
|
WOLFSSL_MSG("Bad depth argument, too large or less than 0");
|
|
return;
|
|
}
|
|
|
|
ctx->verifyDepth = (byte)depth;
|
|
}
|
|
|
|
|
|
/* get cert chaining depth using ssl struct */
|
|
long wolfSSL_get_verify_depth(WOLFSSL* ssl)
|
|
{
|
|
if(ssl == NULL) {
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
#ifndef OPENSSL_EXTRA
|
|
return MAX_CHAIN_DEPTH;
|
|
#else
|
|
return ssl->options.verifyDepth;
|
|
#endif
|
|
}
|
|
|
|
|
|
/* get cert chaining depth using ctx struct */
|
|
long wolfSSL_CTX_get_verify_depth(WOLFSSL_CTX* ctx)
|
|
{
|
|
if (ctx == NULL) {
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
#ifndef OPENSSL_EXTRA
|
|
return MAX_CHAIN_DEPTH;
|
|
#else
|
|
return ctx->verifyDepth;
|
|
#endif
|
|
}
|
|
|
|
|
|
#ifndef NO_FILESYSTEM
|
|
|
|
|
|
WOLFSSL_ABI
|
|
int wolfSSL_CTX_use_certificate_chain_file(WOLFSSL_CTX* ctx, const char* file)
|
|
{
|
|
/* process up to MAX_CHAIN_DEPTH plus subject cert */
|
|
WOLFSSL_ENTER("wolfSSL_CTX_use_certificate_chain_file");
|
|
|
|
if (ProcessFile(ctx, file, WOLFSSL_FILETYPE_PEM, CERT_TYPE, NULL, 1, NULL,
|
|
GET_VERIFY_SETTING_CTX(ctx)) == WOLFSSL_SUCCESS) {
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
|
|
int wolfSSL_CTX_use_certificate_chain_file_format(WOLFSSL_CTX* ctx,
|
|
const char* file, int format)
|
|
{
|
|
/* process up to MAX_CHAIN_DEPTH plus subject cert */
|
|
WOLFSSL_ENTER("wolfSSL_CTX_use_certificate_chain_file_format");
|
|
|
|
if (ProcessFile(ctx, file, format, CERT_TYPE, NULL, 1, NULL,
|
|
GET_VERIFY_SETTING_CTX(ctx)) == WOLFSSL_SUCCESS) {
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
|
|
#ifndef NO_DH
|
|
|
|
/* server Diffie-Hellman parameters */
|
|
static int wolfSSL_SetTmpDH_file_wrapper(WOLFSSL_CTX* ctx, WOLFSSL* ssl,
|
|
const char* fname, int format)
|
|
{
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
byte staticBuffer[1]; /* force heap usage */
|
|
#else
|
|
byte staticBuffer[FILE_BUFFER_SIZE];
|
|
#endif
|
|
byte* myBuffer = staticBuffer;
|
|
int dynamic = 0;
|
|
int ret;
|
|
long sz = 0;
|
|
XFILE file;
|
|
|
|
if (ctx == NULL || fname == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
file = XFOPEN(fname, "rb");
|
|
if (file == XBADFILE) return WOLFSSL_BAD_FILE;
|
|
if(XFSEEK(file, 0, XSEEK_END) != 0) {
|
|
XFCLOSE(file);
|
|
return WOLFSSL_BAD_FILE;
|
|
}
|
|
sz = XFTELL(file);
|
|
if(XFSEEK(file, 0, XSEEK_SET) != 0) {
|
|
XFCLOSE(file);
|
|
return WOLFSSL_BAD_FILE;
|
|
}
|
|
|
|
if (sz > MAX_WOLFSSL_FILE_SIZE || sz <= 0) {
|
|
WOLFSSL_MSG("SetTmpDH file size error");
|
|
XFCLOSE(file);
|
|
return WOLFSSL_BAD_FILE;
|
|
}
|
|
|
|
if (sz > (long)sizeof(staticBuffer)) {
|
|
WOLFSSL_MSG("Getting dynamic buffer");
|
|
myBuffer = (byte*) XMALLOC(sz, ctx->heap, DYNAMIC_TYPE_FILE);
|
|
if (myBuffer == NULL) {
|
|
XFCLOSE(file);
|
|
return WOLFSSL_BAD_FILE;
|
|
}
|
|
dynamic = 1;
|
|
}
|
|
|
|
if ((size_t)XFREAD(myBuffer, 1, sz, file) != (size_t)sz)
|
|
ret = WOLFSSL_BAD_FILE;
|
|
else {
|
|
if (ssl)
|
|
ret = wolfSSL_SetTmpDH_buffer(ssl, myBuffer, sz, format);
|
|
else
|
|
ret = wolfSSL_CTX_SetTmpDH_buffer(ctx, myBuffer, sz, format);
|
|
}
|
|
|
|
XFCLOSE(file);
|
|
if (dynamic)
|
|
XFREE(myBuffer, ctx->heap, DYNAMIC_TYPE_FILE);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/* server Diffie-Hellman parameters */
|
|
int wolfSSL_SetTmpDH_file(WOLFSSL* ssl, const char* fname, int format)
|
|
{
|
|
if (ssl == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
return wolfSSL_SetTmpDH_file_wrapper(ssl->ctx, ssl, fname, format);
|
|
}
|
|
|
|
|
|
/* server Diffie-Hellman parameters */
|
|
int wolfSSL_CTX_SetTmpDH_file(WOLFSSL_CTX* ctx, const char* fname, int format)
|
|
{
|
|
return wolfSSL_SetTmpDH_file_wrapper(ctx, NULL, fname, format);
|
|
}
|
|
|
|
#endif /* NO_DH */
|
|
|
|
#endif /* NO_FILESYSTEM */
|
|
|
|
#ifndef NO_CHECK_PRIVATE_KEY
|
|
/* Check private against public in certificate for match
|
|
*
|
|
* Returns WOLFSSL_SUCCESS on good private key
|
|
* WOLFSSL_FAILURE if mismatched */
|
|
static int check_cert_key(DerBuffer* cert, DerBuffer* key, void* heap,
|
|
int devId, int isKeyLabel, int isKeyId)
|
|
{
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
DecodedCert* der = NULL;
|
|
#else
|
|
DecodedCert der[1];
|
|
#endif
|
|
word32 size;
|
|
byte* buff;
|
|
int ret = WOLFSSL_FAILURE;
|
|
|
|
WOLFSSL_ENTER("check_cert_key");
|
|
|
|
if (cert == NULL || key == NULL) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
der = (DecodedCert*)XMALLOC(sizeof(DecodedCert), NULL, DYNAMIC_TYPE_DCERT);
|
|
if (der == NULL)
|
|
return MEMORY_E;
|
|
#endif
|
|
|
|
size = cert->length;
|
|
buff = cert->buffer;
|
|
InitDecodedCert_ex(der, buff, size, heap, devId);
|
|
if (ParseCertRelative(der, CERT_TYPE, NO_VERIFY, NULL) != 0) {
|
|
FreeDecodedCert(der);
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
XFREE(der, NULL, DYNAMIC_TYPE_DCERT);
|
|
#endif
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
size = key->length;
|
|
buff = key->buffer;
|
|
#ifdef WOLF_PRIVATE_KEY_ID
|
|
if (devId != INVALID_DEVID) {
|
|
int type = 0;
|
|
void *pkey = NULL;
|
|
|
|
#ifndef NO_RSA
|
|
if (der->keyOID == RSAk) {
|
|
type = DYNAMIC_TYPE_RSA;
|
|
}
|
|
#ifdef WC_RSA_PSS
|
|
if (der->keyOID == RSAPSSk) {
|
|
type = DYNAMIC_TYPE_RSA;
|
|
}
|
|
#endif
|
|
#endif
|
|
#ifdef HAVE_ECC
|
|
if (der->keyOID == ECDSAk) {
|
|
type = DYNAMIC_TYPE_ECC;
|
|
}
|
|
#endif
|
|
|
|
ret = CreateDevPrivateKey(&pkey, buff, size, type,
|
|
isKeyLabel, isKeyId, heap, devId);
|
|
#ifdef WOLF_CRYPTO_CB
|
|
if (ret == 0) {
|
|
#ifndef NO_RSA
|
|
if (der->keyOID == RSAk
|
|
#ifdef WC_RSA_PSS
|
|
|| der->keyOID == RSAPSSk
|
|
#endif
|
|
) {
|
|
ret = wc_CryptoCb_RsaCheckPrivKey((RsaKey*)pkey,
|
|
der->publicKey, der->pubKeySize);
|
|
}
|
|
#endif
|
|
#ifdef HAVE_ECC
|
|
if (der->keyOID == ECDSAk) {
|
|
ret = wc_CryptoCb_EccCheckPrivKey((ecc_key*)pkey,
|
|
der->publicKey, der->pubKeySize);
|
|
}
|
|
#endif
|
|
}
|
|
#else
|
|
/* devId was set, don't check, for now */
|
|
/* TODO: Add callback for private key check? */
|
|
#endif
|
|
if (pkey != NULL) {
|
|
#ifndef NO_RSA
|
|
if (der->keyOID == RSAk
|
|
#ifdef WC_RSA_PSS
|
|
|| der->keyOID == RSAPSSk
|
|
#endif
|
|
) {
|
|
wc_FreeRsaKey((RsaKey*)pkey);
|
|
}
|
|
#endif
|
|
#ifdef HAVE_ECC
|
|
if (der->keyOID == ECDSAk) {
|
|
wc_ecc_free((ecc_key*)pkey);
|
|
}
|
|
#endif
|
|
XFREE(pkey, heap, type);
|
|
}
|
|
if (ret != CRYPTOCB_UNAVAILABLE) {
|
|
ret = (ret == 0) ? WOLFSSL_SUCCESS: WOLFSSL_FAILURE;
|
|
}
|
|
}
|
|
else {
|
|
/* fall through if unavailable */
|
|
ret = CRYPTOCB_UNAVAILABLE;
|
|
}
|
|
|
|
if (ret == CRYPTOCB_UNAVAILABLE)
|
|
#endif /* WOLF_PRIVATE_KEY_ID */
|
|
{
|
|
ret = wc_CheckPrivateKeyCert(buff, size, der);
|
|
ret = (ret == 1) ? WOLFSSL_SUCCESS: WOLFSSL_FAILURE;
|
|
}
|
|
FreeDecodedCert(der);
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
XFREE(der, NULL, DYNAMIC_TYPE_DCERT);
|
|
#endif
|
|
|
|
(void)devId;
|
|
(void)isKeyLabel;
|
|
(void)isKeyId;
|
|
|
|
return ret;
|
|
}
|
|
|
|
/* Check private against public in certificate for match
|
|
*
|
|
* ctx WOLFSSL_CTX structure to check private key in
|
|
*
|
|
* Returns WOLFSSL_SUCCESS on good private key
|
|
* WOLFSSL_FAILURE if mismatched. */
|
|
int wolfSSL_CTX_check_private_key(const WOLFSSL_CTX* ctx)
|
|
{
|
|
if (ctx == NULL) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
return check_cert_key(ctx->certificate, ctx->privateKey, ctx->heap,
|
|
ctx->privateKeyDevId, ctx->privateKeyLabel, ctx->privateKeyId);
|
|
}
|
|
#endif /* !NO_CHECK_PRIVATE_KEY */
|
|
|
|
#ifdef OPENSSL_ALL
|
|
/**
|
|
* Return the private key of the WOLFSSL_CTX struct
|
|
* @return WOLFSSL_EVP_PKEY* The caller doesn *NOT*` free the returned object.
|
|
*/
|
|
WOLFSSL_EVP_PKEY* wolfSSL_CTX_get0_privatekey(const WOLFSSL_CTX* ctx)
|
|
{
|
|
const unsigned char *key;
|
|
int type;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_CTX_get0_privatekey");
|
|
|
|
if (ctx == NULL || ctx->privateKey == NULL ||
|
|
ctx->privateKey->buffer == NULL) {
|
|
WOLFSSL_MSG("Bad parameter or key not set");
|
|
return NULL;
|
|
}
|
|
|
|
switch (ctx->privateKeyType) {
|
|
#ifndef NO_RSA
|
|
case rsa_sa_algo:
|
|
type = EVP_PKEY_RSA;
|
|
break;
|
|
#endif
|
|
#ifdef HAVE_ECC
|
|
case ecc_dsa_sa_algo:
|
|
type = EVP_PKEY_EC;
|
|
break;
|
|
#endif
|
|
#ifdef WOLFSSL_SM2
|
|
case sm2_sa_algo:
|
|
type = EVP_PKEY_EC;
|
|
break;
|
|
#endif
|
|
default:
|
|
/* Other key types not supported either as ssl private keys
|
|
* or in the EVP layer */
|
|
WOLFSSL_MSG("Unsupported key type");
|
|
return NULL;
|
|
}
|
|
|
|
key = ctx->privateKey->buffer;
|
|
|
|
if (ctx->privateKeyPKey != NULL)
|
|
return ctx->privateKeyPKey;
|
|
else
|
|
return wolfSSL_d2i_PrivateKey(type,
|
|
(WOLFSSL_EVP_PKEY**)&ctx->privateKeyPKey, &key,
|
|
(long)ctx->privateKey->length);
|
|
}
|
|
#endif
|
|
|
|
#if defined(OPENSSL_EXTRA) || defined(WOLFSSL_WPAS_SMALL)
|
|
|
|
static WOLFSSL_EVP_PKEY* d2iGenericKey(WOLFSSL_EVP_PKEY** out,
|
|
const unsigned char** in, long inSz, int priv)
|
|
{
|
|
|
|
WOLFSSL_EVP_PKEY* pkey = NULL;
|
|
const unsigned char* mem;
|
|
long memSz = inSz;
|
|
|
|
WOLFSSL_ENTER("d2iGenericKey");
|
|
|
|
if (in == NULL || *in == NULL || inSz < 0) {
|
|
WOLFSSL_MSG("Bad argument");
|
|
return NULL;
|
|
}
|
|
mem = *in;
|
|
|
|
#if !defined(NO_RSA)
|
|
{
|
|
word32 keyIdx = 0;
|
|
int isRsaKey;
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
RsaKey *rsa = (RsaKey*)XMALLOC(sizeof(RsaKey), NULL, DYNAMIC_TYPE_RSA);
|
|
if (rsa == NULL)
|
|
return NULL;
|
|
#else
|
|
RsaKey rsa[1];
|
|
#endif
|
|
XMEMSET(rsa, 0, sizeof(RsaKey));
|
|
|
|
/* test if RSA key */
|
|
if (priv)
|
|
isRsaKey = wc_InitRsaKey(rsa, NULL) == 0 &&
|
|
wc_RsaPrivateKeyDecode(mem, &keyIdx, rsa, (word32)memSz) == 0;
|
|
else
|
|
isRsaKey = wc_InitRsaKey(rsa, NULL) == 0 &&
|
|
wc_RsaPublicKeyDecode(mem, &keyIdx, rsa, (word32)memSz) == 0;
|
|
wc_FreeRsaKey(rsa);
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
XFREE(rsa, NULL, DYNAMIC_TYPE_RSA);
|
|
#endif
|
|
|
|
if (isRsaKey) {
|
|
pkey = wolfSSL_EVP_PKEY_new();
|
|
if (pkey != NULL) {
|
|
pkey->pkey_sz = keyIdx;
|
|
pkey->pkey.ptr = (char*)XMALLOC(memSz, NULL,
|
|
priv ? DYNAMIC_TYPE_PRIVATE_KEY :
|
|
DYNAMIC_TYPE_PUBLIC_KEY);
|
|
if (pkey->pkey.ptr == NULL) {
|
|
wolfSSL_EVP_PKEY_free(pkey);
|
|
return NULL;
|
|
}
|
|
XMEMCPY(pkey->pkey.ptr, mem, keyIdx);
|
|
pkey->type = EVP_PKEY_RSA;
|
|
if (out != NULL) {
|
|
*out = pkey;
|
|
}
|
|
|
|
pkey->ownRsa = 1;
|
|
pkey->rsa = wolfssl_rsa_d2i(NULL, mem, inSz,
|
|
priv ? WOLFSSL_RSA_LOAD_PRIVATE : WOLFSSL_RSA_LOAD_PUBLIC);
|
|
if (pkey->rsa == NULL) {
|
|
wolfSSL_EVP_PKEY_free(pkey);
|
|
return NULL;
|
|
}
|
|
|
|
return pkey;
|
|
}
|
|
else {
|
|
WOLFSSL_MSG("RSA wolfSSL_EVP_PKEY_new error");
|
|
}
|
|
}
|
|
}
|
|
#endif /* NO_RSA */
|
|
|
|
#if defined(HAVE_ECC) && defined(OPENSSL_EXTRA)
|
|
{
|
|
word32 keyIdx = 0;
|
|
int isEccKey;
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
ecc_key *ecc = (ecc_key*)XMALLOC(sizeof(ecc_key), NULL, DYNAMIC_TYPE_ECC);
|
|
if (ecc == NULL)
|
|
return NULL;
|
|
#else
|
|
ecc_key ecc[1];
|
|
#endif
|
|
XMEMSET(ecc, 0, sizeof(ecc_key));
|
|
|
|
if (priv)
|
|
isEccKey = wc_ecc_init(ecc) == 0 &&
|
|
wc_EccPrivateKeyDecode(mem, &keyIdx, ecc, (word32)memSz) == 0;
|
|
else
|
|
isEccKey = wc_ecc_init(ecc) == 0 &&
|
|
wc_EccPublicKeyDecode(mem, &keyIdx, ecc, (word32)memSz) == 0;
|
|
wc_ecc_free(ecc);
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
XFREE(ecc, NULL, DYNAMIC_TYPE_ECC);
|
|
#endif
|
|
|
|
if (isEccKey) {
|
|
pkey = wolfSSL_EVP_PKEY_new();
|
|
if (pkey != NULL) {
|
|
pkey->pkey_sz = keyIdx;
|
|
pkey->pkey.ptr = (char*)XMALLOC(keyIdx, NULL,
|
|
priv ? DYNAMIC_TYPE_PRIVATE_KEY :
|
|
DYNAMIC_TYPE_PUBLIC_KEY);
|
|
if (pkey->pkey.ptr == NULL) {
|
|
wolfSSL_EVP_PKEY_free(pkey);
|
|
return NULL;
|
|
}
|
|
XMEMCPY(pkey->pkey.ptr, mem, keyIdx);
|
|
pkey->type = EVP_PKEY_EC;
|
|
if (out != NULL) {
|
|
*out = pkey;
|
|
}
|
|
|
|
pkey->ownEcc = 1;
|
|
pkey->ecc = wolfSSL_EC_KEY_new();
|
|
if (pkey->ecc == NULL) {
|
|
wolfSSL_EVP_PKEY_free(pkey);
|
|
return NULL;
|
|
}
|
|
|
|
if (wolfSSL_EC_KEY_LoadDer_ex(pkey->ecc,
|
|
(const unsigned char*)pkey->pkey.ptr,
|
|
pkey->pkey_sz, priv ? WOLFSSL_RSA_LOAD_PRIVATE
|
|
: WOLFSSL_RSA_LOAD_PUBLIC) != 1) {
|
|
wolfSSL_EVP_PKEY_free(pkey);
|
|
return NULL;
|
|
}
|
|
|
|
return pkey;
|
|
}
|
|
else {
|
|
WOLFSSL_MSG("ECC wolfSSL_EVP_PKEY_new error");
|
|
}
|
|
}
|
|
}
|
|
#endif /* HAVE_ECC && OPENSSL_EXTRA */
|
|
|
|
#if !defined(NO_DSA)
|
|
{
|
|
word32 keyIdx = 0;
|
|
int isDsaKey;
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
DsaKey *dsa = (DsaKey*)XMALLOC(sizeof(DsaKey), NULL, DYNAMIC_TYPE_DSA);
|
|
if (dsa == NULL)
|
|
return NULL;
|
|
#else
|
|
DsaKey dsa[1];
|
|
#endif
|
|
XMEMSET(dsa, 0, sizeof(DsaKey));
|
|
|
|
if (priv)
|
|
isDsaKey = wc_InitDsaKey(dsa) == 0 &&
|
|
wc_DsaPrivateKeyDecode(mem, &keyIdx, dsa, (word32)memSz) == 0;
|
|
else
|
|
isDsaKey = wc_InitDsaKey(dsa) == 0 &&
|
|
wc_DsaPublicKeyDecode(mem, &keyIdx, dsa, (word32)memSz) == 0;
|
|
wc_FreeDsaKey(dsa);
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
XFREE(dsa, NULL, DYNAMIC_TYPE_DSA);
|
|
#endif
|
|
|
|
/* test if DSA key */
|
|
if (isDsaKey) {
|
|
pkey = wolfSSL_EVP_PKEY_new();
|
|
|
|
if (pkey != NULL) {
|
|
pkey->pkey_sz = keyIdx;
|
|
pkey->pkey.ptr = (char*)XMALLOC(memSz, NULL,
|
|
priv ? DYNAMIC_TYPE_PRIVATE_KEY :
|
|
DYNAMIC_TYPE_PUBLIC_KEY);
|
|
if (pkey->pkey.ptr == NULL) {
|
|
wolfSSL_EVP_PKEY_free(pkey);
|
|
return NULL;
|
|
}
|
|
XMEMCPY(pkey->pkey.ptr, mem, keyIdx);
|
|
pkey->type = EVP_PKEY_DSA;
|
|
if (out != NULL) {
|
|
*out = pkey;
|
|
}
|
|
|
|
pkey->ownDsa = 1;
|
|
pkey->dsa = wolfSSL_DSA_new();
|
|
if (pkey->dsa == NULL) {
|
|
wolfSSL_EVP_PKEY_free(pkey);
|
|
return NULL;
|
|
}
|
|
|
|
if (wolfSSL_DSA_LoadDer_ex(pkey->dsa,
|
|
(const unsigned char*)pkey->pkey.ptr,
|
|
pkey->pkey_sz, priv ? WOLFSSL_RSA_LOAD_PRIVATE
|
|
: WOLFSSL_RSA_LOAD_PUBLIC) != 1) {
|
|
wolfSSL_EVP_PKEY_free(pkey);
|
|
return NULL;
|
|
}
|
|
|
|
return pkey;
|
|
}
|
|
else {
|
|
WOLFSSL_MSG("DSA wolfSSL_EVP_PKEY_new error");
|
|
}
|
|
}
|
|
}
|
|
#endif /* NO_DSA */
|
|
|
|
#if !defined(NO_DH) && (defined(WOLFSSL_QT) || defined(OPENSSL_ALL))
|
|
#if !defined(HAVE_FIPS) || (defined(HAVE_FIPS_VERSION) && \
|
|
(HAVE_FIPS_VERSION > 2))
|
|
{
|
|
int isDhKey;
|
|
word32 keyIdx = 0;
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
DhKey *dh = (DhKey*)XMALLOC(sizeof(DhKey), NULL, DYNAMIC_TYPE_DH);
|
|
if (dh == NULL)
|
|
return NULL;
|
|
#else
|
|
DhKey dh[1];
|
|
#endif
|
|
XMEMSET(dh, 0, sizeof(DhKey));
|
|
|
|
isDhKey = wc_InitDhKey(dh) == 0 &&
|
|
wc_DhKeyDecode(mem, &keyIdx, dh, (word32)memSz) == 0;
|
|
wc_FreeDhKey(dh);
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
XFREE(dh, NULL, DYNAMIC_TYPE_DH);
|
|
#endif
|
|
|
|
/* test if DH key */
|
|
if (isDhKey) {
|
|
pkey = wolfSSL_EVP_PKEY_new();
|
|
|
|
if (pkey != NULL) {
|
|
pkey->pkey_sz = (int)memSz;
|
|
pkey->pkey.ptr = (char*)XMALLOC(memSz, NULL,
|
|
priv ? DYNAMIC_TYPE_PRIVATE_KEY :
|
|
DYNAMIC_TYPE_PUBLIC_KEY);
|
|
if (pkey->pkey.ptr == NULL) {
|
|
wolfSSL_EVP_PKEY_free(pkey);
|
|
return NULL;
|
|
}
|
|
XMEMCPY(pkey->pkey.ptr, mem, memSz);
|
|
pkey->type = EVP_PKEY_DH;
|
|
if (out != NULL) {
|
|
*out = pkey;
|
|
}
|
|
|
|
pkey->ownDh = 1;
|
|
pkey->dh = wolfSSL_DH_new();
|
|
if (pkey->dh == NULL) {
|
|
wolfSSL_EVP_PKEY_free(pkey);
|
|
return NULL;
|
|
}
|
|
|
|
if (wolfSSL_DH_LoadDer(pkey->dh,
|
|
(const unsigned char*)pkey->pkey.ptr,
|
|
pkey->pkey_sz) != WOLFSSL_SUCCESS) {
|
|
wolfSSL_EVP_PKEY_free(pkey);
|
|
return NULL;
|
|
}
|
|
|
|
return pkey;
|
|
}
|
|
else {
|
|
WOLFSSL_MSG("DH wolfSSL_EVP_PKEY_new error");
|
|
}
|
|
}
|
|
}
|
|
#endif /* !HAVE_FIPS || HAVE_FIPS_VERSION > 2 */
|
|
#endif /* !NO_DH && (WOLFSSL_QT || OPENSSL_ALL) */
|
|
|
|
#if !defined(NO_DH) && defined(OPENSSL_EXTRA) && defined(WOLFSSL_DH_EXTRA)
|
|
#if !defined(HAVE_FIPS) || (defined(HAVE_FIPS_VERSION) && \
|
|
(HAVE_FIPS_VERSION > 2))
|
|
{
|
|
word32 keyIdx = 0;
|
|
DhKey* key = NULL;
|
|
int ret;
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
DhKey* dh = (DhKey*)XMALLOC(sizeof(DhKey), NULL, DYNAMIC_TYPE_DH);
|
|
if (dh == NULL)
|
|
return NULL;
|
|
#else
|
|
DhKey dh[1];
|
|
#endif
|
|
XMEMSET(dh, 0, sizeof(DhKey));
|
|
|
|
/* test if DH-public key */
|
|
if (wc_InitDhKey(dh) != 0)
|
|
return NULL;
|
|
|
|
ret = wc_DhKeyDecode(mem, &keyIdx, dh, (word32)memSz);
|
|
wc_FreeDhKey(dh);
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
XFREE(dh, NULL, DYNAMIC_TYPE_DH);
|
|
#endif
|
|
|
|
if (ret == 0) {
|
|
pkey = wolfSSL_EVP_PKEY_new();
|
|
if (pkey != NULL) {
|
|
pkey->type = EVP_PKEY_DH;
|
|
pkey->pkey_sz = (int)memSz;
|
|
pkey->pkey.ptr = (char*)XMALLOC(memSz, NULL,
|
|
priv ? DYNAMIC_TYPE_PRIVATE_KEY :
|
|
DYNAMIC_TYPE_PUBLIC_KEY);
|
|
if (pkey->pkey.ptr == NULL) {
|
|
wolfSSL_EVP_PKEY_free(pkey);
|
|
return NULL;
|
|
}
|
|
XMEMCPY(pkey->pkey.ptr, mem, memSz);
|
|
if (out != NULL) {
|
|
*out = pkey;
|
|
}
|
|
pkey->ownDh = 1;
|
|
pkey->dh = wolfSSL_DH_new();
|
|
if (pkey->dh == NULL) {
|
|
wolfSSL_EVP_PKEY_free(pkey);
|
|
return NULL;
|
|
}
|
|
|
|
key = (DhKey*)pkey->dh->internal;
|
|
|
|
keyIdx = 0;
|
|
if (wc_DhKeyDecode(mem, &keyIdx, key, (word32)memSz) == 0)
|
|
{
|
|
int elements = ELEMENT_P | ELEMENT_G | ELEMENT_Q |
|
|
ELEMENT_PUB;
|
|
if (priv)
|
|
elements |= ELEMENT_PRV;
|
|
if(SetDhExternal_ex(pkey->dh, elements)
|
|
== WOLFSSL_SUCCESS ) {
|
|
return pkey;
|
|
}
|
|
}
|
|
else {
|
|
wolfSSL_EVP_PKEY_free(pkey);
|
|
return NULL;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif /* !HAVE_FIPS || HAVE_FIPS_VERSION > 2 */
|
|
#endif /* !NO_DH && OPENSSL_EXTRA && WOLFSSL_DH_EXTRA */
|
|
|
|
#ifdef HAVE_PQC
|
|
#ifdef HAVE_FALCON
|
|
{
|
|
int isFalcon = 0;
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
falcon_key *falcon = (falcon_key *)XMALLOC(sizeof(falcon_key), NULL,
|
|
DYNAMIC_TYPE_FALCON);
|
|
if (falcon == NULL) {
|
|
return NULL;
|
|
}
|
|
#else
|
|
falcon_key falcon[1];
|
|
#endif
|
|
|
|
if (wc_falcon_init(falcon) == 0) {
|
|
/* test if Falcon key */
|
|
if (priv) {
|
|
/* Try level 1 */
|
|
isFalcon = wc_falcon_set_level(falcon, 1) == 0 &&
|
|
wc_falcon_import_private_only(mem, (word32)memSz,
|
|
falcon) == 0;
|
|
if (!isFalcon) {
|
|
/* Try level 5 */
|
|
isFalcon = wc_falcon_set_level(falcon, 5) == 0 &&
|
|
wc_falcon_import_private_only(mem, (word32)memSz,
|
|
falcon) == 0;
|
|
}
|
|
} else {
|
|
/* Try level 1 */
|
|
isFalcon = wc_falcon_set_level(falcon, 1) == 0 &&
|
|
wc_falcon_import_public(mem, (word32)memSz, falcon)
|
|
== 0;
|
|
|
|
if (!isFalcon) {
|
|
/* Try level 5 */
|
|
isFalcon = wc_falcon_set_level(falcon, 5) == 0 &&
|
|
wc_falcon_import_public(mem, (word32)memSz,
|
|
falcon) == 0;
|
|
}
|
|
}
|
|
wc_falcon_free(falcon);
|
|
}
|
|
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
XFREE(falcon, NULL, DYNAMIC_TYPE_FALCON);
|
|
#endif
|
|
if (isFalcon) {
|
|
/* Create a fake Falcon EVP_PKEY. In the future, we might integrate
|
|
* Falcon into the compatibility layer. */
|
|
pkey = wolfSSL_EVP_PKEY_new();
|
|
if (pkey == NULL) {
|
|
WOLFSSL_MSG("Falcon wolfSSL_EVP_PKEY_new error");
|
|
return NULL;
|
|
}
|
|
pkey->type = EVP_PKEY_FALCON;
|
|
pkey->pkey.ptr = NULL;
|
|
pkey->pkey_sz = 0;
|
|
return pkey;
|
|
}
|
|
|
|
}
|
|
#endif /* HAVE_FALCON */
|
|
#ifdef HAVE_DILITHIUM
|
|
{
|
|
int isDilithium = 0;
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
dilithium_key *dilithium = (dilithium_key *)
|
|
XMALLOC(sizeof(dilithium_key), NULL, DYNAMIC_TYPE_DILITHIUM);
|
|
if (dilithium == NULL) {
|
|
return NULL;
|
|
}
|
|
#else
|
|
dilithium_key dilithium[1];
|
|
#endif
|
|
|
|
if (wc_dilithium_init(dilithium) == 0) {
|
|
/* Test if Dilithium key. Try all levels. */
|
|
if (priv) {
|
|
isDilithium = wc_dilithium_set_level(dilithium, 2) == 0 &&
|
|
wc_dilithium_import_private_only(mem,
|
|
(word32)memSz, dilithium) == 0;
|
|
if (!isDilithium) {
|
|
isDilithium = wc_dilithium_set_level(dilithium, 3) == 0 &&
|
|
wc_dilithium_import_private_only(mem,
|
|
(word32)memSz, dilithium) == 0;
|
|
}
|
|
if (!isDilithium) {
|
|
isDilithium = wc_dilithium_set_level(dilithium, 5) == 0 &&
|
|
wc_dilithium_import_private_only(mem,
|
|
(word32)memSz, dilithium) == 0;
|
|
}
|
|
} else {
|
|
isDilithium = wc_dilithium_set_level(dilithium, 2) == 0 &&
|
|
wc_dilithium_import_public(mem, (word32)memSz,
|
|
dilithium) == 0;
|
|
if (!isDilithium) {
|
|
isDilithium = wc_dilithium_set_level(dilithium, 3) == 0 &&
|
|
wc_dilithium_import_public(mem, (word32)memSz,
|
|
dilithium) == 0;
|
|
}
|
|
if (!isDilithium) {
|
|
isDilithium = wc_dilithium_set_level(dilithium, 5) == 0 &&
|
|
wc_dilithium_import_public(mem, (word32)memSz,
|
|
dilithium) == 0;
|
|
}
|
|
}
|
|
wc_dilithium_free(dilithium);
|
|
}
|
|
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
XFREE(dilithium, NULL, DYNAMIC_TYPE_DILITHIUM);
|
|
#endif
|
|
if (isDilithium) {
|
|
/* Create a fake Dilithium EVP_PKEY. In the future, we might
|
|
* integrate Dilithium into the compatibility layer. */
|
|
pkey = wolfSSL_EVP_PKEY_new();
|
|
if (pkey == NULL) {
|
|
WOLFSSL_MSG("Dilithium wolfSSL_EVP_PKEY_new error");
|
|
return NULL;
|
|
}
|
|
pkey->type = EVP_PKEY_DILITHIUM;
|
|
pkey->pkey.ptr = NULL;
|
|
pkey->pkey_sz = 0;
|
|
return pkey;
|
|
}
|
|
|
|
}
|
|
#endif /* HAVE_DILITHIUM */
|
|
#endif /* HAVE_PQC */
|
|
|
|
if (pkey == NULL) {
|
|
WOLFSSL_MSG("wolfSSL_d2i_PUBKEY couldn't determine key type");
|
|
}
|
|
|
|
return pkey;
|
|
|
|
}
|
|
#endif /* OPENSSL_EXTRA || WPA_SMALL */
|
|
|
|
#ifdef OPENSSL_EXTRA
|
|
|
|
WOLFSSL_PKCS8_PRIV_KEY_INFO* wolfSSL_d2i_PKCS8_PKEY(
|
|
WOLFSSL_PKCS8_PRIV_KEY_INFO** pkey, const unsigned char** keyBuf, long keyLen)
|
|
{
|
|
WOLFSSL_PKCS8_PRIV_KEY_INFO* pkcs8 = NULL;
|
|
#ifdef WOLFSSL_PEM_TO_DER
|
|
int ret;
|
|
DerBuffer* der = NULL;
|
|
|
|
if (keyBuf == NULL || *keyBuf == NULL || keyLen <= 0) {
|
|
WOLFSSL_MSG("Bad key PEM/DER args");
|
|
return NULL;
|
|
}
|
|
|
|
ret = PemToDer(*keyBuf, keyLen, PRIVATEKEY_TYPE, &der, NULL, NULL, NULL);
|
|
if (ret < 0) {
|
|
WOLFSSL_MSG("Not PEM format");
|
|
ret = AllocDer(&der, (word32)keyLen, PRIVATEKEY_TYPE, NULL);
|
|
if (ret == 0) {
|
|
XMEMCPY(der->buffer, *keyBuf, keyLen);
|
|
}
|
|
}
|
|
|
|
if (ret == 0) {
|
|
/* Verify this is PKCS8 Key */
|
|
word32 inOutIdx = 0;
|
|
word32 algId;
|
|
ret = ToTraditionalInline_ex(der->buffer, &inOutIdx, der->length, &algId);
|
|
if (ret >= 0) {
|
|
ret = 0; /* good DER */
|
|
}
|
|
}
|
|
|
|
if (ret == 0) {
|
|
pkcs8 = wolfSSL_EVP_PKEY_new();
|
|
if (pkcs8 == NULL)
|
|
ret = MEMORY_E;
|
|
}
|
|
if (ret == 0) {
|
|
pkcs8->pkey.ptr = (char*)XMALLOC(der->length, NULL,
|
|
DYNAMIC_TYPE_PUBLIC_KEY);
|
|
if (pkcs8->pkey.ptr == NULL)
|
|
ret = MEMORY_E;
|
|
}
|
|
if (ret == 0) {
|
|
XMEMCPY(pkcs8->pkey.ptr, der->buffer, der->length);
|
|
pkcs8->pkey_sz = der->length;
|
|
}
|
|
|
|
FreeDer(&der);
|
|
if (ret != 0) {
|
|
wolfSSL_EVP_PKEY_free(pkcs8);
|
|
pkcs8 = NULL;
|
|
}
|
|
if (pkey != NULL) {
|
|
*pkey = pkcs8;
|
|
}
|
|
|
|
#else
|
|
(void)bio;
|
|
(void)pkey;
|
|
#endif /* WOLFSSL_PEM_TO_DER */
|
|
|
|
return pkcs8;
|
|
}
|
|
|
|
|
|
#ifndef NO_BIO
|
|
/* put SSL type in extra for now, not very common */
|
|
|
|
/* Converts a DER format key read from "bio" to a PKCS8 structure.
|
|
*
|
|
* bio input bio to read DER from
|
|
* pkey If not NULL then this pointer will be overwritten with a new PKCS8
|
|
* structure.
|
|
*
|
|
* returns a WOLFSSL_PKCS8_PRIV_KEY_INFO pointer on success and NULL in fail
|
|
* case.
|
|
*/
|
|
WOLFSSL_PKCS8_PRIV_KEY_INFO* wolfSSL_d2i_PKCS8_PKEY_bio(WOLFSSL_BIO* bio,
|
|
WOLFSSL_PKCS8_PRIV_KEY_INFO** pkey)
|
|
{
|
|
WOLFSSL_PKCS8_PRIV_KEY_INFO* pkcs8 = NULL;
|
|
#ifdef WOLFSSL_PEM_TO_DER
|
|
unsigned char* mem = NULL;
|
|
int memSz;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_d2i_PKCS8_PKEY_bio");
|
|
|
|
if (bio == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
if ((memSz = wolfSSL_BIO_get_mem_data(bio, &mem)) < 0) {
|
|
return NULL;
|
|
}
|
|
|
|
pkcs8 = wolfSSL_d2i_PKCS8_PKEY(pkey, (const unsigned char**)&mem, memSz);
|
|
#else
|
|
(void)bio;
|
|
(void)pkey;
|
|
#endif /* WOLFSSL_PEM_TO_DER */
|
|
|
|
return pkcs8;
|
|
}
|
|
|
|
|
|
/* expecting DER format public key
|
|
*
|
|
* bio input bio to read DER from
|
|
* out If not NULL then this pointer will be overwritten with a new
|
|
* WOLFSSL_EVP_PKEY pointer
|
|
*
|
|
* returns a WOLFSSL_EVP_PKEY pointer on success and NULL in fail case.
|
|
*/
|
|
WOLFSSL_EVP_PKEY* wolfSSL_d2i_PUBKEY_bio(WOLFSSL_BIO* bio,
|
|
WOLFSSL_EVP_PKEY** out)
|
|
{
|
|
unsigned char* mem;
|
|
long memSz;
|
|
WOLFSSL_EVP_PKEY* pkey = NULL;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_d2i_PUBKEY_bio");
|
|
|
|
if (bio == NULL) {
|
|
return NULL;
|
|
}
|
|
(void)out;
|
|
|
|
memSz = wolfSSL_BIO_get_len(bio);
|
|
if (memSz <= 0) {
|
|
return NULL;
|
|
}
|
|
|
|
mem = (unsigned char*)XMALLOC(memSz, bio->heap, DYNAMIC_TYPE_TMP_BUFFER);
|
|
if (mem == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
if (wolfSSL_BIO_read(bio, mem, (int)memSz) == memSz) {
|
|
pkey = wolfSSL_d2i_PUBKEY(NULL, (const unsigned char**)&mem, memSz);
|
|
if (out != NULL && pkey != NULL) {
|
|
*out = pkey;
|
|
}
|
|
}
|
|
|
|
XFREE(mem, bio->heap, DYNAMIC_TYPE_TMP_BUFFER);
|
|
return pkey;
|
|
}
|
|
|
|
#endif /* !NO_BIO */
|
|
|
|
|
|
/* Converts a DER encoded public key to a WOLFSSL_EVP_PKEY structure.
|
|
*
|
|
* out pointer to new WOLFSSL_EVP_PKEY structure. Can be NULL
|
|
* in DER buffer to convert
|
|
* inSz size of in buffer
|
|
*
|
|
* returns a pointer to a new WOLFSSL_EVP_PKEY structure on success and NULL
|
|
* on fail
|
|
*/
|
|
WOLFSSL_EVP_PKEY* wolfSSL_d2i_PUBKEY(WOLFSSL_EVP_PKEY** out,
|
|
const unsigned char** in, long inSz)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_d2i_PUBKEY");
|
|
return d2iGenericKey(out, in, inSz, 0);
|
|
}
|
|
|
|
#if defined(OPENSSL_EXTRA) && !defined(NO_CERTS) && !defined(NO_ASN) && \
|
|
!defined(NO_PWDBASED)
|
|
|
|
/* helper function to get raw pointer to DER buffer from WOLFSSL_EVP_PKEY */
|
|
static int wolfSSL_EVP_PKEY_get_der(const WOLFSSL_EVP_PKEY* key, unsigned char** der)
|
|
{
|
|
int sz;
|
|
word16 pkcs8HeaderSz;
|
|
|
|
if (!key || !key->pkey_sz)
|
|
return WOLFSSL_FATAL_ERROR;
|
|
|
|
/* return the key without PKCS8 for compatibility */
|
|
/* if pkcs8HeaderSz is invalid, use 0 and return all of pkey */
|
|
pkcs8HeaderSz = 0;
|
|
if (key->pkey_sz > key->pkcs8HeaderSz)
|
|
pkcs8HeaderSz = key->pkcs8HeaderSz;
|
|
sz = key->pkey_sz - pkcs8HeaderSz;
|
|
if (der) {
|
|
unsigned char* pt = (unsigned char*)key->pkey.ptr;
|
|
if (*der) {
|
|
/* since this function signature has no size value passed in it is
|
|
* assumed that the user has allocated a large enough buffer */
|
|
XMEMCPY(*der, pt + pkcs8HeaderSz, sz);
|
|
*der += sz;
|
|
}
|
|
else {
|
|
*der = (unsigned char*)XMALLOC(sz, NULL, DYNAMIC_TYPE_OPENSSL);
|
|
if (*der == NULL) {
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
XMEMCPY(*der, pt + pkcs8HeaderSz, sz);
|
|
}
|
|
}
|
|
return sz;
|
|
}
|
|
|
|
int wolfSSL_i2d_PUBKEY(const WOLFSSL_EVP_PKEY *key, unsigned char **der)
|
|
{
|
|
return wolfSSL_i2d_PublicKey(key, der);
|
|
}
|
|
|
|
#endif /* OPENSSL_EXTRA && !NO_CERTS && !NO_ASN && !NO_PWDBASED */
|
|
|
|
static WOLFSSL_EVP_PKEY* _d2i_PublicKey(int type, WOLFSSL_EVP_PKEY** out,
|
|
const unsigned char **in, long inSz, int priv)
|
|
{
|
|
int ret = 0;
|
|
word32 idx = 0, algId;
|
|
word16 pkcs8HeaderSz = 0;
|
|
WOLFSSL_EVP_PKEY* local;
|
|
int opt;
|
|
|
|
(void)opt;
|
|
|
|
if (in == NULL || inSz < 0) {
|
|
WOLFSSL_MSG("Bad argument");
|
|
return NULL;
|
|
}
|
|
|
|
if (priv == 1) {
|
|
/* Check if input buffer has PKCS8 header. In the case that it does not
|
|
* have a PKCS8 header then do not error out. */
|
|
if ((ret = ToTraditionalInline_ex((const byte*)(*in), &idx,
|
|
(word32)inSz, &algId)) > 0) {
|
|
WOLFSSL_MSG("Found PKCS8 header");
|
|
pkcs8HeaderSz = (word16)idx;
|
|
|
|
if ((type == EVP_PKEY_RSA && algId != RSAk
|
|
#ifdef WC_RSA_PSS
|
|
&& algId != RSAPSSk
|
|
#endif
|
|
) ||
|
|
(type == EVP_PKEY_EC && algId != ECDSAk) ||
|
|
(type == EVP_PKEY_DSA && algId != DSAk) ||
|
|
(type == EVP_PKEY_DH && algId != DHk)) {
|
|
WOLFSSL_MSG("PKCS8 does not match EVP key type");
|
|
return NULL;
|
|
}
|
|
|
|
(void)idx; /* not used */
|
|
}
|
|
else {
|
|
if (ret != ASN_PARSE_E) {
|
|
WOLFSSL_MSG("Unexpected error with trying to remove PKCS8 "
|
|
"header");
|
|
return NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (out != NULL && *out != NULL) {
|
|
wolfSSL_EVP_PKEY_free(*out);
|
|
*out = NULL;
|
|
}
|
|
local = wolfSSL_EVP_PKEY_new();
|
|
if (local == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
local->type = type;
|
|
local->pkey_sz = (int)inSz;
|
|
local->pkcs8HeaderSz = pkcs8HeaderSz;
|
|
local->pkey.ptr = (char*)XMALLOC(inSz, NULL, DYNAMIC_TYPE_PUBLIC_KEY);
|
|
if (local->pkey.ptr == NULL) {
|
|
wolfSSL_EVP_PKEY_free(local);
|
|
local = NULL;
|
|
return NULL;
|
|
}
|
|
else {
|
|
XMEMCPY(local->pkey.ptr, *in, inSz);
|
|
}
|
|
|
|
switch (type) {
|
|
#ifndef NO_RSA
|
|
case EVP_PKEY_RSA:
|
|
opt = priv ? WOLFSSL_RSA_LOAD_PRIVATE : WOLFSSL_RSA_LOAD_PUBLIC;
|
|
local->ownRsa = 1;
|
|
local->rsa = wolfssl_rsa_d2i(NULL,
|
|
(const unsigned char*)local->pkey.ptr, local->pkey_sz, opt);
|
|
if (local->rsa == NULL) {
|
|
wolfSSL_EVP_PKEY_free(local);
|
|
return NULL;
|
|
}
|
|
break;
|
|
#endif /* NO_RSA */
|
|
#ifdef HAVE_ECC
|
|
case EVP_PKEY_EC:
|
|
local->ownEcc = 1;
|
|
local->ecc = wolfSSL_EC_KEY_new();
|
|
if (local->ecc == NULL) {
|
|
wolfSSL_EVP_PKEY_free(local);
|
|
return NULL;
|
|
}
|
|
opt = priv ? WOLFSSL_EC_KEY_LOAD_PRIVATE :
|
|
WOLFSSL_EC_KEY_LOAD_PUBLIC;
|
|
if (wolfSSL_EC_KEY_LoadDer_ex(local->ecc,
|
|
(const unsigned char*)local->pkey.ptr, local->pkey_sz,
|
|
opt)
|
|
!= WOLFSSL_SUCCESS) {
|
|
wolfSSL_EVP_PKEY_free(local);
|
|
return NULL;
|
|
}
|
|
break;
|
|
#endif /* HAVE_ECC */
|
|
#if defined(WOLFSSL_QT) || defined(OPENSSL_ALL) || defined(WOLFSSL_OPENSSH)
|
|
#ifndef NO_DSA
|
|
case EVP_PKEY_DSA:
|
|
local->ownDsa = 1;
|
|
local->dsa = wolfSSL_DSA_new();
|
|
if (local->dsa == NULL) {
|
|
wolfSSL_EVP_PKEY_free(local);
|
|
return NULL;
|
|
}
|
|
opt = priv ? WOLFSSL_DSA_LOAD_PRIVATE : WOLFSSL_DSA_LOAD_PUBLIC;
|
|
if (wolfSSL_DSA_LoadDer_ex(local->dsa,
|
|
(const unsigned char*)local->pkey.ptr, local->pkey_sz,
|
|
opt)
|
|
!= WOLFSSL_SUCCESS) {
|
|
wolfSSL_EVP_PKEY_free(local);
|
|
return NULL;
|
|
}
|
|
break;
|
|
#endif /* NO_DSA */
|
|
#ifndef NO_DH
|
|
#if !defined(HAVE_FIPS) || (defined(HAVE_FIPS_VERSION) && (HAVE_FIPS_VERSION>2))
|
|
case EVP_PKEY_DH:
|
|
local->ownDh = 1;
|
|
local->dh = wolfSSL_DH_new();
|
|
if (local->dh == NULL) {
|
|
wolfSSL_EVP_PKEY_free(local);
|
|
return NULL;
|
|
}
|
|
if (wolfSSL_DH_LoadDer(local->dh,
|
|
(const unsigned char*)local->pkey.ptr, local->pkey_sz)
|
|
!= WOLFSSL_SUCCESS) {
|
|
wolfSSL_EVP_PKEY_free(local);
|
|
return NULL;
|
|
}
|
|
break;
|
|
#endif /* !HAVE_FIPS || HAVE_FIPS_VERSION > 2 */
|
|
#endif /* HAVE_DH */
|
|
#endif /* WOLFSSL_QT || OPENSSL_ALL || WOLFSSL_OPENSSH */
|
|
default:
|
|
WOLFSSL_MSG("Unsupported key type");
|
|
wolfSSL_EVP_PKEY_free(local);
|
|
return NULL;
|
|
}
|
|
|
|
/* advance pointer with success */
|
|
if (local != NULL) {
|
|
if (local->pkey_sz <= (int)inSz) {
|
|
*in += local->pkey_sz;
|
|
}
|
|
|
|
if (out != NULL) {
|
|
*out = local;
|
|
}
|
|
}
|
|
|
|
return local;
|
|
}
|
|
|
|
WOLFSSL_EVP_PKEY* wolfSSL_d2i_PublicKey(int type, WOLFSSL_EVP_PKEY** out,
|
|
const unsigned char **in, long inSz)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_d2i_PublicKey");
|
|
|
|
return _d2i_PublicKey(type, out, in, inSz, 0);
|
|
}
|
|
/* Reads in a DER format key. If PKCS8 headers are found they are stripped off.
|
|
*
|
|
* type type of key
|
|
* out newly created WOLFSSL_EVP_PKEY structure
|
|
* in pointer to input key DER
|
|
* inSz size of in buffer
|
|
*
|
|
* On success a non null pointer is returned and the pointer in is advanced the
|
|
* same number of bytes read.
|
|
*/
|
|
WOLFSSL_EVP_PKEY* wolfSSL_d2i_PrivateKey(int type, WOLFSSL_EVP_PKEY** out,
|
|
const unsigned char **in, long inSz)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_d2i_PrivateKey");
|
|
|
|
return _d2i_PublicKey(type, out, in, inSz, 1);
|
|
}
|
|
|
|
#ifdef WOLF_PRIVATE_KEY_ID
|
|
/* Create an EVP structure for use with crypto callbacks */
|
|
WOLFSSL_EVP_PKEY* wolfSSL_d2i_PrivateKey_id(int type, WOLFSSL_EVP_PKEY** out,
|
|
void* heap, int devId)
|
|
{
|
|
WOLFSSL_EVP_PKEY* local;
|
|
|
|
if (out != NULL && *out != NULL) {
|
|
wolfSSL_EVP_PKEY_free(*out);
|
|
*out = NULL;
|
|
}
|
|
|
|
local = wolfSSL_EVP_PKEY_new_ex(heap);
|
|
if (local == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
local->type = type;
|
|
local->pkey_sz = 0;
|
|
local->pkcs8HeaderSz = 0;
|
|
|
|
switch (type) {
|
|
#ifndef NO_RSA
|
|
case EVP_PKEY_RSA:
|
|
{
|
|
RsaKey* key;
|
|
local->ownRsa = 1;
|
|
local->rsa = wolfSSL_RSA_new_ex(heap, devId);
|
|
if (local->rsa == NULL) {
|
|
wolfSSL_EVP_PKEY_free(local);
|
|
return NULL;
|
|
}
|
|
key = (RsaKey*)local->rsa->internal;
|
|
#ifdef WOLF_CRYPTO_CB
|
|
key->devId = devId;
|
|
#endif
|
|
(void)key;
|
|
local->rsa->inSet = 1;
|
|
break;
|
|
}
|
|
#endif /* !NO_RSA */
|
|
#ifdef HAVE_ECC
|
|
case EVP_PKEY_EC:
|
|
{
|
|
ecc_key* key;
|
|
local->ownEcc = 1;
|
|
local->ecc = wolfSSL_EC_KEY_new_ex(heap, devId);
|
|
if (local->ecc == NULL) {
|
|
wolfSSL_EVP_PKEY_free(local);
|
|
return NULL;
|
|
}
|
|
key = (ecc_key*)local->ecc->internal;
|
|
#ifdef WOLF_CRYPTO_CB
|
|
key->devId = devId;
|
|
#endif
|
|
key->type = ECC_PRIVATEKEY;
|
|
/* key is required to have a key size / curve set, although
|
|
* actual one used is determined by devId callback function */
|
|
wc_ecc_set_curve(key, ECDHE_SIZE, ECC_CURVE_DEF);
|
|
|
|
local->ecc->inSet = 1;
|
|
break;
|
|
}
|
|
#endif /* HAVE_ECC */
|
|
default:
|
|
WOLFSSL_MSG("Unsupported private key id type");
|
|
wolfSSL_EVP_PKEY_free(local);
|
|
return NULL;
|
|
}
|
|
|
|
if (local != NULL && out != NULL) {
|
|
*out = local;
|
|
}
|
|
|
|
return local;
|
|
}
|
|
#endif /* WOLF_PRIVATE_KEY_ID */
|
|
|
|
#ifndef NO_CERTS /* // NOLINT(readability-redundant-preprocessor) */
|
|
|
|
#ifndef NO_CHECK_PRIVATE_KEY
|
|
/* Check private against public in certificate for match
|
|
*
|
|
* ssl WOLFSSL structure to check private key in
|
|
*
|
|
* Returns WOLFSSL_SUCCESS on good private key
|
|
* WOLFSSL_FAILURE if mismatched. */
|
|
int wolfSSL_check_private_key(const WOLFSSL* ssl)
|
|
{
|
|
if (ssl == NULL) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
return check_cert_key(ssl->buffers.certificate, ssl->buffers.key, ssl->heap,
|
|
ssl->buffers.keyDevId, ssl->buffers.keyLabel, ssl->buffers.keyId);
|
|
}
|
|
#endif /* !NO_CHECK_PRIVATE_KEY */
|
|
|
|
#endif /* !NO_CERTS */
|
|
|
|
int wolfSSL_use_PrivateKey(WOLFSSL* ssl, WOLFSSL_EVP_PKEY* pkey)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_use_PrivateKey");
|
|
if (ssl == NULL || pkey == NULL ) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
return wolfSSL_use_PrivateKey_buffer(ssl, (unsigned char*)pkey->pkey.ptr,
|
|
pkey->pkey_sz, WOLFSSL_FILETYPE_ASN1);
|
|
}
|
|
|
|
|
|
int wolfSSL_use_PrivateKey_ASN1(int pri, WOLFSSL* ssl, const unsigned char* der,
|
|
long derSz)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_use_PrivateKey_ASN1");
|
|
if (ssl == NULL || der == NULL ) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
(void)pri; /* type of private key */
|
|
return wolfSSL_use_PrivateKey_buffer(ssl, der, derSz, WOLFSSL_FILETYPE_ASN1);
|
|
}
|
|
/******************************************************************************
|
|
* wolfSSL_CTX_use_PrivateKey_ASN1 - loads a private key buffer into the SSL ctx
|
|
*
|
|
* RETURNS:
|
|
* returns WOLFSSL_SUCCESS on success, otherwise returns WOLFSSL_FAILURE
|
|
*/
|
|
|
|
int wolfSSL_CTX_use_PrivateKey_ASN1(int pri, WOLFSSL_CTX* ctx,
|
|
unsigned char* der, long derSz)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_use_PrivateKey_ASN1");
|
|
if (ctx == NULL || der == NULL ) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
(void)pri; /* type of private key */
|
|
return wolfSSL_CTX_use_PrivateKey_buffer(ctx, der, derSz, WOLFSSL_FILETYPE_ASN1);
|
|
}
|
|
|
|
|
|
#ifndef NO_RSA
|
|
int wolfSSL_use_RSAPrivateKey_ASN1(WOLFSSL* ssl, unsigned char* der, long derSz)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_use_RSAPrivateKey_ASN1");
|
|
if (ssl == NULL || der == NULL ) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
return wolfSSL_use_PrivateKey_buffer(ssl, der, derSz, WOLFSSL_FILETYPE_ASN1);
|
|
}
|
|
#endif
|
|
|
|
int wolfSSL_use_certificate(WOLFSSL* ssl, WOLFSSL_X509* x509)
|
|
{
|
|
long idx;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_use_certificate");
|
|
if (x509 != NULL && ssl != NULL && x509->derCert != NULL) {
|
|
if (ProcessBuffer(NULL, x509->derCert->buffer, x509->derCert->length,
|
|
WOLFSSL_FILETYPE_ASN1, CERT_TYPE, ssl, &idx, 0,
|
|
GET_VERIFY_SETTING_SSL(ssl)) == WOLFSSL_SUCCESS) {
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
}
|
|
|
|
(void)idx;
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
#endif /* OPENSSL_EXTRA */
|
|
|
|
#if defined(HAVE_RPK)
|
|
/* Confirm that all the byte data in the buffer is unique.
|
|
* return 1 if all the byte data in the buffer is unique, otherwise 0.
|
|
*/
|
|
static int isArrayUnique(const char* buf, size_t len)
|
|
{
|
|
size_t i, j;
|
|
/* check the array is unique */
|
|
for (i = 0; i < len -1; ++i) {
|
|
for (j = i+ 1; j < len; ++j) {
|
|
if (buf[i] == buf[j]) {
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
/* Set user preference for the client_cert_type exetnsion.
|
|
* Takes byte array containing cert types the caller can provide to its peer.
|
|
* Cert types are in preferred order in the array.
|
|
*/
|
|
WOLFSSL_API int wolfSSL_CTX_set_client_cert_type(WOLFSSL_CTX* ctx,
|
|
const char* buf, int bufLen)
|
|
{
|
|
int i;
|
|
|
|
if (ctx == NULL || bufLen > MAX_CLIENT_CERT_TYPE_CNT) {
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
/* if buf is set to NULL or bufLen is set to zero, it defaults the setting*/
|
|
if (buf == NULL || bufLen == 0) {
|
|
ctx->rpkConfig.preferred_ClientCertTypeCnt = 1;
|
|
ctx->rpkConfig.preferred_ClientCertTypes[0]= WOLFSSL_CERT_TYPE_X509;
|
|
ctx->rpkConfig.preferred_ClientCertTypes[1]= WOLFSSL_CERT_TYPE_X509;
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
if (!isArrayUnique(buf, bufLen))
|
|
return BAD_FUNC_ARG;
|
|
|
|
for (i = 0; i < bufLen; i++){
|
|
if (buf[i] != WOLFSSL_CERT_TYPE_RPK && buf[i] != WOLFSSL_CERT_TYPE_X509)
|
|
return BAD_FUNC_ARG;
|
|
|
|
ctx->rpkConfig.preferred_ClientCertTypes[i] = buf[i];
|
|
}
|
|
ctx->rpkConfig.preferred_ClientCertTypeCnt = bufLen;
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
/* Set user preference for the server_cert_type exetnsion.
|
|
* Takes byte array containing cert types the caller can provide to its peer.
|
|
* Cert types are in preferred order in the array.
|
|
*/
|
|
WOLFSSL_API int wolfSSL_CTX_set_server_cert_type(WOLFSSL_CTX* ctx,
|
|
const char* buf, int bufLen)
|
|
{
|
|
int i;
|
|
|
|
if (ctx == NULL || bufLen > MAX_SERVER_CERT_TYPE_CNT) {
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
/* if buf is set to NULL or bufLen is set to zero, it defaults the setting*/
|
|
if (buf == NULL || bufLen == 0) {
|
|
ctx->rpkConfig.preferred_ServerCertTypeCnt = 1;
|
|
ctx->rpkConfig.preferred_ServerCertTypes[0]= WOLFSSL_CERT_TYPE_X509;
|
|
ctx->rpkConfig.preferred_ServerCertTypes[1]= WOLFSSL_CERT_TYPE_X509;
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
if (!isArrayUnique(buf, bufLen))
|
|
return BAD_FUNC_ARG;
|
|
|
|
for (i = 0; i < bufLen; i++){
|
|
if (buf[i] != WOLFSSL_CERT_TYPE_RPK && buf[i] != WOLFSSL_CERT_TYPE_X509)
|
|
return BAD_FUNC_ARG;
|
|
|
|
ctx->rpkConfig.preferred_ServerCertTypes[i] = buf[i];
|
|
}
|
|
ctx->rpkConfig.preferred_ServerCertTypeCnt = bufLen;
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
/* Set user preference for the client_cert_type exetnsion.
|
|
* Takes byte array containing cert types the caller can provide to its peer.
|
|
* Cert types are in preferred order in the array.
|
|
*/
|
|
WOLFSSL_API int wolfSSL_set_client_cert_type(WOLFSSL* ssl,
|
|
const char* buf, int bufLen)
|
|
{
|
|
int i;
|
|
|
|
if (ssl == NULL || bufLen > MAX_CLIENT_CERT_TYPE_CNT) {
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
/* if buf is set to NULL or bufLen is set to zero, it defaults the setting*/
|
|
if (buf == NULL || bufLen == 0) {
|
|
ssl->options.rpkConfig.preferred_ClientCertTypeCnt = 1;
|
|
ssl->options.rpkConfig.preferred_ClientCertTypes[0]
|
|
= WOLFSSL_CERT_TYPE_X509;
|
|
ssl->options.rpkConfig.preferred_ClientCertTypes[1]
|
|
= WOLFSSL_CERT_TYPE_X509;
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
if (!isArrayUnique(buf, bufLen))
|
|
return BAD_FUNC_ARG;
|
|
|
|
for (i = 0; i < bufLen; i++){
|
|
if (buf[i] != WOLFSSL_CERT_TYPE_RPK && buf[i] != WOLFSSL_CERT_TYPE_X509)
|
|
return BAD_FUNC_ARG;
|
|
|
|
ssl->options.rpkConfig.preferred_ClientCertTypes[i] = buf[i];
|
|
}
|
|
ssl->options.rpkConfig.preferred_ClientCertTypeCnt = bufLen;
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
/* Set user preference for the server_cert_type exetnsion.
|
|
* Takes byte array containing cert types the caller can provide to its peer.
|
|
* Cert types are in preferred order in the array.
|
|
*/
|
|
WOLFSSL_API int wolfSSL_set_server_cert_type(WOLFSSL* ssl,
|
|
const char* buf, int bufLen)
|
|
{
|
|
int i;
|
|
|
|
if (ssl == NULL || bufLen > MAX_SERVER_CERT_TYPE_CNT) {
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
/* if buf is set to NULL or bufLen is set to zero, it defaults the setting*/
|
|
if (buf == NULL || bufLen == 0) {
|
|
ssl->options.rpkConfig.preferred_ServerCertTypeCnt = 1;
|
|
ssl->options.rpkConfig.preferred_ServerCertTypes[0]
|
|
= WOLFSSL_CERT_TYPE_X509;
|
|
ssl->options.rpkConfig.preferred_ServerCertTypes[1]
|
|
= WOLFSSL_CERT_TYPE_X509;
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
if (!isArrayUnique(buf, bufLen))
|
|
return BAD_FUNC_ARG;
|
|
|
|
for (i = 0; i < bufLen; i++){
|
|
if (buf[i] != WOLFSSL_CERT_TYPE_RPK && buf[i] != WOLFSSL_CERT_TYPE_X509)
|
|
return BAD_FUNC_ARG;
|
|
|
|
ssl->options.rpkConfig.preferred_ServerCertTypes[i] = buf[i];
|
|
}
|
|
ssl->options.rpkConfig.preferred_ServerCertTypeCnt = bufLen;
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
/* get negotiated certificate type value and return it to the second parameter.
|
|
* cert type value:
|
|
* -1: WOLFSSL_CERT_TYPE_UNKNOWN
|
|
* 0: WOLFSSL_CERT_TYPE_X509
|
|
* 2: WOLFSSL_CERT_TYPE_RPK
|
|
* return WOLFSSL_SUCCESS on success, otherwise negative value.
|
|
* in case no negotiation performed, it returns WOLFSSL_SUCCESS and -1 is for
|
|
* cert type.
|
|
*/
|
|
WOLFSSL_API int wolfSSL_get_negotiated_client_cert_type(WOLFSSL* ssl, int* tp)
|
|
{
|
|
int ret = WOLFSSL_SUCCESS;
|
|
|
|
if (ssl == NULL || tp == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
if (ssl->options.side == WOLFSSL_CLIENT_END) {
|
|
if (ssl->options.rpkState.received_ClientCertTypeCnt == 1)
|
|
*tp = ssl->options.rpkState.received_ClientCertTypes[0];
|
|
else
|
|
*tp = WOLFSSL_CERT_TYPE_UNKNOWN;
|
|
}
|
|
else {
|
|
if (ssl->options.rpkState.sending_ClientCertTypeCnt == 1)
|
|
*tp = ssl->options.rpkState.sending_ClientCertTypes[0];
|
|
else
|
|
*tp = WOLFSSL_CERT_TYPE_UNKNOWN;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/* get negotiated certificate type value and return it to the second parameter.
|
|
* cert type value:
|
|
* -1: WOLFSSL_CERT_TYPE_UNKNOWN
|
|
* 0: WOLFSSL_CERT_TYPE_X509
|
|
* 2: WOLFSSL_CERT_TYPE_RPK
|
|
* return WOLFSSL_SUCCESS on success, otherwise negative value.
|
|
* in case no negotiation performed, it returns WOLFSSL_SUCCESS and -1 is for
|
|
* cert type.
|
|
*/
|
|
WOLFSSL_API int wolfSSL_get_negotiated_server_cert_type(WOLFSSL* ssl, int* tp)
|
|
{
|
|
int ret = WOLFSSL_SUCCESS;
|
|
|
|
if (ssl == NULL || tp == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
if (ssl->options.side == WOLFSSL_CLIENT_END) {
|
|
if (ssl->options.rpkState.received_ServerCertTypeCnt == 1)
|
|
*tp = ssl->options.rpkState.received_ServerCertTypes[0];
|
|
else
|
|
*tp = WOLFSSL_CERT_TYPE_UNKNOWN;
|
|
}
|
|
else {
|
|
if (ssl->options.rpkState.sending_ServerCertTypeCnt == 1)
|
|
*tp = ssl->options.rpkState.sending_ServerCertTypes[0];
|
|
else
|
|
*tp = WOLFSSL_CERT_TYPE_UNKNOWN;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
#endif /* HAVE_RPK */
|
|
|
|
int wolfSSL_use_certificate_ASN1(WOLFSSL* ssl, const unsigned char* der,
|
|
int derSz)
|
|
{
|
|
long idx;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_use_certificate_ASN1");
|
|
if (der != NULL && ssl != NULL) {
|
|
if (ProcessBuffer(NULL, der, derSz, WOLFSSL_FILETYPE_ASN1, CERT_TYPE,
|
|
ssl, &idx, 0, GET_VERIFY_SETTING_SSL(ssl)) == WOLFSSL_SUCCESS) {
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
}
|
|
|
|
(void)idx;
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
#ifndef NO_FILESYSTEM
|
|
|
|
WOLFSSL_ABI
|
|
int wolfSSL_use_certificate_file(WOLFSSL* ssl, const char* file, int format)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_use_certificate_file");
|
|
|
|
if (ssl == NULL) {
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
if (ProcessFile(ssl->ctx, file, format, CERT_TYPE,
|
|
ssl, 0, NULL, GET_VERIFY_SETTING_SSL(ssl)) == WOLFSSL_SUCCESS) {
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
|
|
WOLFSSL_ABI
|
|
int wolfSSL_use_PrivateKey_file(WOLFSSL* ssl, const char* file, int format)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_use_PrivateKey_file");
|
|
|
|
if (ssl == NULL) {
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
if (ProcessFile(ssl->ctx, file, format, PRIVATEKEY_TYPE,
|
|
ssl, 0, NULL, GET_VERIFY_SETTING_SSL(ssl)) == WOLFSSL_SUCCESS) {
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
|
|
WOLFSSL_ABI
|
|
int wolfSSL_use_certificate_chain_file(WOLFSSL* ssl, const char* file)
|
|
{
|
|
/* process up to MAX_CHAIN_DEPTH plus subject cert */
|
|
WOLFSSL_ENTER("wolfSSL_use_certificate_chain_file");
|
|
|
|
if (ssl == NULL) {
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
if (ProcessFile(ssl->ctx, file, WOLFSSL_FILETYPE_PEM, CERT_TYPE,
|
|
ssl, 1, NULL, GET_VERIFY_SETTING_SSL(ssl)) == WOLFSSL_SUCCESS) {
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
int wolfSSL_use_certificate_chain_file_format(WOLFSSL* ssl, const char* file,
|
|
int format)
|
|
{
|
|
/* process up to MAX_CHAIN_DEPTH plus subject cert */
|
|
WOLFSSL_ENTER("wolfSSL_use_certificate_chain_file_format");
|
|
|
|
if (ssl == NULL) {
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
if (ProcessFile(ssl->ctx, file, format, CERT_TYPE, ssl, 1,
|
|
NULL, GET_VERIFY_SETTING_SSL(ssl)) == WOLFSSL_SUCCESS) {
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
#endif /* !NO_FILESYSTEM */
|
|
|
|
#ifdef HAVE_ECC
|
|
|
|
/* Set Temp CTX EC-DHE size in octets, can be 14 - 66 (112 - 521 bit) */
|
|
int wolfSSL_CTX_SetTmpEC_DHE_Sz(WOLFSSL_CTX* ctx, word16 sz)
|
|
{
|
|
if (ctx == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
/* if 0 then get from loaded private key */
|
|
if (sz == 0) {
|
|
/* applies only to ECDSA */
|
|
if (ctx->privateKeyType != ecc_dsa_sa_algo)
|
|
return WOLFSSL_SUCCESS;
|
|
|
|
if (ctx->privateKeySz == 0) {
|
|
WOLFSSL_MSG("Must set private key/cert first");
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
sz = (word16)ctx->privateKeySz;
|
|
}
|
|
|
|
/* check size */
|
|
#if ECC_MIN_KEY_SZ > 0
|
|
if (sz < ECC_MINSIZE)
|
|
return BAD_FUNC_ARG;
|
|
#endif
|
|
if (sz > ECC_MAXSIZE)
|
|
return BAD_FUNC_ARG;
|
|
|
|
ctx->eccTempKeySz = sz;
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
|
|
/* Set Temp SSL EC-DHE size in octets, can be 14 - 66 (112 - 521 bit) */
|
|
int wolfSSL_SetTmpEC_DHE_Sz(WOLFSSL* ssl, word16 sz)
|
|
{
|
|
if (ssl == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
/* check size */
|
|
#if ECC_MIN_KEY_SZ > 0
|
|
if (sz < ECC_MINSIZE)
|
|
return BAD_FUNC_ARG;
|
|
#endif
|
|
if (sz > ECC_MAXSIZE)
|
|
return BAD_FUNC_ARG;
|
|
|
|
ssl->eccTempKeySz = sz;
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
#endif /* HAVE_ECC */
|
|
|
|
|
|
#ifdef OPENSSL_EXTRA
|
|
|
|
#ifndef NO_FILESYSTEM
|
|
int wolfSSL_CTX_use_RSAPrivateKey_file(WOLFSSL_CTX* ctx,const char* file,
|
|
int format)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_use_RSAPrivateKey_file");
|
|
|
|
return wolfSSL_CTX_use_PrivateKey_file(ctx, file, format);
|
|
}
|
|
|
|
|
|
int wolfSSL_use_RSAPrivateKey_file(WOLFSSL* ssl, const char* file, int format)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_use_RSAPrivateKey_file");
|
|
|
|
return wolfSSL_use_PrivateKey_file(ssl, file, format);
|
|
}
|
|
#endif /* NO_FILESYSTEM */
|
|
|
|
|
|
/* Copies the master secret over to out buffer. If outSz is 0 returns the size
|
|
* of master secret.
|
|
*
|
|
* ses : a session from completed TLS/SSL handshake
|
|
* out : buffer to hold copy of master secret
|
|
* outSz : size of out buffer
|
|
* returns : number of bytes copied into out buffer on success
|
|
* less then or equal to 0 is considered a failure case
|
|
*/
|
|
int wolfSSL_SESSION_get_master_key(const WOLFSSL_SESSION* ses,
|
|
unsigned char* out, int outSz)
|
|
{
|
|
int size;
|
|
|
|
ses = ClientSessionToSession(ses);
|
|
|
|
if (outSz == 0) {
|
|
return SECRET_LEN;
|
|
}
|
|
|
|
if (ses == NULL || out == NULL || outSz < 0) {
|
|
return 0;
|
|
}
|
|
|
|
if (outSz > SECRET_LEN) {
|
|
size = SECRET_LEN;
|
|
}
|
|
else {
|
|
size = outSz;
|
|
}
|
|
|
|
XMEMCPY(out, ses->masterSecret, size);
|
|
return size;
|
|
}
|
|
|
|
|
|
int wolfSSL_SESSION_get_master_key_length(const WOLFSSL_SESSION* ses)
|
|
{
|
|
(void)ses;
|
|
return SECRET_LEN;
|
|
}
|
|
|
|
#ifdef WOLFSSL_EARLY_DATA
|
|
unsigned int wolfSSL_SESSION_get_max_early_data(const WOLFSSL_SESSION *session)
|
|
{
|
|
return session->maxEarlyDataSz;
|
|
}
|
|
#endif /* WOLFSSL_EARLY_DATA */
|
|
|
|
#endif /* OPENSSL_EXTRA */
|
|
|
|
typedef struct {
|
|
byte verifyPeer:1;
|
|
byte verifyNone:1;
|
|
byte failNoCert:1;
|
|
byte failNoCertxPSK:1;
|
|
byte verifyPostHandshake:1;
|
|
} SetVerifyOptions;
|
|
|
|
static SetVerifyOptions ModeToVerifyOptions(int mode)
|
|
{
|
|
SetVerifyOptions opts;
|
|
XMEMSET(&opts, 0, sizeof(SetVerifyOptions));
|
|
|
|
if (mode != WOLFSSL_VERIFY_DEFAULT) {
|
|
opts.verifyNone = (mode == WOLFSSL_VERIFY_NONE);
|
|
if (!opts.verifyNone) {
|
|
opts.verifyPeer =
|
|
(mode & WOLFSSL_VERIFY_PEER) != 0;
|
|
opts.failNoCertxPSK =
|
|
(mode & WOLFSSL_VERIFY_FAIL_EXCEPT_PSK) != 0;
|
|
opts.failNoCert =
|
|
(mode & WOLFSSL_VERIFY_FAIL_IF_NO_PEER_CERT) != 0;
|
|
#if defined(WOLFSSL_TLS13) && defined(WOLFSSL_POST_HANDSHAKE_AUTH)
|
|
opts.verifyPostHandshake =
|
|
(mode & WOLFSSL_VERIFY_POST_HANDSHAKE) != 0;
|
|
#endif
|
|
}
|
|
}
|
|
|
|
return opts;
|
|
}
|
|
|
|
WOLFSSL_ABI
|
|
void wolfSSL_CTX_set_verify(WOLFSSL_CTX* ctx, int mode, VerifyCallback vc)
|
|
{
|
|
SetVerifyOptions opts;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_CTX_set_verify");
|
|
if (ctx == NULL)
|
|
return;
|
|
|
|
opts = ModeToVerifyOptions(mode);
|
|
|
|
ctx->verifyNone = opts.verifyNone;
|
|
ctx->verifyPeer = opts.verifyPeer;
|
|
ctx->failNoCert = opts.failNoCert;
|
|
ctx->failNoCertxPSK = opts.failNoCertxPSK;
|
|
#if defined(WOLFSSL_TLS13) && defined(WOLFSSL_POST_HANDSHAKE_AUTH)
|
|
ctx->verifyPostHandshake = opts.verifyPostHandshake;
|
|
#endif
|
|
|
|
ctx->verifyCallback = vc;
|
|
}
|
|
|
|
#ifdef OPENSSL_ALL
|
|
void wolfSSL_CTX_set_cert_verify_callback(WOLFSSL_CTX* ctx,
|
|
CertVerifyCallback cb, void* arg)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_set_cert_verify_callback");
|
|
if (ctx == NULL)
|
|
return;
|
|
|
|
ctx->verifyCertCb = cb;
|
|
ctx->verifyCertCbArg = arg;
|
|
}
|
|
#endif
|
|
|
|
|
|
void wolfSSL_set_verify(WOLFSSL* ssl, int mode, VerifyCallback vc)
|
|
{
|
|
SetVerifyOptions opts;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_set_verify");
|
|
if (ssl == NULL)
|
|
return;
|
|
|
|
opts = ModeToVerifyOptions(mode);
|
|
|
|
ssl->options.verifyNone = opts.verifyNone;
|
|
ssl->options.verifyPeer = opts.verifyPeer;
|
|
ssl->options.failNoCert = opts.failNoCert;
|
|
ssl->options.failNoCertxPSK = opts.failNoCertxPSK;
|
|
#if defined(WOLFSSL_TLS13) && defined(WOLFSSL_POST_HANDSHAKE_AUTH)
|
|
ssl->options.verifyPostHandshake = opts.verifyPostHandshake;
|
|
#endif
|
|
|
|
ssl->verifyCallback = vc;
|
|
}
|
|
|
|
void wolfSSL_set_verify_result(WOLFSSL *ssl, long v)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_set_verify_result");
|
|
|
|
if (ssl == NULL)
|
|
return;
|
|
|
|
#if defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL) || \
|
|
defined(OPENSSL_ALL)
|
|
ssl->peerVerifyRet = v;
|
|
#else
|
|
(void)v;
|
|
WOLFSSL_STUB("wolfSSL_set_verify_result");
|
|
#endif
|
|
}
|
|
|
|
#if defined(OPENSSL_EXTRA) && !defined(NO_CERTS) && \
|
|
defined(WOLFSSL_TLS13) && defined(WOLFSSL_POST_HANDSHAKE_AUTH)
|
|
/* For TLS v1.3 send handshake messages after handshake completes. */
|
|
/* Returns 1=WOLFSSL_SUCCESS or 0=WOLFSSL_FAILURE */
|
|
int wolfSSL_verify_client_post_handshake(WOLFSSL* ssl)
|
|
{
|
|
int ret = wolfSSL_request_certificate(ssl);
|
|
if (ret != WOLFSSL_SUCCESS) {
|
|
if (!IsAtLeastTLSv1_3(ssl->version)) {
|
|
/* specific error of wrong version expected */
|
|
WOLFSSL_ERROR(UNSUPPORTED_PROTO_VERSION);
|
|
|
|
}
|
|
else {
|
|
WOLFSSL_ERROR(ret); /* log the error in the error queue */
|
|
}
|
|
}
|
|
return (ret == WOLFSSL_SUCCESS) ? WOLFSSL_SUCCESS : WOLFSSL_FAILURE;
|
|
}
|
|
|
|
int wolfSSL_CTX_set_post_handshake_auth(WOLFSSL_CTX* ctx, int val)
|
|
{
|
|
int ret = wolfSSL_CTX_allow_post_handshake_auth(ctx);
|
|
if (ret == 0) {
|
|
ctx->postHandshakeAuth = (val != 0);
|
|
}
|
|
return (ret == 0) ? WOLFSSL_SUCCESS : WOLFSSL_FAILURE;
|
|
}
|
|
int wolfSSL_set_post_handshake_auth(WOLFSSL* ssl, int val)
|
|
{
|
|
int ret = wolfSSL_allow_post_handshake_auth(ssl);
|
|
if (ret == 0) {
|
|
ssl->options.postHandshakeAuth = (val != 0);
|
|
}
|
|
return (ret == 0) ? WOLFSSL_SUCCESS : WOLFSSL_FAILURE;
|
|
}
|
|
#endif /* OPENSSL_EXTRA && !NO_CERTS && WOLFSSL_TLS13 && WOLFSSL_POST_HANDSHAKE_AUTH */
|
|
|
|
/* store user ctx for verify callback */
|
|
void wolfSSL_SetCertCbCtx(WOLFSSL* ssl, void* ctx)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_SetCertCbCtx");
|
|
if (ssl)
|
|
ssl->verifyCbCtx = ctx;
|
|
}
|
|
|
|
|
|
/* store user ctx for verify callback */
|
|
void wolfSSL_CTX_SetCertCbCtx(WOLFSSL_CTX* ctx, void* userCtx)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_SetCertCbCtx");
|
|
if (ctx)
|
|
ctx->verifyCbCtx = userCtx;
|
|
}
|
|
|
|
|
|
/* store context CA Cache addition callback */
|
|
void wolfSSL_CTX_SetCACb(WOLFSSL_CTX* ctx, CallbackCACache cb)
|
|
{
|
|
if (ctx && ctx->cm)
|
|
ctx->cm->caCacheCallback = cb;
|
|
}
|
|
|
|
|
|
#if defined(PERSIST_CERT_CACHE)
|
|
|
|
#if !defined(NO_FILESYSTEM)
|
|
|
|
/* Persist cert cache to file */
|
|
int wolfSSL_CTX_save_cert_cache(WOLFSSL_CTX* ctx, const char* fname)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_save_cert_cache");
|
|
|
|
if (ctx == NULL || fname == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
return CM_SaveCertCache(ctx->cm, fname);
|
|
}
|
|
|
|
|
|
/* Persist cert cache from file */
|
|
int wolfSSL_CTX_restore_cert_cache(WOLFSSL_CTX* ctx, const char* fname)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_restore_cert_cache");
|
|
|
|
if (ctx == NULL || fname == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
return CM_RestoreCertCache(ctx->cm, fname);
|
|
}
|
|
|
|
#endif /* NO_FILESYSTEM */
|
|
|
|
/* Persist cert cache to memory */
|
|
int wolfSSL_CTX_memsave_cert_cache(WOLFSSL_CTX* ctx, void* mem,
|
|
int sz, int* used)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_memsave_cert_cache");
|
|
|
|
if (ctx == NULL || mem == NULL || used == NULL || sz <= 0)
|
|
return BAD_FUNC_ARG;
|
|
|
|
return CM_MemSaveCertCache(ctx->cm, mem, sz, used);
|
|
}
|
|
|
|
|
|
/* Restore cert cache from memory */
|
|
int wolfSSL_CTX_memrestore_cert_cache(WOLFSSL_CTX* ctx, const void* mem, int sz)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_memrestore_cert_cache");
|
|
|
|
if (ctx == NULL || mem == NULL || sz <= 0)
|
|
return BAD_FUNC_ARG;
|
|
|
|
return CM_MemRestoreCertCache(ctx->cm, mem, sz);
|
|
}
|
|
|
|
|
|
/* get how big the the cert cache save buffer needs to be */
|
|
int wolfSSL_CTX_get_cert_cache_memsize(WOLFSSL_CTX* ctx)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_get_cert_cache_memsize");
|
|
|
|
if (ctx == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
return CM_GetCertCacheMemSize(ctx->cm);
|
|
}
|
|
|
|
#endif /* PERSIST_CERT_CACHE */
|
|
#endif /* !NO_CERTS */
|
|
|
|
|
|
#ifndef NO_SESSION_CACHE
|
|
|
|
WOLFSSL_ABI
|
|
WOLFSSL_SESSION* wolfSSL_get_session(WOLFSSL* ssl)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_get_session");
|
|
if (ssl) {
|
|
#ifdef NO_SESSION_CACHE_REF
|
|
return ssl->session;
|
|
#else
|
|
if (ssl->options.side == WOLFSSL_CLIENT_END) {
|
|
/* On the client side we want to return a persistent reference for
|
|
* backwards compatibility. */
|
|
#ifndef NO_CLIENT_CACHE
|
|
if (ssl->clientSession) {
|
|
return (WOLFSSL_SESSION*)ssl->clientSession;
|
|
}
|
|
else {
|
|
/* Try to add a ClientCache entry to associate with the current
|
|
* session. Ignore any session cache options. */
|
|
int err;
|
|
const byte* id = ssl->session->sessionID;
|
|
byte idSz = ssl->session->sessionIDSz;
|
|
if (ssl->session->haveAltSessionID) {
|
|
id = ssl->session->altSessionID;
|
|
idSz = ID_LEN;
|
|
}
|
|
err = AddSessionToCache(ssl->ctx, ssl->session, id, idSz,
|
|
NULL, ssl->session->side,
|
|
#ifdef HAVE_SESSION_TICKET
|
|
ssl->session->ticketLen > 0,
|
|
#else
|
|
0,
|
|
#endif
|
|
&ssl->clientSession);
|
|
if (err == 0) {
|
|
return (WOLFSSL_SESSION*)ssl->clientSession;
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
else {
|
|
return ssl->session;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/* The get1 version requires caller to call SSL_SESSION_free */
|
|
WOLFSSL_SESSION* wolfSSL_get1_session(WOLFSSL* ssl)
|
|
{
|
|
WOLFSSL_SESSION* sess = NULL;
|
|
WOLFSSL_ENTER("wolfSSL_get1_session");
|
|
if (ssl != NULL) {
|
|
sess = ssl->session;
|
|
if (sess != NULL) {
|
|
/* increase reference count if allocated session */
|
|
if (sess->type == WOLFSSL_SESSION_TYPE_HEAP) {
|
|
if (wolfSSL_SESSION_up_ref(sess) != WOLFSSL_SUCCESS)
|
|
sess = NULL;
|
|
}
|
|
}
|
|
}
|
|
return sess;
|
|
}
|
|
|
|
|
|
/*
|
|
* Sets the session object to use when establishing a TLS/SSL session using
|
|
* the ssl object. Therefore, this function must be called before
|
|
* wolfSSL_connect. The session object to use can be obtained in a previous
|
|
* TLS/SSL connection using wolfSSL_get_session.
|
|
*
|
|
* This function rejects the session if it has been expired when this function
|
|
* is called. Note that this expiration check is wolfSSL specific and differs
|
|
* from OpenSSL return code behavior.
|
|
*
|
|
* By default, wolfSSL_set_session returns WOLFSSL_SUCCESS on successfully
|
|
* setting the session, WOLFSSL_FAILURE on failure due to the session cache
|
|
* being disabled, or the session has expired.
|
|
*
|
|
* To match OpenSSL return code behavior when session is expired, define
|
|
* OPENSSL_EXTRA and WOLFSSL_ERROR_CODE_OPENSSL. This behavior will return
|
|
* WOLFSSL_SUCCESS even when the session is expired and rejected.
|
|
*/
|
|
WOLFSSL_ABI
|
|
int wolfSSL_set_session(WOLFSSL* ssl, WOLFSSL_SESSION* session)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_set_session");
|
|
if (session)
|
|
return wolfSSL_SetSession(ssl, session);
|
|
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
|
|
#ifndef NO_CLIENT_CACHE
|
|
|
|
/* Associate client session with serverID, find existing or store for saving
|
|
if newSession flag on, don't reuse existing session
|
|
WOLFSSL_SUCCESS on ok */
|
|
int wolfSSL_SetServerID(WOLFSSL* ssl, const byte* id, int len, int newSession)
|
|
{
|
|
WOLFSSL_SESSION* session = NULL;
|
|
byte idHash[SERVER_ID_LEN];
|
|
|
|
WOLFSSL_ENTER("wolfSSL_SetServerID");
|
|
|
|
if (ssl == NULL || id == NULL || len <= 0)
|
|
return BAD_FUNC_ARG;
|
|
|
|
if (len > SERVER_ID_LEN) {
|
|
#if defined(NO_SHA) && !defined(NO_SHA256)
|
|
if (wc_Sha256Hash(id, len, idHash) != 0)
|
|
return WOLFSSL_FAILURE;
|
|
#else
|
|
if (wc_ShaHash(id, len, idHash) != 0)
|
|
return WOLFSSL_FAILURE;
|
|
#endif
|
|
id = idHash;
|
|
len = SERVER_ID_LEN;
|
|
}
|
|
|
|
if (newSession == 0) {
|
|
session = wolfSSL_GetSessionClient(ssl, id, len);
|
|
if (session) {
|
|
if (wolfSSL_SetSession(ssl, session) != WOLFSSL_SUCCESS) {
|
|
#ifdef HAVE_EXT_CACHE
|
|
wolfSSL_FreeSession(ssl->ctx, session);
|
|
#endif
|
|
WOLFSSL_MSG("wolfSSL_SetSession failed");
|
|
session = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (session == NULL) {
|
|
WOLFSSL_MSG("Valid ServerID not cached already");
|
|
|
|
ssl->session->idLen = (word16)len;
|
|
XMEMCPY(ssl->session->serverID, id, len);
|
|
}
|
|
#ifdef HAVE_EXT_CACHE
|
|
else {
|
|
wolfSSL_FreeSession(ssl->ctx, session);
|
|
}
|
|
#endif
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
#endif /* !NO_CLIENT_CACHE */
|
|
|
|
/* TODO: Add SESSION_CACHE_DYNAMIC_MEM support for PERSIST_SESSION_CACHE.
|
|
* Need a count of current sessions to get an accurate memsize (totalCount is
|
|
* not decremented when sessions are removed).
|
|
* Need to determine ideal layout for mem/filesave.
|
|
* Also need mem/filesave checking to ensure not restoring non DYNAMIC_MEM cache.
|
|
*/
|
|
#if defined(PERSIST_SESSION_CACHE) && !defined(SESSION_CACHE_DYNAMIC_MEM)
|
|
|
|
/* for persistence, if changes to layout need to increment and modify
|
|
save_session_cache() and restore_session_cache and memory versions too */
|
|
#define WOLFSSL_CACHE_VERSION 2
|
|
|
|
/* Session Cache Header information */
|
|
typedef struct {
|
|
int version; /* cache layout version id */
|
|
int rows; /* session rows */
|
|
int columns; /* session columns */
|
|
int sessionSz; /* sizeof WOLFSSL_SESSION */
|
|
} cache_header_t;
|
|
|
|
/* current persistence layout is:
|
|
|
|
1) cache_header_t
|
|
2) SessionCache
|
|
3) ClientCache
|
|
|
|
update WOLFSSL_CACHE_VERSION if change layout for the following
|
|
PERSISTENT_SESSION_CACHE functions
|
|
*/
|
|
|
|
/* get how big the the session cache save buffer needs to be */
|
|
int wolfSSL_get_session_cache_memsize(void)
|
|
{
|
|
int sz = (int)(sizeof(SessionCache) + sizeof(cache_header_t));
|
|
#ifndef NO_CLIENT_CACHE
|
|
sz += (int)(sizeof(ClientCache));
|
|
#endif
|
|
return sz;
|
|
}
|
|
|
|
|
|
/* Persist session cache to memory */
|
|
int wolfSSL_memsave_session_cache(void* mem, int sz)
|
|
{
|
|
int i;
|
|
cache_header_t cache_header;
|
|
SessionRow* row = (SessionRow*)((byte*)mem + sizeof(cache_header));
|
|
|
|
WOLFSSL_ENTER("wolfSSL_memsave_session_cache");
|
|
|
|
if (sz < wolfSSL_get_session_cache_memsize()) {
|
|
WOLFSSL_MSG("Memory buffer too small");
|
|
return BUFFER_E;
|
|
}
|
|
|
|
cache_header.version = WOLFSSL_CACHE_VERSION;
|
|
cache_header.rows = SESSION_ROWS;
|
|
cache_header.columns = SESSIONS_PER_ROW;
|
|
cache_header.sessionSz = (int)sizeof(WOLFSSL_SESSION);
|
|
XMEMCPY(mem, &cache_header, sizeof(cache_header));
|
|
|
|
#ifndef ENABLE_SESSION_CACHE_ROW_LOCK
|
|
if (SESSION_ROW_RD_LOCK(row) != 0) {
|
|
WOLFSSL_MSG("Session cache mutex lock failed");
|
|
return BAD_MUTEX_E;
|
|
}
|
|
#endif
|
|
for (i = 0; i < cache_header.rows; ++i) {
|
|
#ifdef ENABLE_SESSION_CACHE_ROW_LOCK
|
|
if (SESSION_ROW_RD_LOCK(&SessionCache[i]) != 0) {
|
|
WOLFSSL_MSG("Session row cache mutex lock failed");
|
|
return BAD_MUTEX_E;
|
|
}
|
|
#endif
|
|
|
|
XMEMCPY(row++, &SessionCache[i], SIZEOF_SESSION_ROW);
|
|
#ifdef ENABLE_SESSION_CACHE_ROW_LOCK
|
|
SESSION_ROW_UNLOCK(&SessionCache[i]);
|
|
#endif
|
|
}
|
|
#ifndef ENABLE_SESSION_CACHE_ROW_LOCK
|
|
SESSION_ROW_UNLOCK(row);
|
|
#endif
|
|
|
|
#ifndef NO_CLIENT_CACHE
|
|
if (wc_LockMutex(&clisession_mutex) != 0) {
|
|
WOLFSSL_MSG("Client cache mutex lock failed");
|
|
return BAD_MUTEX_E;
|
|
}
|
|
XMEMCPY(row, ClientCache, sizeof(ClientCache));
|
|
wc_UnLockMutex(&clisession_mutex);
|
|
#endif
|
|
|
|
WOLFSSL_LEAVE("wolfSSL_memsave_session_cache", WOLFSSL_SUCCESS);
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
|
|
/* Restore the persistent session cache from memory */
|
|
int wolfSSL_memrestore_session_cache(const void* mem, int sz)
|
|
{
|
|
int i;
|
|
cache_header_t cache_header;
|
|
SessionRow* row = (SessionRow*)((byte*)mem + sizeof(cache_header));
|
|
|
|
WOLFSSL_ENTER("wolfSSL_memrestore_session_cache");
|
|
|
|
if (sz < wolfSSL_get_session_cache_memsize()) {
|
|
WOLFSSL_MSG("Memory buffer too small");
|
|
return BUFFER_E;
|
|
}
|
|
|
|
XMEMCPY(&cache_header, mem, sizeof(cache_header));
|
|
if (cache_header.version != WOLFSSL_CACHE_VERSION ||
|
|
cache_header.rows != SESSION_ROWS ||
|
|
cache_header.columns != SESSIONS_PER_ROW ||
|
|
cache_header.sessionSz != (int)sizeof(WOLFSSL_SESSION)) {
|
|
|
|
WOLFSSL_MSG("Session cache header match failed");
|
|
return CACHE_MATCH_ERROR;
|
|
}
|
|
|
|
#ifndef ENABLE_SESSION_CACHE_ROW_LOCK
|
|
if (SESSION_ROW_WR_LOCK(&SessionCache[0]) != 0) {
|
|
WOLFSSL_MSG("Session cache mutex lock failed");
|
|
return BAD_MUTEX_E;
|
|
}
|
|
#endif
|
|
for (i = 0; i < cache_header.rows; ++i) {
|
|
#ifdef ENABLE_SESSION_CACHE_ROW_LOCK
|
|
if (SESSION_ROW_WR_LOCK(&SessionCache[i]) != 0) {
|
|
WOLFSSL_MSG("Session row cache mutex lock failed");
|
|
return BAD_MUTEX_E;
|
|
}
|
|
#endif
|
|
|
|
XMEMCPY(&SessionCache[i], row++, SIZEOF_SESSION_ROW);
|
|
#ifdef ENABLE_SESSION_CACHE_ROW_LOCK
|
|
SESSION_ROW_UNLOCK(&SessionCache[i]);
|
|
#endif
|
|
}
|
|
#ifndef ENABLE_SESSION_CACHE_ROW_LOCK
|
|
SESSION_ROW_UNLOCK(&SessionCache[0]);
|
|
#endif
|
|
|
|
#ifndef NO_CLIENT_CACHE
|
|
if (wc_LockMutex(&clisession_mutex) != 0) {
|
|
WOLFSSL_MSG("Client cache mutex lock failed");
|
|
return BAD_MUTEX_E;
|
|
}
|
|
XMEMCPY(ClientCache, row, sizeof(ClientCache));
|
|
wc_UnLockMutex(&clisession_mutex);
|
|
#endif
|
|
|
|
WOLFSSL_LEAVE("wolfSSL_memrestore_session_cache", WOLFSSL_SUCCESS);
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
#if !defined(NO_FILESYSTEM)
|
|
|
|
/* Persist session cache to file */
|
|
/* doesn't use memsave because of additional memory use */
|
|
int wolfSSL_save_session_cache(const char *fname)
|
|
{
|
|
XFILE file;
|
|
int ret;
|
|
int rc = WOLFSSL_SUCCESS;
|
|
int i;
|
|
cache_header_t cache_header;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_save_session_cache");
|
|
|
|
file = XFOPEN(fname, "w+b");
|
|
if (file == XBADFILE) {
|
|
WOLFSSL_MSG("Couldn't open session cache save file");
|
|
return WOLFSSL_BAD_FILE;
|
|
}
|
|
cache_header.version = WOLFSSL_CACHE_VERSION;
|
|
cache_header.rows = SESSION_ROWS;
|
|
cache_header.columns = SESSIONS_PER_ROW;
|
|
cache_header.sessionSz = (int)sizeof(WOLFSSL_SESSION);
|
|
|
|
/* cache header */
|
|
ret = (int)XFWRITE(&cache_header, sizeof cache_header, 1, file);
|
|
if (ret != 1) {
|
|
WOLFSSL_MSG("Session cache header file write failed");
|
|
XFCLOSE(file);
|
|
return FWRITE_ERROR;
|
|
}
|
|
|
|
#ifndef ENABLE_SESSION_CACHE_ROW_LOCK
|
|
if (SESSION_ROW_RD_LOCK(&SessionCache[0]) != 0) {
|
|
WOLFSSL_MSG("Session cache mutex lock failed");
|
|
XFCLOSE(file);
|
|
return BAD_MUTEX_E;
|
|
}
|
|
#endif
|
|
/* session cache */
|
|
for (i = 0; i < cache_header.rows; ++i) {
|
|
#ifdef ENABLE_SESSION_CACHE_ROW_LOCK
|
|
if (SESSION_ROW_RD_LOCK(&SessionCache[i]) != 0) {
|
|
WOLFSSL_MSG("Session row cache mutex lock failed");
|
|
XFCLOSE(file);
|
|
return BAD_MUTEX_E;
|
|
}
|
|
#endif
|
|
|
|
ret = (int)XFWRITE(&SessionCache[i], SIZEOF_SESSION_ROW, 1, file);
|
|
#ifdef ENABLE_SESSION_CACHE_ROW_LOCK
|
|
SESSION_ROW_UNLOCK(&SessionCache[i]);
|
|
#endif
|
|
if (ret != 1) {
|
|
WOLFSSL_MSG("Session cache member file write failed");
|
|
rc = FWRITE_ERROR;
|
|
break;
|
|
}
|
|
}
|
|
#ifndef ENABLE_SESSION_CACHE_ROW_LOCK
|
|
SESSION_ROW_UNLOCK(&SessionCache[0]);
|
|
#endif
|
|
|
|
#ifndef NO_CLIENT_CACHE
|
|
/* client cache */
|
|
if (wc_LockMutex(&clisession_mutex) != 0) {
|
|
WOLFSSL_MSG("Client cache mutex lock failed");
|
|
XFCLOSE(file);
|
|
return BAD_MUTEX_E;
|
|
}
|
|
ret = (int)XFWRITE(ClientCache, sizeof(ClientCache), 1, file);
|
|
if (ret != 1) {
|
|
WOLFSSL_MSG("Client cache member file write failed");
|
|
rc = FWRITE_ERROR;
|
|
}
|
|
wc_UnLockMutex(&clisession_mutex);
|
|
#endif /* !NO_CLIENT_CACHE */
|
|
|
|
XFCLOSE(file);
|
|
WOLFSSL_LEAVE("wolfSSL_save_session_cache", rc);
|
|
|
|
return rc;
|
|
}
|
|
|
|
|
|
/* Restore the persistent session cache from file */
|
|
/* doesn't use memstore because of additional memory use */
|
|
int wolfSSL_restore_session_cache(const char *fname)
|
|
{
|
|
XFILE file;
|
|
int rc = WOLFSSL_SUCCESS;
|
|
int ret;
|
|
int i;
|
|
cache_header_t cache_header;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_restore_session_cache");
|
|
|
|
file = XFOPEN(fname, "rb");
|
|
if (file == XBADFILE) {
|
|
WOLFSSL_MSG("Couldn't open session cache save file");
|
|
return WOLFSSL_BAD_FILE;
|
|
}
|
|
/* cache header */
|
|
ret = (int)XFREAD(&cache_header, sizeof(cache_header), 1, file);
|
|
if (ret != 1) {
|
|
WOLFSSL_MSG("Session cache header file read failed");
|
|
XFCLOSE(file);
|
|
return FREAD_ERROR;
|
|
}
|
|
if (cache_header.version != WOLFSSL_CACHE_VERSION ||
|
|
cache_header.rows != SESSION_ROWS ||
|
|
cache_header.columns != SESSIONS_PER_ROW ||
|
|
cache_header.sessionSz != (int)sizeof(WOLFSSL_SESSION)) {
|
|
|
|
WOLFSSL_MSG("Session cache header match failed");
|
|
XFCLOSE(file);
|
|
return CACHE_MATCH_ERROR;
|
|
}
|
|
|
|
#ifndef ENABLE_SESSION_CACHE_ROW_LOCK
|
|
if (SESSION_ROW_WR_LOCK(&SessionCache[0]) != 0) {
|
|
WOLFSSL_MSG("Session cache mutex lock failed");
|
|
XFCLOSE(file);
|
|
return BAD_MUTEX_E;
|
|
}
|
|
#endif
|
|
/* session cache */
|
|
for (i = 0; i < cache_header.rows; ++i) {
|
|
#ifdef ENABLE_SESSION_CACHE_ROW_LOCK
|
|
if (SESSION_ROW_WR_LOCK(&SessionCache[i]) != 0) {
|
|
WOLFSSL_MSG("Session row cache mutex lock failed");
|
|
XFCLOSE(file);
|
|
return BAD_MUTEX_E;
|
|
}
|
|
#endif
|
|
|
|
ret = (int)XFREAD(&SessionCache[i], SIZEOF_SESSION_ROW, 1, file);
|
|
#ifdef ENABLE_SESSION_CACHE_ROW_LOCK
|
|
SESSION_ROW_UNLOCK(&SessionCache[i]);
|
|
#endif
|
|
if (ret != 1) {
|
|
WOLFSSL_MSG("Session cache member file read failed");
|
|
XMEMSET(SessionCache, 0, sizeof SessionCache);
|
|
rc = FREAD_ERROR;
|
|
break;
|
|
}
|
|
}
|
|
#ifndef ENABLE_SESSION_CACHE_ROW_LOCK
|
|
SESSION_ROW_UNLOCK(&SessionCache[0]);
|
|
#endif
|
|
|
|
#ifndef NO_CLIENT_CACHE
|
|
/* client cache */
|
|
if (wc_LockMutex(&clisession_mutex) != 0) {
|
|
WOLFSSL_MSG("Client cache mutex lock failed");
|
|
XFCLOSE(file);
|
|
return BAD_MUTEX_E;
|
|
}
|
|
ret = (int)XFREAD(ClientCache, sizeof(ClientCache), 1, file);
|
|
if (ret != 1) {
|
|
WOLFSSL_MSG("Client cache member file read failed");
|
|
XMEMSET(ClientCache, 0, sizeof ClientCache);
|
|
rc = FREAD_ERROR;
|
|
}
|
|
wc_UnLockMutex(&clisession_mutex);
|
|
#endif /* !NO_CLIENT_CACHE */
|
|
|
|
XFCLOSE(file);
|
|
WOLFSSL_LEAVE("wolfSSL_restore_session_cache", rc);
|
|
|
|
return rc;
|
|
}
|
|
|
|
#endif /* !NO_FILESYSTEM */
|
|
#endif /* PERSIST_SESSION_CACHE && !SESSION_CACHE_DYNAMIC_MEM */
|
|
#endif /* NO_SESSION_CACHE */
|
|
|
|
|
|
void wolfSSL_load_error_strings(void)
|
|
{
|
|
/* compatibility only */
|
|
}
|
|
|
|
|
|
int wolfSSL_library_init(void)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_library_init");
|
|
if (wolfSSL_Init() == WOLFSSL_SUCCESS)
|
|
return WOLFSSL_SUCCESS;
|
|
else
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
|
|
|
|
#ifdef HAVE_SECRET_CALLBACK
|
|
|
|
int wolfSSL_set_session_secret_cb(WOLFSSL* ssl, SessionSecretCb cb, void* ctx)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_set_session_secret_cb");
|
|
if (ssl == NULL)
|
|
return WOLFSSL_FATAL_ERROR;
|
|
|
|
ssl->sessionSecretCb = cb;
|
|
ssl->sessionSecretCtx = ctx;
|
|
if (cb != NULL) {
|
|
/* If using a pre-set key, assume session resumption. */
|
|
ssl->session->sessionIDSz = 0;
|
|
ssl->options.resuming = 1;
|
|
}
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
#ifndef NO_SESSION_CACHE
|
|
|
|
/* on by default if built in but allow user to turn off */
|
|
WOLFSSL_ABI
|
|
long wolfSSL_CTX_set_session_cache_mode(WOLFSSL_CTX* ctx, long mode)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_set_session_cache_mode");
|
|
|
|
if (ctx == NULL)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
if (mode == WOLFSSL_SESS_CACHE_OFF) {
|
|
ctx->sessionCacheOff = 1;
|
|
#ifdef HAVE_EXT_CACHE
|
|
ctx->internalCacheOff = 1;
|
|
ctx->internalCacheLookupOff = 1;
|
|
#endif
|
|
}
|
|
|
|
if ((mode & WOLFSSL_SESS_CACHE_NO_AUTO_CLEAR) != 0)
|
|
ctx->sessionCacheFlushOff = 1;
|
|
|
|
#ifdef HAVE_EXT_CACHE
|
|
/* WOLFSSL_SESS_CACHE_NO_INTERNAL activates both if's */
|
|
if ((mode & WOLFSSL_SESS_CACHE_NO_INTERNAL_STORE) != 0)
|
|
ctx->internalCacheOff = 1;
|
|
if ((mode & WOLFSSL_SESS_CACHE_NO_INTERNAL_LOOKUP) != 0)
|
|
ctx->internalCacheLookupOff = 1;
|
|
#endif
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
#ifdef OPENSSL_EXTRA
|
|
/* Get the session cache mode for CTX
|
|
*
|
|
* ctx WOLFSSL_CTX struct to get cache mode from
|
|
*
|
|
* Returns a bit mask that has the session cache mode */
|
|
long wolfSSL_CTX_get_session_cache_mode(WOLFSSL_CTX* ctx)
|
|
{
|
|
long m = 0;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_CTX_get_session_cache_mode");
|
|
|
|
if (ctx == NULL) {
|
|
return m;
|
|
}
|
|
|
|
if (ctx->sessionCacheOff != 1) {
|
|
m |= WOLFSSL_SESS_CACHE_SERVER;
|
|
}
|
|
|
|
if (ctx->sessionCacheFlushOff == 1) {
|
|
m |= WOLFSSL_SESS_CACHE_NO_AUTO_CLEAR;
|
|
}
|
|
|
|
#ifdef HAVE_EXT_CACHE
|
|
if (ctx->internalCacheOff == 1) {
|
|
m |= WOLFSSL_SESS_CACHE_NO_INTERNAL_STORE;
|
|
}
|
|
if (ctx->internalCacheLookupOff == 1) {
|
|
m |= WOLFSSL_SESS_CACHE_NO_INTERNAL_LOOKUP;
|
|
}
|
|
#endif
|
|
|
|
return m;
|
|
}
|
|
#endif /* OPENSSL_EXTRA */
|
|
|
|
#endif /* NO_SESSION_CACHE */
|
|
|
|
#ifdef OPENSSL_EXTRA
|
|
|
|
/*
|
|
* check if the list has TLS13 and pre-TLS13 suites
|
|
* @param list cipher suite list that user want to set
|
|
* @return mixed: 0, only pre-TLS13: 1, only TLS13: 2
|
|
*/
|
|
static int CheckcipherList(const char* list)
|
|
{
|
|
int ret;
|
|
int findTLSv13Suites = 0;
|
|
int findbeforeSuites = 0;
|
|
byte cipherSuite0;
|
|
byte cipherSuite1;
|
|
int flags;
|
|
char* next = (char*)list;
|
|
|
|
do {
|
|
char* current = next;
|
|
char name[MAX_SUITE_NAME + 1];
|
|
word32 length = MAX_SUITE_NAME;
|
|
word32 current_length;
|
|
|
|
next = XSTRSTR(next, ":");
|
|
|
|
current_length = (!next) ? (word32)XSTRLEN(current)
|
|
: (word32)(next - current);
|
|
|
|
if (current_length < length) {
|
|
length = current_length;
|
|
}
|
|
XMEMCPY(name, current, length);
|
|
name[length] = 0;
|
|
|
|
if (XSTRCMP(name, "ALL") == 0 || XSTRCMP(name, "DEFAULT") == 0 ||
|
|
XSTRCMP(name, "HIGH") == 0) {
|
|
findTLSv13Suites = 1;
|
|
findbeforeSuites = 1;
|
|
break;
|
|
}
|
|
|
|
ret = wolfSSL_get_cipher_suite_from_name(name, &cipherSuite0,
|
|
&cipherSuite1, &flags);
|
|
if (ret == 0) {
|
|
if (cipherSuite0 == TLS13_BYTE) {
|
|
/* TLSv13 suite */
|
|
findTLSv13Suites = 1;
|
|
}
|
|
else {
|
|
findbeforeSuites = 1;
|
|
}
|
|
}
|
|
|
|
#if defined(OPENSSL_EXTRA) || defined(OPENSSL_ALL)
|
|
/* check if mixed due to names like RSA:ECDHE+AESGCM etc. */
|
|
if (ret != 0) {
|
|
char* subStr = name;
|
|
char* subStrNext;
|
|
|
|
do {
|
|
subStrNext = XSTRSTR(subStr, "+");
|
|
|
|
if ((XSTRCMP(subStr, "ECDHE") == 0) ||
|
|
(XSTRCMP(subStr, "RSA") == 0)) {
|
|
return 0;
|
|
}
|
|
|
|
if (subStrNext && (XSTRLEN(subStrNext) > 0)) {
|
|
subStr = subStrNext + 1; /* +1 to skip past '+' */
|
|
}
|
|
} while (subStrNext != NULL);
|
|
}
|
|
#endif
|
|
|
|
if (findTLSv13Suites == 1 && findbeforeSuites == 1) {
|
|
/* list has mixed suites */
|
|
return 0;
|
|
}
|
|
}
|
|
while (next++); /* ++ needed to skip ':' */
|
|
|
|
if (findTLSv13Suites == 0 && findbeforeSuites == 1) {
|
|
ret = 1;/* only before TLSv13 suites */
|
|
}
|
|
else if (findTLSv13Suites == 1 && findbeforeSuites == 0) {
|
|
ret = 2;/* only TLSv13 suties */
|
|
}
|
|
else {
|
|
ret = 0;/* handle as mixed */
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/* parse some bulk lists like !eNULL / !aNULL
|
|
*
|
|
* returns WOLFSSL_SUCCESS on success and sets the cipher suite list
|
|
*/
|
|
static int wolfSSL_parse_cipher_list(WOLFSSL_CTX* ctx, Suites* suites,
|
|
const char* list)
|
|
{
|
|
int ret = 0;
|
|
int listattribute = 0;
|
|
int tls13Only = 0;
|
|
#ifndef WOLFSSL_SMALL_STACK
|
|
byte suitesCpy[WOLFSSL_MAX_SUITE_SZ];
|
|
#else
|
|
byte* suitesCpy = NULL;
|
|
#endif
|
|
word16 suitesCpySz = 0;
|
|
word16 i = 0;
|
|
word16 j = 0;
|
|
|
|
if (suites == NULL || list == NULL) {
|
|
WOLFSSL_MSG("NULL argument");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
listattribute = CheckcipherList(list);
|
|
|
|
if (listattribute == 0) {
|
|
/* list has mixed(pre-TLSv13 and TLSv13) suites
|
|
* update cipher suites the same as before
|
|
*/
|
|
return (SetCipherList(ctx, suites, list)) ? WOLFSSL_SUCCESS :
|
|
WOLFSSL_FAILURE;
|
|
}
|
|
else if (listattribute == 1) {
|
|
/* list has only pre-TLSv13 suites.
|
|
* Only update before TLSv13 suites.
|
|
*/
|
|
tls13Only = 0;
|
|
}
|
|
else if (listattribute == 2) {
|
|
/* list has only TLSv13 suites. Only update TLv13 suites
|
|
* simulate set_ciphersuites() compatibility layer API
|
|
*/
|
|
tls13Only = 1;
|
|
if (!IsAtLeastTLSv1_3(ctx->method->version)) {
|
|
/* Silently ignore TLS 1.3 ciphers if we don't support it. */
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
}
|
|
|
|
/* list contains ciphers either only for TLS 1.3 or <= TLS 1.2 */
|
|
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
if (suites->suiteSz > 0) {
|
|
suitesCpy = (byte*)XMALLOC(suites->suiteSz, NULL,
|
|
DYNAMIC_TYPE_TMP_BUFFER);
|
|
if (suitesCpy == NULL)
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
#endif
|
|
|
|
if (suites->suiteSz > 0)
|
|
XMEMCPY(suitesCpy, suites->suites, suites->suiteSz);
|
|
suitesCpySz = suites->suiteSz;
|
|
|
|
ret = SetCipherList(ctx, suites, list);
|
|
if (ret != 1) {
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
XFREE(suitesCpy, NULL, DYNAMIC_TYPE_TMP_BUFFER);
|
|
#endif
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
for (i = 0; i < suitesCpySz &&
|
|
suites->suiteSz <= (WOLFSSL_MAX_SUITE_SZ - SUITE_LEN); i += 2) {
|
|
/* Check for duplicates */
|
|
int duplicate = 0;
|
|
for (j = 0; j < suites->suiteSz; j += 2) {
|
|
if (suitesCpy[i] == suites->suites[j] &&
|
|
suitesCpy[i+1] == suites->suites[j+1]) {
|
|
duplicate = 1;
|
|
break;
|
|
}
|
|
}
|
|
if (!duplicate) {
|
|
if (tls13Only) {
|
|
/* Updating TLS 1.3 ciphers */
|
|
if (suitesCpy[i] != TLS13_BYTE) {
|
|
/* Only copy over <= TLS 1.2 ciphers */
|
|
/* TLS 1.3 ciphers take precedence */
|
|
suites->suites[suites->suiteSz++] = suitesCpy[i];
|
|
suites->suites[suites->suiteSz++] = suitesCpy[i+1];
|
|
}
|
|
}
|
|
else {
|
|
/* Updating <= TLS 1.2 ciphers */
|
|
if (suitesCpy[i] == TLS13_BYTE) {
|
|
/* Only copy over TLS 1.3 ciphers */
|
|
/* TLS 1.3 ciphers take precedence */
|
|
XMEMMOVE(suites->suites + SUITE_LEN, suites->suites,
|
|
suites->suiteSz);
|
|
suites->suites[0] = suitesCpy[i];
|
|
suites->suites[1] = suitesCpy[i+1];
|
|
suites->suiteSz += 2;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
XFREE(suitesCpy, NULL, DYNAMIC_TYPE_TMP_BUFFER);
|
|
#endif
|
|
return ret;
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
int wolfSSL_CTX_set_cipher_list(WOLFSSL_CTX* ctx, const char* list)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_set_cipher_list");
|
|
|
|
if (ctx == NULL)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
if (AllocateCtxSuites(ctx) != 0)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
#ifdef OPENSSL_EXTRA
|
|
return wolfSSL_parse_cipher_list(ctx, ctx->suites, list);
|
|
#else
|
|
return (SetCipherList(ctx, ctx->suites, list)) ?
|
|
WOLFSSL_SUCCESS : WOLFSSL_FAILURE;
|
|
#endif
|
|
}
|
|
|
|
#if defined(OPENSSL_EXTRA) || defined(WOLFSSL_SET_CIPHER_BYTES)
|
|
int wolfSSL_CTX_set_cipher_list_bytes(WOLFSSL_CTX* ctx, const byte* list,
|
|
const int listSz)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_set_cipher_list_bytes");
|
|
|
|
if (ctx == NULL)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
if (AllocateCtxSuites(ctx) != 0)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
return (SetCipherListFromBytes(ctx, ctx->suites, list, listSz)) ?
|
|
WOLFSSL_SUCCESS : WOLFSSL_FAILURE;
|
|
}
|
|
#endif /* OPENSSL_EXTRA || WOLFSSL_SET_CIPHER_BYTES */
|
|
|
|
int wolfSSL_set_cipher_list(WOLFSSL* ssl, const char* list)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_set_cipher_list");
|
|
|
|
if (ssl == NULL || ssl->ctx == NULL) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
if (AllocateSuites(ssl) != 0)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
#ifdef OPENSSL_EXTRA
|
|
return wolfSSL_parse_cipher_list(ssl->ctx, ssl->suites, list);
|
|
#else
|
|
return (SetCipherList(ssl->ctx, ssl->suites, list)) ?
|
|
WOLFSSL_SUCCESS :
|
|
WOLFSSL_FAILURE;
|
|
#endif
|
|
}
|
|
|
|
#if defined(OPENSSL_EXTRA) || defined(WOLFSSL_SET_CIPHER_BYTES)
|
|
int wolfSSL_set_cipher_list_bytes(WOLFSSL* ssl, const byte* list,
|
|
const int listSz)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_set_cipher_list_bytes");
|
|
|
|
if (ssl == NULL || ssl->ctx == NULL) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
if (AllocateSuites(ssl) != 0)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
return (SetCipherListFromBytes(ssl->ctx, ssl->suites, list, listSz))
|
|
? WOLFSSL_SUCCESS
|
|
: WOLFSSL_FAILURE;
|
|
}
|
|
#endif /* OPENSSL_EXTRA || WOLFSSL_SET_CIPHER_BYTES */
|
|
|
|
|
|
#ifdef HAVE_KEYING_MATERIAL
|
|
|
|
#define TLS_PRF_LABEL_CLIENT_FINISHED "client finished"
|
|
#define TLS_PRF_LABEL_SERVER_FINISHED "server finished"
|
|
#define TLS_PRF_LABEL_MASTER_SECRET "master secret"
|
|
#define TLS_PRF_LABEL_EXT_MASTER_SECRET "extended master secret"
|
|
#define TLS_PRF_LABEL_KEY_EXPANSION "key expansion"
|
|
|
|
static const struct ForbiddenLabels {
|
|
const char* label;
|
|
size_t labelLen;
|
|
} forbiddenLabels[] = {
|
|
{TLS_PRF_LABEL_CLIENT_FINISHED, XSTR_SIZEOF(TLS_PRF_LABEL_CLIENT_FINISHED)},
|
|
{TLS_PRF_LABEL_SERVER_FINISHED, XSTR_SIZEOF(TLS_PRF_LABEL_SERVER_FINISHED)},
|
|
{TLS_PRF_LABEL_MASTER_SECRET, XSTR_SIZEOF(TLS_PRF_LABEL_MASTER_SECRET)},
|
|
{TLS_PRF_LABEL_EXT_MASTER_SECRET, XSTR_SIZEOF(TLS_PRF_LABEL_EXT_MASTER_SECRET)},
|
|
{TLS_PRF_LABEL_KEY_EXPANSION, XSTR_SIZEOF(TLS_PRF_LABEL_KEY_EXPANSION)},
|
|
{NULL, 0},
|
|
};
|
|
|
|
/**
|
|
* Implement RFC 5705
|
|
* TLS 1.3 uses a different exporter definition (section 7.5 of RFC 8446)
|
|
* @return WOLFSSL_SUCCESS on success and WOLFSSL_FAILURE on error
|
|
*/
|
|
int wolfSSL_export_keying_material(WOLFSSL *ssl,
|
|
unsigned char *out, size_t outLen,
|
|
const char *label, size_t labelLen,
|
|
const unsigned char *context, size_t contextLen,
|
|
int use_context)
|
|
{
|
|
byte* seed = NULL;
|
|
word32 seedLen;
|
|
const struct ForbiddenLabels* fl;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_export_keying_material");
|
|
|
|
if (ssl == NULL || out == NULL || label == NULL ||
|
|
(use_context && contextLen && context == NULL)) {
|
|
WOLFSSL_MSG("Bad argument");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
/* clientRandom + serverRandom
|
|
* OR
|
|
* clientRandom + serverRandom + ctx len encoding + ctx */
|
|
seedLen = !use_context ? (word32)SEED_LEN :
|
|
(word32)SEED_LEN + 2 + (word32)contextLen;
|
|
|
|
if (ssl->options.saveArrays == 0 || ssl->arrays == NULL) {
|
|
WOLFSSL_MSG("To export keying material wolfSSL needs to keep handshake "
|
|
"data. Call wolfSSL_KeepArrays before attempting to "
|
|
"export keyid material.");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
/* check forbidden labels */
|
|
for (fl = &forbiddenLabels[0]; fl->label != NULL; fl++) {
|
|
if (labelLen >= fl->labelLen &&
|
|
XMEMCMP(label, fl->label, fl->labelLen) == 0) {
|
|
WOLFSSL_MSG("Forbidden label");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
}
|
|
|
|
#ifdef WOLFSSL_TLS13
|
|
if (IsAtLeastTLSv1_3(ssl->version)) {
|
|
/* Path for TLS 1.3 */
|
|
if (!use_context) {
|
|
contextLen = 0;
|
|
context = (byte*)""; /* Give valid pointer for 0 length memcpy */
|
|
}
|
|
|
|
if (Tls13_Exporter(ssl, out, (word32)outLen, label, labelLen,
|
|
context, contextLen) != 0) {
|
|
WOLFSSL_MSG("Tls13_Exporter error");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
#endif
|
|
|
|
/* Path for <=TLS 1.2 */
|
|
seed = (byte*)XMALLOC(seedLen, NULL, DYNAMIC_TYPE_TMP_BUFFER);
|
|
if (seed == NULL) {
|
|
WOLFSSL_MSG("malloc error");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
XMEMCPY(seed, ssl->arrays->clientRandom, RAN_LEN);
|
|
XMEMCPY(seed + RAN_LEN, ssl->arrays->serverRandom, RAN_LEN);
|
|
|
|
if (use_context) {
|
|
/* Encode len in big endian */
|
|
seed[SEED_LEN ] = (contextLen >> 8) & 0xFF;
|
|
seed[SEED_LEN + 1] = (contextLen) & 0xFF;
|
|
if (contextLen) {
|
|
/* 0 length context is allowed */
|
|
XMEMCPY(seed + SEED_LEN + 2, context, contextLen);
|
|
}
|
|
}
|
|
|
|
PRIVATE_KEY_UNLOCK();
|
|
if (wc_PRF_TLS(out, (word32)outLen, ssl->arrays->masterSecret, SECRET_LEN,
|
|
(byte*)label, (word32)labelLen, seed, seedLen, IsAtLeastTLSv1_2(ssl),
|
|
ssl->specs.mac_algorithm, ssl->heap, ssl->devId) != 0) {
|
|
WOLFSSL_MSG("wc_PRF_TLS error");
|
|
PRIVATE_KEY_LOCK();
|
|
XFREE(seed, NULL, DYNAMIC_TYPE_TMP_BUFFER);
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
PRIVATE_KEY_LOCK();
|
|
|
|
XFREE(seed, NULL, DYNAMIC_TYPE_TMP_BUFFER);
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
#endif /* HAVE_KEYING_MATERIAL */
|
|
|
|
int wolfSSL_dtls_get_using_nonblock(WOLFSSL* ssl)
|
|
{
|
|
int useNb = 0;
|
|
|
|
if (ssl == NULL)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_dtls_get_using_nonblock");
|
|
if (ssl->options.dtls) {
|
|
#ifdef WOLFSSL_DTLS
|
|
useNb = ssl->options.dtlsUseNonblock;
|
|
#endif
|
|
}
|
|
else {
|
|
WOLFSSL_MSG("wolfSSL_dtls_get_using_nonblock() is "
|
|
"DEPRECATED for non-DTLS use.");
|
|
}
|
|
return useNb;
|
|
}
|
|
|
|
|
|
#ifndef WOLFSSL_LEANPSK
|
|
|
|
void wolfSSL_dtls_set_using_nonblock(WOLFSSL* ssl, int nonblock)
|
|
{
|
|
(void)nonblock;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_dtls_set_using_nonblock");
|
|
|
|
if (ssl == NULL)
|
|
return;
|
|
|
|
if (ssl->options.dtls) {
|
|
#ifdef WOLFSSL_DTLS
|
|
ssl->options.dtlsUseNonblock = (nonblock != 0);
|
|
#endif
|
|
}
|
|
else {
|
|
WOLFSSL_MSG("wolfSSL_dtls_set_using_nonblock() is "
|
|
"DEPRECATED for non-DTLS use.");
|
|
}
|
|
}
|
|
|
|
|
|
#ifdef WOLFSSL_DTLS
|
|
|
|
int wolfSSL_dtls_get_current_timeout(WOLFSSL* ssl)
|
|
{
|
|
int timeout = 0;
|
|
if (ssl)
|
|
timeout = ssl->dtls_timeout;
|
|
|
|
WOLFSSL_LEAVE("wolfSSL_dtls_get_current_timeout", timeout);
|
|
return timeout;
|
|
}
|
|
|
|
#ifdef WOLFSSL_DTLS13
|
|
|
|
/*
|
|
* This API returns 1 when the user should set a short timeout for receiving
|
|
* data. It is recommended that it is at most 1/4 the value returned by
|
|
* wolfSSL_dtls_get_current_timeout().
|
|
*/
|
|
int wolfSSL_dtls13_use_quick_timeout(WOLFSSL* ssl)
|
|
{
|
|
return ssl->dtls13FastTimeout;
|
|
}
|
|
|
|
/*
|
|
* When this is set, a DTLS 1.3 connection will send acks immediately when a
|
|
* disruption is detected to shortcut timeouts. This results in potentially
|
|
* more traffic but may make the handshake quicker.
|
|
*/
|
|
void wolfSSL_dtls13_set_send_more_acks(WOLFSSL* ssl, int value)
|
|
{
|
|
if (ssl != NULL)
|
|
ssl->options.dtls13SendMoreAcks = !!value;
|
|
}
|
|
#endif /* WOLFSSL_DTLS13 */
|
|
|
|
int wolfSSL_DTLSv1_get_timeout(WOLFSSL* ssl, WOLFSSL_TIMEVAL* timeleft)
|
|
{
|
|
if (ssl && timeleft) {
|
|
XMEMSET(timeleft, 0, sizeof(WOLFSSL_TIMEVAL));
|
|
timeleft->tv_sec = ssl->dtls_timeout;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
#ifndef NO_WOLFSSL_STUB
|
|
int wolfSSL_DTLSv1_handle_timeout(WOLFSSL* ssl)
|
|
{
|
|
WOLFSSL_STUB("SSL_DTLSv1_handle_timeout");
|
|
(void)ssl;
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
#ifndef NO_WOLFSSL_STUB
|
|
void wolfSSL_DTLSv1_set_initial_timeout_duration(WOLFSSL* ssl, word32 duration_ms)
|
|
{
|
|
WOLFSSL_STUB("SSL_DTLSv1_set_initial_timeout_duration");
|
|
(void)ssl;
|
|
(void)duration_ms;
|
|
}
|
|
#endif
|
|
|
|
/* user may need to alter init dtls recv timeout, WOLFSSL_SUCCESS on ok */
|
|
int wolfSSL_dtls_set_timeout_init(WOLFSSL* ssl, int timeout)
|
|
{
|
|
if (ssl == NULL || timeout < 0)
|
|
return BAD_FUNC_ARG;
|
|
|
|
if (timeout > ssl->dtls_timeout_max) {
|
|
WOLFSSL_MSG("Can't set dtls timeout init greater than dtls timeout max");
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
ssl->dtls_timeout_init = timeout;
|
|
ssl->dtls_timeout = timeout;
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
|
|
/* user may need to alter max dtls recv timeout, WOLFSSL_SUCCESS on ok */
|
|
int wolfSSL_dtls_set_timeout_max(WOLFSSL* ssl, int timeout)
|
|
{
|
|
if (ssl == NULL || timeout < 0)
|
|
return BAD_FUNC_ARG;
|
|
|
|
if (timeout < ssl->dtls_timeout_init) {
|
|
WOLFSSL_MSG("Can't set dtls timeout max less than dtls timeout init");
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
ssl->dtls_timeout_max = timeout;
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
|
|
int wolfSSL_dtls_got_timeout(WOLFSSL* ssl)
|
|
{
|
|
int result = WOLFSSL_SUCCESS;
|
|
WOLFSSL_ENTER("wolfSSL_dtls_got_timeout");
|
|
|
|
if (ssl == NULL)
|
|
return WOLFSSL_FATAL_ERROR;
|
|
|
|
#ifdef WOLFSSL_DTLS13
|
|
if (ssl->options.dtls && IsAtLeastTLSv1_3(ssl->version)) {
|
|
result = Dtls13RtxTimeout(ssl);
|
|
if (result < 0) {
|
|
if (result == WANT_WRITE)
|
|
ssl->dtls13SendingAckOrRtx = 1;
|
|
ssl->error = result;
|
|
WOLFSSL_ERROR(result);
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
#endif /* WOLFSSL_DTLS13 */
|
|
|
|
if ((IsSCR(ssl) || !ssl->options.handShakeDone)) {
|
|
if (DtlsMsgPoolTimeout(ssl) < 0){
|
|
ssl->error = SOCKET_ERROR_E;
|
|
WOLFSSL_ERROR(ssl->error);
|
|
result = WOLFSSL_FATAL_ERROR;
|
|
}
|
|
else if ((result = DtlsMsgPoolSend(ssl, 0)) < 0) {
|
|
ssl->error = result;
|
|
WOLFSSL_ERROR(result);
|
|
result = WOLFSSL_FATAL_ERROR;
|
|
}
|
|
else {
|
|
/* Reset return value to success */
|
|
result = WOLFSSL_SUCCESS;
|
|
}
|
|
}
|
|
|
|
WOLFSSL_LEAVE("wolfSSL_dtls_got_timeout", result);
|
|
return result;
|
|
}
|
|
|
|
|
|
/* retransmit all the saves messages, WOLFSSL_SUCCESS on ok */
|
|
int wolfSSL_dtls_retransmit(WOLFSSL* ssl)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_dtls_retransmit");
|
|
|
|
if (ssl == NULL)
|
|
return WOLFSSL_FATAL_ERROR;
|
|
|
|
if (!ssl->options.handShakeDone) {
|
|
int result = DtlsMsgPoolSend(ssl, 0);
|
|
if (result < 0) {
|
|
ssl->error = result;
|
|
WOLFSSL_ERROR(result);
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
#endif /* DTLS */
|
|
#endif /* LEANPSK */
|
|
|
|
|
|
#if defined(WOLFSSL_DTLS) && !defined(NO_WOLFSSL_SERVER)
|
|
|
|
/* Not an SSL function, return 0 for success, error code otherwise */
|
|
/* Prereq: ssl's RNG needs to be initialized. */
|
|
int wolfSSL_DTLS_SetCookieSecret(WOLFSSL* ssl,
|
|
const byte* secret, word32 secretSz)
|
|
{
|
|
int ret = 0;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_DTLS_SetCookieSecret");
|
|
|
|
if (ssl == NULL) {
|
|
WOLFSSL_MSG("need a SSL object");
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
if (secret != NULL && secretSz == 0) {
|
|
WOLFSSL_MSG("can't have a new secret without a size");
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
/* If secretSz is 0, use the default size. */
|
|
if (secretSz == 0)
|
|
secretSz = COOKIE_SECRET_SZ;
|
|
|
|
if (secretSz != ssl->buffers.dtlsCookieSecret.length) {
|
|
byte* newSecret;
|
|
|
|
if (ssl->buffers.dtlsCookieSecret.buffer != NULL) {
|
|
ForceZero(ssl->buffers.dtlsCookieSecret.buffer,
|
|
ssl->buffers.dtlsCookieSecret.length);
|
|
XFREE(ssl->buffers.dtlsCookieSecret.buffer,
|
|
ssl->heap, DYNAMIC_TYPE_COOKIE_PWD);
|
|
}
|
|
|
|
newSecret = (byte*)XMALLOC(secretSz, ssl->heap,DYNAMIC_TYPE_COOKIE_PWD);
|
|
if (newSecret == NULL) {
|
|
ssl->buffers.dtlsCookieSecret.buffer = NULL;
|
|
ssl->buffers.dtlsCookieSecret.length = 0;
|
|
WOLFSSL_MSG("couldn't allocate new cookie secret");
|
|
return MEMORY_ERROR;
|
|
}
|
|
ssl->buffers.dtlsCookieSecret.buffer = newSecret;
|
|
ssl->buffers.dtlsCookieSecret.length = secretSz;
|
|
#ifdef WOLFSSL_CHECK_MEM_ZERO
|
|
wc_MemZero_Add("wolfSSL_DTLS_SetCookieSecret secret",
|
|
ssl->buffers.dtlsCookieSecret.buffer,
|
|
ssl->buffers.dtlsCookieSecret.length);
|
|
#endif
|
|
}
|
|
|
|
/* If the supplied secret is NULL, randomly generate a new secret. */
|
|
if (secret == NULL) {
|
|
ret = wc_RNG_GenerateBlock(ssl->rng,
|
|
ssl->buffers.dtlsCookieSecret.buffer, secretSz);
|
|
}
|
|
else
|
|
XMEMCPY(ssl->buffers.dtlsCookieSecret.buffer, secret, secretSz);
|
|
|
|
WOLFSSL_LEAVE("wolfSSL_DTLS_SetCookieSecret", 0);
|
|
return ret;
|
|
}
|
|
|
|
#endif /* WOLFSSL_DTLS && !NO_WOLFSSL_SERVER */
|
|
|
|
|
|
/* EITHER SIDE METHODS */
|
|
#if defined(OPENSSL_EXTRA) || defined(WOLFSSL_EITHER_SIDE)
|
|
WOLFSSL_METHOD* wolfSSLv23_method(void)
|
|
{
|
|
return wolfSSLv23_method_ex(NULL);
|
|
}
|
|
WOLFSSL_METHOD* wolfSSLv23_method_ex(void* heap)
|
|
{
|
|
WOLFSSL_METHOD* m = NULL;
|
|
WOLFSSL_ENTER("wolfSSLv23_method");
|
|
#if !defined(NO_WOLFSSL_CLIENT)
|
|
m = wolfSSLv23_client_method_ex(heap);
|
|
#elif !defined(NO_WOLFSSL_SERVER)
|
|
m = wolfSSLv23_server_method_ex(heap);
|
|
#else
|
|
(void)heap;
|
|
#endif
|
|
if (m != NULL) {
|
|
m->side = WOLFSSL_NEITHER_END;
|
|
}
|
|
|
|
return m;
|
|
}
|
|
|
|
#ifdef WOLFSSL_ALLOW_SSLV3
|
|
WOLFSSL_METHOD* wolfSSLv3_method(void)
|
|
{
|
|
return wolfSSLv3_method_ex(NULL);
|
|
}
|
|
WOLFSSL_METHOD* wolfSSLv3_method_ex(void* heap)
|
|
{
|
|
WOLFSSL_METHOD* m = NULL;
|
|
WOLFSSL_ENTER("wolfSSLv3_method_ex");
|
|
#if !defined(NO_WOLFSSL_CLIENT)
|
|
m = wolfSSLv3_client_method_ex(heap);
|
|
#elif !defined(NO_WOLFSSL_SERVER)
|
|
m = wolfSSLv3_server_method_ex(heap);
|
|
#endif
|
|
if (m != NULL) {
|
|
m->side = WOLFSSL_NEITHER_END;
|
|
}
|
|
|
|
return m;
|
|
}
|
|
#endif
|
|
#endif /* OPENSSL_EXTRA || WOLFSSL_EITHER_SIDE */
|
|
|
|
/* client only parts */
|
|
#ifndef NO_WOLFSSL_CLIENT
|
|
|
|
#if defined(OPENSSL_EXTRA) && !defined(NO_OLD_TLS)
|
|
WOLFSSL_METHOD* wolfSSLv2_client_method(void)
|
|
{
|
|
WOLFSSL_STUB("wolfSSLv2_client_method");
|
|
return NULL;
|
|
}
|
|
#endif
|
|
|
|
#if defined(WOLFSSL_ALLOW_SSLV3) && !defined(NO_OLD_TLS)
|
|
WOLFSSL_METHOD* wolfSSLv3_client_method(void)
|
|
{
|
|
return wolfSSLv3_client_method_ex(NULL);
|
|
}
|
|
WOLFSSL_METHOD* wolfSSLv3_client_method_ex(void* heap)
|
|
{
|
|
WOLFSSL_METHOD* method =
|
|
(WOLFSSL_METHOD*) XMALLOC(sizeof(WOLFSSL_METHOD),
|
|
heap, DYNAMIC_TYPE_METHOD);
|
|
(void)heap;
|
|
WOLFSSL_ENTER("wolfSSLv3_client_method_ex");
|
|
if (method)
|
|
InitSSL_Method(method, MakeSSLv3());
|
|
return method;
|
|
}
|
|
#endif /* WOLFSSL_ALLOW_SSLV3 && !NO_OLD_TLS */
|
|
|
|
|
|
WOLFSSL_METHOD* wolfSSLv23_client_method(void)
|
|
{
|
|
return wolfSSLv23_client_method_ex(NULL);
|
|
}
|
|
WOLFSSL_METHOD* wolfSSLv23_client_method_ex(void* heap)
|
|
{
|
|
WOLFSSL_METHOD* method =
|
|
(WOLFSSL_METHOD*) XMALLOC(sizeof(WOLFSSL_METHOD),
|
|
heap, DYNAMIC_TYPE_METHOD);
|
|
(void)heap;
|
|
WOLFSSL_ENTER("wolfSSLv23_client_method_ex");
|
|
if (method) {
|
|
#if !defined(NO_SHA256) || defined(WOLFSSL_SHA384) || defined(WOLFSSL_SHA512)
|
|
#if defined(WOLFSSL_TLS13)
|
|
InitSSL_Method(method, MakeTLSv1_3());
|
|
#elif !defined(WOLFSSL_NO_TLS12)
|
|
InitSSL_Method(method, MakeTLSv1_2());
|
|
#elif !defined(NO_OLD_TLS)
|
|
InitSSL_Method(method, MakeTLSv1_1());
|
|
#endif
|
|
#else
|
|
#ifndef NO_OLD_TLS
|
|
InitSSL_Method(method, MakeTLSv1_1());
|
|
#endif
|
|
#endif
|
|
#if !defined(NO_OLD_TLS) || defined(WOLFSSL_TLS13)
|
|
method->downgrade = 1;
|
|
#endif
|
|
}
|
|
return method;
|
|
}
|
|
|
|
/* please see note at top of README if you get an error from connect */
|
|
WOLFSSL_ABI
|
|
int wolfSSL_connect(WOLFSSL* ssl)
|
|
{
|
|
#if !(defined(WOLFSSL_NO_TLS12) && defined(NO_OLD_TLS) && defined(WOLFSSL_TLS13))
|
|
int neededState;
|
|
byte advanceState;
|
|
#endif
|
|
int ret = 0;
|
|
|
|
(void)ret;
|
|
|
|
#ifdef HAVE_ERRNO_H
|
|
errno = 0;
|
|
#endif
|
|
|
|
if (ssl == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
#if defined(OPENSSL_EXTRA) || defined(WOLFSSL_EITHER_SIDE)
|
|
if (ssl->options.side == WOLFSSL_NEITHER_END) {
|
|
ssl->error = InitSSL_Side(ssl, WOLFSSL_CLIENT_END);
|
|
if (ssl->error != WOLFSSL_SUCCESS) {
|
|
WOLFSSL_ERROR(ssl->error);
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
ssl->error = 0; /* expected to be zero here */
|
|
}
|
|
|
|
#ifdef OPENSSL_EXTRA
|
|
if (ssl->CBIS != NULL) {
|
|
ssl->CBIS(ssl, SSL_ST_CONNECT, WOLFSSL_SUCCESS);
|
|
ssl->cbmode = SSL_CB_WRITE;
|
|
}
|
|
#endif
|
|
#endif /* OPENSSL_EXTRA || WOLFSSL_EITHER_SIDE */
|
|
|
|
#if defined(WOLFSSL_NO_TLS12) && defined(NO_OLD_TLS) && defined(WOLFSSL_TLS13)
|
|
return wolfSSL_connect_TLSv13(ssl);
|
|
#else
|
|
#ifdef WOLFSSL_TLS13
|
|
if (ssl->options.tls1_3)
|
|
return wolfSSL_connect_TLSv13(ssl);
|
|
#endif
|
|
|
|
WOLFSSL_ENTER("wolfSSL_connect");
|
|
|
|
/* make sure this wolfSSL object has arrays and rng setup. Protects
|
|
* case where the WOLFSSL object is reused via wolfSSL_clear() */
|
|
if ((ret = ReinitSSL(ssl, ssl->ctx, 0)) != 0) {
|
|
return ret;
|
|
}
|
|
|
|
#ifdef WOLFSSL_WOLFSENTRY_HOOKS
|
|
if ((ssl->ConnectFilter != NULL) &&
|
|
(ssl->options.connectState == CONNECT_BEGIN)) {
|
|
wolfSSL_netfilter_decision_t res;
|
|
if ((ssl->ConnectFilter(ssl, ssl->ConnectFilter_arg, &res) ==
|
|
WOLFSSL_SUCCESS) &&
|
|
(res == WOLFSSL_NETFILTER_REJECT)) {
|
|
ssl->error = SOCKET_FILTERED_E;
|
|
WOLFSSL_ERROR(ssl->error);
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
}
|
|
#endif /* WOLFSSL_WOLFSENTRY_HOOKS */
|
|
|
|
if (ssl->options.side != WOLFSSL_CLIENT_END) {
|
|
ssl->error = SIDE_ERROR;
|
|
WOLFSSL_ERROR(ssl->error);
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
|
|
#ifdef WOLFSSL_DTLS
|
|
if (ssl->version.major == DTLS_MAJOR) {
|
|
ssl->options.dtls = 1;
|
|
ssl->options.tls = 1;
|
|
ssl->options.tls1_1 = 1;
|
|
ssl->options.dtlsStateful = 1;
|
|
}
|
|
#endif
|
|
|
|
/* fragOffset is non-zero when sending fragments. On the last
|
|
* fragment, fragOffset is zero again, and the state can be
|
|
* advanced. */
|
|
advanceState = ssl->fragOffset == 0 &&
|
|
(ssl->options.connectState == CONNECT_BEGIN ||
|
|
ssl->options.connectState == HELLO_AGAIN ||
|
|
(ssl->options.connectState >= FIRST_REPLY_DONE &&
|
|
ssl->options.connectState <= FIRST_REPLY_FOURTH));
|
|
|
|
#ifdef WOLFSSL_DTLS13
|
|
if (ssl->options.dtls && IsAtLeastTLSv1_3(ssl->version))
|
|
advanceState = advanceState && !ssl->dtls13SendingAckOrRtx;
|
|
#endif /* WOLFSSL_DTLS13 */
|
|
|
|
if (ssl->buffers.outputBuffer.length > 0
|
|
#ifdef WOLFSSL_ASYNC_CRYPT
|
|
/* do not send buffered or advance state if last error was an
|
|
async pending operation */
|
|
&& ssl->error != WC_PENDING_E
|
|
#endif
|
|
) {
|
|
ret = SendBuffered(ssl);
|
|
if (ret == 0) {
|
|
if (ssl->fragOffset == 0 && !ssl->options.buildingMsg) {
|
|
if (advanceState) {
|
|
ssl->options.connectState++;
|
|
WOLFSSL_MSG("connect state: "
|
|
"Advanced from last buffered fragment send");
|
|
#ifdef WOLFSSL_ASYNC_IO
|
|
/* Cleanup async */
|
|
FreeAsyncCtx(ssl, 0);
|
|
#endif
|
|
}
|
|
}
|
|
else {
|
|
WOLFSSL_MSG("connect state: "
|
|
"Not advanced, more fragments to send");
|
|
}
|
|
}
|
|
else {
|
|
ssl->error = ret;
|
|
WOLFSSL_ERROR(ssl->error);
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
#ifdef WOLFSSL_DTLS13
|
|
if (ssl->options.dtls)
|
|
ssl->dtls13SendingAckOrRtx = 0;
|
|
#endif /* WOLFSSL_DTLS13 */
|
|
}
|
|
|
|
ret = RetrySendAlert(ssl);
|
|
if (ret != 0) {
|
|
ssl->error = ret;
|
|
WOLFSSL_ERROR(ssl->error);
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
|
|
switch (ssl->options.connectState) {
|
|
|
|
case CONNECT_BEGIN :
|
|
/* always send client hello first */
|
|
if ( (ssl->error = SendClientHello(ssl)) != 0) {
|
|
WOLFSSL_ERROR(ssl->error);
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
ssl->options.connectState = CLIENT_HELLO_SENT;
|
|
WOLFSSL_MSG("connect state: CLIENT_HELLO_SENT");
|
|
FALL_THROUGH;
|
|
|
|
case CLIENT_HELLO_SENT :
|
|
neededState = ssl->options.resuming ? SERVER_FINISHED_COMPLETE :
|
|
SERVER_HELLODONE_COMPLETE;
|
|
#ifdef WOLFSSL_DTLS
|
|
/* In DTLS, when resuming, we can go straight to FINISHED,
|
|
* or do a cookie exchange and then skip to FINISHED, assume
|
|
* we need the cookie exchange first. */
|
|
if (IsDtlsNotSctpMode(ssl))
|
|
neededState = SERVER_HELLOVERIFYREQUEST_COMPLETE;
|
|
#endif
|
|
/* get response */
|
|
while (ssl->options.serverState < neededState) {
|
|
#ifdef WOLFSSL_TLS13
|
|
if (ssl->options.tls1_3)
|
|
return wolfSSL_connect_TLSv13(ssl);
|
|
#endif
|
|
if ( (ssl->error = ProcessReply(ssl)) < 0) {
|
|
WOLFSSL_ERROR(ssl->error);
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
/* if resumption failed, reset needed state */
|
|
else if (neededState == SERVER_FINISHED_COMPLETE) {
|
|
if (!ssl->options.resuming) {
|
|
#ifdef WOLFSSL_DTLS
|
|
if (IsDtlsNotSctpMode(ssl))
|
|
neededState = SERVER_HELLOVERIFYREQUEST_COMPLETE;
|
|
else
|
|
#endif
|
|
neededState = SERVER_HELLODONE_COMPLETE;
|
|
}
|
|
}
|
|
|
|
#ifdef WOLFSSL_DTLS13
|
|
if (ssl->options.dtls && IsAtLeastTLSv1_3(ssl->version)
|
|
&& ssl->dtls13Rtx.sendAcks == 1
|
|
&& ssl->options.seenUnifiedHdr) {
|
|
/* we aren't negotiated the version yet, so we aren't sure
|
|
* the other end can speak v1.3. On the other side we have
|
|
* received a unified records, assuming that the
|
|
* ServerHello got lost, we will send an empty ACK. In case
|
|
* the server is a DTLS with version less than 1.3, it
|
|
* should just ignore the message */
|
|
ssl->dtls13Rtx.sendAcks = 0;
|
|
if ((ssl->error = SendDtls13Ack(ssl)) < 0) {
|
|
if (ssl->error == WANT_WRITE)
|
|
ssl->dtls13SendingAckOrRtx = 1;
|
|
WOLFSSL_ERROR(ssl->error);
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
}
|
|
#endif /* WOLFSSL_DTLS13 */
|
|
}
|
|
|
|
ssl->options.connectState = HELLO_AGAIN;
|
|
WOLFSSL_MSG("connect state: HELLO_AGAIN");
|
|
FALL_THROUGH;
|
|
|
|
case HELLO_AGAIN :
|
|
|
|
#ifdef WOLFSSL_TLS13
|
|
if (ssl->options.tls1_3)
|
|
return wolfSSL_connect_TLSv13(ssl);
|
|
#endif
|
|
|
|
#ifdef WOLFSSL_DTLS
|
|
if (ssl->options.serverState ==
|
|
SERVER_HELLOVERIFYREQUEST_COMPLETE) {
|
|
if (IsDtlsNotSctpMode(ssl)) {
|
|
/* re-init hashes, exclude first hello and verify request */
|
|
if ((ssl->error = InitHandshakeHashes(ssl)) != 0) {
|
|
WOLFSSL_ERROR(ssl->error);
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
if ( (ssl->error = SendClientHello(ssl)) != 0) {
|
|
WOLFSSL_ERROR(ssl->error);
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
ssl->options.connectState = HELLO_AGAIN_REPLY;
|
|
WOLFSSL_MSG("connect state: HELLO_AGAIN_REPLY");
|
|
FALL_THROUGH;
|
|
|
|
case HELLO_AGAIN_REPLY :
|
|
#ifdef WOLFSSL_DTLS
|
|
if (IsDtlsNotSctpMode(ssl)) {
|
|
neededState = ssl->options.resuming ?
|
|
SERVER_FINISHED_COMPLETE : SERVER_HELLODONE_COMPLETE;
|
|
|
|
/* get response */
|
|
while (ssl->options.serverState < neededState) {
|
|
if ( (ssl->error = ProcessReply(ssl)) < 0) {
|
|
WOLFSSL_ERROR(ssl->error);
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
/* if resumption failed, reset needed state */
|
|
if (neededState == SERVER_FINISHED_COMPLETE) {
|
|
if (!ssl->options.resuming)
|
|
neededState = SERVER_HELLODONE_COMPLETE;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
ssl->options.connectState = FIRST_REPLY_DONE;
|
|
WOLFSSL_MSG("connect state: FIRST_REPLY_DONE");
|
|
FALL_THROUGH;
|
|
|
|
case FIRST_REPLY_DONE :
|
|
if (ssl->options.certOnly)
|
|
return WOLFSSL_SUCCESS;
|
|
#if !defined(NO_CERTS) && !defined(WOLFSSL_NO_CLIENT_AUTH)
|
|
#ifdef WOLFSSL_TLS13
|
|
if (ssl->options.tls1_3)
|
|
return wolfSSL_connect_TLSv13(ssl);
|
|
#endif
|
|
if (ssl->options.sendVerify) {
|
|
if ( (ssl->error = SendCertificate(ssl)) != 0) {
|
|
#ifdef WOLFSSL_CHECK_ALERT_ON_ERR
|
|
ProcessReplyEx(ssl, 1); /* See if an alert was sent. */
|
|
#endif
|
|
WOLFSSL_ERROR(ssl->error);
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
WOLFSSL_MSG("sent: certificate");
|
|
}
|
|
|
|
#endif
|
|
ssl->options.connectState = FIRST_REPLY_FIRST;
|
|
WOLFSSL_MSG("connect state: FIRST_REPLY_FIRST");
|
|
FALL_THROUGH;
|
|
|
|
case FIRST_REPLY_FIRST :
|
|
#ifdef WOLFSSL_TLS13
|
|
if (ssl->options.tls1_3)
|
|
return wolfSSL_connect_TLSv13(ssl);
|
|
#endif
|
|
if (!ssl->options.resuming) {
|
|
if ( (ssl->error = SendClientKeyExchange(ssl)) != 0) {
|
|
#ifdef WOLFSSL_CHECK_ALERT_ON_ERR
|
|
ProcessReplyEx(ssl, 1); /* See if an alert was sent. */
|
|
#endif
|
|
#ifdef WOLFSSL_EXTRA_ALERTS
|
|
if (ssl->error == NO_PEER_KEY ||
|
|
ssl->error == PSK_KEY_ERROR) {
|
|
SendAlert(ssl, alert_fatal, handshake_failure);
|
|
}
|
|
#endif
|
|
WOLFSSL_ERROR(ssl->error);
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
WOLFSSL_MSG("sent: client key exchange");
|
|
}
|
|
|
|
ssl->options.connectState = FIRST_REPLY_SECOND;
|
|
WOLFSSL_MSG("connect state: FIRST_REPLY_SECOND");
|
|
FALL_THROUGH;
|
|
|
|
#if !defined(WOLFSSL_NO_TLS12) || !defined(NO_OLD_TLS)
|
|
case FIRST_REPLY_SECOND :
|
|
/* CLIENT: Fail-safe for Server Authentication. */
|
|
if (!ssl->options.peerAuthGood) {
|
|
WOLFSSL_MSG("Server authentication did not happen");
|
|
ssl->error = NO_PEER_VERIFY;
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
|
|
#if !defined(NO_CERTS) && !defined(WOLFSSL_NO_CLIENT_AUTH)
|
|
if (ssl->options.sendVerify) {
|
|
if ( (ssl->error = SendCertificateVerify(ssl)) != 0) {
|
|
#ifdef WOLFSSL_CHECK_ALERT_ON_ERR
|
|
ProcessReplyEx(ssl, 1); /* See if an alert was sent. */
|
|
#endif
|
|
WOLFSSL_ERROR(ssl->error);
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
WOLFSSL_MSG("sent: certificate verify");
|
|
}
|
|
#endif /* !NO_CERTS && !WOLFSSL_NO_CLIENT_AUTH */
|
|
ssl->options.connectState = FIRST_REPLY_THIRD;
|
|
WOLFSSL_MSG("connect state: FIRST_REPLY_THIRD");
|
|
FALL_THROUGH;
|
|
|
|
case FIRST_REPLY_THIRD :
|
|
if ( (ssl->error = SendChangeCipher(ssl)) != 0) {
|
|
#ifdef WOLFSSL_CHECK_ALERT_ON_ERR
|
|
ProcessReplyEx(ssl, 1); /* See if an alert was sent. */
|
|
#endif
|
|
WOLFSSL_ERROR(ssl->error);
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
WOLFSSL_MSG("sent: change cipher spec");
|
|
ssl->options.connectState = FIRST_REPLY_FOURTH;
|
|
WOLFSSL_MSG("connect state: FIRST_REPLY_FOURTH");
|
|
FALL_THROUGH;
|
|
|
|
case FIRST_REPLY_FOURTH :
|
|
if ( (ssl->error = SendFinished(ssl)) != 0) {
|
|
#ifdef WOLFSSL_CHECK_ALERT_ON_ERR
|
|
ProcessReplyEx(ssl, 1); /* See if an alert was sent. */
|
|
#endif
|
|
WOLFSSL_ERROR(ssl->error);
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
WOLFSSL_MSG("sent: finished");
|
|
ssl->options.connectState = FINISHED_DONE;
|
|
WOLFSSL_MSG("connect state: FINISHED_DONE");
|
|
FALL_THROUGH;
|
|
|
|
#ifdef WOLFSSL_DTLS13
|
|
case WAIT_FINISHED_ACK:
|
|
ssl->options.connectState = FINISHED_DONE;
|
|
FALL_THROUGH;
|
|
#endif /* WOLFSSL_DTLS13 */
|
|
|
|
case FINISHED_DONE :
|
|
/* get response */
|
|
while (ssl->options.serverState < SERVER_FINISHED_COMPLETE)
|
|
if ( (ssl->error = ProcessReply(ssl)) < 0) {
|
|
WOLFSSL_ERROR(ssl->error);
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
|
|
ssl->options.connectState = SECOND_REPLY_DONE;
|
|
WOLFSSL_MSG("connect state: SECOND_REPLY_DONE");
|
|
FALL_THROUGH;
|
|
|
|
case SECOND_REPLY_DONE:
|
|
#ifndef NO_HANDSHAKE_DONE_CB
|
|
if (ssl->hsDoneCb) {
|
|
int cbret = ssl->hsDoneCb(ssl, ssl->hsDoneCtx);
|
|
if (cbret < 0) {
|
|
ssl->error = cbret;
|
|
WOLFSSL_MSG("HandShake Done Cb don't continue error");
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
}
|
|
#endif /* NO_HANDSHAKE_DONE_CB */
|
|
|
|
if (!ssl->options.dtls) {
|
|
if (!ssl->options.keepResources) {
|
|
FreeHandshakeResources(ssl);
|
|
}
|
|
}
|
|
#ifdef WOLFSSL_DTLS
|
|
else {
|
|
ssl->options.dtlsHsRetain = 1;
|
|
}
|
|
#endif /* WOLFSSL_DTLS */
|
|
|
|
#if defined(WOLFSSL_ASYNC_CRYPT) && defined(HAVE_SECURE_RENEGOTIATION)
|
|
/* This may be necessary in async so that we don't try to
|
|
* renegotiate again */
|
|
if (ssl->secure_renegotiation && ssl->secure_renegotiation->startScr) {
|
|
ssl->secure_renegotiation->startScr = 0;
|
|
}
|
|
#endif /* WOLFSSL_ASYNC_CRYPT && HAVE_SECURE_RENEGOTIATION */
|
|
#if defined(WOLFSSL_ASYNC_IO) && !defined(WOLFSSL_ASYNC_CRYPT)
|
|
/* Free the remaining async context if not using it for crypto */
|
|
FreeAsyncCtx(ssl, 1);
|
|
#endif
|
|
|
|
ssl->error = 0; /* clear the error */
|
|
|
|
WOLFSSL_LEAVE("wolfSSL_connect", WOLFSSL_SUCCESS);
|
|
return WOLFSSL_SUCCESS;
|
|
#endif /* !WOLFSSL_NO_TLS12 || !NO_OLD_TLS */
|
|
|
|
default:
|
|
WOLFSSL_MSG("Unknown connect state ERROR");
|
|
return WOLFSSL_FATAL_ERROR; /* unknown connect state */
|
|
}
|
|
#endif /* !WOLFSSL_NO_TLS12 || !NO_OLD_TLS || !WOLFSSL_TLS13 */
|
|
}
|
|
|
|
#endif /* NO_WOLFSSL_CLIENT */
|
|
|
|
|
|
/* server only parts */
|
|
#ifndef NO_WOLFSSL_SERVER
|
|
|
|
#if defined(OPENSSL_EXTRA) && !defined(NO_OLD_TLS)
|
|
WOLFSSL_METHOD* wolfSSLv2_server_method(void)
|
|
{
|
|
WOLFSSL_STUB("wolfSSLv2_server_method");
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
#if defined(WOLFSSL_ALLOW_SSLV3) && !defined(NO_OLD_TLS)
|
|
WOLFSSL_METHOD* wolfSSLv3_server_method(void)
|
|
{
|
|
return wolfSSLv3_server_method_ex(NULL);
|
|
}
|
|
WOLFSSL_METHOD* wolfSSLv3_server_method_ex(void* heap)
|
|
{
|
|
WOLFSSL_METHOD* method =
|
|
(WOLFSSL_METHOD*) XMALLOC(sizeof(WOLFSSL_METHOD),
|
|
heap, DYNAMIC_TYPE_METHOD);
|
|
(void)heap;
|
|
WOLFSSL_ENTER("wolfSSLv3_server_method_ex");
|
|
if (method) {
|
|
InitSSL_Method(method, MakeSSLv3());
|
|
method->side = WOLFSSL_SERVER_END;
|
|
}
|
|
return method;
|
|
}
|
|
#endif /* WOLFSSL_ALLOW_SSLV3 && !NO_OLD_TLS */
|
|
|
|
WOLFSSL_METHOD* wolfSSLv23_server_method(void)
|
|
{
|
|
return wolfSSLv23_server_method_ex(NULL);
|
|
}
|
|
|
|
WOLFSSL_METHOD* wolfSSLv23_server_method_ex(void* heap)
|
|
{
|
|
WOLFSSL_METHOD* method =
|
|
(WOLFSSL_METHOD*) XMALLOC(sizeof(WOLFSSL_METHOD),
|
|
heap, DYNAMIC_TYPE_METHOD);
|
|
(void)heap;
|
|
WOLFSSL_ENTER("wolfSSLv23_server_method_ex");
|
|
if (method) {
|
|
#if !defined(NO_SHA256) || defined(WOLFSSL_SHA384) || defined(WOLFSSL_SHA512)
|
|
#ifdef WOLFSSL_TLS13
|
|
InitSSL_Method(method, MakeTLSv1_3());
|
|
#elif !defined(WOLFSSL_NO_TLS12)
|
|
InitSSL_Method(method, MakeTLSv1_2());
|
|
#elif !defined(NO_OLD_TLS)
|
|
InitSSL_Method(method, MakeTLSv1_1());
|
|
#endif
|
|
#else
|
|
#ifndef NO_OLD_TLS
|
|
InitSSL_Method(method, MakeTLSv1_1());
|
|
#else
|
|
#error Must have SHA256, SHA384 or SHA512 enabled for TLS 1.2
|
|
#endif
|
|
#endif
|
|
#if !defined(NO_OLD_TLS) || defined(WOLFSSL_TLS13)
|
|
method->downgrade = 1;
|
|
#endif
|
|
method->side = WOLFSSL_SERVER_END;
|
|
}
|
|
return method;
|
|
}
|
|
|
|
|
|
WOLFSSL_ABI
|
|
int wolfSSL_accept(WOLFSSL* ssl)
|
|
{
|
|
#if !(defined(WOLFSSL_NO_TLS12) && defined(NO_OLD_TLS) && defined(WOLFSSL_TLS13))
|
|
word16 havePSK = 0;
|
|
word16 haveAnon = 0;
|
|
word16 haveMcast = 0;
|
|
#endif
|
|
int ret = 0;
|
|
|
|
(void)ret;
|
|
|
|
if (ssl == NULL)
|
|
return WOLFSSL_FATAL_ERROR;
|
|
|
|
#if defined(OPENSSL_EXTRA) || defined(WOLFSSL_EITHER_SIDE)
|
|
if (ssl->options.side == WOLFSSL_NEITHER_END) {
|
|
WOLFSSL_MSG("Setting WOLFSSL_SSL to be server side");
|
|
ssl->error = InitSSL_Side(ssl, WOLFSSL_SERVER_END);
|
|
if (ssl->error != WOLFSSL_SUCCESS) {
|
|
WOLFSSL_ERROR(ssl->error);
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
ssl->error = 0; /* expected to be zero here */
|
|
}
|
|
#endif /* OPENSSL_EXTRA || WOLFSSL_EITHER_SIDE */
|
|
|
|
#if defined(WOLFSSL_NO_TLS12) && defined(NO_OLD_TLS) && defined(WOLFSSL_TLS13)
|
|
return wolfSSL_accept_TLSv13(ssl);
|
|
#else
|
|
#ifdef WOLFSSL_TLS13
|
|
if (ssl->options.tls1_3)
|
|
return wolfSSL_accept_TLSv13(ssl);
|
|
#endif
|
|
WOLFSSL_ENTER("wolfSSL_accept");
|
|
|
|
/* make sure this wolfSSL object has arrays and rng setup. Protects
|
|
* case where the WOLFSSL object is reused via wolfSSL_clear() */
|
|
if ((ret = ReinitSSL(ssl, ssl->ctx, 0)) != 0) {
|
|
return ret;
|
|
}
|
|
|
|
#ifdef WOLFSSL_WOLFSENTRY_HOOKS
|
|
if ((ssl->AcceptFilter != NULL) &&
|
|
((ssl->options.acceptState == ACCEPT_BEGIN)
|
|
#ifdef HAVE_SECURE_RENEGOTIATION
|
|
|| (ssl->options.acceptState == ACCEPT_BEGIN_RENEG)
|
|
#endif
|
|
))
|
|
{
|
|
wolfSSL_netfilter_decision_t res;
|
|
if ((ssl->AcceptFilter(ssl, ssl->AcceptFilter_arg, &res) ==
|
|
WOLFSSL_SUCCESS) &&
|
|
(res == WOLFSSL_NETFILTER_REJECT)) {
|
|
ssl->error = SOCKET_FILTERED_E;
|
|
WOLFSSL_ERROR(ssl->error);
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
}
|
|
#endif /* WOLFSSL_WOLFSENTRY_HOOKS */
|
|
|
|
#ifdef HAVE_ERRNO_H
|
|
errno = 0;
|
|
#endif
|
|
|
|
#ifndef NO_PSK
|
|
havePSK = ssl->options.havePSK;
|
|
#endif
|
|
(void)havePSK;
|
|
|
|
#ifdef HAVE_ANON
|
|
haveAnon = ssl->options.haveAnon;
|
|
#endif
|
|
(void)haveAnon;
|
|
|
|
#ifdef WOLFSSL_MULTICAST
|
|
haveMcast = ssl->options.haveMcast;
|
|
#endif
|
|
(void)haveMcast;
|
|
|
|
if (ssl->options.side != WOLFSSL_SERVER_END) {
|
|
ssl->error = SIDE_ERROR;
|
|
WOLFSSL_ERROR(ssl->error);
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
|
|
#ifndef NO_CERTS
|
|
/* in case used set_accept_state after init */
|
|
if (!havePSK && !haveAnon && !haveMcast) {
|
|
#ifdef OPENSSL_EXTRA
|
|
if (ssl->ctx->certSetupCb != NULL) {
|
|
WOLFSSL_MSG("CertSetupCb set. server cert and "
|
|
"key not checked");
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
if (!ssl->buffers.certificate ||
|
|
!ssl->buffers.certificate->buffer) {
|
|
|
|
WOLFSSL_MSG("accept error: server cert required");
|
|
ssl->error = NO_PRIVATE_KEY;
|
|
WOLFSSL_ERROR(ssl->error);
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
|
|
if (!ssl->buffers.key || !ssl->buffers.key->buffer) {
|
|
/* allow no private key if using existing key */
|
|
#ifdef WOLF_PRIVATE_KEY_ID
|
|
if (ssl->devId != INVALID_DEVID
|
|
#ifdef HAVE_PK_CALLBACKS
|
|
|| wolfSSL_CTX_IsPrivatePkSet(ssl->ctx)
|
|
#endif
|
|
) {
|
|
WOLFSSL_MSG("Allowing no server private key "
|
|
"(external)");
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
WOLFSSL_MSG("accept error: server key required");
|
|
ssl->error = NO_PRIVATE_KEY;
|
|
WOLFSSL_ERROR(ssl->error);
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#ifdef WOLFSSL_DTLS
|
|
if (ssl->version.major == DTLS_MAJOR) {
|
|
ssl->options.dtls = 1;
|
|
ssl->options.tls = 1;
|
|
ssl->options.tls1_1 = 1;
|
|
if (!IsDtlsNotSctpMode(ssl) || !IsDtlsNotSrtpMode(ssl) ||
|
|
IsSCR(ssl))
|
|
ssl->options.dtlsStateful = 1;
|
|
}
|
|
#endif
|
|
|
|
if (ssl->buffers.outputBuffer.length > 0
|
|
#ifdef WOLFSSL_ASYNC_CRYPT
|
|
/* do not send buffered or advance state if last error was an
|
|
async pending operation */
|
|
&& ssl->error != WC_PENDING_E
|
|
#endif
|
|
) {
|
|
ret = SendBuffered(ssl);
|
|
if (ret == 0) {
|
|
/* fragOffset is non-zero when sending fragments. On the last
|
|
* fragment, fragOffset is zero again, and the state can be
|
|
* advanced. */
|
|
if (ssl->fragOffset == 0 && !ssl->options.buildingMsg) {
|
|
if (ssl->options.acceptState == ACCEPT_FIRST_REPLY_DONE ||
|
|
ssl->options.acceptState == SERVER_HELLO_SENT ||
|
|
ssl->options.acceptState == CERT_SENT ||
|
|
ssl->options.acceptState == CERT_STATUS_SENT ||
|
|
ssl->options.acceptState == KEY_EXCHANGE_SENT ||
|
|
ssl->options.acceptState == CERT_REQ_SENT ||
|
|
ssl->options.acceptState == ACCEPT_SECOND_REPLY_DONE ||
|
|
ssl->options.acceptState == TICKET_SENT ||
|
|
ssl->options.acceptState == CHANGE_CIPHER_SENT) {
|
|
ssl->options.acceptState++;
|
|
WOLFSSL_MSG("accept state: "
|
|
"Advanced from last buffered fragment send");
|
|
#ifdef WOLFSSL_ASYNC_IO
|
|
/* Cleanup async */
|
|
FreeAsyncCtx(ssl, 0);
|
|
#endif
|
|
}
|
|
}
|
|
else {
|
|
WOLFSSL_MSG("accept state: "
|
|
"Not advanced, more fragments to send");
|
|
}
|
|
}
|
|
else {
|
|
ssl->error = ret;
|
|
WOLFSSL_ERROR(ssl->error);
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
#ifdef WOLFSSL_DTLS13
|
|
if (ssl->options.dtls)
|
|
ssl->dtls13SendingAckOrRtx = 0;
|
|
#endif /* WOLFSSL_DTLS13 */
|
|
}
|
|
|
|
ret = RetrySendAlert(ssl);
|
|
if (ret != 0) {
|
|
ssl->error = ret;
|
|
WOLFSSL_ERROR(ssl->error);
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
|
|
switch (ssl->options.acceptState) {
|
|
|
|
case ACCEPT_BEGIN :
|
|
#ifdef HAVE_SECURE_RENEGOTIATION
|
|
case ACCEPT_BEGIN_RENEG:
|
|
#endif
|
|
/* get response */
|
|
while (ssl->options.clientState < CLIENT_HELLO_COMPLETE)
|
|
if ( (ssl->error = ProcessReply(ssl)) < 0) {
|
|
WOLFSSL_ERROR(ssl->error);
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
#ifdef WOLFSSL_TLS13
|
|
ssl->options.acceptState = ACCEPT_CLIENT_HELLO_DONE;
|
|
WOLFSSL_MSG("accept state ACCEPT_CLIENT_HELLO_DONE");
|
|
FALL_THROUGH;
|
|
|
|
case ACCEPT_CLIENT_HELLO_DONE :
|
|
if (ssl->options.tls1_3) {
|
|
return wolfSSL_accept_TLSv13(ssl);
|
|
}
|
|
#endif
|
|
|
|
ssl->options.acceptState = ACCEPT_FIRST_REPLY_DONE;
|
|
WOLFSSL_MSG("accept state ACCEPT_FIRST_REPLY_DONE");
|
|
FALL_THROUGH;
|
|
|
|
case ACCEPT_FIRST_REPLY_DONE :
|
|
if ( (ssl->error = SendServerHello(ssl)) != 0) {
|
|
#ifdef WOLFSSL_CHECK_ALERT_ON_ERR
|
|
ProcessReplyEx(ssl, 1); /* See if an alert was sent. */
|
|
#endif
|
|
WOLFSSL_ERROR(ssl->error);
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
ssl->options.acceptState = SERVER_HELLO_SENT;
|
|
WOLFSSL_MSG("accept state SERVER_HELLO_SENT");
|
|
FALL_THROUGH;
|
|
|
|
case SERVER_HELLO_SENT :
|
|
#ifdef WOLFSSL_TLS13
|
|
if (ssl->options.tls1_3) {
|
|
return wolfSSL_accept_TLSv13(ssl);
|
|
}
|
|
#endif
|
|
#ifndef NO_CERTS
|
|
if (!ssl->options.resuming)
|
|
if ( (ssl->error = SendCertificate(ssl)) != 0) {
|
|
#ifdef WOLFSSL_CHECK_ALERT_ON_ERR
|
|
ProcessReplyEx(ssl, 1); /* See if an alert was sent. */
|
|
#endif
|
|
WOLFSSL_ERROR(ssl->error);
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
#endif
|
|
ssl->options.acceptState = CERT_SENT;
|
|
WOLFSSL_MSG("accept state CERT_SENT");
|
|
FALL_THROUGH;
|
|
|
|
case CERT_SENT :
|
|
#ifndef NO_CERTS
|
|
if (!ssl->options.resuming)
|
|
if ( (ssl->error = SendCertificateStatus(ssl)) != 0) {
|
|
#ifdef WOLFSSL_CHECK_ALERT_ON_ERR
|
|
ProcessReplyEx(ssl, 1); /* See if an alert was sent. */
|
|
#endif
|
|
WOLFSSL_ERROR(ssl->error);
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
#endif
|
|
ssl->options.acceptState = CERT_STATUS_SENT;
|
|
WOLFSSL_MSG("accept state CERT_STATUS_SENT");
|
|
FALL_THROUGH;
|
|
|
|
case CERT_STATUS_SENT :
|
|
#ifdef WOLFSSL_TLS13
|
|
if (ssl->options.tls1_3) {
|
|
return wolfSSL_accept_TLSv13(ssl);
|
|
}
|
|
#endif
|
|
if (!ssl->options.resuming)
|
|
if ( (ssl->error = SendServerKeyExchange(ssl)) != 0) {
|
|
#ifdef WOLFSSL_CHECK_ALERT_ON_ERR
|
|
ProcessReplyEx(ssl, 1); /* See if an alert was sent. */
|
|
#endif
|
|
WOLFSSL_ERROR(ssl->error);
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
ssl->options.acceptState = KEY_EXCHANGE_SENT;
|
|
WOLFSSL_MSG("accept state KEY_EXCHANGE_SENT");
|
|
FALL_THROUGH;
|
|
|
|
case KEY_EXCHANGE_SENT :
|
|
#ifndef NO_CERTS
|
|
if (!ssl->options.resuming) {
|
|
if (ssl->options.verifyPeer) {
|
|
if ( (ssl->error = SendCertificateRequest(ssl)) != 0) {
|
|
#ifdef WOLFSSL_CHECK_ALERT_ON_ERR
|
|
ProcessReplyEx(ssl, 1); /* See if an alert was sent. */
|
|
#endif
|
|
WOLFSSL_ERROR(ssl->error);
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
}
|
|
else {
|
|
/* SERVER: Peer auth good if not verifying client. */
|
|
ssl->options.peerAuthGood = 1;
|
|
}
|
|
}
|
|
#endif
|
|
ssl->options.acceptState = CERT_REQ_SENT;
|
|
WOLFSSL_MSG("accept state CERT_REQ_SENT");
|
|
FALL_THROUGH;
|
|
|
|
case CERT_REQ_SENT :
|
|
if (!ssl->options.resuming)
|
|
if ( (ssl->error = SendServerHelloDone(ssl)) != 0) {
|
|
#ifdef WOLFSSL_CHECK_ALERT_ON_ERR
|
|
ProcessReplyEx(ssl, 1); /* See if an alert was sent. */
|
|
#endif
|
|
WOLFSSL_ERROR(ssl->error);
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
ssl->options.acceptState = SERVER_HELLO_DONE;
|
|
WOLFSSL_MSG("accept state SERVER_HELLO_DONE");
|
|
FALL_THROUGH;
|
|
|
|
case SERVER_HELLO_DONE :
|
|
if (!ssl->options.resuming) {
|
|
while (ssl->options.clientState < CLIENT_FINISHED_COMPLETE)
|
|
if ( (ssl->error = ProcessReply(ssl)) < 0) {
|
|
WOLFSSL_ERROR(ssl->error);
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
}
|
|
ssl->options.acceptState = ACCEPT_SECOND_REPLY_DONE;
|
|
WOLFSSL_MSG("accept state ACCEPT_SECOND_REPLY_DONE");
|
|
FALL_THROUGH;
|
|
|
|
case ACCEPT_SECOND_REPLY_DONE :
|
|
#ifndef NO_CERTS
|
|
/* SERVER: When not resuming and verifying peer but no certificate
|
|
* received and not failing when not received then peer auth good.
|
|
*/
|
|
if (!ssl->options.resuming && ssl->options.verifyPeer &&
|
|
!ssl->options.havePeerCert && !ssl->options.failNoCert) {
|
|
ssl->options.peerAuthGood = 1;
|
|
}
|
|
#endif /* !NO_CERTS */
|
|
#ifdef WOLFSSL_NO_CLIENT_AUTH
|
|
if (!ssl->options.resuming) {
|
|
ssl->options.peerAuthGood = 1;
|
|
}
|
|
#endif
|
|
|
|
#ifdef HAVE_SESSION_TICKET
|
|
if (ssl->options.createTicket && !ssl->options.noTicketTls12) {
|
|
if ( (ssl->error = SendTicket(ssl)) != 0) {
|
|
#ifdef WOLFSSL_CHECK_ALERT_ON_ERR
|
|
ProcessReplyEx(ssl, 1); /* See if an alert was sent. */
|
|
#endif
|
|
WOLFSSL_MSG("Thought we need ticket but failed");
|
|
WOLFSSL_ERROR(ssl->error);
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
}
|
|
#endif /* HAVE_SESSION_TICKET */
|
|
ssl->options.acceptState = TICKET_SENT;
|
|
WOLFSSL_MSG("accept state TICKET_SENT");
|
|
FALL_THROUGH;
|
|
|
|
case TICKET_SENT:
|
|
/* SERVER: Fail-safe for CLient Authentication. */
|
|
if (!ssl->options.peerAuthGood) {
|
|
WOLFSSL_MSG("Client authentication did not happen");
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
|
|
if ( (ssl->error = SendChangeCipher(ssl)) != 0) {
|
|
#ifdef WOLFSSL_CHECK_ALERT_ON_ERR
|
|
ProcessReplyEx(ssl, 1); /* See if an alert was sent. */
|
|
#endif
|
|
WOLFSSL_ERROR(ssl->error);
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
ssl->options.acceptState = CHANGE_CIPHER_SENT;
|
|
WOLFSSL_MSG("accept state CHANGE_CIPHER_SENT");
|
|
FALL_THROUGH;
|
|
|
|
case CHANGE_CIPHER_SENT :
|
|
if ( (ssl->error = SendFinished(ssl)) != 0) {
|
|
#ifdef WOLFSSL_CHECK_ALERT_ON_ERR
|
|
ProcessReplyEx(ssl, 1); /* See if an alert was sent. */
|
|
#endif
|
|
WOLFSSL_ERROR(ssl->error);
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
|
|
ssl->options.acceptState = ACCEPT_FINISHED_DONE;
|
|
WOLFSSL_MSG("accept state ACCEPT_FINISHED_DONE");
|
|
FALL_THROUGH;
|
|
|
|
case ACCEPT_FINISHED_DONE :
|
|
if (ssl->options.resuming) {
|
|
while (ssl->options.clientState < CLIENT_FINISHED_COMPLETE) {
|
|
if ( (ssl->error = ProcessReply(ssl)) < 0) {
|
|
WOLFSSL_ERROR(ssl->error);
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
}
|
|
}
|
|
ssl->options.acceptState = ACCEPT_THIRD_REPLY_DONE;
|
|
WOLFSSL_MSG("accept state ACCEPT_THIRD_REPLY_DONE");
|
|
FALL_THROUGH;
|
|
|
|
case ACCEPT_THIRD_REPLY_DONE :
|
|
#ifndef NO_HANDSHAKE_DONE_CB
|
|
if (ssl->hsDoneCb) {
|
|
int cbret = ssl->hsDoneCb(ssl, ssl->hsDoneCtx);
|
|
if (cbret < 0) {
|
|
ssl->error = cbret;
|
|
WOLFSSL_MSG("HandShake Done Cb don't continue error");
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
}
|
|
#endif /* NO_HANDSHAKE_DONE_CB */
|
|
|
|
if (!ssl->options.dtls) {
|
|
if (!ssl->options.keepResources) {
|
|
FreeHandshakeResources(ssl);
|
|
}
|
|
}
|
|
#ifdef WOLFSSL_DTLS
|
|
else {
|
|
ssl->options.dtlsHsRetain = 1;
|
|
}
|
|
#endif /* WOLFSSL_DTLS */
|
|
|
|
#if defined(WOLFSSL_ASYNC_CRYPT) && defined(HAVE_SECURE_RENEGOTIATION)
|
|
/* This may be necessary in async so that we don't try to
|
|
* renegotiate again */
|
|
if (ssl->secure_renegotiation && ssl->secure_renegotiation->startScr) {
|
|
ssl->secure_renegotiation->startScr = 0;
|
|
}
|
|
#endif /* WOLFSSL_ASYNC_CRYPT && HAVE_SECURE_RENEGOTIATION */
|
|
#if defined(WOLFSSL_ASYNC_IO) && !defined(WOLFSSL_ASYNC_CRYPT)
|
|
/* Free the remaining async context if not using it for crypto */
|
|
FreeAsyncCtx(ssl, 1);
|
|
#endif
|
|
|
|
#if defined(WOLFSSL_SESSION_EXPORT) && defined(WOLFSSL_DTLS)
|
|
if (ssl->dtls_export) {
|
|
if ((ssl->error = wolfSSL_send_session(ssl)) != 0) {
|
|
WOLFSSL_MSG("Export DTLS session error");
|
|
WOLFSSL_ERROR(ssl->error);
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
}
|
|
#endif
|
|
ssl->error = 0; /* clear the error */
|
|
|
|
WOLFSSL_LEAVE("wolfSSL_accept", WOLFSSL_SUCCESS);
|
|
return WOLFSSL_SUCCESS;
|
|
|
|
default :
|
|
WOLFSSL_MSG("Unknown accept state ERROR");
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
#endif /* !WOLFSSL_NO_TLS12 */
|
|
}
|
|
|
|
#endif /* NO_WOLFSSL_SERVER */
|
|
|
|
#if defined(WOLFSSL_DTLS) && !defined(NO_WOLFSSL_SERVER)
|
|
int wolfDTLS_SetChGoodCb(WOLFSSL* ssl, ClientHelloGoodCb cb, void* user_ctx)
|
|
{
|
|
WOLFSSL_ENTER("wolfDTLS_SetChGoodCb");
|
|
|
|
if (ssl == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
ssl->chGoodCb = cb;
|
|
ssl->chGoodCtx = user_ctx;
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
#endif
|
|
|
|
#ifndef NO_HANDSHAKE_DONE_CB
|
|
|
|
int wolfSSL_SetHsDoneCb(WOLFSSL* ssl, HandShakeDoneCb cb, void* user_ctx)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_SetHsDoneCb");
|
|
|
|
if (ssl == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
ssl->hsDoneCb = cb;
|
|
ssl->hsDoneCtx = user_ctx;
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
#endif /* NO_HANDSHAKE_DONE_CB */
|
|
|
|
WOLFSSL_ABI
|
|
int wolfSSL_Cleanup(void)
|
|
{
|
|
int ret = WOLFSSL_SUCCESS; /* Only the first error will be returned */
|
|
int release = 0;
|
|
#if !defined(NO_SESSION_CACHE)
|
|
int i;
|
|
int j;
|
|
#endif
|
|
|
|
WOLFSSL_ENTER("wolfSSL_Cleanup");
|
|
|
|
#ifndef WOLFSSL_MUTEX_INITIALIZER
|
|
if (count_mutex_valid == 1) {
|
|
#endif
|
|
if (wc_LockMutex(&count_mutex) != 0) {
|
|
WOLFSSL_MSG("Bad Lock Mutex count");
|
|
return BAD_MUTEX_E;
|
|
}
|
|
#ifndef WOLFSSL_MUTEX_INITIALIZER
|
|
}
|
|
#endif
|
|
|
|
if (initRefCount > 0) {
|
|
--initRefCount;
|
|
if (initRefCount == 0)
|
|
release = 1;
|
|
}
|
|
|
|
#ifndef WOLFSSL_MUTEX_INITIALIZER
|
|
if (count_mutex_valid == 1) {
|
|
#endif
|
|
wc_UnLockMutex(&count_mutex);
|
|
#ifndef WOLFSSL_MUTEX_INITIALIZER
|
|
}
|
|
#endif
|
|
|
|
if (!release)
|
|
return ret;
|
|
|
|
#ifdef OPENSSL_EXTRA
|
|
wolfSSL_BN_free_one();
|
|
#endif
|
|
|
|
#ifndef NO_SESSION_CACHE
|
|
#ifdef ENABLE_SESSION_CACHE_ROW_LOCK
|
|
for (i = 0; i < SESSION_ROWS; ++i) {
|
|
if ((SessionCache[i].lock_valid == 1) &&
|
|
(wc_FreeRwLock(&SessionCache[i].row_lock) != 0)) {
|
|
if (ret == WOLFSSL_SUCCESS)
|
|
ret = BAD_MUTEX_E;
|
|
}
|
|
SessionCache[i].lock_valid = 0;
|
|
}
|
|
#else
|
|
if ((session_lock_valid == 1) && (wc_FreeRwLock(&session_lock) != 0)) {
|
|
if (ret == WOLFSSL_SUCCESS)
|
|
ret = BAD_MUTEX_E;
|
|
}
|
|
session_lock_valid = 0;
|
|
#endif
|
|
for (i = 0; i < SESSION_ROWS; i++) {
|
|
for (j = 0; j < SESSIONS_PER_ROW; j++) {
|
|
#ifdef SESSION_CACHE_DYNAMIC_MEM
|
|
if (SessionCache[i].Sessions[j]) {
|
|
EvictSessionFromCache(SessionCache[i].Sessions[j]);
|
|
XFREE(SessionCache[i].Sessions[j], SessionCache[i].heap,
|
|
DYNAMIC_TYPE_SESSION);
|
|
SessionCache[i].Sessions[j] = NULL;
|
|
}
|
|
#else
|
|
EvictSessionFromCache(&SessionCache[i].Sessions[j]);
|
|
#endif
|
|
}
|
|
}
|
|
#ifndef NO_CLIENT_CACHE
|
|
if ((clisession_mutex_valid == 1) &&
|
|
(wc_FreeMutex(&clisession_mutex) != 0)) {
|
|
if (ret == WOLFSSL_SUCCESS)
|
|
ret = BAD_MUTEX_E;
|
|
}
|
|
clisession_mutex_valid = 0;
|
|
#endif
|
|
#endif /* !NO_SESSION_CACHE */
|
|
|
|
#ifndef WOLFSSL_MUTEX_INITIALIZER
|
|
if ((count_mutex_valid == 1) && (wc_FreeMutex(&count_mutex) != 0)) {
|
|
if (ret == WOLFSSL_SUCCESS)
|
|
ret = BAD_MUTEX_E;
|
|
}
|
|
count_mutex_valid = 0;
|
|
#endif
|
|
|
|
#ifdef OPENSSL_EXTRA
|
|
wolfSSL_RAND_Cleanup();
|
|
#endif
|
|
|
|
if (wolfCrypt_Cleanup() != 0) {
|
|
WOLFSSL_MSG("Error with wolfCrypt_Cleanup call");
|
|
if (ret == WOLFSSL_SUCCESS)
|
|
ret = WC_CLEANUP_E;
|
|
}
|
|
|
|
#if FIPS_VERSION_GE(5,1)
|
|
if (wolfCrypt_SetPrivateKeyReadEnable_fips(0, WC_KEYTYPE_ALL) < 0) {
|
|
if (ret == WOLFSSL_SUCCESS)
|
|
ret = WC_CLEANUP_E;
|
|
}
|
|
#endif
|
|
|
|
#ifdef HAVE_GLOBAL_RNG
|
|
if ((globalRNGMutex_valid == 1) && (wc_FreeMutex(&globalRNGMutex) != 0)) {
|
|
if (ret == WOLFSSL_SUCCESS)
|
|
ret = BAD_MUTEX_E;
|
|
}
|
|
globalRNGMutex_valid = 0;
|
|
|
|
#if defined(OPENSSL_EXTRA) && defined(HAVE_HASHDRBG)
|
|
wolfSSL_FIPS_drbg_free(gDrbgDefCtx);
|
|
gDrbgDefCtx = NULL;
|
|
#endif
|
|
#endif
|
|
|
|
#if defined(HAVE_EX_DATA) && \
|
|
(defined(OPENSSL_ALL) || defined(WOLFSSL_NGINX) || \
|
|
defined(WOLFSSL_HAPROXY) || defined(OPENSSL_EXTRA) || \
|
|
defined(HAVE_LIGHTY)) || defined(HAVE_EX_DATA) || \
|
|
defined(WOLFSSL_WPAS_SMALL)
|
|
crypto_ex_cb_free(crypto_ex_cb_ctx_session);
|
|
crypto_ex_cb_ctx_session = NULL;
|
|
#endif
|
|
|
|
#ifdef WOLFSSL_MEM_FAIL_COUNT
|
|
wc_MemFailCount_Free();
|
|
#endif
|
|
|
|
return ret;
|
|
}
|
|
|
|
void SetupSession(WOLFSSL* ssl)
|
|
{
|
|
WOLFSSL_SESSION* session = ssl->session;
|
|
|
|
WOLFSSL_ENTER("SetupSession");
|
|
|
|
if (!IsAtLeastTLSv1_3(ssl->version) && ssl->arrays != NULL) {
|
|
/* Make sure the session ID is available when the user calls any
|
|
* get_session API */
|
|
if (!session->haveAltSessionID) {
|
|
XMEMCPY(session->sessionID, ssl->arrays->sessionID, ID_LEN);
|
|
session->sessionIDSz = ssl->arrays->sessionIDSz;
|
|
}
|
|
else {
|
|
XMEMCPY(session->sessionID, session->altSessionID, ID_LEN);
|
|
session->sessionIDSz = ID_LEN;
|
|
}
|
|
}
|
|
session->side = (byte)ssl->options.side;
|
|
if (!IsAtLeastTLSv1_3(ssl->version) && ssl->arrays != NULL)
|
|
XMEMCPY(session->masterSecret, ssl->arrays->masterSecret, SECRET_LEN);
|
|
session->haveEMS = ssl->options.haveEMS;
|
|
#ifdef WOLFSSL_SESSION_ID_CTX
|
|
/* If using compatibility layer then check for and copy over session context
|
|
* id. */
|
|
if (ssl->sessionCtxSz > 0 && ssl->sessionCtxSz < ID_LEN) {
|
|
XMEMCPY(ssl->session->sessionCtx, ssl->sessionCtx, ssl->sessionCtxSz);
|
|
session->sessionCtxSz = ssl->sessionCtxSz;
|
|
}
|
|
#endif
|
|
session->timeout = ssl->timeout;
|
|
#ifndef NO_ASN_TIME
|
|
session->bornOn = LowResTimer();
|
|
#endif
|
|
#if defined(SESSION_CERTS) || (defined(WOLFSSL_TLS13) && \
|
|
defined(HAVE_SESSION_TICKET))
|
|
session->version = ssl->version;
|
|
#endif
|
|
#if defined(SESSION_CERTS) || !defined(NO_RESUME_SUITE_CHECK) || \
|
|
(defined(WOLFSSL_TLS13) && defined(HAVE_SESSION_TICKET))
|
|
session->cipherSuite0 = ssl->options.cipherSuite0;
|
|
session->cipherSuite = ssl->options.cipherSuite;
|
|
#endif
|
|
#if defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL)
|
|
session->peerVerifyRet = (byte)ssl->peerVerifyRet;
|
|
#endif
|
|
session->isSetup = 1;
|
|
}
|
|
|
|
#ifndef NO_SESSION_CACHE
|
|
|
|
WOLFSSL_ABI
|
|
void wolfSSL_flush_sessions(WOLFSSL_CTX* ctx, long tm)
|
|
{
|
|
/* static table now, no flushing needed */
|
|
(void)ctx;
|
|
(void)tm;
|
|
}
|
|
|
|
void wolfSSL_CTX_flush_sessions(WOLFSSL_CTX* ctx, long tm)
|
|
{
|
|
int i, j;
|
|
byte id[ID_LEN];
|
|
|
|
(void)ctx;
|
|
XMEMSET(id, 0, ID_LEN);
|
|
WOLFSSL_ENTER("wolfSSL_flush_sessions");
|
|
for (i = 0; i < SESSION_ROWS; ++i) {
|
|
if (SESSION_ROW_WR_LOCK(&SessionCache[i]) != 0) {
|
|
WOLFSSL_MSG("Session cache mutex lock failed");
|
|
return;
|
|
}
|
|
for (j = 0; j < SESSIONS_PER_ROW; j++) {
|
|
#ifdef SESSION_CACHE_DYNAMIC_MEM
|
|
WOLFSSL_SESSION* s = SessionCache[i].Sessions[j];
|
|
#else
|
|
WOLFSSL_SESSION* s = &SessionCache[i].Sessions[j];
|
|
#endif
|
|
if (
|
|
#ifdef SESSION_CACHE_DYNAMIC_MEM
|
|
s != NULL &&
|
|
#endif
|
|
XMEMCMP(s->sessionID, id, ID_LEN) != 0 &&
|
|
s->bornOn + s->timeout < (word32)tm
|
|
)
|
|
{
|
|
EvictSessionFromCache(s);
|
|
#ifdef SESSION_CACHE_DYNAMIC_MEM
|
|
XFREE(s, s->heap, DYNAMIC_TYPE_SESSION);
|
|
SessionCache[i].Sessions[j] = NULL;
|
|
#endif
|
|
}
|
|
}
|
|
SESSION_ROW_UNLOCK(&SessionCache[i]);
|
|
}
|
|
}
|
|
|
|
|
|
/* set ssl session timeout in seconds */
|
|
WOLFSSL_ABI
|
|
int wolfSSL_set_timeout(WOLFSSL* ssl, unsigned int to)
|
|
{
|
|
if (ssl == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
if (to == 0)
|
|
to = WOLFSSL_SESSION_TIMEOUT;
|
|
ssl->timeout = to;
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
|
|
/**
|
|
* Sets ctx session timeout in seconds.
|
|
* The timeout value set here should be reflected in the
|
|
* "session ticket lifetime hint" if this API works in the openssl compat-layer.
|
|
* Therefore wolfSSL_CTX_set_TicketHint is called internally.
|
|
* Arguments:
|
|
* - ctx WOLFSSL_CTX object which the timeout is set to
|
|
* - to timeout value in second
|
|
* Returns:
|
|
* WOLFSSL_SUCCESS on success, BAD_FUNC_ARG on failure.
|
|
* When WOLFSSL_ERROR_CODE_OPENSSL is defined, returns previous timeout value
|
|
* on success, BAD_FUNC_ARG on failure.
|
|
*/
|
|
WOLFSSL_ABI
|
|
int wolfSSL_CTX_set_timeout(WOLFSSL_CTX* ctx, unsigned int to)
|
|
{
|
|
#if defined(WOLFSSL_ERROR_CODE_OPENSSL)
|
|
word32 prev_timeout = 0;
|
|
#endif
|
|
|
|
int ret = WOLFSSL_SUCCESS;
|
|
(void)ret;
|
|
|
|
if (ctx == NULL)
|
|
ret = BAD_FUNC_ARG;
|
|
|
|
if (ret == WOLFSSL_SUCCESS) {
|
|
#if defined(WOLFSSL_ERROR_CODE_OPENSSL)
|
|
prev_timeout = ctx->timeout;
|
|
#endif
|
|
if (to == 0) {
|
|
ctx->timeout = WOLFSSL_SESSION_TIMEOUT;
|
|
}
|
|
else {
|
|
ctx->timeout = to;
|
|
}
|
|
}
|
|
#if defined(OPENSSL_EXTRA) && defined(HAVE_SESSION_TICKET) && \
|
|
!defined(NO_WOLFSSL_SERVER)
|
|
if (ret == WOLFSSL_SUCCESS) {
|
|
if (to == 0) {
|
|
ret = wolfSSL_CTX_set_TicketHint(ctx, SESSION_TICKET_HINT_DEFAULT);
|
|
}
|
|
else {
|
|
ret = wolfSSL_CTX_set_TicketHint(ctx, to);
|
|
}
|
|
}
|
|
#endif /* OPENSSL_EXTRA && HAVE_SESSION_TICKET && !NO_WOLFSSL_SERVER */
|
|
|
|
#if defined(WOLFSSL_ERROR_CODE_OPENSSL)
|
|
if (ret == WOLFSSL_SUCCESS) {
|
|
return prev_timeout;
|
|
}
|
|
else {
|
|
return ret;
|
|
}
|
|
#else
|
|
return ret;
|
|
#endif /* WOLFSSL_ERROR_CODE_OPENSSL */
|
|
}
|
|
|
|
|
|
#ifndef NO_CLIENT_CACHE
|
|
|
|
/* Get Session from Client cache based on id/len, return NULL on failure */
|
|
WOLFSSL_SESSION* wolfSSL_GetSessionClient(WOLFSSL* ssl, const byte* id, int len)
|
|
{
|
|
WOLFSSL_SESSION* ret = NULL;
|
|
word32 row;
|
|
int idx;
|
|
int count;
|
|
int error = 0;
|
|
ClientSession* clSess;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_GetSessionClient");
|
|
|
|
if (ssl->ctx->sessionCacheOff) {
|
|
WOLFSSL_MSG("Session Cache off");
|
|
return NULL;
|
|
}
|
|
|
|
if (ssl->options.side == WOLFSSL_SERVER_END)
|
|
return NULL;
|
|
|
|
len = min(SERVER_ID_LEN, (word32)len);
|
|
|
|
/* Do not access ssl->ctx->get_sess_cb from here. It is using a different
|
|
* set of ID's */
|
|
|
|
row = HashObject(id, len, &error) % CLIENT_SESSION_ROWS;
|
|
if (error != 0) {
|
|
WOLFSSL_MSG("Hash session failed");
|
|
return NULL;
|
|
}
|
|
|
|
if (wc_LockMutex(&clisession_mutex) != 0) {
|
|
WOLFSSL_MSG("Client cache mutex lock failed");
|
|
return NULL;
|
|
}
|
|
|
|
/* start from most recently used */
|
|
count = min((word32)ClientCache[row].totalCount, CLIENT_SESSIONS_PER_ROW);
|
|
idx = ClientCache[row].nextIdx - 1;
|
|
if (idx < 0 || idx >= CLIENT_SESSIONS_PER_ROW) {
|
|
idx = CLIENT_SESSIONS_PER_ROW - 1; /* if back to front, the previous was end */
|
|
}
|
|
clSess = ClientCache[row].Clients;
|
|
|
|
for (; count > 0; --count) {
|
|
WOLFSSL_SESSION* current;
|
|
SessionRow* sessRow;
|
|
|
|
if (clSess[idx].serverRow >= SESSION_ROWS) {
|
|
WOLFSSL_MSG("Client cache serverRow invalid");
|
|
break;
|
|
}
|
|
|
|
/* lock row */
|
|
sessRow = &SessionCache[clSess[idx].serverRow];
|
|
if (SESSION_ROW_RD_LOCK(sessRow) != 0) {
|
|
WOLFSSL_MSG("Session cache row lock failure");
|
|
break;
|
|
}
|
|
|
|
#ifdef SESSION_CACHE_DYNAMIC_MEM
|
|
current = sessRow->Sessions[clSess[idx].serverIdx];
|
|
#else
|
|
current = &sessRow->Sessions[clSess[idx].serverIdx];
|
|
#endif
|
|
if (current && XMEMCMP(current->serverID, id, len) == 0) {
|
|
WOLFSSL_MSG("Found a serverid match for client");
|
|
if (LowResTimer() < (current->bornOn + current->timeout)) {
|
|
WOLFSSL_MSG("Session valid");
|
|
ret = current;
|
|
SESSION_ROW_UNLOCK(sessRow);
|
|
break;
|
|
} else {
|
|
WOLFSSL_MSG("Session timed out"); /* could have more for id */
|
|
}
|
|
} else {
|
|
WOLFSSL_MSG("ServerID not a match from client table");
|
|
}
|
|
SESSION_ROW_UNLOCK(sessRow);
|
|
|
|
idx = idx > 0 ? idx - 1 : CLIENT_SESSIONS_PER_ROW - 1;
|
|
}
|
|
|
|
wc_UnLockMutex(&clisession_mutex);
|
|
|
|
return ret;
|
|
}
|
|
|
|
#endif /* !NO_CLIENT_CACHE */
|
|
|
|
static int SslSessionCacheOff(const WOLFSSL* ssl, const WOLFSSL_SESSION* session)
|
|
{
|
|
(void)session;
|
|
return ssl->options.sessionCacheOff
|
|
#if defined(HAVE_SESSION_TICKET) && defined(WOLFSSL_FORCE_CACHE_ON_TICKET)
|
|
&& session->ticketLen == 0
|
|
#endif
|
|
;
|
|
}
|
|
|
|
#if defined(HAVE_SESSION_TICKET) && defined(WOLFSSL_TLS13) && \
|
|
defined(WOLFSSL_TICKET_NONCE_MALLOC) && \
|
|
(!defined(HAVE_FIPS) || (defined(FIPS_VERSION_GE) && FIPS_VERSION_GE(5,3)))
|
|
/**
|
|
* SessionTicketNoncePrealloc() - prealloc a buffer for ticket nonces
|
|
* @output: [in] pointer to WOLFSSL_SESSION object that will soon be a
|
|
* destination of a session duplication
|
|
* @buf: [out] address of the preallocated buf
|
|
* @len: [out] len of the preallocated buf
|
|
*
|
|
* prealloc a buffer that will likely suffice to contain a ticket nonce. It's
|
|
* used when copying session under lock, when syscalls need to be avoided. If
|
|
* output already has a dynamic buffer, it's reused.
|
|
*/
|
|
static int SessionTicketNoncePrealloc(byte** buf, byte* len, void *heap)
|
|
{
|
|
(void)heap;
|
|
|
|
*buf = (byte*)XMALLOC(PREALLOC_SESSION_TICKET_NONCE_LEN, heap,
|
|
DYNAMIC_TYPE_SESSION_TICK);
|
|
if (*buf == NULL) {
|
|
WOLFSSL_MSG("Failed to preallocate ticket nonce buffer");
|
|
*len = 0;
|
|
return 1;
|
|
}
|
|
|
|
*len = PREALLOC_SESSION_TICKET_NONCE_LEN;
|
|
return 0;
|
|
}
|
|
#endif /* HAVE_SESSION_TICKET && WOLFSSL_TLS13 */
|
|
|
|
static int wolfSSL_DupSessionEx(const WOLFSSL_SESSION* input,
|
|
WOLFSSL_SESSION* output, int avoidSysCalls, byte* ticketNonceBuf,
|
|
byte* ticketNonceLen, byte* preallocUsed);
|
|
|
|
void TlsSessionCacheUnlockRow(word32 row)
|
|
{
|
|
SessionRow* sessRow;
|
|
|
|
sessRow = &SessionCache[row];
|
|
(void)sessRow;
|
|
SESSION_ROW_UNLOCK(sessRow);
|
|
}
|
|
|
|
/* Don't use this function directly. Use TlsSessionCacheGetAndRdLock and
|
|
* TlsSessionCacheGetAndWrLock to fully utilize compiler const support. */
|
|
static int TlsSessionCacheGetAndLock(const byte *id,
|
|
const WOLFSSL_SESSION **sess, word32 *lockedRow, byte readOnly, byte side)
|
|
{
|
|
SessionRow *sessRow;
|
|
const WOLFSSL_SESSION *s;
|
|
word32 row;
|
|
int count;
|
|
int error;
|
|
int idx;
|
|
|
|
*sess = NULL;
|
|
row = HashObject(id, ID_LEN, &error) % SESSION_ROWS;
|
|
if (error != 0)
|
|
return error;
|
|
sessRow = &SessionCache[row];
|
|
if (readOnly)
|
|
error = SESSION_ROW_RD_LOCK(sessRow);
|
|
else
|
|
error = SESSION_ROW_WR_LOCK(sessRow);
|
|
if (error != 0)
|
|
return FATAL_ERROR;
|
|
|
|
/* start from most recently used */
|
|
count = min((word32)sessRow->totalCount, SESSIONS_PER_ROW);
|
|
idx = sessRow->nextIdx - 1;
|
|
if (idx < 0 || idx >= SESSIONS_PER_ROW) {
|
|
idx = SESSIONS_PER_ROW - 1; /* if back to front, the previous was end */
|
|
}
|
|
for (; count > 0; --count) {
|
|
#ifdef SESSION_CACHE_DYNAMIC_MEM
|
|
s = sessRow->Sessions[idx];
|
|
#else
|
|
s = &sessRow->Sessions[idx];
|
|
#endif
|
|
if (s && XMEMCMP(s->sessionID, id, ID_LEN) == 0 && s->side == side) {
|
|
*sess = s;
|
|
break;
|
|
}
|
|
idx = idx > 0 ? idx - 1 : SESSIONS_PER_ROW - 1;
|
|
}
|
|
if (*sess == NULL) {
|
|
SESSION_ROW_UNLOCK(sessRow);
|
|
}
|
|
else {
|
|
*lockedRow = row;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int CheckSessionMatch(const WOLFSSL* ssl, const WOLFSSL_SESSION* sess)
|
|
{
|
|
if (ssl == NULL || sess == NULL)
|
|
return 0;
|
|
#ifdef OPENSSL_EXTRA
|
|
if (ssl->sessionCtxSz > 0 && (ssl->sessionCtxSz != sess->sessionCtxSz ||
|
|
XMEMCMP(ssl->sessionCtx, sess->sessionCtx, sess->sessionCtxSz) != 0))
|
|
return 0;
|
|
#endif
|
|
#if defined(WOLFSSL_TLS13) && defined(HAVE_SESSION_TICKET)
|
|
if (IsAtLeastTLSv1_3(ssl->version) != IsAtLeastTLSv1_3(sess->version))
|
|
return 0;
|
|
#endif
|
|
return 1;
|
|
}
|
|
|
|
int TlsSessionCacheGetAndRdLock(const byte *id, const WOLFSSL_SESSION **sess,
|
|
word32 *lockedRow, byte side)
|
|
{
|
|
return TlsSessionCacheGetAndLock(id, sess, lockedRow, 1, side);
|
|
}
|
|
|
|
int TlsSessionCacheGetAndWrLock(const byte *id, WOLFSSL_SESSION **sess,
|
|
word32 *lockedRow, byte side)
|
|
{
|
|
return TlsSessionCacheGetAndLock(id, (const WOLFSSL_SESSION**)sess,
|
|
lockedRow, 0, side);
|
|
}
|
|
|
|
int wolfSSL_GetSessionFromCache(WOLFSSL* ssl, WOLFSSL_SESSION* output)
|
|
{
|
|
const WOLFSSL_SESSION* sess = NULL;
|
|
const byte* id = NULL;
|
|
word32 row;
|
|
int error = 0;
|
|
#ifdef HAVE_SESSION_TICKET
|
|
#ifndef WOLFSSL_SMALL_STACK
|
|
byte tmpTicket[PREALLOC_SESSION_TICKET_LEN];
|
|
#else
|
|
byte* tmpTicket = NULL;
|
|
#endif
|
|
#ifdef WOLFSSL_TLS13
|
|
byte *preallocNonce = NULL;
|
|
byte preallocNonceLen = 0;
|
|
byte preallocNonceUsed = 0;
|
|
#endif /* WOLFSSL_TLS13 */
|
|
byte tmpBufSet = 0;
|
|
#endif
|
|
#if defined(SESSION_CERTS) && defined(OPENSSL_EXTRA)
|
|
WOLFSSL_X509* peer = NULL;
|
|
#endif
|
|
byte bogusID[ID_LEN];
|
|
byte bogusIDSz = 0;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_GetSessionFromCache");
|
|
|
|
if (output == NULL) {
|
|
WOLFSSL_MSG("NULL output");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
if (SslSessionCacheOff(ssl, ssl->session))
|
|
return WOLFSSL_FAILURE;
|
|
|
|
if (ssl->options.haveSessionId == 0 && !ssl->session->haveAltSessionID)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
#ifdef HAVE_SESSION_TICKET
|
|
if (ssl->options.side == WOLFSSL_SERVER_END && ssl->options.useTicket == 1)
|
|
return WOLFSSL_FAILURE;
|
|
#endif
|
|
|
|
XMEMSET(bogusID, 0, sizeof(bogusID));
|
|
if (!IsAtLeastTLSv1_3(ssl->version) && ssl->arrays != NULL
|
|
&& !ssl->session->haveAltSessionID)
|
|
id = ssl->arrays->sessionID;
|
|
else if (ssl->session->haveAltSessionID) {
|
|
id = ssl->session->altSessionID;
|
|
/* We want to restore the bogus ID for TLS compatibility */
|
|
if (output == ssl->session) {
|
|
XMEMCPY(bogusID, ssl->session->sessionID, ID_LEN);
|
|
bogusIDSz = ssl->session->sessionIDSz;
|
|
}
|
|
}
|
|
else
|
|
id = ssl->session->sessionID;
|
|
|
|
|
|
#ifdef HAVE_EXT_CACHE
|
|
if (ssl->ctx->get_sess_cb != NULL) {
|
|
int copy = 0;
|
|
int found = 0;
|
|
WOLFSSL_SESSION* extSess;
|
|
/* Attempt to retrieve the session from the external cache. */
|
|
WOLFSSL_MSG("Calling external session cache");
|
|
extSess = ssl->ctx->get_sess_cb(ssl, (byte*)id, ID_LEN, ©);
|
|
if ((extSess != NULL)
|
|
&& CheckSessionMatch(ssl, extSess)
|
|
) {
|
|
WOLFSSL_MSG("Session found in external cache");
|
|
found = 1;
|
|
|
|
error = wolfSSL_DupSession(extSess, output, 0);
|
|
#ifdef HAVE_EX_DATA
|
|
extSess->ownExData = 1;
|
|
output->ownExData = 0;
|
|
#endif
|
|
/* We want to restore the bogus ID for TLS compatibility */
|
|
if (ssl->session->haveAltSessionID &&
|
|
output == ssl->session) {
|
|
XMEMCPY(ssl->session->sessionID, bogusID, ID_LEN);
|
|
ssl->session->sessionIDSz = bogusIDSz;
|
|
}
|
|
}
|
|
/* If copy not set then free immediately */
|
|
if (extSess != NULL && !copy)
|
|
wolfSSL_FreeSession(ssl->ctx, extSess);
|
|
if (found)
|
|
return error;
|
|
WOLFSSL_MSG("Session not found in external cache");
|
|
}
|
|
|
|
if (ssl->options.internalCacheLookupOff) {
|
|
WOLFSSL_MSG("Internal cache lookup turned off");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
#endif
|
|
|
|
#ifdef HAVE_SESSION_TICKET
|
|
if (output->ticket == NULL ||
|
|
output->ticketLenAlloc < PREALLOC_SESSION_TICKET_LEN) {
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
tmpTicket = (byte*)XMALLOC(PREALLOC_SESSION_TICKET_LEN, output->heap,
|
|
DYNAMIC_TYPE_TMP_BUFFER);
|
|
if (tmpTicket == NULL) {
|
|
WOLFSSL_MSG("tmpTicket malloc failed");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
#endif
|
|
if (output->ticketLenAlloc)
|
|
XFREE(output->ticket, output->heap, DYNAMIC_TYPE_SESSION_TICK);
|
|
output->ticket = tmpTicket; /* cppcheck-suppress autoVariables
|
|
*/
|
|
output->ticketLenAlloc = PREALLOC_SESSION_TICKET_LEN;
|
|
output->ticketLen = 0;
|
|
tmpBufSet = 1;
|
|
}
|
|
#endif
|
|
|
|
#if defined(SESSION_CERTS) && defined(OPENSSL_EXTRA)
|
|
if (output->peer != NULL) {
|
|
wolfSSL_X509_free(output->peer);
|
|
output->peer = NULL;
|
|
}
|
|
#endif
|
|
|
|
#if defined(WOLFSSL_TLS13) && defined(HAVE_SESSION_TICKET) && \
|
|
defined(WOLFSSL_TICKET_NONCE_MALLOC) && \
|
|
(!defined(HAVE_FIPS) || (defined(FIPS_VERSION_GE) && FIPS_VERSION_GE(5,3)))
|
|
if (output->ticketNonce.data != output->ticketNonce.dataStatic) {
|
|
XFREE(output->ticketNonce.data, output->heap,
|
|
DYNAMIC_TYPE_SESSION_TICK);
|
|
output->ticketNonce.data = output->ticketNonce.dataStatic;
|
|
output->ticketNonce.len = 0;
|
|
}
|
|
error = SessionTicketNoncePrealloc(&preallocNonce, &preallocNonceLen,
|
|
output->heap);
|
|
if (error != 0) {
|
|
if (tmpBufSet) {
|
|
output->ticket = output->staticTicket;
|
|
output->ticketLenAlloc = 0;
|
|
}
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
if (tmpTicket != NULL)
|
|
XFREE(tmpTicket, output->heap, DYNAMIC_TYPE_TMP_BUFFER);
|
|
#endif
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
#endif /* WOLFSSL_TLS13 && HAVE_SESSION_TICKET*/
|
|
|
|
/* init to avoid clang static analyzer false positive */
|
|
row = 0;
|
|
error = TlsSessionCacheGetAndRdLock(id, &sess, &row, (byte)ssl->options.side);
|
|
error = (error == 0) ? WOLFSSL_SUCCESS : WOLFSSL_FAILURE;
|
|
if (error != WOLFSSL_SUCCESS || sess == NULL) {
|
|
WOLFSSL_MSG("Get Session from cache failed");
|
|
error = WOLFSSL_FAILURE;
|
|
#ifdef HAVE_SESSION_TICKET
|
|
if (tmpBufSet) {
|
|
output->ticket = output->staticTicket;
|
|
output->ticketLenAlloc = 0;
|
|
}
|
|
#ifdef WOLFSSL_TLS13
|
|
if (preallocNonce != NULL) {
|
|
XFREE(preallocNonce, output->heap, DYNAMIC_TYPE_SESSION_TICK);
|
|
preallocNonce = NULL;
|
|
}
|
|
#endif /* WOLFSSL_TLS13 */
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
if (tmpTicket != NULL) {
|
|
XFREE(tmpTicket, output->heap, DYNAMIC_TYPE_TMP_BUFFER);
|
|
tmpTicket = NULL;
|
|
}
|
|
#endif
|
|
#endif
|
|
}
|
|
else {
|
|
if (!CheckSessionMatch(ssl, sess)) {
|
|
WOLFSSL_MSG("Invalid session: can't be used in this context");
|
|
TlsSessionCacheUnlockRow(row);
|
|
error = WOLFSSL_FAILURE;
|
|
}
|
|
else if (LowResTimer() >= (sess->bornOn + sess->timeout)) {
|
|
WOLFSSL_SESSION* wrSess = NULL;
|
|
WOLFSSL_MSG("Invalid session: timed out");
|
|
sess = NULL;
|
|
TlsSessionCacheUnlockRow(row);
|
|
/* Attempt to get a write lock */
|
|
error = TlsSessionCacheGetAndWrLock(id, &wrSess, &row,
|
|
(byte)ssl->options.side);
|
|
if (error == 0 && wrSess != NULL) {
|
|
EvictSessionFromCache(wrSess);
|
|
TlsSessionCacheUnlockRow(row);
|
|
}
|
|
error = WOLFSSL_FAILURE;
|
|
}
|
|
}
|
|
|
|
/* mollify confused cppcheck nullPointer warning. */
|
|
if (sess == NULL)
|
|
error = WOLFSSL_FAILURE;
|
|
|
|
if (error == WOLFSSL_SUCCESS) {
|
|
#if defined(HAVE_SESSION_TICKET) && defined(WOLFSSL_TLS13)
|
|
error = wolfSSL_DupSessionEx(sess, output, 1,
|
|
preallocNonce, &preallocNonceLen, &preallocNonceUsed);
|
|
#else
|
|
error = wolfSSL_DupSession(sess, output, 1);
|
|
#endif /* HAVE_SESSION_TICKET && WOLFSSL_TLS13 */
|
|
#ifdef HAVE_EX_DATA
|
|
output->ownExData = !sess->ownExData; /* Session may own ex_data */
|
|
#endif
|
|
TlsSessionCacheUnlockRow(row);
|
|
}
|
|
|
|
/* We want to restore the bogus ID for TLS compatibility */
|
|
if (ssl->session->haveAltSessionID &&
|
|
output == ssl->session) {
|
|
XMEMCPY(ssl->session->sessionID, bogusID, ID_LEN);
|
|
ssl->session->sessionIDSz = bogusIDSz;
|
|
}
|
|
|
|
#ifdef HAVE_SESSION_TICKET
|
|
if (tmpBufSet) {
|
|
if (error == WOLFSSL_SUCCESS) {
|
|
if (output->ticketLen > SESSION_TICKET_LEN) {
|
|
output->ticket = (byte*)XMALLOC(output->ticketLen, output->heap,
|
|
DYNAMIC_TYPE_SESSION_TICK);
|
|
if (output->ticket == NULL) {
|
|
error = WOLFSSL_FAILURE;
|
|
output->ticket = output->staticTicket;
|
|
output->ticketLenAlloc = 0;
|
|
output->ticketLen = 0;
|
|
}
|
|
}
|
|
else {
|
|
output->ticket = output->staticTicket;
|
|
output->ticketLenAlloc = 0;
|
|
}
|
|
}
|
|
else {
|
|
output->ticket = output->staticTicket;
|
|
output->ticketLenAlloc = 0;
|
|
output->ticketLen = 0;
|
|
}
|
|
if (error == WOLFSSL_SUCCESS) {
|
|
XMEMCPY(output->ticket, tmpTicket, output->ticketLen);
|
|
}
|
|
}
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
if (tmpTicket != NULL)
|
|
XFREE(tmpTicket, output->heap, DYNAMIC_TYPE_TMP_BUFFER);
|
|
#endif
|
|
|
|
#if defined(WOLFSSL_TLS13) && defined(WOLFSSL_TICKET_NONCE_MALLOC) && \
|
|
(!defined(HAVE_FIPS) || (defined(FIPS_VERSION_GE) && FIPS_VERSION_GE(5,3)))
|
|
if (error == WOLFSSL_SUCCESS && preallocNonceUsed) {
|
|
if (preallocNonceLen < PREALLOC_SESSION_TICKET_NONCE_LEN) {
|
|
/* buffer bigger than needed */
|
|
#ifndef XREALLOC
|
|
output->ticketNonce.data = (byte*)XMALLOC(preallocNonceLen,
|
|
output->heap, DYNAMIC_TYPE_SESSION_TICK);
|
|
if (output->ticketNonce.data != NULL)
|
|
XMEMCPY(output->ticketNonce.data, preallocNonce,
|
|
preallocNonceLen);
|
|
XFREE(preallocNonce, output->heap, DYNAMIC_TYPE_SESSION_TICK);
|
|
preallocNonce = NULL;
|
|
#else
|
|
output->ticketNonce.data = XREALLOC(preallocNonce,
|
|
preallocNonceLen, output->heap, DYNAMIC_TYPE_SESSION_TICK);
|
|
if (output->ticketNonce.data != NULL) {
|
|
/* don't free the reallocated pointer */
|
|
preallocNonce = NULL;
|
|
}
|
|
#endif /* !XREALLOC */
|
|
if (output->ticketNonce.data == NULL) {
|
|
output->ticketNonce.data = output->ticketNonce.dataStatic;
|
|
output->ticketNonce.len = 0;
|
|
error = WOLFSSL_FAILURE;
|
|
/* preallocNonce will be free'd after the if */
|
|
}
|
|
}
|
|
else {
|
|
output->ticketNonce.data = preallocNonce;
|
|
output->ticketNonce.len = preallocNonceLen;
|
|
preallocNonce = NULL;
|
|
}
|
|
}
|
|
if (preallocNonce != NULL)
|
|
XFREE(preallocNonce, output->heap, DYNAMIC_TYPE_SESSION_TICK);
|
|
#endif /* WOLFSSL_TLS13 && WOLFSSL_TICKET_NONCE_MALLOC && FIPS_VERSION_GE(5,3)*/
|
|
|
|
#endif
|
|
|
|
#if defined(SESSION_CERTS) && defined(OPENSSL_EXTRA)
|
|
if (peer != NULL) {
|
|
wolfSSL_X509_free(peer);
|
|
}
|
|
#endif
|
|
|
|
return error;
|
|
}
|
|
|
|
WOLFSSL_SESSION* wolfSSL_GetSession(WOLFSSL* ssl, byte* masterSecret,
|
|
byte restoreSessionCerts)
|
|
{
|
|
WOLFSSL_SESSION* ret = NULL;
|
|
|
|
(void)restoreSessionCerts; /* Kept for compatibility */
|
|
|
|
if (wolfSSL_GetSessionFromCache(ssl, ssl->session) == WOLFSSL_SUCCESS) {
|
|
ret = ssl->session;
|
|
}
|
|
else {
|
|
WOLFSSL_MSG("wolfSSL_GetSessionFromCache did not return a session");
|
|
}
|
|
|
|
if (ret != NULL && masterSecret != NULL)
|
|
XMEMCPY(masterSecret, ret->masterSecret, SECRET_LEN);
|
|
|
|
return ret;
|
|
}
|
|
|
|
int wolfSSL_SetSession(WOLFSSL* ssl, WOLFSSL_SESSION* session)
|
|
{
|
|
SessionRow* sessRow = NULL;
|
|
int ret = WOLFSSL_SUCCESS;
|
|
|
|
session = ClientSessionToSession(session);
|
|
|
|
if (ssl == NULL || session == NULL || !session->isSetup) {
|
|
WOLFSSL_MSG("ssl or session NULL or not set up");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
/* We need to lock the session as the first step if its in the cache */
|
|
if (session->type == WOLFSSL_SESSION_TYPE_CACHE) {
|
|
if (session->cacheRow < SESSION_ROWS) {
|
|
sessRow = &SessionCache[session->cacheRow];
|
|
if (SESSION_ROW_RD_LOCK(sessRow) != 0) {
|
|
WOLFSSL_MSG("Session row lock failed");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (ret == WOLFSSL_SUCCESS && ssl->options.side != WOLFSSL_NEITHER_END &&
|
|
(byte)ssl->options.side != session->side) {
|
|
WOLFSSL_MSG("Setting session for wrong role");
|
|
ret = WOLFSSL_FAILURE;
|
|
}
|
|
|
|
if (ret == WOLFSSL_SUCCESS) {
|
|
if (ssl->session == session) {
|
|
WOLFSSL_MSG("ssl->session and session same");
|
|
}
|
|
else if (session->type != WOLFSSL_SESSION_TYPE_CACHE) {
|
|
if (wolfSSL_SESSION_up_ref(session) == WOLFSSL_SUCCESS) {
|
|
wolfSSL_FreeSession(ssl->ctx, ssl->session);
|
|
ssl->session = session;
|
|
}
|
|
else
|
|
ret = WOLFSSL_FAILURE;
|
|
}
|
|
else {
|
|
ret = wolfSSL_DupSession(session, ssl->session, 0);
|
|
if (ret != WOLFSSL_SUCCESS)
|
|
WOLFSSL_MSG("Session duplicate failed");
|
|
}
|
|
}
|
|
|
|
/* Let's copy over the altSessionID for local cache purposes */
|
|
if (ret == WOLFSSL_SUCCESS && session->haveAltSessionID &&
|
|
ssl->session != session) {
|
|
ssl->session->haveAltSessionID = 1;
|
|
XMEMCPY(ssl->session->altSessionID, session->altSessionID, ID_LEN);
|
|
}
|
|
|
|
if (sessRow != NULL) {
|
|
SESSION_ROW_UNLOCK(sessRow);
|
|
sessRow = NULL;
|
|
}
|
|
|
|
/* Note: the `session` variable cannot be used below, since the row is
|
|
* un-locked */
|
|
|
|
if (ret != WOLFSSL_SUCCESS)
|
|
return ret;
|
|
|
|
#ifdef WOLFSSL_SESSION_ID_CTX
|
|
/* check for application context id */
|
|
if (ssl->sessionCtxSz > 0) {
|
|
if (XMEMCMP(ssl->sessionCtx, ssl->session->sessionCtx, ssl->sessionCtxSz)) {
|
|
/* context id did not match! */
|
|
WOLFSSL_MSG("Session context did not match");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
}
|
|
#endif /* WOLFSSL_SESSION_ID_CTX */
|
|
|
|
if (LowResTimer() >= (ssl->session->bornOn + ssl->session->timeout)) {
|
|
#if !defined(OPENSSL_EXTRA) || !defined(WOLFSSL_ERROR_CODE_OPENSSL)
|
|
return WOLFSSL_FAILURE; /* session timed out */
|
|
#else /* defined(OPENSSL_EXTRA) && defined(WOLFSSL_ERROR_CODE_OPENSSL) */
|
|
WOLFSSL_MSG("Session is expired but return success for "
|
|
"OpenSSL compatibility");
|
|
#endif
|
|
}
|
|
ssl->options.resuming = 1;
|
|
ssl->options.haveEMS = ssl->session->haveEMS;
|
|
|
|
#if defined(SESSION_CERTS) || (defined(WOLFSSL_TLS13) && \
|
|
defined(HAVE_SESSION_TICKET))
|
|
ssl->version = ssl->session->version;
|
|
if (IsAtLeastTLSv1_3(ssl->version))
|
|
ssl->options.tls1_3 = 1;
|
|
#endif
|
|
#if defined(SESSION_CERTS) || !defined(NO_RESUME_SUITE_CHECK) || \
|
|
(defined(WOLFSSL_TLS13) && defined(HAVE_SESSION_TICKET))
|
|
ssl->options.cipherSuite0 = ssl->session->cipherSuite0;
|
|
ssl->options.cipherSuite = ssl->session->cipherSuite;
|
|
#endif
|
|
#if defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL)
|
|
ssl->peerVerifyRet = (unsigned long)ssl->session->peerVerifyRet;
|
|
#endif
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
|
|
#ifdef WOLFSSL_SESSION_STATS
|
|
static int get_locked_session_stats(word32* active, word32* total,
|
|
word32* peak);
|
|
#endif
|
|
|
|
#ifndef NO_CLIENT_CACHE
|
|
ClientSession* AddSessionToClientCache(int side, int row, int idx, byte* serverID,
|
|
word16 idLen, const byte* sessionID,
|
|
word16 useTicket)
|
|
{
|
|
int error = -1;
|
|
word32 clientRow = 0, clientIdx = 0;
|
|
ClientSession* ret = NULL;
|
|
|
|
(void)useTicket;
|
|
if (side == WOLFSSL_CLIENT_END
|
|
&& row != INVALID_SESSION_ROW
|
|
&& (idLen
|
|
#ifdef HAVE_SESSION_TICKET
|
|
|| useTicket == 1
|
|
#endif
|
|
|| serverID != NULL
|
|
)) {
|
|
|
|
WOLFSSL_MSG("Trying to add client cache entry");
|
|
|
|
if (idLen) {
|
|
clientRow = HashObject(serverID,
|
|
idLen, &error) % CLIENT_SESSION_ROWS;
|
|
}
|
|
else if (serverID != NULL) {
|
|
clientRow = HashObject(sessionID,
|
|
ID_LEN, &error) % CLIENT_SESSION_ROWS;
|
|
}
|
|
else {
|
|
error = -1;
|
|
}
|
|
if (error == 0 && wc_LockMutex(&clisession_mutex) == 0) {
|
|
clientIdx = ClientCache[clientRow].nextIdx;
|
|
if (clientIdx < CLIENT_SESSIONS_PER_ROW) {
|
|
ClientCache[clientRow].Clients[clientIdx].serverRow =
|
|
(word16)row;
|
|
ClientCache[clientRow].Clients[clientIdx].serverIdx =
|
|
(word16)idx;
|
|
if (sessionID != NULL) {
|
|
word32 sessionIDHash = HashObject(sessionID, ID_LEN,
|
|
&error);
|
|
if (error == 0) {
|
|
ClientCache[clientRow].Clients[clientIdx].sessionIDHash
|
|
= sessionIDHash;
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
error = -1;
|
|
ClientCache[clientRow].nextIdx = 0; /* reset index as safety */
|
|
WOLFSSL_MSG("Invalid client cache index! "
|
|
"Possible corrupted memory");
|
|
}
|
|
if (error == 0) {
|
|
WOLFSSL_MSG("Adding client cache entry");
|
|
|
|
ret = &ClientCache[clientRow].Clients[clientIdx];
|
|
|
|
if (ClientCache[clientRow].totalCount < CLIENT_SESSIONS_PER_ROW)
|
|
ClientCache[clientRow].totalCount++;
|
|
ClientCache[clientRow].nextIdx++;
|
|
ClientCache[clientRow].nextIdx %= CLIENT_SESSIONS_PER_ROW;
|
|
}
|
|
|
|
wc_UnLockMutex(&clisession_mutex);
|
|
}
|
|
else {
|
|
WOLFSSL_MSG("Hash session or lock failed");
|
|
}
|
|
}
|
|
else {
|
|
WOLFSSL_MSG("Skipping client cache");
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
#endif /* !NO_CLIENT_CACHE */
|
|
|
|
/**
|
|
* For backwards compatibility, this API needs to be used in *ALL* functions
|
|
* that access the WOLFSSL_SESSION members directly.
|
|
*
|
|
* This API checks if the passed in session is actually a ClientSession object
|
|
* and returns the matching session cache object. Otherwise just return the
|
|
* input. ClientSession objects only occur in the ClientCache. They are not
|
|
* allocated anywhere else.
|
|
*/
|
|
WOLFSSL_SESSION* ClientSessionToSession(const WOLFSSL_SESSION* session)
|
|
{
|
|
WOLFSSL_ENTER("ClientSessionToSession");
|
|
#ifdef NO_SESSION_CACHE_REF
|
|
return (WOLFSSL_SESSION*)session;
|
|
#else
|
|
#ifndef NO_CLIENT_CACHE
|
|
if (session == NULL)
|
|
return NULL;
|
|
/* Check if session points into ClientCache */
|
|
if ((byte*)session >= (byte*)ClientCache &&
|
|
/* Cast to byte* to make pointer arithmetic work per byte */
|
|
(byte*)session < ((byte*)ClientCache) + sizeof(ClientCache)) {
|
|
ClientSession* clientSession = (ClientSession*)session;
|
|
SessionRow* sessRow = NULL;
|
|
WOLFSSL_SESSION* cacheSession = NULL;
|
|
word32 sessionIDHash = 0;
|
|
int error = 0;
|
|
session = NULL; /* Default to NULL for failure case */
|
|
if (wc_LockMutex(&clisession_mutex) != 0) {
|
|
WOLFSSL_MSG("Client cache mutex lock failed");
|
|
return NULL;
|
|
}
|
|
if (clientSession->serverRow >= SESSION_ROWS ||
|
|
clientSession->serverIdx >= SESSIONS_PER_ROW) {
|
|
WOLFSSL_MSG("Client cache serverRow or serverIdx invalid");
|
|
error = -1;
|
|
}
|
|
if (error == 0) {
|
|
/* Lock row */
|
|
sessRow = &SessionCache[clientSession->serverRow];
|
|
error = SESSION_ROW_RD_LOCK(sessRow);
|
|
if (error != 0) {
|
|
WOLFSSL_MSG("Session cache row lock failure");
|
|
sessRow = NULL;
|
|
}
|
|
}
|
|
if (error == 0) {
|
|
#ifdef SESSION_CACHE_DYNAMIC_MEM
|
|
cacheSession = sessRow->Sessions[clientSession->serverIdx];
|
|
#else
|
|
cacheSession = &sessRow->Sessions[clientSession->serverIdx];
|
|
#endif
|
|
if (cacheSession && cacheSession->sessionIDSz == 0) {
|
|
cacheSession = NULL;
|
|
WOLFSSL_MSG("Session cache entry not set");
|
|
error = -1;
|
|
}
|
|
}
|
|
if (error == 0) {
|
|
/* Calculate the hash of the session ID */
|
|
sessionIDHash = HashObject(cacheSession->sessionID, ID_LEN,
|
|
&error);
|
|
}
|
|
if (error == 0) {
|
|
/* Check the session ID hash matches */
|
|
error = clientSession->sessionIDHash != sessionIDHash;
|
|
if (error != 0)
|
|
WOLFSSL_MSG("session ID hash don't match");
|
|
}
|
|
if (error == 0) {
|
|
/* Hashes match */
|
|
session = cacheSession;
|
|
WOLFSSL_MSG("Found session cache matching client session object");
|
|
}
|
|
if (sessRow != NULL) {
|
|
SESSION_ROW_UNLOCK(sessRow);
|
|
}
|
|
wc_UnLockMutex(&clisession_mutex);
|
|
return (WOLFSSL_SESSION*)session;
|
|
}
|
|
else {
|
|
/* Plain WOLFSSL_SESSION object */
|
|
return (WOLFSSL_SESSION*)session;
|
|
}
|
|
#else
|
|
return (WOLFSSL_SESSION*)session;
|
|
#endif
|
|
#endif
|
|
}
|
|
|
|
int AddSessionToCache(WOLFSSL_CTX* ctx, WOLFSSL_SESSION* addSession,
|
|
const byte* id, byte idSz, int* sessionIndex, int side,
|
|
word16 useTicket, ClientSession** clientCacheEntry)
|
|
{
|
|
WOLFSSL_SESSION* cacheSession = NULL;
|
|
SessionRow* sessRow = NULL;
|
|
word32 idx = 0;
|
|
#if defined(SESSION_CERTS) && defined(OPENSSL_EXTRA)
|
|
WOLFSSL_X509* cachePeer = NULL;
|
|
WOLFSSL_X509* addPeer = NULL;
|
|
#endif
|
|
#ifdef HAVE_SESSION_TICKET
|
|
byte* cacheTicBuff = NULL;
|
|
byte ticBuffUsed = 0;
|
|
byte* ticBuff = NULL;
|
|
int ticLen = 0;
|
|
#if defined(WOLFSSL_TLS13) && defined(WOLFSSL_TICKET_NONCE_MALLOC) && \
|
|
(!defined(HAVE_FIPS) || (defined(FIPS_VERSION_GE) && FIPS_VERSION_GE(5,3)))
|
|
byte *preallocNonce = NULL;
|
|
byte preallocNonceLen = 0;
|
|
byte preallocNonceUsed = 0;
|
|
byte *toFree = NULL;
|
|
#endif /* WOLFSSL_TLS13 && WOLFSSL_TICKET_NONCE_MALLOC */
|
|
#endif /* HAVE_SESSION_TICKET */
|
|
int ret = 0;
|
|
int row;
|
|
int i;
|
|
int overwrite = 0;
|
|
(void)ctx;
|
|
(void)sessionIndex;
|
|
(void)useTicket;
|
|
(void)clientCacheEntry;
|
|
|
|
WOLFSSL_ENTER("AddSessionToCache");
|
|
|
|
if (idSz == 0) {
|
|
WOLFSSL_MSG("AddSessionToCache idSz == 0");
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
addSession = ClientSessionToSession(addSession);
|
|
if (addSession == NULL) {
|
|
WOLFSSL_MSG("AddSessionToCache is NULL");
|
|
return MEMORY_E;
|
|
}
|
|
|
|
#ifdef HAVE_SESSION_TICKET
|
|
ticLen = addSession->ticketLen;
|
|
/* Alloc Memory here to avoid syscalls during lock */
|
|
if (ticLen > SESSION_TICKET_LEN) {
|
|
ticBuff = (byte*)XMALLOC(ticLen, NULL,
|
|
DYNAMIC_TYPE_SESSION_TICK);
|
|
if (ticBuff == NULL) {
|
|
return MEMORY_E;
|
|
}
|
|
}
|
|
#if defined(WOLFSSL_TLS13) && defined(WOLFSSL_TICKET_NONCE_MALLOC) && \
|
|
(!defined(HAVE_FIPS) || (defined(FIPS_VERSION_GE) && FIPS_VERSION_GE(5,3)))
|
|
if (addSession->ticketNonce.data != addSession->ticketNonce.dataStatic) {
|
|
/* use the AddSession->heap even if the buffer maybe saved in
|
|
* CachedSession objects. CachedSession heap and AddSession heap should
|
|
* be the same */
|
|
preallocNonce = (byte*)XMALLOC(addSession->ticketNonce.len,
|
|
addSession->heap, DYNAMIC_TYPE_SESSION_TICK);
|
|
if (preallocNonce == NULL) {
|
|
if (ticBuff != NULL)
|
|
XFREE(ticBuff, addSession->heap, DYNAMIC_TYPE_SESSION_TICK);
|
|
return MEMORY_E;
|
|
}
|
|
preallocNonceLen = addSession->ticketNonce.len;
|
|
}
|
|
#endif /* WOLFSSL_TLS13 && WOLFSL_TICKET_NONCE_MALLOC && FIPS_VERSION_GE(5,3) */
|
|
#endif /* HAVE_SESSION_TICKET */
|
|
|
|
/* Find a position for the new session in cache and use that */
|
|
/* Use the session object in the cache for external cache if required */
|
|
row = (int)(HashObject(id, ID_LEN, &ret) % SESSION_ROWS);
|
|
if (ret != 0) {
|
|
WOLFSSL_MSG("Hash session failed");
|
|
#ifdef HAVE_SESSION_TICKET
|
|
XFREE(ticBuff, NULL, DYNAMIC_TYPE_SESSION_TICK);
|
|
#if defined(WOLFSSL_TLS13) && defined(WOLFSSL_TICKET_NONCE_MALLOC)
|
|
XFREE(preallocNonce, addSession->heap, DYNAMIC_TYPE_SESSION_TICK);
|
|
#endif
|
|
#endif
|
|
return ret;
|
|
}
|
|
|
|
sessRow = &SessionCache[row];
|
|
if (SESSION_ROW_WR_LOCK(sessRow) != 0) {
|
|
#ifdef HAVE_SESSION_TICKET
|
|
XFREE(ticBuff, NULL, DYNAMIC_TYPE_SESSION_TICK);
|
|
#if defined(WOLFSSL_TLS13) && defined(WOLFSSL_TICKET_NONCE_MALLOC)
|
|
XFREE(preallocNonce, addSession->heap, DYNAMIC_TYPE_SESSION_TICK);
|
|
#endif
|
|
#endif
|
|
WOLFSSL_MSG("Session row lock failed");
|
|
return BAD_MUTEX_E;
|
|
}
|
|
|
|
for (i = 0; i < SESSIONS_PER_ROW && i < sessRow->totalCount; i++) {
|
|
#ifdef SESSION_CACHE_DYNAMIC_MEM
|
|
cacheSession = sessRow->Sessions[i];
|
|
#else
|
|
cacheSession = &sessRow->Sessions[i];
|
|
#endif
|
|
if (cacheSession && XMEMCMP(id,
|
|
cacheSession->sessionID, ID_LEN) == 0 &&
|
|
cacheSession->side == side) {
|
|
WOLFSSL_MSG("Session already exists. Overwriting.");
|
|
overwrite = 1;
|
|
idx = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!overwrite)
|
|
idx = sessRow->nextIdx;
|
|
#ifdef SESSION_INDEX
|
|
if (sessionIndex != NULL)
|
|
*sessionIndex = (row << SESSIDX_ROW_SHIFT) | idx;
|
|
#endif
|
|
|
|
#ifdef SESSION_CACHE_DYNAMIC_MEM
|
|
cacheSession = sessRow->Sessions[idx];
|
|
if (cacheSession == NULL) {
|
|
cacheSession = (WOLFSSL_SESSION*) XMALLOC(sizeof(WOLFSSL_SESSION),
|
|
sessRow->heap, DYNAMIC_TYPE_SESSION);
|
|
if (cacheSession == NULL) {
|
|
#ifdef HAVE_SESSION_TICKET
|
|
XFREE(ticBuff, NULL, DYNAMIC_TYPE_SESSION_TICK);
|
|
#if defined(WOLFSSL_TLS13) && defined(WOLFSSL_TICKET_NONCE_MALLOC)
|
|
XFREE(preallocNonce, addSession->heap, DYNAMIC_TYPE_SESSION_TICK);
|
|
#endif
|
|
#endif
|
|
SESSION_ROW_UNLOCK(sessRow);
|
|
return MEMORY_E;
|
|
}
|
|
XMEMSET(cacheSession, 0, sizeof(WOLFSSL_SESSION));
|
|
sessRow->Sessions[idx] = cacheSession;
|
|
}
|
|
#else
|
|
cacheSession = &sessRow->Sessions[idx];
|
|
#endif
|
|
|
|
#ifdef HAVE_EX_DATA
|
|
if (overwrite) {
|
|
/* Figure out who owns the ex_data */
|
|
if (cacheSession->ownExData) {
|
|
/* Prioritize cacheSession copy */
|
|
XMEMCPY(&addSession->ex_data, &cacheSession->ex_data,
|
|
sizeof(WOLFSSL_CRYPTO_EX_DATA));
|
|
}
|
|
/* else will be copied in wolfSSL_DupSession call */
|
|
}
|
|
else if (cacheSession->ownExData) {
|
|
crypto_ex_cb_free_data(cacheSession, crypto_ex_cb_ctx_session,
|
|
&cacheSession->ex_data);
|
|
cacheSession->ownExData = 0;
|
|
}
|
|
#endif
|
|
|
|
if (!overwrite)
|
|
EvictSessionFromCache(cacheSession);
|
|
|
|
cacheSession->type = WOLFSSL_SESSION_TYPE_CACHE;
|
|
cacheSession->cacheRow = row;
|
|
|
|
#if defined(SESSION_CERTS) && defined(OPENSSL_EXTRA)
|
|
/* Save the peer field to free after unlocking the row */
|
|
if (cacheSession->peer != NULL)
|
|
cachePeer = cacheSession->peer;
|
|
cacheSession->peer = NULL;
|
|
#endif
|
|
#ifdef HAVE_SESSION_TICKET
|
|
/* If we can reuse the existing buffer in cacheSession then we won't touch
|
|
* ticBuff at all making it a very cheap malloc/free. The page on a modern
|
|
* OS will most likely not even be allocated to the process. */
|
|
if (ticBuff != NULL && cacheSession->ticketLenAlloc < ticLen) {
|
|
/* Save pointer only if separately allocated */
|
|
if (cacheSession->ticket != cacheSession->staticTicket)
|
|
cacheTicBuff = cacheSession->ticket;
|
|
ticBuffUsed = 1;
|
|
cacheSession->ticket = ticBuff;
|
|
cacheSession->ticketLenAlloc = (word16) ticLen;
|
|
}
|
|
#if defined(WOLFSSL_TLS13) && defined(WOLFSSL_TICKET_NONCE_MALLOC) && \
|
|
(!defined(HAVE_FIPS) || (defined(FIPS_VERSION_GE) && FIPS_VERSION_GE(5,3)))
|
|
/* cache entry never used */
|
|
if (cacheSession->ticketNonce.data == NULL)
|
|
cacheSession->ticketNonce.data = cacheSession->ticketNonce.dataStatic;
|
|
|
|
if (cacheSession->ticketNonce.data !=
|
|
cacheSession->ticketNonce.dataStatic) {
|
|
toFree = cacheSession->ticketNonce.data;
|
|
cacheSession->ticketNonce.data = cacheSession->ticketNonce.dataStatic;
|
|
cacheSession->ticketNonce.len = 0;
|
|
}
|
|
#endif /* WOLFSSL_TLS13 && WOLFSSL_TICKET_NONCE_MALLOC && FIPS_VERSION_GE(5,3)*/
|
|
#endif
|
|
#ifdef SESSION_CERTS
|
|
if (overwrite &&
|
|
addSession->chain.count == 0 &&
|
|
cacheSession->chain.count > 0) {
|
|
/* Copy in the certs from the session */
|
|
addSession->chain.count = cacheSession->chain.count;
|
|
XMEMCPY(addSession->chain.certs, cacheSession->chain.certs,
|
|
sizeof(x509_buffer) * cacheSession->chain.count);
|
|
}
|
|
#endif /* SESSION_CERTS */
|
|
#if defined(SESSION_CERTS) && defined(OPENSSL_EXTRA)
|
|
/* Don't copy the peer cert into cache */
|
|
addPeer = addSession->peer;
|
|
addSession->peer = NULL;
|
|
#endif
|
|
cacheSession->heap = NULL;
|
|
/* Copy data into the cache object */
|
|
#if defined(HAVE_SESSION_TICKET) && defined(WOLFSSL_TLS13) && \
|
|
defined(WOLFSSL_TICKET_NONCE_MALLOC) && \
|
|
(!defined(HAVE_FIPS) || (defined(FIPS_VERSION_GE) && FIPS_VERSION_GE(5,3)))
|
|
ret = wolfSSL_DupSessionEx(addSession, cacheSession, 1, preallocNonce,
|
|
&preallocNonceLen, &preallocNonceUsed) == WOLFSSL_FAILURE;
|
|
#else
|
|
ret = wolfSSL_DupSession(addSession, cacheSession, 1) == WOLFSSL_FAILURE;
|
|
#endif /* HAVE_SESSION_TICKET && WOLFSSL_TLS13 && WOLFSSL_TICKET_NONCE_MALLOC
|
|
&& FIPS_VERSION_GE(5,3)*/
|
|
#if defined(SESSION_CERTS) && defined(OPENSSL_EXTRA)
|
|
addSession->peer = addPeer;
|
|
#endif
|
|
|
|
if (ret == 0) {
|
|
if (!overwrite) {
|
|
/* Increment the totalCount and the nextIdx */
|
|
if (sessRow->totalCount < SESSIONS_PER_ROW)
|
|
sessRow->totalCount++;
|
|
sessRow->nextIdx = (sessRow->nextIdx + 1) % SESSIONS_PER_ROW;
|
|
}
|
|
if (id != addSession->sessionID) {
|
|
/* ssl->session->sessionID may contain the bogus ID or we want the
|
|
* ID from the arrays object */
|
|
XMEMCPY(cacheSession->sessionID, id, ID_LEN);
|
|
cacheSession->sessionIDSz = ID_LEN;
|
|
}
|
|
#if defined(HAVE_EXT_CACHE) || defined(HAVE_EX_DATA)
|
|
if (ctx->rem_sess_cb != NULL)
|
|
cacheSession->rem_sess_cb = ctx->rem_sess_cb;
|
|
#endif
|
|
#ifdef HAVE_EX_DATA
|
|
/* The session in cache now owns the ex_data */
|
|
addSession->ownExData = 0;
|
|
cacheSession->ownExData = 1;
|
|
#endif
|
|
#if defined(HAVE_SESSION_TICKET) && defined(WOLFSSL_TLS13) && \
|
|
defined(WOLFSSL_TICKET_NONCE_MALLOC) && \
|
|
(!defined(HAVE_FIPS) || (defined(FIPS_VERSION_GE) && FIPS_VERSION_GE(5,3)))
|
|
if (preallocNonce != NULL && preallocNonceUsed) {
|
|
cacheSession->ticketNonce.data = preallocNonce;
|
|
cacheSession->ticketNonce.len = preallocNonceLen;
|
|
preallocNonce = NULL;
|
|
preallocNonceLen = 0;
|
|
}
|
|
#endif /* HAVE_SESSION_TICKET && WOLFSSL_TLS13 && WOLFSSL_TICKET_NONCE_MALLOC
|
|
* && FIPS_VERSION_GE(5,3)*/
|
|
}
|
|
#ifdef HAVE_SESSION_TICKET
|
|
else if (ticBuffUsed) {
|
|
/* Error occurred. Need to clean up the ticket buffer. */
|
|
cacheSession->ticket = cacheSession->staticTicket;
|
|
cacheSession->ticketLenAlloc = 0;
|
|
cacheSession->ticketLen = 0;
|
|
}
|
|
#endif
|
|
SESSION_ROW_UNLOCK(sessRow);
|
|
cacheSession = NULL; /* Can't access after unlocked */
|
|
|
|
#ifndef NO_CLIENT_CACHE
|
|
if (ret == 0 && clientCacheEntry != NULL) {
|
|
ClientSession* clientCache = AddSessionToClientCache(side, row, idx,
|
|
addSession->serverID, addSession->idLen, id, useTicket);
|
|
if (clientCache != NULL)
|
|
*clientCacheEntry = clientCache;
|
|
}
|
|
#endif
|
|
|
|
#ifdef HAVE_SESSION_TICKET
|
|
if (ticBuff != NULL && !ticBuffUsed)
|
|
XFREE(ticBuff, NULL, DYNAMIC_TYPE_SESSION_TICK);
|
|
XFREE(cacheTicBuff, NULL, DYNAMIC_TYPE_SESSION_TICK);
|
|
#if defined(WOLFSSL_TLS13) && defined(WOLFSSL_TICKET_NONCE_MALLOC) && \
|
|
(!defined(HAVE_FIPS) || (defined(FIPS_VERSION_GE) && FIPS_VERSION_GE(5,3)))
|
|
XFREE(preallocNonce, addSession->heap, DYNAMIC_TYPE_SESSION_TICK);
|
|
XFREE(toFree, addSession->heap, DYNAMIC_TYPE_SESSION_TICK);
|
|
#endif /* WOLFSSL_TLS13 && WOLFSSL_TICKET_NONCE_MALLOC && FIPS_VERSION_GE(5,3)*/
|
|
#endif
|
|
|
|
#if defined(SESSION_CERTS) && defined(OPENSSL_EXTRA)
|
|
if (cachePeer != NULL) {
|
|
wolfSSL_X509_free(cachePeer);
|
|
cachePeer = NULL; /* Make sure not use after this point */
|
|
}
|
|
#endif
|
|
|
|
return ret;
|
|
}
|
|
|
|
void AddSession(WOLFSSL* ssl)
|
|
{
|
|
int error = 0;
|
|
const byte* id = NULL;
|
|
byte idSz = 0;
|
|
WOLFSSL_SESSION* session = ssl->session;
|
|
|
|
(void)error;
|
|
|
|
WOLFSSL_ENTER("AddSession");
|
|
|
|
if (SslSessionCacheOff(ssl, session)) {
|
|
WOLFSSL_MSG("Cache off");
|
|
return;
|
|
}
|
|
|
|
if (session->haveAltSessionID) {
|
|
id = session->altSessionID;
|
|
idSz = ID_LEN;
|
|
}
|
|
else {
|
|
id = session->sessionID;
|
|
idSz = session->sessionIDSz;
|
|
}
|
|
|
|
/* Do this only for the client because if the server doesn't have an ID at
|
|
* this point, it won't on resumption. */
|
|
if (idSz == 0 && ssl->options.side == WOLFSSL_CLIENT_END) {
|
|
WC_RNG* rng = NULL;
|
|
if (ssl->rng != NULL)
|
|
rng = ssl->rng;
|
|
#if defined(HAVE_GLOBAL_RNG) && defined(OPENSSL_EXTRA)
|
|
else if (initGlobalRNG == 1 || wolfSSL_RAND_Init() == WOLFSSL_SUCCESS) {
|
|
rng = &globalRNG;
|
|
}
|
|
#endif
|
|
if (wc_RNG_GenerateBlock(rng, ssl->session->altSessionID,
|
|
ID_LEN) != 0)
|
|
return;
|
|
ssl->session->haveAltSessionID = 1;
|
|
id = ssl->session->altSessionID;
|
|
idSz = ID_LEN;
|
|
}
|
|
|
|
#ifdef HAVE_EXT_CACHE
|
|
if (!ssl->options.internalCacheOff)
|
|
#endif
|
|
{
|
|
/* Try to add the session to internal cache or external cache
|
|
if a new_sess_cb is set. Its ok if we don't succeed. */
|
|
(void)AddSessionToCache(ssl->ctx, session, id, idSz,
|
|
#ifdef SESSION_INDEX
|
|
&ssl->sessionIndex,
|
|
#else
|
|
NULL,
|
|
#endif
|
|
ssl->options.side,
|
|
#ifdef HAVE_SESSION_TICKET
|
|
ssl->options.useTicket,
|
|
#else
|
|
0,
|
|
#endif
|
|
#ifdef NO_SESSION_CACHE_REF
|
|
NULL
|
|
#else
|
|
(ssl->options.side == WOLFSSL_CLIENT_END) ?
|
|
&ssl->clientSession : NULL
|
|
#endif
|
|
);
|
|
}
|
|
|
|
#ifdef HAVE_EXT_CACHE
|
|
if (error == 0 && ssl->ctx->new_sess_cb != NULL) {
|
|
int cbRet = 0;
|
|
wolfSSL_SESSION_up_ref(session);
|
|
cbRet = ssl->ctx->new_sess_cb(ssl, session);
|
|
if (cbRet == 0)
|
|
wolfSSL_FreeSession(ssl->ctx, session);
|
|
}
|
|
#endif
|
|
|
|
#if defined(WOLFSSL_SESSION_STATS) && defined(WOLFSSL_PEAK_SESSIONS)
|
|
if (error == 0) {
|
|
word32 active = 0;
|
|
|
|
error = get_locked_session_stats(&active, NULL, NULL);
|
|
if (error == WOLFSSL_SUCCESS) {
|
|
error = 0; /* back to this function ok */
|
|
|
|
if (PeakSessions < active) {
|
|
PeakSessions = active;
|
|
}
|
|
}
|
|
}
|
|
#endif /* WOLFSSL_SESSION_STATS && WOLFSSL_PEAK_SESSIONS */
|
|
(void)error;
|
|
}
|
|
|
|
|
|
#ifdef SESSION_INDEX
|
|
|
|
int wolfSSL_GetSessionIndex(WOLFSSL* ssl)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_GetSessionIndex");
|
|
WOLFSSL_LEAVE("wolfSSL_GetSessionIndex", ssl->sessionIndex);
|
|
return ssl->sessionIndex;
|
|
}
|
|
|
|
|
|
int wolfSSL_GetSessionAtIndex(int idx, WOLFSSL_SESSION* session)
|
|
{
|
|
int row, col, result = WOLFSSL_FAILURE;
|
|
SessionRow* sessRow;
|
|
WOLFSSL_SESSION* cacheSession;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_GetSessionAtIndex");
|
|
|
|
session = ClientSessionToSession(session);
|
|
|
|
row = idx >> SESSIDX_ROW_SHIFT;
|
|
col = idx & SESSIDX_IDX_MASK;
|
|
|
|
if (session == NULL ||
|
|
row < 0 || row >= SESSION_ROWS || col >= SESSIONS_PER_ROW) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
sessRow = &SessionCache[row];
|
|
if (SESSION_ROW_RD_LOCK(sessRow) != 0) {
|
|
return BAD_MUTEX_E;
|
|
}
|
|
|
|
#ifdef SESSION_CACHE_DYNAMIC_MEM
|
|
cacheSession = sessRow->Sessions[col];
|
|
#else
|
|
cacheSession = &sessRow->Sessions[col];
|
|
#endif
|
|
if (cacheSession) {
|
|
XMEMCPY(session, cacheSession, sizeof(WOLFSSL_SESSION));
|
|
result = WOLFSSL_SUCCESS;
|
|
}
|
|
else {
|
|
result = WOLFSSL_FAILURE;
|
|
}
|
|
|
|
SESSION_ROW_UNLOCK(sessRow);
|
|
|
|
WOLFSSL_LEAVE("wolfSSL_GetSessionAtIndex", result);
|
|
return result;
|
|
}
|
|
|
|
#endif /* SESSION_INDEX */
|
|
|
|
#if defined(SESSION_CERTS)
|
|
|
|
WOLFSSL_X509_CHAIN* wolfSSL_SESSION_get_peer_chain(WOLFSSL_SESSION* session)
|
|
{
|
|
WOLFSSL_X509_CHAIN* chain = NULL;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_SESSION_get_peer_chain");
|
|
|
|
session = ClientSessionToSession(session);
|
|
|
|
if (session)
|
|
chain = &session->chain;
|
|
|
|
WOLFSSL_LEAVE("wolfSSL_SESSION_get_peer_chain", chain ? 1 : 0);
|
|
return chain;
|
|
}
|
|
|
|
|
|
#ifdef OPENSSL_EXTRA
|
|
/* gets the peer certificate associated with the session passed in
|
|
* returns null on failure, the caller should not free the returned pointer */
|
|
WOLFSSL_X509* wolfSSL_SESSION_get0_peer(WOLFSSL_SESSION* session)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_SESSION_get_peer_chain");
|
|
|
|
session = ClientSessionToSession(session);
|
|
if (session) {
|
|
int count;
|
|
|
|
count = wolfSSL_get_chain_count(&session->chain);
|
|
if (count < 1 || count >= MAX_CHAIN_DEPTH) {
|
|
WOLFSSL_MSG("bad count found");
|
|
return NULL;
|
|
}
|
|
|
|
if (session->peer == NULL) {
|
|
session->peer = wolfSSL_get_chain_X509(&session->chain, 0);
|
|
}
|
|
return session->peer;
|
|
}
|
|
WOLFSSL_MSG("No session passed in");
|
|
|
|
return NULL;
|
|
}
|
|
#endif /* OPENSSL_EXTRA */
|
|
#endif /* SESSION_INDEX && SESSION_CERTS */
|
|
|
|
|
|
#ifdef WOLFSSL_SESSION_STATS
|
|
|
|
static int get_locked_session_stats(word32* active, word32* total, word32* peak)
|
|
{
|
|
int result = WOLFSSL_SUCCESS;
|
|
int i;
|
|
int count;
|
|
int idx;
|
|
word32 now = 0;
|
|
word32 seen = 0;
|
|
word32 ticks = LowResTimer();
|
|
|
|
WOLFSSL_ENTER("get_locked_session_stats");
|
|
|
|
#ifndef ENABLE_SESSION_CACHE_ROW_LOCK
|
|
SESSION_ROW_RD_LOCK(&SessionCache[0]);
|
|
#endif
|
|
for (i = 0; i < SESSION_ROWS; i++) {
|
|
SessionRow* row = &SessionCache[i];
|
|
#ifdef ENABLE_SESSION_CACHE_ROW_LOCK
|
|
if (SESSION_ROW_RD_LOCK(row) != 0) {
|
|
WOLFSSL_MSG("Session row cache mutex lock failed");
|
|
return BAD_MUTEX_E;
|
|
}
|
|
#endif
|
|
|
|
seen += row->totalCount;
|
|
|
|
if (active == NULL) {
|
|
SESSION_ROW_UNLOCK(row);
|
|
continue;
|
|
}
|
|
|
|
count = min((word32)row->totalCount, SESSIONS_PER_ROW);
|
|
idx = row->nextIdx - 1;
|
|
if (idx < 0 || idx >= SESSIONS_PER_ROW) {
|
|
idx = SESSIONS_PER_ROW - 1; /* if back to front previous was end */
|
|
}
|
|
|
|
for (; count > 0; --count) {
|
|
/* if not expired then good */
|
|
#ifdef SESSION_CACHE_DYNAMIC_MEM
|
|
if (row->Sessions[idx] &&
|
|
ticks < (row->Sessions[idx]->bornOn +
|
|
row->Sessions[idx]->timeout) )
|
|
#else
|
|
if (ticks < (row->Sessions[idx].bornOn +
|
|
row->Sessions[idx].timeout) )
|
|
#endif
|
|
{
|
|
now++;
|
|
}
|
|
|
|
idx = idx > 0 ? idx - 1 : SESSIONS_PER_ROW - 1;
|
|
}
|
|
|
|
#ifdef ENABLE_SESSION_CACHE_ROW_LOCK
|
|
SESSION_ROW_UNLOCK(row);
|
|
#endif
|
|
}
|
|
#ifndef ENABLE_SESSION_CACHE_ROW_LOCK
|
|
SESSION_ROW_UNLOCK(&SessionCache[0]);
|
|
#endif
|
|
|
|
if (active) {
|
|
*active = now;
|
|
}
|
|
if (total) {
|
|
*total = seen;
|
|
}
|
|
|
|
#ifdef WOLFSSL_PEAK_SESSIONS
|
|
if (peak) {
|
|
*peak = PeakSessions;
|
|
}
|
|
#else
|
|
(void)peak;
|
|
#endif
|
|
|
|
WOLFSSL_LEAVE("get_locked_session_stats", result);
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
/* return WOLFSSL_SUCCESS on ok */
|
|
int wolfSSL_get_session_stats(word32* active, word32* total, word32* peak,
|
|
word32* maxSessions)
|
|
{
|
|
int result = WOLFSSL_SUCCESS;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_get_session_stats");
|
|
|
|
if (maxSessions) {
|
|
*maxSessions = SESSIONS_PER_ROW * SESSION_ROWS;
|
|
|
|
if (active == NULL && total == NULL && peak == NULL)
|
|
return result; /* we're done */
|
|
}
|
|
|
|
/* user must provide at least one query value */
|
|
if (active == NULL && total == NULL && peak == NULL) {
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
result = get_locked_session_stats(active, total, peak);
|
|
|
|
WOLFSSL_LEAVE("wolfSSL_get_session_stats", result);
|
|
|
|
return result;
|
|
}
|
|
|
|
#endif /* WOLFSSL_SESSION_STATS */
|
|
|
|
|
|
#ifdef PRINT_SESSION_STATS
|
|
|
|
/* WOLFSSL_SUCCESS on ok */
|
|
int wolfSSL_PrintSessionStats(void)
|
|
{
|
|
word32 totalSessionsSeen = 0;
|
|
word32 totalSessionsNow = 0;
|
|
word32 peak = 0;
|
|
word32 maxSessions = 0;
|
|
int i;
|
|
int ret;
|
|
double E; /* expected freq */
|
|
double chiSquare = 0;
|
|
|
|
ret = wolfSSL_get_session_stats(&totalSessionsNow, &totalSessionsSeen,
|
|
&peak, &maxSessions);
|
|
if (ret != WOLFSSL_SUCCESS)
|
|
return ret;
|
|
printf("Total Sessions Seen = %u\n", totalSessionsSeen);
|
|
printf("Total Sessions Now = %u\n", totalSessionsNow);
|
|
#ifdef WOLFSSL_PEAK_SESSIONS
|
|
printf("Peak Sessions = %u\n", peak);
|
|
#endif
|
|
printf("Max Sessions = %u\n", maxSessions);
|
|
|
|
E = (double)totalSessionsSeen / SESSION_ROWS;
|
|
|
|
for (i = 0; i < SESSION_ROWS; i++) {
|
|
double diff = SessionCache[i].totalCount - E;
|
|
diff *= diff; /* square */
|
|
diff /= E; /* normalize */
|
|
|
|
chiSquare += diff;
|
|
}
|
|
printf(" chi-square = %5.1f, d.f. = %d\n", chiSquare,
|
|
SESSION_ROWS - 1);
|
|
#if (SESSION_ROWS == 11)
|
|
printf(" .05 p value = 18.3, chi-square should be less\n");
|
|
#elif (SESSION_ROWS == 211)
|
|
printf(".05 p value = 244.8, chi-square should be less\n");
|
|
#elif (SESSION_ROWS == 5981)
|
|
printf(".05 p value = 6161.0, chi-square should be less\n");
|
|
#elif (SESSION_ROWS == 3)
|
|
printf(".05 p value = 6.0, chi-square should be less\n");
|
|
#elif (SESSION_ROWS == 2861)
|
|
printf(".05 p value = 2985.5, chi-square should be less\n");
|
|
#endif
|
|
printf("\n");
|
|
|
|
return ret;
|
|
}
|
|
|
|
#endif /* SESSION_STATS */
|
|
|
|
#else /* NO_SESSION_CACHE */
|
|
|
|
WOLFSSL_SESSION* ClientSessionToSession(const WOLFSSL_SESSION* session)
|
|
{
|
|
return (WOLFSSL_SESSION*)session;
|
|
}
|
|
|
|
/* No session cache version */
|
|
WOLFSSL_SESSION* wolfSSL_GetSession(WOLFSSL* ssl, byte* masterSecret,
|
|
byte restoreSessionCerts)
|
|
{
|
|
(void)ssl;
|
|
(void)masterSecret;
|
|
(void)restoreSessionCerts;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
#endif /* NO_SESSION_CACHE */
|
|
|
|
|
|
/* call before SSL_connect, if verifying will add name check to
|
|
date check and signature check */
|
|
WOLFSSL_ABI
|
|
int wolfSSL_check_domain_name(WOLFSSL* ssl, const char* dn)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_check_domain_name");
|
|
|
|
if (ssl == NULL || dn == NULL) {
|
|
WOLFSSL_MSG("Bad function argument: NULL");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
if (ssl->buffers.domainName.buffer)
|
|
XFREE(ssl->buffers.domainName.buffer, ssl->heap, DYNAMIC_TYPE_DOMAIN);
|
|
|
|
ssl->buffers.domainName.length = (word32)XSTRLEN(dn);
|
|
ssl->buffers.domainName.buffer = (byte*)XMALLOC(
|
|
ssl->buffers.domainName.length + 1, ssl->heap, DYNAMIC_TYPE_DOMAIN);
|
|
|
|
if (ssl->buffers.domainName.buffer) {
|
|
unsigned char* domainName = ssl->buffers.domainName.buffer;
|
|
XMEMCPY(domainName, dn, ssl->buffers.domainName.length);
|
|
domainName[ssl->buffers.domainName.length] = '\0';
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
else {
|
|
ssl->error = MEMORY_ERROR;
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
}
|
|
|
|
|
|
/* turn on wolfSSL zlib compression
|
|
returns WOLFSSL_SUCCESS for success, else error (not built in)
|
|
*/
|
|
int wolfSSL_set_compression(WOLFSSL* ssl)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_set_compression");
|
|
(void)ssl;
|
|
#ifdef HAVE_LIBZ
|
|
ssl->options.usingCompression = 1;
|
|
return WOLFSSL_SUCCESS;
|
|
#else
|
|
return NOT_COMPILED_IN;
|
|
#endif
|
|
}
|
|
|
|
|
|
#ifndef USE_WINDOWS_API
|
|
#ifndef NO_WRITEV
|
|
|
|
/* simulate writev semantics, doesn't actually do block at a time though
|
|
because of SSL_write behavior and because front adds may be small */
|
|
int wolfSSL_writev(WOLFSSL* ssl, const struct iovec* iov, int iovcnt)
|
|
{
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
byte staticBuffer[1]; /* force heap usage */
|
|
#else
|
|
byte staticBuffer[FILE_BUFFER_SIZE];
|
|
#endif
|
|
byte* myBuffer = staticBuffer;
|
|
int dynamic = 0;
|
|
int sending = 0;
|
|
int idx = 0;
|
|
int i;
|
|
int ret;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_writev");
|
|
|
|
for (i = 0; i < iovcnt; i++)
|
|
sending += (int)iov[i].iov_len;
|
|
|
|
if (sending > (int)sizeof(staticBuffer)) {
|
|
myBuffer = (byte*)XMALLOC(sending, ssl->heap,
|
|
DYNAMIC_TYPE_WRITEV);
|
|
if (!myBuffer)
|
|
return MEMORY_ERROR;
|
|
|
|
dynamic = 1;
|
|
}
|
|
|
|
for (i = 0; i < iovcnt; i++) {
|
|
XMEMCPY(&myBuffer[idx], iov[i].iov_base, iov[i].iov_len);
|
|
idx += (int)iov[i].iov_len;
|
|
}
|
|
|
|
/* myBuffer may not be initialized fully, but the span up to the
|
|
* sending length will be.
|
|
*/
|
|
PRAGMA_GCC_DIAG_PUSH
|
|
PRAGMA_GCC("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
|
|
ret = wolfSSL_write(ssl, myBuffer, sending);
|
|
PRAGMA_GCC_DIAG_POP
|
|
|
|
if (dynamic)
|
|
XFREE(myBuffer, ssl->heap, DYNAMIC_TYPE_WRITEV);
|
|
|
|
return ret;
|
|
}
|
|
#endif
|
|
#endif
|
|
|
|
|
|
#ifdef WOLFSSL_CALLBACKS
|
|
|
|
typedef struct itimerval Itimerval;
|
|
|
|
/* don't keep calling simple functions while setting up timer and signals
|
|
if no inlining these are the next best */
|
|
|
|
#define AddTimes(a, b, c) \
|
|
do { \
|
|
(c).tv_sec = (a).tv_sec + (b).tv_sec; \
|
|
(c).tv_usec = (a).tv_usec + (b).tv_usec;\
|
|
if ((c).tv_usec >= 1000000) { \
|
|
(c).tv_sec++; \
|
|
(c).tv_usec -= 1000000; \
|
|
} \
|
|
} while (0)
|
|
|
|
|
|
#define SubtractTimes(a, b, c) \
|
|
do { \
|
|
(c).tv_sec = (a).tv_sec - (b).tv_sec; \
|
|
(c).tv_usec = (a).tv_usec - (b).tv_usec;\
|
|
if ((c).tv_usec < 0) { \
|
|
(c).tv_sec--; \
|
|
(c).tv_usec += 1000000; \
|
|
} \
|
|
} while (0)
|
|
|
|
#define CmpTimes(a, b, cmp) \
|
|
(((a).tv_sec == (b).tv_sec) ? \
|
|
((a).tv_usec cmp (b).tv_usec) : \
|
|
((a).tv_sec cmp (b).tv_sec)) \
|
|
|
|
|
|
/* do nothing handler */
|
|
static void myHandler(int signo)
|
|
{
|
|
(void)signo;
|
|
return;
|
|
}
|
|
|
|
|
|
static int wolfSSL_ex_wrapper(WOLFSSL* ssl, HandShakeCallBack hsCb,
|
|
TimeoutCallBack toCb, WOLFSSL_TIMEVAL timeout)
|
|
{
|
|
int ret = WOLFSSL_FATAL_ERROR;
|
|
int oldTimerOn = 0; /* was timer already on */
|
|
WOLFSSL_TIMEVAL startTime;
|
|
WOLFSSL_TIMEVAL endTime;
|
|
WOLFSSL_TIMEVAL totalTime;
|
|
Itimerval myTimeout;
|
|
Itimerval oldTimeout; /* if old timer adjust from total time to reset */
|
|
struct sigaction act, oact;
|
|
|
|
#define ERR_OUT(x) { ssl->hsInfoOn = 0; ssl->toInfoOn = 0; return x; }
|
|
|
|
if (hsCb) {
|
|
ssl->hsInfoOn = 1;
|
|
InitHandShakeInfo(&ssl->handShakeInfo, ssl);
|
|
}
|
|
if (toCb) {
|
|
ssl->toInfoOn = 1;
|
|
InitTimeoutInfo(&ssl->timeoutInfo);
|
|
|
|
if (gettimeofday(&startTime, 0) < 0)
|
|
ERR_OUT(GETTIME_ERROR);
|
|
|
|
/* use setitimer to simulate getitimer, init 0 myTimeout */
|
|
myTimeout.it_interval.tv_sec = 0;
|
|
myTimeout.it_interval.tv_usec = 0;
|
|
myTimeout.it_value.tv_sec = 0;
|
|
myTimeout.it_value.tv_usec = 0;
|
|
if (setitimer(ITIMER_REAL, &myTimeout, &oldTimeout) < 0)
|
|
ERR_OUT(SETITIMER_ERROR);
|
|
|
|
if (oldTimeout.it_value.tv_sec || oldTimeout.it_value.tv_usec) {
|
|
oldTimerOn = 1;
|
|
|
|
/* is old timer going to expire before ours */
|
|
if (CmpTimes(oldTimeout.it_value, timeout, <)) {
|
|
timeout.tv_sec = oldTimeout.it_value.tv_sec;
|
|
timeout.tv_usec = oldTimeout.it_value.tv_usec;
|
|
}
|
|
}
|
|
myTimeout.it_value.tv_sec = timeout.tv_sec;
|
|
myTimeout.it_value.tv_usec = timeout.tv_usec;
|
|
|
|
/* set up signal handler, don't restart socket send/recv */
|
|
act.sa_handler = myHandler;
|
|
sigemptyset(&act.sa_mask);
|
|
act.sa_flags = 0;
|
|
#ifdef SA_INTERRUPT
|
|
act.sa_flags |= SA_INTERRUPT;
|
|
#endif
|
|
if (sigaction(SIGALRM, &act, &oact) < 0)
|
|
ERR_OUT(SIGACT_ERROR);
|
|
|
|
if (setitimer(ITIMER_REAL, &myTimeout, 0) < 0)
|
|
ERR_OUT(SETITIMER_ERROR);
|
|
}
|
|
|
|
/* do main work */
|
|
#ifndef NO_WOLFSSL_CLIENT
|
|
if (ssl->options.side == WOLFSSL_CLIENT_END)
|
|
ret = wolfSSL_connect(ssl);
|
|
#endif
|
|
#ifndef NO_WOLFSSL_SERVER
|
|
if (ssl->options.side == WOLFSSL_SERVER_END)
|
|
ret = wolfSSL_accept(ssl);
|
|
#endif
|
|
|
|
/* do callbacks */
|
|
if (toCb) {
|
|
if (oldTimerOn) {
|
|
if (gettimeofday(&endTime, 0) < 0)
|
|
ERR_OUT(SYSLIB_FAILED_E);
|
|
SubtractTimes(endTime, startTime, totalTime);
|
|
/* adjust old timer for elapsed time */
|
|
if (CmpTimes(totalTime, oldTimeout.it_value, <))
|
|
SubtractTimes(oldTimeout.it_value, totalTime,
|
|
oldTimeout.it_value);
|
|
else {
|
|
/* reset value to interval, may be off */
|
|
oldTimeout.it_value.tv_sec = oldTimeout.it_interval.tv_sec;
|
|
oldTimeout.it_value.tv_usec =oldTimeout.it_interval.tv_usec;
|
|
}
|
|
/* keep iter the same whether there or not */
|
|
}
|
|
/* restore old handler */
|
|
if (sigaction(SIGALRM, &oact, 0) < 0)
|
|
ret = SIGACT_ERROR; /* more pressing error, stomp */
|
|
else
|
|
/* use old settings which may turn off (expired or not there) */
|
|
if (setitimer(ITIMER_REAL, &oldTimeout, 0) < 0)
|
|
ret = SETITIMER_ERROR;
|
|
|
|
/* if we had a timeout call callback */
|
|
if (ssl->timeoutInfo.timeoutName[0]) {
|
|
ssl->timeoutInfo.timeoutValue.tv_sec = timeout.tv_sec;
|
|
ssl->timeoutInfo.timeoutValue.tv_usec = timeout.tv_usec;
|
|
(toCb)(&ssl->timeoutInfo);
|
|
}
|
|
ssl->toInfoOn = 0;
|
|
}
|
|
|
|
/* clean up buffers allocated by AddPacketInfo */
|
|
FreeTimeoutInfo(&ssl->timeoutInfo, ssl->heap);
|
|
|
|
if (hsCb) {
|
|
FinishHandShakeInfo(&ssl->handShakeInfo);
|
|
(hsCb)(&ssl->handShakeInfo);
|
|
ssl->hsInfoOn = 0;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
|
|
#ifndef NO_WOLFSSL_CLIENT
|
|
|
|
int wolfSSL_connect_ex(WOLFSSL* ssl, HandShakeCallBack hsCb,
|
|
TimeoutCallBack toCb, WOLFSSL_TIMEVAL timeout)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_connect_ex");
|
|
return wolfSSL_ex_wrapper(ssl, hsCb, toCb, timeout);
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
#ifndef NO_WOLFSSL_SERVER
|
|
|
|
int wolfSSL_accept_ex(WOLFSSL* ssl, HandShakeCallBack hsCb,
|
|
TimeoutCallBack toCb, WOLFSSL_TIMEVAL timeout)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_accept_ex");
|
|
return wolfSSL_ex_wrapper(ssl, hsCb, toCb, timeout);
|
|
}
|
|
|
|
#endif
|
|
|
|
#endif /* WOLFSSL_CALLBACKS */
|
|
|
|
|
|
#ifndef NO_PSK
|
|
|
|
void wolfSSL_CTX_set_psk_client_callback(WOLFSSL_CTX* ctx,
|
|
wc_psk_client_callback cb)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_set_psk_client_callback");
|
|
|
|
if (ctx == NULL)
|
|
return;
|
|
|
|
ctx->havePSK = 1;
|
|
ctx->client_psk_cb = cb;
|
|
}
|
|
|
|
void wolfSSL_set_psk_client_callback(WOLFSSL* ssl,wc_psk_client_callback cb)
|
|
{
|
|
byte haveRSA = 1;
|
|
int keySz = 0;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_set_psk_client_callback");
|
|
|
|
if (ssl == NULL)
|
|
return;
|
|
|
|
ssl->options.havePSK = 1;
|
|
ssl->options.client_psk_cb = cb;
|
|
|
|
#ifdef NO_RSA
|
|
haveRSA = 0;
|
|
#endif
|
|
#ifndef NO_CERTS
|
|
keySz = ssl->buffers.keySz;
|
|
#endif
|
|
if (AllocateSuites(ssl) != 0)
|
|
return;
|
|
InitSuites(ssl->suites, ssl->version, keySz, haveRSA, TRUE,
|
|
ssl->options.haveDH, ssl->options.haveECDSAsig,
|
|
ssl->options.haveECC, TRUE, ssl->options.haveStaticECC,
|
|
ssl->options.haveFalconSig, ssl->options.haveDilithiumSig,
|
|
ssl->options.haveAnon, TRUE, ssl->options.side);
|
|
}
|
|
#ifdef OPENSSL_EXTRA
|
|
/**
|
|
* set call back function for psk session use
|
|
* @param ssl a pointer to WOLFSSL structure
|
|
* @param cb a function pointer to wc_psk_use_session_cb
|
|
* @return none
|
|
*/
|
|
void wolfSSL_set_psk_use_session_callback(WOLFSSL* ssl,
|
|
wc_psk_use_session_cb_func cb)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_set_psk_use_session_callback");
|
|
|
|
if (ssl != NULL) {
|
|
ssl->options.havePSK = 1;
|
|
ssl->options.session_psk_cb = cb;
|
|
}
|
|
|
|
WOLFSSL_LEAVE("wolfSSL_set_psk_use_session_callback", WOLFSSL_SUCCESS);
|
|
}
|
|
#endif
|
|
|
|
void wolfSSL_CTX_set_psk_server_callback(WOLFSSL_CTX* ctx,
|
|
wc_psk_server_callback cb)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_set_psk_server_callback");
|
|
if (ctx == NULL)
|
|
return;
|
|
ctx->havePSK = 1;
|
|
ctx->server_psk_cb = cb;
|
|
}
|
|
|
|
void wolfSSL_set_psk_server_callback(WOLFSSL* ssl,wc_psk_server_callback cb)
|
|
{
|
|
byte haveRSA = 1;
|
|
int keySz = 0;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_set_psk_server_callback");
|
|
if (ssl == NULL)
|
|
return;
|
|
|
|
ssl->options.havePSK = 1;
|
|
ssl->options.server_psk_cb = cb;
|
|
|
|
#ifdef NO_RSA
|
|
haveRSA = 0;
|
|
#endif
|
|
#ifndef NO_CERTS
|
|
keySz = ssl->buffers.keySz;
|
|
#endif
|
|
if (AllocateSuites(ssl) != 0)
|
|
return;
|
|
InitSuites(ssl->suites, ssl->version, keySz, haveRSA, TRUE,
|
|
ssl->options.haveDH, ssl->options.haveECDSAsig,
|
|
ssl->options.haveECC, TRUE, ssl->options.haveStaticECC,
|
|
ssl->options.haveFalconSig, ssl->options.haveDilithiumSig,
|
|
ssl->options.haveAnon, TRUE, ssl->options.side);
|
|
}
|
|
|
|
const char* wolfSSL_get_psk_identity_hint(const WOLFSSL* ssl)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_get_psk_identity_hint");
|
|
|
|
if (ssl == NULL || ssl->arrays == NULL)
|
|
return NULL;
|
|
|
|
return ssl->arrays->server_hint;
|
|
}
|
|
|
|
|
|
const char* wolfSSL_get_psk_identity(const WOLFSSL* ssl)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_get_psk_identity");
|
|
|
|
if (ssl == NULL || ssl->arrays == NULL)
|
|
return NULL;
|
|
|
|
return ssl->arrays->client_identity;
|
|
}
|
|
|
|
int wolfSSL_CTX_use_psk_identity_hint(WOLFSSL_CTX* ctx, const char* hint)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_use_psk_identity_hint");
|
|
if (hint == 0)
|
|
ctx->server_hint[0] = '\0';
|
|
else {
|
|
/* Qt does not call CTX_set_*_psk_callbacks where havePSK is set */
|
|
#ifdef WOLFSSL_QT
|
|
ctx->havePSK=1;
|
|
#endif
|
|
XSTRNCPY(ctx->server_hint, hint, MAX_PSK_ID_LEN);
|
|
ctx->server_hint[MAX_PSK_ID_LEN] = '\0'; /* null term */
|
|
}
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
int wolfSSL_use_psk_identity_hint(WOLFSSL* ssl, const char* hint)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_use_psk_identity_hint");
|
|
|
|
if (ssl == NULL || ssl->arrays == NULL)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
if (hint == 0)
|
|
ssl->arrays->server_hint[0] = 0;
|
|
else {
|
|
XSTRNCPY(ssl->arrays->server_hint, hint,
|
|
sizeof(ssl->arrays->server_hint)-1);
|
|
ssl->arrays->server_hint[sizeof(ssl->arrays->server_hint)-1] = '\0';
|
|
}
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
void* wolfSSL_get_psk_callback_ctx(WOLFSSL* ssl)
|
|
{
|
|
return ssl ? ssl->options.psk_ctx : NULL;
|
|
}
|
|
void* wolfSSL_CTX_get_psk_callback_ctx(WOLFSSL_CTX* ctx)
|
|
{
|
|
return ctx ? ctx->psk_ctx : NULL;
|
|
}
|
|
int wolfSSL_set_psk_callback_ctx(WOLFSSL* ssl, void* psk_ctx)
|
|
{
|
|
if (ssl == NULL)
|
|
return WOLFSSL_FAILURE;
|
|
ssl->options.psk_ctx = psk_ctx;
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
int wolfSSL_CTX_set_psk_callback_ctx(WOLFSSL_CTX* ctx, void* psk_ctx)
|
|
{
|
|
if (ctx == NULL)
|
|
return WOLFSSL_FAILURE;
|
|
ctx->psk_ctx = psk_ctx;
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
#endif /* NO_PSK */
|
|
|
|
|
|
#ifdef HAVE_ANON
|
|
|
|
int wolfSSL_CTX_allow_anon_cipher(WOLFSSL_CTX* ctx)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_allow_anon_cipher");
|
|
|
|
if (ctx == NULL)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
ctx->haveAnon = 1;
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
#endif /* HAVE_ANON */
|
|
|
|
|
|
#ifndef NO_CERTS
|
|
/* used to be defined on NO_FILESYSTEM only, but are generally useful */
|
|
|
|
int wolfSSL_CTX_load_verify_buffer_ex(WOLFSSL_CTX* ctx,
|
|
const unsigned char* in,
|
|
long sz, int format, int userChain,
|
|
word32 flags)
|
|
{
|
|
int verify;
|
|
int ret = WOLFSSL_FAILURE;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_CTX_load_verify_buffer_ex");
|
|
|
|
verify = GET_VERIFY_SETTING_CTX(ctx);
|
|
if (flags & WOLFSSL_LOAD_FLAG_DATE_ERR_OKAY)
|
|
verify = VERIFY_SKIP_DATE;
|
|
|
|
if (format == WOLFSSL_FILETYPE_PEM)
|
|
ret = ProcessChainBuffer(ctx, in, sz, format, CA_TYPE, NULL,
|
|
verify);
|
|
else
|
|
ret = ProcessBuffer(ctx, in, sz, format, CA_TYPE, NULL, NULL,
|
|
userChain, verify);
|
|
#if defined(WOLFSSL_TRUST_PEER_CERT) && defined(OPENSSL_COMPATIBLE_DEFAULTS)
|
|
if (ret == WOLFSSL_SUCCESS)
|
|
ret = wolfSSL_CTX_trust_peer_buffer(ctx, in, sz, format);
|
|
#endif
|
|
|
|
WOLFSSL_LEAVE("wolfSSL_CTX_load_verify_buffer_ex", ret);
|
|
return ret;
|
|
}
|
|
|
|
/* wolfSSL extension allows DER files to be loaded from buffers as well */
|
|
int wolfSSL_CTX_load_verify_buffer(WOLFSSL_CTX* ctx,
|
|
const unsigned char* in,
|
|
long sz, int format)
|
|
{
|
|
return wolfSSL_CTX_load_verify_buffer_ex(ctx, in, sz, format, 0,
|
|
WOLFSSL_LOAD_VERIFY_DEFAULT_FLAGS);
|
|
}
|
|
|
|
int wolfSSL_CTX_load_verify_chain_buffer_format(WOLFSSL_CTX* ctx,
|
|
const unsigned char* in,
|
|
long sz, int format)
|
|
{
|
|
return wolfSSL_CTX_load_verify_buffer_ex(ctx, in, sz, format, 1,
|
|
WOLFSSL_LOAD_VERIFY_DEFAULT_FLAGS);
|
|
}
|
|
|
|
|
|
#ifdef WOLFSSL_TRUST_PEER_CERT
|
|
int wolfSSL_CTX_trust_peer_buffer(WOLFSSL_CTX* ctx,
|
|
const unsigned char* in,
|
|
long sz, int format)
|
|
{
|
|
int verify;
|
|
WOLFSSL_ENTER("wolfSSL_CTX_trust_peer_buffer");
|
|
|
|
/* sanity check on arguments */
|
|
if (sz < 0 || in == NULL || ctx == NULL) {
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
verify = GET_VERIFY_SETTING_CTX(ctx);
|
|
if (WOLFSSL_LOAD_VERIFY_DEFAULT_FLAGS &
|
|
WOLFSSL_LOAD_FLAG_DATE_ERR_OKAY)
|
|
verify = VERIFY_SKIP_DATE;
|
|
|
|
if (format == WOLFSSL_FILETYPE_PEM)
|
|
return ProcessChainBuffer(ctx, in, sz, format, TRUSTED_PEER_TYPE,
|
|
NULL, verify);
|
|
else
|
|
return ProcessBuffer(ctx, in, sz, format, TRUSTED_PEER_TYPE, NULL,
|
|
NULL, 0, verify);
|
|
}
|
|
#endif /* WOLFSSL_TRUST_PEER_CERT */
|
|
|
|
|
|
int wolfSSL_CTX_use_certificate_buffer(WOLFSSL_CTX* ctx,
|
|
const unsigned char* in, long sz, int format)
|
|
{
|
|
int ret = WOLFSSL_FAILURE;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_CTX_use_certificate_buffer");
|
|
ret = ProcessBuffer(ctx, in, sz, format, CERT_TYPE, NULL, NULL, 0,
|
|
GET_VERIFY_SETTING_CTX(ctx));
|
|
WOLFSSL_LEAVE("wolfSSL_CTX_use_certificate_buffer", ret);
|
|
return ret;
|
|
}
|
|
|
|
|
|
int wolfSSL_CTX_use_PrivateKey_buffer(WOLFSSL_CTX* ctx,
|
|
const unsigned char* in, long sz, int format)
|
|
{
|
|
int ret = WOLFSSL_FAILURE;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_CTX_use_PrivateKey_buffer");
|
|
ret = ProcessBuffer(ctx, in, sz, format, PRIVATEKEY_TYPE, NULL, NULL,
|
|
0, GET_VERIFY_SETTING_CTX(ctx));
|
|
WOLFSSL_LEAVE("wolfSSL_CTX_use_PrivateKey_buffer", ret);
|
|
return ret;
|
|
}
|
|
|
|
#ifdef WOLF_PRIVATE_KEY_ID
|
|
int wolfSSL_CTX_use_PrivateKey_id(WOLFSSL_CTX* ctx, const unsigned char* id,
|
|
long sz, int devId, long keySz)
|
|
{
|
|
int ret = wolfSSL_CTX_use_PrivateKey_Id(ctx, id, sz, devId);
|
|
|
|
if (ret == WOLFSSL_SUCCESS)
|
|
ctx->privateKeySz = (word32)keySz;
|
|
|
|
return ret;
|
|
}
|
|
|
|
int wolfSSL_CTX_use_PrivateKey_Id(WOLFSSL_CTX* ctx, const unsigned char* id,
|
|
long sz, int devId)
|
|
{
|
|
int ret = WOLFSSL_FAILURE;
|
|
|
|
FreeDer(&ctx->privateKey);
|
|
if (AllocDer(&ctx->privateKey, (word32)sz, PRIVATEKEY_TYPE,
|
|
ctx->heap) == 0) {
|
|
XMEMCPY(ctx->privateKey->buffer, id, sz);
|
|
ctx->privateKeyId = 1;
|
|
if (devId != INVALID_DEVID)
|
|
ctx->privateKeyDevId = devId;
|
|
else
|
|
ctx->privateKeyDevId = ctx->devId;
|
|
|
|
ret = WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int wolfSSL_CTX_use_PrivateKey_Label(WOLFSSL_CTX* ctx, const char* label,
|
|
int devId)
|
|
{
|
|
int ret = WOLFSSL_FAILURE;
|
|
word32 sz = (word32)XSTRLEN(label) + 1;
|
|
|
|
FreeDer(&ctx->privateKey);
|
|
if (AllocDer(&ctx->privateKey, (word32)sz, PRIVATEKEY_TYPE,
|
|
ctx->heap) == 0) {
|
|
XMEMCPY(ctx->privateKey->buffer, label, sz);
|
|
ctx->privateKeyLabel = 1;
|
|
if (devId != INVALID_DEVID)
|
|
ctx->privateKeyDevId = devId;
|
|
else
|
|
ctx->privateKeyDevId = ctx->devId;
|
|
|
|
ret = WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
#endif /* WOLF_PRIVATE_KEY_ID */
|
|
|
|
int wolfSSL_CTX_use_certificate_chain_buffer_format(WOLFSSL_CTX* ctx,
|
|
const unsigned char* in, long sz, int format)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_use_certificate_chain_buffer_format");
|
|
return ProcessBuffer(ctx, in, sz, format, CERT_TYPE, NULL, NULL, 1,
|
|
GET_VERIFY_SETTING_CTX(ctx));
|
|
}
|
|
|
|
int wolfSSL_CTX_use_certificate_chain_buffer(WOLFSSL_CTX* ctx,
|
|
const unsigned char* in, long sz)
|
|
{
|
|
return wolfSSL_CTX_use_certificate_chain_buffer_format(ctx, in, sz,
|
|
WOLFSSL_FILETYPE_PEM);
|
|
}
|
|
|
|
|
|
#ifndef NO_DH
|
|
|
|
/* server wrapper for ctx or ssl Diffie-Hellman parameters */
|
|
static int wolfSSL_SetTmpDH_buffer_wrapper(WOLFSSL_CTX* ctx, WOLFSSL* ssl,
|
|
const unsigned char* buf,
|
|
long sz, int format)
|
|
{
|
|
DerBuffer* der = NULL;
|
|
int ret = 0;
|
|
word32 pSz = MAX_DH_SIZE;
|
|
word32 gSz = MAX_DH_SIZE;
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
byte* p = NULL;
|
|
byte* g = NULL;
|
|
#else
|
|
byte p[MAX_DH_SIZE];
|
|
byte g[MAX_DH_SIZE];
|
|
#endif
|
|
|
|
if (ctx == NULL || buf == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
ret = AllocDer(&der, 0, DH_PARAM_TYPE, ctx->heap);
|
|
if (ret != 0) {
|
|
return ret;
|
|
}
|
|
der->buffer = (byte*)buf;
|
|
der->length = (word32)sz;
|
|
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
p = (byte*)XMALLOC(pSz, NULL, DYNAMIC_TYPE_PUBLIC_KEY);
|
|
g = (byte*)XMALLOC(gSz, NULL, DYNAMIC_TYPE_PUBLIC_KEY);
|
|
|
|
if (p == NULL || g == NULL) {
|
|
XFREE(p, NULL, DYNAMIC_TYPE_PUBLIC_KEY);
|
|
XFREE(g, NULL, DYNAMIC_TYPE_PUBLIC_KEY);
|
|
return MEMORY_E;
|
|
}
|
|
#endif
|
|
|
|
if (format != WOLFSSL_FILETYPE_ASN1 && format != WOLFSSL_FILETYPE_PEM)
|
|
ret = WOLFSSL_BAD_FILETYPE;
|
|
else {
|
|
if (format == WOLFSSL_FILETYPE_PEM) {
|
|
#ifdef WOLFSSL_PEM_TO_DER
|
|
FreeDer(&der);
|
|
ret = PemToDer(buf, sz, DH_PARAM_TYPE, &der, ctx->heap,
|
|
NULL, NULL);
|
|
if (ret < 0) {
|
|
/* Also try X9.42 format */
|
|
ret = PemToDer(buf, sz, X942_PARAM_TYPE, &der, ctx->heap,
|
|
NULL, NULL);
|
|
}
|
|
#ifdef WOLFSSL_WPAS
|
|
#ifndef NO_DSA
|
|
if (ret < 0) {
|
|
ret = PemToDer(buf, sz, DSA_PARAM_TYPE, &der, ctx->heap,
|
|
NULL, NULL);
|
|
}
|
|
#endif
|
|
#endif /* WOLFSSL_WPAS */
|
|
#else
|
|
ret = NOT_COMPILED_IN;
|
|
#endif /* WOLFSSL_PEM_TO_DER */
|
|
}
|
|
|
|
if (ret == 0) {
|
|
if (wc_DhParamsLoad(der->buffer, der->length, p, &pSz, g, &gSz) < 0)
|
|
ret = WOLFSSL_BAD_FILETYPE;
|
|
else if (ssl)
|
|
ret = wolfSSL_SetTmpDH(ssl, p, pSz, g, gSz);
|
|
else
|
|
ret = wolfSSL_CTX_SetTmpDH(ctx, p, pSz, g, gSz);
|
|
}
|
|
}
|
|
|
|
FreeDer(&der);
|
|
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
XFREE(p, NULL, DYNAMIC_TYPE_PUBLIC_KEY);
|
|
XFREE(g, NULL, DYNAMIC_TYPE_PUBLIC_KEY);
|
|
#endif
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
/* server Diffie-Hellman parameters, WOLFSSL_SUCCESS on ok */
|
|
int wolfSSL_SetTmpDH_buffer(WOLFSSL* ssl, const unsigned char* buf, long sz,
|
|
int format)
|
|
{
|
|
if (ssl == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
return wolfSSL_SetTmpDH_buffer_wrapper(ssl->ctx, ssl, buf, sz, format);
|
|
}
|
|
|
|
|
|
/* server ctx Diffie-Hellman parameters, WOLFSSL_SUCCESS on ok */
|
|
int wolfSSL_CTX_SetTmpDH_buffer(WOLFSSL_CTX* ctx, const unsigned char* buf,
|
|
long sz, int format)
|
|
{
|
|
return wolfSSL_SetTmpDH_buffer_wrapper(ctx, NULL, buf, sz, format);
|
|
}
|
|
|
|
#endif /* NO_DH */
|
|
|
|
|
|
int wolfSSL_use_certificate_buffer(WOLFSSL* ssl,
|
|
const unsigned char* in, long sz, int format)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_use_certificate_buffer");
|
|
if (ssl == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
return ProcessBuffer(ssl->ctx, in, sz, format, CERT_TYPE, ssl, NULL, 0,
|
|
GET_VERIFY_SETTING_SSL(ssl));
|
|
}
|
|
|
|
|
|
int wolfSSL_use_PrivateKey_buffer(WOLFSSL* ssl,
|
|
const unsigned char* in, long sz, int format)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_use_PrivateKey_buffer");
|
|
if (ssl == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
return ProcessBuffer(ssl->ctx, in, sz, format, PRIVATEKEY_TYPE,
|
|
ssl, NULL, 0, GET_VERIFY_SETTING_SSL(ssl));
|
|
}
|
|
|
|
#ifdef WOLF_PRIVATE_KEY_ID
|
|
int wolfSSL_use_PrivateKey_id(WOLFSSL* ssl, const unsigned char* id,
|
|
long sz, int devId, long keySz)
|
|
{
|
|
int ret = wolfSSL_use_PrivateKey_Id(ssl, id, sz, devId);
|
|
|
|
if (ret == WOLFSSL_SUCCESS)
|
|
ssl->buffers.keySz = (word32)keySz;
|
|
|
|
return ret;
|
|
}
|
|
|
|
int wolfSSL_use_PrivateKey_Id(WOLFSSL* ssl, const unsigned char* id,
|
|
long sz, int devId)
|
|
{
|
|
int ret = WOLFSSL_FAILURE;
|
|
|
|
if (ssl->buffers.weOwnKey)
|
|
FreeDer(&ssl->buffers.key);
|
|
if (AllocDer(&ssl->buffers.key, (word32)sz, PRIVATEKEY_TYPE,
|
|
ssl->heap) == 0) {
|
|
XMEMCPY(ssl->buffers.key->buffer, id, sz);
|
|
ssl->buffers.weOwnKey = 1;
|
|
ssl->buffers.keyId = 1;
|
|
if (devId != INVALID_DEVID)
|
|
ssl->buffers.keyDevId = devId;
|
|
else
|
|
ssl->buffers.keyDevId = ssl->devId;
|
|
|
|
ret = WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int wolfSSL_use_PrivateKey_Label(WOLFSSL* ssl, const char* label, int devId)
|
|
{
|
|
int ret = WOLFSSL_FAILURE;
|
|
word32 sz = (word32)XSTRLEN(label) + 1;
|
|
|
|
if (ssl->buffers.weOwnKey)
|
|
FreeDer(&ssl->buffers.key);
|
|
if (AllocDer(&ssl->buffers.key, (word32)sz, PRIVATEKEY_TYPE,
|
|
ssl->heap) == 0) {
|
|
XMEMCPY(ssl->buffers.key->buffer, label, sz);
|
|
ssl->buffers.weOwnKey = 1;
|
|
ssl->buffers.keyLabel = 1;
|
|
if (devId != INVALID_DEVID)
|
|
ssl->buffers.keyDevId = devId;
|
|
else
|
|
ssl->buffers.keyDevId = ssl->devId;
|
|
|
|
ret = WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
#endif /* WOLF_PRIVATE_KEY_ID */
|
|
|
|
int wolfSSL_use_certificate_chain_buffer_format(WOLFSSL* ssl,
|
|
const unsigned char* in, long sz, int format)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_use_certificate_chain_buffer_format");
|
|
if (ssl == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
return ProcessBuffer(ssl->ctx, in, sz, format, CERT_TYPE,
|
|
ssl, NULL, 1, GET_VERIFY_SETTING_SSL(ssl));
|
|
}
|
|
|
|
int wolfSSL_use_certificate_chain_buffer(WOLFSSL* ssl,
|
|
const unsigned char* in, long sz)
|
|
{
|
|
return wolfSSL_use_certificate_chain_buffer_format(ssl, in, sz,
|
|
WOLFSSL_FILETYPE_PEM);
|
|
}
|
|
|
|
|
|
/* unload any certs or keys that SSL owns, leave CTX as is
|
|
WOLFSSL_SUCCESS on ok */
|
|
int wolfSSL_UnloadCertsKeys(WOLFSSL* ssl)
|
|
{
|
|
if (ssl == NULL) {
|
|
WOLFSSL_MSG("Null function arg");
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
if (ssl->buffers.weOwnCert && !ssl->keepCert) {
|
|
WOLFSSL_MSG("Unloading cert");
|
|
FreeDer(&ssl->buffers.certificate);
|
|
#ifdef KEEP_OUR_CERT
|
|
wolfSSL_X509_free(ssl->ourCert);
|
|
ssl->ourCert = NULL;
|
|
#endif
|
|
ssl->buffers.weOwnCert = 0;
|
|
}
|
|
|
|
if (ssl->buffers.weOwnCertChain) {
|
|
WOLFSSL_MSG("Unloading cert chain");
|
|
FreeDer(&ssl->buffers.certChain);
|
|
ssl->buffers.weOwnCertChain = 0;
|
|
}
|
|
|
|
if (ssl->buffers.weOwnKey) {
|
|
WOLFSSL_MSG("Unloading key");
|
|
ForceZero(ssl->buffers.key->buffer, ssl->buffers.key->length);
|
|
FreeDer(&ssl->buffers.key);
|
|
ssl->buffers.weOwnKey = 0;
|
|
}
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
|
|
int wolfSSL_CTX_UnloadCAs(WOLFSSL_CTX* ctx)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_UnloadCAs");
|
|
|
|
if (ctx == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
return wolfSSL_CertManagerUnloadCAs(ctx->cm);
|
|
}
|
|
|
|
|
|
#ifdef WOLFSSL_TRUST_PEER_CERT
|
|
int wolfSSL_CTX_Unload_trust_peers(WOLFSSL_CTX* ctx)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_Unload_trust_peers");
|
|
|
|
if (ctx == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
return wolfSSL_CertManagerUnload_trust_peers(ctx->cm);
|
|
}
|
|
|
|
#ifdef WOLFSSL_LOCAL_X509_STORE
|
|
int wolfSSL_Unload_trust_peers(WOLFSSL* ssl)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_Unload_trust_peers");
|
|
|
|
if (ssl == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
SSL_CM_WARNING(ssl);
|
|
return wolfSSL_CertManagerUnload_trust_peers(SSL_CM(ssl));
|
|
}
|
|
#endif /* WOLFSSL_LOCAL_X509_STORE */
|
|
#endif /* WOLFSSL_TRUST_PEER_CERT */
|
|
/* old NO_FILESYSTEM end */
|
|
#endif /* !NO_CERTS */
|
|
|
|
|
|
#ifdef OPENSSL_EXTRA
|
|
|
|
int wolfSSL_add_all_algorithms(void)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_add_all_algorithms");
|
|
if (initRefCount != 0 || wolfSSL_Init() == WOLFSSL_SUCCESS)
|
|
return WOLFSSL_SUCCESS;
|
|
else
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
|
|
int wolfSSL_OpenSSL_add_all_algorithms_noconf(void)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_OpenSSL_add_all_algorithms_noconf");
|
|
|
|
if (wolfSSL_add_all_algorithms() == WOLFSSL_FATAL_ERROR)
|
|
return WOLFSSL_FATAL_ERROR;
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
int wolfSSL_OpenSSL_add_all_algorithms_conf(void)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_OpenSSL_add_all_algorithms_conf");
|
|
/* This function is currently the same as
|
|
wolfSSL_OpenSSL_add_all_algorithms_noconf since we do not employ
|
|
the use of a wolfssl.cnf type configuration file and is only used for
|
|
OpenSSL compatibility. */
|
|
|
|
if (wolfSSL_add_all_algorithms() == WOLFSSL_FATAL_ERROR) {
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
/* returns previous set cache size which stays constant */
|
|
long wolfSSL_CTX_sess_set_cache_size(WOLFSSL_CTX* ctx, long sz)
|
|
{
|
|
/* cache size fixed at compile time in wolfSSL */
|
|
(void)ctx;
|
|
(void)sz;
|
|
WOLFSSL_MSG("session cache is set at compile time");
|
|
#ifndef NO_SESSION_CACHE
|
|
return (long)(SESSIONS_PER_ROW * SESSION_ROWS);
|
|
#else
|
|
return 0;
|
|
#endif
|
|
}
|
|
|
|
#endif
|
|
|
|
#if defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL) || \
|
|
defined(WOLFSSL_EXTRA) || defined(WOLFSSL_WPAS_SMALL)
|
|
void wolfSSL_CTX_set_quiet_shutdown(WOLFSSL_CTX* ctx, int mode)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_set_quiet_shutdown");
|
|
if (mode)
|
|
ctx->quietShutdown = 1;
|
|
}
|
|
|
|
|
|
void wolfSSL_set_quiet_shutdown(WOLFSSL* ssl, int mode)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_set_quiet_shutdown");
|
|
if (mode)
|
|
ssl->options.quietShutdown = 1;
|
|
}
|
|
#endif /* OPENSSL_EXTRA || OPENSSL_EXTRA_X509_SMALL ||
|
|
WOLFSSL_EXTRA || WOLFSSL_WPAS_SMALL */
|
|
|
|
#ifdef OPENSSL_EXTRA
|
|
#ifndef NO_BIO
|
|
void wolfSSL_set_bio(WOLFSSL* ssl, WOLFSSL_BIO* rd, WOLFSSL_BIO* wr)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_set_bio");
|
|
|
|
if (ssl == NULL) {
|
|
WOLFSSL_MSG("Bad argument, ssl was NULL");
|
|
return;
|
|
}
|
|
|
|
/* free any existing WOLFSSL_BIOs in use but don't free those in
|
|
* a chain */
|
|
if (ssl->biord != NULL) {
|
|
if (ssl->biord != ssl->biowr) {
|
|
if (ssl->biowr != NULL && ssl->biowr->prev != NULL)
|
|
wolfSSL_BIO_free(ssl->biowr);
|
|
ssl->biowr = NULL;
|
|
}
|
|
if (ssl->biord->prev != NULL)
|
|
wolfSSL_BIO_free(ssl->biord);
|
|
ssl->biord = NULL;
|
|
}
|
|
/* set flag obviously */
|
|
if (rd && !(rd->flags & WOLFSSL_BIO_FLAG_READ))
|
|
rd->flags |= WOLFSSL_BIO_FLAG_READ;
|
|
if (wr && !(wr->flags & WOLFSSL_BIO_FLAG_WRITE))
|
|
wr->flags |= WOLFSSL_BIO_FLAG_WRITE;
|
|
|
|
ssl->biord = rd;
|
|
ssl->biowr = wr;
|
|
|
|
/* set SSL to use BIO callbacks instead */
|
|
if (((ssl->cbioFlag & WOLFSSL_CBIO_RECV) == 0)) {
|
|
ssl->CBIORecv = BioReceive;
|
|
}
|
|
if (((ssl->cbioFlag & WOLFSSL_CBIO_SEND) == 0)) {
|
|
ssl->CBIOSend = BioSend;
|
|
}
|
|
|
|
/* User programs should always retry reading from these BIOs */
|
|
if (rd) {
|
|
/* User writes to rd */
|
|
BIO_set_retry_write(rd);
|
|
}
|
|
if (wr) {
|
|
/* User reads from wr */
|
|
BIO_set_retry_read(wr);
|
|
}
|
|
}
|
|
#endif /* !NO_BIO */
|
|
#endif /* OPENSSL_EXTRA */
|
|
|
|
#if defined(OPENSSL_EXTRA) || defined(WOLFSSL_EXTRA)
|
|
void wolfSSL_CTX_set_client_CA_list(WOLFSSL_CTX* ctx,
|
|
WOLF_STACK_OF(WOLFSSL_X509_NAME)* names)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_set_client_CA_list");
|
|
if (ctx != NULL) {
|
|
wolfSSL_sk_X509_NAME_pop_free(ctx->client_ca_names, NULL);
|
|
ctx->client_ca_names = names;
|
|
}
|
|
}
|
|
|
|
void wolfSSL_set_client_CA_list(WOLFSSL* ssl,
|
|
WOLF_STACK_OF(WOLFSSL_X509_NAME)* names)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_set_client_CA_list");
|
|
if (ssl != NULL) {
|
|
if (ssl->client_ca_names != ssl->ctx->client_ca_names)
|
|
wolfSSL_sk_X509_NAME_pop_free(ssl->client_ca_names, NULL);
|
|
ssl->client_ca_names = names;
|
|
}
|
|
}
|
|
|
|
#ifdef OPENSSL_EXTRA
|
|
/* registers client cert callback, called during handshake if server
|
|
requests client auth but user has not loaded client cert/key */
|
|
void wolfSSL_CTX_set_client_cert_cb(WOLFSSL_CTX *ctx, client_cert_cb cb)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_set_client_cert_cb");
|
|
|
|
if (ctx != NULL) {
|
|
ctx->CBClientCert = cb;
|
|
}
|
|
}
|
|
|
|
void wolfSSL_CTX_set_cert_cb(WOLFSSL_CTX* ctx,
|
|
CertSetupCallback cb, void *arg)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_set_cert_cb");
|
|
if (ctx == NULL)
|
|
return;
|
|
|
|
ctx->certSetupCb = cb;
|
|
ctx->certSetupCbArg = arg;
|
|
}
|
|
|
|
int wolfSSL_get_client_suites_sigalgs(const WOLFSSL* ssl,
|
|
const byte** suites, word16* suiteSz,
|
|
const byte** hashSigAlgo, word16* hashSigAlgoSz)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_get_client_suites_sigalgs");
|
|
|
|
if (suites != NULL)
|
|
*suites = NULL;
|
|
if (suiteSz != NULL)
|
|
*suiteSz = 0;
|
|
if (hashSigAlgo != NULL)
|
|
*hashSigAlgo = NULL;
|
|
if (hashSigAlgoSz != NULL)
|
|
*hashSigAlgoSz = 0;
|
|
|
|
if (ssl != NULL && ssl->clSuites != NULL) {
|
|
if (suites != NULL && suiteSz != NULL) {
|
|
*suites = ssl->clSuites->suites;
|
|
*suiteSz = ssl->clSuites->suiteSz;
|
|
}
|
|
if (hashSigAlgo != NULL && hashSigAlgoSz != NULL) {
|
|
*hashSigAlgo = ssl->clSuites->hashSigAlgo;
|
|
*hashSigAlgoSz = ssl->clSuites->hashSigAlgoSz;
|
|
}
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
WOLFSSL_CIPHERSUITE_INFO wolfSSL_get_ciphersuite_info(byte first,
|
|
byte second)
|
|
{
|
|
WOLFSSL_CIPHERSUITE_INFO info;
|
|
info.rsaAuth = (byte)(CipherRequires(first, second, REQUIRES_RSA) ||
|
|
CipherRequires(first, second, REQUIRES_RSA_SIG));
|
|
info.eccAuth = (byte)(CipherRequires(first, second, REQUIRES_ECC) ||
|
|
/* Static ECC ciphers may require RSA for authentication */
|
|
(CipherRequires(first, second, REQUIRES_ECC_STATIC) &&
|
|
!CipherRequires(first, second, REQUIRES_RSA_SIG)));
|
|
info.eccStatic =
|
|
(byte)CipherRequires(first, second, REQUIRES_ECC_STATIC);
|
|
info.psk = (byte)CipherRequires(first, second, REQUIRES_PSK);
|
|
return info;
|
|
}
|
|
|
|
/**
|
|
* @param first First byte of the hash and signature algorithm
|
|
* @param second Second byte of the hash and signature algorithm
|
|
* @param hashAlgo The enum wc_HashType of the MAC algorithm
|
|
* @param sigAlgo The enum Key_Sum of the authentication algorithm
|
|
*/
|
|
int wolfSSL_get_sigalg_info(byte first, byte second,
|
|
int* hashAlgo, int* sigAlgo)
|
|
{
|
|
byte input[2];
|
|
byte hashType;
|
|
byte sigType;
|
|
|
|
if (hashAlgo == NULL || sigAlgo == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
input[0] = first;
|
|
input[1] = second;
|
|
DecodeSigAlg(input, &hashType, &sigType);
|
|
|
|
/* cast so that compiler reminds us of unimplemented values */
|
|
switch ((enum SignatureAlgorithm)sigType) {
|
|
case anonymous_sa_algo:
|
|
*sigAlgo = (enum Key_Sum)0;
|
|
break;
|
|
case rsa_sa_algo:
|
|
*sigAlgo = RSAk;
|
|
break;
|
|
case dsa_sa_algo:
|
|
*sigAlgo = DSAk;
|
|
break;
|
|
case ecc_dsa_sa_algo:
|
|
*sigAlgo = ECDSAk;
|
|
break;
|
|
case rsa_pss_sa_algo:
|
|
*sigAlgo = RSAPSSk;
|
|
break;
|
|
case ed25519_sa_algo:
|
|
*sigAlgo = ED25519k;
|
|
break;
|
|
case rsa_pss_pss_algo:
|
|
*sigAlgo = RSAPSSk;
|
|
break;
|
|
case ed448_sa_algo:
|
|
*sigAlgo = ED448k;
|
|
break;
|
|
case falcon_level1_sa_algo:
|
|
*sigAlgo = FALCON_LEVEL1k;
|
|
break;
|
|
case falcon_level5_sa_algo:
|
|
*sigAlgo = FALCON_LEVEL5k;
|
|
break;
|
|
case dilithium_level2_sa_algo:
|
|
*sigAlgo = DILITHIUM_LEVEL2k;
|
|
break;
|
|
case dilithium_level3_sa_algo:
|
|
*sigAlgo = DILITHIUM_LEVEL3k;
|
|
break;
|
|
case dilithium_level5_sa_algo:
|
|
*sigAlgo = DILITHIUM_LEVEL5k;
|
|
break;
|
|
case sm2_sa_algo:
|
|
*sigAlgo = SM2k;
|
|
break;
|
|
case invalid_sa_algo:
|
|
default:
|
|
*hashAlgo = WC_HASH_TYPE_NONE;
|
|
*sigAlgo = 0;
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
/* cast so that compiler reminds us of unimplemented values */
|
|
switch((enum wc_MACAlgorithm)hashType) {
|
|
case no_mac:
|
|
case rmd_mac: /* Don't have a RIPEMD type in wc_HashType */
|
|
*hashAlgo = WC_HASH_TYPE_NONE;
|
|
break;
|
|
case md5_mac:
|
|
*hashAlgo = WC_HASH_TYPE_MD5;
|
|
break;
|
|
case sha_mac:
|
|
*hashAlgo = WC_HASH_TYPE_SHA;
|
|
break;
|
|
case sha224_mac:
|
|
*hashAlgo = WC_HASH_TYPE_SHA224;
|
|
break;
|
|
case sha256_mac:
|
|
*hashAlgo = WC_HASH_TYPE_SHA256;
|
|
break;
|
|
case sha384_mac:
|
|
*hashAlgo = WC_HASH_TYPE_SHA384;
|
|
break;
|
|
case sha512_mac:
|
|
*hashAlgo = WC_HASH_TYPE_SHA512;
|
|
break;
|
|
case blake2b_mac:
|
|
*hashAlgo = WC_HASH_TYPE_BLAKE2B;
|
|
break;
|
|
case sm3_mac:
|
|
#ifdef WOLFSSL_SM3
|
|
*hashAlgo = WC_HASH_TYPE_SM3;
|
|
#else
|
|
*hashAlgo = WC_HASH_TYPE_NONE;
|
|
#endif
|
|
break;
|
|
default:
|
|
*hashAlgo = WC_HASH_TYPE_NONE;
|
|
*sigAlgo = 0;
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Internal wrapper for calling certSetupCb
|
|
* @param ssl The SSL/TLS Object
|
|
* @return 0 on success
|
|
*/
|
|
int CertSetupCbWrapper(WOLFSSL* ssl)
|
|
{
|
|
int ret = 0;
|
|
if (ssl->ctx->certSetupCb != NULL) {
|
|
WOLFSSL_MSG("Calling user cert setup callback");
|
|
ret = ssl->ctx->certSetupCb(ssl, ssl->ctx->certSetupCbArg);
|
|
if (ret == 1) {
|
|
WOLFSSL_MSG("User cert callback returned success");
|
|
ret = 0;
|
|
}
|
|
else if (ret == 0) {
|
|
SendAlert(ssl, alert_fatal, internal_error);
|
|
ret = CLIENT_CERT_CB_ERROR;
|
|
}
|
|
else if (ret < 0) {
|
|
ret = WOLFSSL_ERROR_WANT_X509_LOOKUP;
|
|
}
|
|
else {
|
|
WOLFSSL_MSG("Unexpected user callback return");
|
|
ret = CLIENT_CERT_CB_ERROR;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
#endif /* OPENSSL_EXTRA */
|
|
|
|
#endif /* OPENSSL_EXTRA || WOLFSSL_EXTRA || HAVE_WEBSERVER */
|
|
|
|
#ifndef WOLFSSL_NO_CA_NAMES
|
|
WOLF_STACK_OF(WOLFSSL_X509_NAME)* wolfSSL_CTX_get_client_CA_list(
|
|
const WOLFSSL_CTX *ctx)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_get_client_CA_list");
|
|
|
|
if (ctx == NULL) {
|
|
WOLFSSL_MSG("Bad argument passed to wolfSSL_CTX_get_client_CA_list");
|
|
return NULL;
|
|
}
|
|
|
|
return ctx->client_ca_names;
|
|
}
|
|
|
|
/* returns the CA's set on server side or the CA's sent from server when
|
|
* on client side */
|
|
WOLF_STACK_OF(WOLFSSL_X509_NAME)* wolfSSL_get_client_CA_list(
|
|
const WOLFSSL* ssl)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_get_client_CA_list");
|
|
|
|
if (ssl == NULL) {
|
|
WOLFSSL_MSG("Bad argument passed to wolfSSL_get_client_CA_list");
|
|
return NULL;
|
|
}
|
|
|
|
return SSL_CA_NAMES(ssl);
|
|
}
|
|
|
|
#if !defined(NO_CERTS)
|
|
int wolfSSL_CTX_add_client_CA(WOLFSSL_CTX* ctx, WOLFSSL_X509* x509)
|
|
{
|
|
WOLFSSL_X509_NAME *nameCopy = NULL;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_CTX_add_client_CA");
|
|
|
|
if (ctx == NULL || x509 == NULL){
|
|
WOLFSSL_MSG("Bad argument");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
if (ctx->client_ca_names == NULL) {
|
|
ctx->client_ca_names = wolfSSL_sk_X509_NAME_new(NULL);
|
|
if (ctx->client_ca_names == NULL) {
|
|
WOLFSSL_MSG("wolfSSL_sk_X509_NAME_new error");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
}
|
|
|
|
nameCopy = wolfSSL_X509_NAME_dup(wolfSSL_X509_get_subject_name(x509));
|
|
if (nameCopy == NULL) {
|
|
WOLFSSL_MSG("wolfSSL_X509_NAME_dup error");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
if (wolfSSL_sk_X509_NAME_push(ctx->client_ca_names, nameCopy) != WOLFSSL_SUCCESS) {
|
|
WOLFSSL_MSG("wolfSSL_sk_X509_NAME_push error");
|
|
wolfSSL_X509_NAME_free(nameCopy);
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
#endif
|
|
|
|
#ifndef NO_BIO
|
|
#if !defined(NO_RSA) && !defined(NO_CERTS)
|
|
WOLF_STACK_OF(WOLFSSL_X509_NAME)* wolfSSL_load_client_CA_file(const char* fname)
|
|
{
|
|
/* The webserver build is using this to load a CA into the server
|
|
* for client authentication as an option. Have this return NULL in
|
|
* that case. If OPENSSL_EXTRA is enabled, go ahead and include
|
|
* the function. */
|
|
#ifdef OPENSSL_EXTRA
|
|
WOLFSSL_STACK *list = NULL;
|
|
WOLFSSL_BIO* bio = NULL;
|
|
WOLFSSL_X509 *cert = NULL;
|
|
WOLFSSL_X509_NAME *nameCopy = NULL;
|
|
unsigned long err = WOLFSSL_FAILURE;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_load_client_CA_file");
|
|
|
|
bio = wolfSSL_BIO_new_file(fname, "rb");
|
|
if (bio == NULL) {
|
|
WOLFSSL_MSG("wolfSSL_BIO_new_file error");
|
|
goto cleanup;
|
|
}
|
|
|
|
list = wolfSSL_sk_X509_NAME_new(NULL);
|
|
if (list == NULL) {
|
|
WOLFSSL_MSG("wolfSSL_sk_X509_NAME_new error");
|
|
goto cleanup;
|
|
}
|
|
|
|
/* Read each certificate in the chain out of the file. */
|
|
while (wolfSSL_PEM_read_bio_X509(bio, &cert, NULL, NULL) != NULL) {
|
|
/* Need a persistent copy of the subject name. */
|
|
nameCopy = wolfSSL_X509_NAME_dup(
|
|
wolfSSL_X509_get_subject_name(cert));
|
|
if (nameCopy == NULL) {
|
|
WOLFSSL_MSG("wolfSSL_X509_NAME_dup error");
|
|
goto cleanup;
|
|
}
|
|
/*
|
|
* Original cert will be freed so make sure not to try to access
|
|
* it in the future.
|
|
*/
|
|
nameCopy->x509 = NULL;
|
|
|
|
if (wolfSSL_sk_X509_NAME_push(list, nameCopy) !=
|
|
WOLFSSL_SUCCESS) {
|
|
WOLFSSL_MSG("wolfSSL_sk_X509_NAME_push error");
|
|
/* Do free in loop because nameCopy is now responsibility
|
|
* of list to free and adding jumps to cleanup after this
|
|
* might result in a double free. */
|
|
wolfSSL_X509_NAME_free(nameCopy);
|
|
goto cleanup;
|
|
}
|
|
|
|
wolfSSL_X509_free(cert);
|
|
cert = NULL;
|
|
}
|
|
|
|
CLEAR_ASN_NO_PEM_HEADER_ERROR(err);
|
|
|
|
err = WOLFSSL_SUCCESS;
|
|
cleanup:
|
|
wolfSSL_X509_free(cert);
|
|
wolfSSL_BIO_free(bio);
|
|
if (err != WOLFSSL_SUCCESS) {
|
|
/* We failed so return NULL */
|
|
wolfSSL_sk_X509_NAME_pop_free(list, NULL);
|
|
list = NULL;
|
|
}
|
|
return list;
|
|
#else
|
|
(void)fname;
|
|
return NULL;
|
|
#endif
|
|
}
|
|
#endif
|
|
#endif /* !NO_BIO */
|
|
#endif /* OPENSSL_EXTRA || WOLFSSL_EXTRA */
|
|
|
|
#ifdef OPENSSL_EXTRA
|
|
|
|
#ifdef WOLFSSL_SYS_CA_CERTS
|
|
/*
|
|
* This is an OpenSSL compatibility layer function, but it doesn't mirror
|
|
* the exact functionality of its OpenSSL counterpart. We don't support the
|
|
* notion of an "OpenSSL directory". This function will attempt to load the
|
|
* environment variables SSL_CERT_DIR and SSL_CERT_FILE, if either are found,
|
|
* they will be loaded. Otherwise, it will act as a wrapper around our
|
|
* native wolfSSL_CTX_load_system_CA_certs function. This function does
|
|
* conform to OpenSSL's return value conventions.
|
|
*/
|
|
int wolfSSL_CTX_set_default_verify_paths(WOLFSSL_CTX* ctx)
|
|
{
|
|
int ret;
|
|
#ifdef XGETENV
|
|
char* certDir;
|
|
char* certFile;
|
|
word32 flags;
|
|
#endif
|
|
|
|
WOLFSSL_ENTER("wolfSSL_CTX_set_default_verify_paths");
|
|
|
|
#ifdef XGETENV
|
|
certDir = XGETENV("SSL_CERT_DIR");
|
|
certFile = XGETENV("SSL_CERT_FILE");
|
|
flags = WOLFSSL_LOAD_FLAG_PEM_CA_ONLY;
|
|
|
|
if (certDir || certFile) {
|
|
if (certDir) {
|
|
/*
|
|
* We want to keep trying to load more CAs even if one cert in
|
|
* the directory is bad and can't be used (e.g. if one is expired),
|
|
* so we use WOLFSSL_LOAD_FLAG_IGNORE_ERR.
|
|
*/
|
|
flags |= WOLFSSL_LOAD_FLAG_IGNORE_ERR;
|
|
}
|
|
|
|
ret = wolfSSL_CTX_load_verify_locations_ex(ctx, certFile, certDir,
|
|
flags);
|
|
if (ret != WOLFSSL_SUCCESS) {
|
|
WOLFSSL_MSG_EX("Failed to load CA certs from SSL_CERT_FILE: %s"
|
|
" SSL_CERT_DIR: %s. Error: %d", certFile,
|
|
certDir, ret);
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
return ret;
|
|
}
|
|
#endif
|
|
|
|
ret = wolfSSL_CTX_load_system_CA_certs(ctx);
|
|
if (ret == WOLFSSL_BAD_PATH) {
|
|
/*
|
|
* OpenSSL doesn't treat the lack of a system CA cert directory as a
|
|
* failure. We do the same here.
|
|
*/
|
|
ret = WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
WOLFSSL_LEAVE("wolfSSL_CTX_set_default_verify_paths", ret);
|
|
|
|
return ret;
|
|
}
|
|
#endif /* WOLFSSL_SYS_CA_CERTS */
|
|
|
|
#if defined(WOLFCRYPT_HAVE_SRP) && !defined(NO_SHA256) \
|
|
&& !defined(WC_NO_RNG)
|
|
static const byte srp_N[] = {
|
|
0xEE, 0xAF, 0x0A, 0xB9, 0xAD, 0xB3, 0x8D, 0xD6, 0x9C, 0x33, 0xF8,
|
|
0x0A, 0xFA, 0x8F, 0xC5, 0xE8, 0x60, 0x72, 0x61, 0x87, 0x75, 0xFF,
|
|
0x3C, 0x0B, 0x9E, 0xA2, 0x31, 0x4C, 0x9C, 0x25, 0x65, 0x76, 0xD6,
|
|
0x74, 0xDF, 0x74, 0x96, 0xEA, 0x81, 0xD3, 0x38, 0x3B, 0x48, 0x13,
|
|
0xD6, 0x92, 0xC6, 0xE0, 0xE0, 0xD5, 0xD8, 0xE2, 0x50, 0xB9, 0x8B,
|
|
0xE4, 0x8E, 0x49, 0x5C, 0x1D, 0x60, 0x89, 0xDA, 0xD1, 0x5D, 0xC7,
|
|
0xD7, 0xB4, 0x61, 0x54, 0xD6, 0xB6, 0xCE, 0x8E, 0xF4, 0xAD, 0x69,
|
|
0xB1, 0x5D, 0x49, 0x82, 0x55, 0x9B, 0x29, 0x7B, 0xCF, 0x18, 0x85,
|
|
0xC5, 0x29, 0xF5, 0x66, 0x66, 0x0E, 0x57, 0xEC, 0x68, 0xED, 0xBC,
|
|
0x3C, 0x05, 0x72, 0x6C, 0xC0, 0x2F, 0xD4, 0xCB, 0xF4, 0x97, 0x6E,
|
|
0xAA, 0x9A, 0xFD, 0x51, 0x38, 0xFE, 0x83, 0x76, 0x43, 0x5B, 0x9F,
|
|
0xC6, 0x1D, 0x2F, 0xC0, 0xEB, 0x06, 0xE3
|
|
};
|
|
static const byte srp_g[] = {
|
|
0x02
|
|
};
|
|
|
|
int wolfSSL_CTX_set_srp_username(WOLFSSL_CTX* ctx, char* username)
|
|
{
|
|
int r = 0;
|
|
SrpSide srp_side = SRP_CLIENT_SIDE;
|
|
byte salt[SRP_SALT_SIZE];
|
|
|
|
WOLFSSL_ENTER("wolfSSL_CTX_set_srp_username");
|
|
if (ctx == NULL || ctx->srp == NULL || username==NULL)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
if (ctx->method->side == WOLFSSL_SERVER_END){
|
|
srp_side = SRP_SERVER_SIDE;
|
|
} else if (ctx->method->side == WOLFSSL_CLIENT_END){
|
|
srp_side = SRP_CLIENT_SIDE;
|
|
} else {
|
|
WOLFSSL_MSG("Init CTX failed");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
if (wc_SrpInit(ctx->srp, SRP_TYPE_SHA256, srp_side) < 0) {
|
|
WOLFSSL_MSG("Init SRP CTX failed");
|
|
XFREE(ctx->srp, ctx->heap, DYNAMIC_TYPE_SRP);
|
|
ctx->srp = NULL;
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
r = wc_SrpSetUsername(ctx->srp, (const byte*)username,
|
|
(word32)XSTRLEN(username));
|
|
if (r < 0) {
|
|
WOLFSSL_MSG("fail to set srp username.");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
/* if wolfSSL_CTX_set_srp_password has already been called, */
|
|
/* execute wc_SrpSetPassword here */
|
|
if (ctx->srp_password != NULL) {
|
|
WC_RNG rng;
|
|
if (wc_InitRng(&rng) < 0){
|
|
WOLFSSL_MSG("wc_InitRng failed");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
XMEMSET(salt, 0, sizeof(salt)/sizeof(salt[0]));
|
|
r = wc_RNG_GenerateBlock(&rng, salt, sizeof(salt)/sizeof(salt[0]));
|
|
wc_FreeRng(&rng);
|
|
if (r < 0) {
|
|
WOLFSSL_MSG("wc_RNG_GenerateBlock failed");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
if (wc_SrpSetParams(ctx->srp, srp_N, sizeof(srp_N)/sizeof(srp_N[0]),
|
|
srp_g, sizeof(srp_g)/sizeof(srp_g[0]),
|
|
salt, sizeof(salt)/sizeof(salt[0])) < 0) {
|
|
WOLFSSL_MSG("wc_SrpSetParam failed");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
r = wc_SrpSetPassword(ctx->srp,
|
|
(const byte*)ctx->srp_password,
|
|
(word32)XSTRLEN((char *)ctx->srp_password));
|
|
if (r < 0) {
|
|
WOLFSSL_MSG("fail to set srp password.");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
XFREE(ctx->srp_password, ctx->heap, DYNAMIC_TYPE_SRP);
|
|
ctx->srp_password = NULL;
|
|
}
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
int wolfSSL_CTX_set_srp_password(WOLFSSL_CTX* ctx, char* password)
|
|
{
|
|
int r;
|
|
byte salt[SRP_SALT_SIZE];
|
|
|
|
WOLFSSL_ENTER("wolfSSL_CTX_set_srp_password");
|
|
if (ctx == NULL || ctx->srp == NULL || password == NULL)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
if (ctx->srp->user != NULL) {
|
|
WC_RNG rng;
|
|
if (wc_InitRng(&rng) < 0) {
|
|
WOLFSSL_MSG("wc_InitRng failed");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
XMEMSET(salt, 0, sizeof(salt)/sizeof(salt[0]));
|
|
r = wc_RNG_GenerateBlock(&rng, salt, sizeof(salt)/sizeof(salt[0]));
|
|
wc_FreeRng(&rng);
|
|
if (r < 0) {
|
|
WOLFSSL_MSG("wc_RNG_GenerateBlock failed");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
if (wc_SrpSetParams(ctx->srp, srp_N, sizeof(srp_N)/sizeof(srp_N[0]),
|
|
srp_g, sizeof(srp_g)/sizeof(srp_g[0]),
|
|
salt, sizeof(salt)/sizeof(salt[0])) < 0){
|
|
WOLFSSL_MSG("wc_SrpSetParam failed");
|
|
wc_FreeRng(&rng);
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
r = wc_SrpSetPassword(ctx->srp, (const byte*)password,
|
|
(word32)XSTRLEN(password));
|
|
if (r < 0) {
|
|
WOLFSSL_MSG("wc_SrpSetPassword failed.");
|
|
wc_FreeRng(&rng);
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
if (ctx->srp_password != NULL){
|
|
XFREE(ctx->srp_password,NULL,
|
|
DYNAMIC_TYPE_SRP);
|
|
ctx->srp_password = NULL;
|
|
}
|
|
wc_FreeRng(&rng);
|
|
} else {
|
|
/* save password for wolfSSL_set_srp_username */
|
|
if (ctx->srp_password != NULL)
|
|
XFREE(ctx->srp_password,ctx->heap, DYNAMIC_TYPE_SRP);
|
|
|
|
ctx->srp_password = (byte*)XMALLOC(XSTRLEN(password) + 1, ctx->heap,
|
|
DYNAMIC_TYPE_SRP);
|
|
if (ctx->srp_password == NULL){
|
|
WOLFSSL_MSG("memory allocation error");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
XMEMCPY(ctx->srp_password, password, XSTRLEN(password) + 1);
|
|
}
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
* The modulus passed to wc_SrpSetParams in ssl.c is constant so check
|
|
* that the requested strength is less than or equal to the size of the
|
|
* static modulus size.
|
|
* @param ctx Not used
|
|
* @param strength Minimum number of bits for the modulus
|
|
* @return 1 if strength is less than or equal to static modulus
|
|
* 0 if strength is greater than static modulus
|
|
*/
|
|
int wolfSSL_CTX_set_srp_strength(WOLFSSL_CTX *ctx, int strength)
|
|
{
|
|
(void)ctx;
|
|
WOLFSSL_ENTER("wolfSSL_CTX_set_srp_strength");
|
|
if (strength > (int)(sizeof(srp_N)*8)) {
|
|
WOLFSSL_MSG("Bad Parameter");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
char* wolfSSL_get_srp_username(WOLFSSL *ssl)
|
|
{
|
|
if (ssl && ssl->ctx && ssl->ctx->srp) {
|
|
return (char*) ssl->ctx->srp->user;
|
|
}
|
|
return NULL;
|
|
}
|
|
#endif /* WOLFCRYPT_HAVE_SRP && !NO_SHA256 && !WC_NO_RNG */
|
|
|
|
/* keyblock size in bytes or -1 */
|
|
int wolfSSL_get_keyblock_size(WOLFSSL* ssl)
|
|
{
|
|
if (ssl == NULL)
|
|
return WOLFSSL_FATAL_ERROR;
|
|
|
|
return 2 * (ssl->specs.key_size + ssl->specs.iv_size +
|
|
ssl->specs.hash_size);
|
|
}
|
|
|
|
#endif /* OPENSSL_EXTRA */
|
|
|
|
#if defined(OPENSSL_EXTRA) || defined(WOLFSSL_EXTRA) || defined(WOLFSSL_WPAS_SMALL)
|
|
|
|
/* store keys returns WOLFSSL_SUCCESS or -1 on error */
|
|
int wolfSSL_get_keys(WOLFSSL* ssl, unsigned char** ms, unsigned int* msLen,
|
|
unsigned char** sr, unsigned int* srLen,
|
|
unsigned char** cr, unsigned int* crLen)
|
|
{
|
|
if (ssl == NULL || ssl->arrays == NULL)
|
|
return WOLFSSL_FATAL_ERROR;
|
|
|
|
*ms = ssl->arrays->masterSecret;
|
|
*sr = ssl->arrays->serverRandom;
|
|
*cr = ssl->arrays->clientRandom;
|
|
|
|
*msLen = SECRET_LEN;
|
|
*srLen = RAN_LEN;
|
|
*crLen = RAN_LEN;
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
void wolfSSL_set_accept_state(WOLFSSL* ssl)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_set_accept_state");
|
|
|
|
if (ssl == NULL)
|
|
return;
|
|
|
|
if (ssl->options.side == WOLFSSL_CLIENT_END) {
|
|
#ifdef HAVE_ECC
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
ecc_key* key = NULL;
|
|
#else
|
|
ecc_key key[1];
|
|
#endif
|
|
word32 idx = 0;
|
|
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
key = (ecc_key*)XMALLOC(sizeof(ecc_key), ssl->heap,
|
|
DYNAMIC_TYPE_ECC);
|
|
if (key == NULL) {
|
|
WOLFSSL_MSG("Error allocating memory for ecc_key");
|
|
}
|
|
#endif
|
|
if (ssl->options.haveStaticECC && ssl->buffers.key != NULL) {
|
|
if (wc_ecc_init(key) >= 0) {
|
|
if (wc_EccPrivateKeyDecode(ssl->buffers.key->buffer, &idx,
|
|
key, ssl->buffers.key->length) != 0) {
|
|
ssl->options.haveECDSAsig = 0;
|
|
ssl->options.haveECC = 0;
|
|
ssl->options.haveStaticECC = 0;
|
|
}
|
|
wc_ecc_free(key);
|
|
}
|
|
}
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
XFREE(key, ssl->heap, DYNAMIC_TYPE_ECC);
|
|
#endif
|
|
#endif
|
|
|
|
#ifndef NO_DH
|
|
if (!ssl->options.haveDH && ssl->ctx->haveDH) {
|
|
ssl->buffers.serverDH_P = ssl->ctx->serverDH_P;
|
|
ssl->buffers.serverDH_G = ssl->ctx->serverDH_G;
|
|
ssl->options.haveDH = 1;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
if (InitSSL_Side(ssl, WOLFSSL_SERVER_END) != WOLFSSL_SUCCESS) {
|
|
WOLFSSL_MSG("Error initializing server side");
|
|
}
|
|
}
|
|
|
|
#endif /* OPENSSL_EXTRA || WOLFSSL_EXTRA || WOLFSSL_WPAS_SMALL */
|
|
|
|
/* return true if connection established */
|
|
int wolfSSL_is_init_finished(const WOLFSSL* ssl)
|
|
{
|
|
if (ssl == NULL)
|
|
return 0;
|
|
|
|
/* Can't use ssl->options.connectState and ssl->options.acceptState because
|
|
* they differ in meaning for TLS <=1.2 and 1.3 */
|
|
if (ssl->options.handShakeState == HANDSHAKE_DONE)
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
#ifdef OPENSSL_EXTRA
|
|
void wolfSSL_CTX_set_tmp_rsa_callback(WOLFSSL_CTX* ctx,
|
|
WOLFSSL_RSA*(*f)(WOLFSSL*, int, int))
|
|
{
|
|
/* wolfSSL verifies all these internally */
|
|
(void)ctx;
|
|
(void)f;
|
|
}
|
|
|
|
|
|
void wolfSSL_set_shutdown(WOLFSSL* ssl, int opt)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_set_shutdown");
|
|
if(ssl==NULL) {
|
|
WOLFSSL_MSG("Shutdown not set. ssl is null");
|
|
return;
|
|
}
|
|
|
|
ssl->options.sentNotify = (opt&WOLFSSL_SENT_SHUTDOWN) > 0;
|
|
ssl->options.closeNotify = (opt&WOLFSSL_RECEIVED_SHUTDOWN) > 0;
|
|
}
|
|
#endif
|
|
|
|
long wolfSSL_CTX_get_options(WOLFSSL_CTX* ctx)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_get_options");
|
|
WOLFSSL_MSG("wolfSSL options are set through API calls and macros");
|
|
if(ctx == NULL)
|
|
return BAD_FUNC_ARG;
|
|
return ctx->mask;
|
|
}
|
|
|
|
/* forward declaration */
|
|
static long wolf_set_options(long old_op, long op);
|
|
|
|
long wolfSSL_CTX_set_options(WOLFSSL_CTX* ctx, long opt)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_set_options");
|
|
|
|
if (ctx == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
ctx->mask = wolf_set_options(ctx->mask, opt);
|
|
#if defined(HAVE_SESSION_TICKET) && (defined(OPENSSL_EXTRA) \
|
|
|| defined(HAVE_WEBSERVER) || defined(WOLFSSL_WPAS_SMALL))
|
|
if ((ctx->mask & WOLFSSL_OP_NO_TICKET) == WOLFSSL_OP_NO_TICKET) {
|
|
ctx->noTicketTls12 = 1;
|
|
}
|
|
/* This code is here for documentation purpose. You must not turn off
|
|
* session tickets with the WOLFSSL_OP_NO_TICKET option for TLSv1.3.
|
|
* Because we need to support both stateful and stateless tickets.
|
|
#ifdef WOLFSSL_TLS13
|
|
if ((ctx->mask & WOLFSSL_OP_NO_TICKET) == WOLFSSL_OP_NO_TICKET) {
|
|
ctx->noTicketTls13 = 1;
|
|
}
|
|
#endif
|
|
*/
|
|
#endif
|
|
return ctx->mask;
|
|
}
|
|
|
|
long wolfSSL_CTX_clear_options(WOLFSSL_CTX* ctx, long opt)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_clear_options");
|
|
if(ctx == NULL)
|
|
return BAD_FUNC_ARG;
|
|
ctx->mask &= ~opt;
|
|
return ctx->mask;
|
|
}
|
|
|
|
#ifdef OPENSSL_EXTRA
|
|
|
|
int wolfSSL_set_rfd(WOLFSSL* ssl, int rfd)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_set_rfd");
|
|
ssl->rfd = rfd; /* not used directly to allow IO callbacks */
|
|
|
|
ssl->IOCB_ReadCtx = &ssl->rfd;
|
|
|
|
#ifdef WOLFSSL_DTLS
|
|
if (ssl->options.dtls) {
|
|
ssl->IOCB_ReadCtx = &ssl->buffers.dtlsCtx;
|
|
ssl->buffers.dtlsCtx.rfd = rfd;
|
|
}
|
|
#endif
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
|
|
int wolfSSL_set_wfd(WOLFSSL* ssl, int wfd)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_set_wfd");
|
|
ssl->wfd = wfd; /* not used directly to allow IO callbacks */
|
|
|
|
ssl->IOCB_WriteCtx = &ssl->wfd;
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
#endif /* OPENSSL_EXTRA */
|
|
|
|
#if !defined(NO_CERTS) && (defined(OPENSSL_EXTRA) || defined(WOLFSSL_WPAS_SMALL))
|
|
|
|
#if defined(SESSION_CERTS) && defined(OPENSSL_EXTRA)
|
|
/**
|
|
* Implemented in a similar way that ngx_ssl_ocsp_validate does it when
|
|
* SSL_get0_verified_chain is not available.
|
|
* @param ssl WOLFSSL object to extract certs from
|
|
* @return Stack of verified certs
|
|
*/
|
|
WOLF_STACK_OF(WOLFSSL_X509) *wolfSSL_get0_verified_chain(const WOLFSSL *ssl)
|
|
{
|
|
WOLF_STACK_OF(WOLFSSL_X509)* chain = NULL;
|
|
WOLFSSL_X509_STORE_CTX* storeCtx = NULL;
|
|
WOLFSSL_X509* peerCert = NULL;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_get0_verified_chain");
|
|
|
|
if (ssl == NULL || ssl->ctx == NULL) {
|
|
WOLFSSL_MSG("Bad parameter");
|
|
return NULL;
|
|
}
|
|
|
|
peerCert = wolfSSL_get_peer_certificate((WOLFSSL*)ssl);
|
|
if (peerCert == NULL) {
|
|
WOLFSSL_MSG("wolfSSL_get_peer_certificate error");
|
|
return NULL;
|
|
}
|
|
/* wolfSSL_get_peer_certificate returns a copy. We want the internal
|
|
* member so that we don't have to worry about free'ing it. We call
|
|
* wolfSSL_get_peer_certificate so that we don't have to worry about
|
|
* setting up the internal pointer. */
|
|
wolfSSL_X509_free(peerCert);
|
|
peerCert = (WOLFSSL_X509*)&ssl->peerCert;
|
|
chain = wolfSSL_get_peer_cert_chain(ssl);
|
|
if (chain == NULL) {
|
|
WOLFSSL_MSG("wolfSSL_get_peer_cert_chain error");
|
|
return NULL;
|
|
}
|
|
storeCtx = wolfSSL_X509_STORE_CTX_new();
|
|
if (storeCtx == NULL) {
|
|
WOLFSSL_MSG("wolfSSL_X509_STORE_CTX_new error");
|
|
return NULL;
|
|
}
|
|
if (wolfSSL_X509_STORE_CTX_init(storeCtx, SSL_STORE(ssl),
|
|
peerCert, chain) != WOLFSSL_SUCCESS) {
|
|
WOLFSSL_MSG("wolfSSL_X509_STORE_CTX_init error");
|
|
wolfSSL_X509_STORE_CTX_free(storeCtx);
|
|
return NULL;
|
|
}
|
|
if (wolfSSL_X509_verify_cert(storeCtx) <= 0) {
|
|
WOLFSSL_MSG("wolfSSL_X509_verify_cert error");
|
|
wolfSSL_X509_STORE_CTX_free(storeCtx);
|
|
return NULL;
|
|
}
|
|
wolfSSL_X509_STORE_CTX_free(storeCtx);
|
|
return chain;
|
|
}
|
|
#endif /* SESSION_CERTS && OPENSSL_EXTRA */
|
|
|
|
WOLFSSL_X509_STORE* wolfSSL_CTX_get_cert_store(WOLFSSL_CTX* ctx)
|
|
{
|
|
if (ctx == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
if (ctx->x509_store_pt != NULL)
|
|
return ctx->x509_store_pt;
|
|
return &ctx->x509_store;
|
|
}
|
|
|
|
void wolfSSL_CTX_set_cert_store(WOLFSSL_CTX* ctx, WOLFSSL_X509_STORE* str)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_set_cert_store");
|
|
if (ctx == NULL || str == NULL || ctx->cm == str->cm) {
|
|
return;
|
|
}
|
|
|
|
if (wolfSSL_CertManager_up_ref(str->cm) != WOLFSSL_SUCCESS) {
|
|
WOLFSSL_MSG("wolfSSL_CertManager_up_ref error");
|
|
return;
|
|
}
|
|
/* free cert manager if have one */
|
|
if (ctx->cm != NULL) {
|
|
wolfSSL_CertManagerFree(ctx->cm);
|
|
}
|
|
ctx->cm = str->cm;
|
|
ctx->x509_store.cm = str->cm;
|
|
|
|
/* free existing store if it exists */
|
|
wolfSSL_X509_STORE_free(ctx->x509_store_pt);
|
|
ctx->x509_store.cache = str->cache;
|
|
ctx->x509_store_pt = str; /* take ownership of store and free it
|
|
with CTX free */
|
|
ctx->cm->x509_store_p = ctx->x509_store_pt;/* CTX has ownership
|
|
and free it with CTX free*/
|
|
}
|
|
|
|
#ifdef OPENSSL_ALL
|
|
int wolfSSL_CTX_set1_verify_cert_store(WOLFSSL_CTX* ctx, WOLFSSL_X509_STORE* str)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_set1_verify_cert_store");
|
|
|
|
if (ctx == NULL || str == NULL) {
|
|
WOLFSSL_MSG("Bad parameter");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
/* NO-OP when setting existing store */
|
|
if (str == CTX_STORE(ctx))
|
|
return WOLFSSL_SUCCESS;
|
|
|
|
if (wolfSSL_X509_STORE_up_ref(str) != WOLFSSL_SUCCESS) {
|
|
WOLFSSL_MSG("wolfSSL_X509_STORE_up_ref error");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
/* free existing store if it exists */
|
|
wolfSSL_X509_STORE_free(ctx->x509_store_pt);
|
|
ctx->x509_store_pt = str; /* take ownership of store and free it
|
|
with CTX free */
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
#endif
|
|
|
|
int wolfSSL_set0_verify_cert_store(WOLFSSL *ssl, WOLFSSL_X509_STORE* str)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_set0_verify_cert_store");
|
|
|
|
if (ssl == NULL || str == NULL) {
|
|
WOLFSSL_MSG("Bad parameter");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
/* NO-OP when setting existing store */
|
|
if (str == SSL_STORE(ssl))
|
|
return WOLFSSL_SUCCESS;
|
|
|
|
/* free existing store if it exists */
|
|
wolfSSL_X509_STORE_free(ssl->x509_store_pt);
|
|
if (str == ssl->ctx->x509_store_pt)
|
|
ssl->x509_store_pt = NULL; /* if setting ctx store then just revert
|
|
to using that instead */
|
|
else
|
|
ssl->x509_store_pt = str; /* take ownership of store and free it
|
|
with SSL free */
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
|
|
int wolfSSL_set1_verify_cert_store(WOLFSSL *ssl, WOLFSSL_X509_STORE* str)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_set1_verify_cert_store");
|
|
|
|
if (ssl == NULL || str == NULL) {
|
|
WOLFSSL_MSG("Bad parameter");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
/* NO-OP when setting existing store */
|
|
if (str == SSL_STORE(ssl))
|
|
return WOLFSSL_SUCCESS;
|
|
|
|
if (wolfSSL_X509_STORE_up_ref(str) != WOLFSSL_SUCCESS) {
|
|
WOLFSSL_MSG("wolfSSL_X509_STORE_up_ref error");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
/* free existing store if it exists */
|
|
wolfSSL_X509_STORE_free(ssl->x509_store_pt);
|
|
if (str == ssl->ctx->x509_store_pt)
|
|
ssl->x509_store_pt = NULL; /* if setting ctx store then just revert
|
|
to using that instead */
|
|
else
|
|
ssl->x509_store_pt = str; /* take ownership of store and free it
|
|
with SSL free */
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
#endif /* !NO_CERTS && (OPENSSL_EXTRA || WOLFSSL_WPAS_SMALL) */
|
|
|
|
#ifdef WOLFSSL_ENCRYPTED_KEYS
|
|
|
|
void wolfSSL_CTX_set_default_passwd_cb_userdata(WOLFSSL_CTX* ctx,
|
|
void* userdata)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_set_default_passwd_cb_userdata");
|
|
if (ctx)
|
|
ctx->passwd_userdata = userdata;
|
|
}
|
|
|
|
|
|
void wolfSSL_CTX_set_default_passwd_cb(WOLFSSL_CTX* ctx, wc_pem_password_cb*
|
|
cb)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_set_default_passwd_cb");
|
|
if (ctx)
|
|
ctx->passwd_cb = cb;
|
|
}
|
|
|
|
wc_pem_password_cb* wolfSSL_CTX_get_default_passwd_cb(WOLFSSL_CTX *ctx)
|
|
{
|
|
if (ctx == NULL || ctx->passwd_cb == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
return ctx->passwd_cb;
|
|
}
|
|
|
|
|
|
void* wolfSSL_CTX_get_default_passwd_cb_userdata(WOLFSSL_CTX *ctx)
|
|
{
|
|
if (ctx == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
return ctx->passwd_userdata;
|
|
}
|
|
|
|
#endif /* WOLFSSL_ENCRYPTED_KEYS */
|
|
|
|
|
|
#if defined(OPENSSL_EXTRA) || defined(HAVE_WEBSERVER) || defined(HAVE_MEMCACHED)
|
|
unsigned long wolfSSL_ERR_get_error(void)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_ERR_get_error");
|
|
#ifdef WOLFSSL_HAVE_ERROR_QUEUE
|
|
return wc_GetErrorNodeErr();
|
|
#else
|
|
return (unsigned long)(0 - NOT_COMPILED_IN);
|
|
#endif
|
|
}
|
|
#endif
|
|
|
|
#if defined(OPENSSL_EXTRA) || defined(HAVE_WEBSERVER)
|
|
|
|
int wolfSSL_num_locks(void)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
void wolfSSL_set_locking_callback(mutex_cb* f)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_set_locking_callback");
|
|
|
|
if (wc_SetMutexCb(f) != 0) {
|
|
WOLFSSL_MSG("Error when setting mutex call back");
|
|
}
|
|
}
|
|
|
|
mutex_cb* wolfSSL_get_locking_callback(void)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_get_locking_callback");
|
|
|
|
return wc_GetMutexCb();
|
|
}
|
|
|
|
|
|
typedef unsigned long (idCb)(void);
|
|
static idCb* inner_idCb = NULL;
|
|
|
|
unsigned long wolfSSL_thread_id(void)
|
|
{
|
|
if (inner_idCb != NULL) {
|
|
return inner_idCb();
|
|
}
|
|
else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
|
|
void wolfSSL_set_id_callback(unsigned long (*f)(void))
|
|
{
|
|
inner_idCb = f;
|
|
}
|
|
|
|
#ifdef WOLFSSL_HAVE_ERROR_QUEUE
|
|
#ifndef NO_BIO
|
|
/* print out and clear all errors */
|
|
void wolfSSL_ERR_print_errors(WOLFSSL_BIO* bio)
|
|
{
|
|
const char* file = NULL;
|
|
const char* reason = NULL;
|
|
int ret;
|
|
int line = 0;
|
|
char buf[WOLFSSL_MAX_ERROR_SZ * 2];
|
|
|
|
WOLFSSL_ENTER("wolfSSL_ERR_print_errors");
|
|
|
|
if (bio == NULL) {
|
|
WOLFSSL_MSG("BIO passed in was null");
|
|
return;
|
|
}
|
|
|
|
do {
|
|
ret = wc_PeekErrorNode(0, &file, &reason, &line);
|
|
if (ret >= 0) {
|
|
const char* r = wolfSSL_ERR_reason_error_string(0 - ret);
|
|
if (XSNPRINTF(buf, sizeof(buf),
|
|
"error:%d:wolfSSL library:%s:%s:%d\n",
|
|
ret, r, file, line)
|
|
>= (int)sizeof(buf))
|
|
{
|
|
WOLFSSL_MSG("Buffer overrun formatting error message");
|
|
}
|
|
wolfSSL_BIO_write(bio, buf, (int)XSTRLEN(buf));
|
|
wc_RemoveErrorNode(0);
|
|
}
|
|
} while (ret >= 0);
|
|
if (wolfSSL_BIO_write(bio, "", 1) != 1) {
|
|
WOLFSSL_MSG("Issue writing final string terminator");
|
|
}
|
|
}
|
|
#endif /* !NO_BIO */
|
|
#endif /* WOLFSSL_HAVE_ERROR_QUEUE */
|
|
|
|
#endif /* OPENSSL_EXTRA || HAVE_WEBSERVER */
|
|
|
|
#if defined(OPENSSL_EXTRA) || defined(WOLFSSL_WPAS_SMALL) || \
|
|
defined(HAVE_SECRET_CALLBACK)
|
|
#if !defined(NO_WOLFSSL_SERVER)
|
|
/* Return the amount of random bytes copied over or error case.
|
|
* ssl : ssl struct after handshake
|
|
* out : buffer to hold random bytes
|
|
* outSz : either 0 (return max buffer sz) or size of out buffer
|
|
*/
|
|
size_t wolfSSL_get_server_random(const WOLFSSL *ssl, unsigned char *out,
|
|
size_t outSz)
|
|
{
|
|
size_t size;
|
|
|
|
/* return max size of buffer */
|
|
if (outSz == 0) {
|
|
return RAN_LEN;
|
|
}
|
|
|
|
if (ssl == NULL || out == NULL) {
|
|
return 0;
|
|
}
|
|
|
|
if (ssl->arrays == NULL) {
|
|
WOLFSSL_MSG("Arrays struct not saved after handshake");
|
|
return 0;
|
|
}
|
|
|
|
if (outSz > RAN_LEN) {
|
|
size = RAN_LEN;
|
|
}
|
|
else {
|
|
size = outSz;
|
|
}
|
|
|
|
XMEMCPY(out, ssl->arrays->serverRandom, size);
|
|
return size;
|
|
}
|
|
#endif /* !NO_WOLFSSL_SERVER */
|
|
#endif /* OPENSSL_EXTRA || WOLFSSL_WPAS_SMALL || HAVE_SECRET_CALLBACK */
|
|
|
|
#ifdef OPENSSL_EXTRA
|
|
#if !defined(NO_WOLFSSL_SERVER)
|
|
/* Used to get the peer ephemeral public key sent during the connection
|
|
* NOTE: currently wolfSSL_KeepHandshakeResources(WOLFSSL* ssl) must be called
|
|
* before the ephemeral key is stored.
|
|
* return WOLFSSL_SUCCESS on success */
|
|
int wolfSSL_get_peer_tmp_key(const WOLFSSL* ssl, WOLFSSL_EVP_PKEY** pkey)
|
|
{
|
|
WOLFSSL_EVP_PKEY* ret = NULL;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_get_server_tmp_key");
|
|
|
|
if (ssl == NULL || pkey == NULL) {
|
|
WOLFSSL_MSG("Bad argument passed in");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
#ifdef HAVE_ECC
|
|
if (ssl->peerEccKey != NULL) {
|
|
unsigned char* der;
|
|
const unsigned char* pt;
|
|
unsigned int derSz = 0;
|
|
int sz;
|
|
|
|
PRIVATE_KEY_UNLOCK();
|
|
if (wc_ecc_export_x963(ssl->peerEccKey, NULL, &derSz) !=
|
|
LENGTH_ONLY_E) {
|
|
WOLFSSL_MSG("get ecc der size failed");
|
|
PRIVATE_KEY_LOCK();
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
PRIVATE_KEY_LOCK();
|
|
|
|
derSz += MAX_SEQ_SZ + (2 * MAX_ALGO_SZ) + MAX_SEQ_SZ + TRAILING_ZERO;
|
|
der = (unsigned char*)XMALLOC(derSz, ssl->heap, DYNAMIC_TYPE_KEY);
|
|
if (der == NULL) {
|
|
WOLFSSL_MSG("Memory error");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
if ((sz = wc_EccPublicKeyToDer(ssl->peerEccKey, der, derSz, 1)) <= 0) {
|
|
WOLFSSL_MSG("get ecc der failed");
|
|
XFREE(der, ssl->heap, DYNAMIC_TYPE_KEY);
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
pt = der; /* in case pointer gets advanced */
|
|
ret = wolfSSL_d2i_PUBKEY(NULL, &pt, sz);
|
|
XFREE(der, ssl->heap, DYNAMIC_TYPE_KEY);
|
|
}
|
|
#endif
|
|
|
|
*pkey = ret;
|
|
#ifdef HAVE_ECC
|
|
if (ret != NULL)
|
|
return WOLFSSL_SUCCESS;
|
|
else
|
|
#endif
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
#endif /* !NO_WOLFSSL_SERVER */
|
|
|
|
/**
|
|
* This function checks if any compiled in protocol versions are
|
|
* left enabled after calls to set_min or set_max API.
|
|
* @param major The SSL/TLS major version
|
|
* @return WOLFSSL_SUCCESS on valid settings and WOLFSSL_FAILURE when no
|
|
* protocol versions are left enabled.
|
|
*/
|
|
static int CheckSslMethodVersion(byte major, unsigned long options)
|
|
{
|
|
int sanityConfirmed = 0;
|
|
|
|
(void)options;
|
|
|
|
switch (major) {
|
|
#ifndef NO_TLS
|
|
case SSLv3_MAJOR:
|
|
#ifdef WOLFSSL_ALLOW_SSLV3
|
|
if (!(options & WOLFSSL_OP_NO_SSLv3)) {
|
|
sanityConfirmed = 1;
|
|
}
|
|
#endif
|
|
#ifndef NO_OLD_TLS
|
|
if (!(options & WOLFSSL_OP_NO_TLSv1))
|
|
sanityConfirmed = 1;
|
|
if (!(options & WOLFSSL_OP_NO_TLSv1_1))
|
|
sanityConfirmed = 1;
|
|
#endif
|
|
#ifndef WOLFSSL_NO_TLS12
|
|
if (!(options & WOLFSSL_OP_NO_TLSv1_2))
|
|
sanityConfirmed = 1;
|
|
#endif
|
|
#ifdef WOLFSSL_TLS13
|
|
if (!(options & WOLFSSL_OP_NO_TLSv1_3))
|
|
sanityConfirmed = 1;
|
|
#endif
|
|
break;
|
|
#endif
|
|
#ifdef WOLFSSL_DTLS
|
|
case DTLS_MAJOR:
|
|
sanityConfirmed = 1;
|
|
break;
|
|
#endif
|
|
default:
|
|
WOLFSSL_MSG("Invalid major version");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
if (!sanityConfirmed) {
|
|
WOLFSSL_MSG("All compiled in TLS versions disabled");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
* protoVerTbl holds (D)TLS version numbers in ascending order.
|
|
* Except DTLS versions, the newer version is located in the latter part of
|
|
* the table. This table is referred by wolfSSL_CTX_set_min_proto_version and
|
|
* wolfSSL_CTX_set_max_proto_version.
|
|
*/
|
|
static const int protoVerTbl[] = {
|
|
SSL3_VERSION,
|
|
TLS1_VERSION,
|
|
TLS1_1_VERSION,
|
|
TLS1_2_VERSION,
|
|
TLS1_3_VERSION,
|
|
DTLS1_VERSION,
|
|
DTLS1_2_VERSION
|
|
};
|
|
/* number of protocol versions listed in protoVerTbl */
|
|
#define NUMBER_OF_PROTOCOLS (sizeof(protoVerTbl)/sizeof(int))
|
|
|
|
/**
|
|
* wolfSSL_CTX_set_min_proto_version attempts to set the minimum protocol
|
|
* version to use by SSL objects created from this WOLFSSL_CTX.
|
|
* This API guarantees that a version of SSL/TLS lower than specified
|
|
* here will not be allowed. If the version specified is not compiled in
|
|
* then this API sets the lowest compiled in protocol version.
|
|
* This API also accept 0 as version, to set the minimum version automatically.
|
|
* CheckSslMethodVersion() is called to check if any remaining protocol versions
|
|
* are enabled.
|
|
* @param ctx The wolfSSL CONTEXT factory for spawning SSL/TLS objects
|
|
* @param version Any of the following
|
|
* * 0
|
|
* * SSL3_VERSION
|
|
* * TLS1_VERSION
|
|
* * TLS1_1_VERSION
|
|
* * TLS1_2_VERSION
|
|
* * TLS1_3_VERSION
|
|
* * DTLS1_VERSION
|
|
* * DTLS1_2_VERSION
|
|
* @return WOLFSSL_SUCCESS on valid settings and WOLFSSL_FAILURE when no
|
|
* protocol versions are left enabled.
|
|
*/
|
|
static int Set_CTX_min_proto_version(WOLFSSL_CTX* ctx, int version)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_set_min_proto_version_ex");
|
|
|
|
if (ctx == NULL) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
switch (version) {
|
|
#ifndef NO_TLS
|
|
case SSL3_VERSION:
|
|
#if defined(WOLFSSL_ALLOW_SSLV3) && !defined(NO_OLD_TLS)
|
|
ctx->minDowngrade = SSLv3_MINOR;
|
|
break;
|
|
#endif
|
|
case TLS1_VERSION:
|
|
#ifdef WOLFSSL_ALLOW_TLSV10
|
|
ctx->minDowngrade = TLSv1_MINOR;
|
|
break;
|
|
#endif
|
|
case TLS1_1_VERSION:
|
|
#ifndef NO_OLD_TLS
|
|
ctx->minDowngrade = TLSv1_1_MINOR;
|
|
break;
|
|
#endif
|
|
case TLS1_2_VERSION:
|
|
#ifndef WOLFSSL_NO_TLS12
|
|
ctx->minDowngrade = TLSv1_2_MINOR;
|
|
break;
|
|
#endif
|
|
case TLS1_3_VERSION:
|
|
#ifdef WOLFSSL_TLS13
|
|
ctx->minDowngrade = TLSv1_3_MINOR;
|
|
break;
|
|
#endif
|
|
#endif
|
|
#ifdef WOLFSSL_DTLS
|
|
case DTLS1_VERSION:
|
|
#ifndef NO_OLD_TLS
|
|
ctx->minDowngrade = DTLS_MINOR;
|
|
break;
|
|
#endif
|
|
case DTLS1_2_VERSION:
|
|
ctx->minDowngrade = DTLSv1_2_MINOR;
|
|
break;
|
|
#endif
|
|
default:
|
|
WOLFSSL_MSG("Unrecognized protocol version or not compiled in");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
switch (version) {
|
|
#ifndef NO_TLS
|
|
case TLS1_3_VERSION:
|
|
wolfSSL_CTX_set_options(ctx, WOLFSSL_OP_NO_TLSv1_2);
|
|
FALL_THROUGH;
|
|
case TLS1_2_VERSION:
|
|
wolfSSL_CTX_set_options(ctx, WOLFSSL_OP_NO_TLSv1_1);
|
|
FALL_THROUGH;
|
|
case TLS1_1_VERSION:
|
|
wolfSSL_CTX_set_options(ctx, WOLFSSL_OP_NO_TLSv1);
|
|
FALL_THROUGH;
|
|
case TLS1_VERSION:
|
|
wolfSSL_CTX_set_options(ctx, WOLFSSL_OP_NO_SSLv3);
|
|
break;
|
|
case SSL3_VERSION:
|
|
case SSL2_VERSION:
|
|
/* Nothing to do here */
|
|
break;
|
|
#endif
|
|
#ifdef WOLFSSL_DTLS
|
|
case DTLS1_VERSION:
|
|
case DTLS1_2_VERSION:
|
|
break;
|
|
#endif
|
|
default:
|
|
WOLFSSL_MSG("Unrecognized protocol version or not compiled in");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
return CheckSslMethodVersion(ctx->method->version.major, ctx->mask);
|
|
}
|
|
|
|
/* Sets the min protocol version allowed with WOLFSSL_CTX
|
|
* returns WOLFSSL_SUCCESS on success */
|
|
int wolfSSL_CTX_set_min_proto_version(WOLFSSL_CTX* ctx, int version)
|
|
{
|
|
int ret;
|
|
int proto = 0;
|
|
int maxProto = 0;
|
|
int i;
|
|
int idx = 0;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_CTX_set_min_proto_version");
|
|
|
|
if (ctx == NULL) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
if (version != 0) {
|
|
proto = version;
|
|
ctx->minProto = 0; /* turn min proto flag off */
|
|
for (i = 0; (unsigned)i < NUMBER_OF_PROTOCOLS; i++) {
|
|
if (protoVerTbl[i] == version) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
/* when 0 is specified as version, try to find out the min version */
|
|
for (i = 0; (unsigned)i < NUMBER_OF_PROTOCOLS; i++) {
|
|
ret = Set_CTX_min_proto_version(ctx, protoVerTbl[i]);
|
|
if (ret == WOLFSSL_SUCCESS) {
|
|
proto = protoVerTbl[i];
|
|
ctx->minProto = 1; /* turn min proto flag on */
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* check case where max > min , if so then clear the NO_* options
|
|
* i is the index into the table for proto version used, see if the max
|
|
* proto version index found is smaller */
|
|
maxProto = wolfSSL_CTX_get_max_proto_version(ctx);
|
|
for (idx = 0; (unsigned)idx < NUMBER_OF_PROTOCOLS; idx++) {
|
|
if (protoVerTbl[idx] == maxProto) {
|
|
break;
|
|
}
|
|
}
|
|
if (idx < i) {
|
|
wolfSSL_CTX_clear_options(ctx, WOLFSSL_OP_NO_TLSv1 |
|
|
WOLFSSL_OP_NO_TLSv1_1 | WOLFSSL_OP_NO_TLSv1_2 |
|
|
WOLFSSL_OP_NO_TLSv1_3);
|
|
}
|
|
|
|
ret = Set_CTX_min_proto_version(ctx, proto);
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* wolfSSL_CTX_set_max_proto_version attempts to set the maximum protocol
|
|
* version to use by SSL objects created from this WOLFSSL_CTX.
|
|
* This API guarantees that a version of SSL/TLS higher than specified
|
|
* here will not be allowed. If the version specified is not compiled in
|
|
* then this API sets the highest compiled in protocol version.
|
|
* This API also accept 0 as version, to set the maximum version automatically.
|
|
* CheckSslMethodVersion() is called to check if any remaining protocol versions
|
|
* are enabled.
|
|
* @param ctx The wolfSSL CONTEXT factory for spawning SSL/TLS objects
|
|
* @param ver Any of the following
|
|
* * 0
|
|
* * SSL3_VERSION
|
|
* * TLS1_VERSION
|
|
* * TLS1_1_VERSION
|
|
* * TLS1_2_VERSION
|
|
* * TLS1_3_VERSION
|
|
* * DTLS1_VERSION
|
|
* * DTLS1_2_VERSION
|
|
* @return WOLFSSL_SUCCESS on valid settings and WOLFSSL_FAILURE when no
|
|
* protocol versions are left enabled.
|
|
*/
|
|
static int Set_CTX_max_proto_version(WOLFSSL_CTX* ctx, int ver)
|
|
{
|
|
int ret;
|
|
WOLFSSL_ENTER("Set_CTX_max_proto_version");
|
|
|
|
if (!ctx || !ctx->method) {
|
|
WOLFSSL_MSG("Bad parameter");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
switch (ver) {
|
|
case SSL2_VERSION:
|
|
WOLFSSL_MSG("wolfSSL does not support SSLv2");
|
|
return WOLFSSL_FAILURE;
|
|
#ifndef NO_TLS
|
|
case SSL3_VERSION:
|
|
wolfSSL_CTX_set_options(ctx, WOLFSSL_OP_NO_TLSv1);
|
|
FALL_THROUGH;
|
|
case TLS1_VERSION:
|
|
wolfSSL_CTX_set_options(ctx, WOLFSSL_OP_NO_TLSv1_1);
|
|
FALL_THROUGH;
|
|
case TLS1_1_VERSION:
|
|
wolfSSL_CTX_set_options(ctx, WOLFSSL_OP_NO_TLSv1_2);
|
|
FALL_THROUGH;
|
|
case TLS1_2_VERSION:
|
|
wolfSSL_CTX_set_options(ctx, WOLFSSL_OP_NO_TLSv1_3);
|
|
FALL_THROUGH;
|
|
case TLS1_3_VERSION:
|
|
/* Nothing to do here */
|
|
break;
|
|
#endif
|
|
#ifdef WOLFSSL_DTLS
|
|
case DTLS1_VERSION:
|
|
case DTLS1_2_VERSION:
|
|
break;
|
|
#endif
|
|
default:
|
|
WOLFSSL_MSG("Unrecognized protocol version or not compiled in");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
ret = CheckSslMethodVersion(ctx->method->version.major, ctx->mask);
|
|
if (ret == WOLFSSL_SUCCESS) {
|
|
/* Check the major */
|
|
switch (ver) {
|
|
#ifndef NO_TLS
|
|
case SSL3_VERSION:
|
|
case TLS1_VERSION:
|
|
case TLS1_1_VERSION:
|
|
case TLS1_2_VERSION:
|
|
case TLS1_3_VERSION:
|
|
if (ctx->method->version.major != SSLv3_MAJOR) {
|
|
WOLFSSL_MSG("Mismatched protocol version");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
break;
|
|
#endif
|
|
#ifdef WOLFSSL_DTLS
|
|
case DTLS1_VERSION:
|
|
case DTLS1_2_VERSION:
|
|
if (ctx->method->version.major != DTLS_MAJOR) {
|
|
WOLFSSL_MSG("Mismatched protocol version");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
break;
|
|
#endif
|
|
}
|
|
/* Update the method */
|
|
switch (ver) {
|
|
case SSL2_VERSION:
|
|
WOLFSSL_MSG("wolfSSL does not support SSLv2");
|
|
return WOLFSSL_FAILURE;
|
|
#ifndef NO_TLS
|
|
case SSL3_VERSION:
|
|
ctx->method->version.minor = SSLv3_MINOR;
|
|
break;
|
|
case TLS1_VERSION:
|
|
ctx->method->version.minor = TLSv1_MINOR;
|
|
break;
|
|
case TLS1_1_VERSION:
|
|
ctx->method->version.minor = TLSv1_1_MINOR;
|
|
break;
|
|
case TLS1_2_VERSION:
|
|
ctx->method->version.minor = TLSv1_2_MINOR;
|
|
break;
|
|
case TLS1_3_VERSION:
|
|
ctx->method->version.minor = TLSv1_3_MINOR;
|
|
break;
|
|
#endif
|
|
#ifdef WOLFSSL_DTLS
|
|
case DTLS1_VERSION:
|
|
ctx->method->version.minor = DTLS_MINOR;
|
|
break;
|
|
case DTLS1_2_VERSION:
|
|
ctx->method->version.minor = DTLSv1_2_MINOR;
|
|
break;
|
|
#endif
|
|
default:
|
|
WOLFSSL_MSG("Unrecognized protocol version or not compiled in");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
|
|
/* Sets the max protocol version allowed with WOLFSSL_CTX
|
|
* returns WOLFSSL_SUCCESS on success */
|
|
int wolfSSL_CTX_set_max_proto_version(WOLFSSL_CTX* ctx, int version)
|
|
{
|
|
int i;
|
|
int ret = WOLFSSL_FAILURE;
|
|
int minProto;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_CTX_set_max_proto_version");
|
|
|
|
if (ctx == NULL) {
|
|
return ret;
|
|
}
|
|
|
|
/* clear out flags and reset min protocol version */
|
|
minProto = wolfSSL_CTX_get_min_proto_version(ctx);
|
|
wolfSSL_CTX_clear_options(ctx,
|
|
WOLFSSL_OP_NO_TLSv1 | WOLFSSL_OP_NO_TLSv1_1 |
|
|
WOLFSSL_OP_NO_TLSv1_2 | WOLFSSL_OP_NO_TLSv1_3);
|
|
wolfSSL_CTX_set_min_proto_version(ctx, minProto);
|
|
if (version != 0) {
|
|
ctx->maxProto = 0; /* turn max proto flag off */
|
|
return Set_CTX_max_proto_version(ctx, version);
|
|
}
|
|
|
|
/* when 0 is specified as version, try to find out the min version from
|
|
* the bottom to top of the protoverTbl.
|
|
*/
|
|
for (i = NUMBER_OF_PROTOCOLS -1; i >= 0; i--) {
|
|
ret = Set_CTX_max_proto_version(ctx, protoVerTbl[i]);
|
|
if (ret == WOLFSSL_SUCCESS) {
|
|
ctx->maxProto = 1; /* turn max proto flag on */
|
|
break;
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
static int Set_SSL_min_proto_version(WOLFSSL* ssl, int ver)
|
|
{
|
|
WOLFSSL_ENTER("Set_SSL_min_proto_version");
|
|
|
|
if (ssl == NULL) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
switch (ver) {
|
|
#ifndef NO_TLS
|
|
case SSL3_VERSION:
|
|
#if defined(WOLFSSL_ALLOW_SSLV3) && !defined(NO_OLD_TLS)
|
|
ssl->options.minDowngrade = SSLv3_MINOR;
|
|
break;
|
|
#endif
|
|
case TLS1_VERSION:
|
|
#ifdef WOLFSSL_ALLOW_TLSV10
|
|
ssl->options.minDowngrade = TLSv1_MINOR;
|
|
break;
|
|
#endif
|
|
case TLS1_1_VERSION:
|
|
#ifndef NO_OLD_TLS
|
|
ssl->options.minDowngrade = TLSv1_1_MINOR;
|
|
break;
|
|
#endif
|
|
case TLS1_2_VERSION:
|
|
#ifndef WOLFSSL_NO_TLS12
|
|
ssl->options.minDowngrade = TLSv1_2_MINOR;
|
|
break;
|
|
#endif
|
|
case TLS1_3_VERSION:
|
|
#ifdef WOLFSSL_TLS13
|
|
ssl->options.minDowngrade = TLSv1_3_MINOR;
|
|
break;
|
|
#endif
|
|
#endif
|
|
#ifdef WOLFSSL_DTLS
|
|
case DTLS1_VERSION:
|
|
#ifndef NO_OLD_TLS
|
|
ssl->options.minDowngrade = DTLS_MINOR;
|
|
break;
|
|
#endif
|
|
case DTLS1_2_VERSION:
|
|
ssl->options.minDowngrade = DTLSv1_2_MINOR;
|
|
break;
|
|
#endif
|
|
default:
|
|
WOLFSSL_MSG("Unrecognized protocol version or not compiled in");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
switch (ver) {
|
|
#ifndef NO_TLS
|
|
case TLS1_3_VERSION:
|
|
ssl->options.mask |= WOLFSSL_OP_NO_TLSv1_2;
|
|
FALL_THROUGH;
|
|
case TLS1_2_VERSION:
|
|
ssl->options.mask |= WOLFSSL_OP_NO_TLSv1_1;
|
|
FALL_THROUGH;
|
|
case TLS1_1_VERSION:
|
|
ssl->options.mask |= WOLFSSL_OP_NO_TLSv1;
|
|
FALL_THROUGH;
|
|
case TLS1_VERSION:
|
|
ssl->options.mask |= WOLFSSL_OP_NO_SSLv3;
|
|
break;
|
|
case SSL3_VERSION:
|
|
case SSL2_VERSION:
|
|
/* Nothing to do here */
|
|
break;
|
|
#endif
|
|
#ifdef WOLFSSL_DTLS
|
|
case DTLS1_VERSION:
|
|
case DTLS1_2_VERSION:
|
|
break;
|
|
#endif
|
|
default:
|
|
WOLFSSL_MSG("Unrecognized protocol version or not compiled in");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
return CheckSslMethodVersion(ssl->version.major, ssl->options.mask);
|
|
}
|
|
|
|
int wolfSSL_set_min_proto_version(WOLFSSL* ssl, int version)
|
|
{
|
|
int i;
|
|
int ret = WOLFSSL_FAILURE;;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_set_min_proto_version");
|
|
|
|
if (ssl == NULL) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
if (version != 0) {
|
|
return Set_SSL_min_proto_version(ssl, version);
|
|
}
|
|
|
|
/* when 0 is specified as version, try to find out the min version */
|
|
for (i= 0; (unsigned)i < NUMBER_OF_PROTOCOLS; i++) {
|
|
ret = Set_SSL_min_proto_version(ssl, protoVerTbl[i]);
|
|
if (ret == WOLFSSL_SUCCESS)
|
|
break;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int Set_SSL_max_proto_version(WOLFSSL* ssl, int ver)
|
|
{
|
|
|
|
WOLFSSL_ENTER("Set_SSL_max_proto_version");
|
|
|
|
if (!ssl) {
|
|
WOLFSSL_MSG("Bad parameter");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
switch (ver) {
|
|
case SSL2_VERSION:
|
|
WOLFSSL_MSG("wolfSSL does not support SSLv2");
|
|
return WOLFSSL_FAILURE;
|
|
#ifndef NO_TLS
|
|
case SSL3_VERSION:
|
|
ssl->options.mask |= WOLFSSL_OP_NO_TLSv1;
|
|
FALL_THROUGH;
|
|
case TLS1_VERSION:
|
|
ssl->options.mask |= WOLFSSL_OP_NO_TLSv1_1;
|
|
FALL_THROUGH;
|
|
case TLS1_1_VERSION:
|
|
ssl->options.mask |= WOLFSSL_OP_NO_TLSv1_2;
|
|
FALL_THROUGH;
|
|
case TLS1_2_VERSION:
|
|
ssl->options.mask |= WOLFSSL_OP_NO_TLSv1_3;
|
|
FALL_THROUGH;
|
|
case TLS1_3_VERSION:
|
|
/* Nothing to do here */
|
|
break;
|
|
#endif
|
|
#ifdef WOLFSSL_DTLS
|
|
case DTLS1_VERSION:
|
|
case DTLS1_2_VERSION:
|
|
break;
|
|
#endif
|
|
default:
|
|
WOLFSSL_MSG("Unrecognized protocol version or not compiled in");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
return CheckSslMethodVersion(ssl->version.major, ssl->options.mask);
|
|
}
|
|
|
|
int wolfSSL_set_max_proto_version(WOLFSSL* ssl, int version)
|
|
{
|
|
int i;
|
|
int ret = WOLFSSL_FAILURE;;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_set_max_proto_version");
|
|
|
|
if (ssl == NULL) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
if (version != 0) {
|
|
return Set_SSL_max_proto_version(ssl, version);
|
|
}
|
|
|
|
/* when 0 is specified as version, try to find out the min version from
|
|
* the bottom to top of the protoverTbl.
|
|
*/
|
|
for (i = NUMBER_OF_PROTOCOLS -1; i >= 0; i--) {
|
|
ret = Set_SSL_max_proto_version(ssl, protoVerTbl[i]);
|
|
if (ret == WOLFSSL_SUCCESS)
|
|
break;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int GetMinProtoVersion(int minDowngrade)
|
|
{
|
|
int ret;
|
|
|
|
switch (minDowngrade) {
|
|
#ifndef NO_OLD_TLS
|
|
#ifdef WOLFSSL_ALLOW_SSLV3
|
|
case SSLv3_MINOR:
|
|
ret = SSL3_VERSION;
|
|
break;
|
|
#endif
|
|
#ifdef WOLFSSL_ALLOW_TLSV10
|
|
case TLSv1_MINOR:
|
|
ret = TLS1_VERSION;
|
|
break;
|
|
#endif
|
|
case TLSv1_1_MINOR:
|
|
ret = TLS1_1_VERSION;
|
|
break;
|
|
#endif
|
|
#ifndef WOLFSSL_NO_TLS12
|
|
case TLSv1_2_MINOR:
|
|
ret = TLS1_2_VERSION;
|
|
break;
|
|
#endif
|
|
#ifdef WOLFSSL_TLS13
|
|
case TLSv1_3_MINOR:
|
|
ret = TLS1_3_VERSION;
|
|
break;
|
|
#endif
|
|
default:
|
|
ret = 0;
|
|
break;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int wolfSSL_CTX_get_min_proto_version(WOLFSSL_CTX* ctx)
|
|
{
|
|
int ret = 0;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_CTX_get_min_proto_version");
|
|
|
|
if (ctx != NULL) {
|
|
if (ctx->minProto) {
|
|
ret = 0;
|
|
}
|
|
else {
|
|
ret = GetMinProtoVersion(ctx->minDowngrade);
|
|
}
|
|
}
|
|
else {
|
|
ret = GetMinProtoVersion(WOLFSSL_MIN_DOWNGRADE);
|
|
}
|
|
|
|
WOLFSSL_LEAVE("wolfSSL_CTX_get_min_proto_version", ret);
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
/* returns the maximum allowed protocol version given the 'options' used
|
|
* returns WOLFSSL_FATAL_ERROR on no match */
|
|
static int GetMaxProtoVersion(long options)
|
|
{
|
|
#ifndef NO_TLS
|
|
#ifdef WOLFSSL_TLS13
|
|
if (!(options & WOLFSSL_OP_NO_TLSv1_3))
|
|
return TLS1_3_VERSION;
|
|
#endif
|
|
#ifndef WOLFSSL_NO_TLS12
|
|
if (!(options & WOLFSSL_OP_NO_TLSv1_2))
|
|
return TLS1_2_VERSION;
|
|
#endif
|
|
#ifndef NO_OLD_TLS
|
|
if (!(options & WOLFSSL_OP_NO_TLSv1_1))
|
|
return TLS1_1_VERSION;
|
|
#ifdef WOLFSSL_ALLOW_TLSV10
|
|
if (!(options & WOLFSSL_OP_NO_TLSv1))
|
|
return TLS1_VERSION;
|
|
#endif
|
|
#ifdef WOLFSSL_ALLOW_SSLV3
|
|
if (!(options & WOLFSSL_OP_NO_SSLv3))
|
|
return SSL3_VERSION;
|
|
#endif
|
|
#endif
|
|
#else
|
|
(void)options;
|
|
#endif /* NO_TLS */
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
|
|
|
|
/* returns the maximum protocol version for 'ctx' */
|
|
int wolfSSL_CTX_get_max_proto_version(WOLFSSL_CTX* ctx)
|
|
{
|
|
int ret = 0;
|
|
long options = 0; /* default to nothing set */
|
|
|
|
WOLFSSL_ENTER("wolfSSL_CTX_get_max_proto_version");
|
|
|
|
if (ctx != NULL) {
|
|
options = wolfSSL_CTX_get_options(ctx);
|
|
}
|
|
|
|
if ((ctx != NULL) && ctx->maxProto) {
|
|
ret = 0;
|
|
}
|
|
else {
|
|
ret = GetMaxProtoVersion(options);
|
|
}
|
|
|
|
WOLFSSL_LEAVE("wolfSSL_CTX_get_max_proto_version", ret);
|
|
|
|
if (ret == WOLFSSL_FATAL_ERROR) {
|
|
WOLFSSL_MSG("Error getting max proto version");
|
|
ret = 0; /* setting ret to 0 to match compat return */
|
|
}
|
|
return ret;
|
|
}
|
|
#endif /* OPENSSL_EXTRA */
|
|
|
|
#if defined(OPENSSL_EXTRA) || defined(WOLFSSL_WPAS_SMALL) || \
|
|
defined(HAVE_SECRET_CALLBACK)
|
|
#if !defined(NO_WOLFSSL_CLIENT)
|
|
/* Return the amount of random bytes copied over or error case.
|
|
* ssl : ssl struct after handshake
|
|
* out : buffer to hold random bytes
|
|
* outSz : either 0 (return max buffer sz) or size of out buffer
|
|
*/
|
|
size_t wolfSSL_get_client_random(const WOLFSSL* ssl, unsigned char* out,
|
|
size_t outSz)
|
|
{
|
|
size_t size;
|
|
|
|
/* return max size of buffer */
|
|
if (outSz == 0) {
|
|
return RAN_LEN;
|
|
}
|
|
|
|
if (ssl == NULL || out == NULL) {
|
|
return 0;
|
|
}
|
|
|
|
if (ssl->arrays == NULL) {
|
|
WOLFSSL_MSG("Arrays struct not saved after handshake");
|
|
return 0;
|
|
}
|
|
|
|
if (outSz > RAN_LEN) {
|
|
size = RAN_LEN;
|
|
}
|
|
else {
|
|
size = outSz;
|
|
}
|
|
|
|
XMEMCPY(out, ssl->arrays->clientRandom, size);
|
|
return size;
|
|
}
|
|
#endif /* !NO_WOLFSSL_CLIENT */
|
|
#endif /* OPENSSL_EXTRA || WOLFSSL_WPAS_SMALL || HAVE_SECRET_CALLBACK */
|
|
|
|
#ifdef OPENSSL_EXTRA
|
|
|
|
unsigned long wolfSSLeay(void)
|
|
{
|
|
return SSLEAY_VERSION_NUMBER;
|
|
}
|
|
|
|
unsigned long wolfSSL_OpenSSL_version_num(void)
|
|
{
|
|
return OPENSSL_VERSION_NUMBER;
|
|
}
|
|
|
|
const char* wolfSSLeay_version(int type)
|
|
{
|
|
(void)type;
|
|
#if defined(OPENSSL_VERSION_NUMBER) && OPENSSL_VERSION_NUMBER >= 0x10100000L
|
|
return wolfSSL_OpenSSL_version(type);
|
|
#else
|
|
return wolfSSL_OpenSSL_version();
|
|
#endif
|
|
}
|
|
#endif /* OPENSSL_EXTRA */
|
|
|
|
#ifdef OPENSSL_EXTRA
|
|
void wolfSSL_ERR_free_strings(void)
|
|
{
|
|
/* handled internally */
|
|
}
|
|
|
|
void wolfSSL_cleanup_all_ex_data(void)
|
|
{
|
|
/* nothing to do here */
|
|
}
|
|
|
|
#endif /* OPENSSL_EXTRA */
|
|
|
|
#if defined(OPENSSL_EXTRA) || defined(DEBUG_WOLFSSL_VERBOSE) || \
|
|
defined(HAVE_CURL)
|
|
void wolfSSL_ERR_clear_error(void)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_ERR_clear_error");
|
|
#if defined(OPENSSL_EXTRA) || defined(DEBUG_WOLFSSL_VERBOSE)
|
|
wc_ClearErrorNodes();
|
|
#endif
|
|
}
|
|
#endif
|
|
|
|
#if defined(OPENSSL_EXTRA) || defined(WOLFSSL_WPAS_SMALL)
|
|
int wolfSSL_clear(WOLFSSL* ssl)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_clear");
|
|
|
|
if (ssl == NULL) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
if (!ssl->options.handShakeDone) {
|
|
/* Only reset the session if we didn't complete a handshake */
|
|
wolfSSL_FreeSession(ssl->ctx, ssl->session);
|
|
ssl->session = wolfSSL_NewSession(ssl->heap);
|
|
if (ssl->session == NULL) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
}
|
|
|
|
/* reset error */
|
|
ssl->error = 0;
|
|
|
|
/* reset option bits */
|
|
ssl->options.isClosed = 0;
|
|
ssl->options.connReset = 0;
|
|
ssl->options.sentNotify = 0;
|
|
ssl->options.closeNotify = 0;
|
|
ssl->options.sendVerify = 0;
|
|
ssl->options.serverState = NULL_STATE;
|
|
ssl->options.clientState = NULL_STATE;
|
|
ssl->options.connectState = CONNECT_BEGIN;
|
|
ssl->options.acceptState = ACCEPT_BEGIN;
|
|
ssl->options.handShakeState = NULL_STATE;
|
|
ssl->options.handShakeDone = 0;
|
|
ssl->options.processReply = 0; /* doProcessInit */
|
|
ssl->options.havePeerVerify = 0;
|
|
ssl->options.havePeerCert = 0;
|
|
ssl->options.peerAuthGood = 0;
|
|
ssl->options.tls1_3 = 0;
|
|
ssl->options.haveSessionId = 0;
|
|
ssl->options.tls = 0;
|
|
ssl->options.tls1_1 = 0;
|
|
#ifdef WOLFSSL_DTLS
|
|
ssl->options.dtlsStateful = 0;
|
|
#endif
|
|
#if defined(HAVE_SESSION_TICKET) || !defined(NO_PSK)
|
|
ssl->options.noPskDheKe = 0;
|
|
#ifdef HAVE_SUPPORTED_CURVES
|
|
ssl->options.onlyPskDheKe = 0;
|
|
#endif
|
|
#endif
|
|
#ifdef HAVE_SESSION_TICKET
|
|
#ifdef WOLFSSL_TLS13
|
|
ssl->options.ticketsSent = 0;
|
|
#endif
|
|
ssl->options.rejectTicket = 0;
|
|
#endif
|
|
#ifdef WOLFSSL_EARLY_DATA
|
|
ssl->earlyData = no_early_data;
|
|
ssl->earlyDataSz = 0;
|
|
#endif
|
|
|
|
#if defined(HAVE_TLS_EXTENSIONS) && !defined(NO_TLS)
|
|
TLSX_FreeAll(ssl->extensions, ssl->heap);
|
|
ssl->extensions = NULL;
|
|
#endif
|
|
|
|
if (ssl->keys.encryptionOn) {
|
|
ForceZero(ssl->buffers.inputBuffer.buffer -
|
|
ssl->buffers.inputBuffer.offset,
|
|
ssl->buffers.inputBuffer.bufferSize);
|
|
#ifdef WOLFSSL_CHECK_MEM_ZERO
|
|
wc_MemZero_Check(ssl->buffers.inputBuffer.buffer -
|
|
ssl->buffers.inputBuffer.offset,
|
|
ssl->buffers.inputBuffer.bufferSize);
|
|
#endif
|
|
}
|
|
ssl->keys.encryptionOn = 0;
|
|
XMEMSET(&ssl->msgsReceived, 0, sizeof(ssl->msgsReceived));
|
|
|
|
if (InitSSL_Suites(ssl) != WOLFSSL_SUCCESS)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
if (InitHandshakeHashes(ssl) != 0)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
#ifdef KEEP_PEER_CERT
|
|
FreeX509(&ssl->peerCert);
|
|
InitX509(&ssl->peerCert, 0, ssl->heap);
|
|
#endif
|
|
|
|
#ifdef WOLFSSL_QUIC
|
|
wolfSSL_quic_clear(ssl);
|
|
#endif
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
#endif /* OPENSSL_EXTRA || WOLFSSL_WPAS_SMALL */
|
|
|
|
#if defined(OPENSSL_EXTRA) || defined(HAVE_WEBSERVER) || defined(HAVE_MEMCACHED)
|
|
long wolfSSL_CTX_set_mode(WOLFSSL_CTX* ctx, long mode)
|
|
{
|
|
/* WOLFSSL_MODE_ACCEPT_MOVING_WRITE_BUFFER is wolfSSL default mode */
|
|
|
|
WOLFSSL_ENTER("wolfSSL_CTX_set_mode");
|
|
switch(mode) {
|
|
case SSL_MODE_ENABLE_PARTIAL_WRITE:
|
|
ctx->partialWrite = 1;
|
|
break;
|
|
#if defined(OPENSSL_ALL) || defined(WOLFSSL_QT)
|
|
case SSL_MODE_RELEASE_BUFFERS:
|
|
WOLFSSL_MSG("SSL_MODE_RELEASE_BUFFERS not implemented.");
|
|
break;
|
|
#endif
|
|
case SSL_MODE_AUTO_RETRY:
|
|
ctx->autoRetry = 1;
|
|
break;
|
|
default:
|
|
WOLFSSL_MSG("Mode Not Implemented");
|
|
}
|
|
|
|
/* SSL_MODE_AUTO_RETRY
|
|
* Should not return -1 with renegotiation on read/write */
|
|
|
|
return mode;
|
|
}
|
|
|
|
long wolfSSL_CTX_clear_mode(WOLFSSL_CTX* ctx, long mode)
|
|
{
|
|
/* WOLFSSL_MODE_ACCEPT_MOVING_WRITE_BUFFER is wolfSSL default mode */
|
|
|
|
WOLFSSL_ENTER("wolfSSL_CTX_clear_mode");
|
|
switch(mode) {
|
|
case SSL_MODE_ENABLE_PARTIAL_WRITE:
|
|
ctx->partialWrite = 0;
|
|
break;
|
|
#if defined(OPENSSL_ALL) || defined(WOLFSSL_QT)
|
|
case SSL_MODE_RELEASE_BUFFERS:
|
|
WOLFSSL_MSG("SSL_MODE_RELEASE_BUFFERS not implemented.");
|
|
break;
|
|
#endif
|
|
case SSL_MODE_AUTO_RETRY:
|
|
ctx->autoRetry = 0;
|
|
break;
|
|
default:
|
|
WOLFSSL_MSG("Mode Not Implemented");
|
|
}
|
|
|
|
/* SSL_MODE_AUTO_RETRY
|
|
* Should not return -1 with renegotiation on read/write */
|
|
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
#ifdef WOLFSSL_SESSION_ID_CTX
|
|
/* Storing app session context id, this value is inherited by WOLFSSL
|
|
* objects created from WOLFSSL_CTX. Any session that is imported with a
|
|
* different session context id will be rejected.
|
|
*
|
|
* ctx structure to set context in
|
|
* sid_ctx value of context to set
|
|
* sid_ctx_len length of sid_ctx buffer
|
|
*
|
|
* Returns WOLFSSL_SUCCESS in success case and WOLFSSL_FAILURE when failing
|
|
*/
|
|
int wolfSSL_CTX_set_session_id_context(WOLFSSL_CTX* ctx,
|
|
const unsigned char* sid_ctx,
|
|
unsigned int sid_ctx_len)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_set_session_id_context");
|
|
|
|
/* No application specific context needed for wolfSSL */
|
|
if (sid_ctx_len > ID_LEN || ctx == NULL || sid_ctx == NULL) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
XMEMCPY(ctx->sessionCtx, sid_ctx, sid_ctx_len);
|
|
ctx->sessionCtxSz = (byte)sid_ctx_len;
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
|
|
|
|
/* Storing app session context id. Any session that is imported with a
|
|
* different session context id will be rejected.
|
|
*
|
|
* ssl structure to set context in
|
|
* id value of context to set
|
|
* len length of sid_ctx buffer
|
|
*
|
|
* Returns WOLFSSL_SUCCESS in success case and WOLFSSL_FAILURE when failing
|
|
*/
|
|
int wolfSSL_set_session_id_context(WOLFSSL* ssl, const unsigned char* id,
|
|
unsigned int len)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_set_session_id_context");
|
|
|
|
if (len > ID_LEN || ssl == NULL || id == NULL) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
XMEMCPY(ssl->sessionCtx, id, len);
|
|
ssl->sessionCtxSz = (byte)len;
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
#endif
|
|
|
|
#ifdef OPENSSL_EXTRA
|
|
|
|
#ifndef NO_WOLFSSL_STUB
|
|
long wolfSSL_SSL_get_mode(WOLFSSL* ssl)
|
|
{
|
|
/* TODO: */
|
|
(void)ssl;
|
|
WOLFSSL_STUB("SSL_get_mode");
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
#ifndef NO_WOLFSSL_STUB
|
|
long wolfSSL_CTX_get_mode(WOLFSSL_CTX* ctx)
|
|
{
|
|
/* TODO: */
|
|
(void)ctx;
|
|
WOLFSSL_STUB("SSL_CTX_get_mode");
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
#ifndef NO_WOLFSSL_STUB
|
|
void wolfSSL_CTX_set_default_read_ahead(WOLFSSL_CTX* ctx, int m)
|
|
{
|
|
/* TODO: maybe? */
|
|
(void)ctx;
|
|
(void)m;
|
|
WOLFSSL_STUB("SSL_CTX_set_default_read_ahead");
|
|
}
|
|
#endif
|
|
|
|
|
|
long wolfSSL_CTX_sess_get_cache_size(WOLFSSL_CTX* ctx)
|
|
{
|
|
(void)ctx;
|
|
#ifndef NO_SESSION_CACHE
|
|
return (long)(SESSIONS_PER_ROW * SESSION_ROWS);
|
|
#else
|
|
return 0;
|
|
#endif
|
|
}
|
|
|
|
|
|
/* returns the unsigned error value and increments the pointer into the
|
|
* error queue.
|
|
*
|
|
* file pointer to file name
|
|
* line gets set to line number of error when not NULL
|
|
*/
|
|
unsigned long wolfSSL_ERR_get_error_line(const char** file, int* line)
|
|
{
|
|
#ifdef WOLFSSL_HAVE_ERROR_QUEUE
|
|
int ret = wc_PullErrorNode(file, NULL, line);
|
|
if (ret < 0) {
|
|
if (ret == BAD_STATE_E) return 0; /* no errors in queue */
|
|
WOLFSSL_MSG("Issue getting error node");
|
|
WOLFSSL_LEAVE("wolfSSL_ERR_get_error_line", ret);
|
|
ret = 0 - ret; /* return absolute value of error */
|
|
|
|
/* panic and try to clear out nodes */
|
|
wc_ClearErrorNodes();
|
|
}
|
|
return (unsigned long)ret;
|
|
#else
|
|
(void)file;
|
|
(void)line;
|
|
|
|
return 0;
|
|
#endif
|
|
}
|
|
|
|
|
|
#if (defined(DEBUG_WOLFSSL) || defined(OPENSSL_EXTRA)) && \
|
|
(!defined(_WIN32) && !defined(NO_ERROR_QUEUE))
|
|
static const char WOLFSSL_SYS_ACCEPT_T[] = "accept";
|
|
static const char WOLFSSL_SYS_BIND_T[] = "bind";
|
|
static const char WOLFSSL_SYS_CONNECT_T[] = "connect";
|
|
static const char WOLFSSL_SYS_FOPEN_T[] = "fopen";
|
|
static const char WOLFSSL_SYS_FREAD_T[] = "fread";
|
|
static const char WOLFSSL_SYS_GETADDRINFO_T[] = "getaddrinfo";
|
|
static const char WOLFSSL_SYS_GETSOCKOPT_T[] = "getsockopt";
|
|
static const char WOLFSSL_SYS_GETSOCKNAME_T[] = "getsockname";
|
|
static const char WOLFSSL_SYS_GETHOSTBYNAME_T[] = "gethostbyname";
|
|
static const char WOLFSSL_SYS_GETNAMEINFO_T[] = "getnameinfo";
|
|
static const char WOLFSSL_SYS_GETSERVBYNAME_T[] = "getservbyname";
|
|
static const char WOLFSSL_SYS_IOCTLSOCKET_T[] = "ioctlsocket";
|
|
static const char WOLFSSL_SYS_LISTEN_T[] = "listen";
|
|
static const char WOLFSSL_SYS_OPENDIR_T[] = "opendir";
|
|
static const char WOLFSSL_SYS_SETSOCKOPT_T[] = "setsockopt";
|
|
static const char WOLFSSL_SYS_SOCKET_T[] = "socket";
|
|
|
|
/* switch with int mapped to function name for compatibility */
|
|
static const char* wolfSSL_ERR_sys_func(int fun)
|
|
{
|
|
switch (fun) {
|
|
case WOLFSSL_SYS_ACCEPT: return WOLFSSL_SYS_ACCEPT_T;
|
|
case WOLFSSL_SYS_BIND: return WOLFSSL_SYS_BIND_T;
|
|
case WOLFSSL_SYS_CONNECT: return WOLFSSL_SYS_CONNECT_T;
|
|
case WOLFSSL_SYS_FOPEN: return WOLFSSL_SYS_FOPEN_T;
|
|
case WOLFSSL_SYS_FREAD: return WOLFSSL_SYS_FREAD_T;
|
|
case WOLFSSL_SYS_GETADDRINFO: return WOLFSSL_SYS_GETADDRINFO_T;
|
|
case WOLFSSL_SYS_GETSOCKOPT: return WOLFSSL_SYS_GETSOCKOPT_T;
|
|
case WOLFSSL_SYS_GETSOCKNAME: return WOLFSSL_SYS_GETSOCKNAME_T;
|
|
case WOLFSSL_SYS_GETHOSTBYNAME: return WOLFSSL_SYS_GETHOSTBYNAME_T;
|
|
case WOLFSSL_SYS_GETNAMEINFO: return WOLFSSL_SYS_GETNAMEINFO_T;
|
|
case WOLFSSL_SYS_GETSERVBYNAME: return WOLFSSL_SYS_GETSERVBYNAME_T;
|
|
case WOLFSSL_SYS_IOCTLSOCKET: return WOLFSSL_SYS_IOCTLSOCKET_T;
|
|
case WOLFSSL_SYS_LISTEN: return WOLFSSL_SYS_LISTEN_T;
|
|
case WOLFSSL_SYS_OPENDIR: return WOLFSSL_SYS_OPENDIR_T;
|
|
case WOLFSSL_SYS_SETSOCKOPT: return WOLFSSL_SYS_SETSOCKOPT_T;
|
|
case WOLFSSL_SYS_SOCKET: return WOLFSSL_SYS_SOCKET_T;
|
|
default:
|
|
return "NULL";
|
|
}
|
|
}
|
|
#endif /* DEBUG_WOLFSSL */
|
|
|
|
|
|
void wolfSSL_ERR_put_error(int lib, int fun, int err, const char* file,
|
|
int line)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_ERR_put_error");
|
|
|
|
#if !defined(DEBUG_WOLFSSL) && !defined(OPENSSL_EXTRA)
|
|
(void)fun;
|
|
(void)err;
|
|
(void)file;
|
|
(void)line;
|
|
WOLFSSL_MSG("Not compiled in debug mode");
|
|
#elif defined(OPENSSL_EXTRA) && \
|
|
(defined(_WIN32) || defined(NO_ERROR_QUEUE))
|
|
(void)fun;
|
|
(void)file;
|
|
(void)line;
|
|
WOLFSSL_ERROR(err);
|
|
#else
|
|
WOLFSSL_ERROR_LINE(err, wolfSSL_ERR_sys_func(fun), (unsigned int)line,
|
|
file, NULL);
|
|
#endif
|
|
(void)lib;
|
|
}
|
|
|
|
|
|
/* Similar to wolfSSL_ERR_get_error_line but takes in a flags argument for
|
|
* more flexibility.
|
|
*
|
|
* file output pointer to file where error happened
|
|
* line output to line number of error
|
|
* data output data. Is a string if ERR_TXT_STRING flag is used
|
|
* flags output format of output
|
|
*
|
|
* Returns the error value or 0 if no errors are in the queue
|
|
*/
|
|
unsigned long wolfSSL_ERR_get_error_line_data(const char** file, int* line,
|
|
const char** data, int *flags)
|
|
{
|
|
#ifdef WOLFSSL_HAVE_ERROR_QUEUE
|
|
int ret;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_ERR_get_error_line_data");
|
|
|
|
if (flags != NULL)
|
|
*flags = ERR_TXT_STRING; /* Clear the flags */
|
|
|
|
ret = wc_PullErrorNode(file, data, line);
|
|
if (ret < 0) {
|
|
if (ret == BAD_STATE_E) return 0; /* no errors in queue */
|
|
WOLFSSL_MSG("Error with pulling error node!");
|
|
WOLFSSL_LEAVE("wolfSSL_ERR_get_error_line_data", ret);
|
|
ret = 0 - ret; /* return absolute value of error */
|
|
|
|
/* panic and try to clear out nodes */
|
|
wc_ClearErrorNodes();
|
|
}
|
|
|
|
return (unsigned long)ret;
|
|
#else
|
|
WOLFSSL_ENTER("wolfSSL_ERR_get_error_line_data");
|
|
WOLFSSL_MSG("Error queue turned off, can not get error line");
|
|
(void)file;
|
|
(void)line;
|
|
(void)data;
|
|
(void)flags;
|
|
return 0;
|
|
#endif
|
|
}
|
|
|
|
#endif /* OPENSSL_EXTRA */
|
|
|
|
|
|
#if (defined(KEEP_PEER_CERT) && defined(SESSION_CERTS)) || \
|
|
(defined(OPENSSL_EXTRA) && defined(SESSION_CERTS))
|
|
/* Decode the X509 DER encoded certificate into a WOLFSSL_X509 object.
|
|
*
|
|
* x509 WOLFSSL_X509 object to decode into.
|
|
* in X509 DER data.
|
|
* len Length of the X509 DER data.
|
|
* returns the new certificate on success, otherwise NULL.
|
|
*/
|
|
static int DecodeToX509(WOLFSSL_X509* x509, const byte* in, int len)
|
|
{
|
|
int ret;
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
DecodedCert* cert;
|
|
#else
|
|
DecodedCert cert[1];
|
|
#endif
|
|
if (x509 == NULL || in == NULL || len <= 0)
|
|
return BAD_FUNC_ARG;
|
|
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
cert = (DecodedCert*)XMALLOC(sizeof(DecodedCert), NULL,
|
|
DYNAMIC_TYPE_DCERT);
|
|
if (cert == NULL)
|
|
return MEMORY_E;
|
|
#endif
|
|
|
|
/* Create a DecodedCert object and copy fields into WOLFSSL_X509 object.
|
|
*/
|
|
InitDecodedCert(cert, (byte*)in, len, NULL);
|
|
if ((ret = ParseCertRelative(cert, CERT_TYPE, 0, NULL)) == 0) {
|
|
/* Check if x509 was not previously initialized by wolfSSL_X509_new() */
|
|
if (x509->dynamicMemory != TRUE)
|
|
InitX509(x509, 0, NULL);
|
|
ret = CopyDecodedToX509(x509, cert);
|
|
}
|
|
FreeDecodedCert(cert);
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
XFREE(cert, NULL, DYNAMIC_TYPE_DCERT);
|
|
#endif
|
|
|
|
return ret;
|
|
}
|
|
#endif /* (KEEP_PEER_CERT & SESSION_CERTS) || (OPENSSL_EXTRA & SESSION_CERTS) */
|
|
|
|
|
|
#ifdef KEEP_PEER_CERT
|
|
WOLFSSL_ABI
|
|
WOLFSSL_X509* wolfSSL_get_peer_certificate(WOLFSSL* ssl)
|
|
{
|
|
WOLFSSL_X509* ret = NULL;
|
|
WOLFSSL_ENTER("wolfSSL_get_peer_certificate");
|
|
if (ssl != NULL) {
|
|
if (ssl->peerCert.issuer.sz)
|
|
ret = wolfSSL_X509_dup(&ssl->peerCert);
|
|
#ifdef SESSION_CERTS
|
|
else if (ssl->session->chain.count > 0) {
|
|
if (DecodeToX509(&ssl->peerCert,
|
|
ssl->session->chain.certs[0].buffer,
|
|
ssl->session->chain.certs[0].length) == 0) {
|
|
ret = wolfSSL_X509_dup(&ssl->peerCert);
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
WOLFSSL_LEAVE("wolfSSL_get_peer_certificate", ret != NULL);
|
|
return ret;
|
|
}
|
|
|
|
#endif /* KEEP_PEER_CERT */
|
|
|
|
#if defined(SESSION_CERTS) && defined(OPENSSL_EXTRA)
|
|
/* Return stack of peer certs.
|
|
* Caller does not need to free return. The stack is Free'd when WOLFSSL* ssl is.
|
|
*/
|
|
WOLF_STACK_OF(WOLFSSL_X509)* wolfSSL_get_peer_cert_chain(const WOLFSSL* ssl)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_get_peer_cert_chain");
|
|
|
|
if (ssl == NULL)
|
|
return NULL;
|
|
|
|
/* Try to populate if NULL or empty */
|
|
if (ssl->peerCertChain == NULL ||
|
|
wolfSSL_sk_X509_num(ssl->peerCertChain) == 0)
|
|
wolfSSL_set_peer_cert_chain((WOLFSSL*) ssl);
|
|
return ssl->peerCertChain;
|
|
}
|
|
|
|
#ifndef WOLFSSL_QT
|
|
static int x509GetIssuerFromCM(WOLFSSL_X509 **issuer, WOLFSSL_CERT_MANAGER* cm,
|
|
WOLFSSL_X509 *x);
|
|
/**
|
|
* Recursively push the issuer CA chain onto the stack
|
|
* @param cm The cert manager that is queried for the issuer
|
|
* @param x This cert's issuer will be queried in cm
|
|
* @param sk The issuer is pushed onto this stack
|
|
* @return WOLFSSL_SUCCESS on success
|
|
* WOLFSSL_FAILURE on no issuer found
|
|
* WOLFSSL_FATAL_ERROR on a fatal error
|
|
*/
|
|
static int PushCAx509Chain(WOLFSSL_CERT_MANAGER* cm,
|
|
WOLFSSL_X509 *x, WOLFSSL_STACK* sk)
|
|
{
|
|
WOLFSSL_X509* issuer[MAX_CHAIN_DEPTH];
|
|
int i;
|
|
int push = 1;
|
|
int ret = WOLFSSL_SUCCESS;
|
|
|
|
for (i = 0; i < MAX_CHAIN_DEPTH; i++) {
|
|
if (x509GetIssuerFromCM(&issuer[i], cm, x)
|
|
!= WOLFSSL_SUCCESS)
|
|
break;
|
|
x = issuer[i];
|
|
}
|
|
if (i == 0) /* No further chain found */
|
|
return WOLFSSL_FAILURE;
|
|
i--;
|
|
for (; i >= 0; i--) {
|
|
if (push) {
|
|
if (wolfSSL_sk_X509_push(sk, issuer[i]) != WOLFSSL_SUCCESS) {
|
|
wolfSSL_X509_free(issuer[i]);
|
|
ret = WOLFSSL_FATAL_ERROR;
|
|
push = 0; /* Free the rest of the unpushed certs */
|
|
}
|
|
}
|
|
else {
|
|
wolfSSL_X509_free(issuer[i]);
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
#endif /* !WOLFSSL_QT */
|
|
|
|
/* Builds up and creates a stack of peer certificates for ssl->peerCertChain
|
|
based off of the ssl session chain. Attempts to place CA certificates
|
|
at the bottom of the stack. Returns stack of WOLFSSL_X509 certs or
|
|
NULL on failure */
|
|
WOLF_STACK_OF(WOLFSSL_X509)* wolfSSL_set_peer_cert_chain(WOLFSSL* ssl)
|
|
{
|
|
WOLFSSL_STACK* sk;
|
|
WOLFSSL_X509* x509;
|
|
int i = 0;
|
|
int ret;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_set_peer_cert_chain");
|
|
if ((ssl == NULL) || (ssl->session->chain.count == 0))
|
|
return NULL;
|
|
|
|
sk = wolfSSL_sk_X509_new_null();
|
|
i = ssl->session->chain.count-1;
|
|
for (; i >= 0; i--) {
|
|
x509 = wolfSSL_X509_new();
|
|
if (x509 == NULL) {
|
|
WOLFSSL_MSG("Error Creating X509");
|
|
wolfSSL_sk_X509_pop_free(sk, NULL);
|
|
return NULL;
|
|
}
|
|
ret = DecodeToX509(x509, ssl->session->chain.certs[i].buffer,
|
|
ssl->session->chain.certs[i].length);
|
|
#if !defined(WOLFSSL_QT)
|
|
if (ret == 0 && i == ssl->session->chain.count-1) {
|
|
/* On the last element in the chain try to add the CA chain
|
|
* first if we have one for this cert */
|
|
SSL_CM_WARNING(ssl);
|
|
if (PushCAx509Chain(SSL_CM(ssl), x509, sk)
|
|
== WOLFSSL_FATAL_ERROR) {
|
|
ret = WOLFSSL_FATAL_ERROR;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
if (ret != 0 || wolfSSL_sk_X509_push(sk, x509) != WOLFSSL_SUCCESS) {
|
|
WOLFSSL_MSG("Error decoding cert");
|
|
wolfSSL_X509_free(x509);
|
|
wolfSSL_sk_X509_pop_free(sk, NULL);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
if (sk == NULL) {
|
|
WOLFSSL_MSG("Null session chain");
|
|
}
|
|
#if defined(OPENSSL_ALL)
|
|
else if (ssl->options.side == WOLFSSL_SERVER_END) {
|
|
/* to be compliant with openssl
|
|
first element is kept as peer cert on server side.*/
|
|
wolfSSL_sk_X509_pop(sk);
|
|
}
|
|
#endif
|
|
if (ssl->peerCertChain != NULL)
|
|
wolfSSL_sk_X509_pop_free(ssl->peerCertChain, NULL);
|
|
/* This is Free'd when ssl is Free'd */
|
|
ssl->peerCertChain = sk;
|
|
return sk;
|
|
}
|
|
#endif /* SESSION_CERTS && OPENSSL_EXTRA */
|
|
|
|
#ifndef NO_CERTS
|
|
#if defined(OPENSSL_EXTRA) || defined(WOLFSSL_WPAS_SMALL)
|
|
|
|
/* create a generic wolfSSL stack node
|
|
* returns a new WOLFSSL_STACK structure on success */
|
|
WOLFSSL_STACK* wolfSSL_sk_new_node(void* heap)
|
|
{
|
|
WOLFSSL_STACK* sk;
|
|
WOLFSSL_ENTER("wolfSSL_sk_new_node");
|
|
|
|
sk = (WOLFSSL_STACK*)XMALLOC(sizeof(WOLFSSL_STACK), heap,
|
|
DYNAMIC_TYPE_OPENSSL);
|
|
if (sk != NULL) {
|
|
XMEMSET(sk, 0, sizeof(*sk));
|
|
sk->heap = heap;
|
|
}
|
|
|
|
return sk;
|
|
}
|
|
|
|
/* free's node but does not free internal data such as in->data.x509 */
|
|
void wolfSSL_sk_free_node(WOLFSSL_STACK* in)
|
|
{
|
|
if (in != NULL) {
|
|
XFREE(in, in->heap, DYNAMIC_TYPE_OPENSSL);
|
|
}
|
|
}
|
|
|
|
/* pushes node "in" onto "stack" and returns pointer to the new stack on success
|
|
* also handles internal "num" for number of nodes on stack
|
|
* return WOLFSSL_SUCCESS on success
|
|
*/
|
|
int wolfSSL_sk_push_node(WOLFSSL_STACK** stack, WOLFSSL_STACK* in)
|
|
{
|
|
if (stack == NULL || in == NULL) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
if (*stack == NULL) {
|
|
in->num = 1;
|
|
*stack = in;
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
in->num = (*stack)->num + 1;
|
|
in->next = *stack;
|
|
*stack = in;
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
#if defined(OPENSSL_ALL) || defined(WOLFSSL_QT)
|
|
static WC_INLINE int compare_WOLFSSL_CIPHER(
|
|
WOLFSSL_CIPHER *a,
|
|
WOLFSSL_CIPHER *b)
|
|
{
|
|
if ((a->cipherSuite0 == b->cipherSuite0) &&
|
|
(a->cipherSuite == b->cipherSuite) &&
|
|
(a->ssl == b->ssl) &&
|
|
(XMEMCMP(a->description, b->description, sizeof a->description) == 0) &&
|
|
(a->offset == b->offset) &&
|
|
(a->in_stack == b->in_stack) &&
|
|
(a->bits == b->bits))
|
|
return 0;
|
|
else
|
|
return -1;
|
|
}
|
|
#endif /* OPENSSL_ALL || WOLFSSL_QT */
|
|
|
|
|
|
/* return 1 on success 0 on fail */
|
|
int wolfSSL_sk_push(WOLFSSL_STACK* sk, const void *data)
|
|
{
|
|
WOLFSSL_STACK* node;
|
|
#if defined(OPENSSL_ALL) || defined(WOLFSSL_QT)
|
|
WOLFSSL_CIPHER ciph;
|
|
#endif
|
|
WOLFSSL_ENTER("wolfSSL_sk_push");
|
|
|
|
if (!sk) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
/* Check if empty data */
|
|
switch (sk->type) {
|
|
case STACK_TYPE_CIPHER:
|
|
#if defined(OPENSSL_ALL) || defined(WOLFSSL_QT)
|
|
/* check if entire struct is zero */
|
|
XMEMSET(&ciph, 0, sizeof(WOLFSSL_CIPHER));
|
|
if (compare_WOLFSSL_CIPHER(&sk->data.cipher, &ciph) == 0) {
|
|
sk->data.cipher = *(WOLFSSL_CIPHER*)data;
|
|
sk->num = 1;
|
|
if (sk->hash_fn) {
|
|
sk->hash = sk->hash_fn(&sk->data.cipher);
|
|
}
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
break;
|
|
#endif
|
|
case STACK_TYPE_X509:
|
|
case STACK_TYPE_GEN_NAME:
|
|
case STACK_TYPE_BIO:
|
|
case STACK_TYPE_OBJ:
|
|
case STACK_TYPE_STRING:
|
|
case STACK_TYPE_ACCESS_DESCRIPTION:
|
|
case STACK_TYPE_X509_EXT:
|
|
case STACK_TYPE_X509_REQ_ATTR:
|
|
case STACK_TYPE_NULL:
|
|
case STACK_TYPE_X509_NAME:
|
|
case STACK_TYPE_X509_NAME_ENTRY:
|
|
case STACK_TYPE_CONF_VALUE:
|
|
case STACK_TYPE_X509_INFO:
|
|
case STACK_TYPE_BY_DIR_entry:
|
|
case STACK_TYPE_BY_DIR_hash:
|
|
case STACK_TYPE_X509_OBJ:
|
|
case STACK_TYPE_DIST_POINT:
|
|
case STACK_TYPE_X509_CRL:
|
|
default:
|
|
/* All other types are pointers */
|
|
if (!sk->data.generic) {
|
|
sk->data.generic = (void*)data;
|
|
sk->num = 1;
|
|
#ifdef OPENSSL_ALL
|
|
if (sk->hash_fn) {
|
|
sk->hash = sk->hash_fn(sk->data.generic);
|
|
}
|
|
#endif
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
break;
|
|
}
|
|
|
|
/* stack already has value(s) create a new node and add more */
|
|
node = wolfSSL_sk_new_node(sk->heap);
|
|
if (!node) {
|
|
WOLFSSL_MSG("Memory error");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
/* push new x509 onto head of stack */
|
|
node->next = sk->next;
|
|
node->type = sk->type;
|
|
sk->next = node;
|
|
sk->num += 1;
|
|
|
|
#ifdef OPENSSL_ALL
|
|
node->hash_fn = sk->hash_fn;
|
|
node->hash = sk->hash;
|
|
sk->hash = 0;
|
|
#endif
|
|
switch (sk->type) {
|
|
case STACK_TYPE_CIPHER:
|
|
#if defined(OPENSSL_ALL) || defined(WOLFSSL_QT)
|
|
node->data.cipher = sk->data.cipher;
|
|
sk->data.cipher = *(WOLFSSL_CIPHER*)data;
|
|
if (sk->hash_fn) {
|
|
sk->hash = sk->hash_fn(&sk->data.cipher);
|
|
}
|
|
break;
|
|
#endif
|
|
case STACK_TYPE_X509:
|
|
case STACK_TYPE_GEN_NAME:
|
|
case STACK_TYPE_BIO:
|
|
case STACK_TYPE_OBJ:
|
|
case STACK_TYPE_STRING:
|
|
case STACK_TYPE_ACCESS_DESCRIPTION:
|
|
case STACK_TYPE_X509_EXT:
|
|
case STACK_TYPE_X509_REQ_ATTR:
|
|
case STACK_TYPE_NULL:
|
|
case STACK_TYPE_X509_NAME:
|
|
case STACK_TYPE_X509_NAME_ENTRY:
|
|
case STACK_TYPE_CONF_VALUE:
|
|
case STACK_TYPE_X509_INFO:
|
|
case STACK_TYPE_BY_DIR_entry:
|
|
case STACK_TYPE_BY_DIR_hash:
|
|
case STACK_TYPE_X509_OBJ:
|
|
case STACK_TYPE_DIST_POINT:
|
|
case STACK_TYPE_X509_CRL:
|
|
default:
|
|
/* All other types are pointers */
|
|
node->data.generic = sk->data.generic;
|
|
sk->data.generic = (void*)data;
|
|
#ifdef OPENSSL_ALL
|
|
if (sk->hash_fn) {
|
|
sk->hash = sk->hash_fn(sk->data.generic);
|
|
}
|
|
#endif
|
|
break;
|
|
}
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
#endif /* OPENSSL_EXTRA || WOLFSSL_WPAS_SMALL */
|
|
|
|
#ifdef OPENSSL_EXTRA
|
|
|
|
/* returns the node at index "idx", NULL if not found */
|
|
WOLFSSL_STACK* wolfSSL_sk_get_node(WOLFSSL_STACK* sk, int idx)
|
|
{
|
|
int i;
|
|
WOLFSSL_STACK* ret = NULL;
|
|
WOLFSSL_STACK* current;
|
|
|
|
current = sk;
|
|
for (i = 0; i <= idx && current != NULL; i++) {
|
|
if (i == idx) {
|
|
ret = current;
|
|
break;
|
|
}
|
|
current = current->next;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
|
|
#endif /* OPENSSL_EXTRA */
|
|
|
|
#ifdef OPENSSL_EXTRA
|
|
|
|
#if defined(OPENSSL_ALL)
|
|
|
|
void *wolfSSL_lh_retrieve(WOLFSSL_STACK *sk, void *data)
|
|
{
|
|
unsigned long hash;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_lh_retrieve");
|
|
|
|
if (!sk || !data) {
|
|
WOLFSSL_MSG("Bad parameters");
|
|
return NULL;
|
|
}
|
|
|
|
if (!sk->hash_fn) {
|
|
WOLFSSL_MSG("No hash function defined");
|
|
return NULL;
|
|
}
|
|
|
|
hash = sk->hash_fn(data);
|
|
|
|
while (sk) {
|
|
/* Calc hash if not done so yet */
|
|
if (!sk->hash) {
|
|
switch (sk->type) {
|
|
case STACK_TYPE_CIPHER:
|
|
sk->hash = sk->hash_fn(&sk->data.cipher);
|
|
break;
|
|
case STACK_TYPE_X509:
|
|
case STACK_TYPE_GEN_NAME:
|
|
case STACK_TYPE_BIO:
|
|
case STACK_TYPE_OBJ:
|
|
case STACK_TYPE_STRING:
|
|
case STACK_TYPE_ACCESS_DESCRIPTION:
|
|
case STACK_TYPE_X509_EXT:
|
|
case STACK_TYPE_X509_REQ_ATTR:
|
|
case STACK_TYPE_NULL:
|
|
case STACK_TYPE_X509_NAME:
|
|
case STACK_TYPE_X509_NAME_ENTRY:
|
|
case STACK_TYPE_CONF_VALUE:
|
|
case STACK_TYPE_X509_INFO:
|
|
case STACK_TYPE_BY_DIR_entry:
|
|
case STACK_TYPE_BY_DIR_hash:
|
|
case STACK_TYPE_X509_OBJ:
|
|
case STACK_TYPE_DIST_POINT:
|
|
case STACK_TYPE_X509_CRL:
|
|
default:
|
|
sk->hash = sk->hash_fn(sk->data.generic);
|
|
break;
|
|
}
|
|
}
|
|
if (sk->hash == hash) {
|
|
switch (sk->type) {
|
|
case STACK_TYPE_CIPHER:
|
|
return &sk->data.cipher;
|
|
case STACK_TYPE_X509:
|
|
case STACK_TYPE_GEN_NAME:
|
|
case STACK_TYPE_BIO:
|
|
case STACK_TYPE_OBJ:
|
|
case STACK_TYPE_STRING:
|
|
case STACK_TYPE_ACCESS_DESCRIPTION:
|
|
case STACK_TYPE_X509_EXT:
|
|
case STACK_TYPE_X509_REQ_ATTR:
|
|
case STACK_TYPE_NULL:
|
|
case STACK_TYPE_X509_NAME:
|
|
case STACK_TYPE_X509_NAME_ENTRY:
|
|
case STACK_TYPE_CONF_VALUE:
|
|
case STACK_TYPE_X509_INFO:
|
|
case STACK_TYPE_BY_DIR_entry:
|
|
case STACK_TYPE_BY_DIR_hash:
|
|
case STACK_TYPE_X509_OBJ:
|
|
case STACK_TYPE_DIST_POINT:
|
|
case STACK_TYPE_X509_CRL:
|
|
default:
|
|
return sk->data.generic;
|
|
}
|
|
}
|
|
sk = sk->next;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
#endif /* OPENSSL_ALL */
|
|
|
|
#endif /* OPENSSL_EXTRA */
|
|
|
|
/* OPENSSL_EXTRA is needed for wolfSSL_X509_d21 function
|
|
KEEP_OUR_CERT is to insure ability for returning ssl certificate */
|
|
#if (defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL)) && \
|
|
defined(KEEP_OUR_CERT)
|
|
WOLFSSL_X509* wolfSSL_get_certificate(WOLFSSL* ssl)
|
|
{
|
|
if (ssl == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
if (ssl->buffers.weOwnCert) {
|
|
if (ssl->ourCert == NULL) {
|
|
if (ssl->buffers.certificate == NULL) {
|
|
WOLFSSL_MSG("Certificate buffer not set!");
|
|
return NULL;
|
|
}
|
|
#ifndef WOLFSSL_X509_STORE_CERTS
|
|
ssl->ourCert = wolfSSL_X509_d2i(NULL,
|
|
ssl->buffers.certificate->buffer,
|
|
ssl->buffers.certificate->length);
|
|
#endif
|
|
}
|
|
return ssl->ourCert;
|
|
}
|
|
else { /* if cert not owned get parent ctx cert or return null */
|
|
if (ssl->ctx) {
|
|
if (ssl->ctx->ourCert == NULL) {
|
|
if (ssl->ctx->certificate == NULL) {
|
|
WOLFSSL_MSG("Ctx Certificate buffer not set!");
|
|
return NULL;
|
|
}
|
|
#ifndef WOLFSSL_X509_STORE_CERTS
|
|
ssl->ctx->ourCert = wolfSSL_X509_d2i(NULL,
|
|
ssl->ctx->certificate->buffer,
|
|
ssl->ctx->certificate->length);
|
|
#endif
|
|
ssl->ctx->ownOurCert = 1;
|
|
}
|
|
return ssl->ctx->ourCert;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
WOLFSSL_X509* wolfSSL_CTX_get0_certificate(WOLFSSL_CTX* ctx)
|
|
{
|
|
if (ctx) {
|
|
if (ctx->ourCert == NULL) {
|
|
if (ctx->certificate == NULL) {
|
|
WOLFSSL_MSG("Ctx Certificate buffer not set!");
|
|
return NULL;
|
|
}
|
|
#ifndef WOLFSSL_X509_STORE_CERTS
|
|
ctx->ourCert = wolfSSL_X509_d2i(NULL,
|
|
ctx->certificate->buffer,
|
|
ctx->certificate->length);
|
|
#endif
|
|
ctx->ownOurCert = 1;
|
|
}
|
|
return ctx->ourCert;
|
|
}
|
|
return NULL;
|
|
}
|
|
#endif /* OPENSSL_EXTRA && KEEP_OUR_CERT */
|
|
#endif /* NO_CERTS */
|
|
|
|
#if defined(OPENSSL_EXTRA) || defined(WOLFSSL_WPAS_SMALL)
|
|
void wolfSSL_set_connect_state(WOLFSSL* ssl)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_set_connect_state");
|
|
if (ssl == NULL) {
|
|
WOLFSSL_MSG("WOLFSSL struct pointer passed in was null");
|
|
return;
|
|
}
|
|
|
|
#ifndef NO_DH
|
|
/* client creates its own DH parameters on handshake */
|
|
if (ssl->buffers.serverDH_P.buffer && ssl->buffers.weOwnDH) {
|
|
XFREE(ssl->buffers.serverDH_P.buffer, ssl->heap,
|
|
DYNAMIC_TYPE_PUBLIC_KEY);
|
|
}
|
|
ssl->buffers.serverDH_P.buffer = NULL;
|
|
if (ssl->buffers.serverDH_G.buffer && ssl->buffers.weOwnDH) {
|
|
XFREE(ssl->buffers.serverDH_G.buffer, ssl->heap,
|
|
DYNAMIC_TYPE_PUBLIC_KEY);
|
|
}
|
|
ssl->buffers.serverDH_G.buffer = NULL;
|
|
#endif
|
|
|
|
if (InitSSL_Side(ssl, WOLFSSL_CLIENT_END) != WOLFSSL_SUCCESS) {
|
|
WOLFSSL_MSG("Error initializing client side");
|
|
}
|
|
}
|
|
#endif /* OPENSSL_EXTRA || WOLFSSL_WPAS_SMALL */
|
|
|
|
|
|
int wolfSSL_get_shutdown(const WOLFSSL* ssl)
|
|
{
|
|
int isShutdown = 0;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_get_shutdown");
|
|
|
|
if (ssl) {
|
|
#if defined(OPENSSL_EXTRA) || defined(WOLFSSL_WPAS_SMALL)
|
|
if (ssl->options.shutdownDone) {
|
|
/* The SSL object was possibly cleared with wolfSSL_clear after
|
|
* a successful shutdown. Simulate a response for a full
|
|
* bidirectional shutdown. */
|
|
isShutdown = WOLFSSL_SENT_SHUTDOWN | WOLFSSL_RECEIVED_SHUTDOWN;
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
/* in OpenSSL, WOLFSSL_SENT_SHUTDOWN = 1, when closeNotifySent *
|
|
* WOLFSSL_RECEIVED_SHUTDOWN = 2, from close notify or fatal err */
|
|
if (ssl->options.sentNotify)
|
|
isShutdown |= WOLFSSL_SENT_SHUTDOWN;
|
|
if (ssl->options.closeNotify||ssl->options.connReset)
|
|
isShutdown |= WOLFSSL_RECEIVED_SHUTDOWN;
|
|
}
|
|
|
|
}
|
|
|
|
WOLFSSL_LEAVE("wolfSSL_get_shutdown", isShutdown);
|
|
return isShutdown;
|
|
}
|
|
|
|
|
|
int wolfSSL_session_reused(WOLFSSL* ssl)
|
|
{
|
|
int resuming = 0;
|
|
WOLFSSL_ENTER("wolfSSL_session_reused");
|
|
if (ssl) {
|
|
#ifndef HAVE_SECURE_RENEGOTIATION
|
|
resuming = ssl->options.resuming;
|
|
#else
|
|
resuming = ssl->options.resuming || ssl->options.resumed;
|
|
#endif
|
|
}
|
|
WOLFSSL_LEAVE("wolfSSL_session_reused", resuming);
|
|
return resuming;
|
|
}
|
|
|
|
/* return a new malloc'd session with default settings on success */
|
|
WOLFSSL_SESSION* wolfSSL_NewSession(void* heap)
|
|
{
|
|
WOLFSSL_SESSION* ret = NULL;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_NewSession");
|
|
|
|
ret = (WOLFSSL_SESSION*)XMALLOC(sizeof(WOLFSSL_SESSION), heap,
|
|
DYNAMIC_TYPE_SESSION);
|
|
if (ret != NULL) {
|
|
int err;
|
|
XMEMSET(ret, 0, sizeof(WOLFSSL_SESSION));
|
|
wolfSSL_RefInit(&ret->ref, &err);
|
|
#ifdef WOLFSSL_REFCNT_ERROR_RETURN
|
|
if (err != 0) {
|
|
WOLFSSL_MSG("Error setting up session reference mutex");
|
|
XFREE(ret, ret->heap, DYNAMIC_TYPE_SESSION);
|
|
return NULL;
|
|
}
|
|
#else
|
|
(void)err;
|
|
#endif
|
|
#ifndef NO_SESSION_CACHE
|
|
ret->cacheRow = INVALID_SESSION_ROW; /* not in cache */
|
|
#endif
|
|
ret->type = WOLFSSL_SESSION_TYPE_HEAP;
|
|
ret->heap = heap;
|
|
#ifdef WOLFSSL_CHECK_MEM_ZERO
|
|
wc_MemZero_Add("SESSION master secret", ret->masterSecret, SECRET_LEN);
|
|
wc_MemZero_Add("SESSION id", ret->sessionID, ID_LEN);
|
|
#endif
|
|
#ifdef HAVE_SESSION_TICKET
|
|
ret->ticket = ret->staticTicket;
|
|
#if defined(WOLFSSL_TLS13) && defined(WOLFSSL_TICKET_NONCE_MALLOC) && \
|
|
(!defined(HAVE_FIPS) || (defined(FIPS_VERSION_GE) && FIPS_VERSION_GE(5,3)))
|
|
ret->ticketNonce.data = ret->ticketNonce.dataStatic;
|
|
#endif
|
|
#endif
|
|
#ifdef HAVE_EX_DATA
|
|
ret->ownExData = 1;
|
|
if (crypto_ex_cb_ctx_session != NULL) {
|
|
crypto_ex_cb_setup_new_data(ret, crypto_ex_cb_ctx_session,
|
|
&ret->ex_data);
|
|
}
|
|
#endif
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
|
|
WOLFSSL_SESSION* wolfSSL_SESSION_new_ex(void* heap)
|
|
{
|
|
return wolfSSL_NewSession(heap);
|
|
}
|
|
|
|
WOLFSSL_SESSION* wolfSSL_SESSION_new(void)
|
|
{
|
|
return wolfSSL_SESSION_new_ex(NULL);
|
|
}
|
|
|
|
/* add one to session reference count
|
|
* return WOLFSSL_SUCCESS on success and WOLFSSL_FAILURE on error */
|
|
int wolfSSL_SESSION_up_ref(WOLFSSL_SESSION* session)
|
|
{
|
|
int ret;
|
|
|
|
session = ClientSessionToSession(session);
|
|
|
|
if (session == NULL || session->type != WOLFSSL_SESSION_TYPE_HEAP)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
wolfSSL_RefInc(&session->ref, &ret);
|
|
#ifdef WOLFSSL_REFCNT_ERROR_RETURN
|
|
if (ret != 0) {
|
|
WOLFSSL_MSG("Failed to lock session mutex");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
#else
|
|
(void)ret;
|
|
#endif
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
* Deep copy the contents from input to output.
|
|
* @param input The source of the copy.
|
|
* @param output The destination of the copy.
|
|
* @param avoidSysCalls If true, then system calls will be avoided or an error
|
|
* will be returned if it is not possible to proceed
|
|
* without a system call. This is useful for fetching
|
|
* sessions from cache. When a cache row is locked, we
|
|
* don't want to block other threads with long running
|
|
* system calls.
|
|
* @param ticketNonceBuf If not null and @avoidSysCalls is true, the copy of the
|
|
* ticketNonce will happen in this pre allocated buffer
|
|
* @param ticketNonceLen @ticketNonceBuf len as input, used length on output
|
|
* @param ticketNonceUsed if @ticketNonceBuf was used to copy the ticket noncet
|
|
* @return WOLFSSL_SUCCESS on success
|
|
* WOLFSSL_FAILURE on failure
|
|
*/
|
|
static int wolfSSL_DupSessionEx(const WOLFSSL_SESSION* input,
|
|
WOLFSSL_SESSION* output, int avoidSysCalls, byte* ticketNonceBuf,
|
|
byte* ticketNonceLen, byte* preallocUsed)
|
|
{
|
|
#ifdef HAVE_SESSION_TICKET
|
|
int ticLenAlloc = 0;
|
|
byte *ticBuff = NULL;
|
|
#endif
|
|
const size_t copyOffset = OFFSETOF(WOLFSSL_SESSION, heap) + sizeof(input->heap);
|
|
int ret = WOLFSSL_SUCCESS;
|
|
|
|
(void)avoidSysCalls;
|
|
(void)ticketNonceBuf;
|
|
(void)ticketNonceLen;
|
|
(void)preallocUsed;
|
|
|
|
input = ClientSessionToSession(input);
|
|
output = ClientSessionToSession(output);
|
|
|
|
if (input == NULL || output == NULL || input == output) {
|
|
WOLFSSL_MSG("input or output are null or same");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
#ifdef HAVE_SESSION_TICKET
|
|
if (output->ticket != output->staticTicket) {
|
|
ticBuff = output->ticket;
|
|
ticLenAlloc = output->ticketLenAlloc;
|
|
}
|
|
#if defined(WOLFSSL_TLS13) && defined(WOLFSSL_TICKET_NONCE_MALLOC) && \
|
|
(!defined(HAVE_FIPS) || (defined(FIPS_VERSION_GE) && FIPS_VERSION_GE(5,3)))
|
|
/* free the data, it would be better to reuse the buffer but this
|
|
* maintain the code simpler. A smart allocator should reuse the free'd
|
|
* buffer in the next malloc without much performance penalties. */
|
|
if (output->ticketNonce.data != output->ticketNonce.dataStatic) {
|
|
|
|
/* Callers that avoid syscall should never calls this with
|
|
* output->tickeNonce.data being a dynamic buffer.*/
|
|
if (avoidSysCalls) {
|
|
WOLFSSL_MSG("can't avoid syscalls with dynamic TicketNonce buffer");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
XFREE(output->ticketNonce.data,
|
|
output->heap, DYNAMIC_TYPE_SESSION_TICK);
|
|
output->ticketNonce.data = output->ticketNonce.dataStatic;
|
|
output->ticketNonce.len = 0;
|
|
}
|
|
#endif /* WOLFSSL_TLS13 && WOLFSSL_TICKET_NONCE_MALLOC && FIPS_VERSION_GE(5,3)*/
|
|
#endif /* HAVE_SESSION_TICKET */
|
|
|
|
#if defined(SESSION_CERTS) && defined(OPENSSL_EXTRA)
|
|
if (output->peer != NULL) {
|
|
if (avoidSysCalls) {
|
|
WOLFSSL_MSG("Can't free cert when avoiding syscalls");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
wolfSSL_X509_free(output->peer);
|
|
output->peer = NULL;
|
|
}
|
|
#endif
|
|
|
|
XMEMCPY((byte*)output + copyOffset, (byte*)input + copyOffset,
|
|
sizeof(WOLFSSL_SESSION) - copyOffset);
|
|
|
|
#if defined(HAVE_SESSION_TICKET) && defined(WOLFSSL_TLS13) && \
|
|
defined(WOLFSSL_TICKET_NONCE_MALLOC) && \
|
|
(!defined(HAVE_FIPS) || (defined(FIPS_VERSION_GE) && FIPS_VERSION_GE(5,3)))
|
|
/* fix pointer to static after the copy */
|
|
output->ticketNonce.data = output->ticketNonce.dataStatic;
|
|
#endif
|
|
/* Set sane values for copy */
|
|
#ifndef NO_SESSION_CACHE
|
|
if (output->type != WOLFSSL_SESSION_TYPE_CACHE)
|
|
output->cacheRow = INVALID_SESSION_ROW;
|
|
#endif
|
|
#if defined(SESSION_CERTS) && defined(OPENSSL_EXTRA)
|
|
if (input->peer != NULL && input->peer->dynamicMemory) {
|
|
if (wolfSSL_X509_up_ref(input->peer) != WOLFSSL_SUCCESS) {
|
|
WOLFSSL_MSG("Can't increase peer cert ref count");
|
|
output->peer = NULL;
|
|
}
|
|
}
|
|
else if (!avoidSysCalls)
|
|
output->peer = wolfSSL_X509_dup(input->peer);
|
|
else
|
|
/* output->peer is not that important to copy */
|
|
output->peer = NULL;
|
|
#endif
|
|
#ifdef HAVE_SESSION_TICKET
|
|
if (input->ticketLen > SESSION_TICKET_LEN) {
|
|
/* Need dynamic buffer */
|
|
if (ticBuff == NULL || ticLenAlloc < input->ticketLen) {
|
|
/* allocate new one */
|
|
byte* tmp;
|
|
if (avoidSysCalls) {
|
|
WOLFSSL_MSG("Failed to allocate memory for ticket when avoiding"
|
|
" syscalls");
|
|
output->ticket = ticBuff;
|
|
output->ticketLenAlloc = (word16) ticLenAlloc;
|
|
output->ticketLen = 0;
|
|
ret = WOLFSSL_FAILURE;
|
|
}
|
|
else {
|
|
#ifdef WOLFSSL_NO_REALLOC
|
|
tmp = (byte*)XMALLOC(input->ticketLen,
|
|
output->heap, DYNAMIC_TYPE_SESSION_TICK);
|
|
XFREE(ticBuff, output->heap, DYNAMIC_TYPE_SESSION_TICK);
|
|
ticBuff = NULL;
|
|
#else
|
|
tmp = (byte*)XREALLOC(ticBuff, input->ticketLen,
|
|
output->heap, DYNAMIC_TYPE_SESSION_TICK);
|
|
#endif /* WOLFSSL_NO_REALLOC */
|
|
if (tmp == NULL) {
|
|
WOLFSSL_MSG("Failed to allocate memory for ticket");
|
|
#ifndef WOLFSSL_NO_REALLOC
|
|
XFREE(ticBuff, output->heap, DYNAMIC_TYPE_SESSION_TICK);
|
|
ticBuff = NULL;
|
|
#endif /* WOLFSSL_NO_REALLOC */
|
|
output->ticket = NULL;
|
|
output->ticketLen = 0;
|
|
output->ticketLenAlloc = 0;
|
|
ret = WOLFSSL_FAILURE;
|
|
}
|
|
else {
|
|
ticBuff = tmp;
|
|
ticLenAlloc = input->ticketLen;
|
|
}
|
|
}
|
|
}
|
|
if (ticBuff != NULL && ret == WOLFSSL_SUCCESS) {
|
|
XMEMCPY(ticBuff, input->ticket, input->ticketLen);
|
|
output->ticket = ticBuff;
|
|
output->ticketLenAlloc = (word16) ticLenAlloc;
|
|
}
|
|
}
|
|
else {
|
|
/* Default ticket to non dynamic */
|
|
if (avoidSysCalls) {
|
|
/* Try to use ticBuf if available. Caller can later move it to
|
|
* the static buffer. */
|
|
if (ticBuff != NULL) {
|
|
if (ticLenAlloc >= input->ticketLen) {
|
|
output->ticket = ticBuff;
|
|
output->ticketLenAlloc = ticLenAlloc;
|
|
}
|
|
else {
|
|
WOLFSSL_MSG("ticket dynamic buffer too small but we are "
|
|
"avoiding system calls");
|
|
ret = WOLFSSL_FAILURE;
|
|
output->ticket = ticBuff;
|
|
output->ticketLenAlloc = (word16) ticLenAlloc;
|
|
output->ticketLen = 0;
|
|
}
|
|
}
|
|
else {
|
|
output->ticket = output->staticTicket;
|
|
output->ticketLenAlloc = 0;
|
|
}
|
|
}
|
|
else {
|
|
if (ticBuff != NULL)
|
|
XFREE(ticBuff, output->heap, DYNAMIC_TYPE_SESSION_TICK);
|
|
output->ticket = output->staticTicket;
|
|
output->ticketLenAlloc = 0;
|
|
}
|
|
if (input->ticketLenAlloc > 0 && ret == WOLFSSL_SUCCESS) {
|
|
/* Shouldn't happen as session should have placed this in
|
|
* the static buffer */
|
|
XMEMCPY(output->ticket, input->ticket,
|
|
input->ticketLen);
|
|
}
|
|
}
|
|
ticBuff = NULL;
|
|
|
|
#if defined(WOLFSSL_TLS13) && defined(WOLFSSL_TICKET_NONCE_MALLOC) && \
|
|
(!defined(HAVE_FIPS) || (defined(FIPS_VERSION_GE) && FIPS_VERSION_GE(5,3)))
|
|
if (preallocUsed != NULL)
|
|
*preallocUsed = 0;
|
|
|
|
if (input->ticketNonce.len > MAX_TICKET_NONCE_STATIC_SZ &&
|
|
ret == WOLFSSL_SUCCESS) {
|
|
/* TicketNonce does not fit in the static buffer */
|
|
if (!avoidSysCalls) {
|
|
output->ticketNonce.data = (byte*)XMALLOC(input->ticketNonce.len,
|
|
output->heap, DYNAMIC_TYPE_SESSION_TICK);
|
|
|
|
if (output->ticketNonce.data == NULL) {
|
|
WOLFSSL_MSG("Failed to allocate space for ticket nonce");
|
|
output->ticketNonce.data = output->ticketNonce.dataStatic;
|
|
output->ticketNonce.len = 0;
|
|
ret = WOLFSSL_FAILURE;
|
|
}
|
|
else {
|
|
output->ticketNonce.len = input->ticketNonce.len;
|
|
XMEMCPY(output->ticketNonce.data, input->ticketNonce.data,
|
|
input->ticketNonce.len);
|
|
ret = WOLFSSL_SUCCESS;
|
|
}
|
|
}
|
|
/* we can't do syscalls. Use prealloc buffers if provided from the
|
|
* caller. */
|
|
else if (ticketNonceBuf != NULL &&
|
|
*ticketNonceLen >= input->ticketNonce.len) {
|
|
XMEMCPY(ticketNonceBuf, input->ticketNonce.data,
|
|
input->ticketNonce.len);
|
|
*ticketNonceLen = input->ticketNonce.len;
|
|
if (preallocUsed != NULL)
|
|
*preallocUsed = 1;
|
|
ret = WOLFSSL_SUCCESS;
|
|
}
|
|
else {
|
|
WOLFSSL_MSG("TicketNonce bigger than static buffer, and we can't "
|
|
"do syscalls");
|
|
ret = WOLFSSL_FAILURE;
|
|
}
|
|
}
|
|
#endif /* WOLFSSL_TLS13 && WOLFSSL_TICKET_NONCE_MALLOC && FIPS_VERSION_GE(5,3)*/
|
|
|
|
#endif /* HAVE_SESSION_TICKET */
|
|
|
|
#ifdef HAVE_EX_DATA
|
|
if (input->type != WOLFSSL_SESSION_TYPE_CACHE &&
|
|
output->type != WOLFSSL_SESSION_TYPE_CACHE) {
|
|
/* Not called with cache as that passes ownership of ex_data */
|
|
ret = crypto_ex_cb_dup_data(&input->ex_data, &output->ex_data,
|
|
crypto_ex_cb_ctx_session);
|
|
}
|
|
#endif
|
|
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* Deep copy the contents from input to output.
|
|
* @param input The source of the copy.
|
|
* @param output The destination of the copy.
|
|
* @param avoidSysCalls If true, then system calls will be avoided or an error
|
|
* will be returned if it is not possible to proceed
|
|
* without a system call. This is useful for fetching
|
|
* sessions from cache. When a cache row is locked, we
|
|
* don't want to block other threads with long running
|
|
* system calls.
|
|
* @return WOLFSSL_SUCCESS on success
|
|
* WOLFSSL_FAILURE on failure
|
|
*/
|
|
int wolfSSL_DupSession(const WOLFSSL_SESSION* input, WOLFSSL_SESSION* output,
|
|
int avoidSysCalls)
|
|
{
|
|
return wolfSSL_DupSessionEx(input, output, avoidSysCalls, NULL, NULL, NULL);
|
|
}
|
|
|
|
WOLFSSL_SESSION* wolfSSL_SESSION_dup(WOLFSSL_SESSION* session)
|
|
{
|
|
WOLFSSL_SESSION* copy;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_SESSION_dup");
|
|
|
|
session = ClientSessionToSession(session);
|
|
if (session == NULL)
|
|
return NULL;
|
|
|
|
#ifdef HAVE_SESSION_TICKET
|
|
if (session->ticketLenAlloc > 0 && !session->ticket) {
|
|
WOLFSSL_MSG("Session dynamic flag is set but ticket pointer is null");
|
|
return NULL;
|
|
}
|
|
#endif
|
|
|
|
copy = wolfSSL_NewSession(session->heap);
|
|
if (copy != NULL &&
|
|
wolfSSL_DupSession(session, copy, 0) != WOLFSSL_SUCCESS) {
|
|
wolfSSL_FreeSession(NULL, copy);
|
|
copy = NULL;
|
|
}
|
|
return copy;
|
|
}
|
|
|
|
void wolfSSL_FreeSession(WOLFSSL_CTX* ctx, WOLFSSL_SESSION* session)
|
|
{
|
|
session = ClientSessionToSession(session);
|
|
if (session == NULL)
|
|
return;
|
|
|
|
(void)ctx;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_FreeSession");
|
|
|
|
if (session->ref.count > 0) {
|
|
int ret;
|
|
int isZero;
|
|
wolfSSL_RefDec(&session->ref, &isZero, &ret);
|
|
(void)ret;
|
|
if (!isZero) {
|
|
return;
|
|
}
|
|
wolfSSL_RefFree(&session->ref);
|
|
}
|
|
|
|
WOLFSSL_MSG("wolfSSL_FreeSession full free");
|
|
|
|
#ifdef HAVE_EX_DATA
|
|
if (session->ownExData) {
|
|
crypto_ex_cb_free_data(session, crypto_ex_cb_ctx_session,
|
|
&session->ex_data);
|
|
}
|
|
#endif
|
|
|
|
#ifdef HAVE_EX_DATA_CLEANUP_HOOKS
|
|
wolfSSL_CRYPTO_cleanup_ex_data(&session->ex_data);
|
|
#endif
|
|
|
|
#if defined(SESSION_CERTS) && defined(OPENSSL_EXTRA)
|
|
if (session->peer) {
|
|
wolfSSL_X509_free(session->peer);
|
|
session->peer = NULL;
|
|
}
|
|
#endif
|
|
|
|
#ifdef HAVE_SESSION_TICKET
|
|
if (session->ticketLenAlloc > 0) {
|
|
XFREE(session->ticket, session->heap, DYNAMIC_TYPE_SESSION_TICK);
|
|
}
|
|
#if defined(WOLFSSL_TLS13) && defined(WOLFSSL_TICKET_NONCE_MALLOC) && \
|
|
(!defined(HAVE_FIPS) || (defined(FIPS_VERSION_GE) && FIPS_VERSION_GE(5,3)))
|
|
if (session->ticketNonce.data != session->ticketNonce.dataStatic) {
|
|
XFREE(session->ticketNonce.data, session->heap,
|
|
DYNAMIC_TYPE_SESSION_TICK);
|
|
}
|
|
#endif /* WOLFSSL_TLS13 && WOLFSSL_TICKET_NONCE_MALLOC && FIPS_VERSION_GE(5,3)*/
|
|
#endif
|
|
|
|
#ifdef HAVE_EX_DATA_CLEANUP_HOOKS
|
|
wolfSSL_CRYPTO_cleanup_ex_data(&session->ex_data);
|
|
#endif
|
|
|
|
/* Make sure masterSecret is zeroed. */
|
|
ForceZero(session->masterSecret, SECRET_LEN);
|
|
/* Session ID is sensitive information too. */
|
|
ForceZero(session->sessionID, ID_LEN);
|
|
|
|
if (session->type == WOLFSSL_SESSION_TYPE_HEAP) {
|
|
XFREE(session, session->heap, DYNAMIC_TYPE_SESSION);
|
|
}
|
|
}
|
|
|
|
/* DO NOT use this API internally. Use wolfSSL_FreeSession directly instead
|
|
* and pass in the ctx parameter if possible (like from ssl->ctx). */
|
|
void wolfSSL_SESSION_free(WOLFSSL_SESSION* session)
|
|
{
|
|
session = ClientSessionToSession(session);
|
|
wolfSSL_FreeSession(NULL, session);
|
|
}
|
|
|
|
#ifndef NO_SESSION_CACHE
|
|
int wolfSSL_CTX_add_session(WOLFSSL_CTX* ctx, WOLFSSL_SESSION* session)
|
|
{
|
|
int error = 0;
|
|
const byte* id = NULL;
|
|
byte idSz = 0;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_CTX_add_session");
|
|
|
|
session = ClientSessionToSession(session);
|
|
if (session == NULL)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
/* Session cache is global */
|
|
(void)ctx;
|
|
|
|
if (session->haveAltSessionID) {
|
|
id = session->altSessionID;
|
|
idSz = ID_LEN;
|
|
}
|
|
else {
|
|
id = session->sessionID;
|
|
idSz = session->sessionIDSz;
|
|
}
|
|
|
|
error = AddSessionToCache(ctx, session, id, idSz,
|
|
NULL, session->side,
|
|
#ifdef HAVE_SESSION_TICKET
|
|
session->ticketLen > 0,
|
|
#else
|
|
0,
|
|
#endif
|
|
NULL);
|
|
|
|
return error == 0 ? WOLFSSL_SUCCESS : WOLFSSL_FAILURE;
|
|
}
|
|
#endif
|
|
|
|
#if defined(OPENSSL_EXTRA) || defined(HAVE_EXT_CACHE)
|
|
|
|
/**
|
|
* set cipher to WOLFSSL_SESSION from WOLFSSL_CIPHER
|
|
* @param session a pointer to WOLFSSL_SESSION structure
|
|
* @param cipher a function pointer to WOLFSSL_CIPHER
|
|
* @return WOLFSSL_SUCCESS on success, otherwise WOLFSSL_FAILURE
|
|
*/
|
|
int wolfSSL_SESSION_set_cipher(WOLFSSL_SESSION* session,
|
|
const WOLFSSL_CIPHER* cipher)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_SESSION_set_cipher");
|
|
|
|
session = ClientSessionToSession(session);
|
|
/* sanity check */
|
|
if (session == NULL || cipher == NULL) {
|
|
WOLFSSL_MSG("bad argument");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
session->cipherSuite0 = cipher->cipherSuite0;
|
|
session->cipherSuite = cipher->cipherSuite;
|
|
|
|
WOLFSSL_LEAVE("wolfSSL_SESSION_set_cipher", WOLFSSL_SUCCESS);
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
#endif /* OPENSSL_EXTRA || HAVE_EXT_CACHE */
|
|
|
|
|
|
/* helper function that takes in a protocol version struct and returns string */
|
|
static const char* wolfSSL_internal_get_version(const ProtocolVersion* version)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_get_version");
|
|
|
|
if (version == NULL) {
|
|
return "Bad arg";
|
|
}
|
|
|
|
if (version->major == SSLv3_MAJOR) {
|
|
switch (version->minor) {
|
|
case SSLv3_MINOR :
|
|
return "SSLv3";
|
|
case TLSv1_MINOR :
|
|
return "TLSv1";
|
|
case TLSv1_1_MINOR :
|
|
return "TLSv1.1";
|
|
case TLSv1_2_MINOR :
|
|
return "TLSv1.2";
|
|
case TLSv1_3_MINOR :
|
|
return "TLSv1.3";
|
|
default:
|
|
return "unknown";
|
|
}
|
|
}
|
|
#ifdef WOLFSSL_DTLS
|
|
else if (version->major == DTLS_MAJOR) {
|
|
switch (version->minor) {
|
|
case DTLS_MINOR :
|
|
return "DTLS";
|
|
case DTLSv1_2_MINOR :
|
|
return "DTLSv1.2";
|
|
case DTLSv1_3_MINOR :
|
|
return "DTLSv1.3";
|
|
default:
|
|
return "unknown";
|
|
}
|
|
}
|
|
#endif /* WOLFSSL_DTLS */
|
|
return "unknown";
|
|
}
|
|
|
|
|
|
const char* wolfSSL_get_version(const WOLFSSL* ssl)
|
|
{
|
|
if (ssl == NULL) {
|
|
WOLFSSL_MSG("Bad argument");
|
|
return "unknown";
|
|
}
|
|
|
|
return wolfSSL_internal_get_version(&ssl->version);
|
|
}
|
|
|
|
|
|
/* current library version */
|
|
const char* wolfSSL_lib_version(void)
|
|
{
|
|
return LIBWOLFSSL_VERSION_STRING;
|
|
}
|
|
|
|
#ifdef OPENSSL_EXTRA
|
|
#if defined(OPENSSL_VERSION_NUMBER) && OPENSSL_VERSION_NUMBER >= 0x10100000L
|
|
const char* wolfSSL_OpenSSL_version(int a)
|
|
{
|
|
(void)a;
|
|
return "wolfSSL " LIBWOLFSSL_VERSION_STRING;
|
|
}
|
|
#else
|
|
const char* wolfSSL_OpenSSL_version(void)
|
|
{
|
|
return "wolfSSL " LIBWOLFSSL_VERSION_STRING;
|
|
}
|
|
#endif /* WOLFSSL_QT */
|
|
#endif
|
|
|
|
|
|
/* current library version in hex */
|
|
word32 wolfSSL_lib_version_hex(void)
|
|
{
|
|
return LIBWOLFSSL_VERSION_HEX;
|
|
}
|
|
|
|
|
|
int wolfSSL_get_current_cipher_suite(WOLFSSL* ssl)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_get_current_cipher_suite");
|
|
if (ssl)
|
|
return (ssl->options.cipherSuite0 << 8) | ssl->options.cipherSuite;
|
|
return 0;
|
|
}
|
|
|
|
WOLFSSL_CIPHER* wolfSSL_get_current_cipher(WOLFSSL* ssl)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_get_current_cipher");
|
|
if (ssl) {
|
|
ssl->cipher.cipherSuite0 = ssl->options.cipherSuite0;
|
|
ssl->cipher.cipherSuite = ssl->options.cipherSuite;
|
|
#if defined(OPENSSL_ALL) || defined(WOLFSSL_QT)
|
|
ssl->cipher.bits = ssl->specs.key_size * 8;
|
|
#endif
|
|
return &ssl->cipher;
|
|
}
|
|
else
|
|
return NULL;
|
|
}
|
|
|
|
|
|
const char* wolfSSL_CIPHER_get_name(const WOLFSSL_CIPHER* cipher)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CIPHER_get_name");
|
|
|
|
if (cipher == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
#if !defined(WOLFSSL_CIPHER_INTERNALNAME) && !defined(NO_ERROR_STRINGS) && \
|
|
!defined(WOLFSSL_QT)
|
|
return GetCipherNameIana(cipher->cipherSuite0, cipher->cipherSuite);
|
|
#else
|
|
return wolfSSL_get_cipher_name_from_suite(cipher->cipherSuite0,
|
|
cipher->cipherSuite);
|
|
#endif
|
|
}
|
|
|
|
const char* wolfSSL_CIPHER_get_version(const WOLFSSL_CIPHER* cipher)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CIPHER_get_version");
|
|
|
|
if (cipher == NULL || cipher->ssl == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
return wolfSSL_get_version(cipher->ssl);
|
|
}
|
|
|
|
const char* wolfSSL_SESSION_CIPHER_get_name(const WOLFSSL_SESSION* session)
|
|
{
|
|
session = ClientSessionToSession(session);
|
|
if (session == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
#if defined(SESSION_CERTS) || !defined(NO_RESUME_SUITE_CHECK) || \
|
|
(defined(WOLFSSL_TLS13) && defined(HAVE_SESSION_TICKET))
|
|
#if !defined(WOLFSSL_CIPHER_INTERNALNAME) && !defined(NO_ERROR_STRINGS)
|
|
return GetCipherNameIana(session->cipherSuite0, session->cipherSuite);
|
|
#else
|
|
return GetCipherNameInternal(session->cipherSuite0, session->cipherSuite);
|
|
#endif
|
|
#else
|
|
return NULL;
|
|
#endif
|
|
}
|
|
|
|
const char* wolfSSL_get_cipher(WOLFSSL* ssl)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_get_cipher");
|
|
return wolfSSL_CIPHER_get_name(wolfSSL_get_current_cipher(ssl));
|
|
}
|
|
|
|
/* gets cipher name in the format DHE-RSA-... rather then TLS_DHE... */
|
|
const char* wolfSSL_get_cipher_name(WOLFSSL* ssl)
|
|
{
|
|
/* get access to cipher_name_idx in internal.c */
|
|
return wolfSSL_get_cipher_name_internal(ssl);
|
|
}
|
|
|
|
const char* wolfSSL_get_cipher_name_from_suite(const byte cipherSuite0,
|
|
const byte cipherSuite)
|
|
{
|
|
return GetCipherNameInternal(cipherSuite0, cipherSuite);
|
|
}
|
|
|
|
const char* wolfSSL_get_cipher_name_iana_from_suite(const byte cipherSuite0,
|
|
const byte cipherSuite)
|
|
{
|
|
return GetCipherNameIana(cipherSuite0, cipherSuite);
|
|
}
|
|
|
|
int wolfSSL_get_cipher_suite_from_name(const char* name, byte* cipherSuite0,
|
|
byte* cipherSuite, int *flags) {
|
|
if ((name == NULL) ||
|
|
(cipherSuite0 == NULL) ||
|
|
(cipherSuite == NULL) ||
|
|
(flags == NULL))
|
|
return BAD_FUNC_ARG;
|
|
return GetCipherSuiteFromName(name, cipherSuite0, cipherSuite, flags);
|
|
}
|
|
|
|
|
|
#if defined(WOLFSSL_QT) || defined(OPENSSL_ALL)
|
|
/* Creates and returns a new WOLFSSL_CIPHER stack. */
|
|
WOLFSSL_STACK* wolfSSL_sk_new_cipher(void)
|
|
{
|
|
WOLFSSL_STACK* sk;
|
|
WOLFSSL_ENTER("wolfSSL_sk_new_cipher");
|
|
|
|
sk = wolfSSL_sk_new_null();
|
|
if (sk == NULL)
|
|
return NULL;
|
|
sk->type = STACK_TYPE_CIPHER;
|
|
|
|
return sk;
|
|
}
|
|
|
|
/* return 1 on success 0 on fail */
|
|
int wolfSSL_sk_CIPHER_push(WOLF_STACK_OF(WOLFSSL_CIPHER)* sk,
|
|
WOLFSSL_CIPHER* cipher)
|
|
{
|
|
return wolfSSL_sk_push(sk, cipher);
|
|
}
|
|
|
|
#ifndef NO_WOLFSSL_STUB
|
|
WOLFSSL_CIPHER* wolfSSL_sk_CIPHER_pop(WOLF_STACK_OF(WOLFSSL_CIPHER)* sk)
|
|
{
|
|
WOLFSSL_STUB("wolfSSL_sk_CIPHER_pop");
|
|
(void)sk;
|
|
return NULL;
|
|
}
|
|
#endif /* NO_WOLFSSL_STUB */
|
|
#endif /* WOLFSSL_QT || OPENSSL_ALL */
|
|
|
|
word32 wolfSSL_CIPHER_get_id(const WOLFSSL_CIPHER* cipher)
|
|
{
|
|
word16 cipher_id = 0;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_CIPHER_get_id");
|
|
|
|
if (cipher && cipher->ssl) {
|
|
cipher_id = (cipher->ssl->options.cipherSuite0 << 8) |
|
|
cipher->ssl->options.cipherSuite;
|
|
}
|
|
|
|
return cipher_id;
|
|
}
|
|
|
|
const WOLFSSL_CIPHER* wolfSSL_get_cipher_by_value(word16 value)
|
|
{
|
|
const WOLFSSL_CIPHER* cipher = NULL;
|
|
byte cipherSuite0, cipherSuite;
|
|
WOLFSSL_ENTER("wolfSSL_get_cipher_by_value");
|
|
|
|
/* extract cipher id information */
|
|
cipherSuite = (value & 0xFF);
|
|
cipherSuite0 = ((value >> 8) & 0xFF);
|
|
|
|
/* TODO: lookup by cipherSuite0 / cipherSuite */
|
|
(void)cipherSuite0;
|
|
(void)cipherSuite;
|
|
|
|
return cipher;
|
|
}
|
|
|
|
|
|
#if defined(OPENSSL_EXTRA)
|
|
/* Free the structure for WOLFSSL_CIPHER stack
|
|
*
|
|
* sk stack to free nodes in
|
|
*/
|
|
void wolfSSL_sk_CIPHER_free(WOLF_STACK_OF(WOLFSSL_CIPHER)* sk)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_sk_CIPHER_free");
|
|
|
|
wolfSSL_sk_free(sk);
|
|
}
|
|
#endif /* OPENSSL_ALL */
|
|
|
|
#if defined(HAVE_ECC) || defined(HAVE_CURVE25519) || defined(HAVE_CURVE448) || \
|
|
!defined(NO_DH)
|
|
#ifdef HAVE_FFDHE
|
|
static const char* wolfssl_ffdhe_name(word16 group)
|
|
{
|
|
const char* str = NULL;
|
|
switch (group) {
|
|
case WOLFSSL_FFDHE_2048:
|
|
str = "FFDHE_2048";
|
|
break;
|
|
case WOLFSSL_FFDHE_3072:
|
|
str = "FFDHE_3072";
|
|
break;
|
|
case WOLFSSL_FFDHE_4096:
|
|
str = "FFDHE_4096";
|
|
break;
|
|
case WOLFSSL_FFDHE_6144:
|
|
str = "FFDHE_6144";
|
|
break;
|
|
case WOLFSSL_FFDHE_8192:
|
|
str = "FFDHE_8192";
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return str;
|
|
}
|
|
#endif
|
|
/* Return the name of the curve used for key exchange as a printable string.
|
|
*
|
|
* ssl The SSL/TLS object.
|
|
* returns NULL if ECDH was not used, otherwise the name as a string.
|
|
*/
|
|
const char* wolfSSL_get_curve_name(WOLFSSL* ssl)
|
|
{
|
|
const char* cName = NULL;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_get_curve_name");
|
|
|
|
if (ssl == NULL)
|
|
return NULL;
|
|
|
|
#if defined(WOLFSSL_TLS13) && defined(HAVE_PQC)
|
|
/* Check for post-quantum groups. Return now because we do not want the ECC
|
|
* check to override this result in the case of a hybrid. */
|
|
if (IsAtLeastTLSv1_3(ssl->version)) {
|
|
switch (ssl->namedGroup) {
|
|
#ifdef HAVE_LIBOQS
|
|
case WOLFSSL_KYBER_LEVEL1:
|
|
return "KYBER_LEVEL1";
|
|
case WOLFSSL_KYBER_LEVEL3:
|
|
return "KYBER_LEVEL3";
|
|
case WOLFSSL_KYBER_LEVEL5:
|
|
return "KYBER_LEVEL5";
|
|
case WOLFSSL_P256_KYBER_LEVEL1:
|
|
return "P256_KYBER_LEVEL1";
|
|
case WOLFSSL_P384_KYBER_LEVEL3:
|
|
return "P384_KYBER_LEVEL3";
|
|
case WOLFSSL_P521_KYBER_LEVEL5:
|
|
return "P521_KYBER_LEVEL5";
|
|
#elif defined(HAVE_PQM4)
|
|
case WOLFSSL_KYBER_LEVEL1:
|
|
return "KYBER_LEVEL1";
|
|
#elif defined(WOLFSSL_WC_KYBER)
|
|
#ifdef WOLFSSL_KYBER512
|
|
case WOLFSSL_KYBER_LEVEL1:
|
|
return "KYBER_LEVEL1";
|
|
#endif
|
|
#ifdef WOLFSSL_KYBER768
|
|
case WOLFSSL_KYBER_LEVEL3:
|
|
return "KYBER_LEVEL3";
|
|
#endif
|
|
#ifdef WOLFSSL_KYBER1024
|
|
case WOLFSSL_KYBER_LEVEL5:
|
|
return "KYBER_LEVEL5";
|
|
#endif
|
|
#endif
|
|
}
|
|
}
|
|
|
|
#endif /* WOLFSSL_TLS13 && HAVE_PQC */
|
|
#ifdef HAVE_FFDHE
|
|
if (ssl->namedGroup != 0) {
|
|
cName = wolfssl_ffdhe_name(ssl->namedGroup);
|
|
}
|
|
#endif
|
|
|
|
#ifdef HAVE_CURVE25519
|
|
if (ssl->ecdhCurveOID == ECC_X25519_OID && cName == NULL) {
|
|
cName = "X25519";
|
|
}
|
|
#endif
|
|
|
|
#ifdef HAVE_CURVE448
|
|
if (ssl->ecdhCurveOID == ECC_X448_OID && cName == NULL) {
|
|
cName = "X448";
|
|
}
|
|
#endif
|
|
|
|
#ifdef HAVE_ECC
|
|
if (ssl->ecdhCurveOID != 0 && cName == NULL) {
|
|
cName = wc_ecc_get_name(wc_ecc_get_oid(ssl->ecdhCurveOID, NULL,
|
|
NULL));
|
|
}
|
|
#endif
|
|
|
|
return cName;
|
|
}
|
|
#endif
|
|
|
|
#ifdef OPENSSL_EXTRA
|
|
#if defined(OPENSSL_ALL) || defined(WOLFSSL_QT)
|
|
/* return authentication NID corresponding to cipher suite
|
|
* @param cipher a pointer to WOLFSSL_CIPHER
|
|
* return NID if found, NID_undef if not found
|
|
*/
|
|
int wolfSSL_CIPHER_get_auth_nid(const WOLFSSL_CIPHER* cipher)
|
|
{
|
|
static const struct authnid {
|
|
const char* alg_name;
|
|
const int nid;
|
|
} authnid_tbl[] = {
|
|
{"RSA", NID_auth_rsa},
|
|
{"PSK", NID_auth_psk},
|
|
{"SRP", NID_auth_srp},
|
|
{"ECDSA", NID_auth_ecdsa},
|
|
{"None", NID_auth_null},
|
|
{NULL, NID_undef}
|
|
};
|
|
|
|
const char* authStr;
|
|
char n[MAX_SEGMENTS][MAX_SEGMENT_SZ] = {{0}};
|
|
|
|
if (GetCipherSegment(cipher, n) == NULL) {
|
|
WOLFSSL_MSG("no suitable cipher name found");
|
|
return NID_undef;
|
|
}
|
|
|
|
authStr = GetCipherAuthStr(n);
|
|
|
|
if (authStr != NULL) {
|
|
const struct authnid* sa;
|
|
for(sa = authnid_tbl; sa->alg_name != NULL; sa++) {
|
|
if (XSTRCMP(sa->alg_name, authStr) == 0) {
|
|
return sa->nid;
|
|
}
|
|
}
|
|
}
|
|
|
|
return NID_undef;
|
|
}
|
|
/* return cipher NID corresponding to cipher suite
|
|
* @param cipher a pointer to WOLFSSL_CIPHER
|
|
* return NID if found, NID_undef if not found
|
|
*/
|
|
int wolfSSL_CIPHER_get_cipher_nid(const WOLFSSL_CIPHER* cipher)
|
|
{
|
|
static const struct ciphernid {
|
|
const char* alg_name;
|
|
const int nid;
|
|
} ciphernid_tbl[] = {
|
|
{"AESGCM(256)", NID_aes_256_gcm},
|
|
{"AESGCM(128)", NID_aes_128_gcm},
|
|
{"AESCCM(128)", NID_aes_128_ccm},
|
|
{"AES(128)", NID_aes_128_cbc},
|
|
{"AES(256)", NID_aes_256_cbc},
|
|
{"CAMELLIA(256)", NID_camellia_256_cbc},
|
|
{"CAMELLIA(128)", NID_camellia_128_cbc},
|
|
{"RC4", NID_rc4},
|
|
{"3DES", NID_des_ede3_cbc},
|
|
{"CHACHA20/POLY1305(256)", NID_chacha20_poly1305},
|
|
{"None", NID_undef},
|
|
{NULL, NID_undef}
|
|
};
|
|
|
|
const char* encStr;
|
|
char n[MAX_SEGMENTS][MAX_SEGMENT_SZ] = {{0}};
|
|
|
|
WOLFSSL_ENTER("wolfSSL_CIPHER_get_cipher_nid");
|
|
|
|
if (GetCipherSegment(cipher, n) == NULL) {
|
|
WOLFSSL_MSG("no suitable cipher name found");
|
|
return NID_undef;
|
|
}
|
|
|
|
encStr = GetCipherEncStr(n);
|
|
|
|
if (encStr != NULL) {
|
|
const struct ciphernid* c;
|
|
for(c = ciphernid_tbl; c->alg_name != NULL; c++) {
|
|
if (XSTRCMP(c->alg_name, encStr) == 0) {
|
|
return c->nid;
|
|
}
|
|
}
|
|
}
|
|
|
|
return NID_undef;
|
|
}
|
|
/* return digest NID corresponding to cipher suite
|
|
* @param cipher a pointer to WOLFSSL_CIPHER
|
|
* return NID if found, NID_undef if not found
|
|
*/
|
|
int wolfSSL_CIPHER_get_digest_nid(const WOLFSSL_CIPHER* cipher)
|
|
{
|
|
static const struct macnid {
|
|
const char* alg_name;
|
|
const int nid;
|
|
} macnid_tbl[] = {
|
|
{"SHA1", NID_sha1},
|
|
{"SHA256", NID_sha256},
|
|
{"SHA384", NID_sha384},
|
|
{NULL, NID_undef}
|
|
};
|
|
|
|
const char* name;
|
|
const char* macStr;
|
|
char n[MAX_SEGMENTS][MAX_SEGMENT_SZ] = {{0}};
|
|
(void)name;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_CIPHER_get_digest_nid");
|
|
|
|
if ((name = GetCipherSegment(cipher, n)) == NULL) {
|
|
WOLFSSL_MSG("no suitable cipher name found");
|
|
return NID_undef;
|
|
}
|
|
|
|
/* in MD5 case, NID will be NID_md5 */
|
|
if (XSTRSTR(name, "MD5") != NULL) {
|
|
return NID_md5;
|
|
}
|
|
|
|
macStr = GetCipherMacStr(n);
|
|
|
|
if (macStr != NULL) {
|
|
const struct macnid* mc;
|
|
for(mc = macnid_tbl; mc->alg_name != NULL; mc++) {
|
|
if (XSTRCMP(mc->alg_name, macStr) == 0) {
|
|
return mc->nid;
|
|
}
|
|
}
|
|
}
|
|
|
|
return NID_undef;
|
|
}
|
|
/* return key exchange NID corresponding to cipher suite
|
|
* @param cipher a pointer to WOLFSSL_CIPHER
|
|
* return NID if found, NID_undef if not found
|
|
*/
|
|
int wolfSSL_CIPHER_get_kx_nid(const WOLFSSL_CIPHER* cipher)
|
|
{
|
|
static const struct kxnid {
|
|
const char* name;
|
|
const int nid;
|
|
} kxnid_table[] = {
|
|
{"ECDHEPSK", NID_kx_ecdhe_psk},
|
|
{"ECDH", NID_kx_ecdhe},
|
|
{"DHEPSK", NID_kx_dhe_psk},
|
|
{"DH", NID_kx_dhe},
|
|
{"RSAPSK", NID_kx_rsa_psk},
|
|
{"SRP", NID_kx_srp},
|
|
{"EDH", NID_kx_dhe},
|
|
{"RSA", NID_kx_rsa},
|
|
{NULL, NID_undef}
|
|
};
|
|
|
|
const char* keaStr;
|
|
char n[MAX_SEGMENTS][MAX_SEGMENT_SZ] = {{0}};
|
|
|
|
WOLFSSL_ENTER("wolfSSL_CIPHER_get_kx_nid");
|
|
|
|
if (GetCipherSegment(cipher, n) == NULL) {
|
|
WOLFSSL_MSG("no suitable cipher name found");
|
|
return NID_undef;
|
|
}
|
|
|
|
/* in TLS 1.3 case, NID will be NID_kx_any */
|
|
if (XSTRCMP(n[0], "TLS13") == 0) {
|
|
return NID_kx_any;
|
|
}
|
|
|
|
keaStr = GetCipherKeaStr(n);
|
|
|
|
if (keaStr != NULL) {
|
|
const struct kxnid* k;
|
|
for(k = kxnid_table; k->name != NULL; k++) {
|
|
if (XSTRCMP(k->name, keaStr) == 0) {
|
|
return k->nid;
|
|
}
|
|
}
|
|
}
|
|
|
|
return NID_undef;
|
|
}
|
|
/* check if cipher suite is AEAD
|
|
* @param cipher a pointer to WOLFSSL_CIPHER
|
|
* return 1 if cipher is AEAD, 0 otherwise
|
|
*/
|
|
int wolfSSL_CIPHER_is_aead(const WOLFSSL_CIPHER* cipher)
|
|
{
|
|
char n[MAX_SEGMENTS][MAX_SEGMENT_SZ] = {{0}};
|
|
|
|
WOLFSSL_ENTER("wolfSSL_CIPHER_is_aead");
|
|
|
|
if (GetCipherSegment(cipher, n) == NULL) {
|
|
WOLFSSL_MSG("no suitable cipher name found");
|
|
return NID_undef;
|
|
}
|
|
|
|
return IsCipherAEAD(n);
|
|
}
|
|
/* Creates cipher->description based on cipher->offset
|
|
* cipher->offset is set in wolfSSL_get_ciphers_compat when it is added
|
|
* to a stack of ciphers.
|
|
* @param [in] cipher: A cipher from a stack of ciphers.
|
|
* return WOLFSSL_SUCCESS if cipher->description is set, else WOLFSSL_FAILURE
|
|
*/
|
|
int wolfSSL_sk_CIPHER_description(WOLFSSL_CIPHER* cipher)
|
|
{
|
|
int strLen;
|
|
unsigned long offset;
|
|
char* dp;
|
|
const char* name;
|
|
const char *keaStr, *authStr, *encStr, *macStr, *protocol;
|
|
char n[MAX_SEGMENTS][MAX_SEGMENT_SZ] = {{0}};
|
|
int len = MAX_DESCRIPTION_SZ-1;
|
|
const CipherSuiteInfo* cipher_names;
|
|
ProtocolVersion pv;
|
|
WOLFSSL_ENTER("wolfSSL_sk_CIPHER_description");
|
|
|
|
if (cipher == NULL)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
dp = cipher->description;
|
|
if (dp == NULL)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
cipher_names = GetCipherNames();
|
|
|
|
offset = cipher->offset;
|
|
if (offset >= (unsigned long)GetCipherNamesSize())
|
|
return WOLFSSL_FAILURE;
|
|
pv.major = cipher_names[offset].major;
|
|
pv.minor = cipher_names[offset].minor;
|
|
protocol = wolfSSL_internal_get_version(&pv);
|
|
|
|
if ((name = GetCipherSegment(cipher, n)) == NULL) {
|
|
WOLFSSL_MSG("no suitable cipher name found");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
/* keaStr */
|
|
keaStr = GetCipherKeaStr(n);
|
|
/* authStr */
|
|
authStr = GetCipherAuthStr(n);
|
|
/* encStr */
|
|
encStr = GetCipherEncStr(n);
|
|
if ((cipher->bits = SetCipherBits(encStr)) == WOLFSSL_FAILURE) {
|
|
WOLFSSL_MSG("Cipher Bits Not Set.");
|
|
}
|
|
/* macStr */
|
|
macStr = GetCipherMacStr(n);
|
|
|
|
|
|
/* Build up the string by copying onto the end. */
|
|
XSTRNCPY(dp, name, len);
|
|
dp[len-1] = '\0'; strLen = (int)XSTRLEN(dp);
|
|
len -= strLen; dp += strLen;
|
|
|
|
XSTRNCPY(dp, " ", len);
|
|
dp[len-1] = '\0'; strLen = (int)XSTRLEN(dp);
|
|
len -= strLen; dp += strLen;
|
|
XSTRNCPY(dp, protocol, len);
|
|
dp[len-1] = '\0'; strLen = (int)XSTRLEN(dp);
|
|
len -= strLen; dp += strLen;
|
|
|
|
XSTRNCPY(dp, " Kx=", len);
|
|
dp[len-1] = '\0'; strLen = (int)XSTRLEN(dp);
|
|
len -= strLen; dp += strLen;
|
|
XSTRNCPY(dp, keaStr, len);
|
|
dp[len-1] = '\0'; strLen = (int)XSTRLEN(dp);
|
|
len -= strLen; dp += strLen;
|
|
|
|
XSTRNCPY(dp, " Au=", len);
|
|
dp[len-1] = '\0'; strLen = (int)XSTRLEN(dp);
|
|
len -= strLen; dp += strLen;
|
|
XSTRNCPY(dp, authStr, len);
|
|
dp[len-1] = '\0'; strLen = (int)XSTRLEN(dp);
|
|
len -= strLen; dp += strLen;
|
|
|
|
XSTRNCPY(dp, " Enc=", len);
|
|
dp[len-1] = '\0'; strLen = (int)XSTRLEN(dp);
|
|
len -= strLen; dp += strLen;
|
|
XSTRNCPY(dp, encStr, len);
|
|
dp[len-1] = '\0'; strLen = (int)XSTRLEN(dp);
|
|
len -= strLen; dp += strLen;
|
|
|
|
XSTRNCPY(dp, " Mac=", len);
|
|
dp[len-1] = '\0'; strLen = (int)XSTRLEN(dp);
|
|
len -= strLen; dp += strLen;
|
|
XSTRNCPY(dp, macStr, len);
|
|
dp[len-1] = '\0';
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
#endif /* OPENSSL_ALL || WOLFSSL_QT */
|
|
|
|
static WC_INLINE const char* wolfssl_kea_to_string(int kea)
|
|
{
|
|
const char* keaStr;
|
|
|
|
switch (kea) {
|
|
case no_kea:
|
|
keaStr = "None";
|
|
break;
|
|
#ifndef NO_RSA
|
|
case rsa_kea:
|
|
keaStr = "RSA";
|
|
break;
|
|
#endif
|
|
#ifndef NO_DH
|
|
case diffie_hellman_kea:
|
|
keaStr = "DHE";
|
|
break;
|
|
#endif
|
|
case fortezza_kea:
|
|
keaStr = "FZ";
|
|
break;
|
|
#ifndef NO_PSK
|
|
case psk_kea:
|
|
keaStr = "PSK";
|
|
break;
|
|
#ifndef NO_DH
|
|
case dhe_psk_kea:
|
|
keaStr = "DHEPSK";
|
|
break;
|
|
#endif
|
|
#ifdef HAVE_ECC
|
|
case ecdhe_psk_kea:
|
|
keaStr = "ECDHEPSK";
|
|
break;
|
|
#endif
|
|
#endif
|
|
#ifdef HAVE_ECC
|
|
case ecc_diffie_hellman_kea:
|
|
keaStr = "ECDHE";
|
|
break;
|
|
case ecc_static_diffie_hellman_kea:
|
|
keaStr = "ECDH";
|
|
break;
|
|
#endif
|
|
default:
|
|
keaStr = "unknown";
|
|
break;
|
|
}
|
|
|
|
return keaStr;
|
|
}
|
|
|
|
static WC_INLINE const char* wolfssl_sigalg_to_string(int sig_algo)
|
|
{
|
|
const char* authStr;
|
|
|
|
switch (sig_algo) {
|
|
case anonymous_sa_algo:
|
|
authStr = "None";
|
|
break;
|
|
#ifndef NO_RSA
|
|
case rsa_sa_algo:
|
|
authStr = "RSA";
|
|
break;
|
|
#ifdef WC_RSA_PSS
|
|
case rsa_pss_sa_algo:
|
|
authStr = "RSA-PSS";
|
|
break;
|
|
#endif
|
|
#endif
|
|
#ifndef NO_DSA
|
|
case dsa_sa_algo:
|
|
authStr = "DSA";
|
|
break;
|
|
#endif
|
|
#ifdef HAVE_ECC
|
|
case ecc_dsa_sa_algo:
|
|
authStr = "ECDSA";
|
|
break;
|
|
#endif
|
|
#ifdef WOLFSSL_SM2
|
|
case sm2_sa_algo:
|
|
authStr = "SM2";
|
|
break;
|
|
#endif
|
|
#ifdef HAVE_ED25519
|
|
case ed25519_sa_algo:
|
|
authStr = "Ed25519";
|
|
break;
|
|
#endif
|
|
#ifdef HAVE_ED448
|
|
case ed448_sa_algo:
|
|
authStr = "Ed448";
|
|
break;
|
|
#endif
|
|
default:
|
|
authStr = "unknown";
|
|
break;
|
|
}
|
|
|
|
return authStr;
|
|
}
|
|
|
|
static WC_INLINE const char* wolfssl_cipher_to_string(int cipher, int key_size)
|
|
{
|
|
const char* encStr;
|
|
|
|
(void)key_size;
|
|
|
|
switch (cipher) {
|
|
case wolfssl_cipher_null:
|
|
encStr = "None";
|
|
break;
|
|
#ifndef NO_RC4
|
|
case wolfssl_rc4:
|
|
encStr = "RC4(128)";
|
|
break;
|
|
#endif
|
|
#ifndef NO_DES3
|
|
case wolfssl_triple_des:
|
|
encStr = "3DES(168)";
|
|
break;
|
|
#endif
|
|
#ifndef NO_AES
|
|
case wolfssl_aes:
|
|
if (key_size == 128)
|
|
encStr = "AES(128)";
|
|
else if (key_size == 256)
|
|
encStr = "AES(256)";
|
|
else
|
|
encStr = "AES(?)";
|
|
break;
|
|
#ifdef HAVE_AESGCM
|
|
case wolfssl_aes_gcm:
|
|
if (key_size == 128)
|
|
encStr = "AESGCM(128)";
|
|
else if (key_size == 256)
|
|
encStr = "AESGCM(256)";
|
|
else
|
|
encStr = "AESGCM(?)";
|
|
break;
|
|
#endif
|
|
#ifdef HAVE_AESCCM
|
|
case wolfssl_aes_ccm:
|
|
if (key_size == 128)
|
|
encStr = "AESCCM(128)";
|
|
else if (key_size == 256)
|
|
encStr = "AESCCM(256)";
|
|
else
|
|
encStr = "AESCCM(?)";
|
|
break;
|
|
#endif
|
|
#endif
|
|
#ifdef HAVE_CHACHA
|
|
case wolfssl_chacha:
|
|
encStr = "CHACHA20/POLY1305(256)";
|
|
break;
|
|
#endif
|
|
#ifdef HAVE_ARIA
|
|
case wolfssl_aria_gcm:
|
|
if (key_size == 128)
|
|
encStr = "Aria(128)";
|
|
else if (key_size == 192)
|
|
encStr = "Aria(192)";
|
|
else if (key_size == 256)
|
|
encStr = "Aria(256)";
|
|
else
|
|
encStr = "Aria(?)";
|
|
break;
|
|
#endif
|
|
#ifdef HAVE_CAMELLIA
|
|
case wolfssl_camellia:
|
|
if (key_size == 128)
|
|
encStr = "Camellia(128)";
|
|
else if (key_size == 256)
|
|
encStr = "Camellia(256)";
|
|
else
|
|
encStr = "Camellia(?)";
|
|
break;
|
|
#endif
|
|
default:
|
|
encStr = "unknown";
|
|
break;
|
|
}
|
|
|
|
return encStr;
|
|
}
|
|
|
|
static WC_INLINE const char* wolfssl_mac_to_string(int mac)
|
|
{
|
|
const char* macStr;
|
|
|
|
switch (mac) {
|
|
case no_mac:
|
|
macStr = "None";
|
|
break;
|
|
#ifndef NO_MD5
|
|
case md5_mac:
|
|
macStr = "MD5";
|
|
break;
|
|
#endif
|
|
#ifndef NO_SHA
|
|
case sha_mac:
|
|
macStr = "SHA1";
|
|
break;
|
|
#endif
|
|
#ifdef HAVE_SHA224
|
|
case sha224_mac:
|
|
macStr = "SHA224";
|
|
break;
|
|
#endif
|
|
#ifndef NO_SHA256
|
|
case sha256_mac:
|
|
macStr = "SHA256";
|
|
break;
|
|
#endif
|
|
#ifdef HAVE_SHA384
|
|
case sha384_mac:
|
|
macStr = "SHA384";
|
|
break;
|
|
#endif
|
|
#ifdef HAVE_SHA512
|
|
case sha512_mac:
|
|
macStr = "SHA512";
|
|
break;
|
|
#endif
|
|
default:
|
|
macStr = "unknown";
|
|
break;
|
|
}
|
|
|
|
return macStr;
|
|
}
|
|
|
|
char* wolfSSL_CIPHER_description(const WOLFSSL_CIPHER* cipher, char* in,
|
|
int len)
|
|
{
|
|
char *ret = in;
|
|
const char *keaStr, *authStr, *encStr, *macStr;
|
|
size_t strLen;
|
|
WOLFSSL_ENTER("wolfSSL_CIPHER_description");
|
|
|
|
if (cipher == NULL || in == NULL)
|
|
return NULL;
|
|
|
|
#if defined(WOLFSSL_QT) || defined(OPENSSL_ALL)
|
|
/* if cipher is in the stack from wolfSSL_get_ciphers_compat then
|
|
* Return the description based on cipher_names[cipher->offset]
|
|
*/
|
|
if (cipher->in_stack == TRUE) {
|
|
wolfSSL_sk_CIPHER_description((WOLFSSL_CIPHER*)cipher);
|
|
XSTRNCPY(in,cipher->description,len);
|
|
return ret;
|
|
}
|
|
#endif
|
|
|
|
/* Get the cipher description based on the SSL session cipher */
|
|
keaStr = wolfssl_kea_to_string(cipher->ssl->specs.kea);
|
|
authStr = wolfssl_sigalg_to_string(cipher->ssl->specs.sig_algo);
|
|
encStr = wolfssl_cipher_to_string(cipher->ssl->specs.bulk_cipher_algorithm,
|
|
cipher->ssl->specs.key_size);
|
|
macStr = wolfssl_mac_to_string(cipher->ssl->specs.mac_algorithm);
|
|
|
|
/* Build up the string by copying onto the end. */
|
|
XSTRNCPY(in, wolfSSL_CIPHER_get_name(cipher), len);
|
|
in[len-1] = '\0'; strLen = XSTRLEN(in); len -= (int)strLen; in += strLen;
|
|
|
|
XSTRNCPY(in, " ", len);
|
|
in[len-1] = '\0'; strLen = XSTRLEN(in); len -= (int)strLen; in += strLen;
|
|
XSTRNCPY(in, wolfSSL_get_version(cipher->ssl), len);
|
|
in[len-1] = '\0'; strLen = XSTRLEN(in); len -= (int)strLen; in += strLen;
|
|
|
|
XSTRNCPY(in, " Kx=", len);
|
|
in[len-1] = '\0'; strLen = XSTRLEN(in); len -= (int)strLen; in += strLen;
|
|
XSTRNCPY(in, keaStr, len);
|
|
in[len-1] = '\0'; strLen = XSTRLEN(in); len -= (int)strLen; in += strLen;
|
|
|
|
XSTRNCPY(in, " Au=", len);
|
|
in[len-1] = '\0'; strLen = XSTRLEN(in); len -= (int)strLen; in += strLen;
|
|
XSTRNCPY(in, authStr, len);
|
|
in[len-1] = '\0'; strLen = XSTRLEN(in); len -= (int)strLen; in += strLen;
|
|
|
|
XSTRNCPY(in, " Enc=", len);
|
|
in[len-1] = '\0'; strLen = XSTRLEN(in); len -= (int)strLen; in += strLen;
|
|
XSTRNCPY(in, encStr, len);
|
|
in[len-1] = '\0'; strLen = XSTRLEN(in); len -= (int)strLen; in += strLen;
|
|
|
|
XSTRNCPY(in, " Mac=", len);
|
|
in[len-1] = '\0'; strLen = XSTRLEN(in); len -= (int)strLen; in += strLen;
|
|
XSTRNCPY(in, macStr, len);
|
|
in[len-1] = '\0';
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
#ifndef NO_WOLFSSL_STUB
|
|
int wolfSSL_OCSP_parse_url(char* url, char** host, char** port, char** path,
|
|
int* ssl)
|
|
{
|
|
(void)url;
|
|
(void)host;
|
|
(void)port;
|
|
(void)path;
|
|
(void)ssl;
|
|
WOLFSSL_STUB("OCSP_parse_url");
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
#ifndef NO_WOLFSSL_STUB
|
|
void wolfSSL_RAND_screen(void)
|
|
{
|
|
WOLFSSL_STUB("RAND_screen");
|
|
}
|
|
#endif
|
|
|
|
|
|
|
|
int wolfSSL_RAND_load_file(const char* fname, long len)
|
|
{
|
|
(void)fname;
|
|
/* wolfCrypt provides enough entropy internally or will report error */
|
|
if (len == -1)
|
|
return 1024;
|
|
else
|
|
return (int)len;
|
|
}
|
|
|
|
|
|
#ifndef NO_WOLFSSL_STUB
|
|
WOLFSSL_COMP_METHOD* wolfSSL_COMP_zlib(void)
|
|
{
|
|
WOLFSSL_STUB("COMP_zlib");
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
#ifndef NO_WOLFSSL_STUB
|
|
WOLFSSL_COMP_METHOD* wolfSSL_COMP_rle(void)
|
|
{
|
|
WOLFSSL_STUB("COMP_rle");
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
#ifndef NO_WOLFSSL_STUB
|
|
int wolfSSL_COMP_add_compression_method(int method, void* data)
|
|
{
|
|
(void)method;
|
|
(void)data;
|
|
WOLFSSL_STUB("COMP_add_compression_method");
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
/* wolfSSL_set_dynlock_create_callback
|
|
* CRYPTO_set_dynlock_create_callback has been deprecated since openSSL 1.0.1.
|
|
* This function exists for compatibility purposes because wolfSSL satisfies
|
|
* thread safety without relying on the callback.
|
|
*/
|
|
void wolfSSL_set_dynlock_create_callback(WOLFSSL_dynlock_value* (*f)(
|
|
const char*, int))
|
|
{
|
|
WOLFSSL_STUB("CRYPTO_set_dynlock_create_callback");
|
|
(void)f;
|
|
}
|
|
/* wolfSSL_set_dynlock_lock_callback
|
|
* CRYPTO_set_dynlock_lock_callback has been deprecated since openSSL 1.0.1.
|
|
* This function exists for compatibility purposes because wolfSSL satisfies
|
|
* thread safety without relying on the callback.
|
|
*/
|
|
void wolfSSL_set_dynlock_lock_callback(
|
|
void (*f)(int, WOLFSSL_dynlock_value*, const char*, int))
|
|
{
|
|
WOLFSSL_STUB("CRYPTO_set_set_dynlock_lock_callback");
|
|
(void)f;
|
|
}
|
|
/* wolfSSL_set_dynlock_destroy_callback
|
|
* CRYPTO_set_dynlock_destroy_callback has been deprecated since openSSL 1.0.1.
|
|
* This function exists for compatibility purposes because wolfSSL satisfies
|
|
* thread safety without relying on the callback.
|
|
*/
|
|
void wolfSSL_set_dynlock_destroy_callback(
|
|
void (*f)(WOLFSSL_dynlock_value*, const char*, int))
|
|
{
|
|
WOLFSSL_STUB("CRYPTO_set_set_dynlock_destroy_callback");
|
|
(void)f;
|
|
}
|
|
|
|
|
|
#endif /* OPENSSL_EXTRA */
|
|
|
|
#ifdef OPENSSL_EXTRA
|
|
#ifndef NO_CERTS
|
|
|
|
#if !defined(NO_ASN) && !defined(NO_PWDBASED)
|
|
/* Copies unencrypted DER key buffer into "der". If "der" is null then the size
|
|
* of buffer needed is returned. If *der == NULL then it allocates a buffer.
|
|
* NOTE: This also advances the "der" pointer to be at the end of buffer.
|
|
*
|
|
* Returns size of key buffer on success
|
|
*/
|
|
int wolfSSL_i2d_PrivateKey(const WOLFSSL_EVP_PKEY* key, unsigned char** der)
|
|
{
|
|
return wolfSSL_EVP_PKEY_get_der(key, der);
|
|
}
|
|
|
|
int wolfSSL_i2d_PublicKey(const WOLFSSL_EVP_PKEY *key, unsigned char **der)
|
|
{
|
|
#if !defined(NO_RSA) || defined(HAVE_ECC)
|
|
#ifdef HAVE_ECC
|
|
unsigned char *local_der = NULL;
|
|
word32 local_derSz = 0;
|
|
unsigned char *pub_der = NULL;
|
|
ecc_key *eccKey = NULL;
|
|
word32 inOutIdx = 0;
|
|
#endif
|
|
word32 pub_derSz = 0;
|
|
int ret;
|
|
int key_type = 0;
|
|
|
|
if (key == NULL) {
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
|
|
key_type = key->type;
|
|
if ((key_type != EVP_PKEY_EC) && (key_type != EVP_PKEY_RSA)) {
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
|
|
#ifndef NO_RSA
|
|
if (key_type == EVP_PKEY_RSA) {
|
|
return wolfSSL_i2d_RSAPublicKey(key->rsa, der);
|
|
}
|
|
#endif
|
|
|
|
/* Now that RSA is taken care of, we only need to consider the ECC case. */
|
|
|
|
#ifdef HAVE_ECC
|
|
|
|
/* We need to get the DER, then convert it to a public key. But what we get
|
|
* might be a buffered private key so we need to decode it and then encode
|
|
* the public part. */
|
|
ret = wolfSSL_EVP_PKEY_get_der(key, &local_der);
|
|
if (ret <= 0) {
|
|
/* In this case, there was no buffered DER at all. This could be the
|
|
* case where the key that was passed in was generated. So now we
|
|
* have to create the local DER. */
|
|
local_derSz = wolfSSL_i2d_ECPrivateKey(key->ecc, &local_der);
|
|
if (local_derSz == 0) {
|
|
ret = WOLFSSL_FATAL_ERROR;
|
|
}
|
|
} else {
|
|
local_derSz = ret;
|
|
ret = 0;
|
|
}
|
|
|
|
if (ret == 0) {
|
|
eccKey = (ecc_key *)XMALLOC(sizeof(*eccKey), NULL, DYNAMIC_TYPE_ECC);
|
|
if (eccKey == NULL) {
|
|
WOLFSSL_MSG("Failed to allocate key buffer.");
|
|
ret = WOLFSSL_FATAL_ERROR;
|
|
}
|
|
}
|
|
|
|
if (ret == 0) {
|
|
ret = wc_ecc_init(eccKey);
|
|
}
|
|
|
|
if (ret == 0) {
|
|
ret = wc_EccPublicKeyDecode(local_der, &inOutIdx, eccKey, local_derSz);
|
|
if (ret < 0) {
|
|
/* We now try again as x.963 [point type][x][opt y]. */
|
|
ret = wc_ecc_import_x963(local_der, local_derSz, eccKey);
|
|
}
|
|
}
|
|
|
|
if (ret == 0) {
|
|
pub_derSz = wc_EccPublicKeyDerSize(eccKey, 0);
|
|
if ((int)pub_derSz <= 0) {
|
|
ret = WOLFSSL_FAILURE;
|
|
}
|
|
}
|
|
|
|
if (ret == 0) {
|
|
pub_der = (unsigned char*)XMALLOC(pub_derSz, NULL,
|
|
DYNAMIC_TYPE_PUBLIC_KEY);
|
|
if (pub_der == NULL) {
|
|
WOLFSSL_MSG("Failed to allocate output buffer.");
|
|
ret = WOLFSSL_FATAL_ERROR;
|
|
}
|
|
}
|
|
|
|
if (ret == 0) {
|
|
pub_derSz = wc_EccPublicKeyToDer(eccKey, pub_der, pub_derSz, 0);
|
|
if ((int)pub_derSz <= 0) {
|
|
ret = WOLFSSL_FATAL_ERROR;
|
|
}
|
|
}
|
|
|
|
/* This block is for actually returning the DER of the public key */
|
|
if ((ret == 0) && (der != NULL)) {
|
|
if (*der == NULL) {
|
|
*der = (unsigned char*)XMALLOC(pub_derSz, NULL,
|
|
DYNAMIC_TYPE_PUBLIC_KEY);
|
|
if (*der == NULL) {
|
|
WOLFSSL_MSG("Failed to allocate output buffer.");
|
|
ret = WOLFSSL_FATAL_ERROR;
|
|
}
|
|
|
|
if (ret == 0) {
|
|
XMEMCPY(*der, pub_der, pub_derSz);
|
|
}
|
|
}
|
|
else {
|
|
XMEMCPY(*der, pub_der, pub_derSz);
|
|
*der += pub_derSz;
|
|
}
|
|
}
|
|
|
|
XFREE(pub_der, NULL, DYNAMIC_TYPE_PUBLIC_KEY);
|
|
XFREE(local_der, NULL, DYNAMIC_TYPE_PUBLIC_KEY);
|
|
|
|
wc_ecc_free(eccKey);
|
|
XFREE(eccKey, NULL, DYNAMIC_TYPE_ECC);
|
|
|
|
#else
|
|
ret = WOLFSSL_FATAL_ERROR;
|
|
#endif /* HAVE_ECC */
|
|
|
|
if (ret == 0) {
|
|
return pub_derSz;
|
|
}
|
|
|
|
return ret;
|
|
#else
|
|
return WOLFSSL_FATAL_ERROR;
|
|
#endif /* !NO_RSA || HAVE_ECC */
|
|
}
|
|
#endif /* !NO_ASN && !NO_PWDBASED */
|
|
|
|
#endif /* !NO_CERTS */
|
|
#endif /* OPENSSL_EXTRA */
|
|
|
|
#ifdef OPENSSL_EXTRA
|
|
|
|
/* Sets the DNS hostname to name.
|
|
* Hostname is cleared if name is NULL or empty. */
|
|
int wolfSSL_set1_host(WOLFSSL * ssl, const char* name)
|
|
{
|
|
if (ssl == NULL) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
return wolfSSL_X509_VERIFY_PARAM_set1_host(ssl->param, name, 0);
|
|
}
|
|
|
|
/******************************************************************************
|
|
* wolfSSL_CTX_set1_param - set a pointer to the SSL verification parameters
|
|
*
|
|
* RETURNS:
|
|
* WOLFSSL_SUCCESS on success, otherwise returns WOLFSSL_FAILURE
|
|
* Note: Returns WOLFSSL_SUCCESS, in case either parameter is NULL,
|
|
* same as openssl.
|
|
*/
|
|
int wolfSSL_CTX_set1_param(WOLFSSL_CTX* ctx, WOLFSSL_X509_VERIFY_PARAM *vpm)
|
|
{
|
|
if (ctx == NULL || vpm == NULL)
|
|
return WOLFSSL_SUCCESS;
|
|
|
|
return wolfSSL_X509_VERIFY_PARAM_set1(ctx->param, vpm);
|
|
}
|
|
|
|
/******************************************************************************
|
|
* wolfSSL_CTX/_get0_param - return a pointer to the SSL verification parameters
|
|
*
|
|
* RETURNS:
|
|
* returns pointer to the SSL verification parameters on success,
|
|
* otherwise returns NULL
|
|
*/
|
|
WOLFSSL_X509_VERIFY_PARAM* wolfSSL_CTX_get0_param(WOLFSSL_CTX* ctx)
|
|
{
|
|
if (ctx == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
return ctx->param;
|
|
}
|
|
|
|
WOLFSSL_X509_VERIFY_PARAM* wolfSSL_get0_param(WOLFSSL* ssl)
|
|
{
|
|
if (ssl == NULL) {
|
|
return NULL;
|
|
}
|
|
return ssl->param;
|
|
}
|
|
|
|
#endif /* OPENSSL_EXTRA */
|
|
|
|
#if defined(OPENSSL_EXTRA) || defined(WOLFSSL_WPAS_SMALL)
|
|
/* Gets an index to store SSL structure at.
|
|
*
|
|
* Returns positive index on success and negative values on failure
|
|
*/
|
|
int wolfSSL_get_ex_data_X509_STORE_CTX_idx(void)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_get_ex_data_X509_STORE_CTX_idx");
|
|
|
|
/* store SSL at index 0 */
|
|
return 0;
|
|
}
|
|
#endif /* OPENSSL_EXTRA || WOLFSSL_WPAS_SMALL */
|
|
|
|
#ifdef OPENSSL_EXTRA
|
|
/* Sets a function callback that will send information about the state of all
|
|
* WOLFSSL objects that have been created by the WOLFSSL_CTX structure passed
|
|
* in.
|
|
*
|
|
* ctx WOLFSSL_CTX structure to set callback function in
|
|
* f callback function to use
|
|
*/
|
|
void wolfSSL_CTX_set_info_callback(WOLFSSL_CTX* ctx,
|
|
void (*f)(const WOLFSSL* ssl, int type, int val))
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_set_info_callback");
|
|
if (ctx == NULL) {
|
|
WOLFSSL_MSG("Bad function argument");
|
|
}
|
|
else {
|
|
ctx->CBIS = f;
|
|
}
|
|
}
|
|
|
|
void wolfSSL_set_info_callback(WOLFSSL* ssl,
|
|
void (*f)(const WOLFSSL* ssl, int type, int val))
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_set_info_callback");
|
|
if (ssl == NULL) {
|
|
WOLFSSL_MSG("Bad function argument");
|
|
}
|
|
else {
|
|
ssl->CBIS = f;
|
|
}
|
|
}
|
|
|
|
|
|
unsigned long wolfSSL_ERR_peek_error(void)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_ERR_peek_error");
|
|
|
|
return wolfSSL_ERR_peek_error_line_data(NULL, NULL, NULL, NULL);
|
|
}
|
|
|
|
int wolfSSL_ERR_GET_LIB(unsigned long err)
|
|
{
|
|
unsigned long value;
|
|
|
|
value = (err & 0xFFFFFFL);
|
|
switch (value) {
|
|
case -SSL_R_HTTP_REQUEST:
|
|
return ERR_LIB_SSL;
|
|
case -ASN_NO_PEM_HEADER:
|
|
case PEM_R_NO_START_LINE:
|
|
case PEM_R_PROBLEMS_GETTING_PASSWORD:
|
|
case PEM_R_BAD_PASSWORD_READ:
|
|
case PEM_R_BAD_DECRYPT:
|
|
return ERR_LIB_PEM;
|
|
case EVP_R_BAD_DECRYPT:
|
|
case EVP_R_BN_DECODE_ERROR:
|
|
case EVP_R_DECODE_ERROR:
|
|
case EVP_R_PRIVATE_KEY_DECODE_ERROR:
|
|
return ERR_LIB_EVP;
|
|
case ASN1_R_HEADER_TOO_LONG:
|
|
return ERR_LIB_ASN1;
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/* This function is to find global error values that are the same through out
|
|
* all library version. With wolfSSL having only one set of error codes the
|
|
* return value is pretty straight forward. The only thing needed is all wolfSSL
|
|
* error values are typically negative.
|
|
*
|
|
* Returns the error reason
|
|
*/
|
|
int wolfSSL_ERR_GET_REASON(unsigned long err)
|
|
{
|
|
int ret = (int)err;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_ERR_GET_REASON");
|
|
|
|
#if defined(OPENSSL_ALL) || defined(WOLFSSL_NGINX) || defined(WOLFSSL_HAPROXY)
|
|
/* Nginx looks for this error to know to stop parsing certificates.
|
|
* Same for HAProxy. */
|
|
if (err == ((ERR_LIB_PEM << 24) | PEM_R_NO_START_LINE) ||
|
|
((err & 0xFFFFFFL) == -ASN_NO_PEM_HEADER) ||
|
|
((err & 0xFFFL) == PEM_R_NO_START_LINE ))
|
|
return PEM_R_NO_START_LINE;
|
|
if (err == ((ERR_LIB_SSL << 24) | -SSL_R_HTTP_REQUEST))
|
|
return SSL_R_HTTP_REQUEST;
|
|
#endif
|
|
#if defined(OPENSSL_ALL) && defined(WOLFSSL_PYTHON)
|
|
if (err == ((ERR_LIB_ASN1 << 24) | ASN1_R_HEADER_TOO_LONG))
|
|
return ASN1_R_HEADER_TOO_LONG;
|
|
#endif
|
|
|
|
/* check if error value is in range of wolfSSL errors */
|
|
ret = 0 - ret; /* setting as negative value */
|
|
/* wolfCrypt range is less than MAX (-100)
|
|
wolfSSL range is MIN (-300) and lower */
|
|
if (ret < MAX_CODE_E && ret > MIN_CODE_E) {
|
|
return ret;
|
|
}
|
|
else {
|
|
WOLFSSL_MSG("Not in range of typical error values");
|
|
ret = (int)err;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/* returns a string that describes the alert
|
|
*
|
|
* alertID the alert value to look up
|
|
*/
|
|
const char* wolfSSL_alert_type_string_long(int alertID)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_alert_type_string_long");
|
|
|
|
return AlertTypeToString(alertID);
|
|
}
|
|
|
|
|
|
const char* wolfSSL_alert_desc_string_long(int alertID)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_alert_desc_string_long");
|
|
|
|
return AlertTypeToString(alertID);
|
|
}
|
|
|
|
#define STATE_STRINGS_PROTO(s) \
|
|
{ \
|
|
{"SSLv3 " s, \
|
|
"SSLv3 " s, \
|
|
"SSLv3 " s}, \
|
|
{"TLSv1 " s, \
|
|
"TLSv1 " s, \
|
|
"TLSv1 " s}, \
|
|
{"TLSv1_1 " s, \
|
|
"TLSv1_1 " s, \
|
|
"TLSv1_1 " s}, \
|
|
{"TLSv1_2 " s, \
|
|
"TLSv1_2 " s, \
|
|
"TLSv1_2 " s}, \
|
|
{"TLSv1_3 " s, \
|
|
"TLSv1_3 " s, \
|
|
"TLSv1_3 " s}, \
|
|
{"DTLSv1 " s, \
|
|
"DTLSv1 " s, \
|
|
"DTLSv1 " s}, \
|
|
{"DTLSv1_2 " s, \
|
|
"DTLSv1_2 " s, \
|
|
"DTLSv1_2 " s}, \
|
|
{"DTLSv1_3 " s, \
|
|
"DTLSv1_3 " s, \
|
|
"DTLSv1_3 " s}, \
|
|
}
|
|
|
|
#define STATE_STRINGS_PROTO_RW(s) \
|
|
{ \
|
|
{"SSLv3 read " s, \
|
|
"SSLv3 write " s, \
|
|
"SSLv3 " s}, \
|
|
{"TLSv1 read " s, \
|
|
"TLSv1 write " s, \
|
|
"TLSv1 " s}, \
|
|
{"TLSv1_1 read " s, \
|
|
"TLSv1_1 write " s, \
|
|
"TLSv1_1 " s}, \
|
|
{"TLSv1_2 read " s, \
|
|
"TLSv1_2 write " s, \
|
|
"TLSv1_2 " s}, \
|
|
{"TLSv1_3 read " s, \
|
|
"TLSv1_3 write " s, \
|
|
"TLSv1_3 " s}, \
|
|
{"DTLSv1 read " s, \
|
|
"DTLSv1 write " s, \
|
|
"DTLSv1 " s}, \
|
|
{"DTLSv1_2 read " s, \
|
|
"DTLSv1_2 write " s, \
|
|
"DTLSv1_2 " s}, \
|
|
{"DTLSv1_3 read " s, \
|
|
"DTLSv1_3 write " s, \
|
|
"DTLSv1_3 " s}, \
|
|
}
|
|
|
|
/* Gets the current state of the WOLFSSL structure
|
|
*
|
|
* ssl WOLFSSL structure to get state of
|
|
*
|
|
* Returns a human readable string of the WOLFSSL structure state
|
|
*/
|
|
const char* wolfSSL_state_string_long(const WOLFSSL* ssl)
|
|
{
|
|
|
|
static const char* OUTPUT_STR[24][8][3] = {
|
|
STATE_STRINGS_PROTO("Initialization"),
|
|
STATE_STRINGS_PROTO_RW("Server Hello Request"),
|
|
STATE_STRINGS_PROTO_RW("Server Hello Verify Request"),
|
|
STATE_STRINGS_PROTO_RW("Server Hello Retry Request"),
|
|
STATE_STRINGS_PROTO_RW("Server Hello"),
|
|
STATE_STRINGS_PROTO_RW("Server Certificate Status"),
|
|
STATE_STRINGS_PROTO_RW("Server Encrypted Extensions"),
|
|
STATE_STRINGS_PROTO_RW("Server Session Ticket"),
|
|
STATE_STRINGS_PROTO_RW("Server Certificate Request"),
|
|
STATE_STRINGS_PROTO_RW("Server Cert"),
|
|
STATE_STRINGS_PROTO_RW("Server Key Exchange"),
|
|
STATE_STRINGS_PROTO_RW("Server Hello Done"),
|
|
STATE_STRINGS_PROTO_RW("Server Change CipherSpec"),
|
|
STATE_STRINGS_PROTO_RW("Server Finished"),
|
|
STATE_STRINGS_PROTO_RW("server Key Update"),
|
|
STATE_STRINGS_PROTO_RW("Client Hello"),
|
|
STATE_STRINGS_PROTO_RW("Client Key Exchange"),
|
|
STATE_STRINGS_PROTO_RW("Client Cert"),
|
|
STATE_STRINGS_PROTO_RW("Client Change CipherSpec"),
|
|
STATE_STRINGS_PROTO_RW("Client Certificate Verify"),
|
|
STATE_STRINGS_PROTO_RW("Client End Of Early Data"),
|
|
STATE_STRINGS_PROTO_RW("Client Finished"),
|
|
STATE_STRINGS_PROTO_RW("Client Key Update"),
|
|
STATE_STRINGS_PROTO("Handshake Done"),
|
|
};
|
|
enum ProtocolVer {
|
|
SSL_V3 = 0,
|
|
TLS_V1,
|
|
TLS_V1_1,
|
|
TLS_V1_2,
|
|
TLS_V1_3,
|
|
DTLS_V1,
|
|
DTLS_V1_2,
|
|
DTLS_V1_3,
|
|
UNKNOWN = 100
|
|
};
|
|
|
|
enum IOMode {
|
|
SS_READ = 0,
|
|
SS_WRITE,
|
|
SS_NEITHER
|
|
};
|
|
|
|
enum SslState {
|
|
ss_null_state = 0,
|
|
ss_server_hellorequest,
|
|
ss_server_helloverify,
|
|
ss_server_helloretryrequest,
|
|
ss_server_hello,
|
|
ss_server_certificatestatus,
|
|
ss_server_encryptedextensions,
|
|
ss_server_sessionticket,
|
|
ss_server_certrequest,
|
|
ss_server_cert,
|
|
ss_server_keyexchange,
|
|
ss_server_hellodone,
|
|
ss_server_changecipherspec,
|
|
ss_server_finished,
|
|
ss_server_keyupdate,
|
|
ss_client_hello,
|
|
ss_client_keyexchange,
|
|
ss_client_cert,
|
|
ss_client_changecipherspec,
|
|
ss_client_certverify,
|
|
ss_client_endofearlydata,
|
|
ss_client_finished,
|
|
ss_client_keyupdate,
|
|
ss_handshake_done
|
|
};
|
|
|
|
int protocol = 0;
|
|
int cbmode = 0;
|
|
int state = 0;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_state_string_long");
|
|
if (ssl == NULL) {
|
|
WOLFSSL_MSG("Null argument passed in");
|
|
return NULL;
|
|
}
|
|
|
|
/* Get state of callback */
|
|
if (ssl->cbmode == SSL_CB_MODE_WRITE) {
|
|
cbmode = SS_WRITE;
|
|
}
|
|
else if (ssl->cbmode == SSL_CB_MODE_READ) {
|
|
cbmode = SS_READ;
|
|
}
|
|
else {
|
|
cbmode = SS_NEITHER;
|
|
}
|
|
|
|
/* Get protocol version */
|
|
switch (ssl->version.major) {
|
|
case SSLv3_MAJOR:
|
|
switch (ssl->version.minor) {
|
|
case SSLv3_MINOR:
|
|
protocol = SSL_V3;
|
|
break;
|
|
case TLSv1_MINOR:
|
|
protocol = TLS_V1;
|
|
break;
|
|
case TLSv1_1_MINOR:
|
|
protocol = TLS_V1_1;
|
|
break;
|
|
case TLSv1_2_MINOR:
|
|
protocol = TLS_V1_2;
|
|
break;
|
|
case TLSv1_3_MINOR:
|
|
protocol = TLS_V1_3;
|
|
break;
|
|
default:
|
|
protocol = UNKNOWN;
|
|
}
|
|
break;
|
|
case DTLS_MAJOR:
|
|
switch (ssl->version.minor) {
|
|
case DTLS_MINOR:
|
|
protocol = DTLS_V1;
|
|
break;
|
|
case DTLSv1_2_MINOR:
|
|
protocol = DTLS_V1_2;
|
|
break;
|
|
case DTLSv1_3_MINOR:
|
|
protocol = DTLS_V1_3;
|
|
break;
|
|
default:
|
|
protocol = UNKNOWN;
|
|
}
|
|
break;
|
|
default:
|
|
protocol = UNKNOWN;
|
|
}
|
|
|
|
/* accept process */
|
|
if (ssl->cbmode == SSL_CB_MODE_READ) {
|
|
state = ssl->cbtype;
|
|
switch (state) {
|
|
case hello_request:
|
|
state = ss_server_hellorequest;
|
|
break;
|
|
case client_hello:
|
|
state = ss_client_hello;
|
|
break;
|
|
case server_hello:
|
|
state = ss_server_hello;
|
|
break;
|
|
case hello_verify_request:
|
|
state = ss_server_helloverify;
|
|
break;
|
|
case session_ticket:
|
|
state = ss_server_sessionticket;
|
|
break;
|
|
case end_of_early_data:
|
|
state = ss_client_endofearlydata;
|
|
break;
|
|
case hello_retry_request:
|
|
state = ss_server_helloretryrequest;
|
|
break;
|
|
case encrypted_extensions:
|
|
state = ss_server_encryptedextensions;
|
|
break;
|
|
case certificate:
|
|
if (ssl->options.side == WOLFSSL_SERVER_END)
|
|
state = ss_client_cert;
|
|
else if (ssl->options.side == WOLFSSL_CLIENT_END)
|
|
state = ss_server_cert;
|
|
else {
|
|
WOLFSSL_MSG("Unknown State");
|
|
state = ss_null_state;
|
|
}
|
|
break;
|
|
case server_key_exchange:
|
|
state = ss_server_keyexchange;
|
|
break;
|
|
case certificate_request:
|
|
state = ss_server_certrequest;
|
|
break;
|
|
case server_hello_done:
|
|
state = ss_server_hellodone;
|
|
break;
|
|
case certificate_verify:
|
|
state = ss_client_certverify;
|
|
break;
|
|
case client_key_exchange:
|
|
state = ss_client_keyexchange;
|
|
break;
|
|
case finished:
|
|
if (ssl->options.side == WOLFSSL_SERVER_END)
|
|
state = ss_client_finished;
|
|
else if (ssl->options.side == WOLFSSL_CLIENT_END)
|
|
state = ss_server_finished;
|
|
else {
|
|
WOLFSSL_MSG("Unknown State");
|
|
state = ss_null_state;
|
|
}
|
|
break;
|
|
case certificate_status:
|
|
state = ss_server_certificatestatus;
|
|
break;
|
|
case key_update:
|
|
if (ssl->options.side == WOLFSSL_SERVER_END)
|
|
state = ss_client_keyupdate;
|
|
else if (ssl->options.side == WOLFSSL_CLIENT_END)
|
|
state = ss_server_keyupdate;
|
|
else {
|
|
WOLFSSL_MSG("Unknown State");
|
|
state = ss_null_state;
|
|
}
|
|
break;
|
|
case change_cipher_hs:
|
|
if (ssl->options.side == WOLFSSL_SERVER_END)
|
|
state = ss_client_changecipherspec;
|
|
else if (ssl->options.side == WOLFSSL_CLIENT_END)
|
|
state = ss_server_changecipherspec;
|
|
else {
|
|
WOLFSSL_MSG("Unknown State");
|
|
state = ss_null_state;
|
|
}
|
|
break;
|
|
default:
|
|
WOLFSSL_MSG("Unknown State");
|
|
state = ss_null_state;
|
|
}
|
|
}
|
|
else {
|
|
/* Send process */
|
|
if (ssl->options.side == WOLFSSL_SERVER_END)
|
|
state = ssl->options.serverState;
|
|
else
|
|
state = ssl->options.clientState;
|
|
|
|
switch (state) {
|
|
case SERVER_HELLOVERIFYREQUEST_COMPLETE:
|
|
state = ss_server_helloverify;
|
|
break;
|
|
case SERVER_HELLO_RETRY_REQUEST_COMPLETE:
|
|
state = ss_server_helloretryrequest;
|
|
break;
|
|
case SERVER_HELLO_COMPLETE:
|
|
state = ss_server_hello;
|
|
break;
|
|
case SERVER_ENCRYPTED_EXTENSIONS_COMPLETE:
|
|
state = ss_server_encryptedextensions;
|
|
break;
|
|
case SERVER_CERT_COMPLETE:
|
|
state = ss_server_cert;
|
|
break;
|
|
case SERVER_KEYEXCHANGE_COMPLETE:
|
|
state = ss_server_keyexchange;
|
|
break;
|
|
case SERVER_HELLODONE_COMPLETE:
|
|
state = ss_server_hellodone;
|
|
break;
|
|
case SERVER_CHANGECIPHERSPEC_COMPLETE:
|
|
state = ss_server_changecipherspec;
|
|
break;
|
|
case SERVER_FINISHED_COMPLETE:
|
|
state = ss_server_finished;
|
|
break;
|
|
case CLIENT_HELLO_RETRY:
|
|
case CLIENT_HELLO_COMPLETE:
|
|
state = ss_client_hello;
|
|
break;
|
|
case CLIENT_KEYEXCHANGE_COMPLETE:
|
|
state = ss_client_keyexchange;
|
|
break;
|
|
case CLIENT_CHANGECIPHERSPEC_COMPLETE:
|
|
state = ss_client_changecipherspec;
|
|
break;
|
|
case CLIENT_FINISHED_COMPLETE:
|
|
state = ss_client_finished;
|
|
break;
|
|
case HANDSHAKE_DONE:
|
|
state = ss_handshake_done;
|
|
break;
|
|
default:
|
|
WOLFSSL_MSG("Unknown State");
|
|
state = ss_null_state;
|
|
}
|
|
}
|
|
|
|
if (protocol == UNKNOWN) {
|
|
WOLFSSL_MSG("Unknown protocol");
|
|
return "";
|
|
}
|
|
else {
|
|
return OUTPUT_STR[state][protocol][cbmode];
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Sets default PEM callback password if null is passed into
|
|
* the callback parameter of a PEM_read_bio_* function.
|
|
*
|
|
* Returns callback phrase size on success or WOLFSSL_FAILURE otherwise.
|
|
*/
|
|
int wolfSSL_PEM_def_callback(char* name, int num, int w, void* key)
|
|
{
|
|
(void)w;
|
|
WOLFSSL_ENTER("wolfSSL_PEM_def_callback");
|
|
|
|
/* We assume that the user passes a default password as userdata */
|
|
if (key) {
|
|
int sz = (int)XSTRLEN((const char*)key);
|
|
sz = (sz > num) ? num : sz;
|
|
XMEMCPY(name, key, sz);
|
|
return sz;
|
|
} else {
|
|
WOLFSSL_MSG("Error, default password cannot be created.");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
}
|
|
|
|
#endif /* OPENSSL_EXTRA */
|
|
|
|
static long wolf_set_options(long old_op, long op)
|
|
{
|
|
/* if SSL_OP_ALL then turn all bug workarounds on */
|
|
if ((op & WOLFSSL_OP_ALL) == WOLFSSL_OP_ALL) {
|
|
WOLFSSL_MSG("\tSSL_OP_ALL");
|
|
}
|
|
|
|
/* by default cookie exchange is on with DTLS */
|
|
if ((op & WOLFSSL_OP_COOKIE_EXCHANGE) == WOLFSSL_OP_COOKIE_EXCHANGE) {
|
|
WOLFSSL_MSG("\tSSL_OP_COOKIE_EXCHANGE : on by default");
|
|
}
|
|
|
|
if ((op & WOLFSSL_OP_NO_SSLv2) == WOLFSSL_OP_NO_SSLv2) {
|
|
WOLFSSL_MSG("\tWOLFSSL_OP_NO_SSLv2 : wolfSSL does not support SSLv2");
|
|
}
|
|
|
|
#ifdef SSL_OP_NO_TLSv1_3
|
|
if ((op & WOLFSSL_OP_NO_TLSv1_3) == WOLFSSL_OP_NO_TLSv1_3) {
|
|
WOLFSSL_MSG("\tSSL_OP_NO_TLSv1_3");
|
|
}
|
|
#endif
|
|
|
|
if ((op & WOLFSSL_OP_NO_TLSv1_2) == WOLFSSL_OP_NO_TLSv1_2) {
|
|
WOLFSSL_MSG("\tSSL_OP_NO_TLSv1_2");
|
|
}
|
|
|
|
if ((op & WOLFSSL_OP_NO_TLSv1_1) == WOLFSSL_OP_NO_TLSv1_1) {
|
|
WOLFSSL_MSG("\tSSL_OP_NO_TLSv1_1");
|
|
}
|
|
|
|
if ((op & WOLFSSL_OP_NO_TLSv1) == WOLFSSL_OP_NO_TLSv1) {
|
|
WOLFSSL_MSG("\tSSL_OP_NO_TLSv1");
|
|
}
|
|
|
|
if ((op & WOLFSSL_OP_NO_SSLv3) == WOLFSSL_OP_NO_SSLv3) {
|
|
WOLFSSL_MSG("\tSSL_OP_NO_SSLv3");
|
|
}
|
|
|
|
if ((op & WOLFSSL_OP_CIPHER_SERVER_PREFERENCE) ==
|
|
WOLFSSL_OP_CIPHER_SERVER_PREFERENCE) {
|
|
WOLFSSL_MSG("\tWOLFSSL_OP_CIPHER_SERVER_PREFERENCE");
|
|
}
|
|
|
|
if ((op & WOLFSSL_OP_NO_COMPRESSION) == WOLFSSL_OP_NO_COMPRESSION) {
|
|
#ifdef HAVE_LIBZ
|
|
WOLFSSL_MSG("SSL_OP_NO_COMPRESSION");
|
|
#else
|
|
WOLFSSL_MSG("SSL_OP_NO_COMPRESSION: compression not compiled in");
|
|
#endif
|
|
}
|
|
|
|
return old_op | op;
|
|
}
|
|
|
|
long wolfSSL_set_options(WOLFSSL* ssl, long op)
|
|
{
|
|
word16 haveRSA = 1;
|
|
word16 havePSK = 0;
|
|
int keySz = 0;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_set_options");
|
|
|
|
if (ssl == NULL) {
|
|
return 0;
|
|
}
|
|
|
|
ssl->options.mask = wolf_set_options(ssl->options.mask, op);
|
|
|
|
if ((ssl->options.mask & WOLFSSL_OP_NO_TLSv1_3) == WOLFSSL_OP_NO_TLSv1_3) {
|
|
if (ssl->version.minor == TLSv1_3_MINOR)
|
|
ssl->version.minor = TLSv1_2_MINOR;
|
|
}
|
|
|
|
if ((ssl->options.mask & WOLFSSL_OP_NO_TLSv1_2) == WOLFSSL_OP_NO_TLSv1_2) {
|
|
if (ssl->version.minor == TLSv1_2_MINOR)
|
|
ssl->version.minor = TLSv1_1_MINOR;
|
|
}
|
|
|
|
if ((ssl->options.mask & WOLFSSL_OP_NO_TLSv1_1) == WOLFSSL_OP_NO_TLSv1_1) {
|
|
if (ssl->version.minor == TLSv1_1_MINOR)
|
|
ssl->version.minor = TLSv1_MINOR;
|
|
}
|
|
|
|
if ((ssl->options.mask & WOLFSSL_OP_NO_TLSv1) == WOLFSSL_OP_NO_TLSv1) {
|
|
if (ssl->version.minor == TLSv1_MINOR)
|
|
ssl->version.minor = SSLv3_MINOR;
|
|
}
|
|
|
|
if ((ssl->options.mask & WOLFSSL_OP_NO_COMPRESSION)
|
|
== WOLFSSL_OP_NO_COMPRESSION) {
|
|
#ifdef HAVE_LIBZ
|
|
ssl->options.usingCompression = 0;
|
|
#endif
|
|
}
|
|
|
|
#if defined(HAVE_SESSION_TICKET) && (defined(OPENSSL_EXTRA) \
|
|
|| defined(HAVE_WEBSERVER) || defined(WOLFSSL_WPAS_SMALL))
|
|
if ((ssl->options.mask & WOLFSSL_OP_NO_TICKET) == WOLFSSL_OP_NO_TICKET) {
|
|
ssl->options.noTicketTls12 = 1;
|
|
}
|
|
#endif
|
|
|
|
|
|
/* in the case of a version change the cipher suites should be reset */
|
|
#ifndef NO_PSK
|
|
havePSK = ssl->options.havePSK;
|
|
#endif
|
|
#ifdef NO_RSA
|
|
haveRSA = 0;
|
|
#endif
|
|
#ifndef NO_CERTS
|
|
keySz = ssl->buffers.keySz;
|
|
#endif
|
|
|
|
if (ssl->options.side != WOLFSSL_NEITHER_END) {
|
|
if (AllocateSuites(ssl) != 0)
|
|
return 0;
|
|
InitSuites(ssl->suites, ssl->version, keySz, haveRSA, havePSK,
|
|
ssl->options.haveDH, ssl->options.haveECDSAsig,
|
|
ssl->options.haveECC, TRUE, ssl->options.haveStaticECC,
|
|
ssl->options.haveFalconSig, ssl->options.haveDilithiumSig,
|
|
ssl->options.haveAnon, TRUE, ssl->options.side);
|
|
}
|
|
|
|
return ssl->options.mask;
|
|
}
|
|
|
|
|
|
long wolfSSL_get_options(const WOLFSSL* ssl)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_get_options");
|
|
if(ssl == NULL)
|
|
return WOLFSSL_FAILURE;
|
|
return ssl->options.mask;
|
|
}
|
|
|
|
#if defined(HAVE_SECURE_RENEGOTIATION) \
|
|
|| defined(HAVE_SERVER_RENEGOTIATION_INFO)
|
|
/* clears the counter for number of renegotiations done
|
|
* returns the current count before it is cleared */
|
|
long wolfSSL_clear_num_renegotiations(WOLFSSL *s)
|
|
{
|
|
long total;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_clear_num_renegotiations");
|
|
if (s == NULL)
|
|
return 0;
|
|
|
|
total = s->secure_rene_count;
|
|
s->secure_rene_count = 0;
|
|
return total;
|
|
}
|
|
|
|
|
|
/* return the number of renegotiations since wolfSSL_new */
|
|
long wolfSSL_total_renegotiations(WOLFSSL *s)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_total_renegotiations");
|
|
return wolfSSL_num_renegotiations(s);
|
|
}
|
|
|
|
|
|
/* return the number of renegotiations since wolfSSL_new */
|
|
long wolfSSL_num_renegotiations(WOLFSSL* s)
|
|
{
|
|
if (s == NULL) {
|
|
return 0;
|
|
}
|
|
|
|
return s->secure_rene_count;
|
|
}
|
|
|
|
|
|
/* Is there a renegotiation currently in progress? */
|
|
int wolfSSL_SSL_renegotiate_pending(WOLFSSL *s)
|
|
{
|
|
return s && s->options.handShakeDone &&
|
|
s->options.handShakeState != HANDSHAKE_DONE ? 1 : 0;
|
|
}
|
|
#endif /* HAVE_SECURE_RENEGOTIATION || HAVE_SERVER_RENEGOTIATION_INFO */
|
|
|
|
#ifdef OPENSSL_EXTRA
|
|
|
|
long wolfSSL_clear_options(WOLFSSL* ssl, long opt)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_clear_options");
|
|
if(ssl == NULL)
|
|
return WOLFSSL_FAILURE;
|
|
ssl->options.mask &= ~opt;
|
|
return ssl->options.mask;
|
|
}
|
|
|
|
#ifdef HAVE_PK_CALLBACKS
|
|
long wolfSSL_set_tlsext_debug_arg(WOLFSSL* ssl, void *arg)
|
|
{
|
|
if (ssl == NULL) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
ssl->loggingCtx = arg;
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
#endif /* HAVE_PK_CALLBACKS */
|
|
|
|
#if defined(OPENSSL_ALL) || defined(WOLFSSL_HAPROXY) || defined(WOLFSSL_NGINX)
|
|
const unsigned char *wolfSSL_SESSION_get0_id_context(
|
|
const WOLFSSL_SESSION *sess, unsigned int *sid_ctx_length)
|
|
{
|
|
return wolfSSL_SESSION_get_id((WOLFSSL_SESSION *)sess, sid_ctx_length);
|
|
}
|
|
int wolfSSL_SESSION_set1_id(WOLFSSL_SESSION *s,
|
|
const unsigned char *sid, unsigned int sid_len)
|
|
{
|
|
if (s == NULL) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
if (sid_len > ID_LEN) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
s->sessionIDSz = sid_len;
|
|
if (sid != s->sessionID) {
|
|
XMEMCPY(s->sessionID, sid, sid_len);
|
|
}
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
int wolfSSL_SESSION_set1_id_context(WOLFSSL_SESSION *s,
|
|
const unsigned char *sid_ctx, unsigned int sid_ctx_len)
|
|
{
|
|
if (s == NULL) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
if (sid_ctx_len > ID_LEN) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
s->sessionCtxSz = sid_ctx_len;
|
|
if (sid_ctx != s->sessionCtx) {
|
|
XMEMCPY(s->sessionCtx, sid_ctx, sid_ctx_len);
|
|
}
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
#endif
|
|
|
|
/*** TBD ***/
|
|
#ifndef NO_WOLFSSL_STUB
|
|
int wolfSSL_sk_SSL_COMP_zero(WOLFSSL_STACK* st)
|
|
{
|
|
(void)st;
|
|
WOLFSSL_STUB("wolfSSL_sk_SSL_COMP_zero");
|
|
/* wolfSSL_set_options(ssl, SSL_OP_NO_COMPRESSION); */
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
#endif
|
|
|
|
#ifdef HAVE_CERTIFICATE_STATUS_REQUEST
|
|
long wolfSSL_set_tlsext_status_type(WOLFSSL *s, int type)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_set_tlsext_status_type");
|
|
|
|
if (s == NULL){
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
if (type == TLSEXT_STATUSTYPE_ocsp){
|
|
int r = TLSX_UseCertificateStatusRequest(&s->extensions, (byte)type, 0, s,
|
|
s->heap, s->devId);
|
|
return (long)r;
|
|
} else {
|
|
WOLFSSL_MSG(
|
|
"SSL_set_tlsext_status_type only supports TLSEXT_STATUSTYPE_ocsp type.");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
}
|
|
|
|
long wolfSSL_get_tlsext_status_type(WOLFSSL *s)
|
|
{
|
|
TLSX* extension;
|
|
|
|
if (s == NULL)
|
|
return WOLFSSL_FATAL_ERROR;
|
|
extension = TLSX_Find(s->extensions, TLSX_STATUS_REQUEST);
|
|
return extension != NULL ? TLSEXT_STATUSTYPE_ocsp : WOLFSSL_FATAL_ERROR;
|
|
}
|
|
#endif /* HAVE_CERTIFICATE_STATUS_REQUEST */
|
|
|
|
#ifndef NO_WOLFSSL_STUB
|
|
long wolfSSL_get_tlsext_status_exts(WOLFSSL *s, void *arg)
|
|
{
|
|
(void)s;
|
|
(void)arg;
|
|
WOLFSSL_STUB("wolfSSL_get_tlsext_status_exts");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
#endif
|
|
|
|
/*** TBD ***/
|
|
#ifndef NO_WOLFSSL_STUB
|
|
long wolfSSL_set_tlsext_status_exts(WOLFSSL *s, void *arg)
|
|
{
|
|
(void)s;
|
|
(void)arg;
|
|
WOLFSSL_STUB("wolfSSL_set_tlsext_status_exts");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
#endif
|
|
|
|
/*** TBD ***/
|
|
#ifndef NO_WOLFSSL_STUB
|
|
long wolfSSL_get_tlsext_status_ids(WOLFSSL *s, void *arg)
|
|
{
|
|
(void)s;
|
|
(void)arg;
|
|
WOLFSSL_STUB("wolfSSL_get_tlsext_status_ids");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
#endif
|
|
|
|
/*** TBD ***/
|
|
#ifndef NO_WOLFSSL_STUB
|
|
long wolfSSL_set_tlsext_status_ids(WOLFSSL *s, void *arg)
|
|
{
|
|
(void)s;
|
|
(void)arg;
|
|
WOLFSSL_STUB("wolfSSL_set_tlsext_status_ids");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
#endif
|
|
|
|
#ifndef NO_WOLFSSL_STUB
|
|
/*** TBD ***/
|
|
WOLFSSL_EVP_PKEY *wolfSSL_get_privatekey(const WOLFSSL *ssl)
|
|
{
|
|
(void)ssl;
|
|
WOLFSSL_STUB("SSL_get_privatekey");
|
|
return NULL;
|
|
}
|
|
#endif
|
|
|
|
#ifndef NO_WOLFSSL_STUB
|
|
/*** TBD ***/
|
|
void SSL_CTX_set_tmp_dh_callback(WOLFSSL_CTX *ctx,
|
|
WOLFSSL_DH *(*dh) (WOLFSSL *ssl, int is_export, int keylength))
|
|
{
|
|
(void)ctx;
|
|
(void)dh;
|
|
WOLFSSL_STUB("SSL_CTX_set_tmp_dh_callback");
|
|
}
|
|
#endif
|
|
|
|
#ifndef NO_WOLFSSL_STUB
|
|
/*** TBD ***/
|
|
WOLF_STACK_OF(SSL_COMP) *SSL_COMP_get_compression_methods(void)
|
|
{
|
|
WOLFSSL_STUB("SSL_COMP_get_compression_methods");
|
|
return NULL;
|
|
}
|
|
#endif
|
|
|
|
|
|
int wolfSSL_sk_SSL_CIPHER_num(const WOLF_STACK_OF(WOLFSSL_CIPHER)* p)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_sk_SSL_CIPHER_num");
|
|
if (p == NULL) {
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
return (int)p->num;
|
|
}
|
|
|
|
WOLFSSL_CIPHER* wolfSSL_sk_SSL_CIPHER_value(WOLFSSL_STACK* sk, int i)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_sk_SSL_CIPHER_value");
|
|
return (WOLFSSL_CIPHER*)wolfSSL_sk_value(sk, i);
|
|
}
|
|
|
|
#if !defined(NETOS)
|
|
void ERR_load_SSL_strings(void)
|
|
{
|
|
|
|
}
|
|
#endif
|
|
|
|
#ifdef HAVE_OCSP
|
|
long wolfSSL_get_tlsext_status_ocsp_resp(WOLFSSL *s, unsigned char **resp)
|
|
{
|
|
if (s == NULL || resp == NULL)
|
|
return 0;
|
|
|
|
*resp = s->ocspResp;
|
|
return s->ocspRespSz;
|
|
}
|
|
|
|
long wolfSSL_set_tlsext_status_ocsp_resp(WOLFSSL *s, unsigned char *resp,
|
|
int len)
|
|
{
|
|
if (s == NULL)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
s->ocspResp = resp;
|
|
s->ocspRespSz = len;
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
#endif /* HAVE_OCSP */
|
|
|
|
#ifdef HAVE_MAX_FRAGMENT
|
|
#ifndef NO_WOLFSSL_CLIENT
|
|
/**
|
|
* Set max fragment tls extension
|
|
* @param c a pointer to WOLFSSL_CTX object
|
|
* @param mode maximum fragment length mode
|
|
* @return 1 on success, otherwise 0 or negative error code
|
|
*/
|
|
int wolfSSL_CTX_set_tlsext_max_fragment_length(WOLFSSL_CTX *c,
|
|
unsigned char mode)
|
|
{
|
|
if (c == NULL || (mode < WOLFSSL_MFL_2_9 || mode > WOLFSSL_MFL_2_12 ))
|
|
return BAD_FUNC_ARG;
|
|
|
|
return wolfSSL_CTX_UseMaxFragment(c, mode);
|
|
}
|
|
/**
|
|
* Set max fragment tls extension
|
|
* @param c a pointer to WOLFSSL object
|
|
* @param mode maximum fragment length mode
|
|
* @return 1 on success, otherwise 0 or negative error code
|
|
*/
|
|
int wolfSSL_set_tlsext_max_fragment_length(WOLFSSL *s, unsigned char mode)
|
|
{
|
|
if (s == NULL || (mode < WOLFSSL_MFL_2_9 || mode > WOLFSSL_MFL_2_12 ))
|
|
return BAD_FUNC_ARG;
|
|
|
|
return wolfSSL_UseMaxFragment(s, mode);
|
|
}
|
|
#endif /* NO_WOLFSSL_CLIENT */
|
|
#endif /* HAVE_MAX_FRAGMENT */
|
|
|
|
#endif /* OPENSSL_EXTRA */
|
|
|
|
#ifdef WOLFSSL_HAVE_TLS_UNIQUE
|
|
size_t wolfSSL_get_finished(const WOLFSSL *ssl, void *buf, size_t count)
|
|
{
|
|
byte len = 0;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_get_finished");
|
|
|
|
if (!ssl || !buf || count < TLS_FINISHED_SZ) {
|
|
WOLFSSL_MSG("Bad parameter");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
if (ssl->options.side == WOLFSSL_SERVER_END) {
|
|
len = ssl->serverFinished_len;
|
|
XMEMCPY(buf, ssl->serverFinished, len);
|
|
}
|
|
else {
|
|
len = ssl->clientFinished_len;
|
|
XMEMCPY(buf, ssl->clientFinished, len);
|
|
}
|
|
return len;
|
|
}
|
|
|
|
size_t wolfSSL_get_peer_finished(const WOLFSSL *ssl, void *buf, size_t count)
|
|
{
|
|
byte len = 0;
|
|
WOLFSSL_ENTER("wolfSSL_get_peer_finished");
|
|
|
|
if (!ssl || !buf || count < TLS_FINISHED_SZ) {
|
|
WOLFSSL_MSG("Bad parameter");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
if (ssl->options.side == WOLFSSL_CLIENT_END) {
|
|
len = ssl->serverFinished_len;
|
|
XMEMCPY(buf, ssl->serverFinished, len);
|
|
}
|
|
else {
|
|
len = ssl->clientFinished_len;
|
|
XMEMCPY(buf, ssl->clientFinished, len);
|
|
}
|
|
|
|
return len;
|
|
}
|
|
#endif /* WOLFSSL_HAVE_TLS_UNIQUE */
|
|
|
|
#if defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL) || \
|
|
defined(OPENSSL_ALL)
|
|
long wolfSSL_get_verify_result(const WOLFSSL *ssl)
|
|
{
|
|
if (ssl == NULL) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
return ssl->peerVerifyRet;
|
|
}
|
|
#endif
|
|
|
|
#ifdef OPENSSL_EXTRA
|
|
|
|
#ifndef NO_WOLFSSL_STUB
|
|
/* shows the number of accepts attempted by CTX in it's lifetime */
|
|
long wolfSSL_CTX_sess_accept(WOLFSSL_CTX* ctx)
|
|
{
|
|
WOLFSSL_STUB("wolfSSL_CTX_sess_accept");
|
|
(void)ctx;
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
#ifndef NO_WOLFSSL_STUB
|
|
/* shows the number of connects attempted CTX in it's lifetime */
|
|
long wolfSSL_CTX_sess_connect(WOLFSSL_CTX* ctx)
|
|
{
|
|
WOLFSSL_STUB("wolfSSL_CTX_sess_connect");
|
|
(void)ctx;
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
|
|
#ifndef NO_WOLFSSL_STUB
|
|
/* shows the number of accepts completed by CTX in it's lifetime */
|
|
long wolfSSL_CTX_sess_accept_good(WOLFSSL_CTX* ctx)
|
|
{
|
|
WOLFSSL_STUB("wolfSSL_CTX_sess_accept_good");
|
|
(void)ctx;
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
|
|
#ifndef NO_WOLFSSL_STUB
|
|
/* shows the number of connects completed by CTX in it's lifetime */
|
|
long wolfSSL_CTX_sess_connect_good(WOLFSSL_CTX* ctx)
|
|
{
|
|
WOLFSSL_STUB("wolfSSL_CTX_sess_connect_good");
|
|
(void)ctx;
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
|
|
#ifndef NO_WOLFSSL_STUB
|
|
/* shows the number of renegotiation accepts attempted by CTX */
|
|
long wolfSSL_CTX_sess_accept_renegotiate(WOLFSSL_CTX* ctx)
|
|
{
|
|
WOLFSSL_STUB("wolfSSL_CTX_sess_accept_renegotiate");
|
|
(void)ctx;
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
|
|
#ifndef NO_WOLFSSL_STUB
|
|
/* shows the number of renegotiation accepts attempted by CTX */
|
|
long wolfSSL_CTX_sess_connect_renegotiate(WOLFSSL_CTX* ctx)
|
|
{
|
|
WOLFSSL_STUB("wolfSSL_CTX_sess_connect_renegotiate");
|
|
(void)ctx;
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
|
|
#ifndef NO_WOLFSSL_STUB
|
|
long wolfSSL_CTX_sess_hits(WOLFSSL_CTX* ctx)
|
|
{
|
|
WOLFSSL_STUB("wolfSSL_CTX_sess_hits");
|
|
(void)ctx;
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
|
|
#ifndef NO_WOLFSSL_STUB
|
|
long wolfSSL_CTX_sess_cb_hits(WOLFSSL_CTX* ctx)
|
|
{
|
|
WOLFSSL_STUB("wolfSSL_CTX_sess_cb_hits");
|
|
(void)ctx;
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
|
|
#ifndef NO_WOLFSSL_STUB
|
|
long wolfSSL_CTX_sess_cache_full(WOLFSSL_CTX* ctx)
|
|
{
|
|
WOLFSSL_STUB("wolfSSL_CTX_sess_cache_full");
|
|
(void)ctx;
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
|
|
#ifndef NO_WOLFSSL_STUB
|
|
long wolfSSL_CTX_sess_misses(WOLFSSL_CTX* ctx)
|
|
{
|
|
WOLFSSL_STUB("wolfSSL_CTX_sess_misses");
|
|
(void)ctx;
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
|
|
#ifndef NO_WOLFSSL_STUB
|
|
long wolfSSL_CTX_sess_timeouts(WOLFSSL_CTX* ctx)
|
|
{
|
|
WOLFSSL_STUB("wolfSSL_CTX_sess_timeouts");
|
|
(void)ctx;
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
|
|
/* Return the total number of sessions */
|
|
long wolfSSL_CTX_sess_number(WOLFSSL_CTX* ctx)
|
|
{
|
|
word32 total = 0;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_CTX_sess_number");
|
|
(void)ctx;
|
|
|
|
#if defined(WOLFSSL_SESSION_STATS) && !defined(NO_SESSION_CACHE)
|
|
if (wolfSSL_get_session_stats(NULL, &total, NULL, NULL) != WOLFSSL_SUCCESS) {
|
|
WOLFSSL_MSG("Error getting session stats");
|
|
}
|
|
#else
|
|
WOLFSSL_MSG("Please use macro WOLFSSL_SESSION_STATS for session stats");
|
|
#endif
|
|
|
|
return (long)total;
|
|
}
|
|
|
|
|
|
#ifndef NO_CERTS
|
|
long wolfSSL_CTX_add_extra_chain_cert(WOLFSSL_CTX* ctx, WOLFSSL_X509* x509)
|
|
{
|
|
byte* chain = NULL;
|
|
int derSz;
|
|
const byte* der;
|
|
int ret;
|
|
DerBuffer *derBuffer = NULL;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_CTX_add_extra_chain_cert");
|
|
|
|
if (ctx == NULL || x509 == NULL) {
|
|
WOLFSSL_MSG("Bad Argument");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
der = wolfSSL_X509_get_der(x509, &derSz);
|
|
if (der == NULL || derSz <= 0) {
|
|
WOLFSSL_MSG("Error getting X509 DER");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
if (ctx->certificate == NULL) {
|
|
WOLFSSL_ENTER("wolfSSL_use_certificate_chain_buffer_format");
|
|
|
|
/* Process buffer makes first certificate the leaf. */
|
|
ret = ProcessBuffer(ctx, der, derSz, WOLFSSL_FILETYPE_ASN1, CERT_TYPE,
|
|
NULL, NULL, 1, GET_VERIFY_SETTING_CTX(ctx));
|
|
if (ret != WOLFSSL_SUCCESS) {
|
|
WOLFSSL_LEAVE("wolfSSL_CTX_add_extra_chain_cert", ret);
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
}
|
|
else {
|
|
long chainSz = 0;
|
|
int idx = 0;
|
|
|
|
/* TODO: Do this elsewhere. */
|
|
ret = AllocDer(&derBuffer, derSz, CERT_TYPE, ctx->heap);
|
|
if (ret != 0) {
|
|
WOLFSSL_MSG("Memory Error");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
XMEMCPY(derBuffer->buffer, der, derSz);
|
|
ret = AddCA(ctx->cm, &derBuffer, WOLFSSL_USER_CA,
|
|
GET_VERIFY_SETTING_CTX(ctx));
|
|
if (ret != WOLFSSL_SUCCESS) {
|
|
WOLFSSL_LEAVE("wolfSSL_CTX_add_extra_chain_cert", ret);
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
/* adding cert to existing chain */
|
|
if (ctx->certChain != NULL && ctx->certChain->length > 0) {
|
|
chainSz += ctx->certChain->length;
|
|
}
|
|
chainSz += OPAQUE24_LEN + derSz;
|
|
|
|
chain = (byte*)XMALLOC(chainSz, ctx->heap, DYNAMIC_TYPE_DER);
|
|
if (chain == NULL) {
|
|
WOLFSSL_MSG("Memory Error");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
if (ctx->certChain != NULL && ctx->certChain->length > 0) {
|
|
XMEMCPY(chain, ctx->certChain->buffer, ctx->certChain->length);
|
|
idx = ctx->certChain->length;
|
|
}
|
|
c32to24(derSz, chain + idx);
|
|
idx += OPAQUE24_LEN;
|
|
XMEMCPY(chain + idx, der, derSz);
|
|
idx += derSz;
|
|
#ifdef WOLFSSL_TLS13
|
|
ctx->certChainCnt++;
|
|
#endif
|
|
|
|
FreeDer(&ctx->certChain);
|
|
ret = AllocDer(&ctx->certChain, idx, CERT_TYPE, ctx->heap);
|
|
if (ret == 0) {
|
|
XMEMCPY(ctx->certChain->buffer, chain, idx);
|
|
}
|
|
}
|
|
|
|
/* on success WOLFSSL_X509 memory is responsibility of ctx */
|
|
wolfSSL_X509_free(x509);
|
|
if (chain != NULL)
|
|
XFREE(chain, ctx->heap, DYNAMIC_TYPE_DER);
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
|
|
long wolfSSL_CTX_set_tlsext_status_arg(WOLFSSL_CTX* ctx, void* arg)
|
|
{
|
|
if (ctx == NULL || ctx->cm == NULL) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
ctx->cm->ocspIOCtx = arg;
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
#endif /* !NO_CERTS */
|
|
|
|
int wolfSSL_get_read_ahead(const WOLFSSL* ssl)
|
|
{
|
|
if (ssl == NULL) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
return ssl->readAhead;
|
|
}
|
|
|
|
|
|
int wolfSSL_set_read_ahead(WOLFSSL* ssl, int v)
|
|
{
|
|
if (ssl == NULL) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
ssl->readAhead = (byte)v;
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
|
|
int wolfSSL_CTX_get_read_ahead(WOLFSSL_CTX* ctx)
|
|
{
|
|
if (ctx == NULL) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
return ctx->readAhead;
|
|
}
|
|
|
|
|
|
int wolfSSL_CTX_set_read_ahead(WOLFSSL_CTX* ctx, int v)
|
|
{
|
|
if (ctx == NULL) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
ctx->readAhead = (byte)v;
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
|
|
long wolfSSL_CTX_set_tlsext_opaque_prf_input_callback_arg(WOLFSSL_CTX* ctx,
|
|
void* arg)
|
|
{
|
|
if (ctx == NULL) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
ctx->userPRFArg = arg;
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
#endif /* OPENSSL_EXTRA */
|
|
|
|
#if defined(OPENSSL_EXTRA) || defined(WOLFSSL_WPAS_SMALL)
|
|
int wolfSSL_sk_num(const WOLFSSL_STACK* sk)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_sk_num");
|
|
if (sk == NULL)
|
|
return 0;
|
|
return (int)sk->num;
|
|
}
|
|
|
|
void* wolfSSL_sk_value(const WOLFSSL_STACK* sk, int i)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_sk_value");
|
|
|
|
for (; sk != NULL && i > 0; i--)
|
|
sk = sk->next;
|
|
if (sk == NULL)
|
|
return NULL;
|
|
|
|
switch (sk->type) {
|
|
case STACK_TYPE_X509:
|
|
return (void*)sk->data.x509;
|
|
case STACK_TYPE_GEN_NAME:
|
|
return (void*)sk->data.gn;
|
|
case STACK_TYPE_BIO:
|
|
return (void*)sk->data.bio;
|
|
case STACK_TYPE_OBJ:
|
|
return (void*)sk->data.obj;
|
|
case STACK_TYPE_STRING:
|
|
return (void*)sk->data.string;
|
|
case STACK_TYPE_CIPHER:
|
|
return (void*)&sk->data.cipher;
|
|
case STACK_TYPE_ACCESS_DESCRIPTION:
|
|
return (void*)sk->data.access;
|
|
case STACK_TYPE_X509_EXT:
|
|
return (void*)sk->data.ext;
|
|
case STACK_TYPE_X509_REQ_ATTR:
|
|
return (void*)sk->data.generic;
|
|
case STACK_TYPE_NULL:
|
|
return (void*)sk->data.generic;
|
|
case STACK_TYPE_X509_NAME:
|
|
return (void*)sk->data.name;
|
|
case STACK_TYPE_X509_NAME_ENTRY:
|
|
return (void*)sk->data.name_entry;
|
|
case STACK_TYPE_CONF_VALUE:
|
|
#ifdef OPENSSL_EXTRA
|
|
return (void*)sk->data.conf;
|
|
#else
|
|
return NULL;
|
|
#endif
|
|
case STACK_TYPE_X509_INFO:
|
|
return (void*)sk->data.info;
|
|
case STACK_TYPE_BY_DIR_entry:
|
|
return (void*)sk->data.dir_entry;
|
|
case STACK_TYPE_BY_DIR_hash:
|
|
return (void*)sk->data.dir_hash;
|
|
case STACK_TYPE_X509_OBJ:
|
|
return (void*)sk->data.x509_obj;
|
|
case STACK_TYPE_DIST_POINT:
|
|
return (void*)sk->data.dp;
|
|
case STACK_TYPE_X509_CRL:
|
|
return (void*)sk->data.crl;
|
|
default:
|
|
return (void*)sk->data.generic;
|
|
}
|
|
}
|
|
|
|
/* copies over data of "in" to "out" */
|
|
static void wolfSSL_CIPHER_copy(WOLFSSL_CIPHER* in, WOLFSSL_CIPHER* out)
|
|
{
|
|
if (in == NULL || out == NULL)
|
|
return;
|
|
|
|
*out = *in;
|
|
}
|
|
|
|
WOLFSSL_STACK* wolfSSL_sk_dup(WOLFSSL_STACK* sk)
|
|
{
|
|
|
|
WOLFSSL_STACK* ret = NULL;
|
|
WOLFSSL_STACK* last = NULL;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_sk_dup");
|
|
|
|
while (sk) {
|
|
WOLFSSL_STACK* cur = wolfSSL_sk_new_node(sk->heap);
|
|
|
|
if (!cur) {
|
|
WOLFSSL_MSG("wolfSSL_sk_new_node error");
|
|
goto error;
|
|
}
|
|
|
|
if (!ret) {
|
|
/* Set first node */
|
|
ret = cur;
|
|
}
|
|
|
|
if (last) {
|
|
last->next = cur;
|
|
}
|
|
|
|
XMEMCPY(cur, sk, sizeof(WOLFSSL_STACK));
|
|
|
|
/* We will allocate new memory for this */
|
|
XMEMSET(&cur->data, 0, sizeof(cur->data));
|
|
cur->next = NULL;
|
|
|
|
switch (sk->type) {
|
|
case STACK_TYPE_X509:
|
|
if (!sk->data.x509)
|
|
break;
|
|
cur->data.x509 = wolfSSL_X509_dup(sk->data.x509);
|
|
if (!cur->data.x509) {
|
|
WOLFSSL_MSG("wolfSSL_X509_dup error");
|
|
goto error;
|
|
}
|
|
break;
|
|
case STACK_TYPE_CIPHER:
|
|
wolfSSL_CIPHER_copy(&sk->data.cipher, &cur->data.cipher);
|
|
break;
|
|
case STACK_TYPE_GEN_NAME:
|
|
if (!sk->data.gn)
|
|
break;
|
|
cur->data.gn = wolfSSL_GENERAL_NAME_dup(sk->data.gn);
|
|
if (!cur->data.gn) {
|
|
WOLFSSL_MSG("wolfSSL_GENERAL_NAME_new error");
|
|
goto error;
|
|
}
|
|
break;
|
|
case STACK_TYPE_OBJ:
|
|
if (!sk->data.obj)
|
|
break;
|
|
cur->data.obj = wolfSSL_ASN1_OBJECT_dup(sk->data.obj);
|
|
if (!cur->data.obj) {
|
|
WOLFSSL_MSG("wolfSSL_ASN1_OBJECT_dup error");
|
|
goto error;
|
|
}
|
|
break;
|
|
case STACK_TYPE_BIO:
|
|
case STACK_TYPE_STRING:
|
|
case STACK_TYPE_ACCESS_DESCRIPTION:
|
|
case STACK_TYPE_X509_EXT:
|
|
case STACK_TYPE_X509_REQ_ATTR:
|
|
case STACK_TYPE_NULL:
|
|
case STACK_TYPE_X509_NAME:
|
|
case STACK_TYPE_X509_NAME_ENTRY:
|
|
case STACK_TYPE_CONF_VALUE:
|
|
case STACK_TYPE_X509_INFO:
|
|
case STACK_TYPE_BY_DIR_entry:
|
|
case STACK_TYPE_BY_DIR_hash:
|
|
case STACK_TYPE_X509_OBJ:
|
|
case STACK_TYPE_DIST_POINT:
|
|
case STACK_TYPE_X509_CRL:
|
|
default:
|
|
WOLFSSL_MSG("Unsupported stack type");
|
|
goto error;
|
|
}
|
|
|
|
sk = sk->next;
|
|
last = cur;
|
|
}
|
|
return ret;
|
|
|
|
error:
|
|
if (ret) {
|
|
wolfSSL_sk_GENERAL_NAME_free(ret);
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
|
|
WOLFSSL_STACK* wolfSSL_shallow_sk_dup(WOLFSSL_STACK* sk)
|
|
{
|
|
|
|
WOLFSSL_STACK* ret = NULL;
|
|
WOLFSSL_STACK** prev = &ret;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_shallow_sk_dup");
|
|
|
|
for (; sk != NULL; sk = sk->next) {
|
|
WOLFSSL_STACK* cur = wolfSSL_sk_new_node(sk->heap);
|
|
|
|
if (!cur) {
|
|
WOLFSSL_MSG("wolfSSL_sk_new_node error");
|
|
goto error;
|
|
}
|
|
|
|
XMEMCPY(cur, sk, sizeof(WOLFSSL_STACK));
|
|
cur->next = NULL;
|
|
|
|
*prev = cur;
|
|
prev = &cur->next;
|
|
}
|
|
return ret;
|
|
|
|
error:
|
|
if (ret) {
|
|
wolfSSL_sk_free(ret);
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/* Free the just the stack structure */
|
|
void wolfSSL_sk_free(WOLFSSL_STACK* sk)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_sk_free");
|
|
|
|
while (sk != NULL) {
|
|
WOLFSSL_STACK* next = sk->next;
|
|
XFREE(sk, NULL, DYNAMIC_TYPE_OPENSSL);
|
|
sk = next;
|
|
}
|
|
}
|
|
|
|
/* Frees each node in the stack and frees the stack.
|
|
*/
|
|
void wolfSSL_sk_GENERIC_pop_free(WOLFSSL_STACK* sk,
|
|
void (*f) (void*))
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_sk_GENERIC_pop_free");
|
|
wolfSSL_sk_pop_free(sk, (wolfSSL_sk_freefunc)f);
|
|
}
|
|
|
|
/* return 1 on success 0 on fail */
|
|
int wolfSSL_sk_GENERIC_push(WOLFSSL_STACK* sk, void* generic)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_sk_GENERIC_push");
|
|
|
|
return wolfSSL_sk_push(sk, generic);
|
|
}
|
|
void wolfSSL_sk_GENERIC_free(WOLFSSL_STACK* sk)
|
|
{
|
|
wolfSSL_sk_free(sk);
|
|
}
|
|
|
|
/* Pop off data from the stack. Checks that the type matches the stack type.
|
|
*
|
|
* @param [in, out] sk Stack of objects.
|
|
* @param [in] type Type of stack.
|
|
* @return Object on success.
|
|
* @return NULL when stack is NULL or no nodes left in stack.
|
|
*/
|
|
void* wolfssl_sk_pop_type(WOLFSSL_STACK* sk, WOLF_STACK_TYPE type)
|
|
{
|
|
WOLFSSL_STACK* node;
|
|
void* data = NULL;
|
|
|
|
/* Check we have a stack passed in of the right type. */
|
|
if ((sk != NULL) && (sk->type == type)) {
|
|
/* Get the next node to become the new first node. */
|
|
node = sk->next;
|
|
/* Get the ASN.1 OBJECT_ID object in the first node. */
|
|
data = sk->data.generic;
|
|
|
|
/* Check whether there is a next node. */
|
|
if (node != NULL) {
|
|
/* Move content out of next node into current node. */
|
|
sk->data.obj = node->data.obj;
|
|
sk->next = node->next;
|
|
/* Dispose of node. */
|
|
XFREE(node, NULL, DYNAMIC_TYPE_ASN1);
|
|
}
|
|
else {
|
|
/* No more nodes - clear out data. */
|
|
sk->data.obj = NULL;
|
|
}
|
|
|
|
/* Decrement count as long as we thought we had nodes. */
|
|
if (sk->num > 0) {
|
|
sk->num -= 1;
|
|
}
|
|
}
|
|
|
|
return data;
|
|
}
|
|
|
|
/* Free all nodes in a stack including the pushed objects */
|
|
void wolfSSL_sk_pop_free(WOLF_STACK_OF(WOLFSSL_ASN1_OBJECT)* sk,
|
|
wolfSSL_sk_freefunc func)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_sk_pop_free");
|
|
|
|
if (sk == NULL) {
|
|
/* pop_free can be called with NULL, do not print bad argument */
|
|
return;
|
|
}
|
|
#if defined(WOLFSSL_QT)
|
|
/* In Qt v15.5, it calls OPENSSL_sk_free(xxx, OPENSSL_sk_free).
|
|
* By using OPENSSL_sk_free for free causes access violation.
|
|
* Therefore, switching free func to wolfSSL_ACCESS_DESCRIPTION_free
|
|
* is needed even the func isn't NULL.
|
|
*/
|
|
if (sk->type == STACK_TYPE_ACCESS_DESCRIPTION) {
|
|
func = (wolfSSL_sk_freefunc)wolfSSL_ACCESS_DESCRIPTION_free;
|
|
}
|
|
#endif
|
|
if (func == NULL) {
|
|
switch(sk->type) {
|
|
case STACK_TYPE_ACCESS_DESCRIPTION:
|
|
#if defined(OPENSSL_ALL)
|
|
func = (wolfSSL_sk_freefunc)wolfSSL_ACCESS_DESCRIPTION_free;
|
|
#endif
|
|
break;
|
|
case STACK_TYPE_X509:
|
|
func = (wolfSSL_sk_freefunc)wolfSSL_X509_free;
|
|
break;
|
|
case STACK_TYPE_X509_OBJ:
|
|
#ifdef OPENSSL_ALL
|
|
func = (wolfSSL_sk_freefunc)wolfSSL_X509_OBJECT_free;
|
|
#endif
|
|
break;
|
|
case STACK_TYPE_OBJ:
|
|
func = (wolfSSL_sk_freefunc)wolfSSL_ASN1_OBJECT_free;
|
|
break;
|
|
case STACK_TYPE_DIST_POINT:
|
|
#ifdef OPENSSL_EXTRA
|
|
func = (wolfSSL_sk_freefunc)wolfSSL_DIST_POINT_free;
|
|
#endif
|
|
break;
|
|
case STACK_TYPE_GEN_NAME:
|
|
func = (wolfSSL_sk_freefunc)wolfSSL_GENERAL_NAME_free;
|
|
break;
|
|
case STACK_TYPE_STRING:
|
|
#if defined(WOLFSSL_NGINX) || defined(WOLFSSL_HAPROXY) || \
|
|
defined(OPENSSL_EXTRA) || defined(OPENSSL_ALL)
|
|
func = (wolfSSL_sk_freefunc)wolfSSL_WOLFSSL_STRING_free;
|
|
#endif
|
|
break;
|
|
case STACK_TYPE_X509_NAME:
|
|
#if (defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL)) \
|
|
&& !defined(WOLFCRYPT_ONLY)
|
|
func = (wolfSSL_sk_freefunc)wolfSSL_X509_NAME_free;
|
|
#endif
|
|
break;
|
|
case STACK_TYPE_X509_NAME_ENTRY:
|
|
#if (defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL)) \
|
|
&& !defined(WOLFCRYPT_ONLY)
|
|
func = (wolfSSL_sk_freefunc)wolfSSL_X509_NAME_ENTRY_free;
|
|
#endif
|
|
break;
|
|
case STACK_TYPE_X509_EXT:
|
|
#if defined(OPENSSL_ALL) || defined(OPENSSL_EXTRA)
|
|
func = (wolfSSL_sk_freefunc)wolfSSL_X509_EXTENSION_free;
|
|
#endif
|
|
break;
|
|
case STACK_TYPE_X509_REQ_ATTR:
|
|
#if defined(OPENSSL_ALL) && \
|
|
(defined(WOLFSSL_CERT_GEN) || defined(WOLFSSL_CERT_REQ))
|
|
func = (wolfSSL_sk_freefunc)wolfSSL_X509_ATTRIBUTE_free;
|
|
#endif
|
|
break;
|
|
case STACK_TYPE_CONF_VALUE:
|
|
#if defined(OPENSSL_ALL)
|
|
func = (wolfSSL_sk_freefunc)wolfSSL_X509V3_conf_free;
|
|
#endif
|
|
break;
|
|
case STACK_TYPE_X509_INFO:
|
|
#if defined(OPENSSL_ALL)
|
|
func = (wolfSSL_sk_freefunc)wolfSSL_X509_INFO_free;
|
|
#endif
|
|
break;
|
|
case STACK_TYPE_BIO:
|
|
#if !defined(NO_BIO) && defined(OPENSSL_EXTRA)
|
|
func = (wolfSSL_sk_freefunc)wolfSSL_BIO_vfree;
|
|
#endif
|
|
break;
|
|
case STACK_TYPE_BY_DIR_entry:
|
|
#if defined(OPENSSL_ALL) && !defined(NO_FILESYSTEM) && !defined(NO_WOLFSSL_DIR)
|
|
func = (wolfSSL_sk_freefunc)wolfSSL_BY_DIR_entry_free;
|
|
#endif
|
|
break;
|
|
case STACK_TYPE_BY_DIR_hash:
|
|
#if defined(OPENSSL_ALL) && !defined(NO_FILESYSTEM) && !defined(NO_WOLFSSL_DIR)
|
|
func = (wolfSSL_sk_freefunc)wolfSSL_BY_DIR_HASH_free;
|
|
#endif
|
|
break;
|
|
case STACK_TYPE_X509_CRL:
|
|
#if defined(HAVE_CRL) && (defined(OPENSSL_EXTRA) || defined(WOLFSSL_WPAS_SMALL))
|
|
func = (wolfSSL_sk_freefunc)wolfSSL_X509_CRL_free;
|
|
#endif
|
|
break;
|
|
case STACK_TYPE_CIPHER:
|
|
case STACK_TYPE_NULL:
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
while (sk != NULL) {
|
|
WOLFSSL_STACK* next = sk->next;
|
|
|
|
if (func != NULL) {
|
|
if (sk->type != STACK_TYPE_CIPHER)
|
|
func(sk->data.generic);
|
|
}
|
|
XFREE(sk, NULL, DYNAMIC_TYPE_OPENSSL);
|
|
sk = next;
|
|
}
|
|
}
|
|
|
|
/* Creates a new stack of the requested type.
|
|
*
|
|
* @param [in] type Type of stack.
|
|
* @return Empty stack on success.
|
|
* @return NULL when dynamic memory allocation fails.
|
|
*/
|
|
WOLFSSL_STACK* wolfssl_sk_new_type(WOLF_STACK_TYPE type)
|
|
{
|
|
WOLFSSL_STACK* sk;
|
|
|
|
/* Allocate a new stack - first node. */
|
|
sk = (WOLFSSL_STACK*)XMALLOC(sizeof(WOLFSSL_STACK), NULL,
|
|
DYNAMIC_TYPE_OPENSSL);
|
|
if (sk == NULL) {
|
|
WOLFSSL_MSG("WOLFSSL_STACK memory error");
|
|
}
|
|
else {
|
|
/* Clear node and set type. */
|
|
XMEMSET(sk, 0, sizeof(WOLFSSL_STACK));
|
|
sk->type = type;
|
|
}
|
|
|
|
return sk;
|
|
}
|
|
|
|
/* Creates and returns a new null stack. */
|
|
WOLFSSL_STACK* wolfSSL_sk_new_null(void)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_sk_new_null");
|
|
|
|
return wolfssl_sk_new_type(STACK_TYPE_NULL);
|
|
}
|
|
|
|
int wolfSSL_sk_SSL_COMP_num(WOLF_STACK_OF(WOLFSSL_COMP)* sk)
|
|
{
|
|
if (sk == NULL)
|
|
return 0;
|
|
return (int)sk->num;
|
|
}
|
|
|
|
#endif /* OPENSSL_EXTRA || WOLFSSL_WPAS_SMALL */
|
|
|
|
#if !defined(NO_SESSION_CACHE) && (defined(OPENSSL_EXTRA) || \
|
|
defined(HAVE_EXT_CACHE))
|
|
/* stunnel 4.28 needs
|
|
*
|
|
* Callback that is called if a session tries to resume but could not find
|
|
* the session to resume it.
|
|
*/
|
|
void wolfSSL_CTX_sess_set_get_cb(WOLFSSL_CTX* ctx,
|
|
WOLFSSL_SESSION*(*f)(WOLFSSL*, const unsigned char*, int, int*))
|
|
{
|
|
if (ctx == NULL)
|
|
return;
|
|
|
|
#ifdef HAVE_EXT_CACHE
|
|
ctx->get_sess_cb = f;
|
|
#else
|
|
(void)f;
|
|
#endif
|
|
}
|
|
|
|
void wolfSSL_CTX_sess_set_new_cb(WOLFSSL_CTX* ctx,
|
|
int (*f)(WOLFSSL*, WOLFSSL_SESSION*))
|
|
{
|
|
if (ctx == NULL)
|
|
return;
|
|
|
|
#ifdef HAVE_EXT_CACHE
|
|
ctx->new_sess_cb = f;
|
|
#else
|
|
(void)f;
|
|
#endif
|
|
}
|
|
|
|
void wolfSSL_CTX_sess_set_remove_cb(WOLFSSL_CTX* ctx, void (*f)(WOLFSSL_CTX*,
|
|
WOLFSSL_SESSION*))
|
|
{
|
|
if (ctx == NULL)
|
|
return;
|
|
|
|
#if defined(HAVE_EXT_CACHE) || defined(HAVE_EX_DATA)
|
|
ctx->rem_sess_cb = f;
|
|
#else
|
|
(void)f;
|
|
#endif
|
|
}
|
|
|
|
|
|
/*
|
|
*
|
|
* Note: It is expected that the importing and exporting function have been
|
|
* built with the same settings. For example if session tickets was
|
|
* enabled with the wolfSSL library exporting a session then it is
|
|
* expected to be turned on with the wolfSSL library importing the session.
|
|
*/
|
|
int wolfSSL_i2d_SSL_SESSION(WOLFSSL_SESSION* sess, unsigned char** p)
|
|
{
|
|
int size = 0;
|
|
#ifdef HAVE_EXT_CACHE
|
|
int idx = 0;
|
|
#ifdef SESSION_CERTS
|
|
int i;
|
|
#endif
|
|
|
|
WOLFSSL_ENTER("wolfSSL_i2d_SSL_SESSION");
|
|
|
|
sess = ClientSessionToSession(sess);
|
|
if (sess == NULL) {
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
/* side | bornOn | timeout | sessionID len | sessionID | masterSecret |
|
|
* haveEMS */
|
|
size += OPAQUE8_LEN + OPAQUE32_LEN + OPAQUE32_LEN + OPAQUE8_LEN +
|
|
sess->sessionIDSz + SECRET_LEN + OPAQUE8_LEN;
|
|
/* altSessionID */
|
|
size += OPAQUE8_LEN + (sess->haveAltSessionID ? ID_LEN : 0);
|
|
#ifdef SESSION_CERTS
|
|
/* Peer chain */
|
|
size += OPAQUE8_LEN;
|
|
for (i = 0; i < sess->chain.count; i++)
|
|
size += OPAQUE16_LEN + sess->chain.certs[i].length;
|
|
#endif
|
|
#if defined(SESSION_CERTS) || (defined(WOLFSSL_TLS13) && \
|
|
defined(HAVE_SESSION_TICKET))
|
|
/* Protocol version */
|
|
size += OPAQUE16_LEN;
|
|
#endif
|
|
#if defined(SESSION_CERTS) || !defined(NO_RESUME_SUITE_CHECK) || \
|
|
(defined(WOLFSSL_TLS13) && defined(HAVE_SESSION_TICKET))
|
|
/* cipher suite */
|
|
size += OPAQUE16_LEN;
|
|
#endif
|
|
#ifndef NO_CLIENT_CACHE
|
|
/* ServerID len | ServerID */
|
|
size += OPAQUE16_LEN + sess->idLen;
|
|
#endif
|
|
#ifdef WOLFSSL_SESSION_ID_CTX
|
|
/* session context ID len | session context ID */
|
|
size += OPAQUE8_LEN + sess->sessionCtxSz;
|
|
#endif
|
|
#if defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL)
|
|
/* peerVerifyRet */
|
|
size += OPAQUE8_LEN;
|
|
#endif
|
|
#ifdef WOLFSSL_TLS13
|
|
/* namedGroup */
|
|
size += OPAQUE16_LEN;
|
|
#endif
|
|
#if defined(HAVE_SESSION_TICKET) || !defined(NO_PSK)
|
|
#ifdef WOLFSSL_TLS13
|
|
#ifdef WOLFSSL_32BIT_MILLI_TIME
|
|
/* ticketSeen | ticketAdd */
|
|
size += OPAQUE32_LEN + OPAQUE32_LEN;
|
|
#else
|
|
/* ticketSeen Hi 32 bits | ticketSeen Lo 32 bits | ticketAdd */
|
|
size += OPAQUE32_LEN + OPAQUE32_LEN + OPAQUE32_LEN;
|
|
#endif
|
|
/* ticketNonce */
|
|
size += OPAQUE8_LEN + sess->ticketNonce.len;
|
|
#endif
|
|
#ifdef WOLFSSL_EARLY_DATA
|
|
size += OPAQUE32_LEN;
|
|
#endif
|
|
#endif
|
|
#ifdef HAVE_SESSION_TICKET
|
|
/* ticket len | ticket */
|
|
size += OPAQUE16_LEN + sess->ticketLen;
|
|
#endif
|
|
|
|
if (p != NULL) {
|
|
unsigned char *data;
|
|
|
|
if (*p == NULL)
|
|
*p = (unsigned char*)XMALLOC(size, NULL, DYNAMIC_TYPE_OPENSSL);
|
|
if (*p == NULL)
|
|
return 0;
|
|
data = *p;
|
|
|
|
data[idx++] = sess->side;
|
|
c32toa(sess->bornOn, data + idx); idx += OPAQUE32_LEN;
|
|
c32toa(sess->timeout, data + idx); idx += OPAQUE32_LEN;
|
|
data[idx++] = sess->sessionIDSz;
|
|
XMEMCPY(data + idx, sess->sessionID, sess->sessionIDSz);
|
|
idx += sess->sessionIDSz;
|
|
XMEMCPY(data + idx, sess->masterSecret, SECRET_LEN); idx += SECRET_LEN;
|
|
data[idx++] = (byte)sess->haveEMS;
|
|
data[idx++] = sess->haveAltSessionID ? ID_LEN : 0;
|
|
if (sess->haveAltSessionID) {
|
|
XMEMCPY(data + idx, sess->altSessionID, ID_LEN);
|
|
idx += ID_LEN;
|
|
}
|
|
#ifdef SESSION_CERTS
|
|
data[idx++] = (byte)sess->chain.count;
|
|
for (i = 0; i < sess->chain.count; i++) {
|
|
c16toa((word16)sess->chain.certs[i].length, data + idx);
|
|
idx += OPAQUE16_LEN;
|
|
XMEMCPY(data + idx, sess->chain.certs[i].buffer,
|
|
sess->chain.certs[i].length);
|
|
idx += sess->chain.certs[i].length;
|
|
}
|
|
#endif
|
|
#if defined(SESSION_CERTS) || (defined(WOLFSSL_TLS13) && \
|
|
defined(HAVE_SESSION_TICKET))
|
|
data[idx++] = sess->version.major;
|
|
data[idx++] = sess->version.minor;
|
|
#endif
|
|
#if defined(SESSION_CERTS) || !defined(NO_RESUME_SUITE_CHECK) || \
|
|
(defined(WOLFSSL_TLS13) && defined(HAVE_SESSION_TICKET))
|
|
data[idx++] = sess->cipherSuite0;
|
|
data[idx++] = sess->cipherSuite;
|
|
#endif
|
|
#ifndef NO_CLIENT_CACHE
|
|
c16toa(sess->idLen, data + idx); idx += OPAQUE16_LEN;
|
|
XMEMCPY(data + idx, sess->serverID, sess->idLen);
|
|
idx += sess->idLen;
|
|
#endif
|
|
#ifdef WOLFSSL_SESSION_ID_CTX
|
|
data[idx++] = sess->sessionCtxSz;
|
|
XMEMCPY(data + idx, sess->sessionCtx, sess->sessionCtxSz);
|
|
idx += sess->sessionCtxSz;
|
|
#endif
|
|
#if defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL)
|
|
data[idx++] = sess->peerVerifyRet;
|
|
#endif
|
|
#ifdef WOLFSSL_TLS13
|
|
c16toa(sess->namedGroup, data + idx);
|
|
idx += OPAQUE16_LEN;
|
|
#endif
|
|
#if defined(HAVE_SESSION_TICKET) || !defined(NO_PSK)
|
|
#ifdef WOLFSSL_TLS13
|
|
#ifdef WOLFSSL_32BIT_MILLI_TIME
|
|
c32toa(sess->ticketSeen, data + idx);
|
|
idx += OPAQUE32_LEN;
|
|
#else
|
|
c32toa((word32)(sess->ticketSeen >> 32), data + idx);
|
|
idx += OPAQUE32_LEN;
|
|
c32toa((word32)sess->ticketSeen, data + idx);
|
|
idx += OPAQUE32_LEN;
|
|
#endif
|
|
c32toa(sess->ticketAdd, data + idx);
|
|
idx += OPAQUE32_LEN;
|
|
data[idx++] = sess->ticketNonce.len;
|
|
XMEMCPY(data + idx, sess->ticketNonce.data, sess->ticketNonce.len);
|
|
idx += sess->ticketNonce.len;
|
|
#endif
|
|
#ifdef WOLFSSL_EARLY_DATA
|
|
c32toa(sess->maxEarlyDataSz, data + idx);
|
|
idx += OPAQUE32_LEN;
|
|
#endif
|
|
#endif
|
|
#ifdef HAVE_SESSION_TICKET
|
|
c16toa(sess->ticketLen, data + idx); idx += OPAQUE16_LEN;
|
|
XMEMCPY(data + idx, sess->ticket, sess->ticketLen);
|
|
idx += sess->ticketLen;
|
|
#endif
|
|
}
|
|
#endif
|
|
|
|
(void)sess;
|
|
(void)p;
|
|
#ifdef HAVE_EXT_CACHE
|
|
(void)idx;
|
|
#endif
|
|
|
|
return size;
|
|
}
|
|
|
|
|
|
/* TODO: no function to free new session.
|
|
*
|
|
* Note: It is expected that the importing and exporting function have been
|
|
* built with the same settings. For example if session tickets was
|
|
* enabled with the wolfSSL library exporting a session then it is
|
|
* expected to be turned on with the wolfSSL library importing the session.
|
|
*/
|
|
WOLFSSL_SESSION* wolfSSL_d2i_SSL_SESSION(WOLFSSL_SESSION** sess,
|
|
const unsigned char** p, long i)
|
|
{
|
|
WOLFSSL_SESSION* s = NULL;
|
|
int ret = 0;
|
|
#if defined(HAVE_EXT_CACHE)
|
|
int idx;
|
|
byte* data;
|
|
#ifdef SESSION_CERTS
|
|
int j;
|
|
word16 length;
|
|
#endif
|
|
#endif /* HAVE_EXT_CACHE */
|
|
|
|
(void)p;
|
|
(void)i;
|
|
(void)ret;
|
|
(void)sess;
|
|
|
|
#ifdef HAVE_EXT_CACHE
|
|
if (p == NULL || *p == NULL)
|
|
return NULL;
|
|
|
|
s = wolfSSL_SESSION_new();
|
|
if (s == NULL)
|
|
return NULL;
|
|
|
|
idx = 0;
|
|
data = (byte*)*p;
|
|
|
|
/* side | bornOn | timeout | sessionID len */
|
|
if (i < OPAQUE8_LEN + OPAQUE32_LEN + OPAQUE32_LEN + OPAQUE8_LEN) {
|
|
ret = BUFFER_ERROR;
|
|
goto end;
|
|
}
|
|
s->side = data[idx++];
|
|
ato32(data + idx, &s->bornOn); idx += OPAQUE32_LEN;
|
|
ato32(data + idx, &s->timeout); idx += OPAQUE32_LEN;
|
|
s->sessionIDSz = data[idx++];
|
|
|
|
/* sessionID | secret | haveEMS | haveAltSessionID */
|
|
if (i - idx < s->sessionIDSz + SECRET_LEN + OPAQUE8_LEN + OPAQUE8_LEN) {
|
|
ret = BUFFER_ERROR;
|
|
goto end;
|
|
}
|
|
XMEMCPY(s->sessionID, data + idx, s->sessionIDSz);
|
|
idx += s->sessionIDSz;
|
|
XMEMCPY(s->masterSecret, data + idx, SECRET_LEN); idx += SECRET_LEN;
|
|
s->haveEMS = data[idx++];
|
|
if (data[idx] != ID_LEN && data[idx] != 0) {
|
|
ret = BUFFER_ERROR;
|
|
goto end;
|
|
}
|
|
s->haveAltSessionID = data[idx++] == ID_LEN;
|
|
|
|
/* altSessionID */
|
|
if (s->haveAltSessionID) {
|
|
if (i - idx < ID_LEN) {
|
|
ret = BUFFER_ERROR;
|
|
goto end;
|
|
}
|
|
XMEMCPY(s->altSessionID, data + idx, ID_LEN); idx += ID_LEN;
|
|
}
|
|
|
|
#ifdef SESSION_CERTS
|
|
/* Certificate chain */
|
|
if (i - idx == 0) {
|
|
ret = BUFFER_ERROR;
|
|
goto end;
|
|
}
|
|
s->chain.count = data[idx++];
|
|
for (j = 0; j < s->chain.count; j++) {
|
|
if (i - idx < OPAQUE16_LEN) {
|
|
ret = BUFFER_ERROR;
|
|
goto end;
|
|
}
|
|
ato16(data + idx, &length); idx += OPAQUE16_LEN;
|
|
s->chain.certs[j].length = length;
|
|
if (i - idx < length) {
|
|
ret = BUFFER_ERROR;
|
|
goto end;
|
|
}
|
|
XMEMCPY(s->chain.certs[j].buffer, data + idx, length);
|
|
idx += length;
|
|
}
|
|
#endif
|
|
#if defined(SESSION_CERTS) || (defined(WOLFSSL_TLS13) && \
|
|
defined(HAVE_SESSION_TICKET))
|
|
/* Protocol Version */
|
|
if (i - idx < OPAQUE16_LEN) {
|
|
ret = BUFFER_ERROR;
|
|
goto end;
|
|
}
|
|
s->version.major = data[idx++];
|
|
s->version.minor = data[idx++];
|
|
#endif
|
|
#if defined(SESSION_CERTS) || !defined(NO_RESUME_SUITE_CHECK) || \
|
|
(defined(WOLFSSL_TLS13) && defined(HAVE_SESSION_TICKET))
|
|
/* Cipher suite */
|
|
if (i - idx < OPAQUE16_LEN) {
|
|
ret = BUFFER_ERROR;
|
|
goto end;
|
|
}
|
|
s->cipherSuite0 = data[idx++];
|
|
s->cipherSuite = data[idx++];
|
|
#endif
|
|
#ifndef NO_CLIENT_CACHE
|
|
/* ServerID len */
|
|
if (i - idx < OPAQUE16_LEN) {
|
|
ret = BUFFER_ERROR;
|
|
goto end;
|
|
}
|
|
ato16(data + idx, &s->idLen); idx += OPAQUE16_LEN;
|
|
|
|
/* ServerID */
|
|
if (i - idx < s->idLen) {
|
|
ret = BUFFER_ERROR;
|
|
goto end;
|
|
}
|
|
XMEMCPY(s->serverID, data + idx, s->idLen); idx += s->idLen;
|
|
#endif
|
|
#ifdef WOLFSSL_SESSION_ID_CTX
|
|
/* byte for length of session context ID */
|
|
if (i - idx < OPAQUE8_LEN) {
|
|
ret = BUFFER_ERROR;
|
|
goto end;
|
|
}
|
|
s->sessionCtxSz = data[idx++];
|
|
|
|
/* app session context ID */
|
|
if (i - idx < s->sessionCtxSz) {
|
|
ret = BUFFER_ERROR;
|
|
goto end;
|
|
}
|
|
XMEMCPY(s->sessionCtx, data + idx, s->sessionCtxSz); idx += s->sessionCtxSz;
|
|
#endif
|
|
#if defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL)
|
|
/* byte for peerVerifyRet */
|
|
if (i - idx < OPAQUE8_LEN) {
|
|
ret = BUFFER_ERROR;
|
|
goto end;
|
|
}
|
|
s->peerVerifyRet = data[idx++];
|
|
#endif
|
|
#ifdef WOLFSSL_TLS13
|
|
if (i - idx < OPAQUE16_LEN) {
|
|
ret = BUFFER_ERROR;
|
|
goto end;
|
|
}
|
|
ato16(data + idx, &s->namedGroup);
|
|
idx += OPAQUE16_LEN;
|
|
#endif
|
|
#if defined(HAVE_SESSION_TICKET) || !defined(NO_PSK)
|
|
#ifdef WOLFSSL_TLS13
|
|
if (i - idx < (OPAQUE32_LEN * 2)) {
|
|
ret = BUFFER_ERROR;
|
|
goto end;
|
|
}
|
|
#ifdef WOLFSSL_32BIT_MILLI_TIME
|
|
ato32(data + idx, &s->ticketSeen);
|
|
idx += OPAQUE32_LEN;
|
|
#else
|
|
{
|
|
word32 seenHi, seenLo;
|
|
|
|
ato32(data + idx, &seenHi);
|
|
idx += OPAQUE32_LEN;
|
|
ato32(data + idx, &seenLo);
|
|
idx += OPAQUE32_LEN;
|
|
s->ticketSeen = ((sword64)seenHi << 32) + seenLo;
|
|
}
|
|
#endif
|
|
ato32(data + idx, &s->ticketAdd);
|
|
idx += OPAQUE32_LEN;
|
|
if (i - idx < OPAQUE8_LEN) {
|
|
ret = BUFFER_ERROR;
|
|
goto end;
|
|
}
|
|
s->ticketNonce.len = data[idx++];
|
|
|
|
if (i - idx < s->ticketNonce.len) {
|
|
ret = BUFFER_ERROR;
|
|
goto end;
|
|
}
|
|
#if defined(WOLFSSL_TICKET_NONCE_MALLOC) && \
|
|
(!defined(HAVE_FIPS) || (defined(FIPS_VERSION_GE) && FIPS_VERSION_GE(5,3)))
|
|
ret = SessionTicketNoncePopulate(s, data + idx, s->ticketNonce.len);
|
|
if (ret != 0)
|
|
goto end;
|
|
#else
|
|
if (s->ticketNonce.len > MAX_TICKET_NONCE_STATIC_SZ) {
|
|
ret = BUFFER_ERROR;
|
|
goto end;
|
|
}
|
|
XMEMCPY(s->ticketNonce.data, data + idx, s->ticketNonce.len);
|
|
#endif /* defined(WOLFSSL_TICKET_NONCE_MALLOC) && FIPS_VERSION_GE(5,3) */
|
|
|
|
idx += s->ticketNonce.len;
|
|
#endif
|
|
#ifdef WOLFSSL_EARLY_DATA
|
|
if (i - idx < OPAQUE32_LEN) {
|
|
ret = BUFFER_ERROR;
|
|
goto end;
|
|
}
|
|
ato32(data + idx, &s->maxEarlyDataSz);
|
|
idx += OPAQUE32_LEN;
|
|
#endif
|
|
#endif
|
|
#ifdef HAVE_SESSION_TICKET
|
|
/* ticket len */
|
|
if (i - idx < OPAQUE16_LEN) {
|
|
ret = BUFFER_ERROR;
|
|
goto end;
|
|
}
|
|
ato16(data + idx, &s->ticketLen); idx += OPAQUE16_LEN;
|
|
|
|
/* Dispose of ol dynamic ticket and ensure space for new ticket. */
|
|
if (s->ticketLenAlloc > 0) {
|
|
XFREE(s->ticket, NULL, DYNAMIC_TYPE_SESSION_TICK);
|
|
}
|
|
if (s->ticketLen <= SESSION_TICKET_LEN)
|
|
s->ticket = s->staticTicket;
|
|
else {
|
|
s->ticket = (byte*)XMALLOC(s->ticketLen, NULL,
|
|
DYNAMIC_TYPE_SESSION_TICK);
|
|
if (s->ticket == NULL) {
|
|
ret = MEMORY_ERROR;
|
|
goto end;
|
|
}
|
|
s->ticketLenAlloc = (word16)s->ticketLen;
|
|
}
|
|
|
|
/* ticket */
|
|
if (i - idx < s->ticketLen) {
|
|
ret = BUFFER_ERROR;
|
|
goto end;
|
|
}
|
|
XMEMCPY(s->ticket, data + idx, s->ticketLen); idx += s->ticketLen;
|
|
#endif
|
|
(void)idx;
|
|
|
|
if (sess != NULL) {
|
|
*sess = s;
|
|
}
|
|
|
|
s->isSetup = 1;
|
|
|
|
*p += idx;
|
|
|
|
end:
|
|
if (ret != 0 && (sess == NULL || *sess != s)) {
|
|
wolfSSL_FreeSession(NULL, s);
|
|
s = NULL;
|
|
}
|
|
#endif /* HAVE_EXT_CACHE */
|
|
return s;
|
|
}
|
|
|
|
/* Check if there is a session ticket associated with this WOLFSSL_SESSION.
|
|
*
|
|
* sess - pointer to WOLFSSL_SESSION struct
|
|
*
|
|
* Returns 1 if has session ticket, otherwise 0 */
|
|
int wolfSSL_SESSION_has_ticket(const WOLFSSL_SESSION* sess)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_SESSION_has_ticket");
|
|
#ifdef HAVE_SESSION_TICKET
|
|
sess = ClientSessionToSession(sess);
|
|
if (sess) {
|
|
if ((sess->ticketLen > 0) && (sess->ticket != NULL)) {
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
}
|
|
#else
|
|
(void)sess;
|
|
#endif
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
unsigned long wolfSSL_SESSION_get_ticket_lifetime_hint(
|
|
const WOLFSSL_SESSION* sess)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_SESSION_get_ticket_lifetime_hint");
|
|
sess = ClientSessionToSession(sess);
|
|
if (sess) {
|
|
return sess->timeout;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
long wolfSSL_SESSION_get_timeout(const WOLFSSL_SESSION* sess)
|
|
{
|
|
long timeout = 0;
|
|
WOLFSSL_ENTER("wolfSSL_SESSION_get_timeout");
|
|
sess = ClientSessionToSession(sess);
|
|
if (sess)
|
|
timeout = sess->timeout;
|
|
return timeout;
|
|
}
|
|
|
|
long wolfSSL_SSL_SESSION_set_timeout(WOLFSSL_SESSION* ses, long t)
|
|
{
|
|
word32 tmptime;
|
|
|
|
ses = ClientSessionToSession(ses);
|
|
if (ses == NULL || t < 0) {
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
tmptime = t & 0xFFFFFFFF;
|
|
ses->timeout = tmptime;
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
long wolfSSL_SESSION_get_time(const WOLFSSL_SESSION* sess)
|
|
{
|
|
long bornOn = 0;
|
|
WOLFSSL_ENTER("wolfSSL_SESSION_get_time");
|
|
sess = ClientSessionToSession(sess);
|
|
if (sess)
|
|
bornOn = sess->bornOn;
|
|
return bornOn;
|
|
}
|
|
|
|
long wolfSSL_SESSION_set_time(WOLFSSL_SESSION *ses, long t)
|
|
{
|
|
|
|
ses = ClientSessionToSession(ses);
|
|
if (ses == NULL || t < 0) {
|
|
return 0;
|
|
}
|
|
ses->bornOn = (word32)t;
|
|
return t;
|
|
}
|
|
|
|
#endif /* !NO_SESSION_CACHE && OPENSSL_EXTRA || HAVE_EXT_CACHE */
|
|
|
|
#ifdef OPENSSL_EXTRA
|
|
|
|
#if defined(HAVE_EX_DATA) && !defined(NO_FILESYSTEM)
|
|
int wolfSSL_cmp_peer_cert_to_file(WOLFSSL* ssl, const char *fname)
|
|
{
|
|
int ret = WOLFSSL_FATAL_ERROR;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_cmp_peer_cert_to_file");
|
|
if (ssl != NULL && fname != NULL)
|
|
{
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
byte staticBuffer[1]; /* force heap usage */
|
|
#else
|
|
byte staticBuffer[FILE_BUFFER_SIZE];
|
|
#endif
|
|
byte* myBuffer = staticBuffer;
|
|
int dynamic = 0;
|
|
XFILE file;
|
|
long sz = 0;
|
|
WOLFSSL_CTX* ctx = ssl->ctx;
|
|
WOLFSSL_X509* peer_cert = &ssl->peerCert;
|
|
DerBuffer* fileDer = NULL;
|
|
|
|
file = XFOPEN(fname, "rb");
|
|
if (file == XBADFILE)
|
|
return WOLFSSL_BAD_FILE;
|
|
|
|
if (XFSEEK(file, 0, XSEEK_END) != 0) {
|
|
XFCLOSE(file);
|
|
return WOLFSSL_BAD_FILE;
|
|
}
|
|
sz = XFTELL(file);
|
|
if (XFSEEK(file, 0, XSEEK_SET) != 0) {
|
|
XFCLOSE(file);
|
|
return WOLFSSL_BAD_FILE;
|
|
}
|
|
|
|
if (sz > MAX_WOLFSSL_FILE_SIZE || sz < 0) {
|
|
WOLFSSL_MSG("cmp_peer_cert_to_file size error");
|
|
XFCLOSE(file);
|
|
return WOLFSSL_BAD_FILE;
|
|
}
|
|
|
|
if (sz > (long)sizeof(staticBuffer)) {
|
|
WOLFSSL_MSG("Getting dynamic buffer");
|
|
myBuffer = (byte*)XMALLOC(sz, ctx->heap, DYNAMIC_TYPE_FILE);
|
|
dynamic = 1;
|
|
}
|
|
|
|
if ((myBuffer != NULL) &&
|
|
(sz > 0) &&
|
|
(XFREAD(myBuffer, 1, sz, file) == (size_t)sz) &&
|
|
(PemToDer(myBuffer, (long)sz, CERT_TYPE,
|
|
&fileDer, ctx->heap, NULL, NULL) == 0) &&
|
|
(fileDer->length != 0) &&
|
|
(fileDer->length == peer_cert->derCert->length) &&
|
|
(XMEMCMP(peer_cert->derCert->buffer, fileDer->buffer,
|
|
fileDer->length) == 0))
|
|
{
|
|
ret = 0;
|
|
}
|
|
|
|
FreeDer(&fileDer);
|
|
|
|
if (dynamic)
|
|
XFREE(myBuffer, ctx->heap, DYNAMIC_TYPE_FILE);
|
|
|
|
XFCLOSE(file);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
#endif
|
|
#endif /* OPENSSL_EXTRA */
|
|
#if defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL)
|
|
const WOLFSSL_ObjectInfo wolfssl_object_info[] = {
|
|
#ifndef NO_CERTS
|
|
/* oidCertExtType */
|
|
{ NID_basic_constraints, BASIC_CA_OID, oidCertExtType, "basicConstraints",
|
|
"X509v3 Basic Constraints"},
|
|
{ NID_subject_alt_name, ALT_NAMES_OID, oidCertExtType, "subjectAltName",
|
|
"X509v3 Subject Alternative Name"},
|
|
{ NID_crl_distribution_points, CRL_DIST_OID, oidCertExtType, "crlDistributionPoints",
|
|
"X509v3 CRL Distribution Points"},
|
|
{ NID_info_access, AUTH_INFO_OID, oidCertExtType, "authorityInfoAccess",
|
|
"Authority Information Access"},
|
|
{ NID_authority_key_identifier, AUTH_KEY_OID, oidCertExtType,
|
|
"authorityKeyIdentifier", "X509v3 Authority Key Identifier"},
|
|
{ NID_subject_key_identifier, SUBJ_KEY_OID, oidCertExtType,
|
|
"subjectKeyIdentifier", "X509v3 Subject Key Identifier"},
|
|
{ NID_key_usage, KEY_USAGE_OID, oidCertExtType, "keyUsage",
|
|
"X509v3 Key Usage"},
|
|
{ NID_inhibit_any_policy, INHIBIT_ANY_OID, oidCertExtType,
|
|
"inhibitAnyPolicy", "X509v3 Inhibit Any Policy"},
|
|
{ NID_ext_key_usage, EXT_KEY_USAGE_OID, oidCertExtType,
|
|
"extendedKeyUsage", "X509v3 Extended Key Usage"},
|
|
{ NID_name_constraints, NAME_CONS_OID, oidCertExtType,
|
|
"nameConstraints", "X509v3 Name Constraints"},
|
|
{ NID_certificate_policies, CERT_POLICY_OID, oidCertExtType,
|
|
"certificatePolicies", "X509v3 Certificate Policies"},
|
|
|
|
/* oidCertAuthInfoType */
|
|
{ NID_ad_OCSP, AIA_OCSP_OID, oidCertAuthInfoType, "OCSP",
|
|
"OCSP"},
|
|
{ NID_ad_ca_issuers, AIA_CA_ISSUER_OID, oidCertAuthInfoType,
|
|
"caIssuers", "CA Issuers"},
|
|
|
|
/* oidCertPolicyType */
|
|
{ NID_any_policy, CP_ANY_OID, oidCertPolicyType, "anyPolicy",
|
|
"X509v3 Any Policy"},
|
|
|
|
/* oidCertAltNameType */
|
|
{ NID_hw_name_oid, HW_NAME_OID, oidCertAltNameType, "Hardware name",""},
|
|
|
|
/* oidCertKeyUseType */
|
|
{ NID_anyExtendedKeyUsage, EKU_ANY_OID, oidCertKeyUseType,
|
|
"anyExtendedKeyUsage", "Any Extended Key Usage"},
|
|
{ EKU_SERVER_AUTH_OID, EKU_SERVER_AUTH_OID, oidCertKeyUseType,
|
|
"serverAuth", "TLS Web Server Authentication"},
|
|
{ EKU_CLIENT_AUTH_OID, EKU_CLIENT_AUTH_OID, oidCertKeyUseType,
|
|
"clientAuth", "TLS Web Client Authentication"},
|
|
{ EKU_OCSP_SIGN_OID, EKU_OCSP_SIGN_OID, oidCertKeyUseType,
|
|
"OCSPSigning", "OCSP Signing"},
|
|
|
|
/* oidCertNameType */
|
|
{ NID_commonName, NID_commonName, oidCertNameType, "CN", "commonName"},
|
|
#if !defined(WOLFSSL_CERT_REQ)
|
|
{ NID_surname, NID_surname, oidCertNameType, "SN", "surname"},
|
|
#endif
|
|
{ NID_serialNumber, NID_serialNumber, oidCertNameType, "serialNumber",
|
|
"serialNumber"},
|
|
{ NID_userId, NID_userId, oidCertNameType, "UID", "userid"},
|
|
{ NID_countryName, NID_countryName, oidCertNameType, "C", "countryName"},
|
|
{ NID_localityName, NID_localityName, oidCertNameType, "L", "localityName"},
|
|
{ NID_stateOrProvinceName, NID_stateOrProvinceName, oidCertNameType, "ST",
|
|
"stateOrProvinceName"},
|
|
{ NID_streetAddress, NID_streetAddress, oidCertNameType, "street",
|
|
"streetAddress"},
|
|
{ NID_organizationName, NID_organizationName, oidCertNameType, "O",
|
|
"organizationName"},
|
|
{ NID_organizationalUnitName, NID_organizationalUnitName, oidCertNameType,
|
|
"OU", "organizationalUnitName"},
|
|
{ NID_emailAddress, NID_emailAddress, oidCertNameType, "emailAddress",
|
|
"emailAddress"},
|
|
{ NID_domainComponent, NID_domainComponent, oidCertNameType, "DC",
|
|
"domainComponent"},
|
|
{ NID_favouriteDrink, NID_favouriteDrink, oidCertNameType, "favouriteDrink",
|
|
"favouriteDrink"},
|
|
{ NID_businessCategory, NID_businessCategory, oidCertNameType, "businessCategory",
|
|
"businessCategory"},
|
|
{ NID_jurisdictionCountryName, NID_jurisdictionCountryName, oidCertNameType, "jurisdictionC",
|
|
"jurisdictionCountryName"},
|
|
{ NID_jurisdictionStateOrProvinceName, NID_jurisdictionStateOrProvinceName,
|
|
oidCertNameType, "jurisdictionST", "jurisdictionStateOrProvinceName"},
|
|
{ NID_postalCode, NID_postalCode, oidCertNameType, "postalCode", "postalCode"},
|
|
{ NID_userId, NID_userId, oidCertNameType, "UID", "userId"},
|
|
|
|
#if defined(WOLFSSL_CERT_REQ) || defined(WOLFSSL_CERT_NAME_ALL)
|
|
{ NID_pkcs9_challengePassword, CHALLENGE_PASSWORD_OID,
|
|
oidCsrAttrType, "challengePassword", "challengePassword"},
|
|
{ NID_pkcs9_contentType, PKCS9_CONTENT_TYPE_OID,
|
|
oidCsrAttrType, "contentType", "contentType" },
|
|
{ NID_pkcs9_unstructuredName, UNSTRUCTURED_NAME_OID,
|
|
oidCsrAttrType, "unstructuredName", "unstructuredName" },
|
|
{ NID_name, NAME_OID, oidCsrAttrType, "name", "name" },
|
|
{ NID_surname, SURNAME_OID,
|
|
oidCsrAttrType, "surname", "surname" },
|
|
{ NID_givenName, GIVEN_NAME_OID,
|
|
oidCsrAttrType, "givenName", "givenName" },
|
|
{ NID_initials, INITIALS_OID,
|
|
oidCsrAttrType, "initials", "initials" },
|
|
{ NID_dnQualifier, DNQUALIFIER_OID,
|
|
oidCsrAttrType, "dnQualifer", "dnQualifier" },
|
|
#endif
|
|
#endif
|
|
#ifdef OPENSSL_EXTRA /* OPENSSL_EXTRA_X509_SMALL only needs the above */
|
|
/* oidHashType */
|
|
#ifdef WOLFSSL_MD2
|
|
{ NID_md2, MD2h, oidHashType, "MD2", "md2"},
|
|
#endif
|
|
#ifdef WOLFSSL_MD5
|
|
{ NID_md5, MD5h, oidHashType, "MD5", "md5"},
|
|
#endif
|
|
#ifndef NO_SHA
|
|
{ NID_sha1, SHAh, oidHashType, "SHA1", "sha1"},
|
|
#endif
|
|
#ifdef WOLFSSL_SHA224
|
|
{ NID_sha224, SHA224h, oidHashType, "SHA224", "sha224"},
|
|
#endif
|
|
#ifndef NO_SHA256
|
|
{ NID_sha256, SHA256h, oidHashType, "SHA256", "sha256"},
|
|
#endif
|
|
#ifdef WOLFSSL_SHA384
|
|
{ NID_sha384, SHA384h, oidHashType, "SHA384", "sha384"},
|
|
#endif
|
|
#ifdef WOLFSSL_SHA512
|
|
{ NID_sha512, SHA512h, oidHashType, "SHA512", "sha512"},
|
|
#endif
|
|
#ifdef WOLFSSL_SHA3
|
|
#ifndef WOLFSSL_NOSHA3_224
|
|
{ NID_sha3_224, SHA3_224h, oidHashType, "SHA3-224", "sha3-224"},
|
|
#endif
|
|
#ifndef WOLFSSL_NOSHA3_256
|
|
{ NID_sha3_256, SHA3_256h, oidHashType, "SHA3-256", "sha3-256"},
|
|
#endif
|
|
#ifndef WOLFSSL_NOSHA3_384
|
|
{ NID_sha3_384, SHA3_384h, oidHashType, "SHA3-384", "sha3-384"},
|
|
#endif
|
|
#ifndef WOLFSSL_NOSHA3_512
|
|
{ NID_sha3_512, SHA3_512h, oidHashType, "SHA3-512", "sha3-512"},
|
|
#endif
|
|
#endif /* WOLFSSL_SHA3 */
|
|
#ifdef WOLFSSL_SM3
|
|
{ NID_sm3, SM3h, oidHashType, "SM3", "sm3"},
|
|
#endif
|
|
/* oidSigType */
|
|
#ifndef NO_DSA
|
|
#ifndef NO_SHA
|
|
{ NID_dsaWithSHA1, CTC_SHAwDSA, oidSigType, "DSA-SHA1", "dsaWithSHA1"},
|
|
{ NID_dsa_with_SHA256, CTC_SHA256wDSA, oidSigType, "dsa_with_SHA256",
|
|
"dsa_with_SHA256"},
|
|
#endif
|
|
#endif /* NO_DSA */
|
|
#ifndef NO_RSA
|
|
#ifdef WOLFSSL_MD2
|
|
{ NID_md2WithRSAEncryption, CTC_MD2wRSA, oidSigType, "RSA-MD2",
|
|
"md2WithRSAEncryption"},
|
|
#endif
|
|
#ifndef NO_MD5
|
|
{ NID_md5WithRSAEncryption, CTC_MD5wRSA, oidSigType, "RSA-MD5",
|
|
"md5WithRSAEncryption"},
|
|
#endif
|
|
#ifndef NO_SHA
|
|
{ NID_sha1WithRSAEncryption, CTC_SHAwRSA, oidSigType, "RSA-SHA1",
|
|
"sha1WithRSAEncryption"},
|
|
#endif
|
|
#ifdef WOLFSSL_SHA224
|
|
{ NID_sha224WithRSAEncryption, CTC_SHA224wRSA, oidSigType, "RSA-SHA224",
|
|
"sha224WithRSAEncryption"},
|
|
#endif
|
|
#ifndef NO_SHA256
|
|
{ NID_sha256WithRSAEncryption, CTC_SHA256wRSA, oidSigType, "RSA-SHA256",
|
|
"sha256WithRSAEncryption"},
|
|
#endif
|
|
#ifdef WOLFSSL_SHA384
|
|
{ NID_sha384WithRSAEncryption, CTC_SHA384wRSA, oidSigType, "RSA-SHA384",
|
|
"sha384WithRSAEncryption"},
|
|
#endif
|
|
#ifdef WOLFSSL_SHA512
|
|
{ NID_sha512WithRSAEncryption, CTC_SHA512wRSA, oidSigType, "RSA-SHA512",
|
|
"sha512WithRSAEncryption"},
|
|
#endif
|
|
#ifdef WOLFSSL_SHA3
|
|
#ifndef WOLFSSL_NOSHA3_224
|
|
{ NID_RSA_SHA3_224, CTC_SHA3_224wRSA, oidSigType, "RSA-SHA3-224",
|
|
"sha3-224WithRSAEncryption"},
|
|
#endif
|
|
#ifndef WOLFSSL_NOSHA3_256
|
|
{ NID_RSA_SHA3_256, CTC_SHA3_256wRSA, oidSigType, "RSA-SHA3-256",
|
|
"sha3-256WithRSAEncryption"},
|
|
#endif
|
|
#ifndef WOLFSSL_NOSHA3_384
|
|
{ NID_RSA_SHA3_384, CTC_SHA3_384wRSA, oidSigType, "RSA-SHA3-384",
|
|
"sha3-384WithRSAEncryption"},
|
|
#endif
|
|
#ifndef WOLFSSL_NOSHA3_512
|
|
{ NID_RSA_SHA3_512, CTC_SHA3_512wRSA, oidSigType, "RSA-SHA3-512",
|
|
"sha3-512WithRSAEncryption"},
|
|
#endif
|
|
#endif
|
|
#ifdef WC_RSA_PSS
|
|
{ NID_rsassaPss, CTC_RSASSAPSS, oidSigType, "RSASSA-PSS", "rsassaPss" },
|
|
#endif
|
|
#endif /* NO_RSA */
|
|
#ifdef HAVE_ECC
|
|
#ifndef NO_SHA
|
|
{ NID_ecdsa_with_SHA1, CTC_SHAwECDSA, oidSigType, "ecdsa-with-SHA1", "shaWithECDSA"},
|
|
#endif
|
|
#ifdef WOLFSSL_SHA224
|
|
{ NID_ecdsa_with_SHA224, CTC_SHA224wECDSA, oidSigType, "ecdsa-with-SHA224","sha224WithECDSA"},
|
|
#endif
|
|
#ifndef NO_SHA256
|
|
{ NID_ecdsa_with_SHA256, CTC_SHA256wECDSA, oidSigType, "ecdsa-with-SHA256","sha256WithECDSA"},
|
|
#endif
|
|
#ifdef WOLFSSL_SHA384
|
|
{ NID_ecdsa_with_SHA384, CTC_SHA384wECDSA, oidSigType, "ecdsa-with-SHA384","sha384WithECDSA"},
|
|
#endif
|
|
#ifdef WOLFSSL_SHA512
|
|
{ NID_ecdsa_with_SHA512, CTC_SHA512wECDSA, oidSigType, "ecdsa-with-SHA512","sha512WithECDSA"},
|
|
#endif
|
|
#ifdef WOLFSSL_SHA3
|
|
#ifndef WOLFSSL_NOSHA3_224
|
|
{ NID_ecdsa_with_SHA3_224, CTC_SHA3_224wECDSA, oidSigType, "id-ecdsa-with-SHA3-224",
|
|
"ecdsa_with_SHA3-224"},
|
|
#endif
|
|
#ifndef WOLFSSL_NOSHA3_256
|
|
{ NID_ecdsa_with_SHA3_256, CTC_SHA3_256wECDSA, oidSigType, "id-ecdsa-with-SHA3-256",
|
|
"ecdsa_with_SHA3-256"},
|
|
#endif
|
|
#ifndef WOLFSSL_NOSHA3_384
|
|
{ NID_ecdsa_with_SHA3_384, CTC_SHA3_384wECDSA, oidSigType, "id-ecdsa-with-SHA3-384",
|
|
"ecdsa_with_SHA3-384"},
|
|
#endif
|
|
#ifndef WOLFSSL_NOSHA3_512
|
|
{ NID_ecdsa_with_SHA3_512, CTC_SHA3_512wECDSA, oidSigType, "id-ecdsa-with-SHA3-512",
|
|
"ecdsa_with_SHA3-512"},
|
|
#endif
|
|
#endif
|
|
#endif /* HAVE_ECC */
|
|
|
|
/* oidKeyType */
|
|
#ifndef NO_DSA
|
|
{ NID_dsa, DSAk, oidKeyType, "DSA", "dsaEncryption"},
|
|
#endif /* NO_DSA */
|
|
#ifndef NO_RSA
|
|
{ NID_rsaEncryption, RSAk, oidKeyType, "rsaEncryption", "rsaEncryption"},
|
|
#ifdef WC_RSA_PSS
|
|
{ NID_rsassaPss, RSAPSSk, oidKeyType, "RSASSA-PSS", "rsassaPss"},
|
|
#endif
|
|
#endif /* NO_RSA */
|
|
#ifdef HAVE_ECC
|
|
{ NID_X9_62_id_ecPublicKey, ECDSAk, oidKeyType, "id-ecPublicKey",
|
|
"id-ecPublicKey"},
|
|
#endif /* HAVE_ECC */
|
|
#ifndef NO_DH
|
|
{ NID_dhKeyAgreement, DHk, oidKeyType, "dhKeyAgreement", "dhKeyAgreement"},
|
|
#endif
|
|
#ifdef HAVE_ED448
|
|
{ NID_ED448, ED448k, oidKeyType, "ED448", "ED448"},
|
|
#endif
|
|
#ifdef HAVE_ED25519
|
|
{ NID_ED25519, ED25519k, oidKeyType, "ED25519", "ED25519"},
|
|
#endif
|
|
#ifdef HAVE_PQC
|
|
#ifdef HAVE_FALCON
|
|
{ CTC_FALCON_LEVEL1, FALCON_LEVEL1k, oidKeyType, "Falcon Level 1",
|
|
"Falcon Level 1"},
|
|
{ CTC_FALCON_LEVEL5, FALCON_LEVEL5k, oidKeyType, "Falcon Level 5",
|
|
"Falcon Level 5"},
|
|
#endif /* HAVE_FALCON */
|
|
#ifdef HAVE_DILITHIUM
|
|
{ CTC_DILITHIUM_LEVEL2, DILITHIUM_LEVEL2k, oidKeyType,
|
|
"Dilithium Level 2", "Dilithium Level 2"},
|
|
{ CTC_DILITHIUM_LEVEL3, DILITHIUM_LEVEL3k, oidKeyType,
|
|
"Dilithium Level 3", "Dilithium Level 3"},
|
|
{ CTC_DILITHIUM_LEVEL5, DILITHIUM_LEVEL5k, oidKeyType,
|
|
"Dilithium Level 5", "Dilithium Level 5"},
|
|
#endif /* HAVE_DILITHIUM */
|
|
#endif /* HAVE_PQC */
|
|
|
|
/* oidCurveType */
|
|
#ifdef HAVE_ECC
|
|
{ NID_X9_62_prime192v1, ECC_SECP192R1_OID, oidCurveType, "prime192v1", "prime192v1"},
|
|
{ NID_X9_62_prime192v2, ECC_PRIME192V2_OID, oidCurveType, "prime192v2", "prime192v2"},
|
|
{ NID_X9_62_prime192v3, ECC_PRIME192V3_OID, oidCurveType, "prime192v3", "prime192v3"},
|
|
|
|
{ NID_X9_62_prime239v1, ECC_PRIME239V1_OID, oidCurveType, "prime239v1", "prime239v1"},
|
|
{ NID_X9_62_prime239v2, ECC_PRIME239V2_OID, oidCurveType, "prime239v2", "prime239v2"},
|
|
{ NID_X9_62_prime239v3, ECC_PRIME239V3_OID, oidCurveType, "prime239v3", "prime239v3"},
|
|
|
|
{ NID_X9_62_prime256v1, ECC_SECP256R1_OID, oidCurveType, "prime256v1", "prime256v1"},
|
|
|
|
{ NID_secp112r1, ECC_SECP112R1_OID, oidCurveType, "secp112r1", "secp112r1"},
|
|
{ NID_secp112r2, ECC_SECP112R2_OID, oidCurveType, "secp112r2", "secp112r2"},
|
|
|
|
{ NID_secp128r1, ECC_SECP128R1_OID, oidCurveType, "secp128r1", "secp128r1"},
|
|
{ NID_secp128r2, ECC_SECP128R2_OID, oidCurveType, "secp128r2", "secp128r2"},
|
|
|
|
{ NID_secp160r1, ECC_SECP160R1_OID, oidCurveType, "secp160r1", "secp160r1"},
|
|
{ NID_secp160r2, ECC_SECP160R2_OID, oidCurveType, "secp160r2", "secp160r2"},
|
|
|
|
{ NID_secp224r1, ECC_SECP224R1_OID, oidCurveType, "secp224r1", "secp224r1"},
|
|
{ NID_secp384r1, ECC_SECP384R1_OID, oidCurveType, "secp384r1", "secp384r1"},
|
|
{ NID_secp521r1, ECC_SECP521R1_OID, oidCurveType, "secp521r1", "secp521r1"},
|
|
|
|
{ NID_secp160k1, ECC_SECP160K1_OID, oidCurveType, "secp160k1", "secp160k1"},
|
|
{ NID_secp192k1, ECC_SECP192K1_OID, oidCurveType, "secp192k1", "secp192k1"},
|
|
{ NID_secp224k1, ECC_SECP224K1_OID, oidCurveType, "secp224k1", "secp224k1"},
|
|
{ NID_secp256k1, ECC_SECP256K1_OID, oidCurveType, "secp256k1", "secp256k1"},
|
|
|
|
{ NID_brainpoolP160r1, ECC_BRAINPOOLP160R1_OID, oidCurveType, "brainpoolP160r1", "brainpoolP160r1"},
|
|
{ NID_brainpoolP192r1, ECC_BRAINPOOLP192R1_OID, oidCurveType, "brainpoolP192r1", "brainpoolP192r1"},
|
|
{ NID_brainpoolP224r1, ECC_BRAINPOOLP224R1_OID, oidCurveType, "brainpoolP224r1", "brainpoolP224r1"},
|
|
{ NID_brainpoolP256r1, ECC_BRAINPOOLP256R1_OID, oidCurveType, "brainpoolP256r1", "brainpoolP256r1"},
|
|
{ NID_brainpoolP320r1, ECC_BRAINPOOLP320R1_OID, oidCurveType, "brainpoolP320r1", "brainpoolP320r1"},
|
|
{ NID_brainpoolP384r1, ECC_BRAINPOOLP384R1_OID, oidCurveType, "brainpoolP384r1", "brainpoolP384r1"},
|
|
{ NID_brainpoolP512r1, ECC_BRAINPOOLP512R1_OID, oidCurveType, "brainpoolP512r1", "brainpoolP512r1"},
|
|
|
|
#ifdef WOLFSSL_SM2
|
|
{ NID_sm2, ECC_SM2P256V1_OID, oidCurveType, "sm2", "sm2"},
|
|
#endif
|
|
#endif /* HAVE_ECC */
|
|
|
|
/* oidBlkType */
|
|
#ifdef WOLFSSL_AES_128
|
|
{ AES128CBCb, AES128CBCb, oidBlkType, "AES-128-CBC", "aes-128-cbc"},
|
|
#endif
|
|
#ifdef WOLFSSL_AES_192
|
|
{ AES192CBCb, AES192CBCb, oidBlkType, "AES-192-CBC", "aes-192-cbc"},
|
|
#endif
|
|
#ifdef WOLFSSL_AES_256
|
|
{ AES256CBCb, AES256CBCb, oidBlkType, "AES-256-CBC", "aes-256-cbc"},
|
|
#endif
|
|
#ifndef NO_DES3
|
|
{ NID_des, DESb, oidBlkType, "DES-CBC", "des-cbc"},
|
|
{ NID_des3, DES3b, oidBlkType, "DES-EDE3-CBC", "des-ede3-cbc"},
|
|
#endif /* !NO_DES3 */
|
|
#if defined(HAVE_CHACHA) && defined(HAVE_POLY1305)
|
|
{ NID_chacha20_poly1305, NID_chacha20_poly1305, oidBlkType, "ChaCha20-Poly1305", "chacha20-poly1305"},
|
|
#endif
|
|
|
|
/* oidOcspType */
|
|
#ifdef HAVE_OCSP
|
|
{ NID_id_pkix_OCSP_basic, OCSP_BASIC_OID, oidOcspType, "basicOCSPResponse",
|
|
"Basic OCSP Response"},
|
|
{ OCSP_NONCE_OID, OCSP_NONCE_OID, oidOcspType, "Nonce",
|
|
"OCSP Nonce"},
|
|
#endif /* HAVE_OCSP */
|
|
|
|
#ifndef NO_PWDBASED
|
|
/* oidKdfType */
|
|
{ PBKDF2_OID, PBKDF2_OID, oidKdfType, "PBKDFv2", "PBKDF2"},
|
|
|
|
/* oidPBEType */
|
|
{ PBE_SHA1_RC4_128, PBE_SHA1_RC4_128, oidPBEType,
|
|
"PBE-SHA1-RC4-128", "pbeWithSHA1And128BitRC4"},
|
|
{ PBE_SHA1_DES, PBE_SHA1_DES, oidPBEType, "PBE-SHA1-DES",
|
|
"pbeWithSHA1AndDES-CBC"},
|
|
{ PBE_SHA1_DES3, PBE_SHA1_DES3, oidPBEType, "PBE-SHA1-3DES",
|
|
"pbeWithSHA1And3-KeyTripleDES-CBC"},
|
|
#endif
|
|
|
|
/* oidKeyWrapType */
|
|
#ifdef WOLFSSL_AES_128
|
|
{ AES128_WRAP, AES128_WRAP, oidKeyWrapType, "AES-128 wrap", "aes128-wrap"},
|
|
#endif
|
|
#ifdef WOLFSSL_AES_192
|
|
{ AES192_WRAP, AES192_WRAP, oidKeyWrapType, "AES-192 wrap", "aes192-wrap"},
|
|
#endif
|
|
#ifdef WOLFSSL_AES_256
|
|
{ AES256_WRAP, AES256_WRAP, oidKeyWrapType, "AES-256 wrap", "aes256-wrap"},
|
|
#endif
|
|
|
|
#ifndef NO_PKCS7
|
|
#ifndef NO_DH
|
|
/* oidCmsKeyAgreeType */
|
|
#ifndef NO_SHA
|
|
{ dhSinglePass_stdDH_sha1kdf_scheme, dhSinglePass_stdDH_sha1kdf_scheme,
|
|
oidCmsKeyAgreeType, "dhSinglePass-stdDH-sha1kdf-scheme", "dhSinglePass-stdDH-sha1kdf-scheme"},
|
|
#endif
|
|
#ifdef WOLFSSL_SHA224
|
|
{ dhSinglePass_stdDH_sha224kdf_scheme,
|
|
dhSinglePass_stdDH_sha224kdf_scheme, oidCmsKeyAgreeType,
|
|
"dhSinglePass-stdDH-sha224kdf-scheme", "dhSinglePass-stdDH-sha224kdf-scheme"},
|
|
#endif
|
|
#ifndef NO_SHA256
|
|
{ dhSinglePass_stdDH_sha256kdf_scheme,
|
|
dhSinglePass_stdDH_sha256kdf_scheme, oidCmsKeyAgreeType,
|
|
"dhSinglePass-stdDH-sha256kdf-scheme", "dhSinglePass-stdDH-sha256kdf-scheme"},
|
|
#endif
|
|
#ifdef WOLFSSL_SHA384
|
|
{ dhSinglePass_stdDH_sha384kdf_scheme,
|
|
dhSinglePass_stdDH_sha384kdf_scheme, oidCmsKeyAgreeType,
|
|
"dhSinglePass-stdDH-sha384kdf-scheme", "dhSinglePass-stdDH-sha384kdf-scheme"},
|
|
#endif
|
|
#ifdef WOLFSSL_SHA512
|
|
{ dhSinglePass_stdDH_sha512kdf_scheme,
|
|
dhSinglePass_stdDH_sha512kdf_scheme, oidCmsKeyAgreeType,
|
|
"dhSinglePass-stdDH-sha512kdf-scheme", "dhSinglePass-stdDH-sha512kdf-scheme"},
|
|
#endif
|
|
#endif
|
|
#endif
|
|
#if defined(WOLFSSL_APACHE_HTTPD)
|
|
/* "1.3.6.1.5.5.7.8.7" */
|
|
{ NID_id_on_dnsSRV, NID_id_on_dnsSRV, oidCertNameType,
|
|
WOLFSSL_SN_DNS_SRV, WOLFSSL_LN_DNS_SRV },
|
|
|
|
/* "1.3.6.1.4.1.311.20.2.3" */
|
|
{ NID_ms_upn, WOLFSSL_MS_UPN_SUM, oidCertExtType, WOLFSSL_SN_MS_UPN,
|
|
WOLFSSL_LN_MS_UPN },
|
|
|
|
/* "1.3.6.1.5.5.7.1.24" */
|
|
{ NID_tlsfeature, WOLFSSL_TLS_FEATURE_SUM, oidTlsExtType,
|
|
WOLFSSL_SN_TLS_FEATURE, WOLFSSL_LN_TLS_FEATURE },
|
|
#endif
|
|
#endif /* OPENSSL_EXTRA */
|
|
};
|
|
|
|
#define WOLFSSL_OBJECT_INFO_SZ \
|
|
(sizeof(wolfssl_object_info) / sizeof(*wolfssl_object_info))
|
|
const size_t wolfssl_object_info_sz = WOLFSSL_OBJECT_INFO_SZ;
|
|
#endif
|
|
|
|
#if defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL)
|
|
/* Free the dynamically allocated data.
|
|
*
|
|
* p Pointer to dynamically allocated memory.
|
|
*/
|
|
void wolfSSL_OPENSSL_free(void* p)
|
|
{
|
|
WOLFSSL_MSG("wolfSSL_OPENSSL_free");
|
|
|
|
XFREE(p, NULL, DYNAMIC_TYPE_OPENSSL);
|
|
}
|
|
#endif /* OPENSSL_EXTRA || OPENSSL_EXTRA_X509_SMALL */
|
|
|
|
#ifdef OPENSSL_EXTRA
|
|
|
|
void *wolfSSL_OPENSSL_malloc(size_t a)
|
|
{
|
|
return (void *)XMALLOC(a, NULL, DYNAMIC_TYPE_OPENSSL);
|
|
}
|
|
|
|
int wolfSSL_OPENSSL_hexchar2int(unsigned char c)
|
|
{
|
|
/* 'char' is unsigned on some platforms. */
|
|
return (int)(signed char)HexCharToByte((char)c);
|
|
}
|
|
|
|
unsigned char *wolfSSL_OPENSSL_hexstr2buf(const char *str, long *len)
|
|
{
|
|
unsigned char* targetBuf;
|
|
int srcDigitHigh = 0;
|
|
int srcDigitLow = 0;
|
|
size_t srcLen;
|
|
size_t srcIdx = 0;
|
|
long targetIdx = 0;
|
|
|
|
srcLen = XSTRLEN(str);
|
|
targetBuf = (unsigned char*)XMALLOC(srcLen / 2, NULL, DYNAMIC_TYPE_OPENSSL);
|
|
if (targetBuf == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
while (srcIdx < srcLen) {
|
|
if (str[srcIdx] == ':') {
|
|
srcIdx++;
|
|
continue;
|
|
}
|
|
|
|
srcDigitHigh = wolfSSL_OPENSSL_hexchar2int(str[srcIdx++]);
|
|
srcDigitLow = wolfSSL_OPENSSL_hexchar2int(str[srcIdx++]);
|
|
if (srcDigitHigh < 0 || srcDigitLow < 0) {
|
|
WOLFSSL_MSG("Invalid hex character.");
|
|
XFREE(targetBuf, NULL, DYNAMIC_TYPE_OPENSSL);
|
|
return NULL;
|
|
}
|
|
|
|
targetBuf[targetIdx++] = (unsigned char)((srcDigitHigh << 4) | srcDigitLow);
|
|
}
|
|
|
|
if (len != NULL)
|
|
*len = targetIdx;
|
|
|
|
return targetBuf;
|
|
}
|
|
|
|
int wolfSSL_OPENSSL_init_ssl(word64 opts, const OPENSSL_INIT_SETTINGS *settings)
|
|
{
|
|
(void)opts;
|
|
(void)settings;
|
|
return wolfSSL_library_init();
|
|
}
|
|
|
|
int wolfSSL_OPENSSL_init_crypto(word64 opts, const OPENSSL_INIT_SETTINGS* settings)
|
|
{
|
|
(void)opts;
|
|
(void)settings;
|
|
return wolfSSL_library_init();
|
|
}
|
|
|
|
#if defined(WOLFSSL_KEY_GEN) && defined(WOLFSSL_PEM_TO_DER)
|
|
|
|
int EncryptDerKey(byte *der, int *derSz, const EVP_CIPHER* cipher,
|
|
unsigned char* passwd, int passwdSz, byte **cipherInfo,
|
|
int maxDerSz)
|
|
{
|
|
int ret, paddingSz;
|
|
word32 idx, cipherInfoSz;
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
EncryptedInfo* info = NULL;
|
|
#else
|
|
EncryptedInfo info[1];
|
|
#endif
|
|
|
|
WOLFSSL_ENTER("EncryptDerKey");
|
|
|
|
if (der == NULL || derSz == NULL || cipher == NULL ||
|
|
passwd == NULL || cipherInfo == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
info = (EncryptedInfo*)XMALLOC(sizeof(EncryptedInfo), NULL,
|
|
DYNAMIC_TYPE_ENCRYPTEDINFO);
|
|
if (info == NULL) {
|
|
WOLFSSL_MSG("malloc failed");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
#endif
|
|
|
|
XMEMSET(info, 0, sizeof(EncryptedInfo));
|
|
|
|
/* set the cipher name on info */
|
|
XSTRNCPY(info->name, cipher, NAME_SZ-1);
|
|
info->name[NAME_SZ-1] = '\0'; /* null term */
|
|
|
|
ret = wc_EncryptedInfoGet(info, info->name);
|
|
if (ret != 0) {
|
|
WOLFSSL_MSG("unsupported cipher");
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
XFREE(info, NULL, DYNAMIC_TYPE_ENCRYPTEDINFO);
|
|
#endif
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
/* Generate a random salt */
|
|
if (wolfSSL_RAND_bytes(info->iv, info->ivSz) != WOLFSSL_SUCCESS) {
|
|
WOLFSSL_MSG("generate iv failed");
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
XFREE(info, NULL, DYNAMIC_TYPE_ENCRYPTEDINFO);
|
|
#endif
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
/* add the padding before encryption */
|
|
paddingSz = ((*derSz)/info->ivSz + 1) * info->ivSz - (*derSz);
|
|
if (paddingSz == 0)
|
|
paddingSz = info->ivSz;
|
|
if (maxDerSz < *derSz + paddingSz) {
|
|
WOLFSSL_MSG("not enough DER buffer allocated");
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
XFREE(info, NULL, DYNAMIC_TYPE_ENCRYPTEDINFO);
|
|
#endif
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
XMEMSET(der+(*derSz), (byte)paddingSz, paddingSz);
|
|
(*derSz) += paddingSz;
|
|
|
|
/* encrypt buffer */
|
|
if (wc_BufferKeyEncrypt(info, der, *derSz, passwd, passwdSz, WC_MD5) != 0) {
|
|
WOLFSSL_MSG("encrypt key failed");
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
XFREE(info, NULL, DYNAMIC_TYPE_ENCRYPTEDINFO);
|
|
#endif
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
/* create cipher info : 'cipher_name,Salt(hex)' */
|
|
cipherInfoSz = (word32)(2*info->ivSz + XSTRLEN(info->name) + 2);
|
|
*cipherInfo = (byte*)XMALLOC(cipherInfoSz, NULL,
|
|
DYNAMIC_TYPE_STRING);
|
|
if (*cipherInfo == NULL) {
|
|
WOLFSSL_MSG("malloc failed");
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
XFREE(info, NULL, DYNAMIC_TYPE_ENCRYPTEDINFO);
|
|
#endif
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
XSTRLCPY((char*)*cipherInfo, info->name, cipherInfoSz);
|
|
XSTRLCAT((char*)*cipherInfo, ",", cipherInfoSz);
|
|
|
|
idx = (word32)XSTRLEN((char*)*cipherInfo);
|
|
cipherInfoSz -= idx;
|
|
ret = Base16_Encode(info->iv, info->ivSz, *cipherInfo+idx, &cipherInfoSz);
|
|
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
XFREE(info, NULL, DYNAMIC_TYPE_ENCRYPTEDINFO);
|
|
#endif
|
|
if (ret != 0) {
|
|
WOLFSSL_MSG("Base16_Encode failed");
|
|
XFREE(*cipherInfo, NULL, DYNAMIC_TYPE_STRING);
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
#endif /* WOLFSSL_KEY_GEN || WOLFSSL_PEM_TO_DER */
|
|
|
|
#if !defined(NO_BIO)
|
|
static int pem_write_pubkey(WOLFSSL_EVP_PKEY* key, void* heap, byte** derBuf,
|
|
int* derSz)
|
|
{
|
|
byte* buf = NULL;
|
|
int sz = 0;
|
|
|
|
(void)heap;
|
|
|
|
if (key == NULL) {
|
|
WOLFSSL_MSG("Bad parameters");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
switch (key->type) {
|
|
#if defined(WOLFSSL_KEY_GEN) && !defined(NO_RSA) && !defined(HAVE_USER_RSA)
|
|
case EVP_PKEY_RSA:
|
|
if ((sz = wolfSSL_RSA_To_Der(key->rsa, &buf, 1, heap))
|
|
< 0) {
|
|
WOLFSSL_MSG("wolfSSL_RSA_To_Der failed");
|
|
break;
|
|
}
|
|
break;
|
|
#endif /* WOLFSSL_KEY_GEN && !NO_RSA && !HAVE_USER_RSA */
|
|
#if !defined(NO_DSA) && !defined(HAVE_SELFTEST) && (defined(WOLFSSL_KEY_GEN) || \
|
|
defined(WOLFSSL_CERT_GEN))
|
|
case EVP_PKEY_DSA:
|
|
if (key->dsa == NULL) {
|
|
WOLFSSL_MSG("key->dsa is null");
|
|
break;
|
|
}
|
|
sz = MAX_DSA_PUBKEY_SZ;
|
|
buf = (byte*)XMALLOC(sz, heap, DYNAMIC_TYPE_TMP_BUFFER);
|
|
if (buf == NULL) {
|
|
WOLFSSL_MSG("malloc failed");
|
|
break;
|
|
}
|
|
/* Key to DER */
|
|
sz = wc_DsaKeyToPublicDer((DsaKey*)key->dsa->internal, buf, sz);
|
|
if (sz < 0) {
|
|
WOLFSSL_MSG("wc_DsaKeyToDer failed");
|
|
break;
|
|
}
|
|
break;
|
|
#endif /* !NO_DSA && !HAVE_SELFTEST && (WOLFSSL_KEY_GEN || WOLFSSL_CERT_GEN) */
|
|
#if defined(HAVE_ECC) && defined(HAVE_ECC_KEY_EXPORT)
|
|
case EVP_PKEY_EC:
|
|
{
|
|
if (key->ecc == NULL) {
|
|
WOLFSSL_MSG("key->ecc is null");
|
|
break;
|
|
}
|
|
if ((sz = wolfssl_ec_key_to_pubkey_der(key->ecc, &buf, heap)) <=
|
|
0) {
|
|
WOLFSSL_MSG("wolfssl_ec_key_to_pubkey_der failed");
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
#endif /* HAVE_ECC && HAVE_ECC_KEY_EXPORT */
|
|
#if !defined(NO_DH) && (defined(WOLFSSL_QT) || defined(OPENSSL_ALL))
|
|
case EVP_PKEY_DH:
|
|
WOLFSSL_MSG("Writing DH PUBKEY not supported!");
|
|
break;
|
|
#endif /* !NO_DH && (WOLFSSL_QT || OPENSSL_ALL) */
|
|
default:
|
|
WOLFSSL_MSG("Unknown Key type!");
|
|
break;
|
|
}
|
|
|
|
if (buf == NULL || sz <= 0) {
|
|
if (buf != NULL)
|
|
XFREE(buf, heap, DYNAMIC_TYPE_DER);
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
*derBuf = buf;
|
|
*derSz = sz;
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
#endif
|
|
|
|
#ifndef NO_BIO
|
|
static int pem_write_bio_pubkey(WOLFSSL_BIO* bio, WOLFSSL_EVP_PKEY* key)
|
|
{
|
|
int ret;
|
|
int derSz = 0;
|
|
byte* derBuf = NULL;
|
|
|
|
ret = pem_write_pubkey(key, bio->heap, &derBuf, &derSz);
|
|
if (ret == WOLFSSL_SUCCESS) {
|
|
ret = der_write_to_bio_as_pem(derBuf, derSz, bio, PUBLICKEY_TYPE);
|
|
XFREE(derBuf, bio->heap, DYNAMIC_TYPE_DER);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/* Takes a public key and writes it out to a WOLFSSL_BIO
|
|
* Returns WOLFSSL_SUCCESS or WOLFSSL_FAILURE
|
|
*/
|
|
int wolfSSL_PEM_write_bio_PUBKEY(WOLFSSL_BIO* bio, WOLFSSL_EVP_PKEY* key)
|
|
{
|
|
int ret;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_PEM_write_bio_PUBKEY");
|
|
|
|
if ((bio == NULL) || (key == NULL)) {
|
|
ret = WOLFSSL_FAILURE;
|
|
}
|
|
else {
|
|
ret = pem_write_bio_pubkey(bio, key);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/* Takes a private key and writes it out to a WOLFSSL_BIO
|
|
* Returns WOLFSSL_SUCCESS or WOLFSSL_FAILURE
|
|
*/
|
|
int wolfSSL_PEM_write_bio_PrivateKey(WOLFSSL_BIO* bio, WOLFSSL_EVP_PKEY* key,
|
|
const WOLFSSL_EVP_CIPHER* cipher,
|
|
unsigned char* passwd, int len,
|
|
wc_pem_password_cb* cb, void* arg)
|
|
{
|
|
byte* keyDer;
|
|
int type;
|
|
|
|
(void)cipher;
|
|
(void)passwd;
|
|
(void)len;
|
|
(void)cb;
|
|
(void)arg;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_PEM_write_bio_PrivateKey");
|
|
|
|
if (bio == NULL || key == NULL) {
|
|
WOLFSSL_MSG("Bad Function Arguments");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
keyDer = (byte*)key->pkey.ptr;
|
|
|
|
switch (key->type) {
|
|
#ifndef NO_RSA
|
|
case EVP_PKEY_RSA:
|
|
type = PRIVATEKEY_TYPE;
|
|
break;
|
|
#endif
|
|
|
|
#ifndef NO_DSA
|
|
case EVP_PKEY_DSA:
|
|
type = DSA_PRIVATEKEY_TYPE;
|
|
break;
|
|
#endif
|
|
|
|
#ifdef HAVE_ECC
|
|
case EVP_PKEY_EC:
|
|
type = ECC_PRIVATEKEY_TYPE;
|
|
break;
|
|
#endif
|
|
|
|
#if !defined(NO_DH) && (defined(WOLFSSL_QT) || defined(OPENSSL_ALL))
|
|
case EVP_PKEY_DH:
|
|
type = DH_PRIVATEKEY_TYPE;
|
|
break;
|
|
#endif
|
|
|
|
default:
|
|
WOLFSSL_MSG("Unknown Key type!");
|
|
type = PRIVATEKEY_TYPE;
|
|
}
|
|
|
|
return der_write_to_bio_as_pem(keyDer, key->pkey_sz, bio, type);
|
|
}
|
|
#endif /* !NO_BIO */
|
|
|
|
/* Colon separated list of <public key>+<digest> algorithms.
|
|
* Replaces list in context.
|
|
*/
|
|
int wolfSSL_CTX_set1_sigalgs_list(WOLFSSL_CTX* ctx, const char* list)
|
|
{
|
|
WOLFSSL_MSG("wolfSSL_CTX_set1_sigalg_list");
|
|
|
|
if (ctx == NULL || list == NULL) {
|
|
WOLFSSL_MSG("Bad function arguments");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
if (AllocateCtxSuites(ctx) != 0)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
return SetSuitesHashSigAlgo(ctx->suites, list);
|
|
}
|
|
|
|
/* Colon separated list of <public key>+<digest> algorithms.
|
|
* Replaces list in SSL.
|
|
*/
|
|
int wolfSSL_set1_sigalgs_list(WOLFSSL* ssl, const char* list)
|
|
{
|
|
WOLFSSL_MSG("wolfSSL_set1_sigalg_list");
|
|
|
|
if (ssl == NULL || list == NULL) {
|
|
WOLFSSL_MSG("Bad function arguments");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
if (AllocateSuites(ssl) != 0)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
return SetSuitesHashSigAlgo(ssl->suites, list);
|
|
}
|
|
|
|
struct WOLFSSL_HashSigInfo {
|
|
int hashAlgo;
|
|
int sigAlgo;
|
|
int nid;
|
|
} wolfssl_hash_sig_info[] =
|
|
{
|
|
#ifndef NO_RSA
|
|
#ifndef NO_SHA256
|
|
{ sha256_mac, rsa_sa_algo, CTC_SHA256wRSA },
|
|
#endif
|
|
#ifdef WOLFSSL_SHA384
|
|
{ sha384_mac, rsa_sa_algo, CTC_SHA384wRSA },
|
|
#endif
|
|
#ifdef WOLFSSL_SHA512
|
|
{ sha512_mac, rsa_sa_algo, CTC_SHA512wRSA },
|
|
#endif
|
|
#ifdef WOLFSSL_SHA224
|
|
{ sha224_mac, rsa_sa_algo, CTC_SHA224wRSA },
|
|
#endif
|
|
#ifndef NO_SHA
|
|
{ sha_mac, rsa_sa_algo, CTC_SHAwRSA },
|
|
#endif
|
|
#ifdef WC_RSA_PSS
|
|
#ifndef NO_SHA256
|
|
{ sha256_mac, rsa_pss_sa_algo, CTC_SHA256wRSA },
|
|
#endif
|
|
#ifdef WOLFSSL_SHA384
|
|
{ sha384_mac, rsa_pss_sa_algo, CTC_SHA384wRSA },
|
|
#endif
|
|
#ifdef WOLFSSL_SHA512
|
|
{ sha512_mac, rsa_pss_sa_algo, CTC_SHA512wRSA },
|
|
#endif
|
|
#ifdef WOLFSSL_SHA224
|
|
{ sha224_mac, rsa_pss_sa_algo, CTC_SHA224wRSA },
|
|
#endif
|
|
#endif
|
|
#endif
|
|
#ifdef HAVE_ECC
|
|
#ifndef NO_SHA256
|
|
{ sha256_mac, ecc_dsa_sa_algo, CTC_SHA256wECDSA },
|
|
#endif
|
|
#ifdef WOLFSSL_SHA384
|
|
{ sha384_mac, ecc_dsa_sa_algo, CTC_SHA384wECDSA },
|
|
#endif
|
|
#ifdef WOLFSSL_SHA512
|
|
{ sha512_mac, ecc_dsa_sa_algo, CTC_SHA512wECDSA },
|
|
#endif
|
|
#ifdef WOLFSSL_SHA224
|
|
{ sha224_mac, ecc_dsa_sa_algo, CTC_SHA224wECDSA },
|
|
#endif
|
|
#ifndef NO_SHA
|
|
{ sha_mac, ecc_dsa_sa_algo, CTC_SHAwECDSA },
|
|
#endif
|
|
#endif
|
|
#if defined(WOLFSSL_SM2) && defined(WOLFSSL_SM3)
|
|
{ sm3_mac, sm2_sa_algo, CTC_SM3wSM2 },
|
|
#endif
|
|
#ifdef HAVE_ED25519
|
|
{ no_mac, ed25519_sa_algo, CTC_ED25519 },
|
|
#endif
|
|
#ifdef HAVE_ED448
|
|
{ no_mac, ed448_sa_algo, CTC_ED448 },
|
|
#endif
|
|
#ifdef HAVE_PQC
|
|
#ifdef HAVE_FALCON
|
|
{ no_mac, falcon_level1_sa_algo, CTC_FALCON_LEVEL1 },
|
|
{ no_mac, falcon_level5_sa_algo, CTC_FALCON_LEVEL5 },
|
|
#endif /* HAVE_FALCON */
|
|
#ifdef HAVE_DILITHIUM
|
|
{ no_mac, dilithium_level2_sa_algo, CTC_DILITHIUM_LEVEL2 },
|
|
{ no_mac, dilithium_level3_sa_algo, CTC_DILITHIUM_LEVEL3 },
|
|
{ no_mac, dilithium_level5_sa_algo, CTC_DILITHIUM_LEVEL5 },
|
|
#endif /* HAVE_DILITHIUM */
|
|
#endif /* HAVE_PQC */
|
|
#ifndef NO_DSA
|
|
#ifndef NO_SHA
|
|
{ sha_mac, dsa_sa_algo, CTC_SHAwDSA },
|
|
#endif
|
|
#endif
|
|
};
|
|
#define WOLFSSL_HASH_SIG_INFO_SZ \
|
|
(int)(sizeof(wolfssl_hash_sig_info)/sizeof(*wolfssl_hash_sig_info))
|
|
|
|
int wolfSSL_get_signature_nid(WOLFSSL *ssl, int* nid)
|
|
{
|
|
int i;
|
|
int ret = WOLFSSL_FAILURE;
|
|
|
|
WOLFSSL_MSG("wolfSSL_get_signature_nid");
|
|
|
|
if (ssl == NULL) {
|
|
WOLFSSL_MSG("Bad function arguments");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
for (i = 0; i < WOLFSSL_HASH_SIG_INFO_SZ; i++) {
|
|
if (ssl->options.hashAlgo == wolfssl_hash_sig_info[i].hashAlgo &&
|
|
ssl->options.sigAlgo == wolfssl_hash_sig_info[i].sigAlgo) {
|
|
*nid = wolfssl_hash_sig_info[i].nid;
|
|
ret = WOLFSSL_SUCCESS;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
#ifdef HAVE_ECC
|
|
|
|
#if defined(WOLFSSL_TLS13) && defined(HAVE_SUPPORTED_CURVES)
|
|
static int populate_groups(int* groups, int max_count, char *list)
|
|
{
|
|
char *end;
|
|
int count = 0;
|
|
const WOLF_EC_NIST_NAME* nist_name;
|
|
|
|
if (!groups || !list) {
|
|
return -1;
|
|
}
|
|
|
|
for (end = list; ; list = ++end) {
|
|
int len;
|
|
|
|
if (count > max_count) {
|
|
WOLFSSL_MSG("Too many curves in list");
|
|
return -1;
|
|
}
|
|
while (*end != ':' && *end != '\0') end++;
|
|
len = (int)(end - list); /* end points to char after end
|
|
* of curve name so no need for -1 */
|
|
if ((len < kNistCurves_MIN_NAME_LEN) ||
|
|
(len > kNistCurves_MAX_NAME_LEN)) {
|
|
WOLFSSL_MSG("Unrecognized curve name in list");
|
|
return -1;
|
|
}
|
|
for (nist_name = kNistCurves; nist_name->name != NULL; nist_name++) {
|
|
if (len == nist_name->name_len &&
|
|
XSTRNCMP(list, nist_name->name, nist_name->name_len) == 0) {
|
|
break;
|
|
}
|
|
}
|
|
if (!nist_name->name) {
|
|
WOLFSSL_MSG("Unrecognized curve name in list");
|
|
return -1;
|
|
}
|
|
groups[count++] = nist_name->nid;
|
|
if (*end == '\0') break;
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
int wolfSSL_CTX_set1_groups_list(WOLFSSL_CTX *ctx, char *list)
|
|
{
|
|
int groups[WOLFSSL_MAX_GROUP_COUNT];
|
|
int count;
|
|
|
|
if (!ctx || !list) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
if ((count = populate_groups(groups,
|
|
WOLFSSL_MAX_GROUP_COUNT, list)) == -1) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
return wolfSSL_CTX_set1_groups(ctx, groups, count);
|
|
}
|
|
|
|
int wolfSSL_set1_groups_list(WOLFSSL *ssl, char *list)
|
|
{
|
|
int groups[WOLFSSL_MAX_GROUP_COUNT];
|
|
int count;
|
|
|
|
if (!ssl || !list) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
if ((count = populate_groups(groups,
|
|
WOLFSSL_MAX_GROUP_COUNT, list)) == -1) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
return wolfSSL_set1_groups(ssl, groups, count);
|
|
}
|
|
#endif /* WOLFSSL_TLS13 */
|
|
|
|
#endif /* HAVE_ECC */
|
|
|
|
#ifndef NO_BIO
|
|
WOLFSSL_EVP_PKEY* wolfSSL_PEM_read_bio_PrivateKey(WOLFSSL_BIO* bio,
|
|
WOLFSSL_EVP_PKEY** key,
|
|
wc_pem_password_cb* cb,
|
|
void* pass)
|
|
{
|
|
WOLFSSL_EVP_PKEY* pkey = NULL;
|
|
DerBuffer* der = NULL;
|
|
int keyFormat = 0;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_PEM_read_bio_PrivateKey");
|
|
|
|
if (bio == NULL)
|
|
return pkey;
|
|
|
|
if (pem_read_bio_key(bio, cb, pass, PRIVATEKEY_TYPE, &keyFormat, &der)
|
|
>= 0) {
|
|
const unsigned char* ptr = der->buffer;
|
|
int type = -1;
|
|
|
|
if (keyFormat) {
|
|
/* keyFormat is Key_Sum enum */
|
|
if (keyFormat == RSAk)
|
|
type = EVP_PKEY_RSA;
|
|
else if (keyFormat == ECDSAk)
|
|
type = EVP_PKEY_EC;
|
|
else if (keyFormat == DSAk)
|
|
type = EVP_PKEY_DSA;
|
|
else if (keyFormat == DHk)
|
|
type = EVP_PKEY_DH;
|
|
}
|
|
else {
|
|
/* Default to RSA if format is not set */
|
|
type = EVP_PKEY_RSA;
|
|
}
|
|
|
|
/* handle case where reuse is attempted */
|
|
if (key != NULL && *key != NULL)
|
|
pkey = *key;
|
|
|
|
wolfSSL_d2i_PrivateKey(type, &pkey, &ptr, der->length);
|
|
if (pkey == NULL) {
|
|
WOLFSSL_MSG("Error loading DER buffer into WOLFSSL_EVP_PKEY");
|
|
}
|
|
}
|
|
|
|
FreeDer(&der);
|
|
|
|
if (key != NULL && pkey != NULL)
|
|
*key = pkey;
|
|
|
|
WOLFSSL_LEAVE("wolfSSL_PEM_read_bio_PrivateKey", 0);
|
|
|
|
return pkey;
|
|
}
|
|
|
|
WOLFSSL_EVP_PKEY *wolfSSL_PEM_read_bio_PUBKEY(WOLFSSL_BIO* bio,
|
|
WOLFSSL_EVP_PKEY **key,
|
|
wc_pem_password_cb *cb,
|
|
void *pass)
|
|
{
|
|
WOLFSSL_EVP_PKEY* pkey = NULL;
|
|
DerBuffer* der = NULL;
|
|
int keyFormat = 0;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_PEM_read_bio_PUBKEY");
|
|
|
|
if (bio == NULL)
|
|
return pkey;
|
|
|
|
if (pem_read_bio_key(bio, cb, pass, PUBLICKEY_TYPE, &keyFormat, &der)
|
|
>= 0) {
|
|
const unsigned char* ptr = der->buffer;
|
|
|
|
/* handle case where reuse is attempted */
|
|
if (key != NULL && *key != NULL)
|
|
pkey = *key;
|
|
|
|
wolfSSL_d2i_PUBKEY(&pkey, &ptr, der->length);
|
|
if (pkey == NULL) {
|
|
WOLFSSL_MSG("Error loading DER buffer into WOLFSSL_EVP_PKEY");
|
|
}
|
|
}
|
|
|
|
FreeDer(&der);
|
|
|
|
if (key != NULL && pkey != NULL)
|
|
*key = pkey;
|
|
|
|
WOLFSSL_LEAVE("wolfSSL_PEM_read_bio_PUBKEY", 0);
|
|
|
|
return pkey;
|
|
}
|
|
#endif /* !NO_BIO */
|
|
|
|
#if !defined(NO_FILESYSTEM)
|
|
WOLFSSL_EVP_PKEY *wolfSSL_PEM_read_PUBKEY(XFILE fp, WOLFSSL_EVP_PKEY **key,
|
|
wc_pem_password_cb *cb, void *pass)
|
|
{
|
|
WOLFSSL_EVP_PKEY* pkey = NULL;
|
|
DerBuffer* der = NULL;
|
|
int keyFormat = 0;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_PEM_read_PUBKEY");
|
|
|
|
if ((pem_read_file_key(fp, cb, pass, PUBLICKEY_TYPE, &keyFormat, &der)
|
|
>= 0) && (der != NULL)) {
|
|
const unsigned char* ptr = der->buffer;
|
|
|
|
/* handle case where reuse is attempted */
|
|
if ((key != NULL) && (*key != NULL)) {
|
|
pkey = *key;
|
|
}
|
|
|
|
if ((wolfSSL_d2i_PUBKEY(&pkey, &ptr, der->length) == NULL) ||
|
|
(pkey == NULL)) {
|
|
WOLFSSL_MSG("Error loading DER buffer into WOLFSSL_EVP_PKEY");
|
|
pkey = NULL;
|
|
}
|
|
}
|
|
|
|
FreeDer(&der);
|
|
|
|
if ((key != NULL) && (pkey != NULL)) {
|
|
*key = pkey;
|
|
}
|
|
|
|
WOLFSSL_LEAVE("wolfSSL_PEM_read_PUBKEY", 0);
|
|
|
|
return pkey;
|
|
}
|
|
#endif /* NO_FILESYSTEM */
|
|
#endif /* OPENSSL_EXTRA */
|
|
|
|
#ifdef WOLFSSL_ALT_CERT_CHAINS
|
|
int wolfSSL_is_peer_alt_cert_chain(const WOLFSSL* ssl)
|
|
{
|
|
int isUsing = 0;
|
|
if (ssl)
|
|
isUsing = ssl->options.usingAltCertChain;
|
|
return isUsing;
|
|
}
|
|
#endif /* WOLFSSL_ALT_CERT_CHAINS */
|
|
|
|
|
|
#ifdef SESSION_CERTS
|
|
|
|
#ifdef WOLFSSL_ALT_CERT_CHAINS
|
|
/* Get peer's alternate certificate chain */
|
|
WOLFSSL_X509_CHAIN* wolfSSL_get_peer_alt_chain(WOLFSSL* ssl)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_get_peer_alt_chain");
|
|
if (ssl)
|
|
return &ssl->session->altChain;
|
|
|
|
return 0;
|
|
}
|
|
#endif /* WOLFSSL_ALT_CERT_CHAINS */
|
|
|
|
|
|
/* Get peer's certificate chain */
|
|
WOLFSSL_X509_CHAIN* wolfSSL_get_peer_chain(WOLFSSL* ssl)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_get_peer_chain");
|
|
if (ssl)
|
|
return &ssl->session->chain;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
/* Get peer's certificate chain total count */
|
|
int wolfSSL_get_chain_count(WOLFSSL_X509_CHAIN* chain)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_get_chain_count");
|
|
if (chain)
|
|
return chain->count;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
/* Get peer's ASN.1 DER certificate at index (idx) length in bytes */
|
|
int wolfSSL_get_chain_length(WOLFSSL_X509_CHAIN* chain, int idx)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_get_chain_length");
|
|
if (chain)
|
|
return chain->certs[idx].length;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
/* Get peer's ASN.1 DER certificate at index (idx) */
|
|
byte* wolfSSL_get_chain_cert(WOLFSSL_X509_CHAIN* chain, int idx)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_get_chain_cert");
|
|
if (chain)
|
|
return chain->certs[idx].buffer;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
/* Get peer's wolfSSL X509 certificate at index (idx) */
|
|
WOLFSSL_X509* wolfSSL_get_chain_X509(WOLFSSL_X509_CHAIN* chain, int idx)
|
|
{
|
|
int ret;
|
|
WOLFSSL_X509* x509 = NULL;
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
DecodedCert* cert = NULL;
|
|
#else
|
|
DecodedCert cert[1];
|
|
#endif
|
|
|
|
WOLFSSL_ENTER("wolfSSL_get_chain_X509");
|
|
if (chain != NULL) {
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
cert = (DecodedCert*)XMALLOC(sizeof(DecodedCert), NULL,
|
|
DYNAMIC_TYPE_DCERT);
|
|
if (cert != NULL)
|
|
#endif
|
|
{
|
|
InitDecodedCert(cert, chain->certs[idx].buffer,
|
|
chain->certs[idx].length, NULL);
|
|
|
|
if ((ret = ParseCertRelative(cert, CERT_TYPE, 0, NULL)) != 0) {
|
|
WOLFSSL_MSG("Failed to parse cert");
|
|
}
|
|
else {
|
|
x509 = (WOLFSSL_X509*)XMALLOC(sizeof(WOLFSSL_X509), NULL,
|
|
DYNAMIC_TYPE_X509);
|
|
if (x509 == NULL) {
|
|
WOLFSSL_MSG("Failed alloc X509");
|
|
}
|
|
else {
|
|
InitX509(x509, 1, NULL);
|
|
|
|
if ((ret = CopyDecodedToX509(x509, cert)) != 0) {
|
|
WOLFSSL_MSG("Failed to copy decoded");
|
|
wolfSSL_X509_free(x509);
|
|
x509 = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
FreeDecodedCert(cert);
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
XFREE(cert, NULL, DYNAMIC_TYPE_DCERT);
|
|
#endif
|
|
}
|
|
}
|
|
(void)ret;
|
|
|
|
return x509;
|
|
}
|
|
|
|
|
|
/* Get peer's PEM certificate at index (idx), output to buffer if inLen big
|
|
enough else return error (-1). If buffer is NULL only calculate
|
|
outLen. Output length is in *outLen WOLFSSL_SUCCESS on ok */
|
|
int wolfSSL_get_chain_cert_pem(WOLFSSL_X509_CHAIN* chain, int idx,
|
|
unsigned char* buf, int inLen, int* outLen)
|
|
{
|
|
#if defined(WOLFSSL_PEM_TO_DER) || defined(WOLFSSL_DER_TO_PEM)
|
|
const char* header = NULL;
|
|
const char* footer = NULL;
|
|
int headerLen;
|
|
int footerLen;
|
|
int i;
|
|
int err;
|
|
word32 szNeeded = 0;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_get_chain_cert_pem");
|
|
if (!chain || !outLen || idx < 0 || idx >= wolfSSL_get_chain_count(chain))
|
|
return BAD_FUNC_ARG;
|
|
|
|
err = wc_PemGetHeaderFooter(CERT_TYPE, &header, &footer);
|
|
if (err != 0)
|
|
return err;
|
|
|
|
headerLen = (int)XSTRLEN(header);
|
|
footerLen = (int)XSTRLEN(footer);
|
|
|
|
/* Null output buffer return size needed in outLen */
|
|
if(!buf) {
|
|
if(Base64_Encode(chain->certs[idx].buffer, chain->certs[idx].length,
|
|
NULL, &szNeeded) != LENGTH_ONLY_E)
|
|
return WOLFSSL_FAILURE;
|
|
*outLen = szNeeded + headerLen + footerLen;
|
|
return LENGTH_ONLY_E;
|
|
}
|
|
|
|
/* don't even try if inLen too short */
|
|
if (inLen < headerLen + footerLen + chain->certs[idx].length)
|
|
return BAD_FUNC_ARG;
|
|
|
|
/* header */
|
|
if (XMEMCPY(buf, header, headerLen) == NULL)
|
|
return WOLFSSL_FATAL_ERROR;
|
|
|
|
i = headerLen;
|
|
|
|
/* body */
|
|
*outLen = inLen; /* input to Base64_Encode */
|
|
if ( (err = Base64_Encode(chain->certs[idx].buffer,
|
|
chain->certs[idx].length, buf + i, (word32*)outLen)) < 0)
|
|
return err;
|
|
i += *outLen;
|
|
|
|
/* footer */
|
|
if ( (i + footerLen) > inLen)
|
|
return BAD_FUNC_ARG;
|
|
if (XMEMCPY(buf + i, footer, footerLen) == NULL)
|
|
return WOLFSSL_FATAL_ERROR;
|
|
*outLen += headerLen + footerLen;
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
#else
|
|
(void)chain;
|
|
(void)idx;
|
|
(void)buf;
|
|
(void)inLen;
|
|
(void)outLen;
|
|
return WOLFSSL_FAILURE;
|
|
#endif /* WOLFSSL_PEM_TO_DER || WOLFSSL_DER_TO_PEM */
|
|
}
|
|
|
|
|
|
/* get session ID */
|
|
WOLFSSL_ABI
|
|
const byte* wolfSSL_get_sessionID(const WOLFSSL_SESSION* session)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_get_sessionID");
|
|
session = ClientSessionToSession(session);
|
|
if (session)
|
|
return session->sessionID;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
#endif /* SESSION_CERTS */
|
|
|
|
#ifdef HAVE_FUZZER
|
|
void wolfSSL_SetFuzzerCb(WOLFSSL* ssl, CallbackFuzzer cbf, void* fCtx)
|
|
{
|
|
if (ssl) {
|
|
ssl->fuzzerCb = cbf;
|
|
ssl->fuzzerCtx = fCtx;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#ifndef NO_CERTS
|
|
#ifdef HAVE_PK_CALLBACKS
|
|
|
|
#ifdef HAVE_ECC
|
|
void wolfSSL_CTX_SetEccKeyGenCb(WOLFSSL_CTX* ctx, CallbackEccKeyGen cb)
|
|
{
|
|
if (ctx)
|
|
ctx->EccKeyGenCb = cb;
|
|
}
|
|
void wolfSSL_SetEccKeyGenCtx(WOLFSSL* ssl, void *ctx)
|
|
{
|
|
if (ssl)
|
|
ssl->EccKeyGenCtx = ctx;
|
|
}
|
|
void* wolfSSL_GetEccKeyGenCtx(WOLFSSL* ssl)
|
|
{
|
|
if (ssl)
|
|
return ssl->EccKeyGenCtx;
|
|
|
|
return NULL;
|
|
}
|
|
void wolfSSL_CTX_SetEccSignCtx(WOLFSSL_CTX* ctx, void *userCtx)
|
|
{
|
|
if (ctx)
|
|
ctx->EccSignCtx = userCtx;
|
|
}
|
|
void* wolfSSL_CTX_GetEccSignCtx(WOLFSSL_CTX* ctx)
|
|
{
|
|
if (ctx)
|
|
return ctx->EccSignCtx;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
WOLFSSL_ABI
|
|
void wolfSSL_CTX_SetEccSignCb(WOLFSSL_CTX* ctx, CallbackEccSign cb)
|
|
{
|
|
if (ctx)
|
|
ctx->EccSignCb = cb;
|
|
}
|
|
void wolfSSL_SetEccSignCtx(WOLFSSL* ssl, void *ctx)
|
|
{
|
|
if (ssl)
|
|
ssl->EccSignCtx = ctx;
|
|
}
|
|
void* wolfSSL_GetEccSignCtx(WOLFSSL* ssl)
|
|
{
|
|
if (ssl)
|
|
return ssl->EccSignCtx;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
void wolfSSL_CTX_SetEccVerifyCb(WOLFSSL_CTX* ctx, CallbackEccVerify cb)
|
|
{
|
|
if (ctx)
|
|
ctx->EccVerifyCb = cb;
|
|
}
|
|
void wolfSSL_SetEccVerifyCtx(WOLFSSL* ssl, void *ctx)
|
|
{
|
|
if (ssl)
|
|
ssl->EccVerifyCtx = ctx;
|
|
}
|
|
void* wolfSSL_GetEccVerifyCtx(WOLFSSL* ssl)
|
|
{
|
|
if (ssl)
|
|
return ssl->EccVerifyCtx;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
void wolfSSL_CTX_SetEccSharedSecretCb(WOLFSSL_CTX* ctx, CallbackEccSharedSecret cb)
|
|
{
|
|
if (ctx)
|
|
ctx->EccSharedSecretCb = cb;
|
|
}
|
|
void wolfSSL_SetEccSharedSecretCtx(WOLFSSL* ssl, void *ctx)
|
|
{
|
|
if (ssl)
|
|
ssl->EccSharedSecretCtx = ctx;
|
|
}
|
|
void* wolfSSL_GetEccSharedSecretCtx(WOLFSSL* ssl)
|
|
{
|
|
if (ssl)
|
|
return ssl->EccSharedSecretCtx;
|
|
|
|
return NULL;
|
|
}
|
|
#endif /* HAVE_ECC */
|
|
|
|
#ifdef HAVE_ED25519
|
|
void wolfSSL_CTX_SetEd25519SignCb(WOLFSSL_CTX* ctx, CallbackEd25519Sign cb)
|
|
{
|
|
if (ctx)
|
|
ctx->Ed25519SignCb = cb;
|
|
}
|
|
void wolfSSL_SetEd25519SignCtx(WOLFSSL* ssl, void *ctx)
|
|
{
|
|
if (ssl)
|
|
ssl->Ed25519SignCtx = ctx;
|
|
}
|
|
void* wolfSSL_GetEd25519SignCtx(WOLFSSL* ssl)
|
|
{
|
|
if (ssl)
|
|
return ssl->Ed25519SignCtx;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
void wolfSSL_CTX_SetEd25519VerifyCb(WOLFSSL_CTX* ctx, CallbackEd25519Verify cb)
|
|
{
|
|
if (ctx)
|
|
ctx->Ed25519VerifyCb = cb;
|
|
}
|
|
void wolfSSL_SetEd25519VerifyCtx(WOLFSSL* ssl, void *ctx)
|
|
{
|
|
if (ssl)
|
|
ssl->Ed25519VerifyCtx = ctx;
|
|
}
|
|
void* wolfSSL_GetEd25519VerifyCtx(WOLFSSL* ssl)
|
|
{
|
|
if (ssl)
|
|
return ssl->Ed25519VerifyCtx;
|
|
|
|
return NULL;
|
|
}
|
|
#endif /* HAVE_ED25519 */
|
|
|
|
#ifdef HAVE_CURVE25519
|
|
void wolfSSL_CTX_SetX25519KeyGenCb(WOLFSSL_CTX* ctx,
|
|
CallbackX25519KeyGen cb)
|
|
{
|
|
if (ctx)
|
|
ctx->X25519KeyGenCb = cb;
|
|
}
|
|
void wolfSSL_SetX25519KeyGenCtx(WOLFSSL* ssl, void *ctx)
|
|
{
|
|
if (ssl)
|
|
ssl->X25519KeyGenCtx = ctx;
|
|
}
|
|
void* wolfSSL_GetX25519KeyGenCtx(WOLFSSL* ssl)
|
|
{
|
|
if (ssl)
|
|
return ssl->X25519KeyGenCtx;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
void wolfSSL_CTX_SetX25519SharedSecretCb(WOLFSSL_CTX* ctx,
|
|
CallbackX25519SharedSecret cb)
|
|
{
|
|
if (ctx)
|
|
ctx->X25519SharedSecretCb = cb;
|
|
}
|
|
void wolfSSL_SetX25519SharedSecretCtx(WOLFSSL* ssl, void *ctx)
|
|
{
|
|
if (ssl)
|
|
ssl->X25519SharedSecretCtx = ctx;
|
|
}
|
|
void* wolfSSL_GetX25519SharedSecretCtx(WOLFSSL* ssl)
|
|
{
|
|
if (ssl)
|
|
return ssl->X25519SharedSecretCtx;
|
|
|
|
return NULL;
|
|
}
|
|
#endif /* HAVE_CURVE25519 */
|
|
|
|
#ifdef HAVE_ED448
|
|
void wolfSSL_CTX_SetEd448SignCb(WOLFSSL_CTX* ctx, CallbackEd448Sign cb)
|
|
{
|
|
if (ctx)
|
|
ctx->Ed448SignCb = cb;
|
|
}
|
|
void wolfSSL_SetEd448SignCtx(WOLFSSL* ssl, void *ctx)
|
|
{
|
|
if (ssl)
|
|
ssl->Ed448SignCtx = ctx;
|
|
}
|
|
void* wolfSSL_GetEd448SignCtx(WOLFSSL* ssl)
|
|
{
|
|
if (ssl)
|
|
return ssl->Ed448SignCtx;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
void wolfSSL_CTX_SetEd448VerifyCb(WOLFSSL_CTX* ctx, CallbackEd448Verify cb)
|
|
{
|
|
if (ctx)
|
|
ctx->Ed448VerifyCb = cb;
|
|
}
|
|
void wolfSSL_SetEd448VerifyCtx(WOLFSSL* ssl, void *ctx)
|
|
{
|
|
if (ssl)
|
|
ssl->Ed448VerifyCtx = ctx;
|
|
}
|
|
void* wolfSSL_GetEd448VerifyCtx(WOLFSSL* ssl)
|
|
{
|
|
if (ssl)
|
|
return ssl->Ed448VerifyCtx;
|
|
|
|
return NULL;
|
|
}
|
|
#endif /* HAVE_ED448 */
|
|
|
|
#ifdef HAVE_CURVE448
|
|
void wolfSSL_CTX_SetX448KeyGenCb(WOLFSSL_CTX* ctx,
|
|
CallbackX448KeyGen cb)
|
|
{
|
|
if (ctx)
|
|
ctx->X448KeyGenCb = cb;
|
|
}
|
|
void wolfSSL_SetX448KeyGenCtx(WOLFSSL* ssl, void *ctx)
|
|
{
|
|
if (ssl)
|
|
ssl->X448KeyGenCtx = ctx;
|
|
}
|
|
void* wolfSSL_GetX448KeyGenCtx(WOLFSSL* ssl)
|
|
{
|
|
if (ssl)
|
|
return ssl->X448KeyGenCtx;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
void wolfSSL_CTX_SetX448SharedSecretCb(WOLFSSL_CTX* ctx,
|
|
CallbackX448SharedSecret cb)
|
|
{
|
|
if (ctx)
|
|
ctx->X448SharedSecretCb = cb;
|
|
}
|
|
void wolfSSL_SetX448SharedSecretCtx(WOLFSSL* ssl, void *ctx)
|
|
{
|
|
if (ssl)
|
|
ssl->X448SharedSecretCtx = ctx;
|
|
}
|
|
void* wolfSSL_GetX448SharedSecretCtx(WOLFSSL* ssl)
|
|
{
|
|
if (ssl)
|
|
return ssl->X448SharedSecretCtx;
|
|
|
|
return NULL;
|
|
}
|
|
#endif /* HAVE_CURVE448 */
|
|
|
|
#ifndef NO_RSA
|
|
void wolfSSL_CTX_SetRsaSignCb(WOLFSSL_CTX* ctx, CallbackRsaSign cb)
|
|
{
|
|
if (ctx)
|
|
ctx->RsaSignCb = cb;
|
|
}
|
|
void wolfSSL_CTX_SetRsaSignCheckCb(WOLFSSL_CTX* ctx, CallbackRsaVerify cb)
|
|
{
|
|
if (ctx)
|
|
ctx->RsaSignCheckCb = cb;
|
|
}
|
|
void wolfSSL_SetRsaSignCtx(WOLFSSL* ssl, void *ctx)
|
|
{
|
|
if (ssl)
|
|
ssl->RsaSignCtx = ctx;
|
|
}
|
|
void* wolfSSL_GetRsaSignCtx(WOLFSSL* ssl)
|
|
{
|
|
if (ssl)
|
|
return ssl->RsaSignCtx;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
void wolfSSL_CTX_SetRsaVerifyCb(WOLFSSL_CTX* ctx, CallbackRsaVerify cb)
|
|
{
|
|
if (ctx)
|
|
ctx->RsaVerifyCb = cb;
|
|
}
|
|
void wolfSSL_SetRsaVerifyCtx(WOLFSSL* ssl, void *ctx)
|
|
{
|
|
if (ssl)
|
|
ssl->RsaVerifyCtx = ctx;
|
|
}
|
|
void* wolfSSL_GetRsaVerifyCtx(WOLFSSL* ssl)
|
|
{
|
|
if (ssl)
|
|
return ssl->RsaVerifyCtx;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
#ifdef WC_RSA_PSS
|
|
void wolfSSL_CTX_SetRsaPssSignCb(WOLFSSL_CTX* ctx, CallbackRsaPssSign cb)
|
|
{
|
|
if (ctx)
|
|
ctx->RsaPssSignCb = cb;
|
|
}
|
|
void wolfSSL_CTX_SetRsaPssSignCheckCb(WOLFSSL_CTX* ctx, CallbackRsaPssVerify cb)
|
|
{
|
|
if (ctx)
|
|
ctx->RsaPssSignCheckCb = cb;
|
|
}
|
|
void wolfSSL_SetRsaPssSignCtx(WOLFSSL* ssl, void *ctx)
|
|
{
|
|
if (ssl)
|
|
ssl->RsaPssSignCtx = ctx;
|
|
}
|
|
void* wolfSSL_GetRsaPssSignCtx(WOLFSSL* ssl)
|
|
{
|
|
if (ssl)
|
|
return ssl->RsaPssSignCtx;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
void wolfSSL_CTX_SetRsaPssVerifyCb(WOLFSSL_CTX* ctx, CallbackRsaPssVerify cb)
|
|
{
|
|
if (ctx)
|
|
ctx->RsaPssVerifyCb = cb;
|
|
}
|
|
void wolfSSL_SetRsaPssVerifyCtx(WOLFSSL* ssl, void *ctx)
|
|
{
|
|
if (ssl)
|
|
ssl->RsaPssVerifyCtx = ctx;
|
|
}
|
|
void* wolfSSL_GetRsaPssVerifyCtx(WOLFSSL* ssl)
|
|
{
|
|
if (ssl)
|
|
return ssl->RsaPssVerifyCtx;
|
|
|
|
return NULL;
|
|
}
|
|
#endif /* WC_RSA_PSS */
|
|
|
|
void wolfSSL_CTX_SetRsaEncCb(WOLFSSL_CTX* ctx, CallbackRsaEnc cb)
|
|
{
|
|
if (ctx)
|
|
ctx->RsaEncCb = cb;
|
|
}
|
|
void wolfSSL_SetRsaEncCtx(WOLFSSL* ssl, void *ctx)
|
|
{
|
|
if (ssl)
|
|
ssl->RsaEncCtx = ctx;
|
|
}
|
|
void* wolfSSL_GetRsaEncCtx(WOLFSSL* ssl)
|
|
{
|
|
if (ssl)
|
|
return ssl->RsaEncCtx;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
void wolfSSL_CTX_SetRsaDecCb(WOLFSSL_CTX* ctx, CallbackRsaDec cb)
|
|
{
|
|
if (ctx)
|
|
ctx->RsaDecCb = cb;
|
|
}
|
|
void wolfSSL_SetRsaDecCtx(WOLFSSL* ssl, void *ctx)
|
|
{
|
|
if (ssl)
|
|
ssl->RsaDecCtx = ctx;
|
|
}
|
|
void* wolfSSL_GetRsaDecCtx(WOLFSSL* ssl)
|
|
{
|
|
if (ssl)
|
|
return ssl->RsaDecCtx;
|
|
|
|
return NULL;
|
|
}
|
|
#endif /* NO_RSA */
|
|
|
|
/* callback for premaster secret generation */
|
|
void wolfSSL_CTX_SetGenPreMasterCb(WOLFSSL_CTX* ctx, CallbackGenPreMaster cb)
|
|
{
|
|
if (ctx)
|
|
ctx->GenPreMasterCb = cb;
|
|
}
|
|
/* Set premaster secret generation callback context */
|
|
void wolfSSL_SetGenPreMasterCtx(WOLFSSL* ssl, void *ctx)
|
|
{
|
|
if (ssl)
|
|
ssl->GenPreMasterCtx = ctx;
|
|
}
|
|
/* Get premaster secret generation callback context */
|
|
void* wolfSSL_GetGenPreMasterCtx(WOLFSSL* ssl)
|
|
{
|
|
if (ssl)
|
|
return ssl->GenPreMasterCtx;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/* callback for master secret generation */
|
|
void wolfSSL_CTX_SetGenMasterSecretCb(WOLFSSL_CTX* ctx, CallbackGenMasterSecret cb)
|
|
{
|
|
if (ctx)
|
|
ctx->GenMasterCb = cb;
|
|
}
|
|
/* Set master secret generation callback context */
|
|
void wolfSSL_SetGenMasterSecretCtx(WOLFSSL* ssl, void *ctx)
|
|
{
|
|
if (ssl)
|
|
ssl->GenMasterCtx = ctx;
|
|
}
|
|
/* Get master secret generation callback context */
|
|
void* wolfSSL_GetGenMasterSecretCtx(WOLFSSL* ssl)
|
|
{
|
|
if (ssl)
|
|
return ssl->GenMasterCtx;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/* callback for session key generation */
|
|
void wolfSSL_CTX_SetGenSessionKeyCb(WOLFSSL_CTX* ctx, CallbackGenSessionKey cb)
|
|
{
|
|
if (ctx)
|
|
ctx->GenSessionKeyCb = cb;
|
|
}
|
|
/* Set session key generation callback context */
|
|
void wolfSSL_SetGenSessionKeyCtx(WOLFSSL* ssl, void *ctx)
|
|
{
|
|
if (ssl)
|
|
ssl->GenSessionKeyCtx = ctx;
|
|
}
|
|
/* Get session key generation callback context */
|
|
void* wolfSSL_GetGenSessionKeyCtx(WOLFSSL* ssl)
|
|
{
|
|
if (ssl)
|
|
return ssl->GenSessionKeyCtx;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/* callback for setting encryption keys */
|
|
void wolfSSL_CTX_SetEncryptKeysCb(WOLFSSL_CTX* ctx, CallbackEncryptKeys cb)
|
|
{
|
|
if (ctx)
|
|
ctx->EncryptKeysCb = cb;
|
|
}
|
|
/* Set encryption keys callback context */
|
|
void wolfSSL_SetEncryptKeysCtx(WOLFSSL* ssl, void *ctx)
|
|
{
|
|
if (ssl)
|
|
ssl->EncryptKeysCtx = ctx;
|
|
}
|
|
/* Get encryption keys callback context */
|
|
void* wolfSSL_GetEncryptKeysCtx(WOLFSSL* ssl)
|
|
{
|
|
if (ssl)
|
|
return ssl->EncryptKeysCtx;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/* callback for Tls finished */
|
|
/* the callback can be used to build TLS Finished message if enabled */
|
|
void wolfSSL_CTX_SetTlsFinishedCb(WOLFSSL_CTX* ctx, CallbackTlsFinished cb)
|
|
{
|
|
if (ctx)
|
|
ctx->TlsFinishedCb = cb;
|
|
}
|
|
/* Set Tls finished callback context */
|
|
void wolfSSL_SetTlsFinishedCtx(WOLFSSL* ssl, void *ctx)
|
|
{
|
|
if (ssl)
|
|
ssl->TlsFinishedCtx = ctx;
|
|
}
|
|
/* Get Tls finished callback context */
|
|
void* wolfSSL_GetTlsFinishedCtx(WOLFSSL* ssl)
|
|
{
|
|
if (ssl)
|
|
return ssl->TlsFinishedCtx;
|
|
|
|
return NULL;
|
|
}
|
|
#if !defined(WOLFSSL_NO_TLS12) && !defined(WOLFSSL_AEAD_ONLY)
|
|
/* callback for verify data */
|
|
void wolfSSL_CTX_SetVerifyMacCb(WOLFSSL_CTX* ctx, CallbackVerifyMac cb)
|
|
{
|
|
if (ctx)
|
|
ctx->VerifyMacCb = cb;
|
|
}
|
|
|
|
/* Set set keys callback context */
|
|
void wolfSSL_SetVerifyMacCtx(WOLFSSL* ssl, void *ctx)
|
|
{
|
|
if (ssl)
|
|
ssl->VerifyMacCtx = ctx;
|
|
}
|
|
/* Get set keys callback context */
|
|
void* wolfSSL_GetVerifyMacCtx(WOLFSSL* ssl)
|
|
{
|
|
if (ssl)
|
|
return ssl->VerifyMacCtx;
|
|
|
|
return NULL;
|
|
}
|
|
#endif /* !WOLFSSL_NO_TLS12 && !WOLFSSL_AEAD_ONLY */
|
|
|
|
void wolfSSL_CTX_SetHKDFExpandLabelCb(WOLFSSL_CTX* ctx,
|
|
CallbackHKDFExpandLabel cb)
|
|
{
|
|
if (ctx)
|
|
ctx->HKDFExpandLabelCb = cb;
|
|
}
|
|
#ifdef WOLFSSL_PUBLIC_ASN
|
|
void wolfSSL_CTX_SetProcessPeerCertCb(WOLFSSL_CTX* ctx,
|
|
CallbackProcessPeerCert cb)
|
|
{
|
|
if (ctx)
|
|
ctx->ProcessPeerCertCb = cb;
|
|
}
|
|
#endif /* WOLFSSL_PUBLIC_ASN */
|
|
void wolfSSL_CTX_SetProcessServerSigKexCb(WOLFSSL_CTX* ctx,
|
|
CallbackProcessServerSigKex cb)
|
|
{
|
|
if (ctx)
|
|
ctx->ProcessServerSigKexCb = cb;
|
|
}
|
|
void wolfSSL_CTX_SetPerformTlsRecordProcessingCb(WOLFSSL_CTX* ctx,
|
|
CallbackPerformTlsRecordProcessing cb)
|
|
{
|
|
if (ctx)
|
|
ctx->PerformTlsRecordProcessingCb = cb;
|
|
}
|
|
#endif /* HAVE_PK_CALLBACKS */
|
|
#endif /* NO_CERTS */
|
|
|
|
#if defined(HAVE_PK_CALLBACKS) && !defined(NO_DH)
|
|
void wolfSSL_CTX_SetDhGenerateKeyPair(WOLFSSL_CTX* ctx,
|
|
CallbackDhGenerateKeyPair cb) {
|
|
if (ctx)
|
|
ctx->DhGenerateKeyPairCb = cb;
|
|
}
|
|
void wolfSSL_CTX_SetDhAgreeCb(WOLFSSL_CTX* ctx, CallbackDhAgree cb)
|
|
{
|
|
if (ctx)
|
|
ctx->DhAgreeCb = cb;
|
|
}
|
|
void wolfSSL_SetDhAgreeCtx(WOLFSSL* ssl, void *ctx)
|
|
{
|
|
if (ssl)
|
|
ssl->DhAgreeCtx = ctx;
|
|
}
|
|
void* wolfSSL_GetDhAgreeCtx(WOLFSSL* ssl)
|
|
{
|
|
if (ssl)
|
|
return ssl->DhAgreeCtx;
|
|
|
|
return NULL;
|
|
}
|
|
#endif /* HAVE_PK_CALLBACKS && !NO_DH */
|
|
|
|
#if defined(HAVE_PK_CALLBACKS) && defined(HAVE_HKDF)
|
|
|
|
void wolfSSL_CTX_SetHKDFExtractCb(WOLFSSL_CTX* ctx, CallbackHKDFExtract cb)
|
|
{
|
|
if (ctx)
|
|
ctx->HkdfExtractCb = cb;
|
|
}
|
|
|
|
void wolfSSL_SetHKDFExtractCtx(WOLFSSL* ssl, void *ctx)
|
|
{
|
|
if (ssl)
|
|
ssl->HkdfExtractCtx = ctx;
|
|
}
|
|
|
|
void* wolfSSL_GetHKDFExtractCtx(WOLFSSL* ssl)
|
|
{
|
|
if (ssl)
|
|
return ssl->HkdfExtractCtx;
|
|
|
|
return NULL;
|
|
}
|
|
#endif /* HAVE_PK_CALLBACKS && HAVE_HKDF */
|
|
|
|
#ifdef WOLFSSL_HAVE_WOLFSCEP
|
|
/* Used by autoconf to see if wolfSCEP is available */
|
|
void wolfSSL_wolfSCEP(void) {}
|
|
#endif
|
|
|
|
|
|
#ifdef WOLFSSL_HAVE_CERT_SERVICE
|
|
/* Used by autoconf to see if cert service is available */
|
|
void wolfSSL_cert_service(void) {}
|
|
#endif
|
|
|
|
#if (defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL)) && \
|
|
!defined(WOLFCRYPT_ONLY)
|
|
#ifndef NO_CERTS
|
|
|
|
#if defined(OPENSSL_ALL) || defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL)
|
|
|
|
#if defined(OPENSSL_EXTRA) || defined(OPENSSL_ALL)
|
|
#if !defined(NO_FILESYSTEM)
|
|
WOLFSSL_EVP_PKEY* wolfSSL_PEM_read_PrivateKey(XFILE fp,
|
|
WOLFSSL_EVP_PKEY **key, wc_pem_password_cb *cb, void *pass)
|
|
{
|
|
WOLFSSL_EVP_PKEY* pkey = NULL;
|
|
DerBuffer* der = NULL;
|
|
int keyFormat = 0;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_PEM_read_PrivateKey");
|
|
|
|
if (pem_read_file_key(fp, cb, pass, PRIVATEKEY_TYPE, &keyFormat,
|
|
&der) >= 0) {
|
|
const unsigned char* ptr = der->buffer;
|
|
int type = -1;
|
|
|
|
if (keyFormat) {
|
|
/* keyFormat is Key_Sum enum */
|
|
if (keyFormat == RSAk)
|
|
type = EVP_PKEY_RSA;
|
|
else if (keyFormat == ECDSAk)
|
|
type = EVP_PKEY_EC;
|
|
else if (keyFormat == DSAk)
|
|
type = EVP_PKEY_DSA;
|
|
else if (keyFormat == DHk)
|
|
type = EVP_PKEY_DH;
|
|
}
|
|
else {
|
|
/* Default to RSA if format is not set */
|
|
type = EVP_PKEY_RSA;
|
|
}
|
|
|
|
/* handle case where reuse is attempted */
|
|
if (key != NULL && *key != NULL)
|
|
pkey = *key;
|
|
|
|
wolfSSL_d2i_PrivateKey(type, &pkey, &ptr, der->length);
|
|
if (pkey == NULL) {
|
|
WOLFSSL_MSG("Error loading DER buffer into WOLFSSL_EVP_PKEY");
|
|
}
|
|
}
|
|
|
|
FreeDer(&der);
|
|
|
|
if (key != NULL && pkey != NULL)
|
|
*key = pkey;
|
|
|
|
WOLFSSL_LEAVE("wolfSSL_PEM_read_PrivateKey", 0);
|
|
|
|
return pkey;
|
|
}
|
|
#endif
|
|
#endif
|
|
|
|
#endif /* OPENSSL_ALL || OPENSSL_EXTRA || OPENSSL_EXTRA_X509_SMALL*/
|
|
|
|
#if defined(OPENSSL_EXTRA) || defined(OPENSSL_ALL)
|
|
|
|
#define PEM_BEGIN "-----BEGIN "
|
|
#define PEM_BEGIN_SZ 11
|
|
#define PEM_END "-----END "
|
|
#define PEM_END_SZ 9
|
|
#define PEM_HDR_FIN "-----"
|
|
#define PEM_HDR_FIN_SZ 5
|
|
#define PEM_HDR_FIN_EOL_NEWLINE "-----\n"
|
|
#define PEM_HDR_FIN_EOL_NULL_TERM "-----\0"
|
|
#define PEM_HDR_FIN_EOL_SZ 6
|
|
|
|
#ifndef NO_BIO
|
|
|
|
int wolfSSL_PEM_read_bio(WOLFSSL_BIO* bio, char **name, char **header,
|
|
unsigned char **data, long *len)
|
|
{
|
|
int ret = WOLFSSL_SUCCESS;
|
|
char pem[256];
|
|
int pemLen;
|
|
char* p;
|
|
char* nameStr = NULL;
|
|
int nameLen = 0;
|
|
char* headerStr = NULL;
|
|
int headerFound = 0;
|
|
unsigned char* der = NULL;
|
|
word32 derLen = 0;
|
|
|
|
if (bio == NULL || name == NULL || header == NULL || data == NULL ||
|
|
len == NULL) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
/* Find header line. */
|
|
pem[sizeof(pem) - 1] = '\0';
|
|
while ((pemLen = wolfSSL_BIO_gets(bio, pem, sizeof(pem) - 1)) > 0) {
|
|
if (XSTRNCMP(pem, PEM_BEGIN, PEM_BEGIN_SZ) == 0)
|
|
break;
|
|
}
|
|
if (pemLen <= 0)
|
|
ret = WOLFSSL_FAILURE;
|
|
/* Have a header line. */
|
|
if (ret == WOLFSSL_SUCCESS) {
|
|
while (pem[pemLen - 1] == '\r' || pem[pemLen - 1] == '\n')
|
|
pemLen--;
|
|
pem[pemLen] = '\0';
|
|
if (XSTRNCMP(pem + pemLen - PEM_HDR_FIN_SZ, PEM_HDR_FIN,
|
|
PEM_HDR_FIN_SZ) != 0) {
|
|
ret = WOLFSSL_FAILURE;
|
|
}
|
|
}
|
|
|
|
/* Get out name. */
|
|
if (ret == WOLFSSL_SUCCESS) {
|
|
nameLen = pemLen - PEM_BEGIN_SZ - PEM_HDR_FIN_SZ;
|
|
nameStr = (char*)XMALLOC(nameLen + 1, NULL,
|
|
DYNAMIC_TYPE_TMP_BUFFER);
|
|
if (nameStr == NULL)
|
|
ret = WOLFSSL_FAILURE;
|
|
}
|
|
if (ret == WOLFSSL_SUCCESS) {
|
|
int headerLen;
|
|
|
|
XSTRNCPY(nameStr, pem + PEM_BEGIN_SZ, nameLen);
|
|
nameStr[nameLen] = '\0';
|
|
|
|
/* Get header of PEM - encryption header. */
|
|
headerLen = 0;
|
|
while ((pemLen = wolfSSL_BIO_gets(bio, pem, sizeof(pem) - 1)) > 0) {
|
|
while (pemLen > 0 && (pem[pemLen - 1] == '\r' ||
|
|
pem[pemLen - 1] == '\n')) {
|
|
pemLen--;
|
|
}
|
|
pem[pemLen++] = '\n';
|
|
pem[pemLen] = '\0';
|
|
|
|
/* Header separator is a blank line. */
|
|
if (pem[0] == '\n') {
|
|
headerFound = 1;
|
|
break;
|
|
}
|
|
|
|
/* Didn't find a blank line - no header. */
|
|
if (XSTRNCMP(pem, PEM_END, PEM_END_SZ) == 0) {
|
|
der = (unsigned char*)headerStr;
|
|
derLen = headerLen;
|
|
/* Empty header - empty string. */
|
|
headerStr = (char*)XMALLOC(1, NULL,
|
|
DYNAMIC_TYPE_TMP_BUFFER);
|
|
if (headerStr == NULL)
|
|
ret = WOLFSSL_FAILURE;
|
|
else
|
|
headerStr[0] = '\0';
|
|
break;
|
|
}
|
|
|
|
p = (char*)XREALLOC(headerStr, headerLen + pemLen + 1, NULL,
|
|
DYNAMIC_TYPE_TMP_BUFFER);
|
|
if (p == NULL) {
|
|
ret = WOLFSSL_FAILURE;
|
|
break;
|
|
}
|
|
|
|
headerStr = p;
|
|
XMEMCPY(headerStr + headerLen, pem, pemLen + 1);
|
|
headerLen += pemLen;
|
|
}
|
|
if (pemLen <= 0)
|
|
ret = WOLFSSL_FAILURE;
|
|
}
|
|
|
|
/* Get body of PEM - if there was a header */
|
|
if (ret == WOLFSSL_SUCCESS && headerFound) {
|
|
derLen = 0;
|
|
while ((pemLen = wolfSSL_BIO_gets(bio, pem, sizeof(pem) - 1)) > 0) {
|
|
while (pemLen > 0 && (pem[pemLen - 1] == '\r' ||
|
|
pem[pemLen - 1] == '\n')) {
|
|
pemLen--;
|
|
}
|
|
pem[pemLen++] = '\n';
|
|
pem[pemLen] = '\0';
|
|
|
|
if (XSTRNCMP(pem, PEM_END, PEM_END_SZ) == 0)
|
|
break;
|
|
|
|
p = (char*)XREALLOC(der, derLen + pemLen + 1, NULL,
|
|
DYNAMIC_TYPE_TMP_BUFFER);
|
|
if (p == NULL) {
|
|
ret = WOLFSSL_FAILURE;
|
|
break;
|
|
}
|
|
|
|
der = (unsigned char*)p;
|
|
XMEMCPY(der + derLen, pem, pemLen + 1);
|
|
derLen += pemLen;
|
|
}
|
|
if (pemLen <= 0)
|
|
ret = WOLFSSL_FAILURE;
|
|
}
|
|
|
|
/* Check trailer. */
|
|
if (ret == WOLFSSL_SUCCESS) {
|
|
if (XSTRNCMP(pem + PEM_END_SZ, nameStr, nameLen) != 0)
|
|
ret = WOLFSSL_FAILURE;
|
|
}
|
|
if (ret == WOLFSSL_SUCCESS) {
|
|
if (XSTRNCMP(pem + PEM_END_SZ + nameLen,
|
|
PEM_HDR_FIN_EOL_NEWLINE,
|
|
PEM_HDR_FIN_EOL_SZ) != 0 &&
|
|
XSTRNCMP(pem + PEM_END_SZ + nameLen,
|
|
PEM_HDR_FIN_EOL_NULL_TERM,
|
|
PEM_HDR_FIN_EOL_SZ) != 0) {
|
|
ret = WOLFSSL_FAILURE;
|
|
}
|
|
}
|
|
|
|
/* Base64 decode body. */
|
|
if (ret == WOLFSSL_SUCCESS) {
|
|
if (Base64_Decode(der, derLen, der, &derLen) != 0)
|
|
ret = WOLFSSL_FAILURE;
|
|
}
|
|
|
|
if (ret == WOLFSSL_SUCCESS) {
|
|
*name = nameStr;
|
|
*header = headerStr;
|
|
*data = der;
|
|
*len = derLen;
|
|
nameStr = NULL;
|
|
headerStr = NULL;
|
|
der = NULL;
|
|
}
|
|
|
|
if (nameStr != NULL)
|
|
XFREE(nameStr, NULL, DYNAMIC_TYPE_TMP_BUFFER);
|
|
if (headerStr != NULL)
|
|
XFREE(headerStr, NULL, DYNAMIC_TYPE_TMP_BUFFER);
|
|
if (der != NULL)
|
|
XFREE(der, NULL, DYNAMIC_TYPE_TMP_BUFFER);
|
|
|
|
return ret;
|
|
}
|
|
|
|
int wolfSSL_PEM_write_bio(WOLFSSL_BIO* bio, const char *name,
|
|
const char *header, const unsigned char *data,
|
|
long len)
|
|
{
|
|
int err = 0;
|
|
int outSz = 0;
|
|
int nameLen;
|
|
int headerLen;
|
|
byte* pem = NULL;
|
|
word32 pemLen;
|
|
word32 derLen = (word32)len;
|
|
|
|
if (bio == NULL || name == NULL || header == NULL || data == NULL)
|
|
return 0;
|
|
|
|
nameLen = (int)XSTRLEN(name);
|
|
headerLen = (int)XSTRLEN(header);
|
|
|
|
pemLen = (derLen + 2) / 3 * 4;
|
|
pemLen += (pemLen + 63) / 64;
|
|
|
|
pem = (byte*)XMALLOC(pemLen, NULL, DYNAMIC_TYPE_TMP_BUFFER);
|
|
err = pem == NULL;
|
|
if (!err)
|
|
err = Base64_Encode(data, derLen, pem, &pemLen) != 0;
|
|
|
|
if (!err) {
|
|
err = wolfSSL_BIO_write(bio, PEM_BEGIN, PEM_BEGIN_SZ) !=
|
|
(int)PEM_BEGIN_SZ;
|
|
}
|
|
if (!err)
|
|
err = wolfSSL_BIO_write(bio, name, nameLen) != nameLen;
|
|
if (!err) {
|
|
err = wolfSSL_BIO_write(bio, PEM_HDR_FIN_EOL_NEWLINE,
|
|
PEM_HDR_FIN_EOL_SZ) != (int)PEM_HDR_FIN_EOL_SZ;
|
|
}
|
|
if (!err && headerLen > 0) {
|
|
err = wolfSSL_BIO_write(bio, header, headerLen) != headerLen;
|
|
/* Blank line after a header and before body. */
|
|
if (!err)
|
|
err = wolfSSL_BIO_write(bio, "\n", 1) != 1;
|
|
headerLen++;
|
|
}
|
|
if (!err)
|
|
err = wolfSSL_BIO_write(bio, pem, pemLen) != (int)pemLen;
|
|
if (!err)
|
|
err = wolfSSL_BIO_write(bio, PEM_END, PEM_END_SZ) !=
|
|
(int)PEM_END_SZ;
|
|
if (!err)
|
|
err = wolfSSL_BIO_write(bio, name, nameLen) != nameLen;
|
|
if (!err) {
|
|
err = wolfSSL_BIO_write(bio, PEM_HDR_FIN_EOL_NEWLINE,
|
|
PEM_HDR_FIN_EOL_SZ) != (int)PEM_HDR_FIN_EOL_SZ;
|
|
}
|
|
|
|
if (!err) {
|
|
outSz = PEM_BEGIN_SZ + nameLen + PEM_HDR_FIN_EOL_SZ + headerLen +
|
|
pemLen + PEM_END_SZ + nameLen + PEM_HDR_FIN_EOL_SZ;
|
|
}
|
|
|
|
if (pem != NULL)
|
|
XFREE(pem, NULL, DYNAMIC_TYPE_TMP_BUFFER);
|
|
|
|
return outSz;
|
|
}
|
|
|
|
#if !defined(NO_FILESYSTEM)
|
|
int wolfSSL_PEM_read(XFILE fp, char **name, char **header,
|
|
unsigned char **data, long *len)
|
|
{
|
|
int ret;
|
|
WOLFSSL_BIO* bio;
|
|
|
|
if (name == NULL || header == NULL || data == NULL || len == NULL)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
bio = wolfSSL_BIO_new_fp(fp, BIO_NOCLOSE);
|
|
if (bio == NULL)
|
|
return 0;
|
|
|
|
ret = wolfSSL_PEM_read_bio(bio, name, header, data, len);
|
|
|
|
if (bio != NULL)
|
|
wolfSSL_BIO_free(bio);
|
|
|
|
return ret;
|
|
}
|
|
|
|
int wolfSSL_PEM_write(XFILE fp, const char *name, const char *header,
|
|
const unsigned char *data, long len)
|
|
{
|
|
int ret;
|
|
WOLFSSL_BIO* bio;
|
|
|
|
if (name == NULL || header == NULL || data == NULL)
|
|
return 0;
|
|
|
|
bio = wolfSSL_BIO_new_fp(fp, BIO_NOCLOSE);
|
|
if (bio == NULL)
|
|
return 0;
|
|
|
|
ret = wolfSSL_PEM_write_bio(bio, name, header, data, len);
|
|
|
|
if (bio != NULL)
|
|
wolfSSL_BIO_free(bio);
|
|
|
|
return ret;
|
|
}
|
|
#endif
|
|
#endif /* !NO_BIO */
|
|
|
|
int wolfSSL_PEM_get_EVP_CIPHER_INFO(const char* header,
|
|
EncryptedInfo* cipher)
|
|
{
|
|
if (header == NULL || cipher == NULL)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
XMEMSET(cipher, 0, sizeof(*cipher));
|
|
|
|
if (wc_EncryptedInfoParse(cipher, &header, XSTRLEN(header)) != 0)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
int wolfSSL_PEM_do_header(EncryptedInfo* cipher, unsigned char* data,
|
|
long* len, wc_pem_password_cb* callback,
|
|
void* ctx)
|
|
{
|
|
int ret = WOLFSSL_SUCCESS;
|
|
char password[NAME_SZ];
|
|
int passwordSz;
|
|
|
|
if (cipher == NULL || data == NULL || len == NULL || callback == NULL)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
passwordSz = callback(password, sizeof(password), PEM_PASS_READ, ctx);
|
|
if (passwordSz < 0)
|
|
ret = WOLFSSL_FAILURE;
|
|
|
|
if (ret == WOLFSSL_SUCCESS) {
|
|
if (wc_BufferKeyDecrypt(cipher, data, (word32)*len, (byte*)password,
|
|
passwordSz, WC_MD5) != 0) {
|
|
ret = WOLFSSL_FAILURE;
|
|
}
|
|
}
|
|
|
|
if (passwordSz > 0)
|
|
XMEMSET(password, 0, passwordSz);
|
|
|
|
return ret;
|
|
}
|
|
|
|
#ifndef NO_BIO
|
|
/*
|
|
* bp : bio to read X509 from
|
|
* x : x509 to write to
|
|
* cb : password call back for reading PEM
|
|
* u : password
|
|
* _AUX is for working with a trusted X509 certificate
|
|
*/
|
|
WOLFSSL_X509 *wolfSSL_PEM_read_bio_X509_AUX(WOLFSSL_BIO *bp,
|
|
WOLFSSL_X509 **x, wc_pem_password_cb *cb,
|
|
void *u)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_PEM_read_bio_X509");
|
|
|
|
/* AUX info is; trusted/rejected uses, friendly name, private key id,
|
|
* and potentially a stack of "other" info. wolfSSL does not store
|
|
* friendly name or private key id yet in WOLFSSL_X509 for human
|
|
* readability and does not support extra trusted/rejected uses for
|
|
* root CA. */
|
|
return wolfSSL_PEM_read_bio_X509(bp, x, cb, u);
|
|
}
|
|
#endif /* !NO_BIO */
|
|
|
|
|
|
#endif /* OPENSSL_EXTRA || OPENSSL_ALL */
|
|
#endif /* !NO_CERTS */
|
|
|
|
/* NID variables are dependent on compatibility header files currently
|
|
*
|
|
* returns a pointer to a new WOLFSSL_ASN1_OBJECT struct on success and NULL
|
|
* on fail
|
|
*/
|
|
|
|
WOLFSSL_ASN1_OBJECT* wolfSSL_OBJ_nid2obj(int id)
|
|
{
|
|
return wolfSSL_OBJ_nid2obj_ex(id, NULL);
|
|
}
|
|
|
|
|
|
WOLFSSL_LOCAL WOLFSSL_ASN1_OBJECT* wolfSSL_OBJ_nid2obj_ex(int id,
|
|
WOLFSSL_ASN1_OBJECT* arg_obj)
|
|
{
|
|
word32 oidSz = 0;
|
|
int nid = 0;
|
|
const byte* oid;
|
|
word32 type = 0;
|
|
WOLFSSL_ASN1_OBJECT* obj = arg_obj;
|
|
byte objBuf[MAX_OID_SZ + MAX_LENGTH_SZ + 1]; /* +1 for object tag */
|
|
word32 objSz = 0;
|
|
const char* sName = NULL;
|
|
int i;
|
|
|
|
#ifdef WOLFSSL_DEBUG_OPENSSL
|
|
WOLFSSL_ENTER("wolfSSL_OBJ_nid2obj");
|
|
#endif
|
|
|
|
for (i = 0; i < (int)WOLFSSL_OBJECT_INFO_SZ; i++) {
|
|
if (wolfssl_object_info[i].nid == id) {
|
|
nid = id;
|
|
id = wolfssl_object_info[i].id;
|
|
sName = wolfssl_object_info[i].sName;
|
|
type = wolfssl_object_info[i].type;
|
|
break;
|
|
}
|
|
}
|
|
if (i == (int)WOLFSSL_OBJECT_INFO_SZ) {
|
|
WOLFSSL_MSG("NID not in table");
|
|
#ifdef WOLFSSL_QT
|
|
sName = NULL;
|
|
type = id;
|
|
#else
|
|
return NULL;
|
|
#endif
|
|
}
|
|
|
|
#ifdef HAVE_ECC
|
|
if (type == 0 && wc_ecc_get_oid(id, &oid, &oidSz) > 0) {
|
|
type = oidCurveType;
|
|
}
|
|
#endif /* HAVE_ECC */
|
|
|
|
if (sName != NULL) {
|
|
if (XSTRLEN(sName) > WOLFSSL_MAX_SNAME - 1) {
|
|
WOLFSSL_MSG("Attempted short name is too large");
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
oid = OidFromId(id, type, &oidSz);
|
|
|
|
/* set object ID to buffer */
|
|
if (obj == NULL){
|
|
obj = wolfSSL_ASN1_OBJECT_new();
|
|
if (obj == NULL) {
|
|
WOLFSSL_MSG("Issue creating WOLFSSL_ASN1_OBJECT struct");
|
|
return NULL;
|
|
}
|
|
}
|
|
obj->nid = nid;
|
|
obj->type = id;
|
|
obj->grp = type;
|
|
|
|
obj->sName[0] = '\0';
|
|
if (sName != NULL) {
|
|
XMEMCPY(obj->sName, (char*)sName, XSTRLEN((char*)sName));
|
|
}
|
|
|
|
objBuf[0] = ASN_OBJECT_ID; objSz++;
|
|
objSz += SetLength(oidSz, objBuf + 1);
|
|
if (oidSz) {
|
|
XMEMCPY(objBuf + objSz, oid, oidSz);
|
|
objSz += oidSz;
|
|
}
|
|
|
|
if (obj->objSz == 0 || objSz != obj->objSz) {
|
|
obj->objSz = objSz;
|
|
if(((obj->dynamic & WOLFSSL_ASN1_DYNAMIC_DATA) != 0) ||
|
|
(obj->obj == NULL)) {
|
|
if (obj->obj != NULL)
|
|
XFREE((byte*)obj->obj, NULL, DYNAMIC_TYPE_ASN1);
|
|
obj->obj = (byte*)XMALLOC(obj->objSz, NULL, DYNAMIC_TYPE_ASN1);
|
|
if (obj->obj == NULL) {
|
|
wolfSSL_ASN1_OBJECT_free(obj);
|
|
return NULL;
|
|
}
|
|
obj->dynamic |= WOLFSSL_ASN1_DYNAMIC_DATA ;
|
|
}
|
|
else {
|
|
obj->dynamic &= ~WOLFSSL_ASN1_DYNAMIC_DATA ;
|
|
}
|
|
}
|
|
XMEMCPY((byte*)obj->obj, objBuf, obj->objSz);
|
|
|
|
(void)type;
|
|
|
|
return obj;
|
|
}
|
|
|
|
static const char* oid_translate_num_to_str(const char* oid)
|
|
{
|
|
const struct oid_dict {
|
|
const char* num;
|
|
const char* desc;
|
|
} oid_dict[] = {
|
|
{ "2.5.29.37.0", "Any Extended Key Usage" },
|
|
{ "1.3.6.1.5.5.7.3.1", "TLS Web Server Authentication" },
|
|
{ "1.3.6.1.5.5.7.3.2", "TLS Web Client Authentication" },
|
|
{ "1.3.6.1.5.5.7.3.3", "Code Signing" },
|
|
{ "1.3.6.1.5.5.7.3.4", "E-mail Protection" },
|
|
{ "1.3.6.1.5.5.7.3.8", "Time Stamping" },
|
|
{ "1.3.6.1.5.5.7.3.9", "OCSP Signing" },
|
|
{ NULL, NULL }
|
|
};
|
|
const struct oid_dict* idx;
|
|
|
|
for (idx = oid_dict; idx->num != NULL; idx++) {
|
|
if (!XSTRCMP(oid, idx->num)) {
|
|
return idx->desc;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
static int wolfssl_obj2txt_numeric(char *buf, int bufLen,
|
|
const WOLFSSL_ASN1_OBJECT *a)
|
|
{
|
|
int bufSz;
|
|
int length;
|
|
word32 idx = 0;
|
|
byte tag;
|
|
|
|
if (GetASNTag(a->obj, &idx, &tag, a->objSz) != 0) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
if (tag != ASN_OBJECT_ID) {
|
|
WOLFSSL_MSG("Bad ASN1 Object");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
if (GetLength((const byte*)a->obj, &idx, &length,
|
|
a->objSz) < 0 || length < 0) {
|
|
return ASN_PARSE_E;
|
|
}
|
|
|
|
if (bufLen < MAX_OID_STRING_SZ) {
|
|
bufSz = bufLen - 1;
|
|
}
|
|
else {
|
|
bufSz = MAX_OID_STRING_SZ;
|
|
}
|
|
|
|
if ((bufSz = DecodePolicyOID(buf, (word32)bufSz, a->obj + idx,
|
|
(word32)length)) <= 0) {
|
|
WOLFSSL_MSG("Error decoding OID");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
buf[bufSz] = '\0';
|
|
|
|
return bufSz;
|
|
}
|
|
|
|
/* If no_name is one then use numerical form, otherwise short name.
|
|
*
|
|
* Returns the buffer size on success, WOLFSSL_FAILURE on error
|
|
*/
|
|
int wolfSSL_OBJ_obj2txt(char *buf, int bufLen, const WOLFSSL_ASN1_OBJECT *a,
|
|
int no_name)
|
|
{
|
|
int bufSz;
|
|
const char* desc;
|
|
const char* name;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_OBJ_obj2txt");
|
|
|
|
if (buf == NULL || bufLen <= 1 || a == NULL) {
|
|
WOLFSSL_MSG("Bad input argument");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
if (no_name == 1) {
|
|
return wolfssl_obj2txt_numeric(buf, bufLen, a);
|
|
}
|
|
|
|
/* return long name unless using x509small, then return short name */
|
|
#if defined(OPENSSL_EXTRA_X509_SMALL) && !defined(OPENSSL_EXTRA)
|
|
name = a->sName;
|
|
#else
|
|
name = wolfSSL_OBJ_nid2ln(wolfSSL_OBJ_obj2nid(a));
|
|
#endif
|
|
|
|
if (name == NULL) {
|
|
WOLFSSL_MSG("Name not found");
|
|
bufSz = 0;
|
|
}
|
|
else if (XSTRLEN(name) + 1 < (word32)bufLen - 1) {
|
|
bufSz = (int)XSTRLEN(name);
|
|
}
|
|
else {
|
|
bufSz = bufLen - 1;
|
|
}
|
|
if (bufSz) {
|
|
XMEMCPY(buf, name, bufSz);
|
|
}
|
|
else if (a->type == GEN_DNS || a->type == GEN_EMAIL ||
|
|
a->type == GEN_URI) {
|
|
bufSz = (int)XSTRLEN((const char*)a->obj);
|
|
XMEMCPY(buf, a->obj, min(bufSz, bufLen));
|
|
}
|
|
else if ((bufSz = wolfssl_obj2txt_numeric(buf, bufLen, a)) > 0) {
|
|
if ((desc = oid_translate_num_to_str(buf))) {
|
|
bufSz = (int)XSTRLEN(desc);
|
|
bufSz = min(bufSz, bufLen - 1);
|
|
XMEMCPY(buf, desc, bufSz);
|
|
}
|
|
}
|
|
else {
|
|
bufSz = 0;
|
|
}
|
|
|
|
buf[bufSz] = '\0';
|
|
|
|
return bufSz;
|
|
}
|
|
#endif /* OPENSSL_EXTRA || OPENSSL_EXTRA_X509_SMALL */
|
|
|
|
#if defined(OPENSSL_EXTRA) || defined(HAVE_LIGHTY) || \
|
|
defined(WOLFSSL_MYSQL_COMPATIBLE) || defined(HAVE_STUNNEL) || \
|
|
defined(WOLFSSL_NGINX) || defined(HAVE_POCO_LIB) || \
|
|
defined(WOLFSSL_HAPROXY) || defined(WOLFSSL_WPAS_SMALL)
|
|
/* Returns the long name that corresponds with an ASN1_OBJECT nid value.
|
|
* n : NID value of ASN1_OBJECT to search */
|
|
const char* wolfSSL_OBJ_nid2ln(int n)
|
|
{
|
|
const WOLFSSL_ObjectInfo *obj_info = wolfssl_object_info;
|
|
size_t i;
|
|
WOLFSSL_ENTER("wolfSSL_OBJ_nid2ln");
|
|
for (i = 0; i < WOLFSSL_OBJECT_INFO_SZ; i++, obj_info++) {
|
|
if (obj_info->nid == n) {
|
|
return obj_info->lName;
|
|
}
|
|
}
|
|
WOLFSSL_MSG("NID not found in table");
|
|
return NULL;
|
|
}
|
|
#endif /* OPENSSL_EXTRA, HAVE_LIGHTY, WOLFSSL_MYSQL_COMPATIBLE, HAVE_STUNNEL,
|
|
WOLFSSL_NGINX, HAVE_POCO_LIB, WOLFSSL_HAPROXY, WOLFSSL_WPAS_SMALL */
|
|
|
|
#if defined(OPENSSL_EXTRA) || defined(HAVE_LIGHTY) || \
|
|
defined(WOLFSSL_MYSQL_COMPATIBLE) || defined(HAVE_STUNNEL) || \
|
|
defined(WOLFSSL_NGINX) || defined(HAVE_POCO_LIB) || \
|
|
defined(WOLFSSL_HAPROXY)
|
|
char wolfSSL_CTX_use_certificate(WOLFSSL_CTX *ctx, WOLFSSL_X509 *x)
|
|
{
|
|
int ret;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_CTX_use_certificate");
|
|
if (!ctx || !x || !x->derCert) {
|
|
WOLFSSL_MSG("Bad parameter");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
FreeDer(&ctx->certificate); /* Make sure previous is free'd */
|
|
ret = AllocDer(&ctx->certificate, x->derCert->length, CERT_TYPE,
|
|
ctx->heap);
|
|
if (ret != 0)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
XMEMCPY(ctx->certificate->buffer, x->derCert->buffer,
|
|
x->derCert->length);
|
|
#ifdef KEEP_OUR_CERT
|
|
if (ctx->ourCert != NULL && ctx->ownOurCert) {
|
|
wolfSSL_X509_free(ctx->ourCert);
|
|
}
|
|
#ifndef WOLFSSL_X509_STORE_CERTS
|
|
ctx->ourCert = x;
|
|
if (wolfSSL_X509_up_ref(x) != 1) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
#else
|
|
ctx->ourCert = wolfSSL_X509_d2i(NULL, x->derCert->buffer,x->derCert->length);
|
|
if(ctx->ourCert == NULL){
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
#endif
|
|
|
|
/* We own the cert because either we up its reference counter
|
|
* or we create our own copy of the cert object. */
|
|
ctx->ownOurCert = 1;
|
|
#endif
|
|
|
|
/* Update the available options with public keys. */
|
|
switch (x->pubKeyOID) {
|
|
#ifndef NO_RSA
|
|
#ifdef WC_RSA_PSS
|
|
case RSAPSSk:
|
|
#endif
|
|
case RSAk:
|
|
ctx->haveRSA = 1;
|
|
break;
|
|
#endif
|
|
#ifdef HAVE_ED25519
|
|
case ED25519k:
|
|
#endif
|
|
#ifdef HAVE_ED448
|
|
case ED448k:
|
|
#endif
|
|
case ECDSAk:
|
|
ctx->haveECC = 1;
|
|
#if defined(HAVE_ECC) || defined(HAVE_ED25519) || defined(HAVE_ED448)
|
|
ctx->pkCurveOID = x->pkCurveOID;
|
|
#endif
|
|
break;
|
|
}
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
static int PushCertToDerBuffer(DerBuffer** inOutDer, int weOwn,
|
|
byte* cert, word32 certSz, void* heap)
|
|
{
|
|
int ret;
|
|
DerBuffer* inChain = NULL;
|
|
DerBuffer* der = NULL;
|
|
word32 len = 0;
|
|
if (inOutDer == NULL)
|
|
return BAD_FUNC_ARG;
|
|
inChain = *inOutDer;
|
|
if (inChain != NULL)
|
|
len = inChain->length;
|
|
ret = AllocDer(&der, len + CERT_HEADER_SZ + certSz, CERT_TYPE,
|
|
heap);
|
|
if (ret != 0) {
|
|
WOLFSSL_MSG("AllocDer error");
|
|
return ret;
|
|
}
|
|
if (inChain != NULL)
|
|
XMEMCPY(der->buffer, inChain->buffer, len);
|
|
c32to24(certSz, der->buffer + len);
|
|
XMEMCPY(der->buffer + len + CERT_HEADER_SZ, cert, certSz);
|
|
if (weOwn)
|
|
FreeDer(inOutDer);
|
|
*inOutDer = der;
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
* wolfSSL_CTX_add1_chain_cert makes a copy of the cert so we free it
|
|
* on success
|
|
*/
|
|
int wolfSSL_CTX_add0_chain_cert(WOLFSSL_CTX* ctx, WOLFSSL_X509* x509)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_add0_chain_cert");
|
|
if (wolfSSL_CTX_add1_chain_cert(ctx, x509) != WOLFSSL_SUCCESS) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
wolfSSL_X509_free(x509);
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
int wolfSSL_CTX_add1_chain_cert(WOLFSSL_CTX* ctx, WOLFSSL_X509* x509)
|
|
{
|
|
int ret;
|
|
WOLFSSL_ENTER("wolfSSL_CTX_add1_chain_cert");
|
|
if (ctx == NULL || x509 == NULL || x509->derCert == NULL) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
if (ctx->certificate == NULL)
|
|
ret = (int)wolfSSL_CTX_use_certificate(ctx, x509);
|
|
else {
|
|
if (wolfSSL_X509_up_ref(x509) != WOLFSSL_SUCCESS) {
|
|
WOLFSSL_MSG("wolfSSL_X509_up_ref error");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
ret = wolfSSL_CTX_load_verify_buffer(ctx, x509->derCert->buffer,
|
|
x509->derCert->length, WOLFSSL_FILETYPE_ASN1);
|
|
if (ret == WOLFSSL_SUCCESS) {
|
|
/* push to ctx->certChain */
|
|
ret = PushCertToDerBuffer(&ctx->certChain, 1,
|
|
x509->derCert->buffer, x509->derCert->length, ctx->heap);
|
|
}
|
|
/* Store cert to free it later */
|
|
if (ret == WOLFSSL_SUCCESS && ctx->x509Chain == NULL) {
|
|
ctx->x509Chain = wolfSSL_sk_X509_new_null();
|
|
if (ctx->x509Chain == NULL) {
|
|
WOLFSSL_MSG("wolfSSL_sk_X509_new_null error");
|
|
ret = WOLFSSL_FAILURE;
|
|
}
|
|
}
|
|
if (ret == WOLFSSL_SUCCESS &&
|
|
wolfSSL_sk_X509_push(ctx->x509Chain, x509)
|
|
!= WOLFSSL_SUCCESS) {
|
|
WOLFSSL_MSG("wolfSSL_sk_X509_push error");
|
|
ret = WOLFSSL_FAILURE;
|
|
}
|
|
if (ret != WOLFSSL_SUCCESS)
|
|
wolfSSL_X509_free(x509); /* Decrease ref counter */
|
|
}
|
|
|
|
return (ret == WOLFSSL_SUCCESS) ? WOLFSSL_SUCCESS : WOLFSSL_FAILURE;
|
|
}
|
|
|
|
#ifdef KEEP_OUR_CERT
|
|
int wolfSSL_add0_chain_cert(WOLFSSL* ssl, WOLFSSL_X509* x509)
|
|
{
|
|
int ret;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_add0_chain_cert");
|
|
|
|
if (ssl == NULL || ssl->ctx == NULL || x509 == NULL ||
|
|
x509->derCert == NULL)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
if (ssl->buffers.certificate == NULL) {
|
|
ret = wolfSSL_use_certificate(ssl, x509);
|
|
/* Store cert to free it later */
|
|
if (ret == WOLFSSL_SUCCESS) {
|
|
if (ssl->buffers.weOwnCert)
|
|
wolfSSL_X509_free(ssl->ourCert);
|
|
ssl->ourCert = x509;
|
|
ssl->buffers.weOwnCert = 1;
|
|
}
|
|
}
|
|
else {
|
|
ret = PushCertToDerBuffer(&ssl->buffers.certChain,
|
|
ssl->buffers.weOwnCertChain, x509->derCert->buffer,
|
|
x509->derCert->length, ssl->heap);
|
|
if (ret == WOLFSSL_SUCCESS) {
|
|
ssl->buffers.weOwnCertChain = 1;
|
|
/* Store cert to free it later */
|
|
if (ssl->ourCertChain == NULL) {
|
|
ssl->ourCertChain = wolfSSL_sk_X509_new_null();
|
|
if (ssl->ourCertChain == NULL) {
|
|
WOLFSSL_MSG("wolfSSL_sk_X509_new_null error");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
}
|
|
if (wolfSSL_sk_X509_push(ssl->ourCertChain, x509)
|
|
!= WOLFSSL_SUCCESS) {
|
|
WOLFSSL_MSG("wolfSSL_sk_X509_push error");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
}
|
|
}
|
|
return ret == WOLFSSL_SUCCESS ? WOLFSSL_SUCCESS : WOLFSSL_FAILURE;
|
|
}
|
|
|
|
int wolfSSL_add1_chain_cert(WOLFSSL* ssl, WOLFSSL_X509* x509)
|
|
{
|
|
int ret;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_add1_chain_cert");
|
|
if (ssl == NULL || ssl->ctx == NULL || x509 == NULL ||
|
|
x509->derCert == NULL)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
if (wolfSSL_X509_up_ref(x509) != WOLFSSL_SUCCESS) {
|
|
WOLFSSL_MSG("wolfSSL_X509_up_ref error");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
ret = wolfSSL_add0_chain_cert(ssl, x509);
|
|
/* Decrease ref counter on error */
|
|
if (ret != WOLFSSL_SUCCESS)
|
|
wolfSSL_X509_free(x509);
|
|
return ret;
|
|
}
|
|
#endif
|
|
|
|
/* Return the corresponding short name for the nid <n>.
|
|
* or NULL if short name can't be found.
|
|
*/
|
|
const char * wolfSSL_OBJ_nid2sn(int n) {
|
|
const WOLFSSL_ObjectInfo *obj_info = wolfssl_object_info;
|
|
size_t i;
|
|
WOLFSSL_ENTER("wolfSSL_OBJ_nid2sn");
|
|
|
|
if (n == NID_md5) {
|
|
/* NID_surname == NID_md5 and NID_surname comes before NID_md5 in
|
|
* wolfssl_object_info. As a result, the loop below will incorrectly
|
|
* return "SN" instead of "MD5." NID_surname isn't the true OpenSSL
|
|
* NID, but other functions rely on this table and modifying it to
|
|
* conform with OpenSSL's NIDs isn't trivial. */
|
|
return "MD5";
|
|
}
|
|
for (i = 0; i < WOLFSSL_OBJECT_INFO_SZ; i++, obj_info++) {
|
|
if (obj_info->nid == n) {
|
|
return obj_info->sName;
|
|
}
|
|
}
|
|
WOLFSSL_MSG_EX("SN not found (nid:%d)",n);
|
|
return NULL;
|
|
}
|
|
|
|
#if defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL)
|
|
int wolfSSL_OBJ_sn2nid(const char *sn) {
|
|
WOLFSSL_ENTER("wolfSSL_OBJ_sn2nid");
|
|
if (sn == NULL)
|
|
return NID_undef;
|
|
return wc_OBJ_sn2nid(sn);
|
|
}
|
|
#endif
|
|
|
|
size_t wolfSSL_OBJ_length(const WOLFSSL_ASN1_OBJECT* o)
|
|
{
|
|
size_t ret = 0;
|
|
int err = 0;
|
|
word32 idx = 0;
|
|
int len = 0;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_OBJ_length");
|
|
|
|
if (o == NULL || o->obj == NULL) {
|
|
WOLFSSL_MSG("Bad argument.");
|
|
err = 1;
|
|
}
|
|
|
|
if (err == 0 && GetASNObjectId(o->obj, &idx, &len, o->objSz)) {
|
|
WOLFSSL_MSG("Error parsing ASN.1 header.");
|
|
err = 1;
|
|
}
|
|
if (err == 0) {
|
|
ret = len;
|
|
}
|
|
|
|
WOLFSSL_LEAVE("wolfSSL_OBJ_length", (int)ret);
|
|
|
|
return ret;
|
|
}
|
|
|
|
const unsigned char* wolfSSL_OBJ_get0_data(const WOLFSSL_ASN1_OBJECT* o)
|
|
{
|
|
const unsigned char* ret = NULL;
|
|
int err = 0;
|
|
word32 idx = 0;
|
|
int len = 0;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_OBJ_get0_data");
|
|
|
|
if (o == NULL || o->obj == NULL) {
|
|
WOLFSSL_MSG("Bad argument.");
|
|
err = 1;
|
|
}
|
|
|
|
if (err == 0 && GetASNObjectId(o->obj, &idx, &len, o->objSz)) {
|
|
WOLFSSL_MSG("Error parsing ASN.1 header.");
|
|
err = 1;
|
|
}
|
|
if (err == 0) {
|
|
ret = o->obj + idx;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
/* Gets the NID value that corresponds with the ASN1 object.
|
|
*
|
|
* o ASN1 object to get NID of
|
|
*
|
|
* Return NID on success and a negative value on failure
|
|
*/
|
|
int wolfSSL_OBJ_obj2nid(const WOLFSSL_ASN1_OBJECT *o)
|
|
{
|
|
word32 oid = 0;
|
|
word32 idx = 0;
|
|
int ret;
|
|
|
|
#ifdef WOLFSSL_DEBUG_OPENSSL
|
|
WOLFSSL_ENTER("wolfSSL_OBJ_obj2nid");
|
|
#endif
|
|
|
|
if (o == NULL) {
|
|
return -1;
|
|
}
|
|
|
|
#ifdef WOLFSSL_QT
|
|
if (o->grp == oidCertExtType) {
|
|
/* If nid is an unknown extension, return NID_undef */
|
|
if (wolfSSL_OBJ_nid2sn(o->nid) == NULL)
|
|
return NID_undef;
|
|
}
|
|
#endif
|
|
|
|
if (o->nid > 0)
|
|
return o->nid;
|
|
if ((ret = GetObjectId(o->obj, &idx, &oid, o->grp, o->objSz)) < 0) {
|
|
if (ret == ASN_OBJECT_ID_E) {
|
|
/* Put ASN object tag in front and try again */
|
|
int len = SetObjectId(o->objSz, NULL) + o->objSz;
|
|
byte* buf = (byte*)XMALLOC(len, NULL, DYNAMIC_TYPE_TMP_BUFFER);
|
|
if (!buf) {
|
|
WOLFSSL_MSG("malloc error");
|
|
return -1;
|
|
}
|
|
idx = SetObjectId(o->objSz, buf);
|
|
XMEMCPY(buf + idx, o->obj, o->objSz);
|
|
idx = 0;
|
|
ret = GetObjectId(buf, &idx, &oid, o->grp, len);
|
|
XFREE(buf, NULL, DYNAMIC_TYPE_TMP_BUFFER);
|
|
if (ret < 0) {
|
|
WOLFSSL_MSG("Issue getting OID of object");
|
|
return -1;
|
|
}
|
|
}
|
|
else {
|
|
WOLFSSL_MSG("Issue getting OID of object");
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
return oid2nid(oid, o->grp);
|
|
}
|
|
|
|
/* Return the corresponding NID for the long name <ln>
|
|
* or NID_undef if NID can't be found.
|
|
*/
|
|
int wolfSSL_OBJ_ln2nid(const char *ln)
|
|
{
|
|
const WOLFSSL_ObjectInfo *obj_info = wolfssl_object_info;
|
|
size_t lnlen;
|
|
WOLFSSL_ENTER("wolfSSL_OBJ_ln2nid");
|
|
if (ln && (lnlen = XSTRLEN(ln)) > 0) {
|
|
/* Accept input like "/commonName=" */
|
|
if (ln[0] == '/') {
|
|
ln++;
|
|
lnlen--;
|
|
}
|
|
if (lnlen) {
|
|
size_t i;
|
|
|
|
if (ln[lnlen-1] == '=') {
|
|
lnlen--;
|
|
}
|
|
for (i = 0; i < WOLFSSL_OBJECT_INFO_SZ; i++, obj_info++) {
|
|
if (lnlen == XSTRLEN(obj_info->lName) &&
|
|
XSTRNCMP(ln, obj_info->lName, lnlen) == 0) {
|
|
return obj_info->nid;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return NID_undef;
|
|
}
|
|
|
|
/* compares two objects, return 0 if equal */
|
|
int wolfSSL_OBJ_cmp(const WOLFSSL_ASN1_OBJECT* a,
|
|
const WOLFSSL_ASN1_OBJECT* b)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_OBJ_cmp");
|
|
|
|
if (a && b && a->obj && b->obj) {
|
|
if (a->objSz == b->objSz) {
|
|
return XMEMCMP(a->obj, b->obj, a->objSz);
|
|
}
|
|
else if (a->type == EXT_KEY_USAGE_OID ||
|
|
b->type == EXT_KEY_USAGE_OID) {
|
|
/* Special case for EXT_KEY_USAGE_OID so that
|
|
* cmp will be treated as a substring search */
|
|
/* Used in libest to check for id-kp-cmcRA in
|
|
* EXT_KEY_USAGE extension */
|
|
unsigned int idx;
|
|
const byte* s; /* shorter */
|
|
unsigned int sLen;
|
|
const byte* l; /* longer */
|
|
unsigned int lLen;
|
|
if (a->objSz > b->objSz) {
|
|
s = b->obj; sLen = b->objSz;
|
|
l = a->obj; lLen = a->objSz;
|
|
}
|
|
else {
|
|
s = a->obj; sLen = a->objSz;
|
|
l = b->obj; lLen = b->objSz;
|
|
}
|
|
for (idx = 0; idx <= lLen - sLen; idx++) {
|
|
if (XMEMCMP(l + idx, s, sLen) == 0) {
|
|
/* Found substring */
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
#endif /* OPENSSL_EXTRA, HAVE_LIGHTY, WOLFSSL_MYSQL_COMPATIBLE, HAVE_STUNNEL,
|
|
WOLFSSL_NGINX, HAVE_POCO_LIB, WOLFSSL_HAPROXY */
|
|
#if defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL) || \
|
|
defined(HAVE_LIGHTY) || defined(WOLFSSL_MYSQL_COMPATIBLE) || \
|
|
defined(HAVE_STUNNEL) || defined(WOLFSSL_NGINX) || \
|
|
defined(HAVE_POCO_LIB) || defined(WOLFSSL_HAPROXY)
|
|
/* Gets the NID value that is related to the OID string passed in. Example
|
|
* string would be "2.5.29.14" for subject key ID.
|
|
*
|
|
* returns NID value on success and NID_undef on error
|
|
*/
|
|
int wolfSSL_OBJ_txt2nid(const char* s)
|
|
{
|
|
unsigned int i;
|
|
#ifdef WOLFSSL_CERT_EXT
|
|
int ret;
|
|
unsigned int sum = 0;
|
|
unsigned int outSz = MAX_OID_SZ;
|
|
unsigned char out[MAX_OID_SZ];
|
|
#endif
|
|
|
|
WOLFSSL_ENTER("wolfSSL_OBJ_txt2nid");
|
|
|
|
if (s == NULL) {
|
|
return NID_undef;
|
|
}
|
|
|
|
#ifdef WOLFSSL_CERT_EXT
|
|
ret = EncodePolicyOID(out, &outSz, s, NULL);
|
|
if (ret == 0) {
|
|
/* sum OID */
|
|
for (i = 0; i < outSz; i++) {
|
|
sum += out[i];
|
|
}
|
|
}
|
|
#endif /* WOLFSSL_CERT_EXT */
|
|
|
|
/* get the group that the OID's sum is in
|
|
* @TODO possible conflict with multiples */
|
|
for (i = 0; i < WOLFSSL_OBJECT_INFO_SZ; i++) {
|
|
int len;
|
|
#ifdef WOLFSSL_CERT_EXT
|
|
if (ret == 0) {
|
|
if (wolfssl_object_info[i].id == (int)sum) {
|
|
return wolfssl_object_info[i].nid;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/* try as a short name */
|
|
len = (int)XSTRLEN(s);
|
|
if ((int)XSTRLEN(wolfssl_object_info[i].sName) == len &&
|
|
XSTRNCMP(wolfssl_object_info[i].sName, s, len) == 0) {
|
|
return wolfssl_object_info[i].nid;
|
|
}
|
|
|
|
/* try as a long name */
|
|
if ((int)XSTRLEN(wolfssl_object_info[i].lName) == len &&
|
|
XSTRNCMP(wolfssl_object_info[i].lName, s, len) == 0) {
|
|
return wolfssl_object_info[i].nid;
|
|
}
|
|
}
|
|
|
|
return NID_undef;
|
|
}
|
|
#endif
|
|
#if defined(OPENSSL_EXTRA) || defined(HAVE_LIGHTY) || \
|
|
defined(WOLFSSL_MYSQL_COMPATIBLE) || defined(HAVE_STUNNEL) || \
|
|
defined(WOLFSSL_NGINX) || defined(HAVE_POCO_LIB) || \
|
|
defined(WOLFSSL_HAPROXY)
|
|
|
|
/* Creates new ASN1_OBJECT from short name, long name, or text
|
|
* representation of oid. If no_name is 0, then short name, long name, and
|
|
* numerical value of oid are interpreted. If no_name is 1, then only the
|
|
* numerical value of the oid is interpreted.
|
|
*
|
|
* Returns pointer to ASN1_OBJECT on success, or NULL on error.
|
|
*/
|
|
#if defined(WOLFSSL_CERT_EXT) && defined(WOLFSSL_CERT_GEN)
|
|
WOLFSSL_ASN1_OBJECT* wolfSSL_OBJ_txt2obj(const char* s, int no_name)
|
|
{
|
|
int i, ret;
|
|
int nid = NID_undef;
|
|
unsigned int outSz = MAX_OID_SZ;
|
|
unsigned char out[MAX_OID_SZ];
|
|
WOLFSSL_ASN1_OBJECT* obj;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_OBJ_txt2obj");
|
|
|
|
if (s == NULL)
|
|
return NULL;
|
|
|
|
/* If s is numerical value, try to sum oid */
|
|
ret = EncodePolicyOID(out, &outSz, s, NULL);
|
|
if (ret == 0 && outSz > 0) {
|
|
/* If numerical encode succeeded then just
|
|
* create object from that because sums are
|
|
* not unique and can cause confusion. */
|
|
obj = wolfSSL_ASN1_OBJECT_new();
|
|
if (obj == NULL) {
|
|
WOLFSSL_MSG("Issue creating WOLFSSL_ASN1_OBJECT struct");
|
|
return NULL;
|
|
}
|
|
obj->dynamic |= WOLFSSL_ASN1_DYNAMIC;
|
|
obj->obj = (byte*)XMALLOC(1 + MAX_LENGTH_SZ + outSz, NULL,
|
|
DYNAMIC_TYPE_ASN1);
|
|
if (obj->obj == NULL) {
|
|
wolfSSL_ASN1_OBJECT_free(obj);
|
|
return NULL;
|
|
}
|
|
obj->dynamic |= WOLFSSL_ASN1_DYNAMIC_DATA ;
|
|
i = SetObjectId(outSz, (byte*)obj->obj);
|
|
XMEMCPY((byte*)obj->obj + i, out, outSz);
|
|
obj->objSz = i + outSz;
|
|
return obj;
|
|
}
|
|
|
|
/* TODO: update short names in wolfssl_object_info and check OID sums
|
|
are correct */
|
|
for (i = 0; i < (int)WOLFSSL_OBJECT_INFO_SZ; i++) {
|
|
/* Short name, long name, and numerical value are interpreted */
|
|
if (no_name == 0 &&
|
|
((XSTRCMP(s, wolfssl_object_info[i].sName) == 0) ||
|
|
(XSTRCMP(s, wolfssl_object_info[i].lName) == 0)))
|
|
{
|
|
nid = wolfssl_object_info[i].nid;
|
|
}
|
|
}
|
|
|
|
if (nid != NID_undef)
|
|
return wolfSSL_OBJ_nid2obj(nid);
|
|
|
|
return NULL;
|
|
}
|
|
#endif
|
|
|
|
/* compatibility function. Its intended use is to remove OID's from an
|
|
* internal table that have been added with OBJ_create. wolfSSL manages its
|
|
* own internal OID values and does not currently support OBJ_create. */
|
|
void wolfSSL_OBJ_cleanup(void)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_OBJ_cleanup");
|
|
}
|
|
|
|
#ifndef NO_WOLFSSL_STUB
|
|
int wolfSSL_OBJ_create(const char *oid, const char *sn, const char *ln)
|
|
{
|
|
(void)oid;
|
|
(void)sn;
|
|
(void)ln;
|
|
WOLFSSL_STUB("wolfSSL_OBJ_create");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
#endif
|
|
|
|
void wolfSSL_set_verify_depth(WOLFSSL *ssl, int depth)
|
|
{
|
|
#if defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL)
|
|
WOLFSSL_ENTER("wolfSSL_set_verify_depth");
|
|
ssl->options.verifyDepth = (byte)depth;
|
|
#endif
|
|
}
|
|
|
|
#endif /* OPENSSL_ALL || HAVE_LIGHTY || WOLFSSL_MYSQL_COMPATIBLE ||
|
|
HAVE_STUNNEL || WOLFSSL_NGINX || HAVE_POCO_LIB || WOLFSSL_HAPROXY */
|
|
|
|
#ifdef OPENSSL_EXTRA
|
|
|
|
/* wolfSSL uses negative values for error states. This function returns an
|
|
* unsigned type so the value returned is the absolute value of the error.
|
|
*/
|
|
unsigned long wolfSSL_ERR_peek_last_error_line(const char **file, int *line)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_ERR_peek_last_error");
|
|
|
|
(void)line;
|
|
(void)file;
|
|
#ifdef WOLFSSL_HAVE_ERROR_QUEUE
|
|
{
|
|
int ret;
|
|
|
|
if ((ret = wc_PeekErrorNode(-1, file, NULL, line)) < 0) {
|
|
WOLFSSL_MSG("Issue peeking at error node in queue");
|
|
return 0;
|
|
}
|
|
#if defined(OPENSSL_ALL) || defined(WOLFSSL_NGINX) \
|
|
|| defined(WOLFSSL_HAPROXY)
|
|
if (ret == -ASN_NO_PEM_HEADER)
|
|
return (ERR_LIB_PEM << 24) | PEM_R_NO_START_LINE;
|
|
#endif
|
|
#if defined(OPENSSL_ALL) && defined(WOLFSSL_PYTHON)
|
|
if (ret == ASN1_R_HEADER_TOO_LONG) {
|
|
return (ERR_LIB_ASN1 << 24) | ASN1_R_HEADER_TOO_LONG;
|
|
}
|
|
#endif
|
|
return (unsigned long)ret;
|
|
}
|
|
#else
|
|
return (unsigned long)(0 - NOT_COMPILED_IN);
|
|
#endif
|
|
}
|
|
|
|
|
|
#ifndef NO_CERTS
|
|
int wolfSSL_CTX_use_PrivateKey(WOLFSSL_CTX *ctx, WOLFSSL_EVP_PKEY *pkey)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_use_PrivateKey");
|
|
|
|
if (ctx == NULL || pkey == NULL) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
switch (pkey->type) {
|
|
#if defined(WOLFSSL_KEY_GEN) && !defined(HAVE_USER_RSA) && !defined(NO_RSA)
|
|
case EVP_PKEY_RSA:
|
|
WOLFSSL_MSG("populating RSA key");
|
|
if (PopulateRSAEvpPkeyDer(pkey) != WOLFSSL_SUCCESS)
|
|
return WOLFSSL_FAILURE;
|
|
break;
|
|
#endif /* (WOLFSSL_KEY_GEN || OPENSSL_EXTRA) && !NO_RSA */
|
|
#if !defined(HAVE_SELFTEST) && (defined(WOLFSSL_KEY_GEN) || \
|
|
defined(WOLFSSL_CERT_GEN)) && !defined(NO_DSA)
|
|
case EVP_PKEY_DSA:
|
|
break;
|
|
#endif /* !HAVE_SELFTEST && (WOLFSSL_KEY_GEN || WOLFSSL_CERT_GEN) && !NO_DSA */
|
|
#ifdef HAVE_ECC
|
|
case EVP_PKEY_EC:
|
|
WOLFSSL_MSG("populating ECC key");
|
|
if (ECC_populate_EVP_PKEY(pkey, pkey->ecc)
|
|
!= WOLFSSL_SUCCESS)
|
|
return WOLFSSL_FAILURE;
|
|
break;
|
|
#endif
|
|
default:
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
if (pkey->pkey.ptr != NULL) {
|
|
/* ptr for WOLFSSL_EVP_PKEY struct is expected to be DER format */
|
|
return wolfSSL_CTX_use_PrivateKey_buffer(ctx,
|
|
(const unsigned char*)pkey->pkey.ptr,
|
|
pkey->pkey_sz, SSL_FILETYPE_ASN1);
|
|
}
|
|
|
|
WOLFSSL_MSG("wolfSSL private key not set");
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
#endif /* !NO_CERTS */
|
|
|
|
#endif /* OPENSSL_EXTRA */
|
|
|
|
#if defined(HAVE_EX_DATA) && \
|
|
(defined(OPENSSL_ALL) || defined(WOLFSSL_NGINX) || \
|
|
defined(WOLFSSL_HAPROXY) || defined(OPENSSL_EXTRA) || \
|
|
defined(HAVE_LIGHTY)) || defined(HAVE_EX_DATA) || \
|
|
defined(WOLFSSL_WPAS_SMALL)
|
|
CRYPTO_EX_cb_ctx* crypto_ex_cb_ctx_session = NULL;
|
|
|
|
static int crypto_ex_cb_new(CRYPTO_EX_cb_ctx** dst, long ctx_l, void* ctx_ptr,
|
|
WOLFSSL_CRYPTO_EX_new* new_func, WOLFSSL_CRYPTO_EX_dup* dup_func,
|
|
WOLFSSL_CRYPTO_EX_free* free_func)
|
|
{
|
|
CRYPTO_EX_cb_ctx* new_ctx = (CRYPTO_EX_cb_ctx*)XMALLOC(
|
|
sizeof(CRYPTO_EX_cb_ctx), NULL, DYNAMIC_TYPE_OPENSSL);
|
|
if (new_ctx == NULL)
|
|
return -1;
|
|
new_ctx->ctx_l = ctx_l;
|
|
new_ctx->ctx_ptr = ctx_ptr;
|
|
new_ctx->new_func = new_func;
|
|
new_ctx->free_func = free_func;
|
|
new_ctx->dup_func = dup_func;
|
|
new_ctx->next = NULL;
|
|
/* Push to end of list */
|
|
while (*dst != NULL)
|
|
dst = &(*dst)->next;
|
|
*dst = new_ctx;
|
|
return 0;
|
|
}
|
|
|
|
void crypto_ex_cb_free(CRYPTO_EX_cb_ctx* cb_ctx)
|
|
{
|
|
while (cb_ctx != NULL) {
|
|
CRYPTO_EX_cb_ctx* next = cb_ctx->next;
|
|
XFREE(cb_ctx, NULL, DYNAMIC_TYPE_OPENSSL);
|
|
cb_ctx = next;
|
|
}
|
|
}
|
|
|
|
void crypto_ex_cb_setup_new_data(void *new_obj, CRYPTO_EX_cb_ctx* cb_ctx,
|
|
WOLFSSL_CRYPTO_EX_DATA* ex_data)
|
|
{
|
|
int idx = 0;
|
|
for (; cb_ctx != NULL; idx++, cb_ctx = cb_ctx->next) {
|
|
if (cb_ctx->new_func != NULL)
|
|
cb_ctx->new_func(new_obj, NULL, ex_data, idx, cb_ctx->ctx_l,
|
|
cb_ctx->ctx_ptr);
|
|
}
|
|
}
|
|
|
|
int crypto_ex_cb_dup_data(const WOLFSSL_CRYPTO_EX_DATA *in,
|
|
WOLFSSL_CRYPTO_EX_DATA *out, CRYPTO_EX_cb_ctx* cb_ctx)
|
|
{
|
|
int idx = 0;
|
|
for (; cb_ctx != NULL; idx++, cb_ctx = cb_ctx->next) {
|
|
if (cb_ctx->dup_func != NULL) {
|
|
void* ptr = wolfSSL_CRYPTO_get_ex_data(in, idx);
|
|
if (!cb_ctx->dup_func(out, in,
|
|
&ptr, idx,
|
|
cb_ctx->ctx_l, cb_ctx->ctx_ptr)) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
wolfSSL_CRYPTO_set_ex_data(out, idx, ptr);
|
|
}
|
|
}
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
void crypto_ex_cb_free_data(void *obj, CRYPTO_EX_cb_ctx* cb_ctx,
|
|
WOLFSSL_CRYPTO_EX_DATA* ex_data)
|
|
{
|
|
int idx = 0;
|
|
for (; cb_ctx != NULL; idx++, cb_ctx = cb_ctx->next) {
|
|
if (cb_ctx->free_func != NULL)
|
|
cb_ctx->free_func(obj, NULL, ex_data, idx, cb_ctx->ctx_l,
|
|
cb_ctx->ctx_ptr);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* get_ex_new_index is a helper function for the following
|
|
* xx_get_ex_new_index functions:
|
|
* - wolfSSL_CRYPTO_get_ex_new_index
|
|
* - wolfSSL_CTX_get_ex_new_index
|
|
* - wolfSSL_get_ex_new_index
|
|
* Issues a unique index number for the specified class-index.
|
|
* Returns an index number greater or equal to zero on success,
|
|
* -1 on failure.
|
|
*/
|
|
int wolfssl_get_ex_new_index(int class_index, long ctx_l, void* ctx_ptr,
|
|
WOLFSSL_CRYPTO_EX_new* new_func, WOLFSSL_CRYPTO_EX_dup* dup_func,
|
|
WOLFSSL_CRYPTO_EX_free* free_func)
|
|
{
|
|
/* index counter for each class index*/
|
|
static int ctx_idx = 0;
|
|
static int ssl_idx = 0;
|
|
static int ssl_session_idx = 0;
|
|
static int x509_idx = 0;
|
|
|
|
int idx = -1;
|
|
|
|
switch(class_index) {
|
|
case WOLF_CRYPTO_EX_INDEX_SSL:
|
|
WOLFSSL_CRYPTO_EX_DATA_IGNORE_PARAMS(ctx_l, ctx_ptr, new_func,
|
|
dup_func, free_func);
|
|
idx = ssl_idx++;
|
|
break;
|
|
case WOLF_CRYPTO_EX_INDEX_SSL_CTX:
|
|
WOLFSSL_CRYPTO_EX_DATA_IGNORE_PARAMS(ctx_l, ctx_ptr, new_func,
|
|
dup_func, free_func);
|
|
idx = ctx_idx++;
|
|
break;
|
|
case WOLF_CRYPTO_EX_INDEX_X509:
|
|
WOLFSSL_CRYPTO_EX_DATA_IGNORE_PARAMS(ctx_l, ctx_ptr, new_func,
|
|
dup_func, free_func);
|
|
idx = x509_idx++;
|
|
break;
|
|
case WOLF_CRYPTO_EX_INDEX_SSL_SESSION:
|
|
if (crypto_ex_cb_new(&crypto_ex_cb_ctx_session, ctx_l, ctx_ptr,
|
|
new_func, dup_func, free_func) != 0)
|
|
return -1;
|
|
idx = ssl_session_idx++;
|
|
break;
|
|
|
|
/* following class indexes are not supoprted */
|
|
case WOLF_CRYPTO_EX_INDEX_X509_STORE:
|
|
case WOLF_CRYPTO_EX_INDEX_X509_STORE_CTX:
|
|
case WOLF_CRYPTO_EX_INDEX_DH:
|
|
case WOLF_CRYPTO_EX_INDEX_DSA:
|
|
case WOLF_CRYPTO_EX_INDEX_EC_KEY:
|
|
case WOLF_CRYPTO_EX_INDEX_RSA:
|
|
case WOLF_CRYPTO_EX_INDEX_ENGINE:
|
|
case WOLF_CRYPTO_EX_INDEX_UI:
|
|
case WOLF_CRYPTO_EX_INDEX_BIO:
|
|
case WOLF_CRYPTO_EX_INDEX_APP:
|
|
case WOLF_CRYPTO_EX_INDEX_UI_METHOD:
|
|
case WOLF_CRYPTO_EX_INDEX_DRBG:
|
|
default:
|
|
break;
|
|
}
|
|
if (idx >= MAX_EX_DATA)
|
|
return -1;
|
|
return idx;
|
|
}
|
|
#endif /* HAVE_EX_DATA || WOLFSSL_WPAS_SMALL */
|
|
|
|
#if defined(HAVE_EX_DATA) || defined(WOLFSSL_WPAS_SMALL)
|
|
void* wolfSSL_CTX_get_ex_data(const WOLFSSL_CTX* ctx, int idx)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_get_ex_data");
|
|
#ifdef HAVE_EX_DATA
|
|
if(ctx != NULL) {
|
|
return wolfSSL_CRYPTO_get_ex_data(&ctx->ex_data, idx);
|
|
}
|
|
#else
|
|
(void)ctx;
|
|
(void)idx;
|
|
#endif
|
|
return NULL;
|
|
}
|
|
|
|
int wolfSSL_CTX_get_ex_new_index(long idx, void* arg,
|
|
WOLFSSL_CRYPTO_EX_new* new_func,
|
|
WOLFSSL_CRYPTO_EX_dup* dup_func,
|
|
WOLFSSL_CRYPTO_EX_free* free_func)
|
|
{
|
|
|
|
WOLFSSL_ENTER("wolfSSL_CTX_get_ex_new_index");
|
|
|
|
return wolfssl_get_ex_new_index(WOLF_CRYPTO_EX_INDEX_SSL_CTX, idx, arg,
|
|
new_func, dup_func, free_func);
|
|
}
|
|
|
|
/* Return the index that can be used for the WOLFSSL structure to store
|
|
* application data.
|
|
*
|
|
*/
|
|
int wolfSSL_get_ex_new_index(long argValue, void* arg,
|
|
WOLFSSL_CRYPTO_EX_new* cb1, WOLFSSL_CRYPTO_EX_dup* cb2,
|
|
WOLFSSL_CRYPTO_EX_free* cb3)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_get_ex_new_index");
|
|
|
|
return wolfssl_get_ex_new_index(WOLF_CRYPTO_EX_INDEX_SSL, argValue, arg,
|
|
cb1, cb2, cb3);
|
|
}
|
|
|
|
|
|
int wolfSSL_CTX_set_ex_data(WOLFSSL_CTX* ctx, int idx, void* data)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_set_ex_data");
|
|
#ifdef HAVE_EX_DATA
|
|
if (ctx != NULL)
|
|
{
|
|
return wolfSSL_CRYPTO_set_ex_data(&ctx->ex_data, idx, data);
|
|
}
|
|
#else
|
|
(void)ctx;
|
|
(void)idx;
|
|
(void)data;
|
|
#endif
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
#ifdef HAVE_EX_DATA_CLEANUP_HOOKS
|
|
int wolfSSL_CTX_set_ex_data_with_cleanup(
|
|
WOLFSSL_CTX* ctx,
|
|
int idx,
|
|
void* data,
|
|
wolfSSL_ex_data_cleanup_routine_t cleanup_routine)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_set_ex_data_with_cleanup");
|
|
if (ctx != NULL)
|
|
{
|
|
return wolfSSL_CRYPTO_set_ex_data_with_cleanup(&ctx->ex_data, idx, data,
|
|
cleanup_routine);
|
|
}
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
#endif /* HAVE_EX_DATA_CLEANUP_HOOKS */
|
|
|
|
#endif /* defined(HAVE_EX_DATA) || defined(WOLFSSL_WPAS_SMALL) */
|
|
|
|
#if defined(OPENSSL_EXTRA) || defined(OPENSSL_EXTRA_X509_SMALL)
|
|
|
|
/* Returns char* to app data stored in ex[0].
|
|
*
|
|
* ssl WOLFSSL structure to get app data from
|
|
*/
|
|
void* wolfSSL_get_app_data(const WOLFSSL *ssl)
|
|
{
|
|
/* checkout exdata stuff... */
|
|
WOLFSSL_ENTER("wolfSSL_get_app_data");
|
|
|
|
return wolfSSL_get_ex_data(ssl, 0);
|
|
}
|
|
|
|
|
|
/* Set ex array 0 to have app data
|
|
*
|
|
* ssl WOLFSSL struct to set app data in
|
|
* arg data to be stored
|
|
*
|
|
* Returns WOLFSSL_SUCCESS on success and WOLFSSL_FAILURE on failure
|
|
*/
|
|
int wolfSSL_set_app_data(WOLFSSL *ssl, void* arg) {
|
|
WOLFSSL_ENTER("wolfSSL_set_app_data");
|
|
|
|
return wolfSSL_set_ex_data(ssl, 0, arg);
|
|
}
|
|
|
|
#endif /* OPENSSL_EXTRA || OPENSSL_EXTRA_X509_SMALL */
|
|
|
|
#if defined(HAVE_EX_DATA) || defined(OPENSSL_EXTRA) || \
|
|
defined(OPENSSL_EXTRA_X509_SMALL) || defined(WOLFSSL_WPAS_SMALL)
|
|
|
|
int wolfSSL_set_ex_data(WOLFSSL* ssl, int idx, void* data)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_set_ex_data");
|
|
#ifdef HAVE_EX_DATA
|
|
if (ssl != NULL)
|
|
{
|
|
return wolfSSL_CRYPTO_set_ex_data(&ssl->ex_data, idx, data);
|
|
}
|
|
#else
|
|
WOLFSSL_MSG("HAVE_EX_DATA macro is not defined");
|
|
(void)ssl;
|
|
(void)idx;
|
|
(void)data;
|
|
#endif
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
#ifdef HAVE_EX_DATA_CLEANUP_HOOKS
|
|
int wolfSSL_set_ex_data_with_cleanup(
|
|
WOLFSSL* ssl,
|
|
int idx,
|
|
void* data,
|
|
wolfSSL_ex_data_cleanup_routine_t cleanup_routine)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_set_ex_data_with_cleanup");
|
|
if (ssl != NULL)
|
|
{
|
|
return wolfSSL_CRYPTO_set_ex_data_with_cleanup(&ssl->ex_data, idx, data,
|
|
cleanup_routine);
|
|
}
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
#endif /* HAVE_EX_DATA_CLEANUP_HOOKS */
|
|
|
|
void* wolfSSL_get_ex_data(const WOLFSSL* ssl, int idx)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_get_ex_data");
|
|
#ifdef HAVE_EX_DATA
|
|
if (ssl != NULL) {
|
|
return wolfSSL_CRYPTO_get_ex_data(&ssl->ex_data, idx);
|
|
}
|
|
#else
|
|
WOLFSSL_MSG("HAVE_EX_DATA macro is not defined");
|
|
(void)ssl;
|
|
(void)idx;
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
#endif /* OPENSSL_EXTRA || OPENSSL_EXTRA_X509_SMALL || WOLFSSL_WPAS_SMALL */
|
|
|
|
#if defined(HAVE_LIGHTY) || defined(HAVE_STUNNEL) \
|
|
|| defined(WOLFSSL_MYSQL_COMPATIBLE) || defined(OPENSSL_EXTRA)
|
|
|
|
#if defined(OPENSSL_EXTRA) && !defined(NO_DH)
|
|
/* Initialize ctx->dh with dh's params. Return WOLFSSL_SUCCESS on ok */
|
|
long wolfSSL_CTX_set_tmp_dh(WOLFSSL_CTX* ctx, WOLFSSL_DH* dh)
|
|
{
|
|
int pSz, gSz;
|
|
byte *p, *g;
|
|
int ret=0;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_CTX_set_tmp_dh");
|
|
|
|
if(!ctx || !dh)
|
|
return BAD_FUNC_ARG;
|
|
|
|
/* Get needed size for p and g */
|
|
pSz = wolfSSL_BN_bn2bin(dh->p, NULL);
|
|
gSz = wolfSSL_BN_bn2bin(dh->g, NULL);
|
|
|
|
if(pSz <= 0 || gSz <= 0)
|
|
return WOLFSSL_FATAL_ERROR;
|
|
|
|
p = (byte*)XMALLOC(pSz, ctx->heap, DYNAMIC_TYPE_PUBLIC_KEY);
|
|
if(!p)
|
|
return MEMORY_E;
|
|
|
|
g = (byte*)XMALLOC(gSz, ctx->heap, DYNAMIC_TYPE_PUBLIC_KEY);
|
|
if(!g) {
|
|
XFREE(p, ctx->heap, DYNAMIC_TYPE_PUBLIC_KEY);
|
|
return MEMORY_E;
|
|
}
|
|
|
|
pSz = wolfSSL_BN_bn2bin(dh->p, p);
|
|
gSz = wolfSSL_BN_bn2bin(dh->g, g);
|
|
|
|
if(pSz >= 0 && gSz >= 0) /* Conversion successful */
|
|
ret = wolfSSL_CTX_SetTmpDH(ctx, p, pSz, g, gSz);
|
|
|
|
XFREE(p, ctx->heap, DYNAMIC_TYPE_PUBLIC_KEY);
|
|
XFREE(g, ctx->heap, DYNAMIC_TYPE_PUBLIC_KEY);
|
|
|
|
return pSz > 0 && gSz > 0 ? ret : WOLFSSL_FATAL_ERROR;
|
|
}
|
|
#endif /* OPENSSL_EXTRA && !NO_DH */
|
|
|
|
|
|
/* returns the enum value associated with handshake state
|
|
*
|
|
* ssl the WOLFSSL structure to get state of
|
|
*/
|
|
int wolfSSL_get_state(const WOLFSSL* ssl)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_get_state");
|
|
|
|
if (ssl == NULL) {
|
|
WOLFSSL_MSG("Null argument passed in");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
return ssl->options.handShakeState;
|
|
}
|
|
#endif /* HAVE_LIGHTY || HAVE_STUNNEL || WOLFSSL_MYSQL_COMPATIBLE */
|
|
|
|
#ifdef OPENSSL_EXTRA
|
|
void wolfSSL_certs_clear(WOLFSSL* ssl)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_certs_clear");
|
|
|
|
if (ssl == NULL)
|
|
return;
|
|
|
|
/* ctx still owns certificate, certChain, key, dh, and cm */
|
|
if (ssl->buffers.weOwnCert)
|
|
FreeDer(&ssl->buffers.certificate);
|
|
ssl->buffers.certificate = NULL;
|
|
if (ssl->buffers.weOwnCertChain)
|
|
FreeDer(&ssl->buffers.certChain);
|
|
ssl->buffers.certChain = NULL;
|
|
#ifdef WOLFSSL_TLS13
|
|
ssl->buffers.certChainCnt = 0;
|
|
#endif
|
|
if (ssl->buffers.weOwnKey)
|
|
FreeDer(&ssl->buffers.key);
|
|
ssl->buffers.key = NULL;
|
|
ssl->buffers.keyType = 0;
|
|
ssl->buffers.keyId = 0;
|
|
ssl->buffers.keyLabel = 0;
|
|
ssl->buffers.keySz = 0;
|
|
ssl->buffers.keyDevId = 0;
|
|
}
|
|
#endif
|
|
|
|
#if defined(OPENSSL_ALL) || defined(WOLFSSL_ASIO) || defined(WOLFSSL_HAPROXY) \
|
|
|| defined(WOLFSSL_NGINX) || defined(WOLFSSL_QT)
|
|
|
|
long wolfSSL_ctrl(WOLFSSL* ssl, int cmd, long opt, void* pt)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_ctrl");
|
|
if (ssl == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
switch (cmd) {
|
|
#if defined(WOLFSSL_NGINX) || defined(WOLFSSL_QT) || defined(OPENSSL_ALL)
|
|
#ifdef HAVE_SNI
|
|
case SSL_CTRL_SET_TLSEXT_HOSTNAME:
|
|
WOLFSSL_MSG("Entering Case: SSL_CTRL_SET_TLSEXT_HOSTNAME.");
|
|
if (pt == NULL) {
|
|
WOLFSSL_MSG("Passed in NULL Host Name.");
|
|
break;
|
|
}
|
|
return wolfSSL_set_tlsext_host_name(ssl, (const char*) pt);
|
|
#endif /* HAVE_SNI */
|
|
#endif /* WOLFSSL_NGINX || WOLFSSL_QT || OPENSSL_ALL */
|
|
default:
|
|
WOLFSSL_MSG("Case not implemented.");
|
|
}
|
|
(void)opt;
|
|
(void)pt;
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
long wolfSSL_CTX_ctrl(WOLFSSL_CTX* ctx, int cmd, long opt, void* pt)
|
|
{
|
|
#if defined(OPENSSL_EXTRA) || defined(HAVE_WEBSERVER)
|
|
long ctrl_opt;
|
|
#endif
|
|
long ret = WOLFSSL_SUCCESS;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_CTX_ctrl");
|
|
if (ctx == NULL)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
switch (cmd) {
|
|
case SSL_CTRL_CHAIN:
|
|
#ifdef SESSION_CERTS
|
|
{
|
|
/*
|
|
* We don't care about opt here because a copy of the certificate is
|
|
* stored anyway so increasing the reference counter is not necessary.
|
|
* Just check to make sure that it is set to one of the correct values.
|
|
*/
|
|
WOLF_STACK_OF(WOLFSSL_X509)* sk = (WOLF_STACK_OF(WOLFSSL_X509)*) pt;
|
|
WOLFSSL_X509* x509;
|
|
int i;
|
|
if (opt != 0 && opt != 1) {
|
|
ret = WOLFSSL_FAILURE;
|
|
break;
|
|
}
|
|
/* Clear certificate chain */
|
|
FreeDer(&ctx->certChain);
|
|
if (sk) {
|
|
for (i = 0; i < wolfSSL_sk_X509_num(sk); i++) {
|
|
x509 = wolfSSL_sk_X509_value(sk, i);
|
|
/* Prevent wolfSSL_CTX_add_extra_chain_cert from freeing cert */
|
|
if (wolfSSL_X509_up_ref(x509) != 1) {
|
|
WOLFSSL_MSG("Error increasing reference count");
|
|
continue;
|
|
}
|
|
if (wolfSSL_CTX_add_extra_chain_cert(ctx, x509) !=
|
|
WOLFSSL_SUCCESS) {
|
|
WOLFSSL_MSG("Error adding certificate to context");
|
|
/* Decrease reference count on failure */
|
|
wolfSSL_X509_free(x509);
|
|
}
|
|
}
|
|
}
|
|
/* Free previous chain */
|
|
wolfSSL_sk_X509_pop_free(ctx->x509Chain, NULL);
|
|
ctx->x509Chain = sk;
|
|
if (sk && opt == 1) {
|
|
/* up all refs when opt == 1 */
|
|
for (i = 0; i < wolfSSL_sk_X509_num(sk); i++) {
|
|
x509 = wolfSSL_sk_X509_value(sk, i);
|
|
if (wolfSSL_X509_up_ref(x509) != 1) {
|
|
WOLFSSL_MSG("Error increasing reference count");
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#else
|
|
WOLFSSL_MSG("Session certificates not compiled in");
|
|
ret = WOLFSSL_FAILURE;
|
|
#endif
|
|
break;
|
|
|
|
#if defined(OPENSSL_EXTRA) || defined(HAVE_WEBSERVER)
|
|
case SSL_CTRL_OPTIONS:
|
|
WOLFSSL_MSG("Entering Case: SSL_CTRL_OPTIONS.");
|
|
ctrl_opt = wolfSSL_CTX_set_options(ctx, opt);
|
|
|
|
#ifdef WOLFSSL_QT
|
|
/* Set whether to use client or server cipher preference */
|
|
if ((ctrl_opt & WOLFSSL_OP_CIPHER_SERVER_PREFERENCE)
|
|
== WOLFSSL_OP_CIPHER_SERVER_PREFERENCE) {
|
|
WOLFSSL_MSG("Using Server's Cipher Preference.");
|
|
ctx->useClientOrder = FALSE;
|
|
} else {
|
|
WOLFSSL_MSG("Using Client's Cipher Preference.");
|
|
ctx->useClientOrder = TRUE;
|
|
}
|
|
#endif /* WOLFSSL_QT */
|
|
|
|
return ctrl_opt;
|
|
#endif /* OPENSSL_EXTRA || HAVE_WEBSERVER */
|
|
case SSL_CTRL_EXTRA_CHAIN_CERT:
|
|
WOLFSSL_MSG("Entering Case: SSL_CTRL_EXTRA_CHAIN_CERT.");
|
|
if (pt == NULL) {
|
|
WOLFSSL_MSG("Passed in x509 pointer NULL.");
|
|
ret = WOLFSSL_FAILURE;
|
|
break;
|
|
}
|
|
return wolfSSL_CTX_add_extra_chain_cert(ctx, (WOLFSSL_X509*)pt);
|
|
|
|
#ifndef NO_DH
|
|
case SSL_CTRL_SET_TMP_DH:
|
|
WOLFSSL_MSG("Entering Case: SSL_CTRL_SET_TMP_DH.");
|
|
if (pt == NULL) {
|
|
WOLFSSL_MSG("Passed in DH pointer NULL.");
|
|
ret = WOLFSSL_FAILURE;
|
|
break;
|
|
}
|
|
return wolfSSL_CTX_set_tmp_dh(ctx, (WOLFSSL_DH*)pt);
|
|
#endif
|
|
|
|
#ifdef HAVE_ECC
|
|
case SSL_CTRL_SET_TMP_ECDH:
|
|
WOLFSSL_MSG("Entering Case: SSL_CTRL_SET_TMP_ECDH.");
|
|
if (pt == NULL) {
|
|
WOLFSSL_MSG("Passed in ECDH pointer NULL.");
|
|
ret = WOLFSSL_FAILURE;
|
|
break;
|
|
}
|
|
return wolfSSL_SSL_CTX_set_tmp_ecdh(ctx, (WOLFSSL_EC_KEY*)pt);
|
|
#endif
|
|
case SSL_CTRL_MODE:
|
|
wolfSSL_CTX_set_mode(ctx,opt);
|
|
break;
|
|
case SSL_CTRL_SET_MIN_PROTO_VERSION:
|
|
WOLFSSL_MSG("set min proto version");
|
|
return wolfSSL_CTX_set_min_proto_version(ctx, (int)opt);
|
|
case SSL_CTRL_SET_MAX_PROTO_VERSION:
|
|
WOLFSSL_MSG("set max proto version");
|
|
return wolfSSL_CTX_set_max_proto_version(ctx, (int)opt);
|
|
case SSL_CTRL_GET_MIN_PROTO_VERSION:
|
|
WOLFSSL_MSG("get min proto version");
|
|
return wolfSSL_CTX_get_min_proto_version(ctx);
|
|
case SSL_CTRL_GET_MAX_PROTO_VERSION:
|
|
WOLFSSL_MSG("get max proto version");
|
|
return wolfSSL_CTX_get_max_proto_version(ctx);
|
|
default:
|
|
WOLFSSL_MSG("CTX_ctrl cmd not implemented");
|
|
ret = WOLFSSL_FAILURE;
|
|
break;
|
|
}
|
|
|
|
(void)ctx;
|
|
(void)cmd;
|
|
(void)opt;
|
|
(void)pt;
|
|
WOLFSSL_LEAVE("wolfSSL_CTX_ctrl", (int)ret);
|
|
return ret;
|
|
}
|
|
|
|
#ifndef WOLFSSL_NO_STUB
|
|
long wolfSSL_CTX_callback_ctrl(WOLFSSL_CTX* ctx, int cmd, void (*fp)(void))
|
|
{
|
|
(void) ctx;
|
|
(void) cmd;
|
|
(void) fp;
|
|
WOLFSSL_STUB("wolfSSL_CTX_callback_ctrl");
|
|
return WOLFSSL_FAILURE;
|
|
|
|
}
|
|
#endif /* WOLFSSL_NO_STUB */
|
|
|
|
#ifndef NO_WOLFSSL_STUB
|
|
long wolfSSL_CTX_clear_extra_chain_certs(WOLFSSL_CTX* ctx)
|
|
{
|
|
return wolfSSL_CTX_ctrl(ctx, SSL_CTRL_CLEAR_EXTRA_CHAIN_CERTS, 0L, NULL);
|
|
}
|
|
#endif
|
|
|
|
/* Returns the verifyCallback from the ssl structure if successful.
|
|
Returns NULL otherwise. */
|
|
VerifyCallback wolfSSL_get_verify_callback(WOLFSSL* ssl)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_get_verify_callback");
|
|
if (ssl) {
|
|
return ssl->verifyCallback;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/* Adds the ASN1 certificate to the user ctx.
|
|
Returns WOLFSSL_SUCCESS if no error, returns WOLFSSL_FAILURE otherwise.*/
|
|
int wolfSSL_CTX_use_certificate_ASN1(WOLFSSL_CTX *ctx, int derSz,
|
|
const unsigned char *der)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_use_certificate_ASN1");
|
|
if (der != NULL && ctx != NULL) {
|
|
if (wolfSSL_CTX_use_certificate_buffer(ctx, der, derSz,
|
|
WOLFSSL_FILETYPE_ASN1) == WOLFSSL_SUCCESS) {
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
}
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
|
|
#if !defined(HAVE_FAST_RSA) && defined(WOLFSSL_KEY_GEN) && \
|
|
!defined(NO_RSA) && !defined(HAVE_USER_RSA)
|
|
/* Adds the rsa private key to the user ctx.
|
|
Returns WOLFSSL_SUCCESS if no error, returns WOLFSSL_FAILURE otherwise.*/
|
|
int wolfSSL_CTX_use_RSAPrivateKey(WOLFSSL_CTX* ctx, WOLFSSL_RSA* rsa)
|
|
{
|
|
int ret;
|
|
int derSize;
|
|
unsigned char *maxDerBuf;
|
|
unsigned char* key = NULL;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_CTX_use_RSAPrivateKey");
|
|
|
|
if (ctx == NULL || rsa == NULL) {
|
|
WOLFSSL_MSG("one or more inputs were NULL");
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
maxDerBuf = (unsigned char*)XMALLOC(4096, NULL, DYNAMIC_TYPE_TMP_BUFFER);
|
|
if (maxDerBuf == NULL) {
|
|
WOLFSSL_MSG("Malloc failure");
|
|
return MEMORY_E;
|
|
}
|
|
key = maxDerBuf;
|
|
/* convert RSA struct to der encoded buffer and get the size */
|
|
if ((derSize = wolfSSL_i2d_RSAPrivateKey(rsa, &key)) <= 0) {
|
|
WOLFSSL_MSG("wolfSSL_i2d_RSAPrivateKey() failure");
|
|
XFREE(maxDerBuf, NULL, DYNAMIC_TYPE_TMP_BUFFER);
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
ret = wolfSSL_CTX_use_PrivateKey_buffer(ctx, (const unsigned char*)maxDerBuf,
|
|
derSize, SSL_FILETYPE_ASN1);
|
|
if (ret != WOLFSSL_SUCCESS) {
|
|
WOLFSSL_MSG("wolfSSL_CTX_USE_PrivateKey_buffer() failure");
|
|
XFREE(maxDerBuf, NULL, DYNAMIC_TYPE_TMP_BUFFER);
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
XFREE(maxDerBuf, NULL, DYNAMIC_TYPE_TMP_BUFFER);
|
|
return ret;
|
|
}
|
|
#endif /* NO_RSA && !HAVE_FAST_RSA */
|
|
|
|
|
|
#ifndef NO_BIO
|
|
/* Converts EVP_PKEY data from a bio buffer to a WOLFSSL_EVP_PKEY structure.
|
|
Returns pointer to private EVP_PKEY struct upon success, NULL if there
|
|
is a failure.*/
|
|
WOLFSSL_EVP_PKEY* wolfSSL_d2i_PrivateKey_bio(WOLFSSL_BIO* bio,
|
|
WOLFSSL_EVP_PKEY** out)
|
|
{
|
|
unsigned char* mem = NULL;
|
|
int memSz = 0;
|
|
WOLFSSL_EVP_PKEY* key = NULL;
|
|
unsigned char* extraBioMem = NULL;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_d2i_PrivateKey_bio");
|
|
|
|
if (bio == NULL) {
|
|
return NULL;
|
|
}
|
|
(void)out;
|
|
|
|
memSz = wolfSSL_BIO_get_len(bio);
|
|
if (memSz <= 0) {
|
|
WOLFSSL_MSG("wolfSSL_BIO_get_len() failure");
|
|
return NULL;
|
|
}
|
|
|
|
mem = (unsigned char*)XMALLOC(memSz, bio->heap, DYNAMIC_TYPE_TMP_BUFFER);
|
|
if (mem == NULL) {
|
|
WOLFSSL_MSG("Malloc failure");
|
|
return NULL;
|
|
}
|
|
|
|
if (wolfSSL_BIO_read(bio, (unsigned char*)mem, memSz) == memSz) {
|
|
int extraBioMemSz;
|
|
int derLength;
|
|
|
|
/* Determines key type and returns the new private EVP_PKEY object */
|
|
if ((key = wolfSSL_d2i_PrivateKey_EVP(NULL, &mem, (long)memSz)) == NULL) {
|
|
WOLFSSL_MSG("wolfSSL_d2i_PrivateKey_EVP() failure");
|
|
XFREE(mem, bio->heap, DYNAMIC_TYPE_TMP_BUFFER);
|
|
return NULL;
|
|
}
|
|
|
|
/* Write extra data back into bio object if necessary. */
|
|
derLength = key->pkey_sz;
|
|
extraBioMemSz = (memSz - derLength);
|
|
if (extraBioMemSz > 0) {
|
|
int i;
|
|
int j = 0;
|
|
|
|
extraBioMem = (unsigned char *)XMALLOC(extraBioMemSz, NULL,
|
|
DYNAMIC_TYPE_TMP_BUFFER);
|
|
if (extraBioMem == NULL) {
|
|
WOLFSSL_MSG("Malloc failure");
|
|
XFREE((unsigned char*)extraBioMem, bio->heap,
|
|
DYNAMIC_TYPE_TMP_BUFFER);
|
|
XFREE(mem, bio->heap, DYNAMIC_TYPE_TMP_BUFFER);
|
|
return NULL;
|
|
}
|
|
|
|
for (i = derLength; i < memSz; i++) {
|
|
*(extraBioMem + j) = *(mem + i);
|
|
j++;
|
|
}
|
|
|
|
wolfSSL_BIO_write(bio, extraBioMem, extraBioMemSz);
|
|
if (wolfSSL_BIO_get_len(bio) <= 0) {
|
|
WOLFSSL_MSG("Failed to write memory to bio");
|
|
XFREE((unsigned char*)extraBioMem, bio->heap,
|
|
DYNAMIC_TYPE_TMP_BUFFER);
|
|
XFREE(mem, bio->heap, DYNAMIC_TYPE_TMP_BUFFER);
|
|
return NULL;
|
|
}
|
|
XFREE((unsigned char*)extraBioMem, bio->heap,
|
|
DYNAMIC_TYPE_TMP_BUFFER);
|
|
}
|
|
|
|
if (out != NULL) {
|
|
*out = key;
|
|
}
|
|
}
|
|
XFREE(mem, bio->heap, DYNAMIC_TYPE_TMP_BUFFER);
|
|
return key;
|
|
}
|
|
#endif /* !NO_BIO */
|
|
|
|
#endif /* OPENSSL_ALL || WOLFSSL_ASIO || WOLFSSL_HAPROXY || WOLFSSL_QT */
|
|
|
|
|
|
#if defined(OPENSSL_ALL) || defined(WOLFSSL_ASIO) || defined(WOLFSSL_HAPROXY) || \
|
|
defined(WOLFSSL_NGINX) || defined(WOLFSSL_QT) || defined(WOLFSSL_WPAS_SMALL)
|
|
|
|
/* Converts a DER encoded private key to a WOLFSSL_EVP_PKEY structure.
|
|
* returns a pointer to a new WOLFSSL_EVP_PKEY structure on success and NULL
|
|
* on fail */
|
|
WOLFSSL_EVP_PKEY* wolfSSL_d2i_PrivateKey_EVP(WOLFSSL_EVP_PKEY** out,
|
|
unsigned char** in, long inSz)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_d2i_PrivateKey_EVP");
|
|
return d2iGenericKey(out, (const unsigned char**)in, inSz, 1);
|
|
}
|
|
|
|
#endif /* OPENSSL_ALL || WOLFSSL_ASIO || WOLFSSL_HAPROXY || WOLFSSL_QT || WOLFSSL_WPAS_SMALL*/
|
|
|
|
|
|
/* stunnel compatibility functions*/
|
|
#if defined(OPENSSL_ALL) || (defined(OPENSSL_EXTRA) && (defined(HAVE_STUNNEL) || \
|
|
defined(WOLFSSL_NGINX) || defined(HAVE_LIGHTY) || \
|
|
defined(WOLFSSL_HAPROXY) || defined(WOLFSSL_OPENSSH)))
|
|
void wolfSSL_ERR_remove_thread_state(void* pid)
|
|
{
|
|
(void) pid;
|
|
return;
|
|
}
|
|
|
|
#ifndef NO_FILESYSTEM
|
|
/***TBD ***/
|
|
void wolfSSL_print_all_errors_fp(XFILE fp)
|
|
{
|
|
(void)fp;
|
|
}
|
|
#endif /* !NO_FILESYSTEM */
|
|
|
|
#endif /* OPENSSL_ALL || OPENSSL_EXTRA || HAVE_STUNNEL || WOLFSSL_NGINX ||
|
|
HAVE_LIGHTY || WOLFSSL_HAPROXY || WOLFSSL_OPENSSH */
|
|
|
|
|
|
#if defined(OPENSSL_EXTRA) || defined(WOLFSSL_WPAS_SMALL) || \
|
|
defined(HAVE_EX_DATA)
|
|
|
|
#if defined(HAVE_EX_DATA) && !defined(NO_SESSION_CACHE)
|
|
static void SESSION_ex_data_cache_update(WOLFSSL_SESSION* session, int idx,
|
|
void* data, byte get, void** getRet, int* setRet)
|
|
{
|
|
int row;
|
|
int i;
|
|
int error = 0;
|
|
SessionRow* sessRow = NULL;
|
|
const byte* id;
|
|
byte foundCache = 0;
|
|
|
|
if (getRet != NULL)
|
|
*getRet = NULL;
|
|
if (setRet != NULL)
|
|
*setRet = WOLFSSL_FAILURE;
|
|
|
|
id = session->sessionID;
|
|
if (session->haveAltSessionID)
|
|
id = session->altSessionID;
|
|
|
|
row = (int)(HashObject(id, ID_LEN, &error) % SESSION_ROWS);
|
|
if (error != 0) {
|
|
WOLFSSL_MSG("Hash session failed");
|
|
return;
|
|
}
|
|
|
|
sessRow = &SessionCache[row];
|
|
if (get)
|
|
error = SESSION_ROW_RD_LOCK(sessRow);
|
|
else
|
|
error = SESSION_ROW_WR_LOCK(sessRow);
|
|
if (error != 0) {
|
|
WOLFSSL_MSG("Session row lock failed");
|
|
return;
|
|
}
|
|
|
|
for (i = 0; i < SESSIONS_PER_ROW && i < sessRow->totalCount; i++) {
|
|
WOLFSSL_SESSION* cacheSession;
|
|
#ifdef SESSION_CACHE_DYNAMIC_MEM
|
|
cacheSession = sessRow->Sessions[i];
|
|
#else
|
|
cacheSession = &sessRow->Sessions[i];
|
|
#endif
|
|
if (cacheSession &&
|
|
XMEMCMP(id, cacheSession->sessionID, ID_LEN) == 0
|
|
&& session->side == cacheSession->side
|
|
#if defined(WOLFSSL_TLS13) && defined(HAVE_SESSION_TICKET)
|
|
&& (IsAtLeastTLSv1_3(session->version) ==
|
|
IsAtLeastTLSv1_3(cacheSession->version))
|
|
#endif
|
|
) {
|
|
if (get) {
|
|
if (getRet) {
|
|
*getRet = wolfSSL_CRYPTO_get_ex_data(
|
|
&cacheSession->ex_data, idx);
|
|
}
|
|
}
|
|
else {
|
|
if (setRet) {
|
|
*setRet = wolfSSL_CRYPTO_set_ex_data(
|
|
&cacheSession->ex_data, idx, data);
|
|
}
|
|
}
|
|
foundCache = 1;
|
|
break;
|
|
}
|
|
}
|
|
SESSION_ROW_UNLOCK(sessRow);
|
|
/* If we don't have a session in cache then clear the ex_data and
|
|
* own it */
|
|
if (!foundCache) {
|
|
XMEMSET(&session->ex_data, 0, sizeof(WOLFSSL_CRYPTO_EX_DATA));
|
|
session->ownExData = 1;
|
|
if (!get) {
|
|
*setRet = wolfSSL_CRYPTO_set_ex_data(&session->ex_data, idx,
|
|
data);
|
|
}
|
|
}
|
|
|
|
}
|
|
#endif
|
|
|
|
int wolfSSL_SESSION_set_ex_data(WOLFSSL_SESSION* session, int idx, void* data)
|
|
{
|
|
int ret = WOLFSSL_FAILURE;
|
|
WOLFSSL_ENTER("wolfSSL_SESSION_set_ex_data");
|
|
#ifdef HAVE_EX_DATA
|
|
session = ClientSessionToSession(session);
|
|
if (session != NULL) {
|
|
#ifndef NO_SESSION_CACHE
|
|
if (!session->ownExData) {
|
|
/* Need to update in cache */
|
|
SESSION_ex_data_cache_update(session, idx, data, 0, NULL, &ret);
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
ret = wolfSSL_CRYPTO_set_ex_data(&session->ex_data, idx, data);
|
|
}
|
|
}
|
|
#else
|
|
(void)session;
|
|
(void)idx;
|
|
(void)data;
|
|
#endif
|
|
return ret;
|
|
}
|
|
|
|
#ifdef HAVE_EX_DATA_CLEANUP_HOOKS
|
|
int wolfSSL_SESSION_set_ex_data_with_cleanup(
|
|
WOLFSSL_SESSION* session,
|
|
int idx,
|
|
void* data,
|
|
wolfSSL_ex_data_cleanup_routine_t cleanup_routine)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_SESSION_set_ex_data_with_cleanup");
|
|
session = ClientSessionToSession(session);
|
|
if(session != NULL) {
|
|
return wolfSSL_CRYPTO_set_ex_data_with_cleanup(&session->ex_data, idx,
|
|
data, cleanup_routine);
|
|
}
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
#endif /* HAVE_EX_DATA_CLEANUP_HOOKS */
|
|
|
|
void* wolfSSL_SESSION_get_ex_data(const WOLFSSL_SESSION* session, int idx)
|
|
{
|
|
void* ret = NULL;
|
|
WOLFSSL_ENTER("wolfSSL_SESSION_get_ex_data");
|
|
#ifdef HAVE_EX_DATA
|
|
session = ClientSessionToSession(session);
|
|
if (session != NULL) {
|
|
#ifndef NO_SESSION_CACHE
|
|
if (!session->ownExData) {
|
|
/* Need to retrieve the data from the session cache */
|
|
SESSION_ex_data_cache_update((WOLFSSL_SESSION*)session, idx, NULL,
|
|
1, &ret, NULL);
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
ret = wolfSSL_CRYPTO_get_ex_data(&session->ex_data, idx);
|
|
}
|
|
}
|
|
#else
|
|
(void)session;
|
|
(void)idx;
|
|
#endif
|
|
return ret;
|
|
}
|
|
#endif /* OPENSSL_EXTRA || WOLFSSL_WPAS_SMALL || HAVE_EX_DATA */
|
|
|
|
/* Note: This is a huge section of API's - through
|
|
* wolfSSL_X509_OBJECT_get0_X509_CRL */
|
|
#if defined(OPENSSL_ALL) || (defined(OPENSSL_EXTRA) && \
|
|
(defined(HAVE_STUNNEL) || defined(WOLFSSL_NGINX) || \
|
|
defined(HAVE_LIGHTY) || defined(WOLFSSL_HAPROXY) || \
|
|
defined(WOLFSSL_OPENSSH) || defined(HAVE_SBLIM_SFCB)))
|
|
#ifdef HAVE_EX_DATA
|
|
int wolfSSL_SESSION_get_ex_new_index(long ctx_l,void* ctx_ptr,
|
|
WOLFSSL_CRYPTO_EX_new* new_func, WOLFSSL_CRYPTO_EX_dup* dup_func,
|
|
WOLFSSL_CRYPTO_EX_free* free_func)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_SESSION_get_ex_new_index");
|
|
return wolfssl_get_ex_new_index(WOLF_CRYPTO_EX_INDEX_SSL_SESSION, ctx_l,
|
|
ctx_ptr, new_func, dup_func, free_func);
|
|
}
|
|
#endif
|
|
|
|
#if defined(USE_WOLFSSL_MEMORY) && !defined(WOLFSSL_DEBUG_MEMORY) && \
|
|
!defined(WOLFSSL_STATIC_MEMORY)
|
|
static wolfSSL_OSSL_Malloc_cb ossl_malloc = NULL;
|
|
static wolfSSL_OSSL_Free_cb ossl_free = NULL;
|
|
static wolfSSL_OSSL_Realloc_cb ossl_realloc = NULL;
|
|
|
|
static void* OSSL_Malloc(size_t size)
|
|
{
|
|
if (ossl_malloc != NULL)
|
|
return ossl_malloc(size, NULL, 0);
|
|
else
|
|
return NULL;
|
|
}
|
|
|
|
static void OSSL_Free(void *ptr)
|
|
{
|
|
if (ossl_free != NULL)
|
|
ossl_free(ptr, NULL, 0);
|
|
}
|
|
|
|
static void* OSSL_Realloc(void *ptr, size_t size)
|
|
{
|
|
if (ossl_realloc != NULL)
|
|
return ossl_realloc(ptr, size, NULL, 0);
|
|
else
|
|
return NULL;
|
|
}
|
|
#endif /* USE_WOLFSSL_MEMORY && !WOLFSSL_DEBUG_MEMORY &&
|
|
* !WOLFSSL_STATIC_MEMORY */
|
|
|
|
int wolfSSL_CRYPTO_set_mem_functions(
|
|
wolfSSL_OSSL_Malloc_cb m,
|
|
wolfSSL_OSSL_Realloc_cb r,
|
|
wolfSSL_OSSL_Free_cb f)
|
|
{
|
|
#if defined(USE_WOLFSSL_MEMORY) && !defined(WOLFSSL_STATIC_MEMORY)
|
|
#ifdef WOLFSSL_DEBUG_MEMORY
|
|
WOLFSSL_MSG("mem functions will receive function name instead of "
|
|
"file name");
|
|
if (wolfSSL_SetAllocators((wolfSSL_Malloc_cb)m, (wolfSSL_Free_cb)f,
|
|
(wolfSSL_Realloc_cb)r) == 0)
|
|
return WOLFSSL_SUCCESS;
|
|
#else
|
|
WOLFSSL_MSG("wolfSSL was compiled without WOLFSSL_DEBUG_MEMORY mem "
|
|
"functions will receive a NULL file name and 0 for the "
|
|
"line number.");
|
|
if (wolfSSL_SetAllocators((wolfSSL_Malloc_cb)OSSL_Malloc,
|
|
(wolfSSL_Free_cb)OSSL_Free, (wolfSSL_Realloc_cb)OSSL_Realloc) == 0) {
|
|
ossl_malloc = m;
|
|
ossl_free = f;
|
|
ossl_realloc = r;
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
#endif
|
|
else
|
|
return WOLFSSL_FAILURE;
|
|
#else
|
|
(void)m;
|
|
(void)r;
|
|
(void)f;
|
|
WOLFSSL_MSG("wolfSSL allocator callback functions not compiled in");
|
|
return WOLFSSL_FAILURE;
|
|
#endif
|
|
}
|
|
|
|
int wolfSSL_ERR_load_ERR_strings(void)
|
|
{
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
void wolfSSL_ERR_load_crypto_strings(void)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_ERR_load_crypto_strings");
|
|
/* Do nothing */
|
|
return;
|
|
}
|
|
|
|
int wolfSSL_FIPS_mode(void)
|
|
{
|
|
#ifdef HAVE_FIPS
|
|
return 1;
|
|
#else
|
|
return 0;
|
|
#endif
|
|
}
|
|
|
|
int wolfSSL_FIPS_mode_set(int r)
|
|
{
|
|
#ifdef HAVE_FIPS
|
|
if (r == 0) {
|
|
WOLFSSL_MSG("Cannot disable FIPS at runtime.");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
return WOLFSSL_SUCCESS;
|
|
#else
|
|
if (r == 0) {
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
WOLFSSL_MSG("Cannot enable FIPS. This isn't the wolfSSL FIPS code.");
|
|
return WOLFSSL_FAILURE;
|
|
#endif
|
|
}
|
|
|
|
int wolfSSL_CIPHER_get_bits(const WOLFSSL_CIPHER *c, int *alg_bits)
|
|
{
|
|
int ret = WOLFSSL_FAILURE;
|
|
WOLFSSL_ENTER("wolfSSL_CIPHER_get_bits");
|
|
|
|
#if defined(WOLFSSL_QT) || defined(OPENSSL_ALL)
|
|
(void)alg_bits;
|
|
if (c!= NULL)
|
|
ret = c->bits;
|
|
#else
|
|
if (c != NULL && c->ssl != NULL) {
|
|
ret = 8 * c->ssl->specs.key_size;
|
|
if (alg_bits != NULL) {
|
|
*alg_bits = ret;
|
|
}
|
|
}
|
|
#endif
|
|
return ret;
|
|
}
|
|
|
|
/* returns value less than 0 on fail to match
|
|
* On a successful match the priority level found is returned
|
|
*/
|
|
int wolfSSL_sk_SSL_CIPHER_find(
|
|
WOLF_STACK_OF(WOLFSSL_CIPHER)* sk, const WOLFSSL_CIPHER* toFind)
|
|
{
|
|
WOLFSSL_STACK* next;
|
|
int i, sz;
|
|
|
|
if (sk == NULL || toFind == NULL) {
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
|
|
sz = wolfSSL_sk_SSL_CIPHER_num(sk);
|
|
next = sk;
|
|
for (i = 0; i < sz && next != NULL; i++) {
|
|
if (next->data.cipher.cipherSuite0 == toFind->cipherSuite0 &&
|
|
next->data.cipher.cipherSuite == toFind->cipherSuite) {
|
|
return sz - i; /* reverse because stack pushed highest on first */
|
|
}
|
|
next = next->next;
|
|
}
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
|
|
/* free's all nodes in the stack and there data */
|
|
void wolfSSL_sk_SSL_CIPHER_free(WOLF_STACK_OF(WOLFSSL_CIPHER)* sk)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_sk_SSL_CIPHER_free");
|
|
wolfSSL_sk_free(sk);
|
|
}
|
|
|
|
#ifdef HAVE_SNI
|
|
int wolfSSL_set_tlsext_host_name(WOLFSSL* ssl, const char* host_name)
|
|
{
|
|
int ret;
|
|
WOLFSSL_ENTER("wolfSSL_set_tlsext_host_name");
|
|
ret = wolfSSL_UseSNI(ssl, WOLFSSL_SNI_HOST_NAME,
|
|
host_name, (word16)XSTRLEN(host_name));
|
|
WOLFSSL_LEAVE("wolfSSL_set_tlsext_host_name", ret);
|
|
return ret;
|
|
}
|
|
|
|
|
|
#ifndef NO_WOLFSSL_SERVER
|
|
const char * wolfSSL_get_servername(WOLFSSL* ssl, byte type)
|
|
{
|
|
void * serverName = NULL;
|
|
if (ssl == NULL)
|
|
return NULL;
|
|
TLSX_SNI_GetRequest(ssl->extensions, type, &serverName);
|
|
return (const char *)serverName;
|
|
}
|
|
#endif /* NO_WOLFSSL_SERVER */
|
|
#endif /* HAVE_SNI */
|
|
|
|
WOLFSSL_CTX* wolfSSL_set_SSL_CTX(WOLFSSL* ssl, WOLFSSL_CTX* ctx)
|
|
{
|
|
int ret;
|
|
/* This method requires some explanation. Its sibling is
|
|
* int SetSSL_CTX(WOLFSSL* ssl, WOLFSSL_CTX* ctx, int writeDup)
|
|
* which re-inits the WOLFSSL* with all settings in the new CTX.
|
|
* That one is the right one to use *before* a handshake is started.
|
|
*
|
|
* This method was added by OpenSSL to be used *during* the handshake, e.g.
|
|
* when a server inspects the SNI in a ClientHello callback and
|
|
* decides which set of certificates to use.
|
|
*
|
|
* Since, at the time the SNI callback is run, some decisions on
|
|
* Extensions or the ServerHello might already have been taken, this
|
|
* method is very restricted in what it does:
|
|
* - changing the server certificate(s)
|
|
* - changing the server id for session handling
|
|
* and everything else in WOLFSSL* needs to remain untouched.
|
|
*/
|
|
WOLFSSL_ENTER("wolfSSL_set_SSL_CTX");
|
|
if (ssl == NULL || ctx == NULL)
|
|
return NULL;
|
|
if (ssl->ctx == ctx)
|
|
return ssl->ctx;
|
|
|
|
wolfSSL_RefInc(&ctx->ref, &ret);
|
|
#ifdef WOLFSSL_REFCNT_ERROR_RETURN
|
|
if (ret != 0) {
|
|
/* can only fail on serious stuff, like mutex not working
|
|
* or ctx refcount out of whack. */
|
|
return NULL;
|
|
}
|
|
#else
|
|
(void)ret;
|
|
#endif
|
|
if (ssl->ctx != NULL)
|
|
wolfSSL_CTX_free(ssl->ctx);
|
|
ssl->ctx = ctx;
|
|
|
|
#ifndef NO_CERTS
|
|
/* ctx owns certificate, certChain and key */
|
|
ssl->buffers.certificate = ctx->certificate;
|
|
ssl->buffers.certChain = ctx->certChain;
|
|
#ifdef WOLFSSL_TLS13
|
|
ssl->buffers.certChainCnt = ctx->certChainCnt;
|
|
#endif
|
|
ssl->buffers.key = ctx->privateKey;
|
|
ssl->buffers.keyType = ctx->privateKeyType;
|
|
ssl->buffers.keyId = ctx->privateKeyId;
|
|
ssl->buffers.keyLabel = ctx->privateKeyLabel;
|
|
ssl->buffers.keySz = ctx->privateKeySz;
|
|
ssl->buffers.keyDevId = ctx->privateKeyDevId;
|
|
/* flags indicating what certs/keys are available */
|
|
ssl->options.haveRSA = ctx->haveRSA;
|
|
ssl->options.haveDH = ctx->haveDH;
|
|
ssl->options.haveECDSAsig = ctx->haveECDSAsig;
|
|
ssl->options.haveECC = ctx->haveECC;
|
|
ssl->options.haveStaticECC = ctx->haveStaticECC;
|
|
ssl->options.haveFalconSig = ctx->haveFalconSig;
|
|
ssl->options.haveDilithiumSig = ctx->haveDilithiumSig;
|
|
#endif
|
|
|
|
#ifdef WOLFSSL_SESSION_ID_CTX
|
|
/* copy over application session context ID */
|
|
ssl->sessionCtxSz = ctx->sessionCtxSz;
|
|
XMEMCPY(ssl->sessionCtx, ctx->sessionCtx, ctx->sessionCtxSz);
|
|
#endif
|
|
|
|
return ssl->ctx;
|
|
}
|
|
|
|
|
|
VerifyCallback wolfSSL_CTX_get_verify_callback(WOLFSSL_CTX* ctx)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_get_verify_callback");
|
|
if(ctx)
|
|
return ctx->verifyCallback;
|
|
return NULL;
|
|
}
|
|
|
|
|
|
#ifdef HAVE_SNI
|
|
|
|
void wolfSSL_CTX_set_servername_callback(WOLFSSL_CTX* ctx, CallbackSniRecv cb)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_set_servername_callback");
|
|
if (ctx)
|
|
ctx->sniRecvCb = cb;
|
|
}
|
|
|
|
int wolfSSL_CTX_set_tlsext_servername_callback(WOLFSSL_CTX* ctx,
|
|
CallbackSniRecv cb)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_set_tlsext_servername_callback");
|
|
if (ctx) {
|
|
ctx->sniRecvCb = cb;
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
int wolfSSL_CTX_set_servername_arg(WOLFSSL_CTX* ctx, void* arg)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_set_servername_arg");
|
|
if (ctx) {
|
|
ctx->sniRecvCbArg = arg;
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
#endif /* HAVE_SNI */
|
|
|
|
|
|
#ifndef NO_BIO
|
|
void wolfSSL_ERR_load_BIO_strings(void) {
|
|
WOLFSSL_ENTER("wolfSSL_ERR_load_BIO_strings");
|
|
/* do nothing */
|
|
}
|
|
#endif
|
|
|
|
#ifndef NO_WOLFSSL_STUB
|
|
/* Set THREADID callback, return 1 on success, 0 on error */
|
|
int wolfSSL_THREADID_set_callback(
|
|
void(*threadid_func)(WOLFSSL_CRYPTO_THREADID*))
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_THREADID_set_callback");
|
|
WOLFSSL_STUB("CRYPTO_THREADID_set_callback");
|
|
(void)threadid_func;
|
|
return 1;
|
|
}
|
|
#endif
|
|
|
|
#ifndef NO_WOLFSSL_STUB
|
|
void wolfSSL_THREADID_set_numeric(void* id, unsigned long val)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_THREADID_set_numeric");
|
|
WOLFSSL_STUB("CRYPTO_THREADID_set_numeric");
|
|
(void)id;
|
|
(void)val;
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
#endif /* OPENSSL_ALL || (OPENSSL_EXTRA && (HAVE_STUNNEL || WOLFSSL_NGINX ||
|
|
* HAVE_LIGHTY || WOLFSSL_HAPROXY || WOLFSSL_OPENSSH ||
|
|
* HAVE_SBLIM_SFCB)) */
|
|
|
|
|
|
#if defined(OPENSSL_EXTRA)
|
|
|
|
int wolfSSL_CRYPTO_memcmp(const void *a, const void *b, size_t size)
|
|
{
|
|
if (!a || !b)
|
|
return 0;
|
|
return ConstantCompare((const byte*)a, (const byte*)b, (int)size);
|
|
}
|
|
|
|
unsigned long wolfSSL_ERR_peek_last_error(void)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_ERR_peek_last_error");
|
|
|
|
#ifdef WOLFSSL_HAVE_ERROR_QUEUE
|
|
{
|
|
int ret;
|
|
|
|
if ((ret = wc_PeekErrorNode(-1, NULL, NULL, NULL)) < 0) {
|
|
WOLFSSL_MSG("Issue peeking at error node in queue");
|
|
return 0;
|
|
}
|
|
if (ret == -ASN_NO_PEM_HEADER)
|
|
return (ERR_LIB_PEM << 24) | PEM_R_NO_START_LINE;
|
|
#if defined(WOLFSSL_PYTHON)
|
|
if (ret == ASN1_R_HEADER_TOO_LONG)
|
|
return (ERR_LIB_ASN1 << 24) | ASN1_R_HEADER_TOO_LONG;
|
|
#endif
|
|
return (unsigned long)ret;
|
|
}
|
|
#else
|
|
return (unsigned long)(0 - NOT_COMPILED_IN);
|
|
#endif
|
|
}
|
|
|
|
#endif /* OPENSSL_EXTRA */
|
|
|
|
int wolfSSL_version(WOLFSSL* ssl)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_version");
|
|
if (ssl->version.major == SSLv3_MAJOR) {
|
|
switch (ssl->version.minor) {
|
|
case SSLv3_MINOR :
|
|
return SSL3_VERSION;
|
|
case TLSv1_MINOR :
|
|
return TLS1_VERSION;
|
|
case TLSv1_1_MINOR :
|
|
return TLS1_1_VERSION;
|
|
case TLSv1_2_MINOR :
|
|
return TLS1_2_VERSION;
|
|
case TLSv1_3_MINOR :
|
|
return TLS1_3_VERSION;
|
|
default:
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
}
|
|
else if (ssl->version.major == DTLS_MAJOR) {
|
|
switch (ssl->version.minor) {
|
|
case DTLS_MINOR :
|
|
return DTLS1_VERSION;
|
|
case DTLSv1_2_MINOR :
|
|
return DTLS1_2_VERSION;
|
|
case DTLSv1_3_MINOR:
|
|
return DTLS1_3_VERSION;
|
|
default:
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
}
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
WOLFSSL_CTX* wolfSSL_get_SSL_CTX(WOLFSSL* ssl)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_get_SSL_CTX");
|
|
return ssl->ctx;
|
|
}
|
|
|
|
#if defined(OPENSSL_ALL) || \
|
|
defined(OPENSSL_EXTRA) || defined(HAVE_STUNNEL) || \
|
|
defined(WOLFSSL_NGINX) || defined(WOLFSSL_HAPROXY)
|
|
|
|
const byte* wolfSSL_SESSION_get_id(const WOLFSSL_SESSION* sess,
|
|
unsigned int* idLen)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_SESSION_get_id");
|
|
sess = ClientSessionToSession(sess);
|
|
if (sess == NULL || idLen == NULL) {
|
|
WOLFSSL_MSG("Bad func args. Please provide idLen");
|
|
return NULL;
|
|
}
|
|
#ifdef HAVE_SESSION_TICKET
|
|
if (sess->haveAltSessionID) {
|
|
*idLen = ID_LEN;
|
|
return sess->altSessionID;
|
|
}
|
|
#endif
|
|
*idLen = sess->sessionIDSz;
|
|
return sess->sessionID;
|
|
}
|
|
|
|
#if (defined(HAVE_SESSION_TICKET) || defined(SESSION_CERTS)) && \
|
|
!defined(NO_FILESYSTEM)
|
|
|
|
#ifndef NO_BIO
|
|
|
|
#if defined(SESSION_CERTS) || \
|
|
(defined(WOLFSSL_TLS13) && defined(HAVE_SESSION_TICKET))
|
|
/* returns a pointer to the protocol used by the session */
|
|
static const char* wolfSSL_SESSION_get_protocol(const WOLFSSL_SESSION* in)
|
|
{
|
|
in = ClientSessionToSession(in);
|
|
return wolfSSL_internal_get_version((ProtocolVersion*)&in->version);
|
|
}
|
|
#endif
|
|
|
|
/* returns true (non 0) if the session has EMS (extended master secret) */
|
|
static int wolfSSL_SESSION_haveEMS(const WOLFSSL_SESSION* in)
|
|
{
|
|
in = ClientSessionToSession(in);
|
|
if (in == NULL)
|
|
return 0;
|
|
return in->haveEMS;
|
|
}
|
|
|
|
#if defined(HAVE_SESSION_TICKET)
|
|
/* prints out the ticket to bio passed in
|
|
* return WOLFSSL_SUCCESS on success
|
|
*/
|
|
static int wolfSSL_SESSION_print_ticket(WOLFSSL_BIO* bio,
|
|
const WOLFSSL_SESSION* in, const char* tab)
|
|
{
|
|
unsigned short i, j, z, sz;
|
|
short tag = 0;
|
|
byte* pt;
|
|
|
|
|
|
in = ClientSessionToSession(in);
|
|
if (in == NULL || bio == NULL) {
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
sz = in->ticketLen;
|
|
pt = in->ticket;
|
|
|
|
if (wolfSSL_BIO_printf(bio, "%s\n", (sz == 0)? " NONE": "") <= 0)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
for (i = 0; i < sz;) {
|
|
char asc[16];
|
|
|
|
if (sz - i < 16) {
|
|
if (wolfSSL_BIO_printf(bio, "%s%04X -", tab, tag + (sz - i)) <= 0)
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
else {
|
|
if (wolfSSL_BIO_printf(bio, "%s%04X -", tab, tag) <= 0)
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
for (j = 0; i < sz && j < 8; j++,i++) {
|
|
asc[j] = ((pt[i])&0x6f)>='A'?((pt[i])&0x6f):'.';
|
|
if (wolfSSL_BIO_printf(bio, " %02X", pt[i]) <= 0)
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
if (i < sz) {
|
|
asc[j] = ((pt[i])&0x6f)>='A'?((pt[i])&0x6f):'.';
|
|
if (wolfSSL_BIO_printf(bio, "-%02X", pt[i]) <= 0)
|
|
return WOLFSSL_FAILURE;
|
|
j++;
|
|
i++;
|
|
}
|
|
|
|
for (; i < sz && j < 16; j++,i++) {
|
|
asc[j] = ((pt[i])&0x6f)>='A'?((pt[i])&0x6f):'.';
|
|
if (wolfSSL_BIO_printf(bio, " %02X", pt[i]) <= 0)
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
/* pad out spacing */
|
|
for (z = j; z < 17; z++) {
|
|
if (wolfSSL_BIO_printf(bio, " ") <= 0)
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
for (z = 0; z < j; z++) {
|
|
if (wolfSSL_BIO_printf(bio, "%c", asc[z]) <= 0)
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
if (wolfSSL_BIO_printf(bio, "\n") <= 0)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
tag += 16;
|
|
}
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
#endif /* HAVE_SESSION_TICKET */
|
|
|
|
|
|
/* prints out the session information in human readable form
|
|
* return WOLFSSL_SUCCESS on success
|
|
*/
|
|
int wolfSSL_SESSION_print(WOLFSSL_BIO *bp, const WOLFSSL_SESSION *session)
|
|
{
|
|
const unsigned char* pt;
|
|
unsigned char buf[SECRET_LEN];
|
|
unsigned int sz = 0, i;
|
|
int ret;
|
|
|
|
session = ClientSessionToSession(session);
|
|
if (session == NULL) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
if (wolfSSL_BIO_printf(bp, "%s\n", "SSL-Session:") <= 0)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
#if defined(SESSION_CERTS) || (defined(WOLFSSL_TLS13) && \
|
|
defined(HAVE_SESSION_TICKET))
|
|
if (wolfSSL_BIO_printf(bp, " Protocol : %s\n",
|
|
wolfSSL_SESSION_get_protocol(session)) <= 0)
|
|
return WOLFSSL_FAILURE;
|
|
#endif
|
|
|
|
if (wolfSSL_BIO_printf(bp, " Cipher : %s\n",
|
|
wolfSSL_SESSION_CIPHER_get_name(session)) <= 0)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
pt = wolfSSL_SESSION_get_id(session, &sz);
|
|
if (wolfSSL_BIO_printf(bp, " Session-ID: ") <= 0)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
for (i = 0; i < sz; i++) {
|
|
if (wolfSSL_BIO_printf(bp, "%02X", pt[i]) <= 0)
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
if (wolfSSL_BIO_printf(bp, "\n") <= 0)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
if (wolfSSL_BIO_printf(bp, " Session-ID-ctx: \n") <= 0)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
ret = wolfSSL_SESSION_get_master_key(session, buf, sizeof(buf));
|
|
if (wolfSSL_BIO_printf(bp, " Master-Key: ") <= 0)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
if (ret > 0) {
|
|
sz = (unsigned int)ret;
|
|
for (i = 0; i < sz; i++) {
|
|
if (wolfSSL_BIO_printf(bp, "%02X", buf[i]) <= 0)
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
}
|
|
if (wolfSSL_BIO_printf(bp, "\n") <= 0)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
/* @TODO PSK identity hint and SRP */
|
|
|
|
if (wolfSSL_BIO_printf(bp, " TLS session ticket:") <= 0)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
#ifdef HAVE_SESSION_TICKET
|
|
if (wolfSSL_SESSION_print_ticket(bp, session, " ") != WOLFSSL_SUCCESS)
|
|
return WOLFSSL_FAILURE;
|
|
#endif
|
|
|
|
#if !defined(NO_SESSION_CACHE) && (defined(OPENSSL_EXTRA) || \
|
|
defined(HAVE_EXT_CACHE))
|
|
if (wolfSSL_BIO_printf(bp, " Start Time: %ld\n",
|
|
wolfSSL_SESSION_get_time(session)) <= 0)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
if (wolfSSL_BIO_printf(bp, " Timeout : %ld (sec)\n",
|
|
wolfSSL_SESSION_get_timeout(session)) <= 0)
|
|
return WOLFSSL_FAILURE;
|
|
#endif /* !NO_SESSION_CACHE && OPENSSL_EXTRA || HAVE_EXT_CACHE */
|
|
|
|
/* @TODO verify return code print */
|
|
|
|
if (wolfSSL_BIO_printf(bp, " Extended master secret: %s\n",
|
|
(wolfSSL_SESSION_haveEMS(session) == 0)? "no" : "yes") <= 0)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
#endif /* !NO_BIO */
|
|
#endif /* (HAVE_SESSION_TICKET || SESSION_CERTS) && !NO_FILESYSTEM */
|
|
|
|
#endif /* OPENSSL_ALL || OPENSSL_EXTRA || HAVE_STUNNEL || WOLFSSL_NGINX || WOLFSSL_HAPROXY */
|
|
|
|
#if defined(OPENSSL_ALL) || (defined(OPENSSL_EXTRA) && defined(HAVE_STUNNEL)) \
|
|
|| defined(WOLFSSL_MYSQL_COMPATIBLE) || defined(WOLFSSL_NGINX)
|
|
|
|
/* TODO: Doesn't currently track SSL_VERIFY_CLIENT_ONCE */
|
|
int wolfSSL_get_verify_mode(const WOLFSSL* ssl) {
|
|
int mode = 0;
|
|
WOLFSSL_ENTER("wolfSSL_get_verify_mode");
|
|
|
|
if (!ssl) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
if (ssl->options.verifyNone) {
|
|
mode = WOLFSSL_VERIFY_NONE;
|
|
}
|
|
else {
|
|
if (ssl->options.verifyPeer) {
|
|
mode |= WOLFSSL_VERIFY_PEER;
|
|
}
|
|
if (ssl->options.failNoCert) {
|
|
mode |= WOLFSSL_VERIFY_FAIL_IF_NO_PEER_CERT;
|
|
}
|
|
if (ssl->options.failNoCertxPSK) {
|
|
mode |= WOLFSSL_VERIFY_FAIL_EXCEPT_PSK;
|
|
}
|
|
#if defined(WOLFSSL_TLS13) && defined(WOLFSSL_POST_HANDSHAKE_AUTH)
|
|
if (ssl->options.verifyPostHandshake) {
|
|
mode |= WOLFSSL_VERIFY_POST_HANDSHAKE;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
WOLFSSL_LEAVE("wolfSSL_get_verify_mode", mode);
|
|
return mode;
|
|
}
|
|
|
|
int wolfSSL_CTX_get_verify_mode(const WOLFSSL_CTX* ctx)
|
|
{
|
|
int mode = 0;
|
|
WOLFSSL_ENTER("wolfSSL_CTX_get_verify_mode");
|
|
|
|
if (!ctx) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
if (ctx->verifyNone) {
|
|
mode = WOLFSSL_VERIFY_NONE;
|
|
}
|
|
else {
|
|
if (ctx->verifyPeer) {
|
|
mode |= WOLFSSL_VERIFY_PEER;
|
|
}
|
|
if (ctx->failNoCert) {
|
|
mode |= WOLFSSL_VERIFY_FAIL_IF_NO_PEER_CERT;
|
|
}
|
|
if (ctx->failNoCertxPSK) {
|
|
mode |= WOLFSSL_VERIFY_FAIL_EXCEPT_PSK;
|
|
}
|
|
#if defined(WOLFSSL_TLS13) && defined(WOLFSSL_POST_HANDSHAKE_AUTH)
|
|
if (ctx->verifyPostHandshake) {
|
|
mode |= WOLFSSL_VERIFY_POST_HANDSHAKE;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
WOLFSSL_LEAVE("wolfSSL_CTX_get_verify_mode", mode);
|
|
return mode;
|
|
}
|
|
|
|
#endif
|
|
#if defined(OPENSSL_EXTRA) && defined(HAVE_CURVE25519)
|
|
/* return 1 if success, 0 if error
|
|
* output keys are little endian format
|
|
*/
|
|
int wolfSSL_EC25519_generate_key(unsigned char *priv, unsigned int *privSz,
|
|
unsigned char *pub, unsigned int *pubSz)
|
|
{
|
|
#ifndef WOLFSSL_KEY_GEN
|
|
WOLFSSL_MSG("No Key Gen built in");
|
|
(void) priv;
|
|
(void) privSz;
|
|
(void) pub;
|
|
(void) pubSz;
|
|
return WOLFSSL_FAILURE;
|
|
#else /* WOLFSSL_KEY_GEN */
|
|
int ret = WOLFSSL_FAILURE;
|
|
int initTmpRng = 0;
|
|
WC_RNG *rng = NULL;
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
WC_RNG *tmpRNG = NULL;
|
|
#else
|
|
WC_RNG tmpRNG[1];
|
|
#endif
|
|
|
|
WOLFSSL_ENTER("wolfSSL_EC25519_generate_key");
|
|
|
|
if (priv == NULL || privSz == NULL || *privSz < CURVE25519_KEYSIZE ||
|
|
pub == NULL || pubSz == NULL || *pubSz < CURVE25519_KEYSIZE) {
|
|
WOLFSSL_MSG("Bad arguments");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
tmpRNG = (WC_RNG*)XMALLOC(sizeof(WC_RNG), NULL, DYNAMIC_TYPE_RNG);
|
|
if (tmpRNG == NULL)
|
|
return WOLFSSL_FAILURE;
|
|
#endif
|
|
if (wc_InitRng(tmpRNG) == 0) {
|
|
rng = tmpRNG;
|
|
initTmpRng = 1;
|
|
}
|
|
else {
|
|
WOLFSSL_MSG("Bad RNG Init, trying global");
|
|
if (initGlobalRNG == 0)
|
|
WOLFSSL_MSG("Global RNG no Init");
|
|
else
|
|
rng = &globalRNG;
|
|
}
|
|
|
|
if (rng) {
|
|
curve25519_key key;
|
|
|
|
if (wc_curve25519_init(&key) != MP_OKAY)
|
|
WOLFSSL_MSG("wc_curve25519_init failed");
|
|
else if (wc_curve25519_make_key(rng, CURVE25519_KEYSIZE, &key)!=MP_OKAY)
|
|
WOLFSSL_MSG("wc_curve25519_make_key failed");
|
|
/* export key pair */
|
|
else if (wc_curve25519_export_key_raw_ex(&key, priv, privSz, pub,
|
|
pubSz, EC25519_LITTLE_ENDIAN)
|
|
!= MP_OKAY)
|
|
WOLFSSL_MSG("wc_curve25519_export_key_raw_ex failed");
|
|
else
|
|
ret = WOLFSSL_SUCCESS;
|
|
|
|
wc_curve25519_free(&key);
|
|
}
|
|
|
|
if (initTmpRng)
|
|
wc_FreeRng(tmpRNG);
|
|
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
XFREE(tmpRNG, NULL, DYNAMIC_TYPE_RNG);
|
|
#endif
|
|
|
|
return ret;
|
|
#endif /* WOLFSSL_KEY_GEN */
|
|
}
|
|
|
|
/* return 1 if success, 0 if error
|
|
* input and output keys are little endian format
|
|
*/
|
|
int wolfSSL_EC25519_shared_key(unsigned char *shared, unsigned int *sharedSz,
|
|
const unsigned char *priv, unsigned int privSz,
|
|
const unsigned char *pub, unsigned int pubSz)
|
|
{
|
|
#ifndef WOLFSSL_KEY_GEN
|
|
WOLFSSL_MSG("No Key Gen built in");
|
|
(void) shared;
|
|
(void) sharedSz;
|
|
(void) priv;
|
|
(void) privSz;
|
|
(void) pub;
|
|
(void) pubSz;
|
|
return WOLFSSL_FAILURE;
|
|
#else /* WOLFSSL_KEY_GEN */
|
|
int ret = WOLFSSL_FAILURE;
|
|
curve25519_key privkey, pubkey;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_EC25519_shared_key");
|
|
|
|
if (shared == NULL || sharedSz == NULL || *sharedSz < CURVE25519_KEYSIZE ||
|
|
priv == NULL || privSz < CURVE25519_KEYSIZE ||
|
|
pub == NULL || pubSz < CURVE25519_KEYSIZE) {
|
|
WOLFSSL_MSG("Bad arguments");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
/* import private key */
|
|
if (wc_curve25519_init(&privkey) != MP_OKAY) {
|
|
WOLFSSL_MSG("wc_curve25519_init privkey failed");
|
|
return ret;
|
|
}
|
|
if (wc_curve25519_import_private_ex(priv, privSz, &privkey,
|
|
EC25519_LITTLE_ENDIAN) != MP_OKAY) {
|
|
WOLFSSL_MSG("wc_curve25519_import_private_ex failed");
|
|
wc_curve25519_free(&privkey);
|
|
return ret;
|
|
}
|
|
|
|
/* import public key */
|
|
if (wc_curve25519_init(&pubkey) != MP_OKAY) {
|
|
WOLFSSL_MSG("wc_curve25519_init pubkey failed");
|
|
wc_curve25519_free(&privkey);
|
|
return ret;
|
|
}
|
|
if (wc_curve25519_import_public_ex(pub, pubSz, &pubkey,
|
|
EC25519_LITTLE_ENDIAN) != MP_OKAY) {
|
|
WOLFSSL_MSG("wc_curve25519_import_public_ex failed");
|
|
wc_curve25519_free(&privkey);
|
|
wc_curve25519_free(&pubkey);
|
|
return ret;
|
|
}
|
|
|
|
if (wc_curve25519_shared_secret_ex(&privkey, &pubkey,
|
|
shared, sharedSz,
|
|
EC25519_LITTLE_ENDIAN) != MP_OKAY)
|
|
WOLFSSL_MSG("wc_curve25519_shared_secret_ex failed");
|
|
else
|
|
ret = WOLFSSL_SUCCESS;
|
|
|
|
wc_curve25519_free(&privkey);
|
|
wc_curve25519_free(&pubkey);
|
|
|
|
return ret;
|
|
#endif /* WOLFSSL_KEY_GEN */
|
|
}
|
|
#endif /* OPENSSL_EXTRA && HAVE_CURVE25519 */
|
|
|
|
#if defined(OPENSSL_EXTRA) && defined(HAVE_ED25519)
|
|
/* return 1 if success, 0 if error
|
|
* output keys are little endian format
|
|
*/
|
|
int wolfSSL_ED25519_generate_key(unsigned char *priv, unsigned int *privSz,
|
|
unsigned char *pub, unsigned int *pubSz)
|
|
{
|
|
#ifndef WOLFSSL_KEY_GEN
|
|
WOLFSSL_MSG("No Key Gen built in");
|
|
(void) priv;
|
|
(void) privSz;
|
|
(void) pub;
|
|
(void) pubSz;
|
|
return WOLFSSL_FAILURE;
|
|
#elif !defined(HAVE_ED25519_KEY_EXPORT)
|
|
WOLFSSL_MSG("No ED25519 key export built in");
|
|
(void) priv;
|
|
(void) privSz;
|
|
(void) pub;
|
|
(void) pubSz;
|
|
return WOLFSSL_FAILURE;
|
|
#else /* WOLFSSL_KEY_GEN && HAVE_ED25519_KEY_EXPORT */
|
|
int ret = WOLFSSL_FAILURE;
|
|
int initTmpRng = 0;
|
|
WC_RNG *rng = NULL;
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
WC_RNG *tmpRNG = NULL;
|
|
#else
|
|
WC_RNG tmpRNG[1];
|
|
#endif
|
|
|
|
WOLFSSL_ENTER("wolfSSL_ED25519_generate_key");
|
|
|
|
if (priv == NULL || privSz == NULL || *privSz < ED25519_PRV_KEY_SIZE ||
|
|
pub == NULL || pubSz == NULL || *pubSz < ED25519_PUB_KEY_SIZE) {
|
|
WOLFSSL_MSG("Bad arguments");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
tmpRNG = (WC_RNG*)XMALLOC(sizeof(WC_RNG), NULL, DYNAMIC_TYPE_RNG);
|
|
if (tmpRNG == NULL)
|
|
return WOLFSSL_FATAL_ERROR;
|
|
#endif
|
|
if (wc_InitRng(tmpRNG) == 0) {
|
|
rng = tmpRNG;
|
|
initTmpRng = 1;
|
|
}
|
|
else {
|
|
WOLFSSL_MSG("Bad RNG Init, trying global");
|
|
if (initGlobalRNG == 0)
|
|
WOLFSSL_MSG("Global RNG no Init");
|
|
else
|
|
rng = &globalRNG;
|
|
}
|
|
|
|
if (rng) {
|
|
ed25519_key key;
|
|
|
|
if (wc_ed25519_init(&key) != MP_OKAY)
|
|
WOLFSSL_MSG("wc_ed25519_init failed");
|
|
else if (wc_ed25519_make_key(rng, ED25519_KEY_SIZE, &key)!=MP_OKAY)
|
|
WOLFSSL_MSG("wc_ed25519_make_key failed");
|
|
/* export private key */
|
|
else if (wc_ed25519_export_key(&key, priv, privSz, pub, pubSz)!=MP_OKAY)
|
|
WOLFSSL_MSG("wc_ed25519_export_key failed");
|
|
else
|
|
ret = WOLFSSL_SUCCESS;
|
|
|
|
wc_ed25519_free(&key);
|
|
}
|
|
|
|
if (initTmpRng)
|
|
wc_FreeRng(tmpRNG);
|
|
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
XFREE(tmpRNG, NULL, DYNAMIC_TYPE_RNG);
|
|
#endif
|
|
|
|
return ret;
|
|
#endif /* WOLFSSL_KEY_GEN && HAVE_ED25519_KEY_EXPORT */
|
|
}
|
|
|
|
/* return 1 if success, 0 if error
|
|
* input and output keys are little endian format
|
|
* priv is a buffer containing private and public part of key
|
|
*/
|
|
int wolfSSL_ED25519_sign(const unsigned char *msg, unsigned int msgSz,
|
|
const unsigned char *priv, unsigned int privSz,
|
|
unsigned char *sig, unsigned int *sigSz)
|
|
{
|
|
#if !defined(HAVE_ED25519_SIGN) || !defined(WOLFSSL_KEY_GEN) || !defined(HAVE_ED25519_KEY_IMPORT)
|
|
#if !defined(HAVE_ED25519_SIGN)
|
|
WOLFSSL_MSG("No ED25519 sign built in");
|
|
#elif !defined(WOLFSSL_KEY_GEN)
|
|
WOLFSSL_MSG("No Key Gen built in");
|
|
#elif !defined(HAVE_ED25519_KEY_IMPORT)
|
|
WOLFSSL_MSG("No ED25519 Key import built in");
|
|
#endif
|
|
(void) msg;
|
|
(void) msgSz;
|
|
(void) priv;
|
|
(void) privSz;
|
|
(void) sig;
|
|
(void) sigSz;
|
|
return WOLFSSL_FAILURE;
|
|
#else /* HAVE_ED25519_SIGN && WOLFSSL_KEY_GEN && HAVE_ED25519_KEY_IMPORT */
|
|
ed25519_key key;
|
|
int ret = WOLFSSL_FAILURE;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_ED25519_sign");
|
|
|
|
if (priv == NULL || privSz != ED25519_PRV_KEY_SIZE ||
|
|
msg == NULL || sig == NULL || *sigSz < ED25519_SIG_SIZE) {
|
|
WOLFSSL_MSG("Bad arguments");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
/* import key */
|
|
if (wc_ed25519_init(&key) != MP_OKAY) {
|
|
WOLFSSL_MSG("wc_curve25519_init failed");
|
|
return ret;
|
|
}
|
|
if (wc_ed25519_import_private_key(priv, privSz/2,
|
|
priv+(privSz/2), ED25519_PUB_KEY_SIZE,
|
|
&key) != MP_OKAY){
|
|
WOLFSSL_MSG("wc_ed25519_import_private failed");
|
|
wc_ed25519_free(&key);
|
|
return ret;
|
|
}
|
|
|
|
if (wc_ed25519_sign_msg(msg, msgSz, sig, sigSz, &key) != MP_OKAY)
|
|
WOLFSSL_MSG("wc_curve25519_shared_secret_ex failed");
|
|
else
|
|
ret = WOLFSSL_SUCCESS;
|
|
|
|
wc_ed25519_free(&key);
|
|
|
|
return ret;
|
|
#endif /* HAVE_ED25519_SIGN && WOLFSSL_KEY_GEN && HAVE_ED25519_KEY_IMPORT */
|
|
}
|
|
|
|
/* return 1 if success, 0 if error
|
|
* input and output keys are little endian format
|
|
* pub is a buffer containing public part of key
|
|
*/
|
|
int wolfSSL_ED25519_verify(const unsigned char *msg, unsigned int msgSz,
|
|
const unsigned char *pub, unsigned int pubSz,
|
|
const unsigned char *sig, unsigned int sigSz)
|
|
{
|
|
#if !defined(HAVE_ED25519_VERIFY) || !defined(WOLFSSL_KEY_GEN) || !defined(HAVE_ED25519_KEY_IMPORT)
|
|
#if !defined(HAVE_ED25519_VERIFY)
|
|
WOLFSSL_MSG("No ED25519 verify built in");
|
|
#elif !defined(WOLFSSL_KEY_GEN)
|
|
WOLFSSL_MSG("No Key Gen built in");
|
|
#elif !defined(HAVE_ED25519_KEY_IMPORT)
|
|
WOLFSSL_MSG("No ED25519 Key import built in");
|
|
#endif
|
|
(void) msg;
|
|
(void) msgSz;
|
|
(void) pub;
|
|
(void) pubSz;
|
|
(void) sig;
|
|
(void) sigSz;
|
|
return WOLFSSL_FAILURE;
|
|
#else /* HAVE_ED25519_VERIFY && WOLFSSL_KEY_GEN && HAVE_ED25519_KEY_IMPORT */
|
|
ed25519_key key;
|
|
int ret = WOLFSSL_FAILURE, check = 0;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_ED25519_verify");
|
|
|
|
if (pub == NULL || pubSz != ED25519_PUB_KEY_SIZE ||
|
|
msg == NULL || sig == NULL || sigSz != ED25519_SIG_SIZE) {
|
|
WOLFSSL_MSG("Bad arguments");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
/* import key */
|
|
if (wc_ed25519_init(&key) != MP_OKAY) {
|
|
WOLFSSL_MSG("wc_curve25519_init failed");
|
|
return ret;
|
|
}
|
|
if (wc_ed25519_import_public(pub, pubSz, &key) != MP_OKAY){
|
|
WOLFSSL_MSG("wc_ed25519_import_public failed");
|
|
wc_ed25519_free(&key);
|
|
return ret;
|
|
}
|
|
|
|
if ((ret = wc_ed25519_verify_msg((byte*)sig, sigSz, msg, msgSz,
|
|
&check, &key)) != MP_OKAY) {
|
|
WOLFSSL_MSG("wc_ed25519_verify_msg failed");
|
|
}
|
|
else if (!check)
|
|
WOLFSSL_MSG("wc_ed25519_verify_msg failed (signature invalid)");
|
|
else
|
|
ret = WOLFSSL_SUCCESS;
|
|
|
|
wc_ed25519_free(&key);
|
|
|
|
return ret;
|
|
#endif /* HAVE_ED25519_VERIFY && WOLFSSL_KEY_GEN && HAVE_ED25519_KEY_IMPORT */
|
|
}
|
|
|
|
#endif /* OPENSSL_EXTRA && HAVE_ED25519 */
|
|
|
|
#if defined(OPENSSL_EXTRA) && defined(HAVE_CURVE448)
|
|
/* return 1 if success, 0 if error
|
|
* output keys are little endian format
|
|
*/
|
|
int wolfSSL_EC448_generate_key(unsigned char *priv, unsigned int *privSz,
|
|
unsigned char *pub, unsigned int *pubSz)
|
|
{
|
|
#ifndef WOLFSSL_KEY_GEN
|
|
WOLFSSL_MSG("No Key Gen built in");
|
|
(void) priv;
|
|
(void) privSz;
|
|
(void) pub;
|
|
(void) pubSz;
|
|
return WOLFSSL_FAILURE;
|
|
#else /* WOLFSSL_KEY_GEN */
|
|
int ret = WOLFSSL_FAILURE;
|
|
int initTmpRng = 0;
|
|
WC_RNG *rng = NULL;
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
WC_RNG *tmpRNG = NULL;
|
|
#else
|
|
WC_RNG tmpRNG[1];
|
|
#endif
|
|
|
|
WOLFSSL_ENTER("wolfSSL_EC448_generate_key");
|
|
|
|
if (priv == NULL || privSz == NULL || *privSz < CURVE448_KEY_SIZE ||
|
|
pub == NULL || pubSz == NULL || *pubSz < CURVE448_KEY_SIZE) {
|
|
WOLFSSL_MSG("Bad arguments");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
tmpRNG = (WC_RNG*)XMALLOC(sizeof(WC_RNG), NULL, DYNAMIC_TYPE_RNG);
|
|
if (tmpRNG == NULL)
|
|
return WOLFSSL_FAILURE;
|
|
#endif
|
|
if (wc_InitRng(tmpRNG) == 0) {
|
|
rng = tmpRNG;
|
|
initTmpRng = 1;
|
|
}
|
|
else {
|
|
WOLFSSL_MSG("Bad RNG Init, trying global");
|
|
if (initGlobalRNG == 0)
|
|
WOLFSSL_MSG("Global RNG no Init");
|
|
else
|
|
rng = &globalRNG;
|
|
}
|
|
|
|
if (rng) {
|
|
curve448_key key;
|
|
|
|
if (wc_curve448_init(&key) != MP_OKAY)
|
|
WOLFSSL_MSG("wc_curve448_init failed");
|
|
else if (wc_curve448_make_key(rng, CURVE448_KEY_SIZE, &key)!=MP_OKAY)
|
|
WOLFSSL_MSG("wc_curve448_make_key failed");
|
|
/* export key pair */
|
|
else if (wc_curve448_export_key_raw_ex(&key, priv, privSz, pub, pubSz,
|
|
EC448_LITTLE_ENDIAN)
|
|
!= MP_OKAY)
|
|
WOLFSSL_MSG("wc_curve448_export_key_raw_ex failed");
|
|
else
|
|
ret = WOLFSSL_SUCCESS;
|
|
|
|
wc_curve448_free(&key);
|
|
}
|
|
|
|
if (initTmpRng)
|
|
wc_FreeRng(tmpRNG);
|
|
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
XFREE(tmpRNG, NULL, DYNAMIC_TYPE_RNG);
|
|
#endif
|
|
|
|
return ret;
|
|
#endif /* WOLFSSL_KEY_GEN */
|
|
}
|
|
|
|
/* return 1 if success, 0 if error
|
|
* input and output keys are little endian format
|
|
*/
|
|
int wolfSSL_EC448_shared_key(unsigned char *shared, unsigned int *sharedSz,
|
|
const unsigned char *priv, unsigned int privSz,
|
|
const unsigned char *pub, unsigned int pubSz)
|
|
{
|
|
#ifndef WOLFSSL_KEY_GEN
|
|
WOLFSSL_MSG("No Key Gen built in");
|
|
(void) shared;
|
|
(void) sharedSz;
|
|
(void) priv;
|
|
(void) privSz;
|
|
(void) pub;
|
|
(void) pubSz;
|
|
return WOLFSSL_FAILURE;
|
|
#else /* WOLFSSL_KEY_GEN */
|
|
int ret = WOLFSSL_FAILURE;
|
|
curve448_key privkey, pubkey;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_EC448_shared_key");
|
|
|
|
if (shared == NULL || sharedSz == NULL || *sharedSz < CURVE448_KEY_SIZE ||
|
|
priv == NULL || privSz < CURVE448_KEY_SIZE ||
|
|
pub == NULL || pubSz < CURVE448_KEY_SIZE) {
|
|
WOLFSSL_MSG("Bad arguments");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
/* import private key */
|
|
if (wc_curve448_init(&privkey) != MP_OKAY) {
|
|
WOLFSSL_MSG("wc_curve448_init privkey failed");
|
|
return ret;
|
|
}
|
|
if (wc_curve448_import_private_ex(priv, privSz, &privkey,
|
|
EC448_LITTLE_ENDIAN) != MP_OKAY) {
|
|
WOLFSSL_MSG("wc_curve448_import_private_ex failed");
|
|
wc_curve448_free(&privkey);
|
|
return ret;
|
|
}
|
|
|
|
/* import public key */
|
|
if (wc_curve448_init(&pubkey) != MP_OKAY) {
|
|
WOLFSSL_MSG("wc_curve448_init pubkey failed");
|
|
wc_curve448_free(&privkey);
|
|
return ret;
|
|
}
|
|
if (wc_curve448_import_public_ex(pub, pubSz, &pubkey,
|
|
EC448_LITTLE_ENDIAN) != MP_OKAY) {
|
|
WOLFSSL_MSG("wc_curve448_import_public_ex failed");
|
|
wc_curve448_free(&privkey);
|
|
wc_curve448_free(&pubkey);
|
|
return ret;
|
|
}
|
|
|
|
if (wc_curve448_shared_secret_ex(&privkey, &pubkey, shared, sharedSz,
|
|
EC448_LITTLE_ENDIAN) != MP_OKAY)
|
|
WOLFSSL_MSG("wc_curve448_shared_secret_ex failed");
|
|
else
|
|
ret = WOLFSSL_SUCCESS;
|
|
|
|
wc_curve448_free(&privkey);
|
|
wc_curve448_free(&pubkey);
|
|
|
|
return ret;
|
|
#endif /* WOLFSSL_KEY_GEN */
|
|
}
|
|
#endif /* OPENSSL_EXTRA && HAVE_CURVE448 */
|
|
|
|
#if defined(OPENSSL_EXTRA) && defined(HAVE_ED448)
|
|
/* return 1 if success, 0 if error
|
|
* output keys are little endian format
|
|
*/
|
|
int wolfSSL_ED448_generate_key(unsigned char *priv, unsigned int *privSz,
|
|
unsigned char *pub, unsigned int *pubSz)
|
|
{
|
|
#ifndef WOLFSSL_KEY_GEN
|
|
WOLFSSL_MSG("No Key Gen built in");
|
|
(void) priv;
|
|
(void) privSz;
|
|
(void) pub;
|
|
(void) pubSz;
|
|
return WOLFSSL_FAILURE;
|
|
#elif !defined(HAVE_ED448_KEY_EXPORT)
|
|
WOLFSSL_MSG("No ED448 key export built in");
|
|
(void) priv;
|
|
(void) privSz;
|
|
(void) pub;
|
|
(void) pubSz;
|
|
return WOLFSSL_FAILURE;
|
|
#else /* WOLFSSL_KEY_GEN && HAVE_ED448_KEY_EXPORT */
|
|
int ret = WOLFSSL_FAILURE;
|
|
int initTmpRng = 0;
|
|
WC_RNG *rng = NULL;
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
WC_RNG *tmpRNG = NULL;
|
|
#else
|
|
WC_RNG tmpRNG[1];
|
|
#endif
|
|
|
|
WOLFSSL_ENTER("wolfSSL_ED448_generate_key");
|
|
|
|
if (priv == NULL || privSz == NULL || *privSz < ED448_PRV_KEY_SIZE ||
|
|
pub == NULL || pubSz == NULL || *pubSz < ED448_PUB_KEY_SIZE) {
|
|
WOLFSSL_MSG("Bad arguments");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
tmpRNG = (WC_RNG*)XMALLOC(sizeof(WC_RNG), NULL, DYNAMIC_TYPE_RNG);
|
|
if (tmpRNG == NULL)
|
|
return WOLFSSL_FATAL_ERROR;
|
|
#endif
|
|
if (wc_InitRng(tmpRNG) == 0) {
|
|
rng = tmpRNG;
|
|
initTmpRng = 1;
|
|
}
|
|
else {
|
|
WOLFSSL_MSG("Bad RNG Init, trying global");
|
|
if (initGlobalRNG == 0)
|
|
WOLFSSL_MSG("Global RNG no Init");
|
|
else
|
|
rng = &globalRNG;
|
|
}
|
|
|
|
if (rng) {
|
|
ed448_key key;
|
|
|
|
if (wc_ed448_init(&key) != MP_OKAY)
|
|
WOLFSSL_MSG("wc_ed448_init failed");
|
|
else if (wc_ed448_make_key(rng, ED448_KEY_SIZE, &key) != MP_OKAY)
|
|
WOLFSSL_MSG("wc_ed448_make_key failed");
|
|
/* export private key */
|
|
else if (wc_ed448_export_key(&key, priv, privSz, pub, pubSz) != MP_OKAY)
|
|
WOLFSSL_MSG("wc_ed448_export_key failed");
|
|
else
|
|
ret = WOLFSSL_SUCCESS;
|
|
|
|
wc_ed448_free(&key);
|
|
}
|
|
|
|
if (initTmpRng)
|
|
wc_FreeRng(tmpRNG);
|
|
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
XFREE(tmpRNG, NULL, DYNAMIC_TYPE_RNG);
|
|
#endif
|
|
|
|
return ret;
|
|
#endif /* WOLFSSL_KEY_GEN && HAVE_ED448_KEY_EXPORT */
|
|
}
|
|
|
|
/* return 1 if success, 0 if error
|
|
* input and output keys are little endian format
|
|
* priv is a buffer containing private and public part of key
|
|
*/
|
|
int wolfSSL_ED448_sign(const unsigned char *msg, unsigned int msgSz,
|
|
const unsigned char *priv, unsigned int privSz,
|
|
unsigned char *sig, unsigned int *sigSz)
|
|
{
|
|
#if !defined(HAVE_ED448_SIGN) || !defined(WOLFSSL_KEY_GEN) || !defined(HAVE_ED448_KEY_IMPORT)
|
|
#if !defined(HAVE_ED448_SIGN)
|
|
WOLFSSL_MSG("No ED448 sign built in");
|
|
#elif !defined(WOLFSSL_KEY_GEN)
|
|
WOLFSSL_MSG("No Key Gen built in");
|
|
#elif !defined(HAVE_ED448_KEY_IMPORT)
|
|
WOLFSSL_MSG("No ED448 Key import built in");
|
|
#endif
|
|
(void) msg;
|
|
(void) msgSz;
|
|
(void) priv;
|
|
(void) privSz;
|
|
(void) sig;
|
|
(void) sigSz;
|
|
return WOLFSSL_FAILURE;
|
|
#else /* HAVE_ED448_SIGN && WOLFSSL_KEY_GEN && HAVE_ED448_KEY_IMPORT */
|
|
ed448_key key;
|
|
int ret = WOLFSSL_FAILURE;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_ED448_sign");
|
|
|
|
if (priv == NULL || privSz != ED448_PRV_KEY_SIZE || msg == NULL ||
|
|
sig == NULL || *sigSz < ED448_SIG_SIZE) {
|
|
WOLFSSL_MSG("Bad arguments");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
/* import key */
|
|
if (wc_ed448_init(&key) != MP_OKAY) {
|
|
WOLFSSL_MSG("wc_curve448_init failed");
|
|
return ret;
|
|
}
|
|
if (wc_ed448_import_private_key(priv, privSz/2, priv+(privSz/2),
|
|
ED448_PUB_KEY_SIZE, &key) != MP_OKAY){
|
|
WOLFSSL_MSG("wc_ed448_import_private failed");
|
|
wc_ed448_free(&key);
|
|
return ret;
|
|
}
|
|
|
|
if (wc_ed448_sign_msg(msg, msgSz, sig, sigSz, &key, NULL, 0) != MP_OKAY)
|
|
WOLFSSL_MSG("wc_curve448_shared_secret_ex failed");
|
|
else
|
|
ret = WOLFSSL_SUCCESS;
|
|
|
|
wc_ed448_free(&key);
|
|
|
|
return ret;
|
|
#endif /* HAVE_ED448_SIGN && WOLFSSL_KEY_GEN && HAVE_ED448_KEY_IMPORT */
|
|
}
|
|
|
|
/* return 1 if success, 0 if error
|
|
* input and output keys are little endian format
|
|
* pub is a buffer containing public part of key
|
|
*/
|
|
int wolfSSL_ED448_verify(const unsigned char *msg, unsigned int msgSz,
|
|
const unsigned char *pub, unsigned int pubSz,
|
|
const unsigned char *sig, unsigned int sigSz)
|
|
{
|
|
#if !defined(HAVE_ED448_VERIFY) || !defined(WOLFSSL_KEY_GEN) || !defined(HAVE_ED448_KEY_IMPORT)
|
|
#if !defined(HAVE_ED448_VERIFY)
|
|
WOLFSSL_MSG("No ED448 verify built in");
|
|
#elif !defined(WOLFSSL_KEY_GEN)
|
|
WOLFSSL_MSG("No Key Gen built in");
|
|
#elif !defined(HAVE_ED448_KEY_IMPORT)
|
|
WOLFSSL_MSG("No ED448 Key import built in");
|
|
#endif
|
|
(void) msg;
|
|
(void) msgSz;
|
|
(void) pub;
|
|
(void) pubSz;
|
|
(void) sig;
|
|
(void) sigSz;
|
|
return WOLFSSL_FAILURE;
|
|
#else /* HAVE_ED448_VERIFY && WOLFSSL_KEY_GEN && HAVE_ED448_KEY_IMPORT */
|
|
ed448_key key;
|
|
int ret = WOLFSSL_FAILURE, check = 0;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_ED448_verify");
|
|
|
|
if (pub == NULL || pubSz != ED448_PUB_KEY_SIZE || msg == NULL ||
|
|
sig == NULL || sigSz != ED448_SIG_SIZE) {
|
|
WOLFSSL_MSG("Bad arguments");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
/* import key */
|
|
if (wc_ed448_init(&key) != MP_OKAY) {
|
|
WOLFSSL_MSG("wc_curve448_init failed");
|
|
return ret;
|
|
}
|
|
if (wc_ed448_import_public(pub, pubSz, &key) != MP_OKAY){
|
|
WOLFSSL_MSG("wc_ed448_import_public failed");
|
|
wc_ed448_free(&key);
|
|
return ret;
|
|
}
|
|
|
|
if ((ret = wc_ed448_verify_msg((byte*)sig, sigSz, msg, msgSz, &check,
|
|
&key, NULL, 0)) != MP_OKAY) {
|
|
WOLFSSL_MSG("wc_ed448_verify_msg failed");
|
|
}
|
|
else if (!check)
|
|
WOLFSSL_MSG("wc_ed448_verify_msg failed (signature invalid)");
|
|
else
|
|
ret = WOLFSSL_SUCCESS;
|
|
|
|
wc_ed448_free(&key);
|
|
|
|
return ret;
|
|
#endif /* HAVE_ED448_VERIFY && WOLFSSL_KEY_GEN */
|
|
}
|
|
|
|
#endif /* OPENSSL_EXTRA && HAVE_ED448 */
|
|
|
|
#ifdef WOLFSSL_JNI
|
|
|
|
int wolfSSL_set_jobject(WOLFSSL* ssl, void* objPtr)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_set_jobject");
|
|
if (ssl != NULL)
|
|
{
|
|
ssl->jObjectRef = objPtr;
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
void* wolfSSL_get_jobject(WOLFSSL* ssl)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_get_jobject");
|
|
if (ssl != NULL)
|
|
return ssl->jObjectRef;
|
|
return NULL;
|
|
}
|
|
|
|
#endif /* WOLFSSL_JNI */
|
|
|
|
|
|
#ifdef WOLFSSL_ASYNC_CRYPT
|
|
int wolfSSL_CTX_AsyncPoll(WOLFSSL_CTX* ctx, WOLF_EVENT** events, int maxEvents,
|
|
WOLF_EVENT_FLAG flags, int* eventCount)
|
|
{
|
|
if (ctx == NULL) {
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
return wolfAsync_EventQueuePoll(&ctx->event_queue, NULL,
|
|
events, maxEvents, flags, eventCount);
|
|
}
|
|
|
|
int wolfSSL_AsyncPoll(WOLFSSL* ssl, WOLF_EVENT_FLAG flags)
|
|
{
|
|
int ret, eventCount = 0;
|
|
WOLF_EVENT* events[1];
|
|
|
|
if (ssl == NULL) {
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
ret = wolfAsync_EventQueuePoll(&ssl->ctx->event_queue, ssl,
|
|
events, sizeof(events)/sizeof(events[0]), flags, &eventCount);
|
|
if (ret == 0) {
|
|
ret = eventCount;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
#endif /* WOLFSSL_ASYNC_CRYPT */
|
|
|
|
#ifdef OPENSSL_EXTRA
|
|
|
|
static int peek_ignore_err(int err)
|
|
{
|
|
switch(err) {
|
|
case -WANT_READ:
|
|
case -WANT_WRITE:
|
|
case -ZERO_RETURN:
|
|
case -WOLFSSL_ERROR_ZERO_RETURN:
|
|
case -SOCKET_PEER_CLOSED_E:
|
|
case -SOCKET_ERROR_E:
|
|
return 1;
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
unsigned long wolfSSL_ERR_peek_error_line_data(const char **file, int *line,
|
|
const char **data, int *flags)
|
|
{
|
|
unsigned long err;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_ERR_peek_error_line_data");
|
|
err = wc_PeekErrorNodeLineData(file, line, data, flags, peek_ignore_err);
|
|
|
|
if (err == -ASN_NO_PEM_HEADER)
|
|
return (ERR_LIB_PEM << 24) | PEM_R_NO_START_LINE;
|
|
#ifdef OPENSSL_ALL
|
|
/* PARSE_ERROR is returned if an HTTP request is detected. */
|
|
else if (err == -SSL_R_HTTP_REQUEST)
|
|
return (ERR_LIB_SSL << 24) | -SSL_R_HTTP_REQUEST;
|
|
#endif
|
|
#if defined(OPENSSL_ALL) && defined(WOLFSSL_PYTHON)
|
|
else if (err == ASN1_R_HEADER_TOO_LONG)
|
|
return (ERR_LIB_ASN1 << 24) | ASN1_R_HEADER_TOO_LONG;
|
|
#endif
|
|
return err;
|
|
}
|
|
#endif
|
|
|
|
#if defined(OPENSSL_ALL) || defined(WOLFSSL_NGINX) || defined(WOLFSSL_HAPROXY)
|
|
|
|
#if !defined(WOLFSSL_USER_IO)
|
|
/* converts an IPv6 or IPv4 address into an octet string for use with rfc3280
|
|
* example input would be "127.0.0.1" and the returned value would be 7F000001
|
|
*/
|
|
WOLFSSL_ASN1_STRING* wolfSSL_a2i_IPADDRESS(const char* ipa)
|
|
{
|
|
int ipaSz = WOLFSSL_IP4_ADDR_LEN;
|
|
char buf[WOLFSSL_IP6_ADDR_LEN + 1]; /* plus 1 for terminator */
|
|
int af = WOLFSSL_IP4;
|
|
WOLFSSL_ASN1_STRING *ret = NULL;
|
|
|
|
if (ipa == NULL)
|
|
return NULL;
|
|
|
|
if (XSTRSTR(ipa, ":") != NULL) {
|
|
af = WOLFSSL_IP6;
|
|
ipaSz = WOLFSSL_IP6_ADDR_LEN;
|
|
}
|
|
|
|
buf[WOLFSSL_IP6_ADDR_LEN] = '\0';
|
|
if (XINET_PTON(af, ipa, (void*)buf) != 1) {
|
|
WOLFSSL_MSG("Error parsing IP address");
|
|
return NULL;
|
|
}
|
|
|
|
ret = wolfSSL_ASN1_STRING_new();
|
|
if (ret != NULL) {
|
|
if (wolfSSL_ASN1_STRING_set(ret, buf, ipaSz) != WOLFSSL_SUCCESS) {
|
|
WOLFSSL_MSG("Error setting the string");
|
|
wolfSSL_ASN1_STRING_free(ret);
|
|
ret = NULL;
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
#endif /* !WOLFSSL_USER_IO */
|
|
|
|
/* Is the specified cipher suite a fake one used an an extension proxy? */
|
|
static WC_INLINE int SCSV_Check(byte suite0, byte suite)
|
|
{
|
|
(void)suite0;
|
|
(void)suite;
|
|
#ifdef HAVE_RENEGOTIATION_INDICATION
|
|
if (suite0 == CIPHER_BYTE && suite == TLS_EMPTY_RENEGOTIATION_INFO_SCSV)
|
|
return 1;
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
static WC_INLINE int sslCipherMinMaxCheck(const WOLFSSL *ssl, byte suite0,
|
|
byte suite)
|
|
{
|
|
const CipherSuiteInfo* cipher_names = GetCipherNames();
|
|
int cipherSz = GetCipherNamesSize();
|
|
int i;
|
|
for (i = 0; i < cipherSz; i++)
|
|
if (cipher_names[i].cipherSuite0 == suite0 &&
|
|
cipher_names[i].cipherSuite == suite)
|
|
break;
|
|
if (i == cipherSz)
|
|
return 1;
|
|
/* Check min version */
|
|
if (cipher_names[i].minor < ssl->options.minDowngrade) {
|
|
if (ssl->options.minDowngrade <= TLSv1_2_MINOR &&
|
|
cipher_names[i].minor >= TLSv1_MINOR)
|
|
/* 1.0 ciphersuites are in general available in 1.1 and
|
|
* 1.1 ciphersuites are in general available in 1.2 */
|
|
return 0;
|
|
return 1;
|
|
}
|
|
/* Check max version */
|
|
switch (cipher_names[i].minor) {
|
|
case SSLv3_MINOR :
|
|
return ssl->options.mask & WOLFSSL_OP_NO_SSLv3;
|
|
case TLSv1_MINOR :
|
|
return ssl->options.mask & WOLFSSL_OP_NO_TLSv1;
|
|
case TLSv1_1_MINOR :
|
|
return ssl->options.mask & WOLFSSL_OP_NO_TLSv1_1;
|
|
case TLSv1_2_MINOR :
|
|
return ssl->options.mask & WOLFSSL_OP_NO_TLSv1_2;
|
|
case TLSv1_3_MINOR :
|
|
return ssl->options.mask & WOLFSSL_OP_NO_TLSv1_3;
|
|
default:
|
|
WOLFSSL_MSG("Unrecognized minor version");
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
/* returns a pointer to internal cipher suite list. Should not be free'd by
|
|
* caller.
|
|
*/
|
|
WOLF_STACK_OF(WOLFSSL_CIPHER) *wolfSSL_get_ciphers_compat(const WOLFSSL *ssl)
|
|
{
|
|
WOLF_STACK_OF(WOLFSSL_CIPHER)* ret = NULL;
|
|
const Suites* suites;
|
|
#if defined(OPENSSL_ALL) || defined(WOLFSSL_QT)
|
|
const CipherSuiteInfo* cipher_names = GetCipherNames();
|
|
int cipherSz = GetCipherNamesSize();
|
|
#endif
|
|
|
|
WOLFSSL_ENTER("wolfSSL_get_ciphers_compat");
|
|
if (ssl == NULL)
|
|
return NULL;
|
|
|
|
suites = WOLFSSL_SUITES(ssl);
|
|
if (suites == NULL)
|
|
return NULL;
|
|
|
|
/* check if stack needs populated */
|
|
if (ssl->suitesStack == NULL) {
|
|
int i;
|
|
#if defined(OPENSSL_ALL) || defined(WOLFSSL_QT)
|
|
int j;
|
|
|
|
/* higher priority of cipher suite will be on top of stack */
|
|
for (i = suites->suiteSz - 2; i >=0; i-=2) {
|
|
#else
|
|
for (i = 0; i < suites->suiteSz; i+=2) {
|
|
#endif
|
|
WOLFSSL_STACK* add;
|
|
|
|
/* A couple of suites are placeholders for special options,
|
|
* skip those. */
|
|
if (SCSV_Check(suites->suites[i], suites->suites[i+1])
|
|
|| sslCipherMinMaxCheck(ssl, suites->suites[i],
|
|
suites->suites[i+1])) {
|
|
continue;
|
|
}
|
|
|
|
add = wolfSSL_sk_new_node(ssl->heap);
|
|
if (add != NULL) {
|
|
add->type = STACK_TYPE_CIPHER;
|
|
add->data.cipher.cipherSuite0 = suites->suites[i];
|
|
add->data.cipher.cipherSuite = suites->suites[i+1];
|
|
add->data.cipher.ssl = ssl;
|
|
#if defined(OPENSSL_ALL) || defined(WOLFSSL_QT)
|
|
for (j = 0; j < cipherSz; j++) {
|
|
if (cipher_names[j].cipherSuite0 ==
|
|
add->data.cipher.cipherSuite0 &&
|
|
cipher_names[j].cipherSuite ==
|
|
add->data.cipher.cipherSuite) {
|
|
add->data.cipher.offset = j;
|
|
break;
|
|
}
|
|
}
|
|
#endif
|
|
#if defined(WOLFSSL_QT) || defined(OPENSSL_ALL)
|
|
/* in_stack is checked in wolfSSL_CIPHER_description */
|
|
add->data.cipher.in_stack = 1;
|
|
#endif
|
|
|
|
add->next = ret;
|
|
if (ret != NULL) {
|
|
add->num = ret->num + 1;
|
|
}
|
|
else {
|
|
add->num = 1;
|
|
}
|
|
ret = add;
|
|
}
|
|
}
|
|
((WOLFSSL*)ssl)->suitesStack = ret;
|
|
}
|
|
return ssl->suitesStack;
|
|
}
|
|
#endif /* OPENSSL_ALL || WOLFSSL_NGINX || WOLFSSL_HAPROXY */
|
|
|
|
#if defined(OPENSSL_ALL) || defined(WOLFSSL_NGINX) || defined(WOLFSSL_HAPROXY) \
|
|
|| defined(OPENSSL_EXTRA) || defined(HAVE_LIGHTY) || defined(HAVE_SECRET_CALLBACK)
|
|
long wolfSSL_SSL_CTX_get_timeout(const WOLFSSL_CTX *ctx)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_SSL_CTX_get_timeout");
|
|
|
|
if (ctx == NULL)
|
|
return 0;
|
|
|
|
return ctx->timeout;
|
|
}
|
|
|
|
|
|
/* returns the time in seconds of the current timeout */
|
|
long wolfSSL_get_timeout(WOLFSSL* ssl)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_get_timeout");
|
|
|
|
if (ssl == NULL)
|
|
return 0;
|
|
return ssl->timeout;
|
|
}
|
|
#endif
|
|
|
|
#if defined(OPENSSL_ALL) || defined(WOLFSSL_NGINX) || defined(WOLFSSL_HAPROXY) \
|
|
|| defined(OPENSSL_EXTRA) || defined(HAVE_LIGHTY)
|
|
|
|
#ifdef HAVE_ECC
|
|
int wolfSSL_SSL_CTX_set_tmp_ecdh(WOLFSSL_CTX *ctx, WOLFSSL_EC_KEY *ecdh)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_SSL_CTX_set_tmp_ecdh");
|
|
|
|
if (ctx == NULL || ecdh == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
ctx->ecdhCurveOID = ecdh->group->curve_oid;
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
#endif
|
|
#ifndef NO_SESSION_CACHE
|
|
int wolfSSL_SSL_CTX_remove_session(WOLFSSL_CTX *ctx, WOLFSSL_SESSION *s)
|
|
{
|
|
#if defined(HAVE_EXT_CACHE) || defined(HAVE_EX_DATA)
|
|
int rem_called = FALSE;
|
|
#endif
|
|
|
|
WOLFSSL_ENTER("wolfSSL_SSL_CTX_remove_session");
|
|
|
|
s = ClientSessionToSession(s);
|
|
if (ctx == NULL || s == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
#ifdef HAVE_EXT_CACHE
|
|
if (!ctx->internalCacheOff)
|
|
#endif
|
|
{
|
|
const byte* id;
|
|
WOLFSSL_SESSION *sess = NULL;
|
|
word32 row = 0;
|
|
int ret;
|
|
|
|
id = s->sessionID;
|
|
if (s->haveAltSessionID)
|
|
id = s->altSessionID;
|
|
|
|
ret = TlsSessionCacheGetAndWrLock(id, &sess, &row, ctx->method->side);
|
|
if (ret == 0 && sess != NULL) {
|
|
#if defined(HAVE_EXT_CACHE) || defined(HAVE_EX_DATA)
|
|
if (sess->rem_sess_cb != NULL) {
|
|
rem_called = TRUE;
|
|
}
|
|
#endif
|
|
/* Call this before changing ownExData so that calls to ex_data
|
|
* don't try to access the SessionCache again. */
|
|
EvictSessionFromCache(sess);
|
|
#ifdef HAVE_EX_DATA
|
|
if (sess->ownExData) {
|
|
/* Most recent version of ex data is in cache. Copy it
|
|
* over so the user can free it. */
|
|
XMEMCPY(&s->ex_data, &sess->ex_data,
|
|
sizeof(WOLFSSL_CRYPTO_EX_DATA));
|
|
s->ownExData = 1;
|
|
sess->ownExData = 0;
|
|
}
|
|
#endif
|
|
#ifdef SESSION_CACHE_DYNAMIC_MEM
|
|
{
|
|
/* Find and clear entry. Row is locked so we are good to go. */
|
|
int idx;
|
|
for (idx = 0; idx < SESSIONS_PER_ROW; idx++) {
|
|
if (sess == SessionCache[row].Sessions[idx]) {
|
|
XFREE(sess, sess->heap, DYNAMIC_TYPE_SESSION);
|
|
SessionCache[row].Sessions[idx] = NULL;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
TlsSessionCacheUnlockRow(row);
|
|
}
|
|
}
|
|
|
|
#if defined(HAVE_EXT_CACHE) || defined(HAVE_EX_DATA)
|
|
if (ctx->rem_sess_cb != NULL && !rem_called) {
|
|
ctx->rem_sess_cb(ctx, s);
|
|
}
|
|
#endif
|
|
|
|
/* s cannot be resumed at this point */
|
|
s->timeout = 0;
|
|
|
|
return 0;
|
|
}
|
|
#endif /* !NO_SESSION_CACHE */
|
|
#ifndef NO_BIO
|
|
BIO *wolfSSL_SSL_get_rbio(const WOLFSSL *s)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_SSL_get_rbio");
|
|
/* Nginx sets the buffer size if the read BIO is different to write BIO.
|
|
* The setting buffer size doesn't do anything so return NULL for both.
|
|
*/
|
|
if (s == NULL)
|
|
return NULL;
|
|
|
|
return s->biord;
|
|
}
|
|
BIO *wolfSSL_SSL_get_wbio(const WOLFSSL *s)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_SSL_get_wbio");
|
|
(void)s;
|
|
/* Nginx sets the buffer size if the read BIO is different to write BIO.
|
|
* The setting buffer size doesn't do anything so return NULL for both.
|
|
*/
|
|
if (s == NULL)
|
|
return NULL;
|
|
|
|
return s->biowr;
|
|
}
|
|
#endif /* !NO_BIO */
|
|
|
|
int wolfSSL_SSL_do_handshake_internal(WOLFSSL *s)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_SSL_do_handshake_internal");
|
|
if (s == NULL)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
if (s->options.side == WOLFSSL_CLIENT_END) {
|
|
#ifndef NO_WOLFSSL_CLIENT
|
|
return wolfSSL_connect(s);
|
|
#else
|
|
WOLFSSL_MSG("Client not compiled in");
|
|
return WOLFSSL_FAILURE;
|
|
#endif
|
|
}
|
|
|
|
#ifndef NO_WOLFSSL_SERVER
|
|
return wolfSSL_accept(s);
|
|
#else
|
|
WOLFSSL_MSG("Server not compiled in");
|
|
return WOLFSSL_FAILURE;
|
|
#endif
|
|
}
|
|
|
|
int wolfSSL_SSL_do_handshake(WOLFSSL *s)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_SSL_do_handshake");
|
|
#ifdef WOLFSSL_QUIC
|
|
if (WOLFSSL_IS_QUIC(s)) {
|
|
return wolfSSL_quic_do_handshake(s);
|
|
}
|
|
#endif
|
|
return wolfSSL_SSL_do_handshake_internal(s);
|
|
}
|
|
|
|
#if defined(OPENSSL_VERSION_NUMBER) && OPENSSL_VERSION_NUMBER >= 0x10100000L
|
|
int wolfSSL_SSL_in_init(const WOLFSSL *ssl)
|
|
#else
|
|
int wolfSSL_SSL_in_init(WOLFSSL *ssl)
|
|
#endif
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_SSL_in_init");
|
|
|
|
return !wolfSSL_is_init_finished(ssl);
|
|
}
|
|
|
|
int wolfSSL_SSL_in_before(const WOLFSSL *ssl)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_SSL_in_before");
|
|
|
|
if (ssl == NULL)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
return ssl->options.handShakeState == NULL_STATE;
|
|
}
|
|
|
|
int wolfSSL_SSL_in_connect_init(WOLFSSL* ssl)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_SSL_in_connect_init");
|
|
|
|
if (ssl == NULL)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
if (ssl->options.side == WOLFSSL_CLIENT_END) {
|
|
return ssl->options.connectState > CONNECT_BEGIN &&
|
|
ssl->options.connectState < SECOND_REPLY_DONE;
|
|
}
|
|
|
|
return ssl->options.acceptState > ACCEPT_BEGIN &&
|
|
ssl->options.acceptState < ACCEPT_THIRD_REPLY_DONE;
|
|
}
|
|
|
|
#ifndef NO_SESSION_CACHE
|
|
|
|
WOLFSSL_SESSION *wolfSSL_SSL_get0_session(const WOLFSSL *ssl)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_SSL_get0_session");
|
|
|
|
return ssl->session;
|
|
}
|
|
|
|
#endif /* NO_SESSION_CACHE */
|
|
|
|
#if defined(HAVE_SESSION_TICKET) && !defined(NO_WOLFSSL_SERVER)
|
|
/* Expected return values from implementations of OpenSSL ticket key callback.
|
|
*/
|
|
#define TICKET_KEY_CB_RET_FAILURE (-1)
|
|
#define TICKET_KEY_CB_RET_NOT_FOUND 0
|
|
#define TICKET_KEY_CB_RET_OK 1
|
|
#define TICKET_KEY_CB_RET_RENEW 2
|
|
|
|
/* Implementation of session ticket encryption/decryption using OpenSSL
|
|
* callback to initialize the cipher and HMAC.
|
|
*
|
|
* ssl The SSL/TLS object.
|
|
* keyName The key name - used to identify the key to be used.
|
|
* iv The IV to use.
|
|
* mac The MAC of the encrypted data.
|
|
* enc Encrypt ticket.
|
|
* encTicket The ticket data.
|
|
* encTicketLen The length of the ticket data.
|
|
* encLen The encrypted/decrypted ticket length - output length.
|
|
* ctx Ignored. Application specific data.
|
|
* returns WOLFSSL_TICKET_RET_OK to indicate success,
|
|
* WOLFSSL_TICKET_RET_CREATE if a new ticket is required and
|
|
* WOLFSSL_TICKET_RET_FATAL on error.
|
|
*/
|
|
static int wolfSSL_TicketKeyCb(WOLFSSL* ssl,
|
|
unsigned char keyName[WOLFSSL_TICKET_NAME_SZ],
|
|
unsigned char iv[WOLFSSL_TICKET_IV_SZ],
|
|
unsigned char mac[WOLFSSL_TICKET_MAC_SZ],
|
|
int enc, unsigned char* encTicket,
|
|
int encTicketLen, int* encLen, void* ctx)
|
|
{
|
|
byte digest[WC_MAX_DIGEST_SIZE];
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
WOLFSSL_EVP_CIPHER_CTX *evpCtx;
|
|
#else
|
|
WOLFSSL_EVP_CIPHER_CTX evpCtx[1];
|
|
#endif
|
|
WOLFSSL_HMAC_CTX hmacCtx;
|
|
unsigned int mdSz = 0;
|
|
int len = 0;
|
|
int ret = WOLFSSL_TICKET_RET_FATAL;
|
|
int res;
|
|
int totalSz = 0;
|
|
|
|
(void)ctx;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_TicketKeyCb");
|
|
|
|
if (ssl == NULL || ssl->ctx == NULL || ssl->ctx->ticketEncWrapCb == NULL) {
|
|
WOLFSSL_MSG("Bad parameter");
|
|
return WOLFSSL_TICKET_RET_FATAL;
|
|
}
|
|
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
evpCtx = (WOLFSSL_EVP_CIPHER_CTX *)XMALLOC(sizeof(*evpCtx), ssl->heap,
|
|
DYNAMIC_TYPE_TMP_BUFFER);
|
|
if (evpCtx == NULL) {
|
|
WOLFSSL_MSG("out of memory");
|
|
return WOLFSSL_TICKET_RET_FATAL;
|
|
}
|
|
#endif
|
|
|
|
/* Initialize the cipher and HMAC. */
|
|
wolfSSL_EVP_CIPHER_CTX_init(evpCtx);
|
|
if (wolfSSL_HMAC_CTX_Init(&hmacCtx) != WOLFSSL_SUCCESS) {
|
|
WOLFSSL_MSG("wolfSSL_HMAC_CTX_Init error");
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
XFREE(evpCtx, ssl->heap, DYNAMIC_TYPE_TMP_BUFFER);
|
|
#endif
|
|
return WOLFSSL_TICKET_RET_FATAL;
|
|
}
|
|
res = ssl->ctx->ticketEncWrapCb(ssl, keyName,
|
|
iv, evpCtx, &hmacCtx, enc);
|
|
if (res != TICKET_KEY_CB_RET_OK && res != TICKET_KEY_CB_RET_RENEW) {
|
|
WOLFSSL_MSG("Ticket callback error");
|
|
ret = WOLFSSL_TICKET_RET_FATAL;
|
|
goto end;
|
|
}
|
|
|
|
if (wolfSSL_HMAC_size(&hmacCtx) > WOLFSSL_TICKET_MAC_SZ) {
|
|
WOLFSSL_MSG("Ticket cipher MAC size error");
|
|
goto end;
|
|
}
|
|
|
|
if (enc)
|
|
{
|
|
/* Encrypt in place. */
|
|
if (!wolfSSL_EVP_CipherUpdate(evpCtx, encTicket, &len,
|
|
encTicket, encTicketLen))
|
|
goto end;
|
|
totalSz = len;
|
|
if (totalSz > *encLen)
|
|
goto end;
|
|
if (!wolfSSL_EVP_EncryptFinal(evpCtx, &encTicket[len], &len))
|
|
goto end;
|
|
/* Total length of encrypted data. */
|
|
totalSz += len;
|
|
if (totalSz > *encLen)
|
|
goto end;
|
|
|
|
/* HMAC the encrypted data into the parameter 'mac'. */
|
|
if (!wolfSSL_HMAC_Update(&hmacCtx, encTicket, totalSz))
|
|
goto end;
|
|
if (!wolfSSL_HMAC_Final(&hmacCtx, mac, &mdSz))
|
|
goto end;
|
|
}
|
|
else
|
|
{
|
|
/* HMAC the encrypted data and compare it to the passed in data. */
|
|
if (!wolfSSL_HMAC_Update(&hmacCtx, encTicket, encTicketLen))
|
|
goto end;
|
|
if (!wolfSSL_HMAC_Final(&hmacCtx, digest, &mdSz))
|
|
goto end;
|
|
if (XMEMCMP(mac, digest, mdSz) != 0)
|
|
goto end;
|
|
|
|
/* Decrypt the ticket data in place. */
|
|
if (!wolfSSL_EVP_CipherUpdate(evpCtx, encTicket, &len,
|
|
encTicket, encTicketLen))
|
|
goto end;
|
|
totalSz = len;
|
|
if (totalSz > encTicketLen)
|
|
goto end;
|
|
if (!wolfSSL_EVP_DecryptFinal(evpCtx, &encTicket[len], &len))
|
|
goto end;
|
|
/* Total length of decrypted data. */
|
|
totalSz += len;
|
|
if (totalSz > encTicketLen)
|
|
goto end;
|
|
}
|
|
*encLen = totalSz;
|
|
|
|
if (res == TICKET_KEY_CB_RET_RENEW && !IsAtLeastTLSv1_3(ssl->version)
|
|
&& !enc)
|
|
ret = WOLFSSL_TICKET_RET_CREATE;
|
|
else
|
|
ret = WOLFSSL_TICKET_RET_OK;
|
|
end:
|
|
|
|
(void)wc_HmacFree(&hmacCtx.hmac);
|
|
(void)wolfSSL_EVP_CIPHER_CTX_cleanup(evpCtx);
|
|
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
XFREE(evpCtx, ssl->heap, DYNAMIC_TYPE_TMP_BUFFER);
|
|
#endif
|
|
|
|
return ret;
|
|
}
|
|
|
|
/* Set the callback to use when encrypting/decrypting tickets.
|
|
*
|
|
* ctx The SSL/TLS context object.
|
|
* cb The OpenSSL session ticket callback.
|
|
* returns WOLFSSL_SUCCESS to indicate success.
|
|
*/
|
|
int wolfSSL_CTX_set_tlsext_ticket_key_cb(WOLFSSL_CTX *ctx, ticketCompatCb cb)
|
|
{
|
|
|
|
/* Set the ticket encryption callback to be a wrapper around OpenSSL
|
|
* callback.
|
|
*/
|
|
ctx->ticketEncCb = wolfSSL_TicketKeyCb;
|
|
ctx->ticketEncWrapCb = cb;
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
#endif /* HAVE_SESSION_TICKET */
|
|
|
|
#endif /* OPENSSL_ALL || WOLFSSL_NGINX || WOLFSSL_HAPROXY ||
|
|
OPENSSL_EXTRA || HAVE_LIGHTY */
|
|
|
|
#if defined(HAVE_SESSION_TICKET) && !defined(WOLFSSL_NO_DEF_TICKET_ENC_CB) && \
|
|
!defined(NO_WOLFSSL_SERVER)
|
|
/* Serialize the session ticket encryption keys.
|
|
*
|
|
* @param [in] ctx SSL/TLS context object.
|
|
* @param [in] keys Buffer to hold session ticket keys.
|
|
* @param [in] keylen Length of buffer.
|
|
* @return WOLFSSL_SUCCESS on success.
|
|
* @return WOLFSSL_FAILURE when ctx is NULL, keys is NULL or keylen is not the
|
|
* correct length.
|
|
*/
|
|
long wolfSSL_CTX_get_tlsext_ticket_keys(WOLFSSL_CTX *ctx,
|
|
unsigned char *keys, int keylen)
|
|
{
|
|
if (ctx == NULL || keys == NULL) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
if (keylen != WOLFSSL_TICKET_KEYS_SZ) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
XMEMCPY(keys, ctx->ticketKeyCtx.name, WOLFSSL_TICKET_NAME_SZ);
|
|
keys += WOLFSSL_TICKET_NAME_SZ;
|
|
XMEMCPY(keys, ctx->ticketKeyCtx.key[0], WOLFSSL_TICKET_KEY_SZ);
|
|
keys += WOLFSSL_TICKET_KEY_SZ;
|
|
XMEMCPY(keys, ctx->ticketKeyCtx.key[1], WOLFSSL_TICKET_KEY_SZ);
|
|
keys += WOLFSSL_TICKET_KEY_SZ;
|
|
c32toa(ctx->ticketKeyCtx.expirary[0], keys);
|
|
keys += OPAQUE32_LEN;
|
|
c32toa(ctx->ticketKeyCtx.expirary[1], keys);
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
/* Deserialize the session ticket encryption keys.
|
|
*
|
|
* @param [in] ctx SSL/TLS context object.
|
|
* @param [in] keys Session ticket keys.
|
|
* @param [in] keylen Length of data.
|
|
* @return WOLFSSL_SUCCESS on success.
|
|
* @return WOLFSSL_FAILURE when ctx is NULL, keys is NULL or keylen is not the
|
|
* correct length.
|
|
*/
|
|
long wolfSSL_CTX_set_tlsext_ticket_keys(WOLFSSL_CTX *ctx,
|
|
unsigned char *keys, int keylen)
|
|
{
|
|
if (ctx == NULL || keys == NULL) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
if (keylen != WOLFSSL_TICKET_KEYS_SZ) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
XMEMCPY(ctx->ticketKeyCtx.name, keys, WOLFSSL_TICKET_NAME_SZ);
|
|
keys += WOLFSSL_TICKET_NAME_SZ;
|
|
XMEMCPY(ctx->ticketKeyCtx.key[0], keys, WOLFSSL_TICKET_KEY_SZ);
|
|
keys += WOLFSSL_TICKET_KEY_SZ;
|
|
XMEMCPY(ctx->ticketKeyCtx.key[1], keys, WOLFSSL_TICKET_KEY_SZ);
|
|
keys += WOLFSSL_TICKET_KEY_SZ;
|
|
ato32(keys, &ctx->ticketKeyCtx.expirary[0]);
|
|
keys += OPAQUE32_LEN;
|
|
ato32(keys, &ctx->ticketKeyCtx.expirary[1]);
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
#endif
|
|
|
|
#if defined(OPENSSL_ALL) || defined(WOLFSSL_NGINX) || defined(WOLFSSL_HAPROXY)
|
|
#ifdef HAVE_OCSP
|
|
/* Not an OpenSSL API. */
|
|
int wolfSSL_get_ocsp_response(WOLFSSL* ssl, byte** response)
|
|
{
|
|
*response = ssl->ocspResp;
|
|
return ssl->ocspRespSz;
|
|
}
|
|
|
|
/* Not an OpenSSL API. */
|
|
char* wolfSSL_get_ocsp_url(WOLFSSL* ssl)
|
|
{
|
|
return ssl->url;
|
|
}
|
|
|
|
/* Not an OpenSSL API. */
|
|
int wolfSSL_set_ocsp_url(WOLFSSL* ssl, char* url)
|
|
{
|
|
if (ssl == NULL)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
ssl->url = url;
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
#endif /* OCSP */
|
|
#endif /* OPENSSL_ALL || WOLFSSL_NGINX || WOLFSSL_HAPROXY */
|
|
|
|
#if defined(HAVE_OCSP) && !defined(NO_ASN_TIME)
|
|
int wolfSSL_get_ocsp_producedDate(
|
|
WOLFSSL *ssl,
|
|
byte *producedDate,
|
|
size_t producedDate_space,
|
|
int *producedDateFormat)
|
|
{
|
|
if ((ssl->ocspProducedDateFormat != ASN_UTC_TIME) &&
|
|
(ssl->ocspProducedDateFormat != ASN_GENERALIZED_TIME))
|
|
return BAD_FUNC_ARG;
|
|
|
|
if ((producedDate == NULL) || (producedDateFormat == NULL))
|
|
return BAD_FUNC_ARG;
|
|
|
|
if (XSTRLEN((char *)ssl->ocspProducedDate) >= producedDate_space)
|
|
return BUFFER_E;
|
|
|
|
XSTRNCPY((char *)producedDate, (const char *)ssl->ocspProducedDate, producedDate_space);
|
|
*producedDateFormat = ssl->ocspProducedDateFormat;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int wolfSSL_get_ocsp_producedDate_tm(WOLFSSL *ssl, struct tm *produced_tm) {
|
|
int idx = 0;
|
|
|
|
if ((ssl->ocspProducedDateFormat != ASN_UTC_TIME) &&
|
|
(ssl->ocspProducedDateFormat != ASN_GENERALIZED_TIME))
|
|
return BAD_FUNC_ARG;
|
|
|
|
if (produced_tm == NULL)
|
|
return BAD_FUNC_ARG;
|
|
|
|
if (ExtractDate(ssl->ocspProducedDate,
|
|
(unsigned char)ssl->ocspProducedDateFormat, produced_tm, &idx))
|
|
return 0;
|
|
else
|
|
return ASN_PARSE_E;
|
|
}
|
|
#endif
|
|
|
|
|
|
#if defined(WOLFSSL_NGINX) || defined(WOLFSSL_HAPROXY) || \
|
|
defined(OPENSSL_EXTRA) || defined(OPENSSL_ALL)
|
|
int wolfSSL_CTX_get_extra_chain_certs(WOLFSSL_CTX* ctx, WOLF_STACK_OF(X509)** chain)
|
|
{
|
|
word32 idx;
|
|
word32 length;
|
|
WOLFSSL_STACK* node;
|
|
WOLFSSL_STACK* last = NULL;
|
|
|
|
if (ctx == NULL || chain == NULL) {
|
|
chain = NULL;
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
if (ctx->x509Chain != NULL) {
|
|
*chain = ctx->x509Chain;
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
/* If there are no chains then success! */
|
|
*chain = NULL;
|
|
if (ctx->certChain == NULL || ctx->certChain->length == 0) {
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
/* Create a new stack of WOLFSSL_X509 object from chain buffer. */
|
|
for (idx = 0; idx < ctx->certChain->length; ) {
|
|
node = wolfSSL_sk_X509_new_null();
|
|
if (node == NULL)
|
|
return WOLFSSL_FAILURE;
|
|
node->next = NULL;
|
|
|
|
/* 3 byte length | X509 DER data */
|
|
ato24(ctx->certChain->buffer + idx, &length);
|
|
idx += 3;
|
|
|
|
/* Create a new X509 from DER encoded data. */
|
|
node->data.x509 = wolfSSL_X509_d2i(NULL, ctx->certChain->buffer + idx,
|
|
length);
|
|
if (node->data.x509 == NULL) {
|
|
XFREE(node, NULL, DYNAMIC_TYPE_OPENSSL);
|
|
/* Return as much of the chain as we created. */
|
|
ctx->x509Chain = *chain;
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
idx += length;
|
|
|
|
/* Add object to the end of the stack. */
|
|
if (last == NULL) {
|
|
node->num = 1;
|
|
*chain = node;
|
|
}
|
|
else {
|
|
(*chain)->num++;
|
|
last->next = node;
|
|
}
|
|
|
|
last = node;
|
|
}
|
|
|
|
ctx->x509Chain = *chain;
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
int wolfSSL_CTX_get_tlsext_status_cb(WOLFSSL_CTX* ctx, tlsextStatusCb* cb)
|
|
{
|
|
if (ctx == NULL || ctx->cm == NULL || cb == NULL)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
#if !defined(NO_WOLFSSL_SERVER) && (defined(HAVE_CERTIFICATE_STATUS_REQUEST) \
|
|
|| defined(HAVE_CERTIFICATE_STATUS_REQUEST_V2))
|
|
if (ctx->cm->ocsp_stapling == NULL)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
*cb = ctx->cm->ocsp_stapling->statusCb;
|
|
#else
|
|
(void)cb;
|
|
*cb = NULL;
|
|
#endif
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
|
|
}
|
|
|
|
int wolfSSL_CTX_set_tlsext_status_cb(WOLFSSL_CTX* ctx, tlsextStatusCb cb)
|
|
{
|
|
if (ctx == NULL || ctx->cm == NULL)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
#if !defined(NO_WOLFSSL_SERVER) && (defined(HAVE_CERTIFICATE_STATUS_REQUEST) \
|
|
|| defined(HAVE_CERTIFICATE_STATUS_REQUEST_V2))
|
|
/* Ensure stapling is on for callback to be used. */
|
|
wolfSSL_CTX_EnableOCSPStapling(ctx);
|
|
|
|
if (ctx->cm->ocsp_stapling == NULL)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
ctx->cm->ocsp_stapling->statusCb = cb;
|
|
#else
|
|
(void)cb;
|
|
#endif
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
int wolfSSL_CTX_get0_chain_certs(WOLFSSL_CTX *ctx,
|
|
WOLF_STACK_OF(WOLFSSL_X509) **sk)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_get0_chain_certs");
|
|
if (ctx == NULL || sk == NULL) {
|
|
WOLFSSL_MSG("Bad parameter");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
/* This function should return ctx->x509Chain if it is populated, otherwise
|
|
it should be populated from ctx->certChain. This matches the behavior of
|
|
wolfSSL_CTX_get_extra_chain_certs, so it is used directly. */
|
|
return wolfSSL_CTX_get_extra_chain_certs(ctx, sk);
|
|
}
|
|
|
|
#ifdef KEEP_OUR_CERT
|
|
int wolfSSL_get0_chain_certs(WOLFSSL *ssl,
|
|
WOLF_STACK_OF(WOLFSSL_X509) **sk)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_get0_chain_certs");
|
|
if (ssl == NULL || sk == NULL) {
|
|
WOLFSSL_MSG("Bad parameter");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
*sk = ssl->ourCertChain;
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
#endif
|
|
|
|
WOLF_STACK_OF(WOLFSSL_STRING)* wolfSSL_sk_WOLFSSL_STRING_new(void)
|
|
{
|
|
WOLF_STACK_OF(WOLFSSL_STRING)* ret = wolfSSL_sk_new_node(NULL);
|
|
|
|
if (ret) {
|
|
ret->type = STACK_TYPE_STRING;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
void wolfSSL_WOLFSSL_STRING_free(WOLFSSL_STRING s)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_WOLFSSL_STRING_free");
|
|
|
|
if (s != NULL)
|
|
XFREE(s, NULL, DYNAMIC_TYPE_OPENSSL);
|
|
}
|
|
|
|
void wolfSSL_sk_WOLFSSL_STRING_free(WOLF_STACK_OF(WOLFSSL_STRING)* sk)
|
|
{
|
|
WOLFSSL_STACK* tmp;
|
|
WOLFSSL_ENTER("wolfSSL_sk_WOLFSSL_STRING_free");
|
|
|
|
if (sk == NULL)
|
|
return;
|
|
|
|
/* parse through stack freeing each node */
|
|
while (sk) {
|
|
tmp = sk->next;
|
|
XFREE(sk->data.string, NULL, DYNAMIC_TYPE_OPENSSL);
|
|
XFREE(sk, NULL, DYNAMIC_TYPE_OPENSSL);
|
|
sk = tmp;
|
|
}
|
|
}
|
|
|
|
WOLFSSL_STRING wolfSSL_sk_WOLFSSL_STRING_value(WOLF_STACK_OF(WOLFSSL_STRING)* strings,
|
|
int idx)
|
|
{
|
|
for (; idx > 0 && strings != NULL; idx--)
|
|
strings = strings->next;
|
|
if (strings == NULL)
|
|
return NULL;
|
|
return strings->data.string;
|
|
}
|
|
|
|
int wolfSSL_sk_WOLFSSL_STRING_num(WOLF_STACK_OF(WOLFSSL_STRING)* strings)
|
|
{
|
|
if (strings)
|
|
return (int)strings->num;
|
|
return 0;
|
|
}
|
|
|
|
#endif /* WOLFSSL_NGINX || WOLFSSL_HAPROXY || OPENSSL_EXTRA || OPENSSL_ALL */
|
|
|
|
#if defined(OPENSSL_ALL) || defined(WOLFSSL_NGINX) || \
|
|
defined(WOLFSSL_HAPROXY) || defined(HAVE_LIGHTY) || \
|
|
defined(WOLFSSL_QUIC)
|
|
#ifdef HAVE_ALPN
|
|
void wolfSSL_get0_alpn_selected(const WOLFSSL *ssl, const unsigned char **data,
|
|
unsigned int *len)
|
|
{
|
|
word16 nameLen;
|
|
|
|
if (ssl != NULL && data != NULL && len != NULL) {
|
|
TLSX_ALPN_GetRequest(ssl->extensions, (void **)data, &nameLen);
|
|
*len = nameLen;
|
|
}
|
|
}
|
|
|
|
int wolfSSL_select_next_proto(unsigned char **out, unsigned char *outLen,
|
|
const unsigned char *in, unsigned int inLen,
|
|
const unsigned char *clientNames,
|
|
unsigned int clientLen)
|
|
{
|
|
unsigned int i, j;
|
|
byte lenIn, lenClient;
|
|
|
|
if (out == NULL || outLen == NULL || in == NULL || clientNames == NULL)
|
|
return OPENSSL_NPN_UNSUPPORTED;
|
|
|
|
for (i = 0; i < inLen; i += lenIn) {
|
|
lenIn = in[i++];
|
|
for (j = 0; j < clientLen; j += lenClient) {
|
|
lenClient = clientNames[j++];
|
|
|
|
if (lenIn != lenClient)
|
|
continue;
|
|
|
|
if (XMEMCMP(in + i, clientNames + j, lenIn) == 0) {
|
|
*out = (unsigned char *)(in + i);
|
|
*outLen = lenIn;
|
|
return OPENSSL_NPN_NEGOTIATED;
|
|
}
|
|
}
|
|
}
|
|
|
|
*out = (unsigned char *)clientNames + 1;
|
|
*outLen = clientNames[0];
|
|
return OPENSSL_NPN_NO_OVERLAP;
|
|
}
|
|
|
|
void wolfSSL_set_alpn_select_cb(WOLFSSL *ssl,
|
|
int (*cb) (WOLFSSL *ssl,
|
|
const unsigned char **out,
|
|
unsigned char *outlen,
|
|
const unsigned char *in,
|
|
unsigned int inlen,
|
|
void *arg), void *arg)
|
|
{
|
|
if (ssl != NULL) {
|
|
ssl->alpnSelect = cb;
|
|
ssl->alpnSelectArg = arg;
|
|
}
|
|
}
|
|
|
|
void wolfSSL_CTX_set_alpn_select_cb(WOLFSSL_CTX *ctx,
|
|
int (*cb) (WOLFSSL *ssl,
|
|
const unsigned char **out,
|
|
unsigned char *outlen,
|
|
const unsigned char *in,
|
|
unsigned int inlen,
|
|
void *arg), void *arg)
|
|
{
|
|
if (ctx != NULL) {
|
|
ctx->alpnSelect = cb;
|
|
ctx->alpnSelectArg = arg;
|
|
}
|
|
}
|
|
|
|
void wolfSSL_CTX_set_next_protos_advertised_cb(WOLFSSL_CTX *s,
|
|
int (*cb) (WOLFSSL *ssl,
|
|
const unsigned char
|
|
**out,
|
|
unsigned int *outlen,
|
|
void *arg), void *arg)
|
|
{
|
|
(void)s;
|
|
(void)cb;
|
|
(void)arg;
|
|
WOLFSSL_STUB("wolfSSL_CTX_set_next_protos_advertised_cb");
|
|
}
|
|
|
|
void wolfSSL_CTX_set_next_proto_select_cb(WOLFSSL_CTX *s,
|
|
int (*cb) (WOLFSSL *ssl,
|
|
unsigned char **out,
|
|
unsigned char *outlen,
|
|
const unsigned char *in,
|
|
unsigned int inlen,
|
|
void *arg), void *arg)
|
|
{
|
|
(void)s;
|
|
(void)cb;
|
|
(void)arg;
|
|
WOLFSSL_STUB("wolfSSL_CTX_set_next_proto_select_cb");
|
|
}
|
|
|
|
void wolfSSL_get0_next_proto_negotiated(const WOLFSSL *s, const unsigned char **data,
|
|
unsigned *len)
|
|
{
|
|
(void)s;
|
|
(void)data;
|
|
(void)len;
|
|
WOLFSSL_STUB("wolfSSL_get0_next_proto_negotiated");
|
|
}
|
|
#endif /* HAVE_ALPN */
|
|
|
|
#endif /* WOLFSSL_NGINX / WOLFSSL_HAPROXY */
|
|
|
|
#if defined(OPENSSL_EXTRA) || defined(HAVE_CURL)
|
|
int wolfSSL_curve_is_disabled(const WOLFSSL* ssl, word16 curve_id)
|
|
{
|
|
if (curve_id >= WOLFSSL_FFDHE_START) {
|
|
/* DH parameters are never disabled. */
|
|
return 0;
|
|
}
|
|
if (curve_id > WOLFSSL_ECC_MAX_AVAIL) {
|
|
WOLFSSL_MSG("Curve id out of supported range");
|
|
/* Disabled if not in valid range. */
|
|
return 1;
|
|
}
|
|
if (curve_id >= 32) {
|
|
/* 0 is for invalid and 1-14 aren't used otherwise. */
|
|
return (ssl->disabledCurves & (1 << (curve_id - 32))) != 0;
|
|
}
|
|
return (ssl->disabledCurves & (1 << curve_id)) != 0;
|
|
}
|
|
|
|
#if (defined(HAVE_ECC) || \
|
|
defined(HAVE_CURVE25519) || defined(HAVE_CURVE448))
|
|
static int set_curves_list(WOLFSSL* ssl, WOLFSSL_CTX *ctx, const char* names)
|
|
{
|
|
int idx, start = 0, len, i, ret = WOLFSSL_FAILURE;
|
|
word16 curve;
|
|
word32 disabled;
|
|
char name[MAX_CURVE_NAME_SZ];
|
|
byte groups_len = 0;
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
void *heap = ssl? ssl->heap : ctx ? ctx->heap : NULL;
|
|
int *groups;
|
|
#else
|
|
int groups[WOLFSSL_MAX_GROUP_COUNT];
|
|
#endif
|
|
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
groups = (int*)XMALLOC(sizeof(int)*WOLFSSL_MAX_GROUP_COUNT,
|
|
heap, DYNAMIC_TYPE_TMP_BUFFER);
|
|
if (groups == NULL) {
|
|
ret = MEMORY_E;
|
|
goto leave;
|
|
}
|
|
#endif
|
|
|
|
for (idx = 1; names[idx-1] != '\0'; idx++) {
|
|
if (names[idx] != ':' && names[idx] != '\0')
|
|
continue;
|
|
|
|
len = idx - start;
|
|
if (len > MAX_CURVE_NAME_SZ - 1)
|
|
goto leave;
|
|
|
|
XMEMCPY(name, names + start, len);
|
|
name[len++] = 0;
|
|
|
|
/* Use XSTRNCMP to avoid valgrind error. */
|
|
if ((XSTRNCMP(name, "prime256v1", len) == 0) ||
|
|
(XSTRNCMP(name, "secp256r1", len) == 0) ||
|
|
(XSTRNCMP(name, "P-256", len) == 0))
|
|
{
|
|
curve = WOLFSSL_ECC_SECP256R1;
|
|
}
|
|
else if ((XSTRNCMP(name, "secp384r1", len) == 0) ||
|
|
(XSTRNCMP(name, "P-384", len) == 0))
|
|
{
|
|
curve = WOLFSSL_ECC_SECP384R1;
|
|
}
|
|
else if ((XSTRNCMP(name, "secp521r1", len) == 0) ||
|
|
(XSTRNCMP(name, "P-521", len) == 0))
|
|
{
|
|
curve = WOLFSSL_ECC_SECP521R1;
|
|
}
|
|
#ifdef WOLFSSL_SM2
|
|
else if ((XSTRNCMP(name, "sm2p256v1", len) == 0) ||
|
|
(XSTRNCMP(name, "SM2", len) == 0))
|
|
{
|
|
curve = WOLFSSL_ECC_SM2P256V1;
|
|
}
|
|
#endif
|
|
#ifdef HAVE_CURVE25519
|
|
else if (XSTRNCMP(name, "X25519", len) == 0)
|
|
{
|
|
curve = WOLFSSL_ECC_X25519;
|
|
}
|
|
#endif
|
|
#ifdef HAVE_CURVE448
|
|
else if (XSTRNCMP(name, "X448", len) == 0)
|
|
{
|
|
curve = WOLFSSL_ECC_X448;
|
|
}
|
|
#endif
|
|
else {
|
|
#if !defined(HAVE_FIPS) && !defined(HAVE_SELFTEST)
|
|
int nret;
|
|
const ecc_set_type *eccSet;
|
|
|
|
nret = wc_ecc_get_curve_idx_from_name(name);
|
|
if (nret < 0) {
|
|
WOLFSSL_MSG("Could not find name in set");
|
|
goto leave;
|
|
}
|
|
|
|
eccSet = wc_ecc_get_curve_params(ret);
|
|
if (eccSet == NULL) {
|
|
WOLFSSL_MSG("NULL set returned");
|
|
goto leave;
|
|
}
|
|
|
|
curve = GetCurveByOID(eccSet->oidSum);
|
|
#else
|
|
WOLFSSL_MSG("API not present to search farther using name");
|
|
goto leave;
|
|
#endif
|
|
}
|
|
|
|
if (curve >= WOLFSSL_ECC_MAX_AVAIL) {
|
|
WOLFSSL_MSG("curve value is not supported");
|
|
goto leave;
|
|
}
|
|
|
|
for (i = 0; i < groups_len; ++i) {
|
|
if (groups[i] == curve) {
|
|
/* silently drop duplicates */
|
|
break;
|
|
}
|
|
}
|
|
if (i >= groups_len) {
|
|
if (groups_len >= WOLFSSL_MAX_GROUP_COUNT) {
|
|
WOLFSSL_MSG_EX("setting %d or more supported "
|
|
"curves is not permitted", groups_len);
|
|
goto leave;
|
|
}
|
|
groups[groups_len++] = (int)curve;
|
|
}
|
|
|
|
start = idx + 1;
|
|
}
|
|
|
|
/* Disable all curves so that only the ones the user wants are enabled. */
|
|
disabled = 0xFFFFFFFFUL;
|
|
for (i = 0; i < groups_len; ++i) {
|
|
/* Switch the bit to off and therefore is enabled. */
|
|
curve = (word16)groups[i];
|
|
if (curve >= 32) {
|
|
/* 0 is for invalid and 1-14 aren't used otherwise. */
|
|
disabled &= ~(1U << (curve - 32));
|
|
}
|
|
else {
|
|
disabled &= ~(1U << curve);
|
|
}
|
|
#ifdef HAVE_SUPPORTED_CURVES
|
|
#if defined(WOLFSSL_TLS13) && !defined(WOLFSSL_OLD_SET_CURVES_LIST)
|
|
/* using the wolfSSL API to set the groups, this will populate
|
|
* (ssl|ctx)->groups and reset any TLSX_SUPPORTED_GROUPS.
|
|
* The order in (ssl|ctx)->groups will then be respected
|
|
* when TLSX_KEY_SHARE needs to be established */
|
|
if ((ssl && wolfSSL_set_groups(ssl, groups, groups_len)
|
|
!= WOLFSSL_SUCCESS)
|
|
|| (ctx && wolfSSL_CTX_set_groups(ctx, groups, groups_len)
|
|
!= WOLFSSL_SUCCESS)) {
|
|
WOLFSSL_MSG("Unable to set supported curve");
|
|
goto leave;
|
|
}
|
|
#elif !defined(NO_WOLFSSL_CLIENT)
|
|
/* set the supported curve so client TLS extension contains only the
|
|
* desired curves */
|
|
if ((ssl && wolfSSL_UseSupportedCurve(ssl, curve) != WOLFSSL_SUCCESS)
|
|
|| (ctx && wolfSSL_CTX_UseSupportedCurve(ctx, curve)
|
|
!= WOLFSSL_SUCCESS)) {
|
|
WOLFSSL_MSG("Unable to set supported curve");
|
|
goto leave;
|
|
}
|
|
#endif
|
|
#endif /* HAVE_SUPPORTED_CURVES */
|
|
}
|
|
|
|
if (ssl)
|
|
ssl->disabledCurves = disabled;
|
|
else
|
|
ctx->disabledCurves = disabled;
|
|
ret = WOLFSSL_SUCCESS;
|
|
|
|
leave:
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
if (groups)
|
|
XFREE((void*)groups, heap, DYNAMIC_TYPE_TMP_BUFFER);
|
|
#endif
|
|
return ret;
|
|
}
|
|
|
|
int wolfSSL_CTX_set1_curves_list(WOLFSSL_CTX* ctx, const char* names)
|
|
{
|
|
if (ctx == NULL || names == NULL) {
|
|
WOLFSSL_MSG("ctx or names was NULL");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
return set_curves_list(NULL, ctx, names);
|
|
}
|
|
|
|
int wolfSSL_set1_curves_list(WOLFSSL* ssl, const char* names)
|
|
{
|
|
if (ssl == NULL || names == NULL) {
|
|
WOLFSSL_MSG("ssl or names was NULL");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
return set_curves_list(ssl, NULL, names);
|
|
}
|
|
#endif /* (HAVE_ECC || HAVE_CURVE25519 || HAVE_CURVE448) */
|
|
#endif /* OPENSSL_EXTRA || HAVE_CURL */
|
|
|
|
#ifdef OPENSSL_EXTRA
|
|
/* Sets a callback for when sending and receiving protocol messages.
|
|
* This callback is copied to all WOLFSSL objects created from the ctx.
|
|
*
|
|
* ctx WOLFSSL_CTX structure to set callback in
|
|
* cb callback to use
|
|
*
|
|
* return WOLFSSL_SUCCESS on success and WOLFSSL_FAILURE with error case
|
|
*/
|
|
int wolfSSL_CTX_set_msg_callback(WOLFSSL_CTX *ctx, SSL_Msg_Cb cb)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_set_msg_callback");
|
|
if (ctx == NULL) {
|
|
WOLFSSL_MSG("Null ctx passed in");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
ctx->protoMsgCb = cb;
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
|
|
/* Sets a callback for when sending and receiving protocol messages.
|
|
*
|
|
* ssl WOLFSSL structure to set callback in
|
|
* cb callback to use
|
|
*
|
|
* return WOLFSSL_SUCCESS on success and WOLFSSL_FAILURE with error case
|
|
*/
|
|
int wolfSSL_set_msg_callback(WOLFSSL *ssl, SSL_Msg_Cb cb)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_set_msg_callback");
|
|
|
|
if (ssl == NULL) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
if (cb != NULL) {
|
|
ssl->toInfoOn = 1;
|
|
}
|
|
|
|
ssl->protoMsgCb = cb;
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
|
|
/* set the user argument to pass to the msg callback when called
|
|
* return WOLFSSL_SUCCESS on success */
|
|
int wolfSSL_CTX_set_msg_callback_arg(WOLFSSL_CTX *ctx, void* arg)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_set_msg_callback_arg");
|
|
if (ctx == NULL) {
|
|
WOLFSSL_MSG("Null WOLFSSL_CTX passed in");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
ctx->protoMsgCtx = arg;
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
|
|
int wolfSSL_set_msg_callback_arg(WOLFSSL *ssl, void* arg)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_set_msg_callback_arg");
|
|
if (ssl == NULL)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
ssl->protoMsgCtx = arg;
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
void *wolfSSL_OPENSSL_memdup(const void *data, size_t siz, const char* file, int line)
|
|
{
|
|
void *ret;
|
|
(void)file;
|
|
(void)line;
|
|
|
|
if (data == NULL || siz >= INT_MAX)
|
|
return NULL;
|
|
|
|
ret = OPENSSL_malloc(siz);
|
|
if (ret == NULL) {
|
|
return NULL;
|
|
}
|
|
return XMEMCPY(ret, data, siz);
|
|
}
|
|
|
|
void wolfSSL_OPENSSL_cleanse(void *ptr, size_t len)
|
|
{
|
|
if (ptr)
|
|
ForceZero(ptr, (word32)len);
|
|
}
|
|
|
|
int wolfSSL_CTX_set_alpn_protos(WOLFSSL_CTX *ctx, const unsigned char *p,
|
|
unsigned int p_len)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_set_alpn_protos");
|
|
if (ctx == NULL)
|
|
return BAD_FUNC_ARG;
|
|
if (ctx->alpn_cli_protos != NULL) {
|
|
XFREE((void*)ctx->alpn_cli_protos, ctx->heap, DYNAMIC_TYPE_OPENSSL);
|
|
}
|
|
|
|
ctx->alpn_cli_protos = (const unsigned char*)XMALLOC(p_len,
|
|
ctx->heap, DYNAMIC_TYPE_OPENSSL);
|
|
if (ctx->alpn_cli_protos == NULL) {
|
|
#if defined(WOLFSSL_ERROR_CODE_OPENSSL)
|
|
/* 0 on success in OpenSSL, non-0 on failure in OpenSSL
|
|
* the function reverses the return value convention.
|
|
*/
|
|
return 1;
|
|
#else
|
|
return WOLFSSL_FAILURE;
|
|
#endif
|
|
}
|
|
XMEMCPY((void*)ctx->alpn_cli_protos, p, p_len);
|
|
ctx->alpn_cli_protos_len = p_len;
|
|
|
|
#if defined(WOLFSSL_ERROR_CODE_OPENSSL)
|
|
/* 0 on success in OpenSSL, non-0 on failure in OpenSSL
|
|
* the function reverses the return value convention.
|
|
*/
|
|
return 0;
|
|
#else
|
|
return WOLFSSL_SUCCESS;
|
|
#endif
|
|
}
|
|
|
|
|
|
#ifdef HAVE_ALPN
|
|
#ifndef NO_BIO
|
|
/* Sets the ALPN extension protos
|
|
*
|
|
* example format is
|
|
* unsigned char p[] = {
|
|
* 8, 'h', 't', 't', 'p', '/', '1', '.', '1'
|
|
* };
|
|
*
|
|
* returns WOLFSSL_SUCCESS on success */
|
|
int wolfSSL_set_alpn_protos(WOLFSSL* ssl,
|
|
const unsigned char* p, unsigned int p_len)
|
|
{
|
|
WOLFSSL_BIO* bio;
|
|
char* pt = NULL;
|
|
|
|
unsigned int sz;
|
|
unsigned int idx = 0;
|
|
int alpn_opt = WOLFSSL_ALPN_CONTINUE_ON_MISMATCH;
|
|
WOLFSSL_ENTER("wolfSSL_set_alpn_protos");
|
|
|
|
if (ssl == NULL || p_len <= 1) {
|
|
#if defined(WOLFSSL_ERROR_CODE_OPENSSL)
|
|
/* 0 on success in OpenSSL, non-0 on failure in OpenSSL
|
|
* the function reverses the return value convention.
|
|
*/
|
|
return 1;
|
|
#else
|
|
return WOLFSSL_FAILURE;
|
|
#endif
|
|
}
|
|
|
|
bio = wolfSSL_BIO_new(wolfSSL_BIO_s_mem());
|
|
if (bio == NULL) {
|
|
#if defined(WOLFSSL_ERROR_CODE_OPENSSL)
|
|
/* 0 on success in OpenSSL, non-0 on failure in OpenSSL
|
|
* the function reverses the return value convention.
|
|
*/
|
|
return 1;
|
|
#else
|
|
return WOLFSSL_FAILURE;
|
|
#endif
|
|
}
|
|
|
|
/* convert into comma separated list */
|
|
while (idx < p_len - 1) {
|
|
unsigned int i;
|
|
|
|
sz = p[idx++];
|
|
if (idx + sz > p_len) {
|
|
WOLFSSL_MSG("Bad list format");
|
|
wolfSSL_BIO_free(bio);
|
|
#if defined(WOLFSSL_ERROR_CODE_OPENSSL)
|
|
/* 0 on success in OpenSSL, non-0 on failure in OpenSSL
|
|
* the function reverses the return value convention.
|
|
*/
|
|
return 1;
|
|
#else
|
|
return WOLFSSL_FAILURE;
|
|
#endif
|
|
}
|
|
if (sz > 0) {
|
|
for (i = 0; i < sz; i++) {
|
|
wolfSSL_BIO_write(bio, &p[idx++], 1);
|
|
}
|
|
if (idx < p_len - 1)
|
|
wolfSSL_BIO_write(bio, ",", 1);
|
|
}
|
|
}
|
|
wolfSSL_BIO_write(bio, "\0", 1);
|
|
|
|
/* clears out all current ALPN extensions set */
|
|
TLSX_Remove(&ssl->extensions, TLSX_APPLICATION_LAYER_PROTOCOL, ssl->heap);
|
|
|
|
if ((sz = wolfSSL_BIO_get_mem_data(bio, &pt)) > 0) {
|
|
wolfSSL_UseALPN(ssl, pt, sz, (byte) alpn_opt);
|
|
}
|
|
wolfSSL_BIO_free(bio);
|
|
#if defined(WOLFSSL_ERROR_CODE_OPENSSL)
|
|
/* 0 on success in OpenSSL, non-0 on failure in OpenSSL
|
|
* the function reverses the return value convention.
|
|
*/
|
|
return 0;
|
|
#else
|
|
return WOLFSSL_SUCCESS;
|
|
#endif
|
|
}
|
|
#endif /* !NO_BIO */
|
|
#endif /* HAVE_ALPN */
|
|
#endif /* OPENSSL_EXTRA */
|
|
|
|
#if defined(OPENSSL_EXTRA)
|
|
|
|
#ifndef NO_BIO
|
|
#define WOLFSSL_BIO_INCLUDED
|
|
#include "src/bio.c"
|
|
#endif
|
|
|
|
word32 nid2oid(int nid, int grp)
|
|
{
|
|
/* get OID type */
|
|
switch (grp) {
|
|
/* oidHashType */
|
|
case oidHashType:
|
|
switch (nid) {
|
|
#ifdef WOLFSSL_MD2
|
|
case NID_md2:
|
|
return MD2h;
|
|
#endif
|
|
#ifndef NO_MD5
|
|
case NID_md5:
|
|
return MD5h;
|
|
#endif
|
|
#ifndef NO_SHA
|
|
case NID_sha1:
|
|
return SHAh;
|
|
#endif
|
|
case NID_sha224:
|
|
return SHA224h;
|
|
#ifndef NO_SHA256
|
|
case NID_sha256:
|
|
return SHA256h;
|
|
#endif
|
|
#ifdef WOLFSSL_SHA384
|
|
case NID_sha384:
|
|
return SHA384h;
|
|
#endif
|
|
#ifdef WOLFSSL_SHA512
|
|
case NID_sha512:
|
|
return SHA512h;
|
|
#endif
|
|
#ifndef WOLFSSL_NOSHA3_224
|
|
case NID_sha3_224:
|
|
return SHA3_224h;
|
|
#endif
|
|
#ifndef WOLFSSL_NOSHA3_256
|
|
case NID_sha3_256:
|
|
return SHA3_256h;
|
|
#endif
|
|
#ifndef WOLFSSL_NOSHA3_384
|
|
case NID_sha3_384:
|
|
return SHA3_384h;
|
|
#endif
|
|
#ifndef WOLFSSL_NOSHA3_512
|
|
case NID_sha3_512:
|
|
return SHA3_512h;
|
|
#endif
|
|
}
|
|
break;
|
|
|
|
/* oidSigType */
|
|
case oidSigType:
|
|
switch (nid) {
|
|
#ifndef NO_DSA
|
|
case NID_dsaWithSHA1:
|
|
return CTC_SHAwDSA;
|
|
case NID_dsa_with_SHA256:
|
|
return CTC_SHA256wDSA;
|
|
#endif /* NO_DSA */
|
|
#ifndef NO_RSA
|
|
case NID_md2WithRSAEncryption:
|
|
return CTC_MD2wRSA;
|
|
case NID_md5WithRSAEncryption:
|
|
return CTC_MD5wRSA;
|
|
case NID_sha1WithRSAEncryption:
|
|
return CTC_SHAwRSA;
|
|
case NID_sha224WithRSAEncryption:
|
|
return CTC_SHA224wRSA;
|
|
case NID_sha256WithRSAEncryption:
|
|
return CTC_SHA256wRSA;
|
|
case NID_sha384WithRSAEncryption:
|
|
return CTC_SHA384wRSA;
|
|
case NID_sha512WithRSAEncryption:
|
|
return CTC_SHA512wRSA;
|
|
#ifdef WOLFSSL_SHA3
|
|
case NID_RSA_SHA3_224:
|
|
return CTC_SHA3_224wRSA;
|
|
case NID_RSA_SHA3_256:
|
|
return CTC_SHA3_256wRSA;
|
|
case NID_RSA_SHA3_384:
|
|
return CTC_SHA3_384wRSA;
|
|
case NID_RSA_SHA3_512:
|
|
return CTC_SHA3_512wRSA;
|
|
#endif
|
|
#endif /* NO_RSA */
|
|
#ifdef HAVE_ECC
|
|
case NID_ecdsa_with_SHA1:
|
|
return CTC_SHAwECDSA;
|
|
case NID_ecdsa_with_SHA224:
|
|
return CTC_SHA224wECDSA;
|
|
case NID_ecdsa_with_SHA256:
|
|
return CTC_SHA256wECDSA;
|
|
case NID_ecdsa_with_SHA384:
|
|
return CTC_SHA384wECDSA;
|
|
case NID_ecdsa_with_SHA512:
|
|
return CTC_SHA512wECDSA;
|
|
#ifdef WOLFSSL_SHA3
|
|
case NID_ecdsa_with_SHA3_224:
|
|
return CTC_SHA3_224wECDSA;
|
|
case NID_ecdsa_with_SHA3_256:
|
|
return CTC_SHA3_256wECDSA;
|
|
case NID_ecdsa_with_SHA3_384:
|
|
return CTC_SHA3_384wECDSA;
|
|
case NID_ecdsa_with_SHA3_512:
|
|
return CTC_SHA3_512wECDSA;
|
|
#endif
|
|
#endif /* HAVE_ECC */
|
|
}
|
|
break;
|
|
|
|
/* oidKeyType */
|
|
case oidKeyType:
|
|
switch (nid) {
|
|
#ifndef NO_DSA
|
|
case NID_dsa:
|
|
return DSAk;
|
|
#endif /* NO_DSA */
|
|
#ifndef NO_RSA
|
|
case NID_rsaEncryption:
|
|
return RSAk;
|
|
#endif /* NO_RSA */
|
|
#ifdef HAVE_ECC
|
|
case NID_X9_62_id_ecPublicKey:
|
|
return ECDSAk;
|
|
#endif /* HAVE_ECC */
|
|
}
|
|
break;
|
|
|
|
|
|
#ifdef HAVE_ECC
|
|
case oidCurveType:
|
|
switch (nid) {
|
|
case NID_X9_62_prime192v1:
|
|
return ECC_SECP192R1_OID;
|
|
case NID_X9_62_prime192v2:
|
|
return ECC_PRIME192V2_OID;
|
|
case NID_X9_62_prime192v3:
|
|
return ECC_PRIME192V3_OID;
|
|
case NID_X9_62_prime239v1:
|
|
return ECC_PRIME239V1_OID;
|
|
case NID_X9_62_prime239v2:
|
|
return ECC_PRIME239V2_OID;
|
|
case NID_X9_62_prime239v3:
|
|
return ECC_PRIME239V3_OID;
|
|
case NID_X9_62_prime256v1:
|
|
return ECC_SECP256R1_OID;
|
|
case NID_secp112r1:
|
|
return ECC_SECP112R1_OID;
|
|
case NID_secp112r2:
|
|
return ECC_SECP112R2_OID;
|
|
case NID_secp128r1:
|
|
return ECC_SECP128R1_OID;
|
|
case NID_secp128r2:
|
|
return ECC_SECP128R2_OID;
|
|
case NID_secp160r1:
|
|
return ECC_SECP160R1_OID;
|
|
case NID_secp160r2:
|
|
return ECC_SECP160R2_OID;
|
|
case NID_secp224r1:
|
|
return ECC_SECP224R1_OID;
|
|
case NID_secp384r1:
|
|
return ECC_SECP384R1_OID;
|
|
case NID_secp521r1:
|
|
return ECC_SECP521R1_OID;
|
|
case NID_secp160k1:
|
|
return ECC_SECP160K1_OID;
|
|
case NID_secp192k1:
|
|
return ECC_SECP192K1_OID;
|
|
case NID_secp224k1:
|
|
return ECC_SECP224K1_OID;
|
|
case NID_secp256k1:
|
|
return ECC_SECP256K1_OID;
|
|
case NID_brainpoolP160r1:
|
|
return ECC_BRAINPOOLP160R1_OID;
|
|
case NID_brainpoolP192r1:
|
|
return ECC_BRAINPOOLP192R1_OID;
|
|
case NID_brainpoolP224r1:
|
|
return ECC_BRAINPOOLP224R1_OID;
|
|
case NID_brainpoolP256r1:
|
|
return ECC_BRAINPOOLP256R1_OID;
|
|
case NID_brainpoolP320r1:
|
|
return ECC_BRAINPOOLP320R1_OID;
|
|
case NID_brainpoolP384r1:
|
|
return ECC_BRAINPOOLP384R1_OID;
|
|
case NID_brainpoolP512r1:
|
|
return ECC_BRAINPOOLP512R1_OID;
|
|
}
|
|
break;
|
|
#endif /* HAVE_ECC */
|
|
|
|
/* oidBlkType */
|
|
case oidBlkType:
|
|
switch (nid) {
|
|
#ifdef WOLFSSL_AES_128
|
|
case AES128CBCb:
|
|
return AES128CBCb;
|
|
#endif
|
|
#ifdef WOLFSSL_AES_192
|
|
case AES192CBCb:
|
|
return AES192CBCb;
|
|
#endif
|
|
#ifdef WOLFSSL_AES_256
|
|
case AES256CBCb:
|
|
return AES256CBCb;
|
|
#endif
|
|
#ifndef NO_DES3
|
|
case NID_des:
|
|
return DESb;
|
|
case NID_des3:
|
|
return DES3b;
|
|
#endif
|
|
}
|
|
break;
|
|
|
|
#ifdef HAVE_OCSP
|
|
case oidOcspType:
|
|
switch (nid) {
|
|
case NID_id_pkix_OCSP_basic:
|
|
return OCSP_BASIC_OID;
|
|
case OCSP_NONCE_OID:
|
|
return OCSP_NONCE_OID;
|
|
}
|
|
break;
|
|
#endif /* HAVE_OCSP */
|
|
|
|
/* oidCertExtType */
|
|
case oidCertExtType:
|
|
switch (nid) {
|
|
case NID_basic_constraints:
|
|
return BASIC_CA_OID;
|
|
case NID_subject_alt_name:
|
|
return ALT_NAMES_OID;
|
|
case NID_crl_distribution_points:
|
|
return CRL_DIST_OID;
|
|
case NID_info_access:
|
|
return AUTH_INFO_OID;
|
|
case NID_authority_key_identifier:
|
|
return AUTH_KEY_OID;
|
|
case NID_subject_key_identifier:
|
|
return SUBJ_KEY_OID;
|
|
case NID_inhibit_any_policy:
|
|
return INHIBIT_ANY_OID;
|
|
case NID_key_usage:
|
|
return KEY_USAGE_OID;
|
|
case NID_name_constraints:
|
|
return NAME_CONS_OID;
|
|
case NID_certificate_policies:
|
|
return CERT_POLICY_OID;
|
|
case NID_ext_key_usage:
|
|
return EXT_KEY_USAGE_OID;
|
|
}
|
|
break;
|
|
|
|
/* oidCertAuthInfoType */
|
|
case oidCertAuthInfoType:
|
|
switch (nid) {
|
|
case NID_ad_OCSP:
|
|
return AIA_OCSP_OID;
|
|
case NID_ad_ca_issuers:
|
|
return AIA_CA_ISSUER_OID;
|
|
}
|
|
break;
|
|
|
|
/* oidCertPolicyType */
|
|
case oidCertPolicyType:
|
|
switch (nid) {
|
|
case NID_any_policy:
|
|
return CP_ANY_OID;
|
|
}
|
|
break;
|
|
|
|
/* oidCertAltNameType */
|
|
case oidCertAltNameType:
|
|
switch (nid) {
|
|
case NID_hw_name_oid:
|
|
return HW_NAME_OID;
|
|
}
|
|
break;
|
|
|
|
/* oidCertKeyUseType */
|
|
case oidCertKeyUseType:
|
|
switch (nid) {
|
|
case NID_anyExtendedKeyUsage:
|
|
return EKU_ANY_OID;
|
|
case EKU_SERVER_AUTH_OID:
|
|
return EKU_SERVER_AUTH_OID;
|
|
case EKU_CLIENT_AUTH_OID:
|
|
return EKU_CLIENT_AUTH_OID;
|
|
case EKU_OCSP_SIGN_OID:
|
|
return EKU_OCSP_SIGN_OID;
|
|
}
|
|
break;
|
|
|
|
/* oidKdfType */
|
|
case oidKdfType:
|
|
switch (nid) {
|
|
case PBKDF2_OID:
|
|
return PBKDF2_OID;
|
|
}
|
|
break;
|
|
|
|
/* oidPBEType */
|
|
case oidPBEType:
|
|
switch (nid) {
|
|
case PBE_SHA1_RC4_128:
|
|
return PBE_SHA1_RC4_128;
|
|
case PBE_SHA1_DES:
|
|
return PBE_SHA1_DES;
|
|
case PBE_SHA1_DES3:
|
|
return PBE_SHA1_DES3;
|
|
}
|
|
break;
|
|
|
|
/* oidKeyWrapType */
|
|
case oidKeyWrapType:
|
|
switch (nid) {
|
|
#ifdef WOLFSSL_AES_128
|
|
case AES128_WRAP:
|
|
return AES128_WRAP;
|
|
#endif
|
|
#ifdef WOLFSSL_AES_192
|
|
case AES192_WRAP:
|
|
return AES192_WRAP;
|
|
#endif
|
|
#ifdef WOLFSSL_AES_256
|
|
case AES256_WRAP:
|
|
return AES256_WRAP;
|
|
#endif
|
|
}
|
|
break;
|
|
|
|
/* oidCmsKeyAgreeType */
|
|
case oidCmsKeyAgreeType:
|
|
switch (nid) {
|
|
#ifndef NO_SHA
|
|
case dhSinglePass_stdDH_sha1kdf_scheme:
|
|
return dhSinglePass_stdDH_sha1kdf_scheme;
|
|
#endif
|
|
#ifdef WOLFSSL_SHA224
|
|
case dhSinglePass_stdDH_sha224kdf_scheme:
|
|
return dhSinglePass_stdDH_sha224kdf_scheme;
|
|
#endif
|
|
#ifndef NO_SHA256
|
|
case dhSinglePass_stdDH_sha256kdf_scheme:
|
|
return dhSinglePass_stdDH_sha256kdf_scheme;
|
|
#endif
|
|
#ifdef WOLFSSL_SHA384
|
|
case dhSinglePass_stdDH_sha384kdf_scheme:
|
|
return dhSinglePass_stdDH_sha384kdf_scheme;
|
|
#endif
|
|
#ifdef WOLFSSL_SHA512
|
|
case dhSinglePass_stdDH_sha512kdf_scheme:
|
|
return dhSinglePass_stdDH_sha512kdf_scheme;
|
|
#endif
|
|
}
|
|
break;
|
|
|
|
/* oidCmsKeyAgreeType */
|
|
#ifdef WOLFSSL_CERT_REQ
|
|
case oidCsrAttrType:
|
|
switch (nid) {
|
|
case NID_pkcs9_contentType:
|
|
return PKCS9_CONTENT_TYPE_OID;
|
|
case NID_pkcs9_challengePassword:
|
|
return CHALLENGE_PASSWORD_OID;
|
|
case NID_serialNumber:
|
|
return SERIAL_NUMBER_OID;
|
|
case NID_userId:
|
|
return USER_ID_OID;
|
|
case NID_surname:
|
|
return SURNAME_OID;
|
|
}
|
|
break;
|
|
#endif
|
|
|
|
default:
|
|
WOLFSSL_MSG("NID not in table");
|
|
/* MSVC warns without the cast */
|
|
return (word32)-1;
|
|
}
|
|
|
|
/* MSVC warns without the cast */
|
|
return (word32)-1;
|
|
}
|
|
|
|
int oid2nid(word32 oid, int grp)
|
|
{
|
|
size_t i;
|
|
/* get OID type */
|
|
switch (grp) {
|
|
/* oidHashType */
|
|
case oidHashType:
|
|
switch (oid) {
|
|
#ifdef WOLFSSL_MD2
|
|
case MD2h:
|
|
return NID_md2;
|
|
#endif
|
|
#ifndef NO_MD5
|
|
case MD5h:
|
|
return NID_md5;
|
|
#endif
|
|
#ifndef NO_SHA
|
|
case SHAh:
|
|
return NID_sha1;
|
|
#endif
|
|
case SHA224h:
|
|
return NID_sha224;
|
|
#ifndef NO_SHA256
|
|
case SHA256h:
|
|
return NID_sha256;
|
|
#endif
|
|
#ifdef WOLFSSL_SHA384
|
|
case SHA384h:
|
|
return NID_sha384;
|
|
#endif
|
|
#ifdef WOLFSSL_SHA512
|
|
case SHA512h:
|
|
return NID_sha512;
|
|
#endif
|
|
}
|
|
break;
|
|
|
|
/* oidSigType */
|
|
case oidSigType:
|
|
switch (oid) {
|
|
#ifndef NO_DSA
|
|
case CTC_SHAwDSA:
|
|
return NID_dsaWithSHA1;
|
|
case CTC_SHA256wDSA:
|
|
return NID_dsa_with_SHA256;
|
|
#endif /* NO_DSA */
|
|
#ifndef NO_RSA
|
|
case CTC_MD2wRSA:
|
|
return NID_md2WithRSAEncryption;
|
|
case CTC_MD5wRSA:
|
|
return NID_md5WithRSAEncryption;
|
|
case CTC_SHAwRSA:
|
|
return NID_sha1WithRSAEncryption;
|
|
case CTC_SHA224wRSA:
|
|
return NID_sha224WithRSAEncryption;
|
|
case CTC_SHA256wRSA:
|
|
return NID_sha256WithRSAEncryption;
|
|
case CTC_SHA384wRSA:
|
|
return NID_sha384WithRSAEncryption;
|
|
case CTC_SHA512wRSA:
|
|
return NID_sha512WithRSAEncryption;
|
|
#ifdef WOLFSSL_SHA3
|
|
case CTC_SHA3_224wRSA:
|
|
return NID_RSA_SHA3_224;
|
|
case CTC_SHA3_256wRSA:
|
|
return NID_RSA_SHA3_256;
|
|
case CTC_SHA3_384wRSA:
|
|
return NID_RSA_SHA3_384;
|
|
case CTC_SHA3_512wRSA:
|
|
return NID_RSA_SHA3_512;
|
|
#endif
|
|
#ifdef WC_RSA_PSS
|
|
case CTC_RSASSAPSS:
|
|
return NID_rsassaPss;
|
|
#endif
|
|
#endif /* NO_RSA */
|
|
#ifdef HAVE_ECC
|
|
case CTC_SHAwECDSA:
|
|
return NID_ecdsa_with_SHA1;
|
|
case CTC_SHA224wECDSA:
|
|
return NID_ecdsa_with_SHA224;
|
|
case CTC_SHA256wECDSA:
|
|
return NID_ecdsa_with_SHA256;
|
|
case CTC_SHA384wECDSA:
|
|
return NID_ecdsa_with_SHA384;
|
|
case CTC_SHA512wECDSA:
|
|
return NID_ecdsa_with_SHA512;
|
|
#ifdef WOLFSSL_SHA3
|
|
case CTC_SHA3_224wECDSA:
|
|
return NID_ecdsa_with_SHA3_224;
|
|
case CTC_SHA3_256wECDSA:
|
|
return NID_ecdsa_with_SHA3_256;
|
|
case CTC_SHA3_384wECDSA:
|
|
return NID_ecdsa_with_SHA3_384;
|
|
case CTC_SHA3_512wECDSA:
|
|
return NID_ecdsa_with_SHA3_512;
|
|
#endif
|
|
#endif /* HAVE_ECC */
|
|
}
|
|
break;
|
|
|
|
/* oidKeyType */
|
|
case oidKeyType:
|
|
switch (oid) {
|
|
#ifndef NO_DSA
|
|
case DSAk:
|
|
return NID_dsa;
|
|
#endif /* NO_DSA */
|
|
#ifndef NO_RSA
|
|
case RSAk:
|
|
return NID_rsaEncryption;
|
|
#ifdef WC_RSA_PSS
|
|
case RSAPSSk:
|
|
return NID_rsassaPss;
|
|
#endif
|
|
#endif /* NO_RSA */
|
|
#ifdef HAVE_ECC
|
|
case ECDSAk:
|
|
return NID_X9_62_id_ecPublicKey;
|
|
#endif /* HAVE_ECC */
|
|
}
|
|
break;
|
|
|
|
|
|
#ifdef HAVE_ECC
|
|
case oidCurveType:
|
|
switch (oid) {
|
|
case ECC_SECP192R1_OID:
|
|
return NID_X9_62_prime192v1;
|
|
case ECC_PRIME192V2_OID:
|
|
return NID_X9_62_prime192v2;
|
|
case ECC_PRIME192V3_OID:
|
|
return NID_X9_62_prime192v3;
|
|
case ECC_PRIME239V1_OID:
|
|
return NID_X9_62_prime239v1;
|
|
case ECC_PRIME239V2_OID:
|
|
return NID_X9_62_prime239v2;
|
|
case ECC_PRIME239V3_OID:
|
|
return NID_X9_62_prime239v3;
|
|
case ECC_SECP256R1_OID:
|
|
return NID_X9_62_prime256v1;
|
|
case ECC_SECP112R1_OID:
|
|
return NID_secp112r1;
|
|
case ECC_SECP112R2_OID:
|
|
return NID_secp112r2;
|
|
case ECC_SECP128R1_OID:
|
|
return NID_secp128r1;
|
|
case ECC_SECP128R2_OID:
|
|
return NID_secp128r2;
|
|
case ECC_SECP160R1_OID:
|
|
return NID_secp160r1;
|
|
case ECC_SECP160R2_OID:
|
|
return NID_secp160r2;
|
|
case ECC_SECP224R1_OID:
|
|
return NID_secp224r1;
|
|
case ECC_SECP384R1_OID:
|
|
return NID_secp384r1;
|
|
case ECC_SECP521R1_OID:
|
|
return NID_secp521r1;
|
|
case ECC_SECP160K1_OID:
|
|
return NID_secp160k1;
|
|
case ECC_SECP192K1_OID:
|
|
return NID_secp192k1;
|
|
case ECC_SECP224K1_OID:
|
|
return NID_secp224k1;
|
|
case ECC_SECP256K1_OID:
|
|
return NID_secp256k1;
|
|
case ECC_BRAINPOOLP160R1_OID:
|
|
return NID_brainpoolP160r1;
|
|
case ECC_BRAINPOOLP192R1_OID:
|
|
return NID_brainpoolP192r1;
|
|
case ECC_BRAINPOOLP224R1_OID:
|
|
return NID_brainpoolP224r1;
|
|
case ECC_BRAINPOOLP256R1_OID:
|
|
return NID_brainpoolP256r1;
|
|
case ECC_BRAINPOOLP320R1_OID:
|
|
return NID_brainpoolP320r1;
|
|
case ECC_BRAINPOOLP384R1_OID:
|
|
return NID_brainpoolP384r1;
|
|
case ECC_BRAINPOOLP512R1_OID:
|
|
return NID_brainpoolP512r1;
|
|
}
|
|
break;
|
|
#endif /* HAVE_ECC */
|
|
|
|
/* oidBlkType */
|
|
case oidBlkType:
|
|
switch (oid) {
|
|
#ifdef WOLFSSL_AES_128
|
|
case AES128CBCb:
|
|
return AES128CBCb;
|
|
#endif
|
|
#ifdef WOLFSSL_AES_192
|
|
case AES192CBCb:
|
|
return AES192CBCb;
|
|
#endif
|
|
#ifdef WOLFSSL_AES_256
|
|
case AES256CBCb:
|
|
return AES256CBCb;
|
|
#endif
|
|
#ifndef NO_DES3
|
|
case DESb:
|
|
return NID_des;
|
|
case DES3b:
|
|
return NID_des3;
|
|
#endif
|
|
}
|
|
break;
|
|
|
|
#ifdef HAVE_OCSP
|
|
case oidOcspType:
|
|
switch (oid) {
|
|
case OCSP_BASIC_OID:
|
|
return NID_id_pkix_OCSP_basic;
|
|
case OCSP_NONCE_OID:
|
|
return OCSP_NONCE_OID;
|
|
}
|
|
break;
|
|
#endif /* HAVE_OCSP */
|
|
|
|
/* oidCertExtType */
|
|
case oidCertExtType:
|
|
switch (oid) {
|
|
case BASIC_CA_OID:
|
|
return NID_basic_constraints;
|
|
case ALT_NAMES_OID:
|
|
return NID_subject_alt_name;
|
|
case CRL_DIST_OID:
|
|
return NID_crl_distribution_points;
|
|
case AUTH_INFO_OID:
|
|
return NID_info_access;
|
|
case AUTH_KEY_OID:
|
|
return NID_authority_key_identifier;
|
|
case SUBJ_KEY_OID:
|
|
return NID_subject_key_identifier;
|
|
case INHIBIT_ANY_OID:
|
|
return NID_inhibit_any_policy;
|
|
case KEY_USAGE_OID:
|
|
return NID_key_usage;
|
|
case NAME_CONS_OID:
|
|
return NID_name_constraints;
|
|
case CERT_POLICY_OID:
|
|
return NID_certificate_policies;
|
|
case EXT_KEY_USAGE_OID:
|
|
return NID_ext_key_usage;
|
|
}
|
|
break;
|
|
|
|
/* oidCertAuthInfoType */
|
|
case oidCertAuthInfoType:
|
|
switch (oid) {
|
|
case AIA_OCSP_OID:
|
|
return NID_ad_OCSP;
|
|
case AIA_CA_ISSUER_OID:
|
|
return NID_ad_ca_issuers;
|
|
}
|
|
break;
|
|
|
|
/* oidCertPolicyType */
|
|
case oidCertPolicyType:
|
|
switch (oid) {
|
|
case CP_ANY_OID:
|
|
return NID_any_policy;
|
|
}
|
|
break;
|
|
|
|
/* oidCertAltNameType */
|
|
case oidCertAltNameType:
|
|
switch (oid) {
|
|
case HW_NAME_OID:
|
|
return NID_hw_name_oid;
|
|
}
|
|
break;
|
|
|
|
/* oidCertKeyUseType */
|
|
case oidCertKeyUseType:
|
|
switch (oid) {
|
|
case EKU_ANY_OID:
|
|
return NID_anyExtendedKeyUsage;
|
|
case EKU_SERVER_AUTH_OID:
|
|
return EKU_SERVER_AUTH_OID;
|
|
case EKU_CLIENT_AUTH_OID:
|
|
return EKU_CLIENT_AUTH_OID;
|
|
case EKU_OCSP_SIGN_OID:
|
|
return EKU_OCSP_SIGN_OID;
|
|
}
|
|
break;
|
|
|
|
/* oidKdfType */
|
|
case oidKdfType:
|
|
switch (oid) {
|
|
case PBKDF2_OID:
|
|
return PBKDF2_OID;
|
|
}
|
|
break;
|
|
|
|
/* oidPBEType */
|
|
case oidPBEType:
|
|
switch (oid) {
|
|
case PBE_SHA1_RC4_128:
|
|
return PBE_SHA1_RC4_128;
|
|
case PBE_SHA1_DES:
|
|
return PBE_SHA1_DES;
|
|
case PBE_SHA1_DES3:
|
|
return PBE_SHA1_DES3;
|
|
}
|
|
break;
|
|
|
|
/* oidKeyWrapType */
|
|
case oidKeyWrapType:
|
|
switch (oid) {
|
|
#ifdef WOLFSSL_AES_128
|
|
case AES128_WRAP:
|
|
return AES128_WRAP;
|
|
#endif
|
|
#ifdef WOLFSSL_AES_192
|
|
case AES192_WRAP:
|
|
return AES192_WRAP;
|
|
#endif
|
|
#ifdef WOLFSSL_AES_256
|
|
case AES256_WRAP:
|
|
return AES256_WRAP;
|
|
#endif
|
|
}
|
|
break;
|
|
|
|
/* oidCmsKeyAgreeType */
|
|
case oidCmsKeyAgreeType:
|
|
switch (oid) {
|
|
#ifndef NO_SHA
|
|
case dhSinglePass_stdDH_sha1kdf_scheme:
|
|
return dhSinglePass_stdDH_sha1kdf_scheme;
|
|
#endif
|
|
#ifdef WOLFSSL_SHA224
|
|
case dhSinglePass_stdDH_sha224kdf_scheme:
|
|
return dhSinglePass_stdDH_sha224kdf_scheme;
|
|
#endif
|
|
#ifndef NO_SHA256
|
|
case dhSinglePass_stdDH_sha256kdf_scheme:
|
|
return dhSinglePass_stdDH_sha256kdf_scheme;
|
|
#endif
|
|
#ifdef WOLFSSL_SHA384
|
|
case dhSinglePass_stdDH_sha384kdf_scheme:
|
|
return dhSinglePass_stdDH_sha384kdf_scheme;
|
|
#endif
|
|
#ifdef WOLFSSL_SHA512
|
|
case dhSinglePass_stdDH_sha512kdf_scheme:
|
|
return dhSinglePass_stdDH_sha512kdf_scheme;
|
|
#endif
|
|
}
|
|
break;
|
|
|
|
#ifdef WOLFSSL_CERT_REQ
|
|
case oidCsrAttrType:
|
|
switch (oid) {
|
|
case PKCS9_CONTENT_TYPE_OID:
|
|
return NID_pkcs9_contentType;
|
|
case CHALLENGE_PASSWORD_OID:
|
|
return NID_pkcs9_challengePassword;
|
|
case SERIAL_NUMBER_OID:
|
|
return NID_serialNumber;
|
|
case USER_ID_OID:
|
|
return NID_userId;
|
|
}
|
|
break;
|
|
#endif
|
|
|
|
default:
|
|
WOLFSSL_MSG("OID not in table");
|
|
}
|
|
/* If not found in above switch then try the table */
|
|
for (i = 0; i < WOLFSSL_OBJECT_INFO_SZ; i++) {
|
|
if (wolfssl_object_info[i].id == (int)oid) {
|
|
return wolfssl_object_info[i].nid;
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
/* frees all nodes in the current threads error queue
|
|
*
|
|
* id thread id. ERR_remove_state is depreciated and id is ignored. The
|
|
* current threads queue will be free'd.
|
|
*/
|
|
void wolfSSL_ERR_remove_state(unsigned long id)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_ERR_remove_state");
|
|
(void)id;
|
|
if (wc_ERR_remove_state() != 0) {
|
|
WOLFSSL_MSG("Error with removing the state");
|
|
}
|
|
}
|
|
|
|
#endif /* OPENSSL_EXTRA */
|
|
|
|
#ifdef OPENSSL_ALL
|
|
|
|
#if !defined(NO_BIO) && !defined(NO_PWDBASED) && defined(HAVE_PKCS8)
|
|
int wolfSSL_PEM_write_bio_PKCS8PrivateKey(WOLFSSL_BIO* bio,
|
|
WOLFSSL_EVP_PKEY* pkey,
|
|
const WOLFSSL_EVP_CIPHER* enc,
|
|
char* passwd, int passwdSz,
|
|
wc_pem_password_cb* cb, void* ctx)
|
|
{
|
|
int ret = 0;
|
|
char password[NAME_SZ];
|
|
byte* key = NULL;
|
|
word32 keySz;
|
|
byte* pem = NULL;
|
|
int pemSz = 0;
|
|
int type = PKCS8_PRIVATEKEY_TYPE;
|
|
const byte* curveOid;
|
|
word32 oidSz;
|
|
|
|
if (bio == NULL || pkey == NULL)
|
|
return -1;
|
|
|
|
keySz = pkey->pkey_sz + 128;
|
|
key = (byte*)XMALLOC(keySz, NULL, DYNAMIC_TYPE_TMP_BUFFER);
|
|
if (key == NULL)
|
|
ret = MEMORY_E;
|
|
|
|
if (ret == 0 && enc != NULL && passwd == NULL) {
|
|
passwdSz = cb(password, sizeof(password), 1, ctx);
|
|
if (passwdSz < 0)
|
|
ret = WOLFSSL_FAILURE;
|
|
passwd = password;
|
|
}
|
|
|
|
if (ret == 0 && enc != NULL) {
|
|
WC_RNG rng;
|
|
ret = wc_InitRng(&rng);
|
|
if (ret == 0) {
|
|
int encAlgId = 0;
|
|
#ifndef NO_DES3
|
|
if (enc == EVP_DES_CBC)
|
|
encAlgId = DESb;
|
|
else if (enc == EVP_DES_EDE3_CBC)
|
|
encAlgId = DES3b;
|
|
else
|
|
#endif
|
|
#if !defined(NO_AES) && defined(HAVE_AES_CBC)
|
|
#ifdef WOLFSSL_AES_256
|
|
if (enc == EVP_AES_256_CBC)
|
|
encAlgId = AES256CBCb;
|
|
else
|
|
#endif
|
|
#endif
|
|
ret = -1;
|
|
if (ret == 0) {
|
|
ret = TraditionalEnc((byte*)pkey->pkey.ptr, pkey->pkey_sz, key,
|
|
&keySz, passwd, passwdSz, PKCS5, PBES2,
|
|
encAlgId, NULL, 0, WC_PKCS12_ITT_DEFAULT,
|
|
&rng, NULL);
|
|
if (ret > 0) {
|
|
keySz = ret;
|
|
ret = 0;
|
|
}
|
|
}
|
|
wc_FreeRng(&rng);
|
|
}
|
|
type = PKCS8_ENC_PRIVATEKEY_TYPE;
|
|
}
|
|
if (ret == 0 && enc == NULL) {
|
|
int algId;
|
|
type = PKCS8_PRIVATEKEY_TYPE;
|
|
#ifdef HAVE_ECC
|
|
if (pkey->type == EVP_PKEY_EC) {
|
|
algId = ECDSAk;
|
|
ret = wc_ecc_get_oid(pkey->ecc->group->curve_oid, &curveOid,
|
|
&oidSz);
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
algId = RSAk;
|
|
curveOid = NULL;
|
|
oidSz = 0;
|
|
}
|
|
|
|
#ifdef HAVE_ECC
|
|
if (ret >= 0)
|
|
#endif
|
|
{
|
|
ret = wc_CreatePKCS8Key(key, &keySz, (byte*)pkey->pkey.ptr,
|
|
pkey->pkey_sz, algId, curveOid, oidSz);
|
|
keySz = ret;
|
|
}
|
|
}
|
|
|
|
if (password == passwd)
|
|
XMEMSET(password, 0, passwdSz);
|
|
|
|
if (ret >= 0) {
|
|
pemSz = 2 * keySz + 2 * 64;
|
|
pem = (byte*)XMALLOC(pemSz, NULL, DYNAMIC_TYPE_TMP_BUFFER);
|
|
if (pem == NULL)
|
|
ret = MEMORY_E;
|
|
}
|
|
|
|
if (ret >= 0)
|
|
ret = wc_DerToPemEx(key, keySz, pem, pemSz, NULL, type);
|
|
|
|
if (key != NULL)
|
|
XFREE(key, NULL, DYNAMIC_TYPE_TMP_BUFFER);
|
|
|
|
if (ret >= 0) {
|
|
if (wolfSSL_BIO_write(bio, pem, ret) != ret)
|
|
ret = -1;
|
|
}
|
|
|
|
if (pem != NULL)
|
|
XFREE(pem, NULL, DYNAMIC_TYPE_TMP_BUFFER);
|
|
|
|
return ret < 0 ? 0 : ret;
|
|
|
|
}
|
|
|
|
#if !defined(NO_FILESYSTEM) && !defined(NO_STDIO_FILESYSTEM)
|
|
int wolfSSL_PEM_write_PKCS8PrivateKey(XFILE f, WOLFSSL_EVP_PKEY* pkey,
|
|
const WOLFSSL_EVP_CIPHER* enc, char* passwd, int passwdSz,
|
|
wc_pem_password_cb* cb, void* ctx)
|
|
{
|
|
int ret = WOLFSSL_SUCCESS;
|
|
BIO *b;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_PEM_write_PKCS8PrivateKey");
|
|
|
|
b = wolfSSL_BIO_new_fp(f, BIO_NOCLOSE);
|
|
if (b == NULL) {
|
|
ret = WOLFSSL_FAILURE;
|
|
}
|
|
if (ret == WOLFSSL_SUCCESS) {
|
|
ret = wolfSSL_PEM_write_bio_PKCS8PrivateKey(b, pkey, enc, passwd,
|
|
passwdSz, cb, ctx);
|
|
}
|
|
|
|
wolfSSL_BIO_free(b);
|
|
|
|
return ret;
|
|
}
|
|
#endif /* !NO_FILESYSTEM && !NO_STDIO_FILESYSTEM */
|
|
|
|
static int bio_get_data(WOLFSSL_BIO* bio, byte** data)
|
|
{
|
|
int ret = 0;
|
|
byte* mem = NULL;
|
|
|
|
ret = wolfSSL_BIO_get_len(bio);
|
|
if (ret > 0) {
|
|
mem = (byte*)XMALLOC(ret, bio->heap, DYNAMIC_TYPE_OPENSSL);
|
|
if (mem == NULL) {
|
|
WOLFSSL_MSG("Memory error");
|
|
ret = MEMORY_E;
|
|
}
|
|
if (ret >= 0) {
|
|
if ((ret = wolfSSL_BIO_read(bio, mem, ret)) <= 0) {
|
|
XFREE(mem, bio->heap, DYNAMIC_TYPE_OPENSSL);
|
|
ret = MEMORY_E;
|
|
mem = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
*data = mem;
|
|
|
|
return ret;
|
|
}
|
|
|
|
/* DER data is PKCS#8 encrypted. */
|
|
WOLFSSL_EVP_PKEY* wolfSSL_d2i_PKCS8PrivateKey_bio(WOLFSSL_BIO* bio,
|
|
WOLFSSL_EVP_PKEY** pkey,
|
|
wc_pem_password_cb* cb,
|
|
void* ctx)
|
|
{
|
|
int ret;
|
|
byte* der;
|
|
int len;
|
|
byte* p;
|
|
word32 algId;
|
|
WOLFSSL_EVP_PKEY* key;
|
|
|
|
if ((len = bio_get_data(bio, &der)) < 0)
|
|
return NULL;
|
|
|
|
if (cb != NULL) {
|
|
char password[NAME_SZ];
|
|
int passwordSz = cb(password, sizeof(password), PEM_PASS_READ, ctx);
|
|
if (passwordSz < 0) {
|
|
XFREE(der, bio->heap, DYNAMIC_TYPE_OPENSSL);
|
|
return NULL;
|
|
}
|
|
#ifdef WOLFSSL_CHECK_MEM_ZERO
|
|
wc_MemZero_Add("wolfSSL_d2i_PKCS8PrivateKey_bio password", password,
|
|
passwordSz);
|
|
#endif
|
|
|
|
ret = ToTraditionalEnc(der, len, password, passwordSz, &algId);
|
|
if (ret < 0) {
|
|
XFREE(der, bio->heap, DYNAMIC_TYPE_OPENSSL);
|
|
return NULL;
|
|
}
|
|
|
|
ForceZero(password, passwordSz);
|
|
#ifdef WOLFSSL_CHECK_MEM_ZERO
|
|
wc_MemZero_Check(password, passwordSz);
|
|
#endif
|
|
}
|
|
|
|
p = der;
|
|
key = wolfSSL_d2i_PrivateKey_EVP(pkey, &p, len);
|
|
XFREE(der, bio->heap, DYNAMIC_TYPE_OPENSSL);
|
|
return key;
|
|
}
|
|
|
|
#endif /* !NO_BIO && !NO_PWDBASED && HAVE_PKCS8 */
|
|
|
|
/* Detect which type of key it is before decoding. */
|
|
WOLFSSL_EVP_PKEY* wolfSSL_d2i_AutoPrivateKey(WOLFSSL_EVP_PKEY** pkey,
|
|
const unsigned char** pp,
|
|
long length)
|
|
{
|
|
int ret;
|
|
WOLFSSL_EVP_PKEY* key = NULL;
|
|
const byte* der = *pp;
|
|
word32 idx = 0;
|
|
int len = 0;
|
|
int cnt = 0;
|
|
word32 algId;
|
|
word32 keyLen = (word32)length;
|
|
|
|
/* Take off PKCS#8 wrapper if found. */
|
|
if ((len = ToTraditionalInline_ex(der, &idx, keyLen, &algId)) >= 0) {
|
|
der += idx;
|
|
keyLen = len;
|
|
}
|
|
idx = 0;
|
|
len = 0;
|
|
|
|
/* Use the number of elements in the outer sequence to determine key type.
|
|
*/
|
|
ret = GetSequence(der, &idx, &len, keyLen);
|
|
if (ret >= 0) {
|
|
word32 end = idx + len;
|
|
while (ret >= 0 && idx < end) {
|
|
/* Skip type */
|
|
idx++;
|
|
/* Get length and skip over - keeping count */
|
|
len = 0;
|
|
ret = GetLength(der, &idx, &len, keyLen);
|
|
if (ret >= 0) {
|
|
if (idx + len > end)
|
|
ret = ASN_PARSE_E;
|
|
else {
|
|
idx += len;
|
|
cnt++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (ret >= 0) {
|
|
int type;
|
|
/* ECC includes version, private[, curve][, public key] */
|
|
if (cnt >= 2 && cnt <= 4)
|
|
type = EVP_PKEY_EC;
|
|
else
|
|
type = EVP_PKEY_RSA;
|
|
|
|
key = wolfSSL_d2i_PrivateKey(type, pkey, &der, keyLen);
|
|
*pp = der;
|
|
}
|
|
|
|
return key;
|
|
}
|
|
#endif /* OPENSSL_ALL */
|
|
|
|
#ifdef WOLFSSL_STATIC_EPHEMERAL
|
|
int wolfSSL_StaticEphemeralKeyLoad(WOLFSSL* ssl, int keyAlgo, void* keyPtr)
|
|
{
|
|
int ret;
|
|
word32 idx = 0;
|
|
DerBuffer* der = NULL;
|
|
|
|
if (ssl == NULL || ssl->ctx == NULL || keyPtr == NULL) {
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
#ifndef SINGLE_THREADED
|
|
if (!ssl->ctx->staticKELockInit) {
|
|
return BUFFER_E; /* no keys set */
|
|
}
|
|
ret = wc_LockMutex(&ssl->ctx->staticKELock);
|
|
if (ret != 0) {
|
|
return ret;
|
|
}
|
|
#endif
|
|
|
|
ret = BUFFER_E; /* set default error */
|
|
switch (keyAlgo) {
|
|
#ifndef NO_DH
|
|
case WC_PK_TYPE_DH:
|
|
if (ssl != NULL)
|
|
der = ssl->staticKE.dhKey;
|
|
if (der == NULL)
|
|
der = ssl->ctx->staticKE.dhKey;
|
|
if (der != NULL) {
|
|
DhKey* key = (DhKey*)keyPtr;
|
|
WOLFSSL_MSG("Using static DH key");
|
|
ret = wc_DhKeyDecode(der->buffer, &idx, key, der->length);
|
|
}
|
|
break;
|
|
#endif
|
|
#ifdef HAVE_ECC
|
|
case WC_PK_TYPE_ECDH:
|
|
if (ssl != NULL)
|
|
der = ssl->staticKE.ecKey;
|
|
if (der == NULL)
|
|
der = ssl->ctx->staticKE.ecKey;
|
|
if (der != NULL) {
|
|
ecc_key* key = (ecc_key*)keyPtr;
|
|
WOLFSSL_MSG("Using static ECDH key");
|
|
ret = wc_EccPrivateKeyDecode(der->buffer, &idx, key, der->length);
|
|
}
|
|
break;
|
|
#endif
|
|
#ifdef HAVE_CURVE25519
|
|
case WC_PK_TYPE_CURVE25519:
|
|
if (ssl != NULL)
|
|
der = ssl->staticKE.x25519Key;
|
|
if (der == NULL)
|
|
der = ssl->ctx->staticKE.x25519Key;
|
|
if (der != NULL) {
|
|
curve25519_key* key = (curve25519_key*)keyPtr;
|
|
WOLFSSL_MSG("Using static X25519 key");
|
|
ret = wc_Curve25519PrivateKeyDecode(der->buffer, &idx, key,
|
|
der->length);
|
|
}
|
|
break;
|
|
#endif
|
|
#ifdef HAVE_CURVE448
|
|
case WC_PK_TYPE_CURVE448:
|
|
if (ssl != NULL)
|
|
der = ssl->staticKE.x448Key;
|
|
if (der == NULL)
|
|
der = ssl->ctx->staticKE.x448Key;
|
|
if (der != NULL) {
|
|
curve448_key* key = (curve448_key*)keyPtr;
|
|
WOLFSSL_MSG("Using static X448 key");
|
|
ret = wc_Curve448PrivateKeyDecode(der->buffer, &idx, key,
|
|
der->length);
|
|
}
|
|
break;
|
|
#endif
|
|
default:
|
|
/* not supported */
|
|
ret = NOT_COMPILED_IN;
|
|
break;
|
|
}
|
|
|
|
#ifndef SINGLE_THREADED
|
|
wc_UnLockMutex(&ssl->ctx->staticKELock);
|
|
#endif
|
|
return ret;
|
|
}
|
|
|
|
static int SetStaticEphemeralKey(WOLFSSL_CTX* ctx,
|
|
StaticKeyExchangeInfo_t* staticKE, int keyAlgo, const char* key,
|
|
unsigned int keySz, int format, void* heap)
|
|
{
|
|
int ret = 0;
|
|
DerBuffer* der = NULL;
|
|
byte* keyBuf = NULL;
|
|
#ifndef NO_FILESYSTEM
|
|
const char* keyFile = NULL;
|
|
#endif
|
|
|
|
/* allow empty key to free buffer */
|
|
if (staticKE == NULL || (key == NULL && keySz > 0)) {
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
WOLFSSL_ENTER("SetStaticEphemeralKey");
|
|
|
|
/* if just free'ing key then skip loading */
|
|
if (key != NULL) {
|
|
#ifndef NO_FILESYSTEM
|
|
/* load file from filesystem */
|
|
if (key != NULL && keySz == 0) {
|
|
size_t keyBufSz = 0;
|
|
keyFile = (const char*)key;
|
|
ret = wc_FileLoad(keyFile, &keyBuf, &keyBufSz, heap);
|
|
if (ret != 0) {
|
|
return ret;
|
|
}
|
|
keySz = (unsigned int)keyBufSz;
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
/* use as key buffer directly */
|
|
keyBuf = (byte*)key;
|
|
}
|
|
|
|
if (format == WOLFSSL_FILETYPE_PEM) {
|
|
#ifdef WOLFSSL_PEM_TO_DER
|
|
int keyFormat = 0;
|
|
ret = PemToDer(keyBuf, keySz, PRIVATEKEY_TYPE, &der,
|
|
heap, NULL, &keyFormat);
|
|
/* auto detect key type */
|
|
if (ret == 0 && keyAlgo == WC_PK_TYPE_NONE) {
|
|
if (keyFormat == ECDSAk)
|
|
keyAlgo = WC_PK_TYPE_ECDH;
|
|
else if (keyFormat == X25519k)
|
|
keyAlgo = WC_PK_TYPE_CURVE25519;
|
|
else
|
|
keyAlgo = WC_PK_TYPE_DH;
|
|
}
|
|
#else
|
|
ret = NOT_COMPILED_IN;
|
|
#endif
|
|
}
|
|
else {
|
|
/* Detect PK type (if required) */
|
|
#ifdef HAVE_ECC
|
|
if (keyAlgo == WC_PK_TYPE_NONE) {
|
|
word32 idx = 0;
|
|
ecc_key eccKey;
|
|
ret = wc_ecc_init_ex(&eccKey, heap, INVALID_DEVID);
|
|
if (ret == 0) {
|
|
ret = wc_EccPrivateKeyDecode(keyBuf, &idx, &eccKey, keySz);
|
|
if (ret == 0)
|
|
keyAlgo = WC_PK_TYPE_ECDH;
|
|
wc_ecc_free(&eccKey);
|
|
}
|
|
}
|
|
#endif
|
|
#if !defined(NO_DH) && defined(WOLFSSL_DH_EXTRA)
|
|
if (keyAlgo == WC_PK_TYPE_NONE) {
|
|
word32 idx = 0;
|
|
DhKey dhKey;
|
|
ret = wc_InitDhKey_ex(&dhKey, heap, INVALID_DEVID);
|
|
if (ret == 0) {
|
|
ret = wc_DhKeyDecode(keyBuf, &idx, &dhKey, keySz);
|
|
if (ret == 0)
|
|
keyAlgo = WC_PK_TYPE_DH;
|
|
wc_FreeDhKey(&dhKey);
|
|
}
|
|
}
|
|
#endif
|
|
#ifdef HAVE_CURVE25519
|
|
if (keyAlgo == WC_PK_TYPE_NONE) {
|
|
word32 idx = 0;
|
|
curve25519_key x25519Key;
|
|
ret = wc_curve25519_init_ex(&x25519Key, heap, INVALID_DEVID);
|
|
if (ret == 0) {
|
|
ret = wc_Curve25519PrivateKeyDecode(keyBuf, &idx, &x25519Key,
|
|
keySz);
|
|
if (ret == 0)
|
|
keyAlgo = WC_PK_TYPE_CURVE25519;
|
|
wc_curve25519_free(&x25519Key);
|
|
}
|
|
}
|
|
#endif
|
|
#ifdef HAVE_CURVE448
|
|
if (keyAlgo == WC_PK_TYPE_NONE) {
|
|
word32 idx = 0;
|
|
curve448_key x448Key;
|
|
ret = wc_curve448_init(&x448Key);
|
|
if (ret == 0) {
|
|
ret = wc_Curve448PrivateKeyDecode(keyBuf, &idx, &x448Key,
|
|
keySz);
|
|
if (ret == 0)
|
|
keyAlgo = WC_PK_TYPE_CURVE448;
|
|
wc_curve448_free(&x448Key);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
if (keyAlgo != WC_PK_TYPE_NONE) {
|
|
ret = AllocDer(&der, keySz, PRIVATEKEY_TYPE, heap);
|
|
if (ret == 0) {
|
|
XMEMCPY(der->buffer, keyBuf, keySz);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#ifndef NO_FILESYSTEM
|
|
/* done with keyFile buffer */
|
|
if (keyFile && keyBuf) {
|
|
XFREE(keyBuf, heap, DYNAMIC_TYPE_TMP_BUFFER);
|
|
}
|
|
#endif
|
|
|
|
#ifndef SINGLE_THREADED
|
|
if (ret == 0 && !ctx->staticKELockInit) {
|
|
ret = wc_InitMutex(&ctx->staticKELock);
|
|
if (ret == 0) {
|
|
ctx->staticKELockInit = 1;
|
|
}
|
|
}
|
|
#endif
|
|
if (ret == 0
|
|
#ifndef SINGLE_THREADED
|
|
&& (ret = wc_LockMutex(&ctx->staticKELock)) == 0
|
|
#endif
|
|
) {
|
|
switch (keyAlgo) {
|
|
#ifndef NO_DH
|
|
case WC_PK_TYPE_DH:
|
|
FreeDer(&staticKE->dhKey);
|
|
staticKE->dhKey = der; der = NULL;
|
|
break;
|
|
#endif
|
|
#ifdef HAVE_ECC
|
|
case WC_PK_TYPE_ECDH:
|
|
FreeDer(&staticKE->ecKey);
|
|
staticKE->ecKey = der; der = NULL;
|
|
break;
|
|
#endif
|
|
#ifdef HAVE_CURVE25519
|
|
case WC_PK_TYPE_CURVE25519:
|
|
FreeDer(&staticKE->x25519Key);
|
|
staticKE->x25519Key = der; der = NULL;
|
|
break;
|
|
#endif
|
|
#ifdef HAVE_CURVE448
|
|
case WC_PK_TYPE_CURVE448:
|
|
FreeDer(&staticKE->x448Key);
|
|
staticKE->x448Key = der; der = NULL;
|
|
break;
|
|
#endif
|
|
default:
|
|
/* not supported */
|
|
ret = NOT_COMPILED_IN;
|
|
break;
|
|
}
|
|
|
|
#ifndef SINGLE_THREADED
|
|
wc_UnLockMutex(&ctx->staticKELock);
|
|
#endif
|
|
}
|
|
|
|
if (ret != 0) {
|
|
FreeDer(&der);
|
|
}
|
|
|
|
(void)ctx; /* not used for single threaded */
|
|
|
|
WOLFSSL_LEAVE("SetStaticEphemeralKey", ret);
|
|
|
|
return ret;
|
|
}
|
|
|
|
int wolfSSL_CTX_set_ephemeral_key(WOLFSSL_CTX* ctx, int keyAlgo,
|
|
const char* key, unsigned int keySz, int format)
|
|
{
|
|
if (ctx == NULL) {
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
return SetStaticEphemeralKey(ctx, &ctx->staticKE, keyAlgo,
|
|
key, keySz, format, ctx->heap);
|
|
}
|
|
int wolfSSL_set_ephemeral_key(WOLFSSL* ssl, int keyAlgo,
|
|
const char* key, unsigned int keySz, int format)
|
|
{
|
|
if (ssl == NULL || ssl->ctx == NULL) {
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
return SetStaticEphemeralKey(ssl->ctx, &ssl->staticKE, keyAlgo,
|
|
key, keySz, format, ssl->heap);
|
|
}
|
|
|
|
static int GetStaticEphemeralKey(WOLFSSL_CTX* ctx, WOLFSSL* ssl,
|
|
int keyAlgo, const unsigned char** key, unsigned int* keySz)
|
|
{
|
|
int ret = 0;
|
|
DerBuffer* der = NULL;
|
|
|
|
if (key) *key = NULL;
|
|
if (keySz) *keySz = 0;
|
|
|
|
#ifndef SINGLE_THREADED
|
|
if (ctx->staticKELockInit &&
|
|
(ret = wc_LockMutex(&ctx->staticKELock)) != 0) {
|
|
return ret;
|
|
}
|
|
#endif
|
|
|
|
switch (keyAlgo) {
|
|
#ifndef NO_DH
|
|
case WC_PK_TYPE_DH:
|
|
if (ssl != NULL)
|
|
der = ssl->staticKE.dhKey;
|
|
if (der == NULL)
|
|
der = ctx->staticKE.dhKey;
|
|
break;
|
|
#endif
|
|
#ifdef HAVE_ECC
|
|
case WC_PK_TYPE_ECDH:
|
|
if (ssl != NULL)
|
|
der = ssl->staticKE.ecKey;
|
|
if (der == NULL)
|
|
der = ctx->staticKE.ecKey;
|
|
break;
|
|
#endif
|
|
#ifdef HAVE_CURVE25519
|
|
case WC_PK_TYPE_CURVE25519:
|
|
if (ssl != NULL)
|
|
der = ssl->staticKE.x25519Key;
|
|
if (der == NULL)
|
|
der = ctx->staticKE.x25519Key;
|
|
break;
|
|
#endif
|
|
#ifdef HAVE_CURVE448
|
|
case WC_PK_TYPE_CURVE448:
|
|
if (ssl != NULL)
|
|
der = ssl->staticKE.x448Key;
|
|
if (der == NULL)
|
|
der = ctx->staticKE.x448Key;
|
|
break;
|
|
#endif
|
|
default:
|
|
/* not supported */
|
|
ret = NOT_COMPILED_IN;
|
|
break;
|
|
}
|
|
|
|
if (der) {
|
|
if (key)
|
|
*key = der->buffer;
|
|
if (keySz)
|
|
*keySz = der->length;
|
|
}
|
|
|
|
#ifndef SINGLE_THREADED
|
|
wc_UnLockMutex(&ctx->staticKELock);
|
|
#endif
|
|
|
|
return ret;
|
|
}
|
|
|
|
/* returns pointer to currently loaded static ephemeral as ASN.1 */
|
|
/* this can be converted to PEM using wc_DerToPem */
|
|
int wolfSSL_CTX_get_ephemeral_key(WOLFSSL_CTX* ctx, int keyAlgo,
|
|
const unsigned char** key, unsigned int* keySz)
|
|
{
|
|
if (ctx == NULL) {
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
return GetStaticEphemeralKey(ctx, NULL, keyAlgo, key, keySz);
|
|
}
|
|
int wolfSSL_get_ephemeral_key(WOLFSSL* ssl, int keyAlgo,
|
|
const unsigned char** key, unsigned int* keySz)
|
|
{
|
|
if (ssl == NULL || ssl->ctx == NULL) {
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
return GetStaticEphemeralKey(ssl->ctx, ssl, keyAlgo, key, keySz);
|
|
}
|
|
|
|
#endif /* WOLFSSL_STATIC_EPHEMERAL */
|
|
|
|
#if defined(OPENSSL_EXTRA)
|
|
/* wolfSSL_THREADID_current is provided as a compat API with
|
|
* CRYPTO_THREADID_current to register current thread id into given id object.
|
|
* However, CRYPTO_THREADID_current API has been deprecated and no longer
|
|
* exists in the OpenSSL 1.0.0 or later.This API only works as a stub
|
|
* like as existing wolfSSL_THREADID_set_numeric.
|
|
*/
|
|
void wolfSSL_THREADID_current(WOLFSSL_CRYPTO_THREADID* id)
|
|
{
|
|
(void)id;
|
|
return;
|
|
}
|
|
/* wolfSSL_THREADID_hash is provided as a compatible API with
|
|
* CRYPTO_THREADID_hash which returns a hash value calculated from the
|
|
* specified thread id. However, CRYPTO_THREADID_hash API has been
|
|
* deprecated and no longer exists in the OpenSSL 1.0.0 or later.
|
|
* This API only works as a stub to returns 0. This behavior is
|
|
* equivalent to the latest OpenSSL CRYPTO_THREADID_hash.
|
|
*/
|
|
unsigned long wolfSSL_THREADID_hash(const WOLFSSL_CRYPTO_THREADID* id)
|
|
{
|
|
(void)id;
|
|
return 0UL;
|
|
}
|
|
/* wolfSSL_CTX_set_ecdh_auto is provided as compatible API with
|
|
* SSL_CTX_set_ecdh_auto to enable auto ecdh curve selection functionality.
|
|
* Since this functionality is enabled by default in wolfSSL,
|
|
* this API exists as a stub.
|
|
*/
|
|
int wolfSSL_CTX_set_ecdh_auto(WOLFSSL_CTX* ctx, int onoff)
|
|
{
|
|
(void)ctx;
|
|
(void)onoff;
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
* set security level (wolfSSL doesn't support security level)
|
|
* @param ctx a pointer to WOLFSSL_EVP_PKEY_CTX structure
|
|
* @param level security level
|
|
*/
|
|
void wolfSSL_CTX_set_security_level(WOLFSSL_CTX* ctx, int level)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_set_security_level");
|
|
(void)ctx;
|
|
(void)level;
|
|
}
|
|
/**
|
|
* get security level (wolfSSL doesn't support security level)
|
|
* @param ctx a pointer to WOLFSSL_EVP_PKEY_CTX structure
|
|
* @return always 0(level 0)
|
|
*/
|
|
int wolfSSL_CTX_get_security_level(const WOLFSSL_CTX* ctx)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_get_security_level");
|
|
(void)ctx;
|
|
return 0;
|
|
}
|
|
|
|
|
|
/**
|
|
* Determine whether a WOLFSSL_SESSION object can be used for resumption
|
|
* @param s a pointer to WOLFSSL_SESSION structure
|
|
* @return return 1 if session is resumable, otherwise 0.
|
|
*/
|
|
int wolfSSL_SESSION_is_resumable(const WOLFSSL_SESSION *s)
|
|
{
|
|
s = ClientSessionToSession(s);
|
|
if (s == NULL)
|
|
return 0;
|
|
|
|
#ifdef HAVE_SESSION_TICKET
|
|
if (s->ticketLen > 0)
|
|
return 1;
|
|
#endif
|
|
|
|
if (s->sessionIDSz > 0)
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
#if defined(OPENSSL_EXTRA) && defined(HAVE_SECRET_CALLBACK)
|
|
/*
|
|
* This API accepts a user callback which puts key-log records into
|
|
* a KEY LOGFILE. The callback is stored into a CTX and propagated to
|
|
* each SSL object on its creation timing.
|
|
*/
|
|
void wolfSSL_CTX_set_keylog_callback(WOLFSSL_CTX* ctx, wolfSSL_CTX_keylog_cb_func cb)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_set_keylog_callback");
|
|
/* stores the callback into WOLFSSL_CTX */
|
|
if (ctx != NULL) {
|
|
ctx->keyLogCb = cb;
|
|
}
|
|
}
|
|
wolfSSL_CTX_keylog_cb_func wolfSSL_CTX_get_keylog_callback(
|
|
const WOLFSSL_CTX* ctx)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_get_keylog_callback");
|
|
if (ctx != NULL)
|
|
return ctx->keyLogCb;
|
|
else
|
|
return NULL;
|
|
}
|
|
#endif /* OPENSSL_EXTRA && HAVE_SECRET_CALLBACK */
|
|
|
|
#endif /* OPENSSL_EXTRA */
|
|
|
|
#ifndef NO_CERT
|
|
#define WOLFSSL_X509_INCLUDED
|
|
#include "src/x509.c"
|
|
#endif
|
|
|
|
/*******************************************************************************
|
|
* START OF standard C library wrapping APIs
|
|
******************************************************************************/
|
|
#if defined(OPENSSL_ALL) || (defined(OPENSSL_EXTRA) && (defined(HAVE_STUNNEL) || \
|
|
defined(WOLFSSL_NGINX) || defined(HAVE_LIGHTY) || \
|
|
defined(WOLFSSL_HAPROXY) || defined(WOLFSSL_OPENSSH)))
|
|
#ifndef NO_WOLFSSL_STUB
|
|
int wolfSSL_CRYPTO_set_mem_ex_functions(void *(*m) (size_t, const char *, int),
|
|
void *(*r) (void *, size_t, const char *,
|
|
int), void (*f) (void *))
|
|
{
|
|
(void) m;
|
|
(void) r;
|
|
(void) f;
|
|
WOLFSSL_ENTER("wolfSSL_CRYPTO_set_mem_ex_functions");
|
|
WOLFSSL_STUB("CRYPTO_set_mem_ex_functions");
|
|
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
#endif
|
|
#endif
|
|
|
|
#if defined(OPENSSL_EXTRA)
|
|
|
|
/**
|
|
* free allocated memory resource
|
|
* @param str a pointer to resource to be freed
|
|
* @param file dummy argument
|
|
* @param line dummy argument
|
|
*/
|
|
void wolfSSL_CRYPTO_free(void *str, const char *file, int line)
|
|
{
|
|
(void)file;
|
|
(void)line;
|
|
XFREE(str, 0, DYNAMIC_TYPE_TMP_BUFFER);
|
|
}
|
|
/**
|
|
* allocate memory with size of num
|
|
* @param num size of memory allocation to be malloced
|
|
* @param file dummy argument
|
|
* @param line dummy argument
|
|
* @return a pointer to allocated memory on succssesful, otherwise NULL
|
|
*/
|
|
void *wolfSSL_CRYPTO_malloc(size_t num, const char *file, int line)
|
|
{
|
|
(void)file;
|
|
(void)line;
|
|
return XMALLOC(num, 0, DYNAMIC_TYPE_TMP_BUFFER);
|
|
}
|
|
|
|
#endif
|
|
|
|
/*******************************************************************************
|
|
* END OF standard C library wrapping APIs
|
|
******************************************************************************/
|
|
|
|
/*******************************************************************************
|
|
* START OF EX_DATA APIs
|
|
******************************************************************************/
|
|
#if defined(OPENSSL_ALL) || (defined(OPENSSL_EXTRA) && (defined(HAVE_STUNNEL) || \
|
|
defined(WOLFSSL_NGINX) || defined(HAVE_LIGHTY) || \
|
|
defined(WOLFSSL_HAPROXY) || defined(WOLFSSL_OPENSSH)))
|
|
void wolfSSL_CRYPTO_cleanup_all_ex_data(void){
|
|
WOLFSSL_ENTER("CRYPTO_cleanup_all_ex_data");
|
|
}
|
|
#endif
|
|
|
|
#ifdef HAVE_EX_DATA
|
|
void* wolfSSL_CRYPTO_get_ex_data(const WOLFSSL_CRYPTO_EX_DATA* ex_data, int idx)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CTX_get_ex_data");
|
|
#ifdef MAX_EX_DATA
|
|
if(ex_data && idx < MAX_EX_DATA && idx >= 0) {
|
|
return ex_data->ex_data[idx];
|
|
}
|
|
#else
|
|
(void)ex_data;
|
|
(void)idx;
|
|
#endif
|
|
return NULL;
|
|
}
|
|
|
|
int wolfSSL_CRYPTO_set_ex_data(WOLFSSL_CRYPTO_EX_DATA* ex_data, int idx, void *data)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CRYPTO_set_ex_data");
|
|
#ifdef MAX_EX_DATA
|
|
if (ex_data && idx < MAX_EX_DATA && idx >= 0) {
|
|
#ifdef HAVE_EX_DATA_CLEANUP_HOOKS
|
|
if (ex_data->ex_data_cleanup_routines[idx]) {
|
|
if (ex_data->ex_data[idx])
|
|
ex_data->ex_data_cleanup_routines[idx](ex_data->ex_data[idx]);
|
|
ex_data->ex_data_cleanup_routines[idx] = NULL;
|
|
}
|
|
#endif
|
|
ex_data->ex_data[idx] = data;
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
#else
|
|
(void)ex_data;
|
|
(void)idx;
|
|
(void)data;
|
|
#endif
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
#ifdef HAVE_EX_DATA_CLEANUP_HOOKS
|
|
int wolfSSL_CRYPTO_set_ex_data_with_cleanup(
|
|
WOLFSSL_CRYPTO_EX_DATA* ex_data,
|
|
int idx,
|
|
void *data,
|
|
wolfSSL_ex_data_cleanup_routine_t cleanup_routine)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CRYPTO_set_ex_data_with_cleanup");
|
|
if (ex_data && idx < MAX_EX_DATA && idx >= 0) {
|
|
if (ex_data->ex_data_cleanup_routines[idx] && ex_data->ex_data[idx])
|
|
ex_data->ex_data_cleanup_routines[idx](ex_data->ex_data[idx]);
|
|
ex_data->ex_data[idx] = data;
|
|
ex_data->ex_data_cleanup_routines[idx] = cleanup_routine;
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
#endif /* HAVE_EX_DATA_CLEANUP_HOOKS */
|
|
|
|
/**
|
|
* Issues unique index for the class specified by class_index.
|
|
* Other parameter except class_index are ignored.
|
|
* Currently, following class_index are accepted:
|
|
* - WOLF_CRYPTO_EX_INDEX_SSL
|
|
* - WOLF_CRYPTO_EX_INDEX_SSL_CTX
|
|
* - WOLF_CRYPTO_EX_INDEX_X509
|
|
* @param class_index index one of CRYPTO_EX_INDEX_xxx
|
|
* @param argp parameters to be saved
|
|
* @param argl parameters to be saved
|
|
* @param new_func a pointer to WOLFSSL_CRYPTO_EX_new
|
|
* @param dup_func a pointer to WOLFSSL_CRYPTO_EX_dup
|
|
* @param free_func a pointer to WOLFSSL_CRYPTO_EX_free
|
|
* @return index value grater or equal to zero on success, -1 on failure.
|
|
*/
|
|
int wolfSSL_CRYPTO_get_ex_new_index(int class_index, long argl, void *argp,
|
|
WOLFSSL_CRYPTO_EX_new* new_func,
|
|
WOLFSSL_CRYPTO_EX_dup* dup_func,
|
|
WOLFSSL_CRYPTO_EX_free* free_func)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_CRYPTO_get_ex_new_index");
|
|
|
|
return wolfssl_get_ex_new_index(class_index, argl, argp, new_func,
|
|
dup_func, free_func);
|
|
}
|
|
#endif /* HAVE_EX_DATA */
|
|
|
|
/*******************************************************************************
|
|
* END OF EX_DATA APIs
|
|
******************************************************************************/
|
|
|
|
/*******************************************************************************
|
|
* START OF BUF_MEM API
|
|
******************************************************************************/
|
|
|
|
#if defined(OPENSSL_EXTRA)
|
|
|
|
/* Begin functions for openssl/buffer.h */
|
|
WOLFSSL_BUF_MEM* wolfSSL_BUF_MEM_new(void)
|
|
{
|
|
WOLFSSL_BUF_MEM* buf;
|
|
buf = (WOLFSSL_BUF_MEM*)XMALLOC(sizeof(WOLFSSL_BUF_MEM), NULL,
|
|
DYNAMIC_TYPE_OPENSSL);
|
|
if (buf) {
|
|
XMEMSET(buf, 0, sizeof(WOLFSSL_BUF_MEM));
|
|
}
|
|
return buf;
|
|
}
|
|
|
|
/* non-compat API returns length of buffer on success */
|
|
int wolfSSL_BUF_MEM_grow_ex(WOLFSSL_BUF_MEM* buf, size_t len,
|
|
char zeroFill)
|
|
{
|
|
|
|
int len_int = (int)len;
|
|
int mx;
|
|
char* tmp;
|
|
|
|
/* verify provided arguments */
|
|
if (buf == NULL || len_int < 0) {
|
|
return 0; /* BAD_FUNC_ARG; */
|
|
}
|
|
|
|
/* check to see if fits in existing length */
|
|
if (buf->length > len) {
|
|
buf->length = len;
|
|
return len_int;
|
|
}
|
|
|
|
/* check to see if fits in max buffer */
|
|
if (buf->max >= len) {
|
|
if (buf->data != NULL && zeroFill) {
|
|
XMEMSET(&buf->data[buf->length], 0, len - buf->length);
|
|
}
|
|
buf->length = len;
|
|
return len_int;
|
|
}
|
|
|
|
/* expand size, to handle growth */
|
|
mx = (len_int + 3) / 3 * 4;
|
|
|
|
/* use realloc */
|
|
tmp = (char*)XREALLOC(buf->data, mx, NULL, DYNAMIC_TYPE_OPENSSL);
|
|
if (tmp == NULL) {
|
|
return 0; /* ERR_R_MALLOC_FAILURE; */
|
|
}
|
|
buf->data = tmp;
|
|
|
|
buf->max = mx;
|
|
if (zeroFill)
|
|
XMEMSET(&buf->data[buf->length], 0, len - buf->length);
|
|
buf->length = len;
|
|
|
|
return len_int;
|
|
|
|
}
|
|
|
|
/* returns length of buffer on success */
|
|
int wolfSSL_BUF_MEM_grow(WOLFSSL_BUF_MEM* buf, size_t len)
|
|
{
|
|
return wolfSSL_BUF_MEM_grow_ex(buf, len, 1);
|
|
}
|
|
|
|
/* non-compat API returns length of buffer on success */
|
|
int wolfSSL_BUF_MEM_resize(WOLFSSL_BUF_MEM* buf, size_t len)
|
|
{
|
|
char* tmp;
|
|
int mx;
|
|
|
|
/* verify provided arguments */
|
|
if (buf == NULL || len == 0 || (int)len <= 0) {
|
|
return 0; /* BAD_FUNC_ARG; */
|
|
}
|
|
|
|
if (len == buf->length)
|
|
return (int)len;
|
|
|
|
if (len > buf->length)
|
|
return wolfSSL_BUF_MEM_grow_ex(buf, len, 0);
|
|
|
|
/* expand size, to handle growth */
|
|
mx = ((int)len + 3) / 3 * 4;
|
|
|
|
/* We want to shrink the internal buffer */
|
|
tmp = (char*)XREALLOC(buf->data, mx, NULL, DYNAMIC_TYPE_OPENSSL);
|
|
if (tmp == NULL)
|
|
return 0;
|
|
|
|
buf->data = tmp;
|
|
buf->length = len;
|
|
buf->max = mx;
|
|
|
|
return (int)len;
|
|
}
|
|
|
|
void wolfSSL_BUF_MEM_free(WOLFSSL_BUF_MEM* buf)
|
|
{
|
|
if (buf) {
|
|
if (buf->data) {
|
|
XFREE(buf->data, NULL, DYNAMIC_TYPE_OPENSSL);
|
|
buf->data = NULL;
|
|
}
|
|
buf->max = 0;
|
|
buf->length = 0;
|
|
XFREE(buf, NULL, DYNAMIC_TYPE_OPENSSL);
|
|
}
|
|
}
|
|
/* End Functions for openssl/buffer.h */
|
|
|
|
#endif /* OPENSSL_EXTRA */
|
|
|
|
/*******************************************************************************
|
|
* END OF BUF_MEM API
|
|
******************************************************************************/
|
|
|
|
#define WOLFSSL_CONF_INCLUDED
|
|
#include <src/conf.c>
|
|
|
|
/*******************************************************************************
|
|
* START OF RAND API
|
|
******************************************************************************/
|
|
|
|
#if defined(OPENSSL_EXTRA) && !defined(WOLFSSL_NO_OPENSSL_RAND_CB)
|
|
static int wolfSSL_RAND_InitMutex(void)
|
|
{
|
|
if (gRandMethodsInit == 0) {
|
|
if (wc_InitMutex(&gRandMethodMutex) != 0) {
|
|
WOLFSSL_MSG("Bad Init Mutex rand methods");
|
|
return BAD_MUTEX_E;
|
|
}
|
|
gRandMethodsInit = 1;
|
|
}
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
#ifdef OPENSSL_EXTRA
|
|
|
|
/* Checks if the global RNG has been created. If not then one is created.
|
|
*
|
|
* Returns WOLFSSL_SUCCESS when no error is encountered.
|
|
*/
|
|
int wolfSSL_RAND_Init(void)
|
|
{
|
|
int ret = WOLFSSL_FAILURE;
|
|
#ifdef HAVE_GLOBAL_RNG
|
|
if (wc_LockMutex(&globalRNGMutex) == 0) {
|
|
if (initGlobalRNG == 0) {
|
|
ret = wc_InitRng(&globalRNG);
|
|
if (ret == 0) {
|
|
initGlobalRNG = 1;
|
|
ret = WOLFSSL_SUCCESS;
|
|
}
|
|
}
|
|
else {
|
|
/* GlobalRNG is already initialized */
|
|
ret = WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
wc_UnLockMutex(&globalRNGMutex);
|
|
}
|
|
#endif
|
|
return ret;
|
|
}
|
|
|
|
|
|
/* WOLFSSL_SUCCESS on ok */
|
|
int wolfSSL_RAND_seed(const void* seed, int len)
|
|
{
|
|
#ifndef WOLFSSL_NO_OPENSSL_RAND_CB
|
|
if (wolfSSL_RAND_InitMutex() == 0 && wc_LockMutex(&gRandMethodMutex) == 0) {
|
|
if (gRandMethods && gRandMethods->seed) {
|
|
int ret = gRandMethods->seed(seed, len);
|
|
wc_UnLockMutex(&gRandMethodMutex);
|
|
return ret;
|
|
}
|
|
wc_UnLockMutex(&gRandMethodMutex);
|
|
}
|
|
#else
|
|
(void)seed;
|
|
(void)len;
|
|
#endif
|
|
|
|
/* Make sure global shared RNG (globalRNG) is initialized */
|
|
return wolfSSL_RAND_Init();
|
|
}
|
|
|
|
|
|
/* Returns the path for reading seed data from.
|
|
* Uses the env variable $RANDFILE first if set, if not then used $HOME/.rnd
|
|
*
|
|
* Note uses stdlib by default unless XGETENV macro is overwritten
|
|
*
|
|
* fname buffer to hold path
|
|
* len length of fname buffer
|
|
*
|
|
* Returns a pointer to fname on success and NULL on failure
|
|
*/
|
|
const char* wolfSSL_RAND_file_name(char* fname, unsigned long len)
|
|
{
|
|
#ifndef NO_FILESYSTEM
|
|
char* rt;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_RAND_file_name");
|
|
|
|
if (fname == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
XMEMSET(fname, 0, len);
|
|
/* if access to stdlib.h */
|
|
if ((rt = XGETENV("RANDFILE")) != NULL) {
|
|
if (len > XSTRLEN(rt)) {
|
|
XMEMCPY(fname, rt, XSTRLEN(rt));
|
|
}
|
|
else {
|
|
WOLFSSL_MSG("RANDFILE too large for buffer");
|
|
rt = NULL;
|
|
}
|
|
}
|
|
|
|
/* $RANDFILE was not set or is too large, check $HOME */
|
|
if (rt == NULL) {
|
|
char ap[] = "/.rnd";
|
|
|
|
WOLFSSL_MSG("Environment variable RANDFILE not set");
|
|
if ((rt = XGETENV("HOME")) == NULL) {
|
|
WOLFSSL_MSG("Environment variable HOME not set");
|
|
return NULL;
|
|
}
|
|
|
|
if (len > XSTRLEN(rt) + XSTRLEN(ap)) {
|
|
fname[0] = '\0';
|
|
XSTRNCAT(fname, rt, len);
|
|
XSTRNCAT(fname, ap, len - XSTRLEN(rt));
|
|
return fname;
|
|
}
|
|
else {
|
|
WOLFSSL_MSG("HOME too large for buffer");
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
return fname;
|
|
#else
|
|
/* no filesystem defined */
|
|
WOLFSSL_ENTER("wolfSSL_RAND_file_name");
|
|
WOLFSSL_MSG("No filesystem feature enabled, not compiled in");
|
|
(void)fname;
|
|
(void)len;
|
|
return NULL;
|
|
#endif
|
|
}
|
|
|
|
|
|
/* Writes 1024 bytes from the RNG to the given file name.
|
|
*
|
|
* fname name of file to write to
|
|
*
|
|
* Returns the number of bytes written
|
|
*/
|
|
int wolfSSL_RAND_write_file(const char* fname)
|
|
{
|
|
int bytes = 0;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_RAND_write_file");
|
|
|
|
if (fname == NULL) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
#ifndef NO_FILESYSTEM
|
|
{
|
|
#ifndef WOLFSSL_SMALL_STACK
|
|
unsigned char buf[1024];
|
|
#else
|
|
unsigned char* buf = (unsigned char *)XMALLOC(1024, NULL,
|
|
DYNAMIC_TYPE_TMP_BUFFER);
|
|
if (buf == NULL) {
|
|
WOLFSSL_MSG("malloc failed");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
#endif
|
|
bytes = 1024; /* default size of buf */
|
|
|
|
if (initGlobalRNG == 0 && wolfSSL_RAND_Init() != WOLFSSL_SUCCESS) {
|
|
WOLFSSL_MSG("No RNG to use");
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
XFREE(buf, NULL, DYNAMIC_TYPE_TMP_BUFFER);
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
if (wc_RNG_GenerateBlock(&globalRNG, buf, bytes) != 0) {
|
|
WOLFSSL_MSG("Error generating random buffer");
|
|
bytes = 0;
|
|
}
|
|
else {
|
|
XFILE f;
|
|
|
|
#ifdef WOLFSSL_CHECK_MEM_ZERO
|
|
wc_MemZero_Add("wolfSSL_RAND_write_file buf", buf, bytes);
|
|
#endif
|
|
|
|
f = XFOPEN(fname, "wb");
|
|
if (f == XBADFILE) {
|
|
WOLFSSL_MSG("Error opening the file");
|
|
bytes = 0;
|
|
}
|
|
else {
|
|
size_t bytes_written = XFWRITE(buf, 1, bytes, f);
|
|
bytes = (int)bytes_written;
|
|
XFCLOSE(f);
|
|
}
|
|
}
|
|
ForceZero(buf, bytes);
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
XFREE(buf, NULL, DYNAMIC_TYPE_TMP_BUFFER);
|
|
#elif defined(WOLFSSL_CHECK_MEM_ZERO)
|
|
wc_MemZero_Check(buf, sizeof(buf));
|
|
#endif
|
|
}
|
|
#endif
|
|
|
|
return bytes;
|
|
}
|
|
|
|
#ifndef FREERTOS_TCP
|
|
|
|
/* These constant values are protocol values made by egd */
|
|
#if defined(USE_WOLFSSL_IO) && !defined(USE_WINDOWS_API) && !defined(HAVE_FIPS) && \
|
|
defined(HAVE_HASHDRBG) && !defined(NETOS) && defined(HAVE_SYS_UN_H)
|
|
#define WOLFSSL_EGD_NBLOCK 0x01
|
|
#include <sys/un.h>
|
|
#endif
|
|
|
|
/* This collects entropy from the path nm and seeds the global PRNG with it.
|
|
*
|
|
* nm is the file path to the egd server
|
|
*
|
|
* Returns the number of bytes read.
|
|
*/
|
|
int wolfSSL_RAND_egd(const char* nm)
|
|
{
|
|
#ifdef WOLFSSL_EGD_NBLOCK
|
|
struct sockaddr_un rem;
|
|
int fd;
|
|
int ret = WOLFSSL_SUCCESS;
|
|
word32 bytes = 0;
|
|
word32 idx = 0;
|
|
#ifndef WOLFSSL_SMALL_STACK
|
|
unsigned char buf[256];
|
|
#else
|
|
unsigned char* buf;
|
|
buf = (unsigned char*)XMALLOC(256, NULL, DYNAMIC_TYPE_TMP_BUFFER);
|
|
if (buf == NULL) {
|
|
WOLFSSL_MSG("Not enough memory");
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
#endif
|
|
|
|
XMEMSET(&rem, 0, sizeof(struct sockaddr_un));
|
|
if (nm == NULL) {
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
XFREE(buf, NULL, DYNAMIC_TYPE_TMP_BUFFER);
|
|
#endif
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
|
|
fd = socket(AF_UNIX, SOCK_STREAM, 0);
|
|
if (fd < 0) {
|
|
WOLFSSL_MSG("Error creating socket");
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
XFREE(buf, NULL, DYNAMIC_TYPE_TMP_BUFFER);
|
|
#endif
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
rem.sun_family = AF_UNIX;
|
|
XSTRNCPY(rem.sun_path, nm, sizeof(rem.sun_path) - 1);
|
|
rem.sun_path[sizeof(rem.sun_path)-1] = '\0';
|
|
|
|
/* connect to egd server */
|
|
if (connect(fd, (struct sockaddr*)&rem, sizeof(struct sockaddr_un)) == -1) {
|
|
WOLFSSL_MSG("error connecting to egd server");
|
|
ret = WOLFSSL_FATAL_ERROR;
|
|
}
|
|
|
|
#ifdef WOLFSSL_CHECK_MEM_ZERO
|
|
if (ret == WOLFSSL_SUCCESS) {
|
|
wc_MemZero_Add("wolfSSL_RAND_egd buf", buf, 256);
|
|
}
|
|
#endif
|
|
while (ret == WOLFSSL_SUCCESS && bytes < 255 && idx + 2 < 256) {
|
|
buf[idx] = WOLFSSL_EGD_NBLOCK;
|
|
buf[idx + 1] = 255 - bytes; /* request 255 bytes from server */
|
|
ret = (int)write(fd, buf + idx, 2);
|
|
if (ret != 2) {
|
|
if (errno == EAGAIN) {
|
|
ret = WOLFSSL_SUCCESS;
|
|
continue;
|
|
}
|
|
WOLFSSL_MSG("error requesting entropy from egd server");
|
|
ret = WOLFSSL_FATAL_ERROR;
|
|
break;
|
|
}
|
|
|
|
/* attempting to read */
|
|
buf[idx] = 0;
|
|
ret = (int)read(fd, buf + idx, 256 - bytes);
|
|
if (ret == 0) {
|
|
WOLFSSL_MSG("error reading entropy from egd server");
|
|
ret = WOLFSSL_FATAL_ERROR;
|
|
break;
|
|
}
|
|
if (ret > 0 && buf[idx] > 0) {
|
|
bytes += buf[idx]; /* egd stores amount sent in first byte */
|
|
if (bytes + idx > 255 || buf[idx] > ret) {
|
|
WOLFSSL_MSG("Buffer error");
|
|
ret = WOLFSSL_FATAL_ERROR;
|
|
break;
|
|
}
|
|
XMEMMOVE(buf + idx, buf + idx + 1, buf[idx]);
|
|
idx = bytes;
|
|
ret = WOLFSSL_SUCCESS;
|
|
if (bytes >= 255) {
|
|
break;
|
|
}
|
|
}
|
|
else {
|
|
if (errno == EAGAIN || errno == EINTR) {
|
|
WOLFSSL_MSG("EGD would read");
|
|
ret = WOLFSSL_SUCCESS; /* try again */
|
|
}
|
|
else if (buf[idx] == 0) {
|
|
/* if egd returned 0 then there is no more entropy to be had.
|
|
Do not try more reads. */
|
|
ret = WOLFSSL_SUCCESS;
|
|
break;
|
|
}
|
|
else {
|
|
WOLFSSL_MSG("Error with read");
|
|
ret = WOLFSSL_FATAL_ERROR;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (bytes > 0 && ret == WOLFSSL_SUCCESS) {
|
|
/* call to check global RNG is created */
|
|
if (wolfSSL_RAND_Init() != WOLFSSL_SUCCESS) {
|
|
WOLFSSL_MSG("Error with initializing global RNG structure");
|
|
ret = WOLFSSL_FATAL_ERROR;
|
|
}
|
|
else if (wc_RNG_DRBG_Reseed(&globalRNG, (const byte*) buf, bytes)
|
|
!= 0) {
|
|
WOLFSSL_MSG("Error with reseeding DRBG structure");
|
|
ret = WOLFSSL_FATAL_ERROR;
|
|
}
|
|
#ifdef SHOW_SECRETS
|
|
else { /* print out entropy found only when no error occurred */
|
|
word32 i;
|
|
printf("EGD Entropy = ");
|
|
for (i = 0; i < bytes; i++) {
|
|
printf("%02X", buf[i]);
|
|
}
|
|
printf("\n");
|
|
}
|
|
#endif
|
|
}
|
|
|
|
ForceZero(buf, bytes);
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
XFREE(buf, NULL, DYNAMIC_TYPE_TMP_BUFFER);
|
|
#elif defined(WOLFSSL_CHECK_MEM_ZERO)
|
|
wc_MemZero_Check(buf, 256);
|
|
#endif
|
|
close(fd);
|
|
|
|
if (ret == WOLFSSL_SUCCESS) {
|
|
return bytes;
|
|
}
|
|
else {
|
|
return ret;
|
|
}
|
|
#else
|
|
WOLFSSL_MSG("Type of socket needed is not available");
|
|
WOLFSSL_MSG("\tor using mode where DRBG API is not available");
|
|
(void)nm;
|
|
|
|
return WOLFSSL_FATAL_ERROR;
|
|
#endif /* WOLFSSL_EGD_NBLOCK */
|
|
}
|
|
|
|
#endif /* !FREERTOS_TCP */
|
|
|
|
void wolfSSL_RAND_Cleanup(void)
|
|
{
|
|
#ifndef WOLFSSL_NO_OPENSSL_RAND_CB
|
|
if (wolfSSL_RAND_InitMutex() == 0 && wc_LockMutex(&gRandMethodMutex) == 0) {
|
|
if (gRandMethods && gRandMethods->cleanup)
|
|
gRandMethods->cleanup();
|
|
wc_UnLockMutex(&gRandMethodMutex);
|
|
}
|
|
|
|
if (wc_FreeMutex(&gRandMethodMutex) == 0)
|
|
gRandMethodsInit = 0;
|
|
#endif
|
|
#ifdef HAVE_GLOBAL_RNG
|
|
if (wc_LockMutex(&globalRNGMutex) == 0) {
|
|
if (initGlobalRNG) {
|
|
wc_FreeRng(&globalRNG);
|
|
initGlobalRNG = 0;
|
|
}
|
|
wc_UnLockMutex(&globalRNGMutex);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
/* returns WOLFSSL_SUCCESS if the bytes generated are valid otherwise WOLFSSL_FAILURE */
|
|
int wolfSSL_RAND_pseudo_bytes(unsigned char* buf, int num)
|
|
{
|
|
int ret;
|
|
int hash;
|
|
byte secret[DRBG_SEED_LEN]; /* secret length arbitrarily chosen */
|
|
|
|
#ifndef WOLFSSL_NO_OPENSSL_RAND_CB
|
|
if (wolfSSL_RAND_InitMutex() == 0 && wc_LockMutex(&gRandMethodMutex) == 0) {
|
|
if (gRandMethods && gRandMethods->pseudorand) {
|
|
ret = gRandMethods->pseudorand(buf, num);
|
|
wc_UnLockMutex(&gRandMethodMutex);
|
|
return ret;
|
|
}
|
|
wc_UnLockMutex(&gRandMethodMutex);
|
|
}
|
|
#endif
|
|
|
|
#ifdef WOLFSSL_HAVE_PRF
|
|
#ifndef NO_SHA256
|
|
hash = WC_SHA256;
|
|
#elif defined(WOLFSSL_SHA384)
|
|
hash = WC_SHA384;
|
|
#elif !defined(NO_SHA)
|
|
hash = WC_SHA;
|
|
#elif !defined(NO_MD5)
|
|
hash = WC_MD5;
|
|
#endif
|
|
|
|
/* get secret value from source of entropy */
|
|
ret = wolfSSL_RAND_bytes(secret, DRBG_SEED_LEN);
|
|
|
|
/* uses input buffer to seed for pseudo random number generation, each
|
|
* thread will potentially have different results this way */
|
|
if (ret == WOLFSSL_SUCCESS) {
|
|
PRIVATE_KEY_UNLOCK();
|
|
ret = wc_PRF(buf, num, secret, DRBG_SEED_LEN, (const byte*)buf, num,
|
|
hash, NULL, INVALID_DEVID);
|
|
PRIVATE_KEY_LOCK();
|
|
ret = (ret == 0) ? WOLFSSL_SUCCESS: WOLFSSL_FAILURE;
|
|
}
|
|
#else
|
|
/* fall back to just doing wolfSSL_RAND_bytes if PRF not avialbale */
|
|
ret = wolfSSL_RAND_bytes(buf, num);
|
|
(void)hash;
|
|
(void)secret;
|
|
#endif
|
|
return ret;
|
|
}
|
|
|
|
/* returns WOLFSSL_SUCCESS if the bytes generated are valid otherwise WOLFSSL_FAILURE */
|
|
int wolfSSL_RAND_bytes(unsigned char* buf, int num)
|
|
{
|
|
int ret = 0;
|
|
WC_RNG* rng = NULL;
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
WC_RNG* tmpRNG = NULL;
|
|
#else
|
|
WC_RNG tmpRNG[1];
|
|
#endif
|
|
int initTmpRng = 0;
|
|
#ifdef HAVE_GLOBAL_RNG
|
|
int used_global = 0;
|
|
#endif
|
|
|
|
WOLFSSL_ENTER("wolfSSL_RAND_bytes");
|
|
/* sanity check */
|
|
if (buf == NULL || num < 0)
|
|
/* return code compliant with OpenSSL */
|
|
return 0;
|
|
|
|
/* if a RAND callback has been set try and use it */
|
|
#ifndef WOLFSSL_NO_OPENSSL_RAND_CB
|
|
if (wolfSSL_RAND_InitMutex() == 0 && wc_LockMutex(&gRandMethodMutex) == 0) {
|
|
if (gRandMethods && gRandMethods->bytes) {
|
|
ret = gRandMethods->bytes(buf, num);
|
|
wc_UnLockMutex(&gRandMethodMutex);
|
|
return ret;
|
|
}
|
|
wc_UnLockMutex(&gRandMethodMutex);
|
|
}
|
|
#endif
|
|
#ifdef HAVE_GLOBAL_RNG
|
|
if (initGlobalRNG) {
|
|
if (wc_LockMutex(&globalRNGMutex) != 0) {
|
|
WOLFSSL_MSG("Bad Lock Mutex rng");
|
|
return ret;
|
|
}
|
|
|
|
rng = &globalRNG;
|
|
used_global = 1;
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
tmpRNG = (WC_RNG*)XMALLOC(sizeof(WC_RNG), NULL, DYNAMIC_TYPE_RNG);
|
|
if (tmpRNG == NULL)
|
|
return ret;
|
|
#endif
|
|
if (wc_InitRng(tmpRNG) == 0) {
|
|
rng = tmpRNG;
|
|
initTmpRng = 1;
|
|
}
|
|
}
|
|
if (rng) {
|
|
/* handles size greater than RNG_MAX_BLOCK_LEN */
|
|
int blockCount = num / RNG_MAX_BLOCK_LEN;
|
|
|
|
while (blockCount--) {
|
|
ret = wc_RNG_GenerateBlock(rng, buf, RNG_MAX_BLOCK_LEN);
|
|
if (ret != 0) {
|
|
WOLFSSL_MSG("Bad wc_RNG_GenerateBlock");
|
|
break;
|
|
}
|
|
num -= RNG_MAX_BLOCK_LEN;
|
|
buf += RNG_MAX_BLOCK_LEN;
|
|
}
|
|
|
|
if (ret == 0 && num)
|
|
ret = wc_RNG_GenerateBlock(rng, buf, num);
|
|
|
|
if (ret != 0)
|
|
WOLFSSL_MSG("Bad wc_RNG_GenerateBlock");
|
|
else
|
|
ret = WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
#ifdef HAVE_GLOBAL_RNG
|
|
if (used_global == 1)
|
|
wc_UnLockMutex(&globalRNGMutex);
|
|
#endif
|
|
if (initTmpRng)
|
|
wc_FreeRng(tmpRNG);
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
if (tmpRNG)
|
|
XFREE(tmpRNG, NULL, DYNAMIC_TYPE_RNG);
|
|
#endif
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
int wolfSSL_RAND_poll(void)
|
|
{
|
|
byte entropy[16];
|
|
int ret = 0;
|
|
word32 entropy_sz = 16;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_RAND_poll");
|
|
if (initGlobalRNG == 0){
|
|
WOLFSSL_MSG("Global RNG no Init");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
ret = wc_GenerateSeed(&globalRNG.seed, entropy, entropy_sz);
|
|
if (ret != 0){
|
|
WOLFSSL_MSG("Bad wc_RNG_GenerateBlock");
|
|
ret = WOLFSSL_FAILURE;
|
|
}else
|
|
ret = WOLFSSL_SUCCESS;
|
|
|
|
return ret;
|
|
}
|
|
|
|
/* If a valid struct is provided with function pointers, will override
|
|
RAND_seed, bytes, cleanup, add, pseudo_bytes and status. If a NULL
|
|
pointer is passed in, it will cancel any previous function overrides.
|
|
|
|
Returns WOLFSSL_SUCCESS on success, WOLFSSL_FAILURE on failure. */
|
|
int wolfSSL_RAND_set_rand_method(const WOLFSSL_RAND_METHOD *methods)
|
|
{
|
|
#ifndef WOLFSSL_NO_OPENSSL_RAND_CB
|
|
if (wolfSSL_RAND_InitMutex() == 0 && wc_LockMutex(&gRandMethodMutex) == 0) {
|
|
gRandMethods = methods;
|
|
wc_UnLockMutex(&gRandMethodMutex);
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
#else
|
|
(void)methods;
|
|
#endif
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
/* Returns WOLFSSL_SUCCESS if the RNG has been seeded with enough data */
|
|
int wolfSSL_RAND_status(void)
|
|
{
|
|
int ret = WOLFSSL_SUCCESS;
|
|
#ifndef WOLFSSL_NO_OPENSSL_RAND_CB
|
|
if (wolfSSL_RAND_InitMutex() == 0 && wc_LockMutex(&gRandMethodMutex) == 0) {
|
|
if (gRandMethods && gRandMethods->status)
|
|
ret = gRandMethods->status();
|
|
wc_UnLockMutex(&gRandMethodMutex);
|
|
}
|
|
else {
|
|
ret = WOLFSSL_FAILURE;
|
|
}
|
|
#else
|
|
/* wolfCrypt provides enough seed internally, so return success */
|
|
#endif
|
|
return ret;
|
|
}
|
|
|
|
void wolfSSL_RAND_add(const void* add, int len, double entropy)
|
|
{
|
|
#ifndef WOLFSSL_NO_OPENSSL_RAND_CB
|
|
if (wolfSSL_RAND_InitMutex() == 0 && wc_LockMutex(&gRandMethodMutex) == 0) {
|
|
if (gRandMethods && gRandMethods->add) {
|
|
/* callback has return code, but RAND_add does not */
|
|
(void)gRandMethods->add(add, len, entropy);
|
|
}
|
|
wc_UnLockMutex(&gRandMethodMutex);
|
|
}
|
|
#else
|
|
/* wolfSSL seeds/adds internally, use explicit RNG if you want
|
|
to take control */
|
|
(void)add;
|
|
(void)len;
|
|
(void)entropy;
|
|
#endif
|
|
}
|
|
|
|
#endif /* OPENSSL_EXTRA */
|
|
|
|
/*******************************************************************************
|
|
* END OF RAND API
|
|
******************************************************************************/
|
|
|
|
/*******************************************************************************
|
|
* START OF EVP_CIPHER API
|
|
******************************************************************************/
|
|
|
|
#ifdef OPENSSL_EXTRA
|
|
|
|
/* store for external read of iv, WOLFSSL_SUCCESS on success */
|
|
int wolfSSL_StoreExternalIV(WOLFSSL_EVP_CIPHER_CTX* ctx)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_StoreExternalIV");
|
|
|
|
if (ctx == NULL) {
|
|
WOLFSSL_MSG("Bad function argument");
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
|
|
switch (ctx->cipherType) {
|
|
#ifndef NO_AES
|
|
#if defined(HAVE_AES_CBC) || defined(WOLFSSL_AES_DIRECT)
|
|
case AES_128_CBC_TYPE :
|
|
case AES_192_CBC_TYPE :
|
|
case AES_256_CBC_TYPE :
|
|
WOLFSSL_MSG("AES CBC");
|
|
XMEMCPY(ctx->iv, &ctx->cipher.aes.reg, ctx->ivSz);
|
|
break;
|
|
#endif
|
|
#ifdef HAVE_AESGCM
|
|
case AES_128_GCM_TYPE :
|
|
case AES_192_GCM_TYPE :
|
|
case AES_256_GCM_TYPE :
|
|
WOLFSSL_MSG("AES GCM");
|
|
XMEMCPY(ctx->iv, &ctx->cipher.aes.reg, ctx->ivSz);
|
|
break;
|
|
#endif /* HAVE_AESGCM */
|
|
#ifdef HAVE_AESCCM
|
|
case AES_128_CCM_TYPE :
|
|
case AES_192_CCM_TYPE :
|
|
case AES_256_CCM_TYPE :
|
|
WOLFSSL_MSG("AES CCM");
|
|
XMEMCPY(ctx->iv, &ctx->cipher.aes.reg, ctx->ivSz);
|
|
break;
|
|
#endif /* HAVE_AESCCM */
|
|
#ifdef HAVE_AES_ECB
|
|
case AES_128_ECB_TYPE :
|
|
case AES_192_ECB_TYPE :
|
|
case AES_256_ECB_TYPE :
|
|
WOLFSSL_MSG("AES ECB");
|
|
break;
|
|
#endif
|
|
#ifdef WOLFSSL_AES_COUNTER
|
|
case AES_128_CTR_TYPE :
|
|
case AES_192_CTR_TYPE :
|
|
case AES_256_CTR_TYPE :
|
|
WOLFSSL_MSG("AES CTR");
|
|
XMEMCPY(ctx->iv, &ctx->cipher.aes.reg, AES_BLOCK_SIZE);
|
|
break;
|
|
#endif /* WOLFSSL_AES_COUNTER */
|
|
#ifdef WOLFSSL_AES_CFB
|
|
#if !defined(HAVE_SELFTEST) && !defined(HAVE_FIPS)
|
|
case AES_128_CFB1_TYPE:
|
|
case AES_192_CFB1_TYPE:
|
|
case AES_256_CFB1_TYPE:
|
|
WOLFSSL_MSG("AES CFB1");
|
|
break;
|
|
case AES_128_CFB8_TYPE:
|
|
case AES_192_CFB8_TYPE:
|
|
case AES_256_CFB8_TYPE:
|
|
WOLFSSL_MSG("AES CFB8");
|
|
break;
|
|
#endif /* !HAVE_SELFTEST && !HAVE_FIPS */
|
|
case AES_128_CFB128_TYPE:
|
|
case AES_192_CFB128_TYPE:
|
|
case AES_256_CFB128_TYPE:
|
|
WOLFSSL_MSG("AES CFB128");
|
|
break;
|
|
#endif /* WOLFSSL_AES_CFB */
|
|
#if defined(WOLFSSL_AES_OFB)
|
|
case AES_128_OFB_TYPE:
|
|
case AES_192_OFB_TYPE:
|
|
case AES_256_OFB_TYPE:
|
|
WOLFSSL_MSG("AES OFB");
|
|
break;
|
|
#endif /* WOLFSSL_AES_OFB */
|
|
#ifdef WOLFSSL_AES_XTS
|
|
case AES_128_XTS_TYPE:
|
|
case AES_256_XTS_TYPE:
|
|
WOLFSSL_MSG("AES XTS");
|
|
break;
|
|
#endif /* WOLFSSL_AES_XTS */
|
|
#endif /* NO_AES */
|
|
|
|
#ifdef HAVE_ARIA
|
|
case ARIA_128_GCM_TYPE :
|
|
case ARIA_192_GCM_TYPE :
|
|
case ARIA_256_GCM_TYPE :
|
|
WOLFSSL_MSG("ARIA GCM");
|
|
XMEMCPY(ctx->iv, &ctx->cipher.aria.nonce, ARIA_BLOCK_SIZE);
|
|
break;
|
|
#endif /* HAVE_ARIA */
|
|
|
|
#ifndef NO_DES3
|
|
case DES_CBC_TYPE :
|
|
WOLFSSL_MSG("DES CBC");
|
|
XMEMCPY(ctx->iv, &ctx->cipher.des.reg, DES_BLOCK_SIZE);
|
|
break;
|
|
|
|
case DES_EDE3_CBC_TYPE :
|
|
WOLFSSL_MSG("DES EDE3 CBC");
|
|
XMEMCPY(ctx->iv, &ctx->cipher.des3.reg, DES_BLOCK_SIZE);
|
|
break;
|
|
#endif
|
|
#ifdef WOLFSSL_DES_ECB
|
|
case DES_ECB_TYPE :
|
|
WOLFSSL_MSG("DES ECB");
|
|
break;
|
|
case DES_EDE3_ECB_TYPE :
|
|
WOLFSSL_MSG("DES3 ECB");
|
|
break;
|
|
#endif
|
|
case ARC4_TYPE :
|
|
WOLFSSL_MSG("ARC4");
|
|
break;
|
|
|
|
#if defined(HAVE_CHACHA) && defined(HAVE_POLY1305)
|
|
case CHACHA20_POLY1305_TYPE:
|
|
break;
|
|
#endif
|
|
|
|
#ifdef HAVE_CHACHA
|
|
case CHACHA20_TYPE:
|
|
break;
|
|
#endif
|
|
|
|
#ifdef WOLFSSL_SM4_ECB
|
|
case SM4_ECB_TYPE:
|
|
break;
|
|
#endif
|
|
#ifdef WOLFSSL_SM4_CBC
|
|
case SM4_CBC_TYPE:
|
|
WOLFSSL_MSG("SM4 CBC");
|
|
XMEMCPY(&ctx->cipher.sm4.iv, ctx->iv, SM4_BLOCK_SIZE);
|
|
break;
|
|
#endif
|
|
#ifdef WOLFSSL_SM4_CTR
|
|
case SM4_CTR_TYPE:
|
|
WOLFSSL_MSG("SM4 CTR");
|
|
XMEMCPY(&ctx->cipher.sm4.iv, ctx->iv, SM4_BLOCK_SIZE);
|
|
break;
|
|
#endif
|
|
#ifdef WOLFSSL_SM4_GCM
|
|
case SM4_GCM_TYPE:
|
|
WOLFSSL_MSG("SM4 GCM");
|
|
XMEMCPY(&ctx->cipher.sm4.iv, ctx->iv, SM4_BLOCK_SIZE);
|
|
break;
|
|
#endif
|
|
#ifdef WOLFSSL_SM4_CCM
|
|
case SM4_CCM_TYPE:
|
|
WOLFSSL_MSG("SM4 CCM");
|
|
XMEMCPY(&ctx->cipher.sm4.iv, ctx->iv, SM4_BLOCK_SIZE);
|
|
break;
|
|
#endif
|
|
|
|
case NULL_CIPHER_TYPE :
|
|
WOLFSSL_MSG("NULL");
|
|
break;
|
|
|
|
default: {
|
|
WOLFSSL_MSG("bad type");
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
}
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
/* set internal IV from external, WOLFSSL_SUCCESS on success */
|
|
int wolfSSL_SetInternalIV(WOLFSSL_EVP_CIPHER_CTX* ctx)
|
|
{
|
|
|
|
WOLFSSL_ENTER("wolfSSL_SetInternalIV");
|
|
|
|
if (ctx == NULL) {
|
|
WOLFSSL_MSG("Bad function argument");
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
|
|
switch (ctx->cipherType) {
|
|
|
|
#ifndef NO_AES
|
|
#if defined(HAVE_AES_CBC) || defined(WOLFSSL_AES_DIRECT)
|
|
case AES_128_CBC_TYPE :
|
|
case AES_192_CBC_TYPE :
|
|
case AES_256_CBC_TYPE :
|
|
WOLFSSL_MSG("AES CBC");
|
|
XMEMCPY(&ctx->cipher.aes.reg, ctx->iv, AES_BLOCK_SIZE);
|
|
break;
|
|
#endif
|
|
#ifdef HAVE_AESGCM
|
|
case AES_128_GCM_TYPE :
|
|
case AES_192_GCM_TYPE :
|
|
case AES_256_GCM_TYPE :
|
|
WOLFSSL_MSG("AES GCM");
|
|
XMEMCPY(&ctx->cipher.aes.reg, ctx->iv, AES_BLOCK_SIZE);
|
|
break;
|
|
#endif
|
|
#ifdef HAVE_AES_ECB
|
|
case AES_128_ECB_TYPE :
|
|
case AES_192_ECB_TYPE :
|
|
case AES_256_ECB_TYPE :
|
|
WOLFSSL_MSG("AES ECB");
|
|
break;
|
|
#endif
|
|
#ifdef WOLFSSL_AES_COUNTER
|
|
case AES_128_CTR_TYPE :
|
|
case AES_192_CTR_TYPE :
|
|
case AES_256_CTR_TYPE :
|
|
WOLFSSL_MSG("AES CTR");
|
|
XMEMCPY(&ctx->cipher.aes.reg, ctx->iv, AES_BLOCK_SIZE);
|
|
break;
|
|
#endif
|
|
|
|
#endif /* NO_AES */
|
|
|
|
#ifdef HAVE_ARIA
|
|
case ARIA_128_GCM_TYPE :
|
|
case ARIA_192_GCM_TYPE :
|
|
case ARIA_256_GCM_TYPE :
|
|
WOLFSSL_MSG("ARIA GCM");
|
|
XMEMCPY(&ctx->cipher.aria.nonce, ctx->iv, ARIA_BLOCK_SIZE);
|
|
break;
|
|
#endif /* HAVE_ARIA */
|
|
|
|
#ifndef NO_DES3
|
|
case DES_CBC_TYPE :
|
|
WOLFSSL_MSG("DES CBC");
|
|
XMEMCPY(&ctx->cipher.des.reg, ctx->iv, DES_BLOCK_SIZE);
|
|
break;
|
|
|
|
case DES_EDE3_CBC_TYPE :
|
|
WOLFSSL_MSG("DES EDE3 CBC");
|
|
XMEMCPY(&ctx->cipher.des3.reg, ctx->iv, DES_BLOCK_SIZE);
|
|
break;
|
|
#endif
|
|
#ifdef WOLFSSL_DES_ECB
|
|
case DES_ECB_TYPE :
|
|
WOLFSSL_MSG("DES ECB");
|
|
break;
|
|
case DES_EDE3_ECB_TYPE :
|
|
WOLFSSL_MSG("DES3 ECB");
|
|
break;
|
|
#endif
|
|
|
|
case ARC4_TYPE :
|
|
WOLFSSL_MSG("ARC4");
|
|
break;
|
|
|
|
#if defined(HAVE_CHACHA) && defined(HAVE_POLY1305)
|
|
case CHACHA20_POLY1305_TYPE:
|
|
break;
|
|
#endif
|
|
|
|
#ifdef HAVE_CHACHA
|
|
case CHACHA20_TYPE:
|
|
break;
|
|
#endif
|
|
|
|
#ifdef WOLFSSL_SM4_ECB
|
|
case SM4_ECB_TYPE:
|
|
break;
|
|
#endif
|
|
#ifdef WOLFSSL_SM4_CBC
|
|
case SM4_CBC_TYPE:
|
|
WOLFSSL_MSG("SM4 CBC");
|
|
XMEMCPY(ctx->iv, &ctx->cipher.sm4.iv, ctx->ivSz);
|
|
break;
|
|
#endif
|
|
#ifdef WOLFSSL_SM4_CTR
|
|
case SM4_CTR_TYPE:
|
|
WOLFSSL_MSG("SM4 CTR");
|
|
XMEMCPY(ctx->iv, &ctx->cipher.sm4.iv, ctx->ivSz);
|
|
break;
|
|
#endif
|
|
#ifdef WOLFSSL_SM4_GCM
|
|
case SM4_GCM_TYPE:
|
|
WOLFSSL_MSG("SM4 GCM");
|
|
XMEMCPY(ctx->iv, &ctx->cipher.sm4.iv, ctx->ivSz);
|
|
break;
|
|
#endif
|
|
#ifdef WOLFSSL_SM4_CCM
|
|
case SM4_CCM_TYPE:
|
|
WOLFSSL_MSG("SM4 CCM");
|
|
XMEMCPY(ctx->iv, &ctx->cipher.sm4.iv, ctx->ivSz);
|
|
break;
|
|
#endif
|
|
|
|
case NULL_CIPHER_TYPE :
|
|
WOLFSSL_MSG("NULL");
|
|
break;
|
|
|
|
default: {
|
|
WOLFSSL_MSG("bad type");
|
|
return WOLFSSL_FATAL_ERROR;
|
|
}
|
|
}
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
#ifndef NO_DES3
|
|
|
|
void wolfSSL_3des_iv(WOLFSSL_EVP_CIPHER_CTX* ctx, int doset,
|
|
unsigned char* iv, int len)
|
|
{
|
|
(void)len;
|
|
|
|
WOLFSSL_MSG("wolfSSL_3des_iv");
|
|
|
|
if (ctx == NULL || iv == NULL) {
|
|
WOLFSSL_MSG("Bad function argument");
|
|
return;
|
|
}
|
|
|
|
if (doset)
|
|
wc_Des3_SetIV(&ctx->cipher.des3, iv); /* OpenSSL compat, no ret */
|
|
else
|
|
XMEMCPY(iv, &ctx->cipher.des3.reg, DES_BLOCK_SIZE);
|
|
}
|
|
|
|
#endif /* NO_DES3 */
|
|
|
|
|
|
#ifndef NO_AES
|
|
|
|
void wolfSSL_aes_ctr_iv(WOLFSSL_EVP_CIPHER_CTX* ctx, int doset,
|
|
unsigned char* iv, int len)
|
|
{
|
|
(void)len;
|
|
|
|
WOLFSSL_MSG("wolfSSL_aes_ctr_iv");
|
|
|
|
if (ctx == NULL || iv == NULL) {
|
|
WOLFSSL_MSG("Bad function argument");
|
|
return;
|
|
}
|
|
|
|
if (doset)
|
|
(void)wc_AesSetIV(&ctx->cipher.aes, iv); /* OpenSSL compat, no ret */
|
|
else
|
|
XMEMCPY(iv, &ctx->cipher.aes.reg, AES_BLOCK_SIZE);
|
|
}
|
|
|
|
#endif /* NO_AES */
|
|
|
|
#endif /* OPENSSL_EXTRA */
|
|
|
|
/*******************************************************************************
|
|
* END OF EVP_CIPHER API
|
|
******************************************************************************/
|
|
|
|
#ifndef NO_CERTS
|
|
|
|
#define WOLFSSL_X509_STORE_INCLUDED
|
|
#include <src/x509_str.c>
|
|
|
|
/*******************************************************************************
|
|
* START OF PKCS7 APIs
|
|
******************************************************************************/
|
|
#ifdef HAVE_PKCS7
|
|
|
|
#ifdef OPENSSL_ALL
|
|
PKCS7* wolfSSL_PKCS7_new(void)
|
|
{
|
|
WOLFSSL_PKCS7* pkcs7;
|
|
int ret = 0;
|
|
|
|
pkcs7 = (WOLFSSL_PKCS7*)XMALLOC(sizeof(WOLFSSL_PKCS7), NULL,
|
|
DYNAMIC_TYPE_PKCS7);
|
|
if (pkcs7 != NULL) {
|
|
XMEMSET(pkcs7, 0, sizeof(WOLFSSL_PKCS7));
|
|
ret = wc_PKCS7_Init(&pkcs7->pkcs7, NULL, INVALID_DEVID);
|
|
}
|
|
|
|
if (ret != 0 && pkcs7 != NULL) {
|
|
XFREE(pkcs7, NULL, DYNAMIC_TYPE_PKCS7);
|
|
pkcs7 = NULL;
|
|
}
|
|
|
|
return (PKCS7*)pkcs7;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* wolfSSL_PKCS7_SIGNED_new - allocates PKCS7 and initialize it for a signed data
|
|
*
|
|
* RETURNS:
|
|
* returns pointer to the PKCS7 structure on success, otherwise returns NULL
|
|
*/
|
|
PKCS7_SIGNED* wolfSSL_PKCS7_SIGNED_new(void)
|
|
{
|
|
byte signedData[]= { 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x07, 0x02};
|
|
PKCS7* pkcs7 = NULL;
|
|
|
|
if ((pkcs7 = wolfSSL_PKCS7_new()) == NULL)
|
|
return NULL;
|
|
pkcs7->contentOID = SIGNED_DATA;
|
|
if ((wc_PKCS7_SetContentType(pkcs7, signedData, sizeof(signedData))) < 0) {
|
|
if (pkcs7) {
|
|
wolfSSL_PKCS7_free(pkcs7);
|
|
return NULL;
|
|
}
|
|
}
|
|
return pkcs7;
|
|
}
|
|
|
|
void wolfSSL_PKCS7_free(PKCS7* pkcs7)
|
|
{
|
|
WOLFSSL_PKCS7* p7 = (WOLFSSL_PKCS7*)pkcs7;
|
|
|
|
if (p7 != NULL) {
|
|
if (p7->data != NULL)
|
|
XFREE(p7->data, NULL, DYNAMIC_TYPE_PKCS7);
|
|
wc_PKCS7_Free(&p7->pkcs7);
|
|
if (p7->certs)
|
|
wolfSSL_sk_pop_free(p7->certs, NULL);
|
|
XFREE(p7, NULL, DYNAMIC_TYPE_PKCS7);
|
|
}
|
|
}
|
|
|
|
void wolfSSL_PKCS7_SIGNED_free(PKCS7_SIGNED* p7)
|
|
{
|
|
wolfSSL_PKCS7_free(p7);
|
|
return;
|
|
}
|
|
|
|
/**
|
|
* Convert DER/ASN.1 encoded signedData structure to internal PKCS7
|
|
* structure. Note, does not support detached content.
|
|
*
|
|
* p7 - pointer to set to address of newly created PKCS7 structure on return
|
|
* in - pointer to pointer of DER/ASN.1 data
|
|
* len - length of input data, bytes
|
|
*
|
|
* Returns newly allocated and populated PKCS7 structure or NULL on error.
|
|
*/
|
|
PKCS7* wolfSSL_d2i_PKCS7(PKCS7** p7, const unsigned char** in, int len)
|
|
{
|
|
return wolfSSL_d2i_PKCS7_ex(p7, in, len, NULL, 0);
|
|
}
|
|
|
|
/* This internal function is only decoding and setting up the PKCS7 struct. It
|
|
* does not verify the PKCS7 signature.
|
|
*
|
|
* RETURNS:
|
|
* returns pointer to a PKCS7 structure on success, otherwise returns NULL
|
|
*/
|
|
static PKCS7* wolfSSL_d2i_PKCS7_only(PKCS7** p7, const unsigned char** in,
|
|
int len, byte* content, word32 contentSz)
|
|
{
|
|
WOLFSSL_PKCS7* pkcs7 = NULL;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_d2i_PKCS7_ex");
|
|
|
|
if (in == NULL || *in == NULL || len < 0)
|
|
return NULL;
|
|
|
|
if ((pkcs7 = (WOLFSSL_PKCS7*)wolfSSL_PKCS7_new()) == NULL)
|
|
return NULL;
|
|
|
|
pkcs7->len = len;
|
|
pkcs7->data = (byte*)XMALLOC(pkcs7->len, NULL, DYNAMIC_TYPE_PKCS7);
|
|
if (pkcs7->data == NULL) {
|
|
wolfSSL_PKCS7_free((PKCS7*)pkcs7);
|
|
return NULL;
|
|
}
|
|
XMEMCPY(pkcs7->data, *in, pkcs7->len);
|
|
|
|
if (content != NULL) {
|
|
pkcs7->pkcs7.content = content;
|
|
pkcs7->pkcs7.contentSz = contentSz;
|
|
}
|
|
|
|
if (p7 != NULL)
|
|
*p7 = (PKCS7*)pkcs7;
|
|
*in += pkcs7->len;
|
|
return (PKCS7*)pkcs7;
|
|
}
|
|
|
|
|
|
/*****************************************************************************
|
|
* wolfSSL_d2i_PKCS7_ex - Converts the given unsigned char buffer of size len
|
|
* into a PKCS7 object. Optionally, accepts a byte buffer of content which
|
|
* is stored as the PKCS7 object's content, to support detached signatures.
|
|
* @param content The content which is signed, in case the signature is
|
|
* detached. Ignored if NULL.
|
|
* @param contentSz The size of the passed in content.
|
|
*
|
|
* RETURNS:
|
|
* returns pointer to a PKCS7 structure on success, otherwise returns NULL
|
|
*/
|
|
PKCS7* wolfSSL_d2i_PKCS7_ex(PKCS7** p7, const unsigned char** in, int len,
|
|
byte* content, word32 contentSz)
|
|
{
|
|
WOLFSSL_PKCS7* pkcs7 = NULL;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_d2i_PKCS7_ex");
|
|
|
|
if (in == NULL || *in == NULL || len < 0)
|
|
return NULL;
|
|
|
|
pkcs7 = (WOLFSSL_PKCS7*)wolfSSL_d2i_PKCS7_only(p7, in, len, content,
|
|
contentSz);
|
|
if (pkcs7 != NULL) {
|
|
if (wc_PKCS7_VerifySignedData(&pkcs7->pkcs7, pkcs7->data, pkcs7->len)
|
|
!= 0) {
|
|
WOLFSSL_MSG("wc_PKCS7_VerifySignedData failed");
|
|
wolfSSL_PKCS7_free((PKCS7*)pkcs7);
|
|
if (p7 != NULL) {
|
|
*p7 = NULL;
|
|
}
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
return (PKCS7*)pkcs7;
|
|
}
|
|
|
|
|
|
/**
|
|
* This API was added as a helper function for libest. It
|
|
* extracts a stack of certificates from the pkcs7 object.
|
|
* @param pkcs7 PKCS7 parameter object
|
|
* @return WOLFSSL_STACK_OF(WOLFSSL_X509)*
|
|
*/
|
|
WOLFSSL_STACK* wolfSSL_PKCS7_to_stack(PKCS7* pkcs7)
|
|
{
|
|
int i;
|
|
WOLFSSL_PKCS7* p7 = (WOLFSSL_PKCS7*)pkcs7;
|
|
WOLF_STACK_OF(WOLFSSL_X509)* ret = NULL;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_PKCS7_to_stack");
|
|
|
|
if (!p7) {
|
|
WOLFSSL_MSG("Bad parameter");
|
|
return NULL;
|
|
}
|
|
|
|
if (p7->certs)
|
|
return p7->certs;
|
|
|
|
for (i = 0; i < MAX_PKCS7_CERTS && p7->pkcs7.cert[i]; i++) {
|
|
WOLFSSL_X509* x509 = wolfSSL_X509_d2i(NULL, p7->pkcs7.cert[i],
|
|
p7->pkcs7.certSz[i]);
|
|
if (!ret)
|
|
ret = wolfSSL_sk_X509_new_null();
|
|
if (x509) {
|
|
if (wolfSSL_sk_X509_push(ret, x509) != WOLFSSL_SUCCESS) {
|
|
wolfSSL_X509_free(x509);
|
|
WOLFSSL_MSG("wolfSSL_sk_X509_push error");
|
|
goto error;
|
|
}
|
|
}
|
|
else {
|
|
WOLFSSL_MSG("wolfSSL_X509_d2i error");
|
|
goto error;
|
|
}
|
|
}
|
|
|
|
/* Save stack to free later */
|
|
if (p7->certs)
|
|
wolfSSL_sk_pop_free(p7->certs, NULL);
|
|
p7->certs = ret;
|
|
|
|
return ret;
|
|
error:
|
|
if (ret) {
|
|
wolfSSL_sk_pop_free(ret, NULL);
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/**
|
|
* Return stack of signers contained in PKCS7 cert.
|
|
* Notes:
|
|
* - Currently only PKCS#7 messages with a single signer cert is supported.
|
|
* - Returned WOLFSSL_STACK must be freed by caller.
|
|
*
|
|
* pkcs7 - PKCS7 struct to retrieve signer certs from.
|
|
* certs - currently unused
|
|
* flags - flags to control function behavior.
|
|
*
|
|
* Return WOLFSSL_STACK of signers on success, NULL on error.
|
|
*/
|
|
WOLFSSL_STACK* wolfSSL_PKCS7_get0_signers(PKCS7* pkcs7, WOLFSSL_STACK* certs,
|
|
int flags)
|
|
{
|
|
WOLFSSL_X509* x509 = NULL;
|
|
WOLFSSL_STACK* signers = NULL;
|
|
WOLFSSL_PKCS7* p7 = (WOLFSSL_PKCS7*)pkcs7;
|
|
|
|
if (p7 == NULL)
|
|
return NULL;
|
|
|
|
/* Only PKCS#7 messages with a single cert that is the verifying certificate
|
|
* is supported.
|
|
*/
|
|
if (flags & PKCS7_NOINTERN) {
|
|
WOLFSSL_MSG("PKCS7_NOINTERN flag not supported");
|
|
return NULL;
|
|
}
|
|
|
|
signers = wolfSSL_sk_X509_new_null();
|
|
if (signers == NULL)
|
|
return NULL;
|
|
|
|
if (wolfSSL_d2i_X509(&x509, (const byte**)&p7->pkcs7.singleCert,
|
|
p7->pkcs7.singleCertSz) == NULL) {
|
|
wolfSSL_sk_X509_pop_free(signers, NULL);
|
|
return NULL;
|
|
}
|
|
|
|
if (wolfSSL_sk_X509_push(signers, x509) != WOLFSSL_SUCCESS) {
|
|
wolfSSL_sk_X509_pop_free(signers, NULL);
|
|
return NULL;
|
|
}
|
|
|
|
(void)certs;
|
|
|
|
return signers;
|
|
}
|
|
|
|
#ifndef NO_BIO
|
|
|
|
PKCS7* wolfSSL_d2i_PKCS7_bio(WOLFSSL_BIO* bio, PKCS7** p7)
|
|
{
|
|
WOLFSSL_PKCS7* pkcs7;
|
|
int ret;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_d2i_PKCS7_bio");
|
|
|
|
if (bio == NULL)
|
|
return NULL;
|
|
|
|
if ((pkcs7 = (WOLFSSL_PKCS7*)wolfSSL_PKCS7_new()) == NULL)
|
|
return NULL;
|
|
|
|
pkcs7->len = wolfSSL_BIO_get_len(bio);
|
|
pkcs7->data = (byte*)XMALLOC(pkcs7->len, NULL, DYNAMIC_TYPE_PKCS7);
|
|
if (pkcs7->data == NULL) {
|
|
wolfSSL_PKCS7_free((PKCS7*)pkcs7);
|
|
return NULL;
|
|
}
|
|
|
|
if ((ret = wolfSSL_BIO_read(bio, pkcs7->data, pkcs7->len)) <= 0) {
|
|
wolfSSL_PKCS7_free((PKCS7*)pkcs7);
|
|
return NULL;
|
|
}
|
|
/* pkcs7->len may change if using b64 for example */
|
|
pkcs7->len = ret;
|
|
|
|
if (wc_PKCS7_VerifySignedData(&pkcs7->pkcs7, pkcs7->data, pkcs7->len)
|
|
!= 0) {
|
|
WOLFSSL_MSG("wc_PKCS7_VerifySignedData failed");
|
|
wolfSSL_PKCS7_free((PKCS7*)pkcs7);
|
|
return NULL;
|
|
}
|
|
|
|
if (p7 != NULL)
|
|
*p7 = (PKCS7*)pkcs7;
|
|
return (PKCS7*)pkcs7;
|
|
}
|
|
|
|
int wolfSSL_i2d_PKCS7(PKCS7 *p7, unsigned char **out)
|
|
{
|
|
byte* output = NULL;
|
|
int localBuf = 0;
|
|
int len;
|
|
WC_RNG rng;
|
|
int ret = WOLFSSL_FAILURE;
|
|
WOLFSSL_ENTER("wolfSSL_i2d_PKCS7");
|
|
|
|
if (!out || !p7) {
|
|
WOLFSSL_MSG("Bad parameter");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
if (!p7->rng) {
|
|
if (wc_InitRng(&rng) != 0) {
|
|
WOLFSSL_MSG("wc_InitRng error");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
p7->rng = &rng; /* cppcheck-suppress autoVariables
|
|
*/
|
|
}
|
|
|
|
if ((len = wc_PKCS7_EncodeSignedData(p7, NULL, 0)) < 0) {
|
|
WOLFSSL_MSG("wc_PKCS7_EncodeSignedData error");
|
|
goto cleanup;
|
|
}
|
|
|
|
if (*out == NULL) {
|
|
output = (byte*)XMALLOC(len, NULL, DYNAMIC_TYPE_TMP_BUFFER);
|
|
if (!output) {
|
|
WOLFSSL_MSG("malloc error");
|
|
goto cleanup;
|
|
}
|
|
localBuf = 1;
|
|
}
|
|
else {
|
|
output = *out;
|
|
}
|
|
|
|
if ((len = wc_PKCS7_EncodeSignedData(p7, output, len)) < 0) {
|
|
WOLFSSL_MSG("wc_PKCS7_EncodeSignedData error");
|
|
goto cleanup;
|
|
}
|
|
|
|
ret = len;
|
|
cleanup:
|
|
if (p7->rng == &rng) {
|
|
wc_FreeRng(&rng);
|
|
p7->rng = NULL;
|
|
}
|
|
if (ret == WOLFSSL_FAILURE && localBuf && output)
|
|
XFREE(output, NULL, DYNAMIC_TYPE_TMP_BUFFER);
|
|
if (ret != WOLFSSL_FAILURE)
|
|
*out = output;
|
|
return ret;
|
|
}
|
|
|
|
int wolfSSL_i2d_PKCS7_bio(WOLFSSL_BIO *bio, PKCS7 *p7)
|
|
{
|
|
byte* output = NULL;
|
|
int len;
|
|
int ret = WOLFSSL_FAILURE;
|
|
WOLFSSL_ENTER("wolfSSL_i2d_PKCS7_bio");
|
|
|
|
if (!bio || !p7) {
|
|
WOLFSSL_MSG("Bad parameter");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
if ((len = wolfSSL_i2d_PKCS7(p7, &output)) == WOLFSSL_FAILURE) {
|
|
WOLFSSL_MSG("wolfSSL_i2d_PKCS7 error");
|
|
goto cleanup;
|
|
}
|
|
|
|
if (wolfSSL_BIO_write(bio, output, len) <= 0) {
|
|
WOLFSSL_MSG("wolfSSL_BIO_write error");
|
|
goto cleanup;
|
|
}
|
|
|
|
ret = WOLFSSL_SUCCESS;
|
|
cleanup:
|
|
if (output)
|
|
XFREE(output, NULL, DYNAMIC_TYPE_TMP_BUFFER);
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* Creates and returns a PKCS7 signedData structure.
|
|
*
|
|
* Inner content type is set to DATA to match OpenSSL behavior.
|
|
*
|
|
* signer - certificate to sign bundle with
|
|
* pkey - private key matching signer
|
|
* certs - optional additional set of certificates to include
|
|
* in - input data to be signed
|
|
* flags - optional set of flags to control sign behavior
|
|
*
|
|
* PKCS7_BINARY - Do not translate input data to MIME canonical
|
|
* format (\r\n line endings), thus preventing corruption of
|
|
* binary content.
|
|
* PKCS7_TEXT - Prepend MIME headers for text/plain to content.
|
|
* PKCS7_DETACHED - Set signature detached, omit content from output bundle.
|
|
* PKCS7_STREAM - initialize PKCS7 struct for signing, do not read data.
|
|
*
|
|
* Flags not currently supported:
|
|
* PKCS7_NOCERTS - Do not include the signer cert in the output bundle.
|
|
* PKCS7_PARTIAL - Allow for PKCS7_sign() to be only partially set up,
|
|
* then signers etc to be added separately before
|
|
* calling PKCS7_final().
|
|
*
|
|
* Returns valid PKCS7 structure pointer, or NULL if an error occurred.
|
|
*/
|
|
PKCS7* wolfSSL_PKCS7_sign(WOLFSSL_X509* signer, WOLFSSL_EVP_PKEY* pkey,
|
|
WOLFSSL_STACK* certs, WOLFSSL_BIO* in, int flags)
|
|
{
|
|
int err = 0;
|
|
WOLFSSL_PKCS7* p7 = NULL;
|
|
WOLFSSL_STACK* cert = certs;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_PKCS7_sign");
|
|
|
|
if (flags & PKCS7_NOCERTS) {
|
|
WOLFSSL_MSG("PKCS7_NOCERTS flag not yet supported");
|
|
err = 1;
|
|
}
|
|
|
|
if (flags & PKCS7_PARTIAL) {
|
|
WOLFSSL_MSG("PKCS7_PARTIAL flag not yet supported");
|
|
err = 1;
|
|
}
|
|
|
|
if ((err == 0) && (signer == NULL || signer->derCert == NULL ||
|
|
signer->derCert->length == 0)) {
|
|
WOLFSSL_MSG("Bad function arg, signer is NULL or incomplete");
|
|
err = 1;
|
|
}
|
|
|
|
if ((err == 0) && (pkey == NULL || pkey->pkey.ptr == NULL ||
|
|
pkey->pkey_sz <= 0)) {
|
|
WOLFSSL_MSG("Bad function arg, pkey is NULL or incomplete");
|
|
err = 1;
|
|
}
|
|
|
|
if ((err == 0) && (in == NULL) && !(flags & PKCS7_STREAM)) {
|
|
WOLFSSL_MSG("input data required unless PKCS7_STREAM used");
|
|
err = 1;
|
|
}
|
|
|
|
if ((err == 0) && ((p7 = (WOLFSSL_PKCS7*)wolfSSL_PKCS7_new()) == NULL)) {
|
|
WOLFSSL_MSG("Error allocating new WOLFSSL_PKCS7");
|
|
err = 1;
|
|
}
|
|
|
|
/* load signer certificate */
|
|
if (err == 0) {
|
|
if (wc_PKCS7_InitWithCert(&p7->pkcs7, signer->derCert->buffer,
|
|
signer->derCert->length) != 0) {
|
|
WOLFSSL_MSG("Failed to load signer certificate");
|
|
err = 1;
|
|
}
|
|
}
|
|
|
|
/* set signer private key, data types, defaults */
|
|
if (err == 0) {
|
|
p7->pkcs7.privateKey = (byte*)pkey->pkey.ptr;
|
|
p7->pkcs7.privateKeySz = pkey->pkey_sz;
|
|
p7->pkcs7.contentOID = DATA; /* inner content default is DATA */
|
|
p7->pkcs7.hashOID = SHA256h; /* default to SHA-256 hash type */
|
|
p7->type = SIGNED_DATA; /* PKCS7_final switches on type */
|
|
}
|
|
|
|
/* add additional chain certs if provided */
|
|
while (cert && (err == 0)) {
|
|
if (cert->data.x509 != NULL && cert->data.x509->derCert != NULL) {
|
|
if (wc_PKCS7_AddCertificate(&p7->pkcs7,
|
|
cert->data.x509->derCert->buffer,
|
|
cert->data.x509->derCert->length) != 0) {
|
|
WOLFSSL_MSG("Error in wc_PKCS7_AddCertificate");
|
|
err = 1;
|
|
}
|
|
}
|
|
cert = cert->next;
|
|
}
|
|
|
|
if ((err == 0) && (flags & PKCS7_DETACHED)) {
|
|
if (wc_PKCS7_SetDetached(&p7->pkcs7, 1) != 0) {
|
|
WOLFSSL_MSG("Failed to set signature detached");
|
|
err = 1;
|
|
}
|
|
}
|
|
|
|
if ((err == 0) && (flags & PKCS7_STREAM)) {
|
|
/* if streaming, return before finalizing */
|
|
return (PKCS7*)p7;
|
|
}
|
|
|
|
if ((err == 0) && (wolfSSL_PKCS7_final((PKCS7*)p7, in, flags) != 1)) {
|
|
WOLFSSL_MSG("Error calling wolfSSL_PKCS7_final");
|
|
err = 1;
|
|
}
|
|
|
|
if ((err != 0) && (p7 != NULL)) {
|
|
wolfSSL_PKCS7_free((PKCS7*)p7);
|
|
p7 = NULL;
|
|
}
|
|
|
|
return (PKCS7*)p7;
|
|
}
|
|
|
|
#ifdef HAVE_SMIME
|
|
|
|
#ifndef MAX_MIME_LINE_LEN
|
|
#define MAX_MIME_LINE_LEN 1024
|
|
#endif
|
|
|
|
/**
|
|
* Copy input BIO to output BIO, but convert all line endings to CRLF (\r\n),
|
|
* used by PKCS7_final().
|
|
*
|
|
* in - input WOLFSSL_BIO to be converted
|
|
* out - output WOLFSSL_BIO to hold copy of in, with line endings adjusted
|
|
*
|
|
* Return 0 on success, negative on error
|
|
*/
|
|
static int wolfSSL_BIO_to_MIME_crlf(WOLFSSL_BIO* in, WOLFSSL_BIO* out)
|
|
{
|
|
int ret = 0;
|
|
int lineLen = 0;
|
|
word32 canonLineLen = 0;
|
|
char* canonLine = NULL;
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
char* line = NULL;
|
|
#else
|
|
char line[MAX_MIME_LINE_LEN];
|
|
#endif
|
|
|
|
if (in == NULL || out == NULL) {
|
|
return BAD_FUNC_ARG;
|
|
}
|
|
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
line = (char*)XMALLOC(MAX_MIME_LINE_LEN, in->heap,
|
|
DYNAMIC_TYPE_TMP_BUFFER);
|
|
if (line == NULL) {
|
|
return MEMORY_E;
|
|
}
|
|
#endif
|
|
XMEMSET(line, 0, MAX_MIME_LINE_LEN);
|
|
|
|
while ((lineLen = wolfSSL_BIO_gets(in, line, MAX_MIME_LINE_LEN)) > 0) {
|
|
|
|
if (line[lineLen - 1] == '\r' || line[lineLen - 1] == '\n') {
|
|
canonLineLen = (word32)lineLen;
|
|
if ((canonLine = wc_MIME_single_canonicalize(
|
|
line, &canonLineLen)) == NULL) {
|
|
ret = -1;
|
|
break;
|
|
}
|
|
|
|
/* remove trailing null */
|
|
if (canonLineLen >= 1 && canonLine[canonLineLen-1] == '\0') {
|
|
canonLineLen--;
|
|
}
|
|
|
|
if (wolfSSL_BIO_write(out, canonLine, (int)canonLineLen) < 0) {
|
|
ret = -1;
|
|
break;
|
|
}
|
|
XFREE(canonLine, NULL, DYNAMIC_TYPE_PKCS7);
|
|
canonLine = NULL;
|
|
}
|
|
else {
|
|
/* no line ending in current line, write direct to out */
|
|
if (wolfSSL_BIO_write(out, line, lineLen) < 0) {
|
|
ret = -1;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (canonLine != NULL) {
|
|
XFREE(canonLine, NULL, DYNAMIC_TYPE_PKCS7);
|
|
}
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
XFREE(line, in->heap, DYNAMIC_TYPE_TMP_BUFFER);
|
|
#endif
|
|
|
|
return ret;
|
|
}
|
|
|
|
#endif /* HAVE_SMIME */
|
|
|
|
/* Used by both PKCS7_final() and PKCS7_verify() */
|
|
static const char contTypeText[] = "Content-Type: text/plain\r\n\r\n";
|
|
|
|
/**
|
|
* Finalize PKCS7 structure, currently supports signedData only.
|
|
*
|
|
* Does not generate final bundle (ie: signedData), but finalizes
|
|
* the PKCS7 structure in preparation for a output function to be called next.
|
|
*
|
|
* pkcs7 - initialized PKCS7 structure, populated with signer, etc
|
|
* in - input data
|
|
* flags - flags to control PKCS7 behavior. Other flags except those noted
|
|
* below are ignored:
|
|
*
|
|
* PKCS7_BINARY - Do not translate input data to MIME canonical
|
|
* format (\r\n line endings), thus preventing corruption of
|
|
* binary content.
|
|
* PKCS7_TEXT - Prepend MIME headers for text/plain to content.
|
|
*
|
|
* Returns 1 on success, 0 on error
|
|
*/
|
|
int wolfSSL_PKCS7_final(PKCS7* pkcs7, WOLFSSL_BIO* in, int flags)
|
|
{
|
|
int ret = 1;
|
|
int memSz = 0;
|
|
unsigned char* mem = NULL;
|
|
WOLFSSL_PKCS7* p7 = (WOLFSSL_PKCS7*)pkcs7;
|
|
WOLFSSL_BIO* data = NULL;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_PKCS7_final");
|
|
|
|
if (p7 == NULL || in == NULL) {
|
|
WOLFSSL_MSG("Bad input args to PKCS7_final");
|
|
ret = 0;
|
|
}
|
|
|
|
if (ret == 1) {
|
|
if ((data = wolfSSL_BIO_new(wolfSSL_BIO_s_mem())) == NULL) {
|
|
WOLFSSL_MSG("Error in wolfSSL_BIO_new");
|
|
ret = 0;
|
|
}
|
|
}
|
|
|
|
/* prepend Content-Type header if PKCS7_TEXT */
|
|
if ((ret == 1) && (flags & PKCS7_TEXT)) {
|
|
if (wolfSSL_BIO_write(data, contTypeText,
|
|
(int)XSTR_SIZEOF(contTypeText)) < 0) {
|
|
WOLFSSL_MSG("Error prepending Content-Type header");
|
|
ret = 0;
|
|
}
|
|
}
|
|
|
|
/* convert line endings to CRLF if !PKCS7_BINARY */
|
|
if (ret == 1) {
|
|
if (flags & PKCS7_BINARY) {
|
|
|
|
/* no CRLF conversion, direct copy content */
|
|
if ((memSz = wolfSSL_BIO_get_len(in)) <= 0) {
|
|
ret = 0;
|
|
}
|
|
if (ret == 1) {
|
|
mem = (unsigned char*)XMALLOC(memSz, in->heap,
|
|
DYNAMIC_TYPE_TMP_BUFFER);
|
|
if (mem == NULL) {
|
|
WOLFSSL_MSG("Failed to allocate memory for input data");
|
|
ret = 0;
|
|
}
|
|
}
|
|
|
|
if (ret == 1) {
|
|
if (wolfSSL_BIO_read(in, mem, memSz) != memSz) {
|
|
WOLFSSL_MSG("Error reading from input BIO");
|
|
ret = 0;
|
|
}
|
|
else if (wolfSSL_BIO_write(data, mem, memSz) < 0) {
|
|
ret = 0;
|
|
}
|
|
}
|
|
|
|
if (mem != NULL) {
|
|
XFREE(mem, in->heap, DYNAMIC_TYPE_TMP_BUFFER);
|
|
}
|
|
}
|
|
else {
|
|
#ifdef HAVE_SMIME
|
|
/* convert content line endings to CRLF */
|
|
if (wolfSSL_BIO_to_MIME_crlf(in, data) != 0) {
|
|
WOLFSSL_MSG("Error converting line endings to CRLF");
|
|
ret = 0;
|
|
}
|
|
else {
|
|
p7->pkcs7.contentCRLF = 1;
|
|
}
|
|
#else
|
|
WOLFSSL_MSG("Without PKCS7_BINARY requires wolfSSL to be built "
|
|
"with HAVE_SMIME");
|
|
ret = 0;
|
|
#endif
|
|
}
|
|
}
|
|
|
|
if ((ret == 1) && ((memSz = wolfSSL_BIO_get_mem_data(data, &mem)) < 0)) {
|
|
WOLFSSL_MSG("Error in wolfSSL_BIO_get_mem_data");
|
|
ret = 0;
|
|
}
|
|
|
|
if (ret == 1) {
|
|
if (p7->data != NULL) {
|
|
XFREE(p7->data, NULL, DYNAMIC_TYPE_PKCS7);
|
|
}
|
|
p7->data = (byte*)XMALLOC(memSz, NULL, DYNAMIC_TYPE_PKCS7);
|
|
if (p7->data == NULL) {
|
|
ret = 0;
|
|
}
|
|
else {
|
|
XMEMCPY(p7->data, mem, memSz);
|
|
p7->len = memSz;
|
|
}
|
|
}
|
|
|
|
if (ret == 1) {
|
|
p7->pkcs7.content = p7->data;
|
|
p7->pkcs7.contentSz = p7->len;
|
|
}
|
|
|
|
if (data != NULL) {
|
|
wolfSSL_BIO_free(data);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int wolfSSL_PKCS7_verify(PKCS7* pkcs7, WOLFSSL_STACK* certs,
|
|
WOLFSSL_X509_STORE* store, WOLFSSL_BIO* in, WOLFSSL_BIO* out, int flags)
|
|
{
|
|
int i, ret = 0;
|
|
unsigned char* mem = NULL;
|
|
int memSz = 0;
|
|
WOLFSSL_PKCS7* p7 = (WOLFSSL_PKCS7*)pkcs7;
|
|
int contTypeLen;
|
|
WOLFSSL_X509* signer = NULL;
|
|
WOLFSSL_STACK* signers = NULL;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_PKCS7_verify");
|
|
|
|
if (pkcs7 == NULL)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
if (in != NULL) {
|
|
if ((memSz = wolfSSL_BIO_get_mem_data(in, &mem)) < 0)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
p7->pkcs7.content = mem;
|
|
p7->pkcs7.contentSz = memSz;
|
|
}
|
|
|
|
/* certs is the list of certificates to find the cert with issuer/serial. */
|
|
(void)certs;
|
|
/* store is the certificate store to use to verify signer certificate
|
|
* associated with the signers.
|
|
*/
|
|
(void)store;
|
|
|
|
ret = wc_PKCS7_VerifySignedData(&p7->pkcs7, p7->data, p7->len);
|
|
if (ret != 0)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
if ((flags & PKCS7_NOVERIFY) != PKCS7_NOVERIFY) {
|
|
/* Verify signer certificates */
|
|
if (store == NULL || store->cm == NULL) {
|
|
WOLFSSL_MSG("No store or store certs, but PKCS7_NOVERIFY not set");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
signers = wolfSSL_PKCS7_get0_signers(pkcs7, certs, flags);
|
|
if (signers == NULL) {
|
|
WOLFSSL_MSG("No signers found to verify");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
for (i = 0; i < wolfSSL_sk_X509_num(signers); i++) {
|
|
signer = wolfSSL_sk_X509_value(signers, i);
|
|
|
|
if (wolfSSL_CertManagerVerifyBuffer(store->cm,
|
|
signer->derCert->buffer,
|
|
signer->derCert->length,
|
|
WOLFSSL_FILETYPE_ASN1) != WOLFSSL_SUCCESS) {
|
|
WOLFSSL_MSG("Failed to verify signer certificate");
|
|
wolfSSL_sk_X509_pop_free(signers, NULL);
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
}
|
|
wolfSSL_sk_X509_pop_free(signers, NULL);
|
|
}
|
|
|
|
if (flags & PKCS7_TEXT) {
|
|
/* strip MIME header for text/plain, otherwise error */
|
|
contTypeLen = XSTR_SIZEOF(contTypeText);
|
|
if ((p7->pkcs7.contentSz < (word32)contTypeLen) ||
|
|
(XMEMCMP(p7->pkcs7.content, contTypeText, contTypeLen) != 0)) {
|
|
WOLFSSL_MSG("Error PKCS7 Content-Type not found with PKCS7_TEXT");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
p7->pkcs7.content += contTypeLen;
|
|
p7->pkcs7.contentSz -= contTypeLen;
|
|
}
|
|
|
|
if (out != NULL) {
|
|
wolfSSL_BIO_write(out, p7->pkcs7.content, p7->pkcs7.contentSz);
|
|
}
|
|
|
|
WOLFSSL_LEAVE("wolfSSL_PKCS7_verify", WOLFSSL_SUCCESS);
|
|
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
* This API was added as a helper function for libest. It
|
|
* encodes a stack of certificates to pkcs7 format.
|
|
* @param pkcs7 PKCS7 parameter object
|
|
* @param certs WOLFSSL_STACK_OF(WOLFSSL_X509)*
|
|
* @param out Output bio
|
|
* @return WOLFSSL_SUCCESS on success and WOLFSSL_FAILURE on failure
|
|
*/
|
|
int wolfSSL_PKCS7_encode_certs(PKCS7* pkcs7, WOLFSSL_STACK* certs,
|
|
WOLFSSL_BIO* out)
|
|
{
|
|
int ret;
|
|
WOLFSSL_PKCS7* p7;
|
|
WOLFSSL_ENTER("wolfSSL_PKCS7_encode_certs");
|
|
|
|
if (!pkcs7 || !certs || !out) {
|
|
WOLFSSL_MSG("Bad parameter");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
p7 = (WOLFSSL_PKCS7*)pkcs7;
|
|
|
|
/* take ownership of certs */
|
|
p7->certs = certs;
|
|
/* TODO: takes ownership even on failure below but not on above failure. */
|
|
|
|
if (pkcs7->certList) {
|
|
WOLFSSL_MSG("wolfSSL_PKCS7_encode_certs called multiple times on same "
|
|
"struct");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
if (certs) {
|
|
/* Save some of the values */
|
|
int hashOID = pkcs7->hashOID;
|
|
byte version = pkcs7->version;
|
|
|
|
if (!certs->data.x509 || !certs->data.x509->derCert) {
|
|
WOLFSSL_MSG("Missing cert");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
if (wc_PKCS7_InitWithCert(pkcs7, certs->data.x509->derCert->buffer,
|
|
certs->data.x509->derCert->length) != 0) {
|
|
WOLFSSL_MSG("wc_PKCS7_InitWithCert error");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
certs = certs->next;
|
|
|
|
pkcs7->hashOID = hashOID;
|
|
pkcs7->version = version;
|
|
}
|
|
|
|
/* Add the certs to the PKCS7 struct */
|
|
while (certs) {
|
|
if (!certs->data.x509 || !certs->data.x509->derCert) {
|
|
WOLFSSL_MSG("Missing cert");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
if (wc_PKCS7_AddCertificate(pkcs7, certs->data.x509->derCert->buffer,
|
|
certs->data.x509->derCert->length) != 0) {
|
|
WOLFSSL_MSG("wc_PKCS7_AddCertificate error");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
certs = certs->next;
|
|
}
|
|
|
|
if (wc_PKCS7_SetSignerIdentifierType(pkcs7, DEGENERATE_SID) != 0) {
|
|
WOLFSSL_MSG("wc_PKCS7_SetSignerIdentifierType error");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
ret = wolfSSL_i2d_PKCS7_bio(out, pkcs7);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* wolfSSL_PEM_write_bio_PKCS7 - writes the PKCS7 data to BIO
|
|
*
|
|
* RETURNS:
|
|
* returns WOLFSSL_SUCCESS on success, otherwise returns WOLFSSL_FAILURE
|
|
*/
|
|
int wolfSSL_PEM_write_bio_PKCS7(WOLFSSL_BIO* bio, PKCS7* p7)
|
|
{
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
byte* outputHead;
|
|
byte* outputFoot;
|
|
#else
|
|
byte outputHead[2048];
|
|
byte outputFoot[2048];
|
|
#endif
|
|
word32 outputHeadSz = 2048;
|
|
word32 outputFootSz = 2048;
|
|
word32 outputSz = 0;
|
|
byte* output = NULL;
|
|
byte* pem = NULL;
|
|
int pemSz = -1;
|
|
enum wc_HashType hashType;
|
|
byte hashBuf[WC_MAX_DIGEST_SIZE];
|
|
word32 hashSz = -1;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_PEM_write_bio_PKCS7");
|
|
|
|
if (bio == NULL || p7 == NULL)
|
|
return WOLFSSL_FAILURE;
|
|
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
outputHead = (byte*)XMALLOC(outputHeadSz, bio->heap,
|
|
DYNAMIC_TYPE_TMP_BUFFER);
|
|
if (outputHead == NULL)
|
|
return MEMORY_E;
|
|
|
|
outputFoot = (byte*)XMALLOC(outputFootSz, bio->heap,
|
|
DYNAMIC_TYPE_TMP_BUFFER);
|
|
if (outputFoot == NULL)
|
|
goto error;
|
|
|
|
#endif
|
|
|
|
XMEMSET(hashBuf, 0, WC_MAX_DIGEST_SIZE);
|
|
XMEMSET(outputHead, 0, outputHeadSz);
|
|
XMEMSET(outputFoot, 0, outputFootSz);
|
|
|
|
hashType = wc_OidGetHash(p7->hashOID);
|
|
hashSz = wc_HashGetDigestSize(hashType);
|
|
if (hashSz > WC_MAX_DIGEST_SIZE)
|
|
goto error;
|
|
|
|
/* only SIGNED_DATA is supported */
|
|
switch (p7->contentOID) {
|
|
case SIGNED_DATA:
|
|
break;
|
|
default:
|
|
WOLFSSL_MSG("Unknown PKCS#7 Type");
|
|
goto error;
|
|
};
|
|
|
|
if ((wc_PKCS7_EncodeSignedData_ex(p7, hashBuf, hashSz,
|
|
outputHead, &outputHeadSz, outputFoot, &outputFootSz)) != 0)
|
|
goto error;
|
|
|
|
outputSz = outputHeadSz + p7->contentSz + outputFootSz;
|
|
output = (byte*)XMALLOC(outputSz, bio->heap, DYNAMIC_TYPE_TMP_BUFFER);
|
|
|
|
if (!output)
|
|
goto error;
|
|
|
|
XMEMSET(output, 0, outputSz);
|
|
outputSz = 0;
|
|
XMEMCPY(&output[outputSz], outputHead, outputHeadSz);
|
|
outputSz += outputHeadSz;
|
|
XMEMCPY(&output[outputSz], p7->content, p7->contentSz);
|
|
outputSz += p7->contentSz;
|
|
XMEMCPY(&output[outputSz], outputFoot, outputFootSz);
|
|
outputSz += outputFootSz;
|
|
|
|
/* get PEM size */
|
|
pemSz = wc_DerToPemEx(output, outputSz, NULL, 0, NULL, CERT_TYPE);
|
|
if (pemSz < 0)
|
|
goto error;
|
|
|
|
pemSz++; /* for '\0'*/
|
|
|
|
/* create PEM buffer and convert from DER to PEM*/
|
|
if ((pem = (byte*)XMALLOC(pemSz, bio->heap, DYNAMIC_TYPE_TMP_BUFFER))
|
|
== NULL)
|
|
goto error;
|
|
|
|
XMEMSET(pem, 0, pemSz);
|
|
|
|
if (wc_DerToPemEx(output, outputSz, pem, pemSz, NULL, CERT_TYPE) < 0) {
|
|
goto error;
|
|
}
|
|
if ((wolfSSL_BIO_write(bio, pem, pemSz) == pemSz)) {
|
|
XFREE(output, bio->heap, DYNAMIC_TYPE_TMP_BUFFER);
|
|
XFREE(pem, bio->heap, DYNAMIC_TYPE_TMP_BUFFER);
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
XFREE(outputHead, bio->heap, DYNAMIC_TYPE_TMP_BUFFER);
|
|
XFREE(outputFoot, bio->heap, DYNAMIC_TYPE_TMP_BUFFER);
|
|
#endif
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
error:
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
if (outputHead) {
|
|
XFREE(outputHead, bio->heap, DYNAMIC_TYPE_TMP_BUFFER);
|
|
}
|
|
if (outputFoot) {
|
|
XFREE(outputFoot, bio->heap, DYNAMIC_TYPE_TMP_BUFFER);
|
|
}
|
|
#endif
|
|
if (output) {
|
|
XFREE(output, bio->heap, DYNAMIC_TYPE_TMP_BUFFER);
|
|
}
|
|
if (pem) {
|
|
XFREE(pem, bio->heap, DYNAMIC_TYPE_TMP_BUFFER);
|
|
}
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
#ifdef HAVE_SMIME
|
|
/*****************************************************************************
|
|
* wolfSSL_SMIME_read_PKCS7 - Reads the given S/MIME message and parses it into
|
|
* a PKCS7 object. In case of a multipart message, stores the signed data in
|
|
* bcont.
|
|
*
|
|
* RETURNS:
|
|
* returns pointer to a PKCS7 structure on success, otherwise returns NULL
|
|
*/
|
|
PKCS7* wolfSSL_SMIME_read_PKCS7(WOLFSSL_BIO* in,
|
|
WOLFSSL_BIO** bcont)
|
|
{
|
|
MimeHdr* allHdrs = NULL;
|
|
MimeHdr* curHdr = NULL;
|
|
MimeParam* curParam = NULL;
|
|
int inLen = 0;
|
|
byte* bcontMem = NULL;
|
|
int bcontMemSz = 0;
|
|
int sectionLen = 0;
|
|
int ret = -1;
|
|
char* section = NULL;
|
|
char* canonLine = NULL;
|
|
char* canonSection = NULL;
|
|
PKCS7* pkcs7 = NULL;
|
|
word32 outLen = 0;
|
|
word32 canonLineLen = 0;
|
|
byte* out = NULL;
|
|
byte* outHead = NULL;
|
|
|
|
int canonPos = 0;
|
|
int lineLen = 0;
|
|
int remainLen = 0;
|
|
byte isEnd = 0;
|
|
size_t canonSize = 0;
|
|
size_t boundLen = 0;
|
|
char* boundary = NULL;
|
|
|
|
static const char kContType[] = "Content-Type";
|
|
static const char kCTE[] = "Content-Transfer-Encoding";
|
|
static const char kMultSigned[] = "multipart/signed";
|
|
static const char kAppPkcsSign[] = "application/pkcs7-signature";
|
|
static const char kAppXPkcsSign[] = "application/x-pkcs7-signature";
|
|
static const char kAppPkcs7Mime[] = "application/pkcs7-mime";
|
|
static const char kAppXPkcs7Mime[] = "application/x-pkcs7-mime";
|
|
|
|
WOLFSSL_ENTER("wolfSSL_SMIME_read_PKCS7");
|
|
|
|
if (in == NULL || bcont == NULL) {
|
|
goto error;
|
|
}
|
|
inLen = wolfSSL_BIO_get_len(in);
|
|
if (inLen <= 0) {
|
|
goto error;
|
|
}
|
|
remainLen = wolfSSL_BIO_get_len(in);
|
|
if (remainLen <= 0) {
|
|
goto error;
|
|
}
|
|
|
|
section = (char*)XMALLOC(remainLen+1, NULL, DYNAMIC_TYPE_PKCS7);
|
|
if (section == NULL) {
|
|
goto error;
|
|
}
|
|
lineLen = wolfSSL_BIO_gets(in, section, remainLen);
|
|
if (lineLen <= 0) {
|
|
goto error;
|
|
}
|
|
while (isEnd == 0 && remainLen > 0) {
|
|
sectionLen += lineLen;
|
|
remainLen -= lineLen;
|
|
lineLen = wolfSSL_BIO_gets(in, §ion[sectionLen], remainLen);
|
|
if (lineLen <= 0) {
|
|
goto error;
|
|
}
|
|
/* Line with just newline signals end of headers. */
|
|
if ((lineLen==2 && !XSTRNCMP(§ion[sectionLen],
|
|
"\r\n", 2)) ||
|
|
(lineLen==1 && (section[sectionLen] == '\r' ||
|
|
section[sectionLen] == '\n'))) {
|
|
isEnd = 1;
|
|
}
|
|
}
|
|
section[sectionLen] = '\0';
|
|
ret = wc_MIME_parse_headers(section, sectionLen, &allHdrs);
|
|
if (ret < 0) {
|
|
WOLFSSL_MSG("Parsing MIME headers failed.");
|
|
goto error;
|
|
}
|
|
isEnd = 0;
|
|
section[0] = '\0';
|
|
sectionLen = 0;
|
|
|
|
curHdr = wc_MIME_find_header_name(kContType, allHdrs);
|
|
if (curHdr && !XSTRNCMP(curHdr->body, kMultSigned,
|
|
XSTR_SIZEOF(kMultSigned))) {
|
|
curParam = wc_MIME_find_param_attr("protocol", curHdr->params);
|
|
if (curParam && (!XSTRNCMP(curParam->value, kAppPkcsSign,
|
|
XSTR_SIZEOF(kAppPkcsSign)) ||
|
|
!XSTRNCMP(curParam->value, kAppXPkcsSign,
|
|
XSTR_SIZEOF(kAppXPkcsSign)))) {
|
|
curParam = wc_MIME_find_param_attr("boundary", curHdr->params);
|
|
if (curParam == NULL) {
|
|
goto error;
|
|
}
|
|
|
|
boundLen = XSTRLEN(curParam->value) + 2;
|
|
boundary = (char*)XMALLOC(boundLen+1, NULL, DYNAMIC_TYPE_PKCS7);
|
|
if (boundary == NULL) {
|
|
goto error;
|
|
}
|
|
XMEMSET(boundary, 0, (word32)(boundLen+1));
|
|
boundary[0] = boundary[1] = '-';
|
|
XSTRNCPY(&boundary[2], curParam->value, boundLen-2);
|
|
|
|
/* Parse up to first boundary, ignore everything here. */
|
|
lineLen = wolfSSL_BIO_gets(in, section, remainLen);
|
|
if (lineLen <= 0) {
|
|
goto error;
|
|
}
|
|
while (XSTRNCMP(§ion[sectionLen], boundary, boundLen) &&
|
|
remainLen > 0) {
|
|
sectionLen += lineLen;
|
|
remainLen -= lineLen;
|
|
lineLen = wolfSSL_BIO_gets(in, §ion[sectionLen],
|
|
remainLen);
|
|
if (lineLen <= 0) {
|
|
goto error;
|
|
}
|
|
}
|
|
|
|
section[0] = '\0';
|
|
sectionLen = 0;
|
|
canonSize = remainLen + 1;
|
|
canonSection = (char*)XMALLOC(canonSize, NULL,
|
|
DYNAMIC_TYPE_PKCS7);
|
|
if (canonSection == NULL) {
|
|
goto error;
|
|
}
|
|
|
|
lineLen = wolfSSL_BIO_gets(in, section, remainLen);
|
|
if (lineLen < 0) {
|
|
goto error;
|
|
}
|
|
while (XSTRNCMP(§ion[sectionLen], boundary, boundLen) &&
|
|
remainLen > 0) {
|
|
canonLineLen = lineLen;
|
|
canonLine = wc_MIME_single_canonicalize(§ion[sectionLen],
|
|
&canonLineLen);
|
|
if (canonLine == NULL) {
|
|
goto error;
|
|
}
|
|
/* If line endings were added, the initial length may be
|
|
* exceeded. */
|
|
if ((canonPos + canonLineLen) >= canonSize) {
|
|
canonSize = canonPos + canonLineLen;
|
|
canonSection = (char*)XREALLOC(canonSection, canonSize,
|
|
NULL, DYNAMIC_TYPE_PKCS7);
|
|
if (canonSection == NULL) {
|
|
goto error;
|
|
}
|
|
}
|
|
XMEMCPY(&canonSection[canonPos], canonLine,
|
|
(int)canonLineLen - 1);
|
|
canonPos += canonLineLen - 1;
|
|
XFREE(canonLine, NULL, DYNAMIC_TYPE_PKCS7);
|
|
canonLine = NULL;
|
|
|
|
sectionLen += lineLen;
|
|
remainLen -= lineLen;
|
|
|
|
lineLen = wolfSSL_BIO_gets(in, §ion[sectionLen],
|
|
remainLen);
|
|
if (lineLen <= 0) {
|
|
goto error;
|
|
}
|
|
}
|
|
|
|
if (canonPos > 0) {
|
|
canonPos--;
|
|
}
|
|
|
|
/* Strip the final trailing newline. Support \r, \n or \r\n. */
|
|
if (canonSection[canonPos] == '\n') {
|
|
if (canonPos > 0) {
|
|
canonPos--;
|
|
}
|
|
}
|
|
|
|
if (canonSection[canonPos] == '\r') {
|
|
if (canonPos > 0) {
|
|
canonPos--;
|
|
}
|
|
}
|
|
|
|
canonSection[canonPos+1] = '\0';
|
|
|
|
*bcont = wolfSSL_BIO_new(wolfSSL_BIO_s_mem());
|
|
ret = wolfSSL_BIO_write(*bcont, canonSection,
|
|
canonPos + 1);
|
|
if (ret != (canonPos+1)) {
|
|
goto error;
|
|
}
|
|
if ((bcontMemSz = wolfSSL_BIO_get_mem_data(*bcont, &bcontMem))
|
|
< 0) {
|
|
goto error;
|
|
}
|
|
XFREE(canonSection, NULL, DYNAMIC_TYPE_PKCS7);
|
|
canonSection = NULL;
|
|
|
|
wc_MIME_free_hdrs(allHdrs);
|
|
allHdrs = NULL;
|
|
section[0] = '\0';
|
|
sectionLen = 0;
|
|
lineLen = wolfSSL_BIO_gets(in, section, remainLen);
|
|
if (lineLen <= 0) {
|
|
goto error;
|
|
}
|
|
while (isEnd == 0 && remainLen > 0) {
|
|
sectionLen += lineLen;
|
|
remainLen -= lineLen;
|
|
lineLen = wolfSSL_BIO_gets(in, §ion[sectionLen],
|
|
remainLen);
|
|
if (lineLen <= 0) {
|
|
goto error;
|
|
}
|
|
/* Line with just newline signals end of headers. */
|
|
if ((lineLen==2 && !XSTRNCMP(§ion[sectionLen],
|
|
"\r\n", 2)) ||
|
|
(lineLen==1 && (section[sectionLen] == '\r' ||
|
|
section[sectionLen] == '\n'))) {
|
|
isEnd = 1;
|
|
}
|
|
}
|
|
section[sectionLen] = '\0';
|
|
ret = wc_MIME_parse_headers(section, sectionLen, &allHdrs);
|
|
if (ret < 0) {
|
|
WOLFSSL_MSG("Parsing MIME headers failed.");
|
|
goto error;
|
|
}
|
|
curHdr = wc_MIME_find_header_name(kContType, allHdrs);
|
|
if (curHdr == NULL || (XSTRNCMP(curHdr->body, kAppPkcsSign,
|
|
XSTR_SIZEOF(kAppPkcsSign)) &&
|
|
XSTRNCMP(curHdr->body, kAppXPkcsSign,
|
|
XSTR_SIZEOF(kAppXPkcsSign)))) {
|
|
WOLFSSL_MSG("S/MIME headers not found inside "
|
|
"multipart message.\n");
|
|
goto error;
|
|
}
|
|
|
|
section[0] = '\0';
|
|
sectionLen = 0;
|
|
lineLen = wolfSSL_BIO_gets(in, section, remainLen);
|
|
while (XSTRNCMP(§ion[sectionLen], boundary, boundLen) &&
|
|
remainLen > 0) {
|
|
sectionLen += lineLen;
|
|
remainLen -= lineLen;
|
|
lineLen = wolfSSL_BIO_gets(in, §ion[sectionLen],
|
|
remainLen);
|
|
if (lineLen <= 0) {
|
|
goto error;
|
|
}
|
|
}
|
|
|
|
XFREE(boundary, NULL, DYNAMIC_TYPE_PKCS7);
|
|
boundary = NULL;
|
|
}
|
|
}
|
|
else if (curHdr && (!XSTRNCMP(curHdr->body, kAppPkcs7Mime,
|
|
XSTR_SIZEOF(kAppPkcs7Mime)) ||
|
|
!XSTRNCMP(curHdr->body, kAppXPkcs7Mime,
|
|
XSTR_SIZEOF(kAppXPkcs7Mime)))) {
|
|
sectionLen = wolfSSL_BIO_get_len(in);
|
|
if (sectionLen <= 0) {
|
|
goto error;
|
|
}
|
|
ret = wolfSSL_BIO_read(in, section, sectionLen);
|
|
if (ret < 0 || ret != sectionLen) {
|
|
WOLFSSL_MSG("Error reading input BIO.");
|
|
goto error;
|
|
}
|
|
}
|
|
else {
|
|
WOLFSSL_MSG("S/MIME headers not found.");
|
|
goto error;
|
|
}
|
|
|
|
curHdr = wc_MIME_find_header_name(kCTE, allHdrs);
|
|
if (curHdr == NULL) {
|
|
WOLFSSL_MSG("Content-Transfer-Encoding header not found, "
|
|
"assuming base64 encoding.");
|
|
}
|
|
else if (XSTRNCMP(curHdr->body, "base64", XSTRLEN("base64"))) {
|
|
WOLFSSL_MSG("S/MIME encodings other than base64 are not "
|
|
"currently supported.\n");
|
|
goto error;
|
|
}
|
|
|
|
if (section == NULL || sectionLen <= 0) {
|
|
goto error;
|
|
}
|
|
outLen = ((sectionLen*3+3)/4)+1;
|
|
out = (byte*)XMALLOC(outLen*sizeof(byte), NULL, DYNAMIC_TYPE_PKCS7);
|
|
outHead = out;
|
|
if (outHead == NULL) {
|
|
goto error;
|
|
}
|
|
/* Strip trailing newlines. */
|
|
while ((sectionLen > 0) &&
|
|
(section[sectionLen-1] == '\r' || section[sectionLen-1] == '\n')) {
|
|
sectionLen--;
|
|
}
|
|
section[sectionLen] = '\0';
|
|
ret = Base64_Decode((const byte*)section, sectionLen, out, &outLen);
|
|
if (ret < 0) {
|
|
WOLFSSL_MSG("Error base64 decoding S/MIME message.");
|
|
goto error;
|
|
}
|
|
pkcs7 = wolfSSL_d2i_PKCS7_only(NULL, (const unsigned char**)&out, outLen,
|
|
bcontMem, bcontMemSz);
|
|
|
|
wc_MIME_free_hdrs(allHdrs);
|
|
XFREE(outHead, NULL, DYNAMIC_TYPE_PKCS7);
|
|
XFREE(section, NULL, DYNAMIC_TYPE_PKCS7);
|
|
|
|
return pkcs7;
|
|
|
|
error:
|
|
wc_MIME_free_hdrs(allHdrs);
|
|
XFREE(boundary, NULL, DYNAMIC_TYPE_PKCS7);
|
|
XFREE(outHead, NULL, DYNAMIC_TYPE_PKCS7);
|
|
XFREE(section, NULL, DYNAMIC_TYPE_PKCS7);
|
|
if (canonSection != NULL)
|
|
XFREE(canonSection, NULL, DYNAMIC_TYPE_PKCS7);
|
|
if (canonLine != NULL)
|
|
XFREE(canonLine, NULL, DYNAMIC_TYPE_PKCS7);
|
|
if (bcont) {
|
|
wolfSSL_BIO_free(*bcont);
|
|
*bcont = NULL; /* reset 'bcount' pointer to NULL on failure */
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/* Convert hash algo OID (from Hash_Sum in asn.h) to SMIME string equivalent.
|
|
* Returns hash algorithm string or "unknown" if not found */
|
|
static const char* wolfSSL_SMIME_HashOIDToString(int hashOID)
|
|
{
|
|
switch (hashOID) {
|
|
case MD5h:
|
|
return "md5";
|
|
case SHAh:
|
|
return "sha1";
|
|
case SHA224h:
|
|
return "sha-224";
|
|
case SHA256h:
|
|
return "sha-256";
|
|
case SHA384h:
|
|
return "sha-384";
|
|
case SHA512h:
|
|
return "sha-512";
|
|
case SHA3_224h:
|
|
return "sha3-224";
|
|
case SHA3_384h:
|
|
return "sha3-384";
|
|
case SHA3_512h:
|
|
return "sha3-512";
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return "unknown";
|
|
}
|
|
|
|
/* Convert PKCS#7 type (from PKCS7_TYPES in pkcs7.h) to SMIME string.
|
|
* RFC2633 only defines signed-data, enveloped-data, certs-only.
|
|
* Returns string on success, NULL on unknown type. */
|
|
static const char* wolfSSL_SMIME_PKCS7TypeToString(int type)
|
|
{
|
|
switch (type) {
|
|
case SIGNED_DATA:
|
|
return "signed-data";
|
|
case ENVELOPED_DATA:
|
|
return "enveloped-data";
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/**
|
|
* Convert PKCS7 structure to SMIME format, adding necessary headers.
|
|
*
|
|
* Handles generation of PKCS7 bundle (ie: signedData). PKCS7 structure
|
|
* should be set up beforehand with PKCS7_sign/final/etc. Output is always
|
|
* Base64 encoded.
|
|
*
|
|
* out - output BIO for SMIME formatted data to be placed
|
|
* pkcs7 - input PKCS7 structure, initialized and set up
|
|
* in - input content to be encoded into PKCS7
|
|
* flags - flags to control behavior of PKCS7 generation
|
|
*
|
|
* Returns 1 on success, 0 or negative on failure
|
|
*/
|
|
int wolfSSL_SMIME_write_PKCS7(WOLFSSL_BIO* out, PKCS7* pkcs7, WOLFSSL_BIO* in,
|
|
int flags)
|
|
{
|
|
int i;
|
|
int ret = 1;
|
|
WOLFSSL_PKCS7* p7 = (WOLFSSL_PKCS7*)pkcs7;
|
|
byte* p7out = NULL;
|
|
int len = 0;
|
|
|
|
char boundary[33]; /* 32 chars + \0 */
|
|
byte* sigBase64 = NULL;
|
|
word32 sigBase64Len = 0;
|
|
const char* p7TypeString = NULL;
|
|
|
|
static const char alphanum[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
|
|
|
|
if (out == NULL || p7 == NULL) {
|
|
WOLFSSL_MSG("Bad function arguments");
|
|
return 0;
|
|
}
|
|
|
|
if (in != NULL && (p7->pkcs7.content == NULL || p7->pkcs7.contentSz == 0 ||
|
|
p7->pkcs7.contentCRLF == 0)) {
|
|
/* store and adjust content line endings for CRLF if needed */
|
|
if (wolfSSL_PKCS7_final((PKCS7*)p7, in, flags) != 1) {
|
|
ret = 0;
|
|
}
|
|
}
|
|
|
|
if (ret > 0) {
|
|
/* Generate signedData bundle, DER in output (dynamic) */
|
|
if ((len = wolfSSL_i2d_PKCS7((PKCS7*)p7, &p7out)) == WOLFSSL_FAILURE) {
|
|
WOLFSSL_MSG("Error in wolfSSL_i2d_PKCS7");
|
|
ret = 0;
|
|
}
|
|
}
|
|
|
|
/* Base64 encode signedData bundle */
|
|
if (ret > 0) {
|
|
if (Base64_Encode(p7out, len, NULL, &sigBase64Len) != LENGTH_ONLY_E) {
|
|
ret = 0;
|
|
}
|
|
else {
|
|
sigBase64 = (byte*)XMALLOC(sigBase64Len, NULL,
|
|
DYNAMIC_TYPE_TMP_BUFFER);
|
|
if (sigBase64 == NULL) {
|
|
ret = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (ret > 0) {
|
|
XMEMSET(sigBase64, 0, sigBase64Len);
|
|
if (Base64_Encode(p7out, len, sigBase64, &sigBase64Len) < 0) {
|
|
WOLFSSL_MSG("Error in Base64_Encode of signature");
|
|
ret = 0;
|
|
}
|
|
}
|
|
|
|
/* build up SMIME message */
|
|
if (ret > 0) {
|
|
if (flags & PKCS7_DETACHED) {
|
|
|
|
/* generate random boundary */
|
|
if (initGlobalRNG == 0 && wolfSSL_RAND_Init() != WOLFSSL_SUCCESS) {
|
|
WOLFSSL_MSG("No RNG to use");
|
|
ret = 0;
|
|
}
|
|
|
|
/* no need to generate random byte for null terminator (size-1) */
|
|
if ((ret > 0) && (wc_RNG_GenerateBlock(&globalRNG, (byte*)boundary,
|
|
sizeof(boundary) - 1 ) != 0)) {
|
|
WOLFSSL_MSG("Error in wc_RNG_GenerateBlock");
|
|
ret = 0;
|
|
}
|
|
|
|
if (ret > 0) {
|
|
for (i = 0; i < (int)sizeof(boundary) - 1; i++) {
|
|
boundary[i] =
|
|
alphanum[boundary[i] % XSTR_SIZEOF(alphanum)];
|
|
}
|
|
boundary[sizeof(boundary)-1] = 0;
|
|
}
|
|
|
|
if (ret > 0) {
|
|
/* S/MIME header beginning */
|
|
ret = wolfSSL_BIO_printf(out,
|
|
"MIME-Version: 1.0\n"
|
|
"Content-Type: multipart/signed; "
|
|
"protocol=\"application/x-pkcs7-signature\"; "
|
|
"micalg=\"%s\"; "
|
|
"boundary=\"----%s\"\n\n"
|
|
"This is an S/MIME signed message\n\n"
|
|
"------%s\n",
|
|
wolfSSL_SMIME_HashOIDToString(p7->pkcs7.hashOID),
|
|
boundary, boundary);
|
|
}
|
|
|
|
if (ret > 0) {
|
|
/* S/MIME content */
|
|
ret = wolfSSL_BIO_write(out,
|
|
p7->pkcs7.content, p7->pkcs7.contentSz);
|
|
}
|
|
|
|
if (ret > 0) {
|
|
/* S/SMIME header end boundary */
|
|
ret = wolfSSL_BIO_printf(out,
|
|
"\n------%s\n", boundary);
|
|
}
|
|
|
|
if (ret > 0) {
|
|
/* Signature and header */
|
|
ret = wolfSSL_BIO_printf(out,
|
|
"Content-Type: application/x-pkcs7-signature; "
|
|
"name=\"smime.p7s\"\n"
|
|
"Content-Transfer-Encoding: base64\n"
|
|
"Content-Disposition: attachment; "
|
|
"filename=\"smime.p7s\"\n\n"
|
|
"%.*s\n" /* Base64 encoded signature */
|
|
"------%s--\n\n",
|
|
sigBase64Len, sigBase64,
|
|
boundary);
|
|
}
|
|
}
|
|
else {
|
|
p7TypeString = wolfSSL_SMIME_PKCS7TypeToString(p7->type);
|
|
if (p7TypeString == NULL) {
|
|
WOLFSSL_MSG("Unsupported PKCS7 SMIME type");
|
|
ret = 0;
|
|
}
|
|
|
|
if (ret > 0) {
|
|
/* not detached */
|
|
ret = wolfSSL_BIO_printf(out,
|
|
"MIME-Version: 1.0\n"
|
|
"Content-Disposition: attachment; "
|
|
"filename=\"smime.p7m\"\n"
|
|
"Content-Type: application/x-pkcs7-mime; "
|
|
"smime-type=%s; name=\"smime.p7m\"\n"
|
|
"Content-Transfer-Encoding: base64\n\n"
|
|
"%.*s\n" /* signature */,
|
|
p7TypeString, sigBase64Len, sigBase64);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (p7out != NULL) {
|
|
XFREE(p7out, NULL, DYNAMIC_TYPE_TMP_BUFFER);
|
|
}
|
|
if (sigBase64 != NULL) {
|
|
XFREE(sigBase64, NULL, DYNAMIC_TYPE_TMP_BUFFER);
|
|
}
|
|
|
|
if (ret > 0) {
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
#endif /* HAVE_SMIME */
|
|
#endif /* !NO_BIO */
|
|
#endif /* OPENSSL_ALL */
|
|
|
|
#endif /* HAVE_PKCS7 */
|
|
/*******************************************************************************
|
|
* END OF PKCS7 APIs
|
|
******************************************************************************/
|
|
|
|
/*******************************************************************************
|
|
* START OF PKCS12 APIs
|
|
******************************************************************************/
|
|
#ifdef OPENSSL_EXTRA
|
|
|
|
/* no-op function. Was initially used for adding encryption algorithms available
|
|
* for PKCS12 */
|
|
void wolfSSL_PKCS12_PBE_add(void)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_PKCS12_PBE_add");
|
|
}
|
|
|
|
#if !defined(NO_FILESYSTEM)
|
|
WOLFSSL_X509_PKCS12 *wolfSSL_d2i_PKCS12_fp(XFILE fp,
|
|
WOLFSSL_X509_PKCS12 **pkcs12)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_d2i_PKCS12_fp");
|
|
return (WOLFSSL_X509_PKCS12 *)wolfSSL_d2i_X509_fp_ex(fp, (void **)pkcs12,
|
|
PKCS12_TYPE);
|
|
}
|
|
#endif /* !NO_FILESYSTEM */
|
|
|
|
#endif /* OPENSSL_EXTRA */
|
|
|
|
#if defined(HAVE_PKCS12)
|
|
|
|
#ifdef OPENSSL_EXTRA
|
|
|
|
#if !defined(NO_ASN) && !defined(NO_PWDBASED)
|
|
|
|
#ifndef NO_BIO
|
|
WC_PKCS12* wolfSSL_d2i_PKCS12_bio(WOLFSSL_BIO* bio, WC_PKCS12** pkcs12)
|
|
{
|
|
WC_PKCS12* localPkcs12 = NULL;
|
|
unsigned char* mem = NULL;
|
|
long memSz;
|
|
int ret = -1;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_d2i_PKCS12_bio");
|
|
|
|
if (bio == NULL) {
|
|
WOLFSSL_MSG("Bad Function Argument bio is NULL");
|
|
return NULL;
|
|
}
|
|
|
|
memSz = wolfSSL_BIO_get_len(bio);
|
|
if (memSz <= 0) {
|
|
return NULL;
|
|
}
|
|
mem = (unsigned char*)XMALLOC(memSz, bio->heap, DYNAMIC_TYPE_TMP_BUFFER);
|
|
if (mem == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
if (mem != NULL) {
|
|
localPkcs12 = wc_PKCS12_new();
|
|
if (localPkcs12 == NULL) {
|
|
WOLFSSL_MSG("Memory error");
|
|
}
|
|
}
|
|
|
|
if (mem != NULL && localPkcs12 != NULL) {
|
|
if (wolfSSL_BIO_read(bio, mem, (int)memSz) == memSz) {
|
|
ret = wc_d2i_PKCS12(mem, (word32)memSz, localPkcs12);
|
|
if (ret < 0) {
|
|
WOLFSSL_MSG("Failed to get PKCS12 sequence");
|
|
}
|
|
}
|
|
else {
|
|
WOLFSSL_MSG("Failed to get data from bio struct");
|
|
}
|
|
}
|
|
|
|
/* cleanup */
|
|
if (mem != NULL)
|
|
XFREE(mem, bio->heap, DYNAMIC_TYPE_TMP_BUFFER);
|
|
if (ret < 0 && localPkcs12 != NULL) {
|
|
wc_PKCS12_free(localPkcs12);
|
|
localPkcs12 = NULL;
|
|
}
|
|
if (pkcs12 != NULL)
|
|
*pkcs12 = localPkcs12;
|
|
|
|
return localPkcs12;
|
|
}
|
|
|
|
/* Converts the PKCS12 to DER format and outputs it into bio.
|
|
*
|
|
* bio is the structure to hold output DER
|
|
* pkcs12 structure to create DER from
|
|
*
|
|
* return 1 for success or 0 if an error occurs
|
|
*/
|
|
int wolfSSL_i2d_PKCS12_bio(WOLFSSL_BIO *bio, WC_PKCS12 *pkcs12)
|
|
{
|
|
int ret = WOLFSSL_FAILURE;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_i2d_PKCS12_bio");
|
|
|
|
if ((bio != NULL) && (pkcs12 != NULL)) {
|
|
word32 certSz = 0;
|
|
byte *certDer = NULL;
|
|
|
|
certSz = wc_i2d_PKCS12(pkcs12, &certDer, NULL);
|
|
if ((certSz > 0) && (certDer != NULL)) {
|
|
if (wolfSSL_BIO_write(bio, certDer, certSz) == (int)certSz) {
|
|
ret = WOLFSSL_SUCCESS;
|
|
}
|
|
}
|
|
|
|
if (certDer != NULL) {
|
|
XFREE(certDer, NULL, DYNAMIC_TYPE_PKCS);
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
#endif /* !NO_BIO */
|
|
|
|
/* Creates a new WC_PKCS12 structure
|
|
*
|
|
* pass password to use
|
|
* name friendlyName to use
|
|
* pkey private key to go into PKCS12 bundle
|
|
* cert certificate to go into PKCS12 bundle
|
|
* ca extra certificates that can be added to bundle. Can be NULL
|
|
* keyNID type of encryption to use on the key (-1 means no encryption)
|
|
* certNID type of encryption to use on the certificate
|
|
* itt number of iterations with encryption
|
|
* macItt number of iterations with mac creation
|
|
* keyType flag for signature and/or encryption key
|
|
*
|
|
* returns a pointer to a new WC_PKCS12 structure on success and NULL on fail
|
|
*/
|
|
WC_PKCS12* wolfSSL_PKCS12_create(char* pass, char* name, WOLFSSL_EVP_PKEY* pkey,
|
|
WOLFSSL_X509* cert, WOLF_STACK_OF(WOLFSSL_X509)* ca, int keyNID,
|
|
int certNID, int itt, int macItt, int keyType)
|
|
{
|
|
WC_PKCS12* pkcs12;
|
|
WC_DerCertList* list = NULL;
|
|
word32 passSz;
|
|
byte* keyDer = NULL;
|
|
word32 keyDerSz;
|
|
byte* certDer;
|
|
int certDerSz;
|
|
|
|
WOLFSSL_ENTER("wolfSSL_PKCS12_create");
|
|
|
|
if (pass == NULL || pkey == NULL || cert == NULL) {
|
|
WOLFSSL_LEAVE("wolfSSL_PKCS12_create", BAD_FUNC_ARG);
|
|
return NULL;
|
|
}
|
|
passSz = (word32)XSTRLEN(pass);
|
|
|
|
keyDer = (byte*)pkey->pkey.ptr;
|
|
keyDerSz = pkey->pkey_sz;
|
|
|
|
certDer = (byte*)wolfSSL_X509_get_der(cert, &certDerSz);
|
|
if (certDer == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
if (ca != NULL) {
|
|
unsigned long numCerts = ca->num;
|
|
WOLFSSL_STACK* sk = ca;
|
|
|
|
while (numCerts > 0 && sk != NULL) {
|
|
byte* curDer;
|
|
WC_DerCertList* cur;
|
|
int curDerSz = 0;
|
|
|
|
cur = (WC_DerCertList*)XMALLOC(sizeof(WC_DerCertList), NULL,
|
|
DYNAMIC_TYPE_PKCS);
|
|
if (cur == NULL) {
|
|
wc_FreeCertList(list, NULL);
|
|
return NULL;
|
|
}
|
|
|
|
curDer = (byte*)wolfSSL_X509_get_der(sk->data.x509, &curDerSz);
|
|
if (curDer == NULL || curDerSz < 0) {
|
|
XFREE(cur, NULL, DYNAMIC_TYPE_PKCS);
|
|
wc_FreeCertList(list, NULL);
|
|
return NULL;
|
|
}
|
|
|
|
cur->buffer = (byte*)XMALLOC(curDerSz, NULL, DYNAMIC_TYPE_PKCS);
|
|
if (cur->buffer == NULL) {
|
|
XFREE(cur, NULL, DYNAMIC_TYPE_PKCS);
|
|
wc_FreeCertList(list, NULL);
|
|
return NULL;
|
|
}
|
|
XMEMCPY(cur->buffer, curDer, curDerSz);
|
|
cur->bufferSz = curDerSz;
|
|
cur->next = list;
|
|
list = cur;
|
|
|
|
sk = sk->next;
|
|
numCerts--;
|
|
}
|
|
}
|
|
|
|
pkcs12 = wc_PKCS12_create(pass, passSz, name, keyDer, keyDerSz,
|
|
certDer, certDerSz, list, keyNID, certNID, itt, macItt,
|
|
keyType, NULL);
|
|
|
|
if (ca != NULL) {
|
|
wc_FreeCertList(list, NULL);
|
|
}
|
|
|
|
return pkcs12;
|
|
}
|
|
|
|
|
|
/* return WOLFSSL_SUCCESS on success, WOLFSSL_FAILURE on failure */
|
|
int wolfSSL_PKCS12_parse(WC_PKCS12* pkcs12, const char* psw,
|
|
WOLFSSL_EVP_PKEY** pkey, WOLFSSL_X509** cert,
|
|
WOLF_STACK_OF(WOLFSSL_X509)** ca)
|
|
{
|
|
void* heap = NULL;
|
|
int ret;
|
|
byte* certData = NULL;
|
|
word32 certDataSz;
|
|
byte* pk = NULL;
|
|
word32 pkSz;
|
|
WC_DerCertList* certList = NULL;
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
DecodedCert *DeCert;
|
|
#else
|
|
DecodedCert DeCert[1];
|
|
#endif
|
|
|
|
WOLFSSL_ENTER("wolfSSL_PKCS12_parse");
|
|
|
|
/* make sure we init return args */
|
|
if (pkey) *pkey = NULL;
|
|
if (cert) *cert = NULL;
|
|
if (ca) *ca = NULL;
|
|
|
|
if (pkcs12 == NULL || psw == NULL || pkey == NULL || cert == NULL) {
|
|
WOLFSSL_MSG("Bad argument value");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
heap = wc_PKCS12_GetHeap(pkcs12);
|
|
|
|
if (ca == NULL) {
|
|
ret = wc_PKCS12_parse(pkcs12, psw, &pk, &pkSz, &certData, &certDataSz,
|
|
NULL);
|
|
}
|
|
else {
|
|
ret = wc_PKCS12_parse(pkcs12, psw, &pk, &pkSz, &certData, &certDataSz,
|
|
&certList);
|
|
}
|
|
if (ret < 0) {
|
|
WOLFSSL_LEAVE("wolfSSL_PKCS12_parse", ret);
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
DeCert = (DecodedCert *)XMALLOC(sizeof(*DeCert), heap,
|
|
DYNAMIC_TYPE_DCERT);
|
|
if (DeCert == NULL) {
|
|
WOLFSSL_MSG("out of memory");
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
#endif
|
|
|
|
/* Decode cert and place in X509 stack struct */
|
|
if (certList != NULL) {
|
|
WC_DerCertList* current = certList;
|
|
|
|
*ca = (WOLF_STACK_OF(WOLFSSL_X509)*)XMALLOC(
|
|
sizeof(WOLF_STACK_OF(WOLFSSL_X509)), heap, DYNAMIC_TYPE_X509);
|
|
if (*ca == NULL) {
|
|
if (pk != NULL) {
|
|
XFREE(pk, heap, DYNAMIC_TYPE_PUBLIC_KEY);
|
|
}
|
|
if (certData != NULL) {
|
|
XFREE(certData, heap, DYNAMIC_TYPE_PKCS);
|
|
}
|
|
/* Free up WC_DerCertList and move on */
|
|
while (current != NULL) {
|
|
WC_DerCertList* next = current->next;
|
|
|
|
XFREE(current->buffer, heap, DYNAMIC_TYPE_PKCS);
|
|
XFREE(current, heap, DYNAMIC_TYPE_PKCS);
|
|
current = next;
|
|
}
|
|
ret = WOLFSSL_FAILURE;
|
|
goto out;
|
|
}
|
|
XMEMSET(*ca, 0, sizeof(WOLF_STACK_OF(WOLFSSL_X509)));
|
|
|
|
/* add list of DER certs as X509's to stack */
|
|
while (current != NULL) {
|
|
WC_DerCertList* toFree = current;
|
|
WOLFSSL_X509* x509;
|
|
|
|
x509 = (WOLFSSL_X509*)XMALLOC(sizeof(WOLFSSL_X509), heap,
|
|
DYNAMIC_TYPE_X509);
|
|
InitX509(x509, 1, heap);
|
|
InitDecodedCert(DeCert, current->buffer, current->bufferSz, heap);
|
|
if (ParseCertRelative(DeCert, CERT_TYPE, NO_VERIFY, NULL) != 0) {
|
|
WOLFSSL_MSG("Issue with parsing certificate");
|
|
FreeDecodedCert(DeCert);
|
|
wolfSSL_X509_free(x509);
|
|
}
|
|
else {
|
|
if (CopyDecodedToX509(x509, DeCert) != 0) {
|
|
WOLFSSL_MSG("Failed to copy decoded cert");
|
|
FreeDecodedCert(DeCert);
|
|
wolfSSL_X509_free(x509);
|
|
wolfSSL_sk_X509_pop_free(*ca, NULL); *ca = NULL;
|
|
if (pk != NULL) {
|
|
XFREE(pk, heap, DYNAMIC_TYPE_PUBLIC_KEY);
|
|
}
|
|
if (certData != NULL) {
|
|
XFREE(certData, heap, DYNAMIC_TYPE_PKCS);
|
|
}
|
|
/* Free up WC_DerCertList */
|
|
while (current != NULL) {
|
|
WC_DerCertList* next = current->next;
|
|
|
|
XFREE(current->buffer, heap, DYNAMIC_TYPE_PKCS);
|
|
XFREE(current, heap, DYNAMIC_TYPE_PKCS);
|
|
current = next;
|
|
}
|
|
ret = WOLFSSL_FAILURE;
|
|
goto out;
|
|
}
|
|
FreeDecodedCert(DeCert);
|
|
|
|
if (wolfSSL_sk_X509_push(*ca, x509) != 1) {
|
|
WOLFSSL_MSG("Failed to push x509 onto stack");
|
|
wolfSSL_X509_free(x509);
|
|
wolfSSL_sk_X509_pop_free(*ca, NULL); *ca = NULL;
|
|
if (pk != NULL) {
|
|
XFREE(pk, heap, DYNAMIC_TYPE_PUBLIC_KEY);
|
|
}
|
|
if (certData != NULL) {
|
|
XFREE(certData, heap, DYNAMIC_TYPE_PKCS);
|
|
}
|
|
|
|
/* Free up WC_DerCertList */
|
|
while (current != NULL) {
|
|
WC_DerCertList* next = current->next;
|
|
|
|
XFREE(current->buffer, heap, DYNAMIC_TYPE_PKCS);
|
|
XFREE(current, heap, DYNAMIC_TYPE_PKCS);
|
|
current = next;
|
|
}
|
|
ret = WOLFSSL_FAILURE;
|
|
goto out;
|
|
}
|
|
}
|
|
current = current->next;
|
|
XFREE(toFree->buffer, heap, DYNAMIC_TYPE_PKCS);
|
|
XFREE(toFree, heap, DYNAMIC_TYPE_PKCS);
|
|
}
|
|
}
|
|
|
|
|
|
/* Decode cert and place in X509 struct */
|
|
if (certData != NULL) {
|
|
*cert = (WOLFSSL_X509*)XMALLOC(sizeof(WOLFSSL_X509), heap,
|
|
DYNAMIC_TYPE_X509);
|
|
if (*cert == NULL) {
|
|
if (pk != NULL) {
|
|
XFREE(pk, heap, DYNAMIC_TYPE_PUBLIC_KEY);
|
|
}
|
|
if (ca != NULL) {
|
|
wolfSSL_sk_X509_pop_free(*ca, NULL); *ca = NULL;
|
|
}
|
|
XFREE(certData, heap, DYNAMIC_TYPE_PKCS);
|
|
ret = WOLFSSL_FAILURE;
|
|
goto out;
|
|
}
|
|
InitX509(*cert, 1, heap);
|
|
InitDecodedCert(DeCert, certData, certDataSz, heap);
|
|
if (ParseCertRelative(DeCert, CERT_TYPE, NO_VERIFY, NULL) != 0) {
|
|
WOLFSSL_MSG("Issue with parsing certificate");
|
|
}
|
|
if (CopyDecodedToX509(*cert, DeCert) != 0) {
|
|
WOLFSSL_MSG("Failed to copy decoded cert");
|
|
FreeDecodedCert(DeCert);
|
|
if (pk != NULL) {
|
|
XFREE(pk, heap, DYNAMIC_TYPE_PUBLIC_KEY);
|
|
}
|
|
if (ca != NULL) {
|
|
wolfSSL_sk_X509_pop_free(*ca, NULL); *ca = NULL;
|
|
}
|
|
wolfSSL_X509_free(*cert); *cert = NULL;
|
|
XFREE(certData, heap, DYNAMIC_TYPE_PKCS);
|
|
ret = WOLFSSL_FAILURE;
|
|
goto out;
|
|
}
|
|
FreeDecodedCert(DeCert);
|
|
XFREE(certData, heap, DYNAMIC_TYPE_PKCS);
|
|
}
|
|
|
|
|
|
/* get key type */
|
|
ret = BAD_STATE_E;
|
|
if (pk != NULL) { /* decode key if present */
|
|
*pkey = wolfSSL_EVP_PKEY_new_ex(heap);
|
|
if (*pkey == NULL) {
|
|
wolfSSL_X509_free(*cert); *cert = NULL;
|
|
if (ca != NULL) {
|
|
wolfSSL_sk_X509_pop_free(*ca, NULL); *ca = NULL;
|
|
}
|
|
XFREE(pk, heap, DYNAMIC_TYPE_PUBLIC_KEY);
|
|
ret = WOLFSSL_FAILURE;
|
|
goto out;
|
|
}
|
|
|
|
#ifndef NO_RSA
|
|
{
|
|
const unsigned char* pt = pk;
|
|
if (wolfSSL_d2i_PrivateKey(EVP_PKEY_RSA, pkey, &pt, pkSz) !=
|
|
NULL) {
|
|
ret = 0;
|
|
}
|
|
}
|
|
#endif /* NO_RSA */
|
|
|
|
#ifdef HAVE_ECC
|
|
if (ret != 0) { /* if is in fail state check if ECC key */
|
|
const unsigned char* pt = pk;
|
|
if (wolfSSL_d2i_PrivateKey(EVP_PKEY_EC, pkey, &pt, pkSz) !=
|
|
NULL) {
|
|
ret = 0;
|
|
}
|
|
}
|
|
#endif /* HAVE_ECC */
|
|
if (pk != NULL)
|
|
XFREE(pk, heap, DYNAMIC_TYPE_PKCS);
|
|
if (ret != 0) { /* if is in fail state and no PKEY then fail */
|
|
wolfSSL_X509_free(*cert); *cert = NULL;
|
|
if (ca != NULL) {
|
|
wolfSSL_sk_X509_pop_free(*ca, NULL); *ca = NULL;
|
|
}
|
|
wolfSSL_EVP_PKEY_free(*pkey); *pkey = NULL;
|
|
WOLFSSL_MSG("Bad PKCS12 key format");
|
|
ret = WOLFSSL_FAILURE;
|
|
goto out;
|
|
}
|
|
|
|
if (pkey != NULL && *pkey != NULL) {
|
|
(*pkey)->save_type = 0;
|
|
}
|
|
}
|
|
|
|
(void)ret;
|
|
(void)ca;
|
|
|
|
ret = WOLFSSL_SUCCESS;
|
|
|
|
out:
|
|
|
|
#ifdef WOLFSSL_SMALL_STACK
|
|
XFREE(DeCert, heap, DYNAMIC_TYPE_DCERT);
|
|
#endif
|
|
|
|
return ret;
|
|
}
|
|
|
|
int wolfSSL_PKCS12_verify_mac(WC_PKCS12 *pkcs12, const char *psw,
|
|
int pswLen)
|
|
{
|
|
WOLFSSL_ENTER("wolfSSL_PKCS12_verify_mac");
|
|
|
|
if (!pkcs12) {
|
|
return WOLFSSL_FAILURE;
|
|
}
|
|
|
|
return wc_PKCS12_verify_ex(pkcs12, (const byte*)psw, pswLen) == 0 ?
|
|
WOLFSSL_SUCCESS : WOLFSSL_FAILURE;
|
|
}
|
|
|
|
#endif /* !NO_ASN && !NO_PWDBASED */
|
|
|
|
#endif /* OPENSSL_EXTRA */
|
|
|
|
#endif /* HAVE_PKCS12 */
|
|
/*******************************************************************************
|
|
* END OF PKCS12 APIs
|
|
******************************************************************************/
|
|
|
|
#endif /* !NO_CERTS */
|
|
|
|
|
|
/*******************************************************************************
|
|
* BEGIN OPENSSL FIPS DRBG APIs
|
|
******************************************************************************/
|
|
#if defined(OPENSSL_EXTRA) && !defined(WC_NO_RNG) && defined(HAVE_HASHDRBG)
|
|
int wolfSSL_FIPS_drbg_init(WOLFSSL_DRBG_CTX *ctx, int type, unsigned int flags)
|
|
{
|
|
int ret = WOLFSSL_FAILURE;
|
|
if (ctx != NULL) {
|
|
XMEMSET(ctx, 0, sizeof(WOLFSSL_DRBG_CTX));
|
|
ctx->type = type;
|
|
ctx->xflags = flags;
|
|
ctx->status = DRBG_STATUS_UNINITIALISED;
|
|
ret = WOLFSSL_SUCCESS;
|
|
}
|
|
return ret;
|
|
}
|
|
WOLFSSL_DRBG_CTX* wolfSSL_FIPS_drbg_new(int type, unsigned int flags)
|
|
{
|
|
int ret = WOLFSSL_FAILURE;
|
|
WOLFSSL_DRBG_CTX* ctx = (WOLFSSL_DRBG_CTX*)XMALLOC(sizeof(WOLFSSL_DRBG_CTX),
|
|
NULL, DYNAMIC_TYPE_OPENSSL);
|
|
ret = wolfSSL_FIPS_drbg_init(ctx, type, flags);
|
|
if (ret == WOLFSSL_SUCCESS && type != 0) {
|
|
ret = wolfSSL_FIPS_drbg_instantiate(ctx, NULL, 0);
|
|
}
|
|
if (ret != WOLFSSL_SUCCESS) {
|
|
WOLFSSL_ERROR(ret);
|
|
wolfSSL_FIPS_drbg_free(ctx);
|
|
ctx = NULL;
|
|
}
|
|
return ctx;
|
|
}
|
|
int wolfSSL_FIPS_drbg_instantiate(WOLFSSL_DRBG_CTX* ctx,
|
|
const unsigned char* pers, size_t perslen)
|
|
{
|
|
int ret = WOLFSSL_FAILURE;
|
|
if (ctx != NULL && ctx->rng == NULL) {
|
|
#if !defined(HAVE_SELFTEST) && (!defined(HAVE_FIPS) || \
|
|
(defined(HAVE_FIPS) && FIPS_VERSION_GE(5,0)))
|
|
ctx->rng = wc_rng_new((byte*)pers, (word32)perslen, NULL);
|
|
#else
|
|
ctx->rng = (WC_RNG*)XMALLOC(sizeof(WC_RNG), NULL, DYNAMIC_TYPE_RNG);
|
|
if (ctx->rng != NULL) {
|
|
#if defined(HAVE_FIPS) && FIPS_VERSION_GE(2,0)
|
|
ret = wc_InitRngNonce(ctx->rng, (byte*)pers, (word32)perslen);
|
|
#else
|
|
ret = wc_InitRng(ctx->rng);
|
|
(void)pers;
|
|
(void)perslen;
|
|
#endif
|
|
if (ret != 0) {
|
|
WOLFSSL_ERROR(ret);
|
|
XFREE(ctx->rng, NULL, DYNAMIC_TYPE_RNG);
|
|
ctx->rng = NULL;
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
if (ctx != NULL && ctx->rng != NULL) {
|
|
ctx->status = DRBG_STATUS_READY;
|
|
ret = WOLFSSL_SUCCESS;
|
|
}
|
|
return ret;
|
|
}
|
|
int wolfSSL_FIPS_drbg_set_callbacks(WOLFSSL_DRBG_CTX* ctx,
|
|
drbg_entropy_get entropy_get, drbg_entropy_clean entropy_clean,
|
|
size_t entropy_blocklen,
|
|
drbg_nonce_get none_get, drbg_nonce_clean nonce_clean)
|
|
{
|
|
int ret = WOLFSSL_FAILURE;
|
|
if (ctx != NULL) {
|
|
ctx->entropy_get = entropy_get;
|
|
ctx->entropy_clean = entropy_clean;
|
|
ctx->entropy_blocklen = entropy_blocklen;
|
|
ctx->none_get = none_get;
|
|
ctx->nonce_clean = nonce_clean;
|
|
ret = WOLFSSL_SUCCESS;
|
|
}
|
|
return ret;
|
|
}
|
|
void wolfSSL_FIPS_rand_add(const void* buf, int num, double entropy)
|
|
{
|
|
/* not implemented */
|
|
(void)buf;
|
|
(void)num;
|
|
(void)entropy;
|
|
}
|
|
int wolfSSL_FIPS_drbg_reseed(WOLFSSL_DRBG_CTX* ctx, const unsigned char* adin,
|
|
size_t adinlen)
|
|
{
|
|
int ret = WOLFSSL_FAILURE;
|
|
if (ctx != NULL && ctx->rng != NULL) {
|
|
#if !defined(HAVE_SELFTEST) && (!defined(HAVE_FIPS) || \
|
|
(defined(HAVE_FIPS) && FIPS_VERSION_GE(2,0)))
|
|
if (wc_RNG_DRBG_Reseed(ctx->rng, adin, (word32)adinlen) == 0) {
|
|
ret = WOLFSSL_SUCCESS;
|
|
}
|
|
#else
|
|
ret = WOLFSSL_SUCCESS;
|
|
(void)adin;
|
|
(void)adinlen;
|
|
#endif
|
|
}
|
|
return ret;
|
|
}
|
|
int wolfSSL_FIPS_drbg_generate(WOLFSSL_DRBG_CTX* ctx, unsigned char* out,
|
|
size_t outlen, int prediction_resistance, const unsigned char* adin,
|
|
size_t adinlen)
|
|
{
|
|
int ret = WOLFSSL_FAILURE;
|
|
if (ctx != NULL && ctx->rng != NULL) {
|
|
ret = wc_RNG_GenerateBlock(ctx->rng, out, (word32)outlen);
|
|
if (ret == 0) {
|
|
ret = WOLFSSL_SUCCESS;
|
|
}
|
|
}
|
|
(void)prediction_resistance;
|
|
(void)adin;
|
|
(void)adinlen;
|
|
return ret;
|
|
}
|
|
int wolfSSL_FIPS_drbg_uninstantiate(WOLFSSL_DRBG_CTX *ctx)
|
|
{
|
|
if (ctx != NULL && ctx->rng != NULL) {
|
|
#if !defined(HAVE_SELFTEST) && (!defined(HAVE_FIPS) || \
|
|
(defined(HAVE_FIPS) && FIPS_VERSION_GE(5,0)))
|
|
wc_rng_free(ctx->rng);
|
|
#else
|
|
wc_FreeRng(ctx->rng);
|
|
XFREE(ctx->rng, NULL, DYNAMIC_TYPE_RNG);
|
|
#endif
|
|
ctx->rng = NULL;
|
|
ctx->status = DRBG_STATUS_UNINITIALISED;
|
|
}
|
|
return WOLFSSL_SUCCESS;
|
|
}
|
|
void wolfSSL_FIPS_drbg_free(WOLFSSL_DRBG_CTX *ctx)
|
|
{
|
|
if (ctx != NULL) {
|
|
/* As safety check if free'ing the default drbg, then mark global NULL.
|
|
* Technically the user should not call free on the default drbg. */
|
|
if (ctx == gDrbgDefCtx) {
|
|
gDrbgDefCtx = NULL;
|
|
}
|
|
wolfSSL_FIPS_drbg_uninstantiate(ctx);
|
|
XFREE(ctx, NULL, DYNAMIC_TYPE_OPENSSL);
|
|
}
|
|
}
|
|
WOLFSSL_DRBG_CTX* wolfSSL_FIPS_get_default_drbg(void)
|
|
{
|
|
if (gDrbgDefCtx == NULL) {
|
|
gDrbgDefCtx = wolfSSL_FIPS_drbg_new(0, 0);
|
|
}
|
|
return gDrbgDefCtx;
|
|
}
|
|
void wolfSSL_FIPS_get_timevec(unsigned char* buf, unsigned long* pctr)
|
|
{
|
|
/* not implemented */
|
|
(void)buf;
|
|
(void)pctr;
|
|
}
|
|
void* wolfSSL_FIPS_drbg_get_app_data(WOLFSSL_DRBG_CTX *ctx)
|
|
{
|
|
if (ctx != NULL) {
|
|
return ctx->app_data;
|
|
}
|
|
return NULL;
|
|
}
|
|
void wolfSSL_FIPS_drbg_set_app_data(WOLFSSL_DRBG_CTX *ctx, void *app_data)
|
|
{
|
|
if (ctx != NULL) {
|
|
ctx->app_data = app_data;
|
|
}
|
|
}
|
|
#endif
|
|
/*******************************************************************************
|
|
* END OF OPENSSL FIPS DRBG APIs
|
|
******************************************************************************/
|
|
|
|
|
|
#endif /* !WOLFCRYPT_ONLY */
|
|
|