mirrors/wolfssl
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Added new --disable-oldnames option to allow for using openssl along-side wolfssl headers (without OPENSSL_EXTRA). Add --enable-opensslcoexist which makes sure oldnames is disabled. Refactor of SSL_ to WOLF_SSL_. Refactor of SHA, MD5, SHA224, SHA256, SHA512 and SHA384 to WC_ naming.

Browse Source
This commit is contained in:
David Garske 2017-09-25 18:47:36 -07:00
parent 35141c335d
commit 6707be2b0e
54 changed files with 3606 additions and 3417 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

41
configure.ac
View File

@ -401,6 +401,21 @@ AC_ARG_ENABLE([haproxy],
)
# OpenSSL Coexist
AC_ARG_ENABLE([opensslcoexist],
[AS_HELP_STRING([--enable-opensslcoexist],[Enable coexistence of wolfssl/openssl (default: disabled)])],
[ ENABLED_OPENSSLCOEXIST=$enableval ],
[ ENABLED_OPENSSLCOEXIST=no ]
)
if test "x$ENABLED_OPENSSLCOEXIST" = "xyes"
then
# make sure old names are disabled
enable_oldnames=no
AM_CFLAGS="$AM_CFLAGS -DOPENSSL_COEXIST"
fi
# OPENSSL Extra Compatibility
AC_ARG_ENABLE([opensslextra],
[AS_HELP_STRING([--enable-opensslextra],[Enable extra OpenSSL API, size+ (default: disabled)])],
@ -412,7 +427,7 @@ then
ENABLED_OPENSSLEXTRA="yes"
fi
if test "$ENABLED_OPENSSLEXTRA" = "yes"
if test "$ENABLED_OPENSSLEXTRA" = "yes" && test "x$ENABLED_OPENSSLCOEXIST" = "xno"
then
AM_CFLAGS="-DOPENSSL_EXTRA $AM_CFLAGS"
fi
@ -2625,7 +2640,7 @@ then
AM_CFLAGS="$AM_CFLAGS -DECC_SHAMIR"
fi
fi
if test "x$ENABLED_OPENSSLEXTRA" = "xno"
if test "x$ENABLED_OPENSSLEXTRA" = "xno" && test "x$ENABLED_OPENSSLCOEXIST" = "xno"
then
ENABLED_OPENSSLEXTRA="yes"
AM_CFLAGS="-DOPENSSL_EXTRA $AM_CFLAGS"
@ -2723,7 +2738,7 @@ AC_ARG_ENABLE([lighty],
if test "$ENABLED_LIGHTY" = "yes"
then
# Requires opensslextra make sure on
if test "x$ENABLED_OPENSSLEXTRA" = "xno"
if test "x$ENABLED_OPENSSLEXTRA" = "xno" && test "x$ENABLED_OPENSSLCOEXIST" = "xno"
then
ENABLED_OPENSSLEXTRA="yes"
AM_CFLAGS="-DOPENSSL_EXTRA $AM_CFLAGS"
@ -2740,7 +2755,7 @@ if test "$ENABLED_HAPROXY" = "yes"
then
AM_CFLAGS="$AM_CFLAGS -DWOLFSSL_HAPROXY"
# Requires opensslextra make sure on
if test "x$ENABLED_OPENSSLEXTRA" = "xno"
if test "x$ENABLED_OPENSSLEXTRA" = "xno" && test "x$ENABLED_OPENSSLCOEXIST" = "xno"
then
ENABLED_OPENSSLEXTRA="yes"
AM_CFLAGS="-DOPENSSL_EXTRA $AM_CFLAGS"
@ -2769,7 +2784,7 @@ fi
if test "$ENABLED_STUNNEL" = "yes"
then
# Requires opensslextra make sure on
if test "x$ENABLED_OPENSSLEXTRA" = "xno"
if test "x$ENABLED_OPENSSLEXTRA" = "xno" && test "x$ENABLED_OPENSSLCOEXIST" = "xno"
then
ENABLED_OPENSSLEXTRA="yes"
AM_CFLAGS="-DOPENSSL_EXTRA $AM_CFLAGS"
@ -3474,6 +3489,20 @@ then
fi
# Old name support for backwards compatibility
AC_ARG_ENABLE([oldnames],
[AS_HELP_STRING([--enable-oldnames],[Keep backwards compat with old names (default: enabled)])],
[ ENABLED_OLDNAMES=$enableval ],
[ ENABLED_OLDNAMES=yes ]
)
if test "x$ENABLED_OLDNAMES" = "xno" && test "x$ENABLED_OPENSSLCOEXIST" = "xno"
then
AM_CFLAGS="$AM_CFLAGS -DNO_OLD_RNGNAME -DNO_OLD_WC_NAMES -DNO_OLD_SSL_NAMES"
fi
# check if PSK was enabled for conditionally running psk.test script
AM_CONDITIONAL([BUILD_PSK], [test "x$ENABLED_PSK" = "xyes"])
@ -3871,6 +3900,8 @@ echo " * Single threaded: $ENABLED_SINGLETHREADED"
echo " * Filesystem: $ENABLED_FILESYSTEM"
echo " * OpenSSH Build: $ENABLED_OPENSSH"
echo " * OpenSSL Extra API: $ENABLED_OPENSSLEXTRA"
echo " * OpenSSL Coexist: $ENABLED_OPENSSLCOEXIST"
echo " * Old Names: $ENABLED_OLDNAMES"
echo " * Max Strength Build: $ENABLED_MAXSTRENGTH"
echo " * Distro Build: $ENABLED_DISTRO"
echo " * fastmath: $ENABLED_FASTMATH"

158
examples/client/client.c
View File

@ -46,7 +46,7 @@
#include <wolfssl/test.h>
#include "examples/client/client.h"
#include <examples/client/client.h>
#ifndef NO_WOLFSSL_CLIENT
@ -106,14 +106,14 @@ static int NonBlockingSSL_Connect(WOLFSSL* ssl)
error = wolfSSL_get_error(ssl, 0);
sockfd = (SOCKET_T)wolfSSL_get_fd(ssl);
while (ret != SSL_SUCCESS && (error == SSL_ERROR_WANT_READ ||
error == SSL_ERROR_WANT_WRITE ||
while (ret != WOLF_SSL_SUCCESS && (error == WOLF_SSL_ERROR_WANT_READ ||
error == WOLF_SSL_ERROR_WANT_WRITE ||
error == WC_PENDING_E)) {
int currTimeout = 1;
if (error == SSL_ERROR_WANT_READ)
if (error == WOLF_SSL_ERROR_WANT_READ)
printf("... client would read block\n");
else if (error == SSL_ERROR_WANT_WRITE)
else if (error == WOLF_SSL_ERROR_WANT_WRITE)
printf("... client would write block\n");
#ifdef WOLFSSL_ASYNC_CRYPT
else if (error == WC_PENDING_E) {
@ -139,16 +139,16 @@ static int NonBlockingSSL_Connect(WOLFSSL* ssl)
error = wolfSSL_get_error(ssl, 0);
}
else if (select_ret == TEST_TIMEOUT && !wolfSSL_dtls(ssl)) {
error = SSL_ERROR_WANT_READ;
error = WOLF_SSL_ERROR_WANT_READ;
}
#ifdef WOLFSSL_DTLS
else if (select_ret == TEST_TIMEOUT && wolfSSL_dtls(ssl) &&
wolfSSL_dtls_got_timeout(ssl) >= 0) {
error = SSL_ERROR_WANT_READ;
error = WOLF_SSL_ERROR_WANT_READ;
}
#endif
else {
error = SSL_FATAL_ERROR;
error = WOLF_SSL_FATAL_ERROR;
}
}
@ -162,7 +162,7 @@ static void ShowCiphers(void)
int ret = wolfSSL_get_ciphers(ciphers, (int)sizeof(ciphers));
if (ret == SSL_SUCCESS)
if (ret == WOLF_SSL_SUCCESS)
printf("%s\n", ciphers);
}
@ -232,20 +232,20 @@ static int ClientBenchmarkConnections(WOLFSSL_CTX* ctx, char* host, word16 port,
#endif
if (useX25519) {
if (wolfSSL_UseKeyShare(ssl, WOLFSSL_ECC_X25519)
!= SSL_SUCCESS) {
!= WOLF_SSL_SUCCESS) {
err_sys("unable to use curve x25519");
}
}
#endif
#endif
if (wolfSSL_set_fd(ssl, sockfd) != SSL_SUCCESS) {
if (wolfSSL_set_fd(ssl, sockfd) != WOLF_SSL_SUCCESS) {
err_sys("error in setting fd");
}
do {
err = 0; /* reset error */
ret = wolfSSL_connect(ssl);
if (ret != SSL_SUCCESS) {
if (ret != WOLF_SSL_SUCCESS) {
err = wolfSSL_get_error(ssl, 0);
#ifdef WOLFSSL_ASYNC_CRYPT
if (err == WC_PENDING_E) {
@ -255,7 +255,7 @@ static int ClientBenchmarkConnections(WOLFSSL_CTX* ctx, char* host, word16 port,
#endif
}
} while (err == WC_PENDING_E);
if (ret != SSL_SUCCESS) {
if (ret != WOLF_SSL_SUCCESS) {
err_sys("SSL_connect failed");
}
@ -307,7 +307,7 @@ static int ClientBenchmarkThroughput(WOLFSSL_CTX* ctx, char* host, word16 port,
err_sys("unable to get SSL object");
tcp_connect(&sockfd, host, port, dtlsUDP, dtlsSCTP, ssl);
if (wolfSSL_set_fd(ssl, sockfd) != SSL_SUCCESS) {
if (wolfSSL_set_fd(ssl, sockfd) != WOLF_SSL_SUCCESS) {
err_sys("error in setting fd");
}
@ -316,7 +316,7 @@ static int ClientBenchmarkThroughput(WOLFSSL_CTX* ctx, char* host, word16 port,
#ifdef HAVE_CURVE25519
if (useX25519) {
if (wolfSSL_UseKeyShare(ssl, WOLFSSL_ECC_X25519)
!= SSL_SUCCESS) {
!= WOLF_SSL_SUCCESS) {
err_sys("unable to use curve x25519");
}
}
@ -326,7 +326,7 @@ static int ClientBenchmarkThroughput(WOLFSSL_CTX* ctx, char* host, word16 port,
do {
err = 0; /* reset error */
ret = wolfSSL_connect(ssl);
if (ret != SSL_SUCCESS) {
if (ret != WOLF_SSL_SUCCESS) {
err = wolfSSL_get_error(ssl, 0);
#ifdef WOLFSSL_ASYNC_CRYPT
if (err == WC_PENDING_E) {
@ -336,7 +336,7 @@ static int ClientBenchmarkThroughput(WOLFSSL_CTX* ctx, char* host, word16 port,
#endif
}
} while (err == WC_PENDING_E);
if (ret == SSL_SUCCESS) {
if (ret == WOLF_SSL_SUCCESS) {
/* Perform throughput test */
char *tx_buffer, *rx_buffer;
@ -411,7 +411,7 @@ static int ClientBenchmarkThroughput(WOLFSSL_CTX* ctx, char* host, word16 port,
}
else
#endif
if (err != SSL_ERROR_WANT_READ) {
if (err != WOLF_SSL_ERROR_WANT_READ) {
printf("SSL_read bench error %d\n", err);
err_sys("SSL_read failed");
}
@ -528,7 +528,7 @@ static int StartTLS_Init(SOCKET_T* sockfd)
err_sys("incorrect STARTTLS command received, expected 220");
}
return SSL_SUCCESS;
return WOLF_SSL_SUCCESS;
}
/* Closes down the SMTP connection */
@ -581,10 +581,10 @@ static int SMTP_Shutdown(WOLFSSL* ssl, int wc_shutdown)
printf("%s\n", tmpBuf);
ret = wolfSSL_shutdown(ssl);
if (wc_shutdown && ret == SSL_SHUTDOWN_NOT_DONE)
if (wc_shutdown && ret == WOLF_SSL_SHUTDOWN_NOT_DONE)
wolfSSL_shutdown(ssl); /* bidirectional shutdown */
return SSL_SUCCESS;
return WOLF_SSL_SUCCESS;
}
static void ClientWrite(WOLFSSL* ssl, char* msg, int msgSz)
@ -629,13 +629,13 @@ static void ClientRead(WOLFSSL* ssl, char* reply, int replyLen, int mustRead)
}
else
#endif
if (err != SSL_ERROR_WANT_READ) {
if (err != WOLF_SSL_ERROR_WANT_READ) {
printf("SSL_read reply error %d, %s\n", err,
wolfSSL_ERR_error_string(err, buffer));
err_sys("SSL_read failed");
}
}
} while (err == WC_PENDING_E || (mustRead && err == SSL_ERROR_WANT_READ));
} while (err == WC_PENDING_E || (mustRead && err == WOLF_SSL_ERROR_WANT_READ));
if (ret > 0) {
reply[ret] = 0;
printf("%s\n", reply);
@ -1411,14 +1411,14 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
err_sys("unable to get ctx");
#ifdef SINGLE_THREADED
if (wolfSSL_CTX_new_rng(ctx) != SSL_SUCCESS) {
if (wolfSSL_CTX_new_rng(ctx) != WOLF_SSL_SUCCESS) {
wolfSSL_CTX_free(ctx);
err_sys("Single Threaded new rng at CTX failed");
}
#endif
if (cipherList && !useDefCipherList) {
if (wolfSSL_CTX_set_cipher_list(ctx, cipherList) != SSL_SUCCESS) {
if (wolfSSL_CTX_set_cipher_list(ctx, cipherList) != WOLF_SSL_SUCCESS) {
wolfSSL_CTX_free(ctx);
err_sys("client can't set cipher list 1");
}
@ -1461,7 +1461,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
defaultCipherList = "PSK-AES128-CBC-SHA256";
#endif
if (wolfSSL_CTX_set_cipher_list(ctx,defaultCipherList)
!=SSL_SUCCESS) {
!=WOLF_SSL_SUCCESS) {
wolfSSL_CTX_free(ctx);
err_sys("client can't set cipher list 2");
}
@ -1477,7 +1477,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
if (cipherList == NULL || (cipherList && useDefCipherList)) {
wolfSSL_CTX_allow_anon_cipher(ctx);
if (wolfSSL_CTX_set_cipher_list(ctx,"ADH-AES128-SHA")
!= SSL_SUCCESS) {
!= WOLF_SSL_SUCCESS) {
wolfSSL_CTX_free(ctx);
err_sys("client can't set cipher list 4");
}
@ -1500,7 +1500,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
#if defined(WOLFSSL_SNIFFER)
if (cipherList == NULL) {
/* don't use EDH, can't sniff tmp keys */
if (wolfSSL_CTX_set_cipher_list(ctx, "AES128-SHA") != SSL_SUCCESS) {
if (wolfSSL_CTX_set_cipher_list(ctx, "AES128-SHA") != WOLF_SSL_SUCCESS) {
wolfSSL_CTX_free(ctx);
err_sys("client can't set cipher list 3");
}
@ -1531,14 +1531,14 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
if (useClientCert){
#if !defined(NO_FILESYSTEM)
if (wolfSSL_CTX_use_certificate_chain_file(ctx, ourCert)
!= SSL_SUCCESS) {
!= WOLF_SSL_SUCCESS) {
wolfSSL_CTX_free(ctx);
err_sys("can't load client cert file, check file and run from"
" wolfSSL home dir");
}
if (wolfSSL_CTX_use_PrivateKey_file(ctx, ourKey, SSL_FILETYPE_PEM)
!= SSL_SUCCESS) {
if (wolfSSL_CTX_use_PrivateKey_file(ctx, ourKey, WOLF_SSL_FILETYPE_PEM)
!= WOLF_SSL_SUCCESS) {
wolfSSL_CTX_free(ctx);
err_sys("can't load client private key file, check file and run "
"from wolfSSL home dir");
@ -1552,7 +1552,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
if (!usePsk && !useAnon && !useVerifyCb) {
#if !defined(NO_FILESYSTEM)
if (wolfSSL_CTX_load_verify_locations(ctx, verifyCert,0)
!= SSL_SUCCESS) {
!= WOLF_SSL_SUCCESS) {
wolfSSL_CTX_free(ctx);
err_sys("can't load ca file, Please run from wolfSSL home dir");
}
@ -1562,7 +1562,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
#ifdef HAVE_ECC
/* load ecc verify too, echoserver uses it by default w/ ecc */
#if !defined(NO_FILESYSTEM)
if (wolfSSL_CTX_load_verify_locations(ctx, eccCertFile, 0) != SSL_SUCCESS) {
if (wolfSSL_CTX_load_verify_locations(ctx, eccCertFile, 0) != WOLF_SSL_SUCCESS) {
wolfSSL_CTX_free(ctx);
err_sys("can't load ecc ca file, Please run from wolfSSL home dir");
}
@ -1573,7 +1573,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
#if defined(WOLFSSL_TRUST_PEER_CERT) && !defined(NO_FILESYSTEM)
if (trustCert) {
if ((ret = wolfSSL_CTX_trust_peer_cert(ctx, trustCert,
SSL_FILETYPE_PEM)) != SSL_SUCCESS) {
WOLF_SSL_FILETYPE_PEM)) != WOLF_SSL_SUCCESS) {
wolfSSL_CTX_free(ctx);
err_sys("can't load trusted peer cert file");
}
@ -1581,11 +1581,11 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
#endif /* WOLFSSL_TRUST_PEER_CERT && !NO_FILESYSTEM */
}
if (useVerifyCb)
wolfSSL_CTX_set_verify(ctx, SSL_VERIFY_PEER, myVerify);
wolfSSL_CTX_set_verify(ctx, WOLF_SSL_VERIFY_PEER, myVerify);
else if (!usePsk && !useAnon && doPeerCheck == 0)
wolfSSL_CTX_set_verify(ctx, SSL_VERIFY_NONE, 0);
wolfSSL_CTX_set_verify(ctx, WOLF_SSL_VERIFY_NONE, 0);
else if (!usePsk && !useAnon && overrideDateErrors == 1)
wolfSSL_CTX_set_verify(ctx, SSL_VERIFY_PEER, myDateCb);
wolfSSL_CTX_set_verify(ctx, WOLF_SSL_VERIFY_PEER, myDateCb);
#endif /* !defined(NO_CERTS) */
#ifdef WOLFSSL_ASYNC_CRYPT
@ -1599,34 +1599,34 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
#ifdef HAVE_SNI
if (sniHostName)
if (wolfSSL_CTX_UseSNI(ctx, 0, sniHostName, XSTRLEN(sniHostName))
!= SSL_SUCCESS) {
!= WOLF_SSL_SUCCESS) {
wolfSSL_CTX_free(ctx);
err_sys("UseSNI failed");
}
#endif
#ifdef HAVE_MAX_FRAGMENT
if (maxFragment)
if (wolfSSL_CTX_UseMaxFragment(ctx, maxFragment) != SSL_SUCCESS) {
if (wolfSSL_CTX_UseMaxFragment(ctx, maxFragment) != WOLF_SSL_SUCCESS) {
wolfSSL_CTX_free(ctx);
err_sys("UseMaxFragment failed");
}
#endif
#ifdef HAVE_TRUNCATED_HMAC
if (truncatedHMAC)
if (wolfSSL_CTX_UseTruncatedHMAC(ctx) != SSL_SUCCESS) {
if (wolfSSL_CTX_UseTruncatedHMAC(ctx) != WOLF_SSL_SUCCESS) {
wolfSSL_CTX_free(ctx);
err_sys("UseTruncatedHMAC failed");
}
#endif
#ifdef HAVE_SESSION_TICKET
if (wolfSSL_CTX_UseSessionTicket(ctx) != SSL_SUCCESS) {
if (wolfSSL_CTX_UseSessionTicket(ctx) != WOLF_SSL_SUCCESS) {
wolfSSL_CTX_free(ctx);
err_sys("UseSessionTicket failed");
}
#endif
#ifdef HAVE_EXTENDED_MASTER
if (disableExtMasterSecret)
if (wolfSSL_CTX_DisableExtendedMasterSecret(ctx) != SSL_SUCCESS) {
if (wolfSSL_CTX_DisableExtendedMasterSecret(ctx) != WOLF_SSL_SUCCESS) {
wolfSSL_CTX_free(ctx);
err_sys("DisableExtendedMasterSecret failed");
}
@ -1634,11 +1634,11 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
#if defined(HAVE_CURVE25519) && defined(HAVE_SUPPORTED_CURVES)
if (useX25519) {
if (wolfSSL_CTX_UseSupportedCurve(ctx, WOLFSSL_ECC_X25519)
!= SSL_SUCCESS) {
!= WOLF_SSL_SUCCESS) {
err_sys("unable to support X25519");
}
if (wolfSSL_CTX_UseSupportedCurve(ctx, WOLFSSL_ECC_SECP256R1)
!= SSL_SUCCESS) {
!= WOLF_SSL_SUCCESS) {
err_sys("unable to support secp256r1");
}
}
@ -1662,7 +1662,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
}
#if defined(WOLFSSL_MDK_ARM)
wolfSSL_CTX_set_verify(ctx, SSL_VERIFY_NONE, 0);
wolfSSL_CTX_set_verify(ctx, WOLF_SSL_VERIFY_NONE, 0);
#endif
#if defined(OPENSSL_EXTRA)
@ -1670,7 +1670,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
wolfSSL_CTX_free(ctx);
err_sys("bad read ahead default value");
}
if (wolfSSL_CTX_set_read_ahead(ctx, 1) != SSL_SUCCESS) {
if (wolfSSL_CTX_set_read_ahead(ctx, 1) != WOLF_SSL_SUCCESS) {
wolfSSL_CTX_free(ctx);
err_sys("error setting read ahead value");
}
@ -1688,7 +1688,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
if (doMcast) {
#ifdef WOLFSSL_MULTICAST
wolfSSL_CTX_mcast_set_member_id(ctx, mcastID);
if (wolfSSL_CTX_set_cipher_list(ctx, "WDM-NULL-SHA256") != SSL_SUCCESS) {
if (wolfSSL_CTX_set_cipher_list(ctx, "WDM-NULL-SHA256") != WOLF_SSL_SUCCESS) {
wolfSSL_CTX_free(ctx);
err_sys("Couldn't set multicast cipher list.");
}
@ -1711,7 +1711,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
#ifdef HAVE_CURVE25519
if (useX25519) {
if (wolfSSL_UseKeyShare(ssl, WOLFSSL_ECC_X25519)
!= SSL_SUCCESS) {
!= WOLF_SSL_SUCCESS) {
err_sys("unable to use curve x25519");
}
}
@ -1719,13 +1719,13 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
#ifdef HAVE_ECC
#if defined(HAVE_ECC256) || defined(HAVE_ALL_CURVES)
if (wolfSSL_UseKeyShare(ssl, WOLFSSL_ECC_SECP256R1)
!= SSL_SUCCESS) {
!= WOLF_SSL_SUCCESS) {
err_sys("unable to use curve secp256r1");
}
#endif
#if defined(HAVE_ECC384) || defined(HAVE_ALL_CURVES)
if (wolfSSL_UseKeyShare(ssl, WOLFSSL_ECC_SECP384R1)
!= SSL_SUCCESS) {
!= WOLF_SSL_SUCCESS) {
err_sys("unable to use curve secp384r1");
}
#endif
@ -1733,7 +1733,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
}
if (onlyKeyShare == 0 || onlyKeyShare == 1) {
#ifdef HAVE_FFDHE_2048
if (wolfSSL_UseKeyShare(ssl, WOLFSSL_FFDHE_2048) != SSL_SUCCESS) {
if (wolfSSL_UseKeyShare(ssl, WOLFSSL_FFDHE_2048) != WOLF_SSL_SUCCESS) {
err_sys("unable to use DH 2048-bit parameters");
}
#endif
@ -1756,7 +1756,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
XMEMSET(sr, 0x5A, sizeof(sr));
if (wolfSSL_set_secret(ssl, 1, pms, sizeof(pms), cr, sr, suite)
!= SSL_SUCCESS) {
!= WOLF_SSL_SUCCESS) {
wolfSSL_CTX_free(ctx);
err_sys("unable to set mcast secret");
}
@ -1778,7 +1778,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
switch (statusRequest) {
case WOLFSSL_CSR_OCSP:
if (wolfSSL_UseOCSPStapling(ssl, WOLFSSL_CSR_OCSP,
WOLFSSL_CSR_OCSP_USE_NONCE) != SSL_SUCCESS) {
WOLFSSL_CSR_OCSP_USE_NONCE) != WOLF_SSL_SUCCESS) {
wolfSSL_free(ssl);
wolfSSL_CTX_free(ctx);
err_sys("UseCertificateStatusRequest failed");
@ -1796,7 +1796,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
case WOLFSSL_CSR2_OCSP:
if (wolfSSL_UseOCSPStaplingV2(ssl,
WOLFSSL_CSR2_OCSP, WOLFSSL_CSR2_OCSP_USE_NONCE)
!= SSL_SUCCESS) {
!= WOLF_SSL_SUCCESS) {
wolfSSL_free(ssl);
wolfSSL_CTX_free(ctx);
err_sys("UseCertificateStatusRequest failed");
@ -1805,7 +1805,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
case WOLFSSL_CSR2_OCSP_MULTI:
if (wolfSSL_UseOCSPStaplingV2(ssl,
WOLFSSL_CSR2_OCSP_MULTI, 0)
!= SSL_SUCCESS) {
!= WOLF_SSL_SUCCESS) {
wolfSSL_free(ssl);
wolfSSL_CTX_free(ctx);
err_sys("UseCertificateStatusRequest failed");
@ -1819,7 +1819,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
#endif
tcp_connect(&sockfd, host, port, dtlsUDP, dtlsSCTP, ssl);
if (wolfSSL_set_fd(ssl, sockfd) != SSL_SUCCESS) {
if (wolfSSL_set_fd(ssl, sockfd) != WOLF_SSL_SUCCESS) {
wolfSSL_free(ssl);
wolfSSL_CTX_free(ctx);
err_sys("error in setting fd");
@ -1827,7 +1827,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
/* STARTTLS */
if (doSTARTTLS) {
if (StartTLS_Init(&sockfd) != SSL_SUCCESS) {
if (StartTLS_Init(&sockfd) != WOLF_SSL_SUCCESS) {
wolfSSL_free(ssl);
wolfSSL_CTX_free(ctx);
err_sys("error during STARTTLS protocol");
@ -1840,18 +1840,18 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
wolfIO_SetTimeout(DEFAULT_TIMEOUT_SEC);
#endif
if (wolfSSL_EnableCRL(ssl, WOLFSSL_CRL_CHECKALL) != SSL_SUCCESS) {
if (wolfSSL_EnableCRL(ssl, WOLFSSL_CRL_CHECKALL) != WOLF_SSL_SUCCESS) {
wolfSSL_free(ssl);
wolfSSL_CTX_free(ctx);
err_sys("can't enable crl check");
}
if (wolfSSL_LoadCRL(ssl, crlPemDir, SSL_FILETYPE_PEM, 0)
!= SSL_SUCCESS) {
if (wolfSSL_LoadCRL(ssl, crlPemDir, WOLF_SSL_FILETYPE_PEM, 0)
!= WOLF_SSL_SUCCESS) {
wolfSSL_free(ssl);
wolfSSL_CTX_free(ctx);
err_sys("can't load crl, check crlfile and date validity");
}
if (wolfSSL_SetCRL_Cb(ssl, CRL_CallBack) != SSL_SUCCESS) {
if (wolfSSL_SetCRL_Cb(ssl, CRL_CallBack) != WOLF_SSL_SUCCESS) {
wolfSSL_free(ssl);
wolfSSL_CTX_free(ctx);
err_sys("can't set crl callback");
@ -1860,7 +1860,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
#endif
#ifdef HAVE_SECURE_RENEGOTIATION
if (scr) {
if (wolfSSL_UseSecureRenegotiation(ssl) != SSL_SUCCESS) {
if (wolfSSL_UseSecureRenegotiation(ssl) != WOLF_SSL_SUCCESS) {
wolfSSL_free(ssl);
wolfSSL_CTX_free(ctx);
err_sys("can't enable secure renegotiation");
@ -1887,7 +1887,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
do {
err = 0; /* reset error */
ret = wolfSSL_connect(ssl);
if (ret != SSL_SUCCESS) {
if (ret != WOLF_SSL_SUCCESS) {
err = wolfSSL_get_error(ssl, 0);
#ifdef WOLFSSL_ASYNC_CRYPT
if (err == WC_PENDING_E) {
@ -1903,7 +1903,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
timeout.tv_usec = 0;
ret = NonBlockingSSL_Connect(ssl); /* will keep retrying on timeout */
#endif
if (ret != SSL_SUCCESS) {
if (ret != WOLF_SSL_SUCCESS) {
printf("wolfSSL_connect error %d, %s\n", err,
wolfSSL_ERR_error_string(err, buffer));
wolfSSL_free(ssl);
@ -1953,7 +1953,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
if (doSTARTTLS) {
if (XSTRNCMP(starttlsProt, "smtp", 4) == 0) {
if (SMTP_Shutdown(ssl, wc_shutdown) != SSL_SUCCESS) {
if (SMTP_Shutdown(ssl, wc_shutdown) != WOLF_SSL_SUCCESS) {
wolfSSL_free(ssl);
wolfSSL_CTX_free(ctx);
err_sys("error closing STARTTLS connection");
@ -1975,7 +1975,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
word16 protocol_nameSz = 0;
err = wolfSSL_ALPN_GetProtocol(ssl, &protocol_name, &protocol_nameSz);
if (err == SSL_SUCCESS)
if (err == WOLF_SSL_SUCCESS)
printf("Received ALPN protocol : %s (%d)\n",
protocol_name, protocol_nameSz);
else if (err == SSL_ALPN_NOT_FOUND)
@ -1991,7 +1991,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
printf("not doing secure renegotiation on example with"
" nonblocking yet");
} else {
if (wolfSSL_Rehandshake(ssl) != SSL_SUCCESS) {
if (wolfSSL_Rehandshake(ssl) != WOLF_SSL_SUCCESS) {
err = wolfSSL_get_error(ssl, 0);
printf("err = %d, %s\n", err,
wolfSSL_ERR_error_string(err, buffer));
@ -2056,7 +2056,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
if (dtlsUDP == 0) { /* don't send alert after "break" command */
ret = wolfSSL_shutdown(ssl);
if (wc_shutdown && ret == SSL_SHUTDOWN_NOT_DONE)
if (wc_shutdown && ret == WOLF_SSL_SHUTDOWN_NOT_DONE)
wolfSSL_shutdown(ssl); /* bidirectional shutdown */
}
#ifdef ATOMIC_USER
@ -2078,7 +2078,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
#endif
}
tcp_connect(&sockfd, host, port, dtlsUDP, dtlsSCTP, sslResume);
if (wolfSSL_set_fd(sslResume, sockfd) != SSL_SUCCESS) {
if (wolfSSL_set_fd(sslResume, sockfd) != WOLF_SSL_SUCCESS) {
wolfSSL_free(sslResume);
wolfSSL_CTX_free(ctx);
err_sys("error in setting fd");
@ -2092,7 +2092,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
#endif
#ifdef HAVE_SECURE_RENEGOTIATION
if (scr) {
if (wolfSSL_UseSecureRenegotiation(sslResume) != SSL_SUCCESS) {
if (wolfSSL_UseSecureRenegotiation(sslResume) != WOLF_SSL_SUCCESS) {
wolfSSL_free(sslResume);
wolfSSL_CTX_free(ctx);
err_sys("can't enable secure renegotiation");
@ -2108,23 +2108,23 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
#ifdef WOLFSSL_TLS13
#ifdef HAVE_CURVE25519
if (useX25519) {
if (wolfSSL_UseKeyShare(ssl, WOLFSSL_ECC_X25519) != SSL_SUCCESS) {
if (wolfSSL_UseKeyShare(ssl, WOLFSSL_ECC_X25519) != WOLF_SSL_SUCCESS) {
err_sys("unable to use curve x25519");
}
}
#endif
#ifdef HAVE_ECC
if (wolfSSL_UseKeyShare(sslResume,
WOLFSSL_ECC_SECP256R1) != SSL_SUCCESS) {
WOLFSSL_ECC_SECP256R1) != WOLF_SSL_SUCCESS) {
err_sys("unable to use curve secp256r1");
}
if (wolfSSL_UseKeyShare(sslResume,
WOLFSSL_ECC_SECP384R1) != SSL_SUCCESS) {
WOLFSSL_ECC_SECP384R1) != WOLF_SSL_SUCCESS) {
err_sys("unable to use curve secp384r1");
}
#endif
#ifdef HAVE_FFDHE_2048
if (wolfSSL_UseKeyShare(sslResume, WOLFSSL_FFDHE_2048) != SSL_SUCCESS) {
if (wolfSSL_UseKeyShare(sslResume, WOLFSSL_FFDHE_2048) != WOLF_SSL_SUCCESS) {
err_sys("unable to use DH 2048-bit parameters");
}
#endif
@ -2193,7 +2193,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
do {
err = 0; /* reset error */
ret = wolfSSL_connect(sslResume);
if (ret != SSL_SUCCESS) {
if (ret != WOLF_SSL_SUCCESS) {
err = wolfSSL_get_error(sslResume, 0);
#ifdef WOLFSSL_ASYNC_CRYPT
if (err == WC_PENDING_E) {
@ -2210,7 +2210,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
timeout.tv_usec = 0;
ret = NonBlockingSSL_Connect(ssl); /* will keep retrying on timeout */
#endif
if (ret != SSL_SUCCESS) {
if (ret != WOLF_SSL_SUCCESS) {
printf("wolfSSL_connect resume error %d, %s\n", err,
wolfSSL_ERR_error_string(err, buffer));
wolfSSL_free(sslResume);
@ -2233,7 +2233,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
printf("Sending ALPN accepted list : %s\n", alpnList);
err = wolfSSL_ALPN_GetProtocol(sslResume, &protocol_name,
&protocol_nameSz);
if (err == SSL_SUCCESS)
if (err == WOLF_SSL_SUCCESS)
printf("Received ALPN protocol : %s (%d)\n",
protocol_name, protocol_nameSz);
else if (err == SSL_ALPN_NOT_FOUND)
@ -2329,7 +2329,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
}
}
if (ret < 0) {
if (err != SSL_ERROR_WANT_READ) {
if (err != WOLF_SSL_ERROR_WANT_READ) {
printf("SSL_read resume error %d, %s\n", err,
wolfSSL_ERR_error_string(err, buffer));
wolfSSL_free(sslResume);
@ -2354,7 +2354,7 @@ THREAD_RETURN WOLFSSL_THREAD client_test(void* args)
} while (err == WC_PENDING_E);
ret = wolfSSL_shutdown(sslResume);
if (wc_shutdown && ret == SSL_SHUTDOWN_NOT_DONE)
if (wc_shutdown && ret == WOLF_SSL_SHUTDOWN_NOT_DONE)
wolfSSL_shutdown(sslResume); /* bidirectional shutdown */
wolfSSL_free(sslResume);

14
examples/echoclient/echoclient.c
View File

@ -52,7 +52,7 @@
#include <cyassl/test.h>
#include "examples/echoclient/echoclient.h"
#include <examples/echoclient/echoclient.h>
#ifndef NO_WOLFSSL_CLIENT
@ -135,11 +135,11 @@ void echoclient_test(void* args)
#ifndef NO_FILESYSTEM
#ifndef NO_RSA
if (SSL_CTX_load_verify_locations(ctx, caCertFile, 0) != SSL_SUCCESS)
if (SSL_CTX_load_verify_locations(ctx, caCertFile, 0) != WOLF_SSL_SUCCESS)
err_sys("can't load ca file, Please run from wolfSSL home dir");
#endif
#ifdef HAVE_ECC
if (SSL_CTX_load_verify_locations(ctx, eccCertFile, 0) != SSL_SUCCESS)
if (SSL_CTX_load_verify_locations(ctx, eccCertFile, 0) != WOLF_SSL_SUCCESS)
err_sys("can't load ca file, Please run from wolfSSL home dir");
#endif
#elif !defined(NO_CERTS)
@ -163,7 +163,7 @@ void echoclient_test(void* args)
#else
defaultCipherList = "PSK-AES128-CBC-SHA256";
#endif
if (CyaSSL_CTX_set_cipher_list(ctx,defaultCipherList) !=SSL_SUCCESS)
if (CyaSSL_CTX_set_cipher_list(ctx,defaultCipherList) !=WOLF_SSL_SUCCESS)
err_sys("client can't set cipher list 2");
#endif
}
@ -173,7 +173,7 @@ void echoclient_test(void* args)
#endif
#if defined(WOLFSSL_MDK_ARM)
CyaSSL_CTX_set_verify(ctx, SSL_VERIFY_NONE, 0);
CyaSSL_CTX_set_verify(ctx, WOLF_SSL_VERIFY_NONE, 0);
#endif
#ifdef WOLFSSL_ASYNC_CRYPT
@ -196,7 +196,7 @@ void echoclient_test(void* args)
do {
err = 0; /* Reset error */
ret = SSL_connect(ssl);
if (ret != SSL_SUCCESS) {
if (ret != WOLF_SSL_SUCCESS) {
err = SSL_get_error(ssl, 0);
#ifdef WOLFSSL_ASYNC_CRYPT
if (err == WC_PENDING_E) {
@ -206,7 +206,7 @@ void echoclient_test(void* args)
#endif
}
} while (err == WC_PENDING_E);
if (ret != SSL_SUCCESS) {
if (ret != WOLF_SSL_SUCCESS) {
printf("SSL_connect error %d, %s\n", err,
ERR_error_string(err, buffer));
err_sys("SSL_connect failed");

34
examples/echoserver/echoserver.c
View File

@ -151,7 +151,7 @@ THREAD_RETURN CYASSL_THREAD echoserver_test(void* args)
#error "no valid server method built in"
#endif
ctx = CyaSSL_CTX_new(method);
/* CyaSSL_CTX_set_session_cache_mode(ctx, SSL_SESS_CACHE_OFF); */
/* CyaSSL_CTX_set_session_cache_mode(ctx, WOLF_SSL_SESS_CACHE_OFF); */
#if defined(OPENSSL_EXTRA) || defined(HAVE_WEBSERVER)
CyaSSL_CTX_set_default_passwd_cb(ctx, PasswordCallBack);
@ -168,37 +168,37 @@ THREAD_RETURN CYASSL_THREAD echoserver_test(void* args)
if (doPSK == 0) {
#if defined(HAVE_NTRU) && defined(WOLFSSL_STATIC_RSA)
/* ntru */
if (CyaSSL_CTX_use_certificate_file(ctx, ntruCertFile, SSL_FILETYPE_PEM)
!= SSL_SUCCESS)
if (CyaSSL_CTX_use_certificate_file(ctx, ntruCertFile, WOLF_SSL_FILETYPE_PEM)
!= WOLF_SSL_SUCCESS)
err_sys("can't load ntru cert file, "
"Please run from wolfSSL home dir");
if (CyaSSL_CTX_use_NTRUPrivateKey_file(ctx, ntruKeyFile)
!= SSL_SUCCESS)
!= WOLF_SSL_SUCCESS)
err_sys("can't load ntru key file, "
"Please run from wolfSSL home dir");
#elif defined(HAVE_ECC) && !defined(CYASSL_SNIFFER)
/* ecc */
if (CyaSSL_CTX_use_certificate_file(ctx, eccCertFile, SSL_FILETYPE_PEM)
!= SSL_SUCCESS)
if (CyaSSL_CTX_use_certificate_file(ctx, eccCertFile, WOLF_SSL_FILETYPE_PEM)
!= WOLF_SSL_SUCCESS)
err_sys("can't load server cert file, "
"Please run from wolfSSL home dir");
if (CyaSSL_CTX_use_PrivateKey_file(ctx, eccKeyFile, SSL_FILETYPE_PEM)
!= SSL_SUCCESS)
if (CyaSSL_CTX_use_PrivateKey_file(ctx, eccKeyFile, WOLF_SSL_FILETYPE_PEM)
!= WOLF_SSL_SUCCESS)
err_sys("can't load server key file, "
"Please run from wolfSSL home dir");
#elif defined(NO_CERTS)
/* do nothing, just don't load cert files */
#else
/* normal */
if (CyaSSL_CTX_use_certificate_file(ctx, svrCertFile, SSL_FILETYPE_PEM)
!= SSL_SUCCESS)
if (CyaSSL_CTX_use_certificate_file(ctx, svrCertFile, WOLF_SSL_FILETYPE_PEM)
!= WOLF_SSL_SUCCESS)
err_sys("can't load server cert file, "
"Please run from wolfSSL home dir");
if (CyaSSL_CTX_use_PrivateKey_file(ctx, svrKeyFile, SSL_FILETYPE_PEM)
!= SSL_SUCCESS)
if (CyaSSL_CTX_use_PrivateKey_file(ctx, svrKeyFile, WOLF_SSL_FILETYPE_PEM)
!= WOLF_SSL_SUCCESS)
err_sys("can't load server key file, "
"Please run from wolfSSL home dir");
#endif
@ -228,7 +228,7 @@ THREAD_RETURN CYASSL_THREAD echoserver_test(void* args)
#else
defaultCipherList = "PSK-AES128-CBC-SHA256";
#endif
if (CyaSSL_CTX_set_cipher_list(ctx, defaultCipherList) != SSL_SUCCESS)
if (CyaSSL_CTX_set_cipher_list(ctx, defaultCipherList) != WOLF_SSL_SUCCESS)
err_sys("server can't set cipher list 2");
#endif
}
@ -280,7 +280,7 @@ THREAD_RETURN CYASSL_THREAD echoserver_test(void* args)
wolfSSL_dtls_set_peer(ssl, &client, client_len);
#endif
#if !defined(NO_FILESYSTEM) && !defined(NO_DH) && !defined(NO_ASN)
CyaSSL_SetTmpDH_file(ssl, dhParamFile, SSL_FILETYPE_PEM);
CyaSSL_SetTmpDH_file(ssl, dhParamFile, WOLF_SSL_FILETYPE_PEM);
#elif !defined(NO_DH)
SetDH(ssl); /* will repick suites with DHE, higher than PSK */
#endif
@ -288,7 +288,7 @@ THREAD_RETURN CYASSL_THREAD echoserver_test(void* args)
do {
err = 0; /* Reset error */
ret = CyaSSL_accept(ssl);
if (ret != SSL_SUCCESS) {
if (ret != WOLF_SSL_SUCCESS) {
err = CyaSSL_get_error(ssl, 0);
#ifdef WOLFSSL_ASYNC_CRYPT
if (err == WC_PENDING_E) {
@ -298,7 +298,7 @@ THREAD_RETURN CYASSL_THREAD echoserver_test(void* args)
#endif
}
} while (err == WC_PENDING_E);
if (ret != SSL_SUCCESS) {
if (ret != WOLF_SSL_SUCCESS) {
printf("SSL_accept error = %d, %s\n", err,
CyaSSL_ERR_error_string(err, buffer));
printf("SSL_accept failed\n");
@ -337,7 +337,7 @@ THREAD_RETURN CYASSL_THREAD echoserver_test(void* args)
}
} while (err == WC_PENDING_E);
if (ret <= 0) {
if (err != SSL_ERROR_WANT_READ && err != SSL_ERROR_ZERO_RETURN){
if (err != WOLF_SSL_ERROR_WANT_READ && err != WOLF_SSL_ERROR_ZERO_RETURN){
printf("SSL_read echo error %d, %s!\n", err,
CyaSSL_ERR_error_string(err, buffer));
}

8
examples/sctp/sctp-client-dtls.c
View File

@ -71,11 +71,11 @@ int main()
err_sys("ctx new dtls client failed");
ret = wolfSSL_CTX_dtls_set_sctp(ctx);
if (ret != SSL_SUCCESS)
if (ret != WOLF_SSL_SUCCESS)
err_sys("set sctp mode failed");
ret = wolfSSL_CTX_load_verify_locations(ctx, cacert, NULL);
if (ret != SSL_SUCCESS)
if (ret != WOLF_SSL_SUCCESS)
err_sys("ca cert error");
WOLFSSL* ssl = wolfSSL_new(ctx);
@ -85,12 +85,12 @@ int main()
wolfSSL_set_fd(ssl, sd);
ret = wolfSSL_connect(ssl);
if (ret != SSL_SUCCESS)
if (ret != WOLF_SSL_SUCCESS)
err_sys("ssl connect failed");
printf("TLS version is %s\n", wolfSSL_get_version(ssl));
printf("Cipher Suite is %s\n",
wolfSSL_CIPHER_get_name(wolfSSL_get_current_cipher(ssl)));
wolfSSL_CIPHER_get_name(wolfSSL_get_current_cipher(ssl)));
wolfSSL_write(ssl, response, (int)strlen(response));
int got = wolfSSL_read(ssl, buffer, sizeof(buffer));

14
examples/sctp/sctp-server-dtls.c
View File

@ -77,15 +77,15 @@ int main()
err_sys("ctx new dtls server failed");
ret = wolfSSL_CTX_dtls_set_sctp(ctx);
if (ret != SSL_SUCCESS)
if (ret != WOLF_SSL_SUCCESS)
err_sys("set sctp mode failed");
ret = wolfSSL_CTX_use_PrivateKey_file(ctx, key, SSL_FILETYPE_PEM);
if (ret != SSL_SUCCESS)
ret = wolfSSL_CTX_use_PrivateKey_file(ctx, key, WOLF_SSL_FILETYPE_PEM);
if (ret != WOLF_SSL_SUCCESS)
err_sys("use private key error");
ret = wolfSSL_CTX_use_certificate_file(ctx, cert, SSL_FILETYPE_PEM);
if (ret != SSL_SUCCESS)
ret = wolfSSL_CTX_use_certificate_file(ctx, cert, WOLF_SSL_FILETYPE_PEM);
if (ret != WOLF_SSL_SUCCESS)
err_sys("use cert error");
WOLFSSL* ssl = wolfSSL_new(ctx);
@ -95,12 +95,12 @@ int main()
wolfSSL_set_fd(ssl, client_sd);
ret = wolfSSL_accept(ssl);
if (ret != SSL_SUCCESS)
if (ret != WOLF_SSL_SUCCESS)
err_sys("ssl accept failed");
printf("TLS version is %s\n", wolfSSL_get_version(ssl));
printf("Cipher Suite is %s\n",
wolfSSL_CIPHER_get_name(wolfSSL_get_current_cipher(ssl)));
wolfSSL_CIPHER_get_name(wolfSSL_get_current_cipher(ssl)));
int got = wolfSSL_read(ssl, buffer, sizeof(buffer));
if (got > 0) {

108
examples/server/server.c
View File

@ -132,15 +132,15 @@ static int NonBlockingSSL_Accept(SSL* ssl)
SOCKET_T sockfd = (SOCKET_T)CyaSSL_get_fd(ssl);
int select_ret = 0;
while (ret != SSL_SUCCESS && (error == SSL_ERROR_WANT_READ ||
error == SSL_ERROR_WANT_WRITE ||
while (ret != WOLF_SSL_SUCCESS && (error == WOLF_SSL_ERROR_WANT_READ ||
error == WOLF_SSL_ERROR_WANT_WRITE ||
error == WC_PENDING_E)) {
int currTimeout = 1;
if (error == SSL_ERROR_WANT_READ) {
if (error == WOLF_SSL_ERROR_WANT_READ) {
/* printf("... server would read block\n"); */
}
else if (error == SSL_ERROR_WANT_WRITE) {
else if (error == WOLF_SSL_ERROR_WANT_WRITE) {
/* printf("... server would write block\n"); */
}
#ifdef WOLFSSL_ASYNC_CRYPT
@ -168,16 +168,16 @@ static int NonBlockingSSL_Accept(SSL* ssl)
error = SSL_get_error(ssl, 0);
}
else if (select_ret == TEST_TIMEOUT && !CyaSSL_dtls(ssl)) {
error = SSL_ERROR_WANT_READ;
error = WOLF_SSL_ERROR_WANT_READ;
}
#ifdef CYASSL_DTLS
else if (select_ret == TEST_TIMEOUT && CyaSSL_dtls(ssl) &&
CyaSSL_dtls_got_timeout(ssl) >= 0) {
error = SSL_ERROR_WANT_READ;
error = WOLF_SSL_ERROR_WANT_READ;
}
#endif
else {
error = SSL_FATAL_ERROR;
error = WOLF_SSL_FATAL_ERROR;
}
}
@ -222,8 +222,8 @@ int ServerEchoData(SSL* ssl, int clientfd, int echoData, int throughput)
}
else
#endif
if (err != SSL_ERROR_WANT_READ &&
err != SSL_ERROR_ZERO_RETURN) {
if (err != WOLF_SSL_ERROR_WANT_READ &&
err != WOLF_SSL_ERROR_ZERO_RETURN) {
printf("SSL_read echo error %d\n", err);
err_sys_ex(runWithErrors, "SSL_read failed");
}
@ -304,7 +304,7 @@ static void ServerRead(WOLFSSL* ssl, char* input, int inputLen)
}
else
#endif
if (err != SSL_ERROR_WANT_READ) {
if (err != WOLF_SSL_ERROR_WANT_READ) {
printf("SSL_read input error %d, %s\n", err,
ERR_error_string(err, buffer));
err_sys_ex(runWithErrors, "SSL_read failed");
@ -335,7 +335,7 @@ static void ServerWrite(WOLFSSL* ssl, const char* output, int outputLen)
}
#endif
}
} while (err == WC_PENDING_E || err == SSL_ERROR_WANT_WRITE);
} while (err == WC_PENDING_E || err == WOLF_SSL_ERROR_WANT_WRITE);
if (ret != outputLen) {
printf("SSL_write msg error %d, %s\n", err,
ERR_error_string(err, buffer));
@ -918,13 +918,13 @@ THREAD_RETURN CYASSL_THREAD server_test(void* args)
#endif /* DEBUG_WOLFSSL */
if (wolfSSL_CTX_load_static_memory(&ctx, method, memory, sizeof(memory),0,1)
!= SSL_SUCCESS)
!= WOLF_SSL_SUCCESS)
err_sys_ex(runWithErrors, "unable to load static memory and create ctx");
/* load in a buffer for IO */
if (wolfSSL_CTX_load_static_memory(&ctx, NULL, memoryIO, sizeof(memoryIO),
WOLFMEM_IO_POOL_FIXED | WOLFMEM_TRACK_STATS, 1)
!= SSL_SUCCESS)
!= WOLF_SSL_SUCCESS)
err_sys_ex(runWithErrors, "unable to load static memory and create ctx");
#else
ctx = SSL_CTX_new(method(NULL));
@ -940,7 +940,7 @@ THREAD_RETURN CYASSL_THREAD server_test(void* args)
#endif
if (cipherList && !useDefCipherList) {
if (SSL_CTX_set_cipher_list(ctx, cipherList) != SSL_SUCCESS)
if (SSL_CTX_set_cipher_list(ctx, cipherList) != WOLF_SSL_SUCCESS)
err_sys_ex(runWithErrors, "server can't set cipher list 1");
}
@ -972,7 +972,7 @@ THREAD_RETURN CYASSL_THREAD server_test(void* args)
if ((!usePsk || usePskPlus) && !useAnon) {
#if !defined(NO_FILESYSTEM)
if (SSL_CTX_use_certificate_chain_file(ctx, ourCert)
!= SSL_SUCCESS)
!= WOLF_SSL_SUCCESS)
err_sys_ex(runWithErrors, "can't load server cert file, check file and run from"
" wolfSSL home dir");
#else
@ -983,17 +983,17 @@ THREAD_RETURN CYASSL_THREAD server_test(void* args)
#endif
#ifndef NO_DH
if (wolfSSL_CTX_SetMinDhKey_Sz(ctx, (word16)minDhKeyBits) != SSL_SUCCESS) {
if (wolfSSL_CTX_SetMinDhKey_Sz(ctx, (word16)minDhKeyBits) != WOLF_SSL_SUCCESS) {
err_sys_ex(runWithErrors, "Error setting minimum DH key size");
}
#endif
#ifndef NO_RSA
if (wolfSSL_CTX_SetMinRsaKey_Sz(ctx, minRsaKeyBits) != SSL_SUCCESS){
if (wolfSSL_CTX_SetMinRsaKey_Sz(ctx, minRsaKeyBits) != WOLF_SSL_SUCCESS){
err_sys_ex(runWithErrors, "Error setting minimum RSA key size");
}
#endif
#ifdef HAVE_ECC
if (wolfSSL_CTX_SetMinEccKey_Sz(ctx, minEccKeyBits) != SSL_SUCCESS){
if (wolfSSL_CTX_SetMinEccKey_Sz(ctx, minEccKeyBits) != WOLF_SSL_SUCCESS){
err_sys_ex(runWithErrors, "Error setting minimum ECC key size");
}
#endif
@ -1001,7 +1001,7 @@ THREAD_RETURN CYASSL_THREAD server_test(void* args)
#ifdef HAVE_NTRU
if (useNtruKey) {
if (CyaSSL_CTX_use_NTRUPrivateKey_file(ctx, ourKey)
!= SSL_SUCCESS)
!= WOLF_SSL_SUCCESS)
err_sys_ex(runWithErrors, "can't load ntru key file, "
"Please run from wolfSSL home dir");
}
@ -1009,8 +1009,8 @@ THREAD_RETURN CYASSL_THREAD server_test(void* args)
#if !defined(NO_CERTS)
if (!useNtruKey && (!usePsk || usePskPlus) && !useAnon) {
#if !defined(NO_FILESYSTEM)
if (SSL_CTX_use_PrivateKey_file(ctx, ourKey, SSL_FILETYPE_PEM)
!= SSL_SUCCESS)
if (SSL_CTX_use_PrivateKey_file(ctx, ourKey, WOLF_SSL_FILETYPE_PEM)
!= WOLF_SSL_SUCCESS)
err_sys_ex(runWithErrors, "can't load server private key file, check file and run "
"from wolfSSL home dir");
#else
@ -1042,7 +1042,7 @@ THREAD_RETURN CYASSL_THREAD server_test(void* args)
#else
defaultCipherList = "PSK-AES128-CBC-SHA256";
#endif
if (SSL_CTX_set_cipher_list(ctx, defaultCipherList) != SSL_SUCCESS)
if (SSL_CTX_set_cipher_list(ctx, defaultCipherList) != WOLF_SSL_SUCCESS)
err_sys_ex(runWithErrors, "server can't set cipher list 2");
}
#endif
@ -1052,7 +1052,7 @@ THREAD_RETURN CYASSL_THREAD server_test(void* args)
#ifdef HAVE_ANON
CyaSSL_CTX_allow_anon_cipher(ctx);
if (cipherList == NULL || (cipherList && useDefCipherList)) {
if (SSL_CTX_set_cipher_list(ctx, "ADH-AES128-SHA") != SSL_SUCCESS)
if (SSL_CTX_set_cipher_list(ctx, "ADH-AES128-SHA") != WOLF_SSL_SUCCESS)
err_sys_ex(runWithErrors, "server can't set cipher list 4");
}
#endif
@ -1062,15 +1062,15 @@ THREAD_RETURN CYASSL_THREAD server_test(void* args)
/* if not using PSK, verify peer with certs
if using PSK Plus then verify peer certs except PSK suites */
if (doCliCertCheck && (usePsk == 0 || usePskPlus) && useAnon == 0) {
SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER |
((usePskPlus)? SSL_VERIFY_FAIL_EXCEPT_PSK :
SSL_VERIFY_FAIL_IF_NO_PEER_CERT),0);
if (SSL_CTX_load_verify_locations(ctx, verifyCert, 0) != SSL_SUCCESS)
SSL_CTX_set_verify(ctx, WOLF_SSL_VERIFY_PEER |
((usePskPlus)? WOLF_SSL_VERIFY_FAIL_EXCEPT_PSK :
WOLF_SSL_VERIFY_FAIL_IF_NO_PEER_CERT),0);
if (SSL_CTX_load_verify_locations(ctx, verifyCert, 0) != WOLF_SSL_SUCCESS)
err_sys_ex(runWithErrors, "can't load ca file, Please run from wolfSSL home dir");
#ifdef WOLFSSL_TRUST_PEER_CERT
if (trustCert) {
if ((ret = wolfSSL_CTX_trust_peer_cert(ctx, trustCert,
SSL_FILETYPE_PEM)) != SSL_SUCCESS) {
WOLF_SSL_FILETYPE_PEM)) != WOLF_SSL_SUCCESS) {
err_sys_ex(runWithErrors, "can't load trusted peer cert file");
}
}
@ -1081,7 +1081,7 @@ THREAD_RETURN CYASSL_THREAD server_test(void* args)
#if defined(CYASSL_SNIFFER)
/* don't use EDH, can't sniff tmp keys */
if (cipherList == NULL) {
if (SSL_CTX_set_cipher_list(ctx, "AES128-SHA") != SSL_SUCCESS)
if (SSL_CTX_set_cipher_list(ctx, "AES128-SHA") != WOLF_SSL_SUCCESS)
err_sys_ex(runWithErrors, "server can't set cipher list 3");
}
#endif
@ -1089,7 +1089,7 @@ THREAD_RETURN CYASSL_THREAD server_test(void* args)
#ifdef HAVE_SNI
if (sniHostName)
if (CyaSSL_CTX_UseSNI(ctx, CYASSL_SNI_HOST_NAME, sniHostName,
XSTRLEN(sniHostName)) != SSL_SUCCESS)
XSTRLEN(sniHostName)) != WOLF_SSL_SUCCESS)
err_sys_ex(runWithErrors, "UseSNI failed");
#endif
@ -1144,7 +1144,7 @@ THREAD_RETURN CYASSL_THREAD server_test(void* args)
if (doMcast) {
#ifdef WOLFSSL_MULTICAST
wolfSSL_CTX_mcast_set_member_id(ctx, mcastID);
if (wolfSSL_CTX_set_cipher_list(ctx, "WDM-NULL-SHA256") != SSL_SUCCESS)
if (wolfSSL_CTX_set_cipher_list(ctx, "WDM-NULL-SHA256") != WOLF_SSL_SUCCESS)
err_sys("Couldn't set multicast cipher list.");
#endif
}
@ -1157,7 +1157,7 @@ THREAD_RETURN CYASSL_THREAD server_test(void* args)
#endif
#ifdef WOLFSSL_SEND_HRR_COOKIE
if (hrrCookie && wolfSSL_send_hrr_cookie(ssl, NULL, 0) != SSL_SUCCESS) {
if (hrrCookie && wolfSSL_send_hrr_cookie(ssl, NULL, 0) != WOLF_SSL_SUCCESS) {
err_sys("unable to set use of cookie with HRR msg");
}
#endif
@ -1185,7 +1185,7 @@ THREAD_RETURN CYASSL_THREAD server_test(void* args)
XMEMSET(sr, 0x5A, sizeof(sr));
if (wolfSSL_set_secret(ssl, 1, pms, sizeof(pms), cr, sr, suite)
!= SSL_SUCCESS)
!= WOLF_SSL_SUCCESS)
err_sys("unable to set mcast secret");
#endif
}
@ -1197,12 +1197,12 @@ THREAD_RETURN CYASSL_THREAD server_test(void* args)
#ifdef HAVE_CRL_MONITOR
crlFlags = CYASSL_CRL_MONITOR | CYASSL_CRL_START_MON;
#endif
if (CyaSSL_EnableCRL(ssl, 0) != SSL_SUCCESS)
if (CyaSSL_EnableCRL(ssl, 0) != WOLF_SSL_SUCCESS)
err_sys_ex(runWithErrors, "unable to enable CRL");
if (CyaSSL_LoadCRL(ssl, crlPemDir, SSL_FILETYPE_PEM, crlFlags)
!= SSL_SUCCESS)
if (CyaSSL_LoadCRL(ssl, crlPemDir, WOLF_SSL_FILETYPE_PEM, crlFlags)
!= WOLF_SSL_SUCCESS)
err_sys_ex(runWithErrors, "unable to load CRL");
if (CyaSSL_SetCRL_Cb(ssl, CRL_CallBack) != SSL_SUCCESS)
if (CyaSSL_SetCRL_Cb(ssl, CRL_CallBack) != WOLF_SSL_SUCCESS)
err_sys_ex(runWithErrors, "unable to set CRL callback url");
#endif
#ifdef HAVE_OCSP
@ -1218,13 +1218,13 @@ THREAD_RETURN CYASSL_THREAD server_test(void* args)
#endif
#if defined(HAVE_CERTIFICATE_STATUS_REQUEST) \
|| defined(HAVE_CERTIFICATE_STATUS_REQUEST_V2)
if (wolfSSL_CTX_EnableOCSPStapling(ctx) != SSL_SUCCESS)
if (wolfSSL_CTX_EnableOCSPStapling(ctx) != WOLF_SSL_SUCCESS)
err_sys_ex(runWithErrors, "can't enable OCSP Stapling Certificate Manager");
if (SSL_CTX_load_verify_locations(ctx, "certs/ocsp/intermediate1-ca-cert.pem", 0) != SSL_SUCCESS)
if (SSL_CTX_load_verify_locations(ctx, "certs/ocsp/intermediate1-ca-cert.pem", 0) != WOLF_SSL_SUCCESS)
err_sys_ex(runWithErrors, "can't load ca file, Please run from wolfSSL home dir");
if (SSL_CTX_load_verify_locations(ctx, "certs/ocsp/intermediate2-ca-cert.pem", 0) != SSL_SUCCESS)
if (SSL_CTX_load_verify_locations(ctx, "certs/ocsp/intermediate2-ca-cert.pem", 0) != WOLF_SSL_SUCCESS)
err_sys_ex(runWithErrors, "can't load ca file, Please run from wolfSSL home dir");
if (SSL_CTX_load_verify_locations(ctx, "certs/ocsp/intermediate3-ca-cert.pem", 0) != SSL_SUCCESS)
if (SSL_CTX_load_verify_locations(ctx, "certs/ocsp/intermediate3-ca-cert.pem", 0) != WOLF_SSL_SUCCESS)
err_sys_ex(runWithErrors, "can't load ca file, Please run from wolfSSL home dir");
#endif
#ifdef HAVE_PK_CALLBACKS
@ -1241,7 +1241,7 @@ THREAD_RETURN CYASSL_THREAD server_test(void* args)
dtlsUDP, dtlsSCTP, serverReadyFile ? 1 : 0, doListen);
doListen = 0; /* Don't listen next time */
if (SSL_set_fd(ssl, clientfd) != SSL_SUCCESS) {
if (SSL_set_fd(ssl, clientfd) != WOLF_SSL_SUCCESS) {
err_sys_ex(runWithErrors, "error in setting fd");
}
@ -1273,7 +1273,7 @@ THREAD_RETURN CYASSL_THREAD server_test(void* args)
if ((usePsk == 0 || usePskPlus) || useAnon == 1 || cipherList != NULL
|| needDH == 1) {
#if !defined(NO_FILESYSTEM) && !defined(NO_DH) && !defined(NO_ASN)
CyaSSL_SetTmpDH_file(ssl, ourDhParam, SSL_FILETYPE_PEM);
CyaSSL_SetTmpDH_file(ssl, ourDhParam, WOLF_SSL_FILETYPE_PEM);
#elif !defined(NO_DH)
SetDH(ssl); /* repick suites with DHE, higher priority than PSK */
#endif
@ -1298,7 +1298,7 @@ THREAD_RETURN CYASSL_THREAD server_test(void* args)
err = 0; /* reset error */
ret = wolfSSL_read_early_data(ssl, input, sizeof(input)-1,
&len);
if (ret != SSL_SUCCESS) {
if (ret != WOLF_SSL_SUCCESS) {
err = SSL_get_error(ssl, 0);
#ifdef WOLFSSL_ASYNC_CRYPT
if (err == WC_PENDING_E) {
@ -1317,7 +1317,7 @@ THREAD_RETURN CYASSL_THREAD server_test(void* args)
do {
err = 0; /* reset error */
ret = SSL_accept(ssl);
if (ret != SSL_SUCCESS) {
if (ret != WOLF_SSL_SUCCESS) {
err = SSL_get_error(ssl, 0);
#ifdef WOLFSSL_ASYNC_CRYPT
if (err == WC_PENDING_E) {
@ -1331,7 +1331,7 @@ THREAD_RETURN CYASSL_THREAD server_test(void* args)
#else
ret = NonBlockingSSL_Accept(ssl);
#endif
if (ret != SSL_SUCCESS) {
if (ret != WOLF_SSL_SUCCESS) {
err = SSL_get_error(ssl, 0);
printf("SSL_accept error %d, %s\n", err,
ERR_error_string(err, buffer));
@ -1385,7 +1385,7 @@ THREAD_RETURN CYASSL_THREAD server_test(void* args)
word16 protocol_nameSz = 0, listSz = 0;
err = wolfSSL_ALPN_GetProtocol(ssl, &protocol_name, &protocol_nameSz);
if (err == SSL_SUCCESS)
if (err == WOLF_SSL_SUCCESS)
printf("Sent ALPN protocol : %s (%d)\n",
protocol_name, protocol_nameSz);
else if (err == SSL_ALPN_NOT_FOUND)
@ -1394,7 +1394,7 @@ THREAD_RETURN CYASSL_THREAD server_test(void* args)
printf("Getting ALPN protocol name failed\n");
err = wolfSSL_ALPN_GetPeerProtocol(ssl, &list, &listSz);
if (err == SSL_SUCCESS)
if (err == WOLF_SSL_SUCCESS)
printf("List of protocol names sent by Client: %s (%d)\n",
list, listSz);
else
@ -1407,17 +1407,17 @@ THREAD_RETURN CYASSL_THREAD server_test(void* args)
#if !defined(NO_FILESYSTEM) && !defined(NO_CERTS)
#if defined(WOLFSSL_TLS13) && defined(WOLFSSL_POST_HANDSHAKE_AUTH)
if (postHandAuth) {
SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER |
((usePskPlus)? SSL_VERIFY_FAIL_EXCEPT_PSK :
SSL_VERIFY_FAIL_IF_NO_PEER_CERT),0);
SSL_CTX_set_verify(ctx, WOLF_SSL_VERIFY_PEER |
((usePskPlus)? WOLF_SSL_VERIFY_FAIL_EXCEPT_PSK :
WOLF_SSL_VERIFY_FAIL_IF_NO_PEER_CERT),0);
if (SSL_CTX_load_verify_locations(ctx, verifyCert, 0)
!= SSL_SUCCESS) {
!= WOLF_SSL_SUCCESS) {
err_sys_ex(runWithErrors, "can't load ca file, Please run from wolfSSL home dir");
}
#ifdef WOLFSSL_TRUST_PEER_CERT
if (trustCert) {
if ((ret = wolfSSL_CTX_trust_peer_cert(ctx, trustCert,
SSL_FILETYPE_PEM)) != SSL_SUCCESS) {
WOLF_SSL_FILETYPE_PEM)) != WOLF_SSL_SUCCESS) {
err_sys_ex(runWithErrors, "can't load trusted peer cert file");
}
}
@ -1471,7 +1471,7 @@ THREAD_RETURN CYASSL_THREAD server_test(void* args)
if (dtlsUDP == 0) {
ret = SSL_shutdown(ssl);
if (wc_shutdown && ret == SSL_SHUTDOWN_NOT_DONE)
if (wc_shutdown && ret == WOLF_SSL_SHUTDOWN_NOT_DONE)
SSL_shutdown(ssl); /* bidirectional shutdown */
}
/* display collected statistics */

54
src/bio.c
View File

@ -75,11 +75,11 @@ long wolfSSL_BIO_get_mem_ptr(WOLFSSL_BIO *bio, WOLFSSL_BUF_MEM **ptr)
WOLFSSL_ENTER("BIO_get_mem_ptr");
if (bio == NULL || ptr == NULL) {
return SSL_FAILURE;
return WOLF_SSL_FAILURE;
}
*ptr = (WOLFSSL_BUF_MEM*)(bio->mem);
return SSL_SUCCESS;
return WOLF_SSL_SUCCESS;
}
/*** TBD ***/
@ -99,19 +99,19 @@ int wolfSSL_BIO_set_write_buf_size(WOLFSSL_BIO *bio, long size)
WOLFSSL_ENTER("wolfSSL_BIO_set_write_buf_size");
if (bio == NULL || bio->type != BIO_BIO || size < 0) {
return SSL_FAILURE;
return WOLF_SSL_FAILURE;
}
/* if already in pair then do not change size */
if (bio->pair != NULL) {
WOLFSSL_MSG("WOLFSSL_BIO is paired, free from pair before changing");
return SSL_FAILURE;
return WOLF_SSL_FAILURE;
}
bio->wrSz = (int)size;
if (bio->wrSz < 0) {
WOLFSSL_MSG("Unexpected negative size value");
return SSL_FAILURE;
return WOLF_SSL_FAILURE;
}
if (bio->mem != NULL) {
@ -121,12 +121,12 @@ int wolfSSL_BIO_set_write_buf_size(WOLFSSL_BIO *bio, long size)
bio->mem = (byte*)XMALLOC(bio->wrSz, bio->heap, DYNAMIC_TYPE_OPENSSL);
if (bio->mem == NULL) {
WOLFSSL_MSG("Memory allocation error");
return SSL_FAILURE;
return WOLF_SSL_FAILURE;
}
bio->wrIdx = 0;
bio->rdIdx = 0;
return SSL_SUCCESS;
return WOLF_SSL_SUCCESS;
}
@ -140,31 +140,31 @@ int wolfSSL_BIO_make_bio_pair(WOLFSSL_BIO *b1, WOLFSSL_BIO *b2)
if (b1 == NULL || b2 == NULL) {
WOLFSSL_LEAVE("wolfSSL_BIO_make_bio_pair", BAD_FUNC_ARG);
return SSL_FAILURE;
return WOLF_SSL_FAILURE;
}
/* both are expected to be of type BIO and not already paired */
if (b1->type != BIO_BIO || b2->type != BIO_BIO ||
b1->pair != NULL || b2->pair != NULL) {
WOLFSSL_MSG("Expected type BIO and not already paired");
return SSL_FAILURE;
return WOLF_SSL_FAILURE;
}
/* set default write size if not already set */
if (b1->mem == NULL && wolfSSL_BIO_set_write_buf_size(b1,
WOLFSSL_BIO_SIZE) != SSL_SUCCESS) {
return SSL_FAILURE;
WOLFSSL_BIO_SIZE) != WOLF_SSL_SUCCESS) {
return WOLF_SSL_FAILURE;
}
if (b2->mem == NULL && wolfSSL_BIO_set_write_buf_size(b2,
WOLFSSL_BIO_SIZE) != SSL_SUCCESS) {
return SSL_FAILURE;
WOLFSSL_BIO_SIZE) != WOLF_SSL_SUCCESS) {
return WOLF_SSL_FAILURE;
}
b1->pair = b2;
b2->pair = b1;
return SSL_SUCCESS;
return WOLF_SSL_SUCCESS;
}
@ -173,12 +173,12 @@ int wolfSSL_BIO_ctrl_reset_read_request(WOLFSSL_BIO *b)
WOLFSSL_ENTER("wolfSSL_BIO_ctrl_reset_read_request");
if (b == NULL) {
return SSL_FAILURE;
return WOLF_SSL_FAILURE;
}
b->readRq = 0;
return SSL_SUCCESS;
return WOLF_SSL_SUCCESS;
}
@ -219,7 +219,7 @@ int wolfSSL_BIO_nread(WOLFSSL_BIO *bio, char **buf, int num)
if (bio == NULL || buf == NULL) {
WOLFSSL_MSG("NULL argument passed in");
return SSL_FAILURE;
return WOLF_SSL_FAILURE;
}
if (bio->pair != NULL) {
@ -362,17 +362,17 @@ long wolfSSL_BIO_set_fp(WOLFSSL_BIO *bio, XFILE fp, int c)
if (bio == NULL || fp == NULL) {
WOLFSSL_LEAVE("wolfSSL_BIO_set_fp", BAD_FUNC_ARG);
return SSL_FAILURE;
return WOLF_SSL_FAILURE;
}
if (bio->type != BIO_FILE) {
return SSL_FAILURE;
return WOLF_SSL_FAILURE;
}
bio->close = (byte)c;
bio->file = fp;
return SSL_SUCCESS;
return WOLF_SSL_SUCCESS;
}
@ -381,16 +381,16 @@ long wolfSSL_BIO_get_fp(WOLFSSL_BIO *bio, XFILE* fp)
WOLFSSL_ENTER("wolfSSL_BIO_get_fp");
if (bio == NULL || fp == NULL) {
return SSL_FAILURE;
return WOLF_SSL_FAILURE;
}
if (bio->type != BIO_FILE) {
return SSL_FAILURE;
return WOLF_SSL_FAILURE;
}
*fp = bio->file;
return SSL_SUCCESS;
return WOLF_SSL_SUCCESS;
}
/* overwrites file */
@ -399,7 +399,7 @@ int wolfSSL_BIO_write_filename(WOLFSSL_BIO *bio, char *name)
WOLFSSL_ENTER("wolfSSL_BIO_write_filename");
if (bio == NULL || name == NULL) {
return SSL_FAILURE;
return WOLF_SSL_FAILURE;
}
if (bio->type == BIO_FILE) {
@ -409,14 +409,14 @@ int wolfSSL_BIO_write_filename(WOLFSSL_BIO *bio, char *name)
bio->file = XFOPEN(name, "w");
if (bio->file == NULL) {
return SSL_FAILURE;
return WOLF_SSL_FAILURE;
}
bio->close = BIO_CLOSE;
return SSL_SUCCESS;
return WOLF_SSL_SUCCESS;
}
return SSL_FAILURE;
return WOLF_SSL_FAILURE;
}

34
src/crl.c
View File

@ -421,11 +421,11 @@ static int AddCRL(WOLFSSL_CRL* crl, DecodedCRL* dcrl, const byte* buff,
}
/* Load CRL File of type, SSL_SUCCESS on ok */
/* Load CRL File of type, WOLF_SSL_SUCCESS on ok */
int BufferLoadCRL(WOLFSSL_CRL* crl, const byte* buff, long sz, int type,
int noVerify)
{
int ret = SSL_SUCCESS;
int ret = WOLF_SSL_SUCCESS;
const byte* myBuffer = buff; /* if DER ok, otherwise switch */
DerBuffer* der = NULL;
#ifdef WOLFSSL_SMALL_STACK
@ -439,7 +439,7 @@ int BufferLoadCRL(WOLFSSL_CRL* crl, const byte* buff, long sz, int type,
if (crl == NULL || buff == NULL || sz == 0)
return BAD_FUNC_ARG;
if (type == SSL_FILETYPE_PEM) {
if (type == WOLF_SSL_FILETYPE_PEM) {
int eccKey = 0; /* not used */
EncryptedInfo info;
info.ctx = NULL;
@ -484,7 +484,7 @@ int BufferLoadCRL(WOLFSSL_CRL* crl, const byte* buff, long sz, int type,
FreeDer(&der);
return ret ? ret : SSL_SUCCESS; /* convert 0 to SSL_SUCCESS */
return ret ? ret : WOLF_SSL_SUCCESS; /* convert 0 to WOLF_SSL_SUCCESS */
}
@ -540,8 +540,8 @@ static int SwapLists(WOLFSSL_CRL* crl)
}
if (crl->monitors[0].path) {
ret = LoadCRL(tmp, crl->monitors[0].path, SSL_FILETYPE_PEM, 0);
if (ret != SSL_SUCCESS) {
ret = LoadCRL(tmp, crl->monitors[0].path, WOLF_SSL_FILETYPE_PEM, 0);
if (ret != WOLF_SSL_SUCCESS) {
WOLFSSL_MSG("PEM LoadCRL on dir change failed");
FreeCRL(tmp, 0);
#ifdef WOLFSSL_SMALL_STACK
@ -552,8 +552,8 @@ static int SwapLists(WOLFSSL_CRL* crl)
}
if (crl->monitors[1].path) {
ret = LoadCRL(tmp, crl->monitors[1].path, SSL_FILETYPE_ASN1, 0);
if (ret != SSL_SUCCESS) {
ret = LoadCRL(tmp, crl->monitors[1].path, WOLF_SSL_FILETYPE_ASN1, 0);
if (ret != WOLF_SSL_SUCCESS) {
WOLFSSL_MSG("DER LoadCRL on dir change failed");
FreeCRL(tmp, 0);
#ifdef WOLFSSL_SMALL_STACK
@ -884,7 +884,7 @@ static void* DoMonitor(void* arg)
/* Start Monitoring the CRL path(s) in a thread */
static int StartMonitorCRL(WOLFSSL_CRL* crl)
{
int ret = SSL_SUCCESS;
int ret = WOLF_SSL_SUCCESS;
WOLFSSL_ENTER("StartMonitorCRL");
@ -948,10 +948,10 @@ static int StartMonitorCRL(WOLFSSL_CRL* crl)
#if !defined(NO_FILESYSTEM) && !defined(NO_WOLFSSL_DIR)
/* Load CRL path files of type, SSL_SUCCESS on ok */
/* Load CRL path files of type, WOLF_SSL_SUCCESS on ok */
int LoadCRL(WOLFSSL_CRL* crl, const char* path, int type, int monitor)
{
int ret = SSL_SUCCESS;
int ret = WOLF_SSL_SUCCESS;
char* name = NULL;
#ifdef WOLFSSL_SMALL_STACK
ReadDirCtx* readCtx = NULL;
@ -974,7 +974,7 @@ int LoadCRL(WOLFSSL_CRL* crl, const char* path, int type, int monitor)
ret = wc_ReadDirFirst(readCtx, path, &name);
while (ret == 0 && name) {
int skip = 0;
if (type == SSL_FILETYPE_PEM) {
if (type == WOLF_SSL_FILETYPE_PEM) {
if (XSTRSTR(name, ".pem") == NULL) {
WOLFSSL_MSG("not .pem file, skipping");
skip = 1;
@ -990,14 +990,14 @@ int LoadCRL(WOLFSSL_CRL* crl, const char* path, int type, int monitor)
}
if (!skip && ProcessFile(NULL, name, type, CRL_TYPE, NULL, 0, crl)
!= SSL_SUCCESS) {
!= WOLF_SSL_SUCCESS) {
WOLFSSL_MSG("CRL file load failed, continuing");
}
ret = wc_ReadDirNext(readCtx, path, &name);
}
wc_ReadDirClose(readCtx);
ret = SSL_SUCCESS; /* load failures not reported, for backwards compat */
ret = WOLF_SSL_SUCCESS; /* load failures not reported, for backwards compat */
#ifdef WOLFSSL_SMALL_STACK
XFREE(readCtx, crl->heap, DYNAMIC_TYPE_TMP_BUFFER);
@ -1015,14 +1015,14 @@ int LoadCRL(WOLFSSL_CRL* crl, const char* path, int type, int monitor)
XSTRNCPY(pathBuf, path, pathLen);
pathBuf[pathLen] = '\0'; /* Null Terminate */
if (type == SSL_FILETYPE_PEM) {
if (type == WOLF_SSL_FILETYPE_PEM) {
/* free old path before setting a new one */
if (crl->monitors[0].path) {
XFREE(crl->monitors[0].path, crl->heap,
DYNAMIC_TYPE_CRL_MONITOR);
}
crl->monitors[0].path = pathBuf;
crl->monitors[0].type = SSL_FILETYPE_PEM;
crl->monitors[0].type = WOLF_SSL_FILETYPE_PEM;
} else {
/* free old path before setting a new one */
if (crl->monitors[1].path) {
@ -1030,7 +1030,7 @@ int LoadCRL(WOLFSSL_CRL* crl, const char* path, int type, int monitor)
DYNAMIC_TYPE_CRL_MONITOR);
}
crl->monitors[1].path = pathBuf;
crl->monitors[1].type = SSL_FILETYPE_ASN1;
crl->monitors[1].type = WOLF_SSL_FILETYPE_ASN1;
}
if (monitor & WOLFSSL_CRL_START_MON) {

106
src/internal.c
View File

@ -1081,7 +1081,7 @@ static int ExportPeerInfo(WOLFSSL* ssl, byte* exp, word32 len, byte ver)
WOLFSSL_MSG("No get peer call back set");
return BAD_FUNC_ARG;
}
if (ssl->ctx->CBGetPeer(ssl, ip, &ipSz, &port, &fam) != SSL_SUCCESS) {
if (ssl->ctx->CBGetPeer(ssl, ip, &ipSz, &port, &fam) != WOLF_SSL_SUCCESS) {
WOLFSSL_MSG("Get peer callback error");
return SOCKET_ERROR_E;
}
@ -1136,7 +1136,7 @@ static int ImportPeerInfo(WOLFSSL* ssl, byte* buf, word32 len, byte ver)
WOLFSSL_MSG("No set peer function");
return BAD_FUNC_ARG;
}
if (ssl->ctx->CBSetPeer(ssl, ip, ipSz, port, fam) != SSL_SUCCESS) {
if (ssl->ctx->CBSetPeer(ssl, ip, ipSz, port, fam) != WOLF_SSL_SUCCESS) {
WOLFSSL_MSG("Error setting peer info");
return SOCKET_ERROR_E;
}
@ -2940,25 +2940,25 @@ static void SetDigest(WOLFSSL* ssl, int hashAlgo)
#ifndef NO_SHA
case sha_mac:
ssl->buffers.digest.buffer = ssl->hsHashes->certHashes.sha;
ssl->buffers.digest.length = SHA_DIGEST_SIZE;
ssl->buffers.digest.length = WC_SHA_DIGEST_SIZE;
break;
#endif /* !NO_SHA */
#ifndef NO_SHA256
case sha256_mac:
ssl->buffers.digest.buffer = ssl->hsHashes->certHashes.sha256;
ssl->buffers.digest.length = SHA256_DIGEST_SIZE;
ssl->buffers.digest.length = WC_SHA256_DIGEST_SIZE;
break;
#endif /* !NO_SHA256 */
#ifdef WOLFSSL_SHA384
case sha384_mac:
ssl->buffers.digest.buffer = ssl->hsHashes->certHashes.sha384;
ssl->buffers.digest.length = SHA384_DIGEST_SIZE;
ssl->buffers.digest.length = WC_SHA384_DIGEST_SIZE;
break;
#endif /* WOLFSSL_SHA384 */
#ifdef WOLFSSL_SHA512
case sha512_mac:
ssl->buffers.digest.buffer = ssl->hsHashes->certHashes.sha512;
ssl->buffers.digest.length = SHA512_DIGEST_SIZE;
ssl->buffers.digest.length = WC_SHA512_DIGEST_SIZE;
break;
#endif /* WOLFSSL_SHA512 */
} /* switch */
@ -3901,7 +3901,7 @@ int DhAgree(WOLFSSL* ssl, DhKey* dhKey,
ctx parent factory
writeDup flag indicating this is a write dup only
SSL_SUCCESS return value on success */
WOLF_SSL_SUCCESS return value on success */
int SetSSL_CTX(WOLFSSL* ssl, WOLFSSL_CTX* ctx, int writeDup)
{
byte havePSK = 0;
@ -4097,7 +4097,7 @@ int SetSSL_CTX(WOLFSSL* ssl, WOLFSSL_CTX* ctx, int writeDup)
ssl->readAhead = ctx->readAhead;
#endif
return SSL_SUCCESS;
return WOLF_SSL_SUCCESS;
}
int InitHandshakeHashes(WOLFSSL* ssl)
@ -4410,7 +4410,7 @@ int InitSSL(WOLFSSL* ssl, WOLFSSL_CTX* ctx, int writeDup)
/* Initialize SSL with the appropriate fields from it's ctx */
/* requires valid arrays and suites unless writeDup ing */
if ((ret = SetSSL_CTX(ssl, ctx, writeDup)) != SSL_SUCCESS)
if ((ret = SetSSL_CTX(ssl, ctx, writeDup)) != WOLF_SSL_SUCCESS)
return ret;
ssl->options.dtls = ssl->version.major == DTLS_MAJOR;
@ -6636,13 +6636,13 @@ static const byte PAD2[PAD_MD5] =
static int BuildMD5(WOLFSSL* ssl, Hashes* hashes, const byte* sender)
{
int ret;
byte md5_result[MD5_DIGEST_SIZE];
byte md5_result[WC_MD5_DIGEST_SIZE];
#ifdef WOLFSSL_SMALL_STACK
Md5* md5 = (Md5*)XMALLOC(sizeof(Md5), ssl->heap, DYNAMIC_TYPE_HASHCTX);
wc_Md5* md5 = (wc_Md5*)XMALLOC(sizeof(wc_Md5), ssl->heap, DYNAMIC_TYPE_HASHCTX);
if (md5 == NULL)
return MEMORY_E;
#else
Md5 md5[1];
wc_Md5 md5[1];
#endif
/* make md5 inner */
@ -6664,7 +6664,7 @@ static int BuildMD5(WOLFSSL* ssl, Hashes* hashes, const byte* sender)
if (ret == 0)
ret = wc_Md5Update(md5, PAD2, PAD_MD5);
if (ret == 0)
ret = wc_Md5Update(md5, md5_result, MD5_DIGEST_SIZE);
ret = wc_Md5Update(md5, md5_result, WC_MD5_DIGEST_SIZE);
if (ret == 0)
ret = wc_Md5Final(md5, hashes->md5);
wc_Md5Free(md5);
@ -6683,13 +6683,13 @@ static int BuildMD5(WOLFSSL* ssl, Hashes* hashes, const byte* sender)
static int BuildSHA(WOLFSSL* ssl, Hashes* hashes, const byte* sender)
{
int ret;
byte sha_result[SHA_DIGEST_SIZE];
byte sha_result[WC_SHA_DIGEST_SIZE];
#ifdef WOLFSSL_SMALL_STACK
Sha* sha = (Sha*)XMALLOC(sizeof(Sha), ssl->heap, DYNAMIC_TYPE_HASHCTX);
wc_Sha* sha = (wc_Sha*)XMALLOC(sizeof(wc_Sha), ssl->heap, DYNAMIC_TYPE_HASHCTX);
if (sha == NULL)
return MEMORY_E;
#else
Sha sha[1];
wc_Sha sha[1];
#endif
/* make sha inner */
ret = wc_ShaCopy(&ssl->hsHashes->hashSha, sha); /* Save current position */
@ -6710,7 +6710,7 @@ static int BuildSHA(WOLFSSL* ssl, Hashes* hashes, const byte* sender)
if (ret == 0)
ret = wc_ShaUpdate(sha, PAD2, PAD_SHA);
if (ret == 0)
ret = wc_ShaUpdate(sha, sha_result, SHA_DIGEST_SIZE);
ret = wc_ShaUpdate(sha, sha_result, WC_SHA_DIGEST_SIZE);
if (ret == 0)
ret = wc_ShaFinal(sha, hashes->sha);
wc_ShaFree(sha);
@ -6731,9 +6731,9 @@ static int BuildFinished(WOLFSSL* ssl, Hashes* hashes, const byte* sender)
int ret = 0;
#ifdef WOLFSSL_SHA384
#ifdef WOLFSSL_SMALL_STACK
Sha384* sha384;
wc_Sha384* sha384;
#else
Sha384 sha384[1];
wc_Sha384 sha384[1];
#endif /* WOLFSSL_SMALL_STACK */
#endif /* WOLFSSL_SHA384 */
@ -6742,7 +6742,7 @@ static int BuildFinished(WOLFSSL* ssl, Hashes* hashes, const byte* sender)
#ifdef WOLFSSL_SHA384
#ifdef WOLFSSL_SMALL_STACK
sha384 = (Sha384*)XMALLOC(sizeof(Sha384), ssl->heap, DYNAMIC_TYPE_HASHCTX);
sha384 = (wc_Sha384*)XMALLOC(sizeof(wc_Sha384), ssl->heap, DYNAMIC_TYPE_HASHCTX);
if (sha384 == NULL)
return MEMORY_E;
#endif /* WOLFSSL_SMALL_STACK */
@ -8205,7 +8205,7 @@ int ProcessPeerCerts(WOLFSSL* ssl, byte* input, word32* inOutIdx,
/* already verified above */
ret = AddCA(ssl->ctx->cm, &add, WOLFSSL_CHAIN_CA, 0);
if (ret == 1) {
ret = 0; /* SSL_SUCCESS for external */
ret = 0; /* WOLF_SSL_SUCCESS for external */
}
}
else if (ret != 0) {
@ -8363,7 +8363,7 @@ int ProcessPeerCerts(WOLFSSL* ssl, byte* input, word32* inOutIdx,
/* compare against previous time */
if (XMEMCMP(args->dCert->subjectHash,
ssl->secure_renegotiation->subject_hash,
SHA_DIGEST_SIZE) != 0) {
WC_SHA_DIGEST_SIZE) != 0) {
WOLFSSL_MSG(
"Peer sent different cert during scr, fatal");
args->fatal = 1;
@ -8374,7 +8374,7 @@ int ProcessPeerCerts(WOLFSSL* ssl, byte* input, word32* inOutIdx,
/* cache peer's hash */
if (args->fatal == 0) {
XMEMCPY(ssl->secure_renegotiation->subject_hash,
args->dCert->subjectHash, SHA_DIGEST_SIZE);
args->dCert->subjectHash, WC_SHA_DIGEST_SIZE);
}
}
#endif /* HAVE_SECURE_RENEGOTIATION */
@ -11136,7 +11136,7 @@ static int SanityCheckCipherText(WOLFSSL* ssl, word32 encryptSz)
static INLINE void Md5Rounds(int rounds, const byte* data, int sz)
{
Md5 md5;
wc_Md5 md5;
int i;
wc_InitMd5(&md5); /* no error check on purpose, dummy round */
@ -11151,7 +11151,7 @@ static INLINE void Md5Rounds(int rounds, const byte* data, int sz)
/* do a dummy sha round */
static INLINE void ShaRounds(int rounds, const byte* data, int sz)
{
Sha sha;
wc_Sha sha;
int i;
wc_InitSha(&sha); /* no error check on purpose, dummy round */
@ -11167,7 +11167,7 @@ static INLINE void ShaRounds(int rounds, const byte* data, int sz)
static INLINE void Sha256Rounds(int rounds, const byte* data, int sz)
{
Sha256 sha256;
wc_Sha256 sha256;
int i;
wc_InitSha256(&sha256); /* no error check on purpose, dummy round */
@ -11186,7 +11186,7 @@ static INLINE void Sha256Rounds(int rounds, const byte* data, int sz)
static INLINE void Sha384Rounds(int rounds, const byte* data, int sz)
{
Sha384 sha384;
wc_Sha384 sha384;
int i;
wc_InitSha384(&sha384); /* no error check on purpose, dummy round */
@ -11205,7 +11205,7 @@ static INLINE void Sha384Rounds(int rounds, const byte* data, int sz)
static INLINE void Sha512Rounds(int rounds, const byte* data, int sz)
{
Sha512 sha512;
wc_Sha512 sha512;
int i;
wc_InitSha512(&sha512); /* no error check on purpose, dummy round */
@ -11428,7 +11428,7 @@ int DoApplicationData(WOLFSSL* ssl, byte* input, word32* inOutIdx)
if (ssl->earlyData) {
if (ssl->earlyDataSz + dataSz > ssl->options.maxEarlyDataSz) {
SendAlert(ssl, alert_fatal, unexpected_message);
return SSL_FATAL_ERROR;
return WOLF_SSL_FATAL_ERROR;
}
ssl->earlyDataSz += dataSz;
}
@ -12298,8 +12298,8 @@ static int SSL_hmac(WOLFSSL* ssl, byte* digest, const byte* in, word32 sz,
word32 padSz = ssl->specs.pad_size;
int ret = 0;
Md5 md5;
Sha sha;
wc_Md5 md5;
wc_Sha sha;
/* data */
byte seq[SEQ_SZ];
@ -12411,11 +12411,11 @@ static int SSL_hmac(WOLFSSL* ssl, byte* digest, const byte* in, word32 sz,
static int BuildMD5_CertVerify(WOLFSSL* ssl, byte* digest)
{
int ret;
byte md5_result[MD5_DIGEST_SIZE];
byte md5_result[WC_MD5_DIGEST_SIZE];
#ifdef WOLFSSL_SMALL_STACK
Md5* md5 = (Md5*)XMALLOC(sizeof(Md5), ssl->heap, DYNAMIC_TYPE_HASHCTX);
wc_Md5* md5 = (wc_Md5*)XMALLOC(sizeof(wc_Md5), ssl->heap, DYNAMIC_TYPE_HASHCTX);
#else
Md5 md5[1];
wc_Md5 md5[1];
#endif
/* make md5 inner */
@ -12435,7 +12435,7 @@ static int BuildMD5_CertVerify(WOLFSSL* ssl, byte* digest)
if (ret == 0)
ret = wc_Md5Update(md5, PAD2, PAD_MD5);
if (ret == 0)
ret = wc_Md5Update(md5, md5_result, MD5_DIGEST_SIZE);
ret = wc_Md5Update(md5, md5_result, WC_MD5_DIGEST_SIZE);
if (ret == 0)
ret = wc_Md5Final(md5, digest);
wc_Md5Free(md5);
@ -12455,11 +12455,11 @@ static int BuildMD5_CertVerify(WOLFSSL* ssl, byte* digest)
static int BuildSHA_CertVerify(WOLFSSL* ssl, byte* digest)
{
int ret;
byte sha_result[SHA_DIGEST_SIZE];
byte sha_result[WC_SHA_DIGEST_SIZE];
#ifdef WOLFSSL_SMALL_STACK
Sha* sha = (Sha*)XMALLOC(sizeof(Sha), ssl->heap, DYNAMIC_TYPE_HASHCTX);
wc_Sha* sha = (wc_Sha*)XMALLOC(sizeof(wc_Sha), ssl->heap, DYNAMIC_TYPE_HASHCTX);
#else
Sha sha[1];
wc_Sha sha[1];
#endif
/* make sha inner */
@ -12479,7 +12479,7 @@ static int BuildSHA_CertVerify(WOLFSSL* ssl, byte* digest)
if (ret == 0)
ret = wc_ShaUpdate(sha, PAD2, PAD_SHA);
if (ret == 0)
ret = wc_ShaUpdate(sha, sha_result, SHA_DIGEST_SIZE);
ret = wc_ShaUpdate(sha, sha_result, WC_SHA_DIGEST_SIZE);
if (ret == 0)
ret = wc_ShaFinal(sha, digest);
wc_ShaFree(sha);
@ -13179,7 +13179,7 @@ int SendCertificateRequest(WOLFSSL* ssl)
word32 i = RECORD_HEADER_SZ + HANDSHAKE_HEADER_SZ;
word32 dnLen = 0;
#ifdef WOLFSSL_NGINX
STACK_OF(WOLFSSL_X509_NAME)* names;
WOLF_STACK_OF(WOLFSSL_X509_NAME)* names;
#endif
int typeTotal = 1; /* only 1 for now */
@ -13782,7 +13782,7 @@ int SendData(WOLFSSL* ssl, const void* data, int sz)
if (ssl->options.handShakeState != HANDSHAKE_DONE) {
int err;
WOLFSSL_MSG("handshake not complete, trying to finish");
if ( (err = wolfSSL_negotiate(ssl)) != SSL_SUCCESS) {
if ( (err = wolfSSL_negotiate(ssl)) != WOLF_SSL_SUCCESS) {
/* if async would block return WANT_WRITE */
if (ssl->error == WC_PENDING_E) {
return WOLFSSL_CBIO_ERR_WANT_WRITE;
@ -13939,7 +13939,7 @@ int ReceiveData(WOLFSSL* ssl, byte* output, int sz, int peek)
if (ssl->options.handShakeState != HANDSHAKE_DONE) {
int err;
WOLFSSL_MSG("Handshake not complete, trying to finish");
if ( (err = wolfSSL_negotiate(ssl)) != SSL_SUCCESS) {
if ( (err = wolfSSL_negotiate(ssl)) != WOLF_SSL_SUCCESS) {
#ifdef WOLFSSL_ASYNC_CRYPT
/* if async would block return WANT_WRITE */
if (ssl->error == WC_PENDING_E) {
@ -13956,7 +13956,7 @@ startScr:
int err;
ssl->secure_renegotiation->startScr = 0; /* only start once */
WOLFSSL_MSG("Need to start scr, server requested");
if ( (err = wolfSSL_Rehandshake(ssl)) != SSL_SUCCESS)
if ( (err = wolfSSL_Rehandshake(ssl)) != WOLF_SSL_SUCCESS)
return err;
}
#endif
@ -14204,7 +14204,7 @@ const char* wolfSSL_ERR_reason_error_string(unsigned long e)
return "peer subject name mismatch";
case WANT_READ :
case SSL_ERROR_WANT_READ :
case WOLF_SSL_ERROR_WANT_READ :
return "non-blocking socket wants data to be read";
case NOT_READY_ERROR :
@ -14217,7 +14217,7 @@ const char* wolfSSL_ERR_reason_error_string(unsigned long e)
return "record layer version error";
case WANT_WRITE :
case SSL_ERROR_WANT_WRITE :
case WOLF_SSL_ERROR_WANT_WRITE :
return "non-blocking socket write buffer full";
case BUFFER_ERROR :
@ -14278,7 +14278,7 @@ const char* wolfSSL_ERR_reason_error_string(unsigned long e)
return "cant decode peer key";
case ZERO_RETURN:
case SSL_ERROR_ZERO_RETURN:
case WOLF_SSL_ERROR_ZERO_RETURN:
return "peer sent close notify alert";
case ECC_CURVETYPE_ERROR:
@ -16331,7 +16331,7 @@ void PickHashSigAlgo(WOLFSSL* ssl, const byte* hashSigAlgo,
if (ticket == NULL) return MEMORY_E;
ret = TLSX_UseSessionTicket(&ssl->extensions, ticket, ssl->heap);
if (ret != SSL_SUCCESS) return ret;
if (ret != WOLF_SSL_SUCCESS) return ret;
idSz = 0;
}
@ -22372,12 +22372,12 @@ static int DoSessionTicket(WOLFSSL* ssl, const byte* input, word32* inOutIdx,
#endif /* NO_SHA && NO_SHA256 */
#if !defined(NO_SHA) && defined(NO_SHA256)
cookieType = SHA;
cookieSz = SHA_DIGEST_SIZE;
cookieType = WC_SHA;
cookieSz = WC_SHA_DIGEST_SIZE;
#endif /* NO_SHA */
#ifndef NO_SHA256
cookieType = SHA256;
cookieSz = SHA256_DIGEST_SIZE;
cookieType = WC_SHA256;
cookieSz = WC_SHA256_DIGEST_SIZE;
#endif /* NO_SHA256 */
ret = wc_HmacSetKey(&cookieHmac, cookieType,
ssl->buffers.dtlsCookieSecret.buffer,
@ -22605,7 +22605,7 @@ static int DoSessionTicket(WOLFSSL* ssl, const byte* input, word32* inOutIdx,
int ret = 0;
ret = TLSX_AddEmptyRenegotiationInfo(&ssl->extensions, ssl->heap);
if (ret != SSL_SUCCESS)
if (ret != WOLF_SSL_SUCCESS)
return ret;
}
#endif /* HAVE_SERVER_RENEGOTIATION_INFO */
@ -23622,7 +23622,7 @@ static int DoSessionTicket(WOLFSSL* ssl, const byte* input, word32* inOutIdx,
if (ssl->options.side != WOLFSSL_SERVER_END) {
WOLFSSL_MSG("Client received client keyexchange, attack?");
WOLFSSL_ERROR(ssl->error = SIDE_ERROR);
ERROR_OUT(SSL_FATAL_ERROR, exit_dcke);
ERROR_OUT(WOLF_SSL_FATAL_ERROR, exit_dcke);
}
if (ssl->options.clientState < CLIENT_HELLO_COMPLETE) {

280
src/keys.c
View File

File diff suppressed because it is too large Load Diff

16
src/ocsp.c
View File

@ -471,11 +471,11 @@ int wolfSSL_OCSP_resp_find_status(WOLFSSL_OCSP_BASICRESP *bs,
WOLFSSL_ASN1_TIME** nextupd)
{
if (bs == NULL || id == NULL)
return SSL_FAILURE;
return WOLF_SSL_FAILURE;
/* Only supporting one certificate status in asn.c. */
if (CompareOcspReqResp(id, bs) != 0)
return SSL_FAILURE;
return WOLF_SSL_FAILURE;
if (status != NULL)
*status = bs->status->status;
@ -490,7 +490,7 @@ int wolfSSL_OCSP_resp_find_status(WOLFSSL_OCSP_BASICRESP *bs,
if (revtime != NULL)
*revtime = NULL;
return SSL_SUCCESS;
return WOLF_SSL_SUCCESS;
}
const char *wolfSSL_OCSP_cert_status_str(long s)
@ -515,7 +515,7 @@ int wolfSSL_OCSP_check_validity(WOLFSSL_ASN1_TIME* thisupd,
(void)sec;
(void)maxsec;
/* Dates validated in DecodeSingleResponse. */
return SSL_SUCCESS;
return WOLF_SSL_SUCCESS;
}
void wolfSSL_OCSP_CERTID_free(WOLFSSL_OCSP_CERTID* certId)
@ -581,19 +581,19 @@ void wolfSSL_OCSP_BASICRESP_free(WOLFSSL_OCSP_BASICRESP* basicResponse)
/* Signature verified in DecodeBasicOcspResponse.
* But no store available to verify certificate. */
int wolfSSL_OCSP_basic_verify(WOLFSSL_OCSP_BASICRESP *bs,
STACK_OF(WOLFSSL_X509) *certs, WOLFSSL_X509_STORE *st, unsigned long flags)
WOLF_STACK_OF(WOLFSSL_X509) *certs, WOLFSSL_X509_STORE *st, unsigned long flags)
{
DecodedCert cert;
int ret = SSL_SUCCESS;
int ret = WOLF_SSL_SUCCESS;
(void)certs;
if (flags & OCSP_NOVERIFY)
return SSL_SUCCESS;
return WOLF_SSL_SUCCESS;
InitDecodedCert(&cert, bs->cert, bs->certSz, NULL);
if (ParseCertRelative(&cert, CERT_TYPE, VERIFY, st->cm) < 0)
ret = SSL_FAILURE;
ret = WOLF_SSL_FAILURE;
FreeDecodedCert(&cert);
return ret;

30
src/sniffer.c
View File

@ -339,17 +339,17 @@ typedef struct FinCaputre {
typedef struct HsHashes {
#ifndef NO_OLD_TLS
#ifndef NO_SHA
Sha hashSha;
wc_Sha hashSha;
#endif
#ifndef NO_MD5
Md5 hashMd5;
wc_Md5 hashMd5;
#endif
#endif
#ifndef NO_SHA256
Sha256 hashSha256;
wc_Sha256 hashSha256;
#endif
#ifdef WOLFSSL_SHA384
Sha384 hashSha384;
wc_Sha384 hashSha384;
#endif
} HsHashes;
@ -619,18 +619,18 @@ static int HashCopy(HS_Hashes* d, HsHashes* s)
{
#ifndef NO_OLD_TLS
#ifndef NO_SHA
XMEMCPY(&d->hashSha, &s->hashSha, sizeof(Sha));
XMEMCPY(&d->hashSha, &s->hashSha, sizeof(wc_Sha));
#endif
#ifndef NO_MD5
XMEMCPY(&d->hashMd5, &s->hashMd5, sizeof(Md5));
XMEMCPY(&d->hashMd5, &s->hashMd5, sizeof(wc_Md5));
#endif
#endif
#ifndef NO_SHA256
XMEMCPY(&d->hashSha256, &s->hashSha256, sizeof(Sha256));
XMEMCPY(&d->hashSha256, &s->hashSha256, sizeof(wc_Sha256));
#endif
#ifdef WOLFSSL_SHA384
XMEMCPY(&d->hashSha384, &s->hashSha384, sizeof(Sha384));
XMEMCPY(&d->hashSha384, &s->hashSha384, sizeof(wc_Sha384));
#endif
return 0;
@ -1183,7 +1183,7 @@ static int LoadKeyFile(byte** keyBuf, word32* keyBufSz,
return -1;
}
if (typeKey == SSL_FILETYPE_PEM) {
if (typeKey == WOLF_SSL_FILETYPE_PEM) {
byte* saveBuf = (byte*)malloc(fileSz);
int saveBufSz = 0;
@ -1228,8 +1228,8 @@ static int SetNamedPrivateKey(const char* name, const char* address, int port,
{
SnifferServer* sniffer;
int ret;
int type = (typeKey == FILETYPE_PEM) ? SSL_FILETYPE_PEM :
SSL_FILETYPE_ASN1;
int type = (typeKey == FILETYPE_PEM) ? WOLF_SSL_FILETYPE_PEM :
WOLF_SSL_FILETYPE_ASN1;
int isNew = 0;
word32 serverIp;
@ -1306,7 +1306,7 @@ static int SetNamedPrivateKey(const char* name, const char* address, int port,
sniffer->ctx, (void*)password);
}
ret = SSL_CTX_use_PrivateKey_file(sniffer->ctx, keyFile, type);
if (ret != SSL_SUCCESS) {
if (ret != WOLF_SSL_SUCCESS) {
SetError(KEY_FILE_STR, error, NULL, 0);
if (isNew)
FreeSnifferServer(sniffer);
@ -1825,7 +1825,7 @@ static int ProcessClientHello(const byte* input, int* sslBytes,
*sslBytes + HANDSHAKE_HEADER_SZ + RECORD_HEADER_SZ,
WOLFSSL_SNI_HOST_NAME, name, &nameSz);
if (ret == SSL_SUCCESS) {
if (ret == WOLF_SSL_SUCCESS) {
NamedKey* namedKey;
if (nameSz >= sizeof(name))
@ -1838,7 +1838,7 @@ static int ProcessClientHello(const byte* input, int* sslBytes,
XSTRNCMP((char*)name, namedKey->name, nameSz) == 0) {
if (wolfSSL_use_PrivateKey_buffer(session->sslServer,
namedKey->key, namedKey->keySz,
SSL_FILETYPE_ASN1) != SSL_SUCCESS) {
WOLF_SSL_FILETYPE_ASN1) != WOLF_SSL_SUCCESS) {
wc_UnLockMutex(&session->context->namedKeysMutex);
SetError(CLIENT_HELLO_LATE_KEY_STR, error, session,
FATAL_ERROR_STATE);
@ -3596,7 +3596,7 @@ int ssl_GetSessionStats(unsigned int* active, unsigned int* total,
ret = wolfSSL_get_session_stats(active, total, peak, maxSessions);
if (ret == SSL_SUCCESS)
if (ret == WOLF_SSL_SUCCESS)
return 0;
else {
SetError(BAD_SESSION_STATS, error, NULL, 0);

2308
src/ssl.c
View File

File diff suppressed because it is too large Load Diff

160
src/tls.c
View File

@ -73,9 +73,9 @@
#ifdef WOLFSSL_SHA384
#define P_HASH_MAX_SIZE SHA384_DIGEST_SIZE
#define P_HASH_MAX_SIZE WC_SHA384_DIGEST_SIZE
#else
#define P_HASH_MAX_SIZE SHA256_DIGEST_SIZE
#define P_HASH_MAX_SIZE WC_SHA256_DIGEST_SIZE
#endif
@ -118,30 +118,30 @@ static int p_hash(byte* result, word32 resLen, const byte* secret,
switch (hash) {
#ifndef NO_MD5
case md5_mac:
hash = MD5;
len = MD5_DIGEST_SIZE;
hash = WC_MD5;
len = WC_MD5_DIGEST_SIZE;
break;
#endif
#ifndef NO_SHA256
case sha256_mac:
hash = SHA256;
len = SHA256_DIGEST_SIZE;
hash = WC_SHA256;
len = WC_SHA256_DIGEST_SIZE;
break;
#endif
#ifdef WOLFSSL_SHA384
case sha384_mac:
hash = SHA384;
len = SHA384_DIGEST_SIZE;
hash = WC_SHA384;
len = WC_SHA384_DIGEST_SIZE;
break;
#endif
#ifndef NO_SHA
case sha_mac:
default:
hash = SHA;
len = SHA_DIGEST_SIZE;
hash = WC_SHA;
len = WC_SHA_DIGEST_SIZE;
break;
#endif
}
@ -347,7 +347,7 @@ static int PRF(byte* digest, word32 digLen, const byte* secret, word32 secLen,
}
#ifdef WOLFSSL_SHA384
#define HSHASH_SZ SHA384_DIGEST_SIZE
#define HSHASH_SZ WC_SHA384_DIGEST_SIZE
#else
#define HSHASH_SZ FINISHED_SZ
#endif
@ -362,7 +362,7 @@ int BuildTlsHandshakeHash(WOLFSSL* ssl, byte* hash, word32* hashLen)
#ifndef NO_OLD_TLS
wc_Md5GetHash(&ssl->hsHashes->hashMd5, hash);
wc_ShaGetHash(&ssl->hsHashes->hashSha, &hash[MD5_DIGEST_SIZE]);
wc_ShaGetHash(&ssl->hsHashes->hashSha, &hash[WC_MD5_DIGEST_SIZE]);
#endif
if (IsAtLeastTLSv1_2(ssl)) {
@ -374,7 +374,7 @@ int BuildTlsHandshakeHash(WOLFSSL* ssl, byte* hash, word32* hashLen)
if (ret != 0)
return ret;
hashSz = SHA256_DIGEST_SIZE;
hashSz = WC_SHA256_DIGEST_SIZE;
}
#endif
#ifdef WOLFSSL_SHA384
@ -384,7 +384,7 @@ int BuildTlsHandshakeHash(WOLFSSL* ssl, byte* hash, word32* hashLen)
if (ret != 0)
return ret;
hashSz = SHA384_DIGEST_SIZE;
hashSz = WC_SHA384_DIGEST_SIZE;
}
#endif
}
@ -805,26 +805,26 @@ int wolfSSL_GetHmacType(WOLFSSL* ssl)
#ifndef NO_MD5
case md5_mac:
{
return MD5;
return WC_MD5;
}
#endif
#ifndef NO_SHA256
case sha256_mac:
{
return SHA256;
return WC_SHA256;
}
#endif
#ifdef WOLFSSL_SHA384
case sha384_mac:
{
return SHA384;
return WC_SHA384;
}
#endif
#ifndef NO_SHA
case sha_mac:
{
return SHA;
return WC_SHA;
}
#endif
#ifdef HAVE_BLAKE2
@ -835,7 +835,7 @@ int wolfSSL_GetHmacType(WOLFSSL* ssl)
#endif
default:
{
return SSL_FATAL_ERROR;
return WOLF_SSL_FATAL_ERROR;
}
}
}
@ -1173,7 +1173,7 @@ static int TLSX_SetALPN(TLSX** extensions, const void* data, word16 size,
return ret;
}
return SSL_SUCCESS;
return WOLF_SSL_SUCCESS;
}
/** Parses a buffer of ALPN extensions and set the first one matching
@ -1207,7 +1207,7 @@ static int TLSX_ALPN_ParseAndSet(WOLFSSL *ssl, byte *input, word16 length,
ssl->alpnSelectArg) == 0) {
WOLFSSL_MSG("ALPN protocol match");
if (TLSX_UseALPN(&ssl->extensions, (char*)out, outLen, 0, ssl->heap)
== SSL_SUCCESS) {
== WOLF_SSL_SUCCESS) {
if (extension == NULL) {
extension = TLSX_Find(ssl->extensions,
TLSX_APPLICATION_LAYER_PROTOCOL);
@ -1287,7 +1287,7 @@ static int TLSX_ALPN_ParseAndSet(WOLFSSL *ssl, byte *input, word16 length,
alpn->protocol_name,
(word16)XSTRLEN(alpn->protocol_name),
ssl->heap);
if (r != SSL_SUCCESS) {
if (r != WOLF_SSL_SUCCESS) {
WOLFSSL_MSG("TLSX_UseALPN failed");
return BUFFER_ERROR;
}
@ -1337,7 +1337,7 @@ int TLSX_UseALPN(TLSX** extensions, const void* data, word16 size, byte options,
extension->data = (void*)alpn;
}
return SSL_SUCCESS;
return WOLF_SSL_SUCCESS;
}
/** Get the protocol name set by the server */
@ -1360,7 +1360,7 @@ int TLSX_ALPN_GetRequest(TLSX* extensions, void** data, word16 *dataSz)
WOLFSSL_MSG("ALPN extension not found");
*data = NULL;
*dataSz = 0;
return SSL_FATAL_ERROR;
return WOLF_SSL_FATAL_ERROR;
}
if (alpn->negotiated != 1) {
@ -1368,7 +1368,7 @@ int TLSX_ALPN_GetRequest(TLSX* extensions, void** data, word16 *dataSz)
/* consider as an error */
if (alpn->options & WOLFSSL_ALPN_FAILED_ON_MISMATCH) {
WOLFSSL_MSG("No protocol match with peer -> Failed");
return SSL_FATAL_ERROR;
return WOLF_SSL_FATAL_ERROR;
}
/* continue without negotiated protocol */
@ -1378,13 +1378,13 @@ int TLSX_ALPN_GetRequest(TLSX* extensions, void** data, word16 *dataSz)
if (alpn->next != NULL) {
WOLFSSL_MSG("Only one protocol name must be accepted");
return SSL_FATAL_ERROR;
return WOLF_SSL_FATAL_ERROR;
}
*data = alpn->protocol_name;
*dataSz = (word16)XSTRLEN((char*)*data);
return SSL_SUCCESS;
return WOLF_SSL_SUCCESS;
}
#define ALPN_FREE_ALL TLSX_ALPN_FreeAll
@ -1641,7 +1641,7 @@ static int TLSX_SNI_Parse(WOLFSSL* ssl, byte* input, word16 length,
int r = TLSX_UseSNI(&ssl->extensions,
type, input + offset, size, ssl->heap);
if (r != SSL_SUCCESS)
if (r != WOLF_SSL_SUCCESS)
return r; /* throws error. */
if(cacheOnly) {
@ -1760,7 +1760,7 @@ int TLSX_UseSNI(TLSX** extensions, byte type, const void* data, word16 size,
} while ((sni = sni->next));
}
return SSL_SUCCESS;
return WOLF_SSL_SUCCESS;
}
#ifndef NO_WOLFSSL_SERVER
@ -1935,7 +1935,7 @@ int TLSX_SNI_GetFromBuffer(const byte* clientHello, word32 helloSz,
*inOutSz = min(sniLen, *inOutSz);
XMEMCPY(sni, clientHello + offset, *inOutSz);
return SSL_SUCCESS;
return WOLF_SSL_SUCCESS;
}
}
@ -2001,7 +2001,7 @@ static int TLSX_MFL_Parse(WOLFSSL* ssl, byte* input, word16 length,
if (isRequest) {
int r = TLSX_UseMaxFragment(&ssl->extensions, *input, ssl->heap);
if (r != SSL_SUCCESS) return r; /* throw error */
if (r != WOLF_SSL_SUCCESS) return r; /* throw error */
TLSX_SetResponse(ssl, TLSX_MAX_FRAGMENT_LENGTH);
}
@ -2033,7 +2033,7 @@ int TLSX_UseMaxFragment(TLSX** extensions, byte mfl, void* heap)
return ret;
}
return SSL_SUCCESS;
return WOLF_SSL_SUCCESS;
}
@ -2069,7 +2069,7 @@ static int TLSX_THM_Parse(WOLFSSL* ssl, byte* input, word16 length,
if (isRequest) {
int r = TLSX_UseTruncatedHMAC(&ssl->extensions, ssl->heap);
if (r != SSL_SUCCESS)
if (r != WOLF_SSL_SUCCESS)
return r; /* throw error */
TLSX_SetResponse(ssl, TLSX_TRUNCATED_HMAC);
@ -2091,7 +2091,7 @@ int TLSX_UseTruncatedHMAC(TLSX** extensions, void* heap)
if ((ret = TLSX_Push(extensions, TLSX_TRUNCATED_HMAC, NULL, heap)) != 0)
return ret;
return SSL_SUCCESS;
return WOLF_SSL_SUCCESS;
}
#define THM_PARSE TLSX_THM_Parse
@ -2209,7 +2209,7 @@ static int TLSX_CSR_Parse(WOLFSSL* ssl, byte* input, word16 length,
ret = TLSX_UseCertificateStatusRequest(&ssl->extensions,
csr->status_type, csr->options, ssl->heap,
ssl->devId);
if (ret != SSL_SUCCESS)
if (ret != WOLF_SSL_SUCCESS)
return ret;
switch (csr->status_type) {
@ -2285,7 +2285,7 @@ static int TLSX_CSR_Parse(WOLFSSL* ssl, byte* input, word16 length,
/* accept the first good status_type and return */
ret = TLSX_UseCertificateStatusRequest(&ssl->extensions, status_type,
0, ssl->heap, ssl->devId);
if (ret != SSL_SUCCESS)
if (ret != WOLF_SSL_SUCCESS)
return ret; /* throw error */
TLSX_SetResponse(ssl, TLSX_STATUS_REQUEST);
@ -2415,7 +2415,7 @@ int TLSX_UseCertificateStatusRequest(TLSX** extensions, byte status_type,
return ret;
}
return SSL_SUCCESS;
return WOLF_SSL_SUCCESS;
}
#define CSR_FREE_ALL TLSX_CSR_Free
@ -2573,7 +2573,7 @@ static int TLSX_CSR2_Parse(WOLFSSL* ssl, byte* input, word16 length,
for (; csr2; csr2 = csr2->next) {
ret = TLSX_UseCertificateStatusRequestV2(&ssl->extensions,
csr2->status_type, csr2->options, ssl->heap, ssl->devId);
if (ret != SSL_SUCCESS)
if (ret != WOLF_SSL_SUCCESS)
return ret;
switch (csr2->status_type) {
@ -2672,7 +2672,7 @@ static int TLSX_CSR2_Parse(WOLFSSL* ssl, byte* input, word16 length,
/* accept the first good status_type and return */
ret = TLSX_UseCertificateStatusRequestV2(&ssl->extensions,
status_type, 0, ssl->heap, ssl->devId);
if (ret != SSL_SUCCESS)
if (ret != WOLF_SSL_SUCCESS)
return ret; /* throw error */
TLSX_SetResponse(ssl, TLSX_STATUS_REQUEST_V2);
@ -2845,7 +2845,7 @@ int TLSX_UseCertificateStatusRequestV2(TLSX** extensions, byte status_type,
return ret;
}
return SSL_SUCCESS;
return WOLF_SSL_SUCCESS;
}
#define CSR2_FREE_ALL TLSX_CSR2_FreeAll
@ -2984,7 +2984,7 @@ static int TLSX_EllipticCurve_Parse(WOLFSSL* ssl, byte* input, word16 length,
r = TLSX_UseSupportedCurve(&ssl->extensions, name, ssl->heap);
if (r != SSL_SUCCESS) return r; /* throw error */
if (r != WOLF_SSL_SUCCESS) return r; /* throw error */
}
return 0;
@ -3320,7 +3320,7 @@ int TLSX_UseSupportedCurve(TLSX** extensions, word16 name, void* heap)
} while ((curve = curve->next));
}
return SSL_SUCCESS;
return WOLF_SSL_SUCCESS;
}
#define EC_FREE_ALL TLSX_EllipticCurve_FreeAll
@ -3412,7 +3412,7 @@ static int TLSX_SecureRenegotiation_Parse(WOLFSSL* ssl, byte* input,
TLSX_RENEGOTIATION_INFO) == NULL) {
ret = TLSX_AddEmptyRenegotiationInfo(&ssl->extensions,
ssl->heap);
if (ret == SSL_SUCCESS)
if (ret == WOLF_SSL_SUCCESS)
ret = 0;
} else {
@ -3494,7 +3494,7 @@ int TLSX_UseSecureRenegotiation(TLSX** extensions, void* heap)
return ret;
}
return SSL_SUCCESS;
return WOLF_SSL_SUCCESS;
}
#ifdef HAVE_SERVER_RENEGOTIATION_INFO
@ -3512,7 +3512,7 @@ int TLSX_AddEmptyRenegotiationInfo(TLSX** extensions, void* heap)
if (ext)
ext->resp = 1;
return SSL_SUCCESS;
return WOLF_SSL_SUCCESS;
}
#endif /* HAVE_SERVER_RENEGOTIATION_INFO */
@ -3603,7 +3603,7 @@ static int TLSX_SessionTicket_Parse(WOLFSSL* ssl, byte* input, word16 length,
if (length == 0) {
/* blank ticket */
ret = TLSX_UseSessionTicket(&ssl->extensions, NULL, ssl->heap);
if (ret == SSL_SUCCESS) {
if (ret == WOLF_SSL_SUCCESS) {
ret = 0;
TLSX_SetResponse(ssl, TLSX_SESSION_TICKET); /* send blank ticket */
ssl->options.createTicket = 1; /* will send ticket msg */
@ -3621,7 +3621,7 @@ static int TLSX_SessionTicket_Parse(WOLFSSL* ssl, byte* input, word16 length,
} else if (ret == WOLFSSL_TICKET_RET_CREATE) {
WOLFSSL_MSG("Using existing client ticket, creating new one");
ret = TLSX_UseSessionTicket(&ssl->extensions, NULL, ssl->heap);
if (ret == SSL_SUCCESS) {
if (ret == WOLF_SSL_SUCCESS) {
ret = 0;
TLSX_SetResponse(ssl, TLSX_SESSION_TICKET);
/* send blank ticket */
@ -3685,7 +3685,7 @@ int TLSX_UseSessionTicket(TLSX** extensions, SessionTicket* ticket, void* heap)
!= 0)
return ret;
return SSL_SUCCESS;
return WOLF_SSL_SUCCESS;
}
#define WOLF_STK_VALIDATE_REQUEST TLSX_SessionTicket_ValidateRequest
@ -3999,7 +3999,7 @@ static int TLSX_QSH_Parse(WOLFSSL* ssl, byte* input, word16 length,
/* peer sent an agreed upon scheme */
r = TLSX_UseQSHScheme(&ssl->extensions, name, NULL, 0, ssl->heap);
if (r != SSL_SUCCESS) return r; /* throw error */
if (r != WOLF_SSL_SUCCESS) return r; /* throw error */
numKeys--;
}
@ -4070,7 +4070,7 @@ static int TLSX_QSH_Parse(WOLFSSL* ssl, byte* input, word16 length,
XFREE(temp, ssl->heap, DYNAMIC_TYPE_TLSX);
}
if (r != SSL_SUCCESS) {return r;} /* throw error */
if (r != WOLF_SSL_SUCCESS) {return r;} /* throw error */
numKeys--;
}
@ -4266,7 +4266,7 @@ int TLSX_UseQSHScheme(TLSX** extensions, word16 name, byte* pKey, word16 pkeySz,
} while ((format = format->next));
}
}
return SSL_SUCCESS;
return WOLF_SSL_SUCCESS;
}
#define QSH_FREE_ALL TLSX_QSH_FreeAll
@ -6201,7 +6201,7 @@ static int TLSX_PreSharedKey_Parse(WOLFSSL* ssl, byte* input, word16 length,
while (list != NULL && len > 0) {
/* Length of binder */
list->binderLen = input[idx++];
if (list->binderLen < SHA256_DIGEST_SIZE ||
if (list->binderLen < WC_SHA256_DIGEST_SIZE ||
list->binderLen > MAX_DIGEST_SIZE)
return BUFFER_E;
if (len < OPAQUE8_LEN + list->binderLen)
@ -6309,15 +6309,15 @@ static INLINE byte GetHmacLength(int hmac)
switch (hmac) {
#ifndef NO_SHA256
case sha256_mac:
return SHA256_DIGEST_SIZE;
return WC_SHA256_DIGEST_SIZE;
#endif
#ifndef NO_SHA384
case sha384_mac:
return SHA384_DIGEST_SIZE;
return WC_SHA384_DIGEST_SIZE;
#endif
#ifndef NO_SHA512
case sha512_mac:
return SHA512_DIGEST_SIZE;
return WC_SHA512_DIGEST_SIZE;
#endif
}
return 0;
@ -7398,7 +7398,7 @@ int TLSX_PopulateExtensions(WOLFSSL* ssl, byte isServer)
}
if (TLSX_UseQSHScheme(&ssl->extensions, WOLFSSL_NTRU_EESS743,
public_key, public_key_len, ssl->heap)
!= SSL_SUCCESS)
!= WOLF_SSL_SUCCESS)
ret = -1;
/* add NTRU 196 */
@ -7408,7 +7408,7 @@ int TLSX_PopulateExtensions(WOLFSSL* ssl, byte isServer)
}
if (TLSX_UseQSHScheme(&ssl->extensions, WOLFSSL_NTRU_EESS593,
public_key, public_key_len, ssl->heap)
!= SSL_SUCCESS)
!= WOLF_SSL_SUCCESS)
ret = -1;
/* add NTRU 128 */
@ -7418,7 +7418,7 @@ int TLSX_PopulateExtensions(WOLFSSL* ssl, byte isServer)
}
if (TLSX_UseQSHScheme(&ssl->extensions, WOLFSSL_NTRU_EESS439,
public_key, public_key_len, ssl->heap)
!= SSL_SUCCESS)
!= WOLF_SSL_SUCCESS)
ret = -1;
}
else if (ssl->sendQSHKeys && ssl->QSH_Key == NULL) {
@ -7439,7 +7439,7 @@ int TLSX_PopulateExtensions(WOLFSSL* ssl, byte isServer)
&public_key_len, qsh->name);
if (TLSX_UseQSHScheme(&ssl->extensions, qsh->name,
public_key, public_key_len,
ssl->heap) != SSL_SUCCESS)
ssl->heap) != WOLF_SSL_SUCCESS)
ret = -1;
qsh = next;
}
@ -7455,29 +7455,29 @@ int TLSX_PopulateExtensions(WOLFSSL* ssl, byte isServer)
#ifndef NO_ECC_SECP
ret = TLSX_UseSupportedCurve(&ssl->extensions,
WOLFSSL_ECC_SECP160R1, ssl->heap);
if (ret != SSL_SUCCESS) return ret;
if (ret != WOLF_SSL_SUCCESS) return ret;
#endif
#ifdef HAVE_ECC_SECPR2
ret = TLSX_UseSupportedCurve(&ssl->extensions,
WOLFSSL_ECC_SECP160R2, ssl->heap);
if (ret != SSL_SUCCESS) return ret;
if (ret != WOLF_SSL_SUCCESS) return ret;
#endif
#ifdef HAVE_ECC_KOBLITZ
ret = TLSX_UseSupportedCurve(&ssl->extensions,
WOLFSSL_ECC_SECP160K1, ssl->heap);
if (ret != SSL_SUCCESS) return ret;
if (ret != WOLF_SSL_SUCCESS) return ret;
#endif
#endif
#if defined(HAVE_ECC192) || defined(HAVE_ALL_CURVES)
#ifndef NO_ECC_SECP
ret = TLSX_UseSupportedCurve(&ssl->extensions,
WOLFSSL_ECC_SECP192R1, ssl->heap);
if (ret != SSL_SUCCESS) return ret;
if (ret != WOLF_SSL_SUCCESS) return ret;
#endif
#ifdef HAVE_ECC_KOBLITZ
ret = TLSX_UseSupportedCurve(&ssl->extensions,
WOLFSSL_ECC_SECP192K1, ssl->heap);
if (ret != SSL_SUCCESS) return ret;
if (ret != WOLF_SSL_SUCCESS) return ret;
#endif
#endif
#endif
@ -7485,60 +7485,60 @@ int TLSX_PopulateExtensions(WOLFSSL* ssl, byte isServer)
#ifndef NO_ECC_SECP
ret = TLSX_UseSupportedCurve(&ssl->extensions,
WOLFSSL_ECC_SECP224R1, ssl->heap);
if (ret != SSL_SUCCESS) return ret;
if (ret != WOLF_SSL_SUCCESS) return ret;
#endif
#ifdef HAVE_ECC_KOBLITZ
ret = TLSX_UseSupportedCurve(&ssl->extensions,
WOLFSSL_ECC_SECP224K1, ssl->heap);
if (ret != SSL_SUCCESS) return ret;
if (ret != WOLF_SSL_SUCCESS) return ret;
#endif
#endif
#if !defined(NO_ECC256) || defined(HAVE_ALL_CURVES)
#ifndef NO_ECC_SECP
ret = TLSX_UseSupportedCurve(&ssl->extensions,
WOLFSSL_ECC_SECP256R1, ssl->heap);
if (ret != SSL_SUCCESS) return ret;
if (ret != WOLF_SSL_SUCCESS) return ret;
#endif
#if defined(HAVE_CURVE25519)
ret = TLSX_UseSupportedCurve(&ssl->extensions,
WOLFSSL_ECC_X25519, ssl->heap);
if (ret != SSL_SUCCESS) return ret;
if (ret != WOLF_SSL_SUCCESS) return ret;
#endif
#ifdef HAVE_ECC_KOBLITZ
ret = TLSX_UseSupportedCurve(&ssl->extensions,
WOLFSSL_ECC_SECP256K1, ssl->heap);
if (ret != SSL_SUCCESS) return ret;
if (ret != WOLF_SSL_SUCCESS) return ret;
#endif
#ifdef HAVE_ECC_BRAINPOOL
ret = TLSX_UseSupportedCurve(&ssl->extensions,
WOLFSSL_ECC_BRAINPOOLP256R1, ssl->heap);
if (ret != SSL_SUCCESS) return ret;
if (ret != WOLF_SSL_SUCCESS) return ret;
#endif
#endif
#if defined(HAVE_ECC384) || defined(HAVE_ALL_CURVES)
#ifndef NO_ECC_SECP
ret = TLSX_UseSupportedCurve(&ssl->extensions,
WOLFSSL_ECC_SECP384R1, ssl->heap);
if (ret != SSL_SUCCESS) return ret;
if (ret != WOLF_SSL_SUCCESS) return ret;
#endif
#ifdef HAVE_ECC_BRAINPOOL
ret = TLSX_UseSupportedCurve(&ssl->extensions,
WOLFSSL_ECC_BRAINPOOLP384R1, ssl->heap);
if (ret != SSL_SUCCESS) return ret;
if (ret != WOLF_SSL_SUCCESS) return ret;
#endif
#endif
#if defined(HAVE_ECC512) || defined(HAVE_ALL_CURVES)
#ifdef HAVE_ECC_BRAINPOOL
ret = TLSX_UseSupportedCurve(&ssl->extensions,
WOLFSSL_ECC_BRAINPOOLP512R1, ssl->heap);
if (ret != SSL_SUCCESS) return ret;
if (ret != WOLF_SSL_SUCCESS) return ret;
#endif
#endif
#if defined(HAVE_ECC521) || defined(HAVE_ALL_CURVES)
#ifndef NO_ECC_SECP
ret = TLSX_UseSupportedCurve(&ssl->extensions,
WOLFSSL_ECC_SECP521R1, ssl->heap);
if (ret != SSL_SUCCESS) return ret;
if (ret != WOLF_SSL_SUCCESS) return ret;
#endif
#endif
}
@ -7567,31 +7567,31 @@ int TLSX_PopulateExtensions(WOLFSSL* ssl, byte isServer)
#ifdef HAVE_FFDHE_2048
ret = TLSX_UseSupportedCurve(&ssl->extensions,
WOLFSSL_FFDHE_2048, ssl->heap);
if (ret != SSL_SUCCESS)
if (ret != WOLF_SSL_SUCCESS)
return ret;
#endif
#ifdef HAVE_FFDHE_3072
ret = TLSX_UseSupportedCurve(&ssl->extensions,
WOLFSSL_FFDHE_3072, ssl->heap);
if (ret != SSL_SUCCESS)
if (ret != WOLF_SSL_SUCCESS)
return ret;
#endif
#ifdef HAVE_FFDHE_4096
ret = TLSX_UseSupportedCurve(&ssl->extensions,
WOLFSSL_FFDHE_4096, ssl->heap);
if (ret != SSL_SUCCESS)
if (ret != WOLF_SSL_SUCCESS)
return ret;
#endif
#ifdef HAVE_FFDHE_6144
ret = TLSX_UseSupportedCurve(&ssl->extensions,
WOLFSSL_FFDHE_6144, ssl->heap);
if (ret != SSL_SUCCESS)
if (ret != WOLF_SSL_SUCCESS)
return ret;
#endif
#ifdef HAVE_FFDHE_8192
ret = TLSX_UseSupportedCurve(&ssl->extensions,
WOLFSSL_FFDHE_8192, ssl->heap);
if (ret != SSL_SUCCESS)
if (ret != WOLF_SSL_SUCCESS)
return ret;
#endif
ret = 0;
@ -7719,7 +7719,7 @@ int TLSX_PopulateExtensions(WOLFSSL* ssl, byte isServer)
(void)public_key_len;
(void)ssl;
if (ret == SSL_SUCCESS)
if (ret == WOLF_SSL_SUCCESS)
ret = 0;
return ret;

194
src/tls13.c
View File

@ -196,22 +196,22 @@ static int Tls13_HKDF_Extract(byte* prk, const byte* salt, int saltLen,
switch (mac) {
#ifndef NO_SHA256
case sha256_mac:
hash = SHA256;
len = SHA256_DIGEST_SIZE;
hash = WC_SHA256;
len = WC_SHA256_DIGEST_SIZE;
break;
#endif
#ifdef WOLFSSL_SHA384
case sha384_mac:
hash = SHA384;
len = SHA384_DIGEST_SIZE;
hash = WC_SHA384;
len = WC_SHA384_DIGEST_SIZE;
break;
#endif
#ifdef WOLFSSL_TLS13_TLS13_SHA512
case sha512_mac:
hash = SHA512;
len = SHA512_DIGEST_SIZE;
hash = WC_SHA512;
len = WC_SHA512_DIGEST_SIZE;
break;
#endif
}
@ -348,8 +348,8 @@ static int DeriveKeyMsg(WOLFSSL* ssl, byte* output, int outputLen,
ret = wc_Sha256Final(&digest.sha256, hash);
wc_Sha256Free(&digest.sha256);
}
hashSz = SHA256_DIGEST_SIZE;
digestAlg = SHA256;
hashSz = WC_SHA256_DIGEST_SIZE;
digestAlg = WC_SHA256;
break;
#endif
#ifdef WOLFSSL_SHA384
@ -361,8 +361,8 @@ static int DeriveKeyMsg(WOLFSSL* ssl, byte* output, int outputLen,
ret = wc_Sha384Final(&digest.sha384, hash);
wc_Sha384Free(&digest.sha384);
}
hashSz = SHA384_DIGEST_SIZE;
digestAlg = SHA384;
hashSz = WC_SHA384_DIGEST_SIZE;
digestAlg = WC_SHA384;
break;
#endif
#ifdef WOLFSSL_TLS13_SHA512
@ -374,8 +374,8 @@ static int DeriveKeyMsg(WOLFSSL* ssl, byte* output, int outputLen,
ret = wc_Sha512Final(&digest.sha512, hash);
wc_Sha512Free(&digest.sha512);
}
hashSz = SHA512_DIGEST_SIZE;
digestAlg = SHA512;
hashSz = WC_SHA512_DIGEST_SIZE;
digestAlg = WC_SHA512;
break;
#endif
}
@ -428,8 +428,8 @@ static int DeriveKey(WOLFSSL* ssl, byte* output, int outputLen,
switch (hashAlgo) {
#ifndef NO_SHA256
case sha256_mac:
hashSz = SHA256_DIGEST_SIZE;
digestAlg = SHA256;
hashSz = WC_SHA256_DIGEST_SIZE;
digestAlg = WC_SHA256;
if (includeMsgs)
ret = wc_Sha256GetHash(&ssl->hsHashes->hashSha256, hash);
break;
@ -437,8 +437,8 @@ static int DeriveKey(WOLFSSL* ssl, byte* output, int outputLen,
#ifdef WOLFSSL_SHA384
case sha384_mac:
hashSz = SHA384_DIGEST_SIZE;
digestAlg = SHA384;
hashSz = WC_SHA384_DIGEST_SIZE;
digestAlg = WC_SHA384;
if (includeMsgs)
ret = wc_Sha384GetHash(&ssl->hsHashes->hashSha384, hash);
break;
@ -446,8 +446,8 @@ static int DeriveKey(WOLFSSL* ssl, byte* output, int outputLen,
#ifdef WOLFSSL_TLS13_SHA512
case sha512_mac:
hashSz = SHA512_DIGEST_SIZE;
digestAlg = SHA512;
hashSz = WC_SHA512_DIGEST_SIZE;
digestAlg = WC_SHA512;
if (includeMsgs)
ret = wc_Sha512GetHash(&ssl->hsHashes->hashSha512, hash);
break;
@ -893,30 +893,30 @@ static int BuildTls13HandshakeHmac(WOLFSSL* ssl, byte* key, byte* hash,
word32* pHashSz)
{
Hmac verifyHmac;
int hashType = SHA256;
int hashSz = SHA256_DIGEST_SIZE;
int hashType = WC_SHA256;
int hashSz = WC_SHA256_DIGEST_SIZE;
int ret = BAD_FUNC_ARG;
/* Get the hash of the previous handshake messages. */
switch (ssl->specs.mac_algorithm) {
#ifndef NO_SHA256
case sha256_mac:
hashType = SHA256;
hashSz = SHA256_DIGEST_SIZE;
hashType = WC_SHA256;
hashSz = WC_SHA256_DIGEST_SIZE;
ret = wc_Sha256GetHash(&ssl->hsHashes->hashSha256, hash);
break;
#endif /* !NO_SHA256 */
#ifdef WOLFSSL_SHA384
case sha384_mac:
hashType = SHA384;
hashSz = SHA384_DIGEST_SIZE;
hashType = WC_SHA384;
hashSz = WC_SHA384_DIGEST_SIZE;
ret = wc_Sha384GetHash(&ssl->hsHashes->hashSha384, hash);
break;
#endif /* WOLFSSL_SHA384 */
#ifdef WOLFSSL_TLS13_SHA512
case sha512_mac:
hashType = SHA512;
hashSz = SHA512_DIGEST_SIZE;
hashType = WC_SHA512;
hashSz = WC_SHA512_DIGEST_SIZE;
ret = wc_Sha512GetHash(&ssl->hsHashes->hashSha512, hash);
break;
#endif /* WOLFSSL_TLS13_SHA512 */
@ -2392,11 +2392,11 @@ static int CreateCookie(WOLFSSL* ssl, byte* hash, byte hashSz)
#if !defined(NO_SHA) && defined(NO_SHA256)
cookieType = SHA;
macSz = SHA_DIGEST_SIZE;
macSz = WC_SHA_DIGEST_SIZE;
#endif /* NO_SHA */
#ifndef NO_SHA256
cookieType = SHA256;
macSz = SHA256_DIGEST_SIZE;
cookieType = WC_SHA256;
macSz = WC_SHA256_DIGEST_SIZE;
#endif /* NO_SHA256 */
ret = wc_HmacSetKey(&cookieHmac, cookieType,
@ -3133,11 +3133,11 @@ static int CheckCookie(WOLFSSL* ssl, byte* cookie, byte cookieSz)
#if !defined(NO_SHA) && defined(NO_SHA256)
cookieType = SHA;
macSz = SHA_DIGEST_SIZE;
macSz = WC_SHA_DIGEST_SIZE;
#endif /* NO_SHA */
#ifndef NO_SHA256
cookieType = SHA256;
macSz = SHA256_DIGEST_SIZE;
cookieType = WC_SHA256;
macSz = WC_SHA256_DIGEST_SIZE;
#endif /* NO_SHA256 */
if (cookieSz < ssl->specs.hash_size + macSz)
@ -3920,21 +3920,21 @@ static INLINE int GetMsgHash(WOLFSSL* ssl, byte* hash)
case sha256_mac:
ret = wc_Sha256GetHash(&ssl->hsHashes->hashSha256, hash);
if (ret == 0)
ret = SHA256_DIGEST_SIZE;
ret = WC_SHA256_DIGEST_SIZE;
break;
#endif /* !NO_SHA256 */
#ifdef WOLFSSL_SHA384
case sha384_mac:
ret = wc_Sha384GetHash(&ssl->hsHashes->hashSha384, hash);
if (ret == 0)
ret = SHA384_DIGEST_SIZE;
ret = WC_SHA384_DIGEST_SIZE;
break;
#endif /* WOLFSSL_SHA384 */
#ifdef WOLFSSL_TLS13_SHA512
case sha512_mac:
ret = wc_Sha512GetHash(&ssl->hsHashes->hashSha512, hash);
if (ret == 0)
ret = SHA512_DIGEST_SIZE;
ret = WC_SHA512_DIGEST_SIZE;
break;
#endif /* WOLFSSL_TLS13_SHA512 */
}
@ -4029,7 +4029,7 @@ static int CreateRSAEncodedSig(byte* sig, byte* sigData, int sigDataSz,
ret = wc_Sha256Final(&digest.sha256, hash);
wc_Sha256Free(&digest.sha256);
}
hashSz = SHA256_DIGEST_SIZE;
hashSz = WC_SHA256_DIGEST_SIZE;
break;
#endif
#ifdef WOLFSSL_SHA384
@ -4041,7 +4041,7 @@ static int CreateRSAEncodedSig(byte* sig, byte* sigData, int sigDataSz,
ret = wc_Sha384Final(&digest.sha384, hash);
wc_Sha384Free(&digest.sha384);
}
hashSz = SHA384_DIGEST_SIZE;
hashSz = WC_SHA384_DIGEST_SIZE;
break;
#endif
#ifdef WOLFSSL_SHA512
@ -4053,7 +4053,7 @@ static int CreateRSAEncodedSig(byte* sig, byte* sigData, int sigDataSz,
ret = wc_Sha512Final(&digest.sha512, hash);
wc_Sha512Free(&digest.sha512);
}
hashSz = SHA512_DIGEST_SIZE;
hashSz = WC_SHA512_DIGEST_SIZE;
break;
#endif
}
@ -4090,7 +4090,7 @@ static int CreateECCEncodedSig(byte* sigData, int sigDataSz, int hashAlgo)
ret = wc_Sha256Final(&digest.sha256, sigData);
wc_Sha256Free(&digest.sha256);
}
hashSz = SHA256_DIGEST_SIZE;
hashSz = WC_SHA256_DIGEST_SIZE;
break;
#endif
#ifdef WOLFSSL_SHA384
@ -4102,7 +4102,7 @@ static int CreateECCEncodedSig(byte* sigData, int sigDataSz, int hashAlgo)
ret = wc_Sha384Final(&digest.sha384, sigData);
wc_Sha384Free(&digest.sha384);
}
hashSz = SHA384_DIGEST_SIZE;
hashSz = WC_SHA384_DIGEST_SIZE;
break;
#endif
#ifdef WOLFSSL_SHA512
@ -4114,7 +4114,7 @@ static int CreateECCEncodedSig(byte* sigData, int sigDataSz, int hashAlgo)
ret = wc_Sha512Final(&digest.sha512, sigData);
wc_Sha512Free(&digest.sha512);
}
hashSz = SHA512_DIGEST_SIZE;
hashSz = WC_SHA512_DIGEST_SIZE;
break;
#endif
}
@ -6385,7 +6385,7 @@ int DoTls13HandShakeMsg(WOLFSSL* ssl, byte* input, word32* inOutIdx,
* Please see note at top of README if you get an error from connect.
*
* ssl The SSL/TLS object.
* returns SSL_SUCCESS on successful handshake, SSL_FATAL_ERROR when
* returns WOLF_SSL_SUCCESS on successful handshake, WOLF_SSL_FATAL_ERROR when
* unrecoverable error occurs and 0 otherwise.
* For more error information use wolfSSL_get_error().
*/
@ -6401,7 +6401,7 @@ int wolfSSL_connect_TLSv13(WOLFSSL* ssl)
if (ssl->options.side != WOLFSSL_CLIENT_END) {
WOLFSSL_ERROR(ssl->error = SIDE_ERROR);
return SSL_FATAL_ERROR;
return WOLF_SSL_FATAL_ERROR;
}
if (ssl->buffers.outputBuffer.length > 0) {
@ -6421,7 +6421,7 @@ int wolfSSL_connect_TLSv13(WOLFSSL* ssl)
}
else {
WOLFSSL_ERROR(ssl->error);
return SSL_FATAL_ERROR;
return WOLF_SSL_FATAL_ERROR;
}
}
@ -6431,7 +6431,7 @@ int wolfSSL_connect_TLSv13(WOLFSSL* ssl)
/* Always send client hello first. */
if ((ssl->error = SendTls13ClientHello(ssl)) != 0) {
WOLFSSL_ERROR(ssl->error);
return SSL_FATAL_ERROR;
return WOLF_SSL_FATAL_ERROR;
}
ssl->options.connectState = CLIENT_HELLO_SENT;
@ -6439,7 +6439,7 @@ int wolfSSL_connect_TLSv13(WOLFSSL* ssl)
#ifdef WOLFSSL_EARLY_DATA
if (ssl->earlyData) {
ssl->options.handShakeState = CLIENT_HELLO_COMPLETE;
return SSL_SUCCESS;
return WOLF_SSL_SUCCESS;
}
#endif
FALL_THROUGH;
@ -6451,7 +6451,7 @@ int wolfSSL_connect_TLSv13(WOLFSSL* ssl)
while (ssl->options.serverState < neededState) {
if ((ssl->error = ProcessReply(ssl)) < 0) {
WOLFSSL_ERROR(ssl->error);
return SSL_FATAL_ERROR;
return WOLF_SSL_FATAL_ERROR;
}
/* if resumption failed, reset needed state. */
if (neededState == SERVER_FINISHED_COMPLETE &&
@ -6466,7 +6466,7 @@ int wolfSSL_connect_TLSv13(WOLFSSL* ssl)
case HELLO_AGAIN:
if (ssl->options.certOnly)
return SSL_SUCCESS;
return WOLF_SSL_SUCCESS;
if (!ssl->options.tls1_3)
return wolfSSL_connect(ssl);
@ -6476,7 +6476,7 @@ int wolfSSL_connect_TLSv13(WOLFSSL* ssl)
/* Try again with different security parameters. */
if ((ssl->error = SendTls13ClientHello(ssl)) != 0) {
WOLFSSL_ERROR(ssl->error);
return SSL_FATAL_ERROR;
return WOLF_SSL_FATAL_ERROR;
}
}
@ -6494,7 +6494,7 @@ int wolfSSL_connect_TLSv13(WOLFSSL* ssl)
while (ssl->options.serverState < neededState) {
if ((ssl->error = ProcessReply(ssl)) < 0) {
WOLFSSL_ERROR(ssl->error);
return SSL_FATAL_ERROR;
return WOLF_SSL_FATAL_ERROR;
}
/* if resumption failed, reset needed state */
else if (neededState == SERVER_FINISHED_COMPLETE) {
@ -6513,7 +6513,7 @@ int wolfSSL_connect_TLSv13(WOLFSSL* ssl)
if (ssl->earlyData) {
if ((ssl->error = SendTls13EndOfEarlyData(ssl)) != 0) {
WOLFSSL_ERROR(ssl->error);
return SSL_FATAL_ERROR;
return WOLF_SSL_FATAL_ERROR;
}
WOLFSSL_MSG("sent: end_of_early_data");
}
@ -6529,7 +6529,7 @@ int wolfSSL_connect_TLSv13(WOLFSSL* ssl)
ssl->error = SendTls13Certificate(ssl);
if (ssl->error != 0) {
WOLFSSL_ERROR(ssl->error);
return SSL_FATAL_ERROR;
return WOLF_SSL_FATAL_ERROR;
}
WOLFSSL_MSG("sent: certificate");
}
@ -6546,7 +6546,7 @@ int wolfSSL_connect_TLSv13(WOLFSSL* ssl)
ssl->error = SendTls13CertificateVerify(ssl);
if (ssl->error != 0) {
WOLFSSL_ERROR(ssl->error);
return SSL_FATAL_ERROR;
return WOLF_SSL_FATAL_ERROR;
}
WOLFSSL_MSG("sent: certificate verify");
}
@ -6559,7 +6559,7 @@ int wolfSSL_connect_TLSv13(WOLFSSL* ssl)
case FIRST_REPLY_THIRD:
if ((ssl->error = SendTls13Finished(ssl)) != 0) {
WOLFSSL_ERROR(ssl->error);
return SSL_FATAL_ERROR;
return WOLF_SSL_FATAL_ERROR;
}
WOLFSSL_MSG("sent: finished");
@ -6574,17 +6574,17 @@ int wolfSSL_connect_TLSv13(WOLFSSL* ssl)
if (cbret < 0) {
ssl->error = cbret;
WOLFSSL_MSG("HandShake Done Cb don't continue error");
return SSL_FATAL_ERROR;
return WOLF_SSL_FATAL_ERROR;
}
}
#endif /* NO_HANDSHAKE_DONE_CB */
WOLFSSL_LEAVE("wolfSSL_connect_TLSv13()", SSL_SUCCESS);
return SSL_SUCCESS;
WOLFSSL_LEAVE("wolfSSL_connect_TLSv13()", WOLF_SSL_SUCCESS);
return WOLF_SSL_SUCCESS;
default:
WOLFSSL_MSG("Unknown connect state ERROR");
return SSL_FATAL_ERROR; /* unknown connect state */
return WOLF_SSL_FATAL_ERROR; /* unknown connect state */
}
}
@ -6597,7 +6597,7 @@ int wolfSSL_connect_TLSv13(WOLFSSL* ssl)
* secretSz Size of secret data in bytes.
* Use a value of 0 to indicate use of default size.
* returns BAD_FUNC_ARG when ssl is NULL or not using TLS v1.3, SIDE_ERROR when
* called on a client; SSL_SUCCESS on success and otherwise failure.
* called on a client; WOLF_SSL_SUCCESS on success and otherwise failure.
*/
int wolfSSL_send_hrr_cookie(WOLFSSL* ssl, const unsigned char* secret,
unsigned int secretSz)
@ -6611,10 +6611,10 @@ int wolfSSL_send_hrr_cookie(WOLFSSL* ssl, const unsigned char* secret,
if (secretSz == 0) {
#if !defined(NO_SHA) && defined(NO_SHA256)
secretSz = SHA_DIGEST_SIZE;
secretSz = WC_SHA_DIGEST_SIZE;
#endif /* NO_SHA */
#ifndef NO_SHA256
secretSz = SHA256_DIGEST_SIZE;
secretSz = WC_SHA256_DIGEST_SIZE;
#endif /* NO_SHA256 */
}
@ -6652,7 +6652,7 @@ int wolfSSL_send_hrr_cookie(WOLFSSL* ssl, const unsigned char* secret,
ssl->options.sendCookie = 1;
return SSL_SUCCESS;
return WOLF_SSL_SUCCESS;
}
#endif
@ -6676,7 +6676,7 @@ int wolfSSL_UseKeyShare(WOLFSSL* ssl, word16 group)
if (ret != 0)
return ret;
return SSL_SUCCESS;
return WOLF_SSL_SUCCESS;
}
/* Send no key share entries - use HelloRetryRequest to negotiate shared group.
@ -6697,7 +6697,7 @@ int wolfSSL_NoKeyShares(WOLFSSL* ssl)
if (ret != 0)
return ret;
return SSL_SUCCESS;
return WOLF_SSL_SUCCESS;
}
/* Do not send a ticket after TLS v1.3 handshake for resumption.
@ -6771,13 +6771,13 @@ int wolfSSL_no_dhe_psk(WOLFSSL* ssl)
}
/* Update the keys for encryption and decryption.
* If using non-blocking I/O and SSL_ERROR_WANT_WRITE is returned then
* If using non-blocking I/O and WOLF_SSL_ERROR_WANT_WRITE is returned then
* calling wolfSSL_write() will have the message sent when ready.
*
* ssl The SSL/TLS object.
* returns BAD_FUNC_ARG when ssl is NULL, or not using TLS v1.3,
* SSL_ERROR_WANT_WRITE when non-blocking I/O is not ready to write,
* SSL_SUCCESS on success and otherwise failure.
* WOLF_SSL_ERROR_WANT_WRITE when non-blocking I/O is not ready to write,
* WOLF_SSL_SUCCESS on success and otherwise failure.
*/
int wolfSSL_update_keys(WOLFSSL* ssl)
{
@ -6788,9 +6788,9 @@ int wolfSSL_update_keys(WOLFSSL* ssl)
ret = SendTls13KeyUpdate(ssl);
if (ret == WANT_WRITE)
ret = SSL_ERROR_WANT_WRITE;
ret = WOLF_SSL_ERROR_WANT_WRITE;
else if (ret == 0)
ret = SSL_SUCCESS;
ret = WOLF_SSL_SUCCESS;
return ret;
}
@ -6864,9 +6864,9 @@ int wolfSSL_request_certificate(WOLFSSL* ssl)
ret = SendTls13CertificateRequest(ssl, &certReqCtx->ctx, certReqCtx->len);
if (ret == WANT_WRITE)
ret = SSL_ERROR_WANT_WRITE;
ret = WOLF_SSL_ERROR_WANT_WRITE;
else if (ret == 0)
ret = SSL_SUCCESS;
ret = WOLF_SSL_SUCCESS;
return ret;
}
#endif /* !NO_CERTS && WOLFSSL_POST_HANDSHAKE_AUTH */
@ -6879,7 +6879,7 @@ int wolfSSL_request_certificate(WOLFSSL* ssl)
* Please see note at top of README if you get an error from accept.
*
* ssl The SSL/TLS object.
* returns SSL_SUCCESS on successful handshake, SSL_FATAL_ERROR when
* returns WOLF_SSL_SUCCESS on successful handshake, WOLF_SSL_FATAL_ERROR when
* unrecoverable error occurs and 0 otherwise.
* For more error information use wolfSSL_get_error().
*/
@ -6905,7 +6905,7 @@ int wolfSSL_accept_TLSv13(WOLFSSL* ssl)
if (ssl->options.side != WOLFSSL_SERVER_END) {
WOLFSSL_ERROR(ssl->error = SIDE_ERROR);
return SSL_FATAL_ERROR;
return WOLF_SSL_FATAL_ERROR;
}
#ifndef NO_CERTS
@ -6918,7 +6918,7 @@ int wolfSSL_accept_TLSv13(WOLFSSL* ssl)
WOLFSSL_MSG("accept error: don't have server cert and key");
ssl->error = NO_PRIVATE_KEY;
WOLFSSL_ERROR(ssl->error);
return SSL_FATAL_ERROR;
return WOLF_SSL_FATAL_ERROR;
}
#endif
@ -6939,7 +6939,7 @@ int wolfSSL_accept_TLSv13(WOLFSSL* ssl)
}
else {
WOLFSSL_ERROR(ssl->error);
return SSL_FATAL_ERROR;
return WOLF_SSL_FATAL_ERROR;
}
}
@ -6950,7 +6950,7 @@ int wolfSSL_accept_TLSv13(WOLFSSL* ssl)
while (ssl->options.clientState < CLIENT_HELLO_COMPLETE)
if ((ssl->error = ProcessReply(ssl)) < 0) {
WOLFSSL_ERROR(ssl->error);
return SSL_FATAL_ERROR;
return WOLF_SSL_FATAL_ERROR;
}
ssl->options.acceptState = ACCEPT_CLIENT_HELLO_DONE;
@ -6961,7 +6961,7 @@ int wolfSSL_accept_TLSv13(WOLFSSL* ssl)
if (ssl->options.serverState == SERVER_HELLO_RETRY_REQUEST) {
if ((ssl->error = SendTls13HelloRetryRequest(ssl)) != 0) {
WOLFSSL_ERROR(ssl->error);
return SSL_FATAL_ERROR;
return WOLF_SSL_FATAL_ERROR;
}
}
ssl->options.acceptState = ACCEPT_HELLO_RETRY_REQUEST_DONE;
@ -6972,7 +6972,7 @@ int wolfSSL_accept_TLSv13(WOLFSSL* ssl)
if (ssl->options.serverState == SERVER_HELLO_RETRY_REQUEST) {
if ( (ssl->error = ProcessReply(ssl)) < 0) {
WOLFSSL_ERROR(ssl->error);
return SSL_FATAL_ERROR;
return WOLF_SSL_FATAL_ERROR;
}
}
ssl->options.acceptState = ACCEPT_FIRST_REPLY_DONE;
@ -6982,7 +6982,7 @@ int wolfSSL_accept_TLSv13(WOLFSSL* ssl)
case ACCEPT_FIRST_REPLY_DONE :
if ((ssl->error = SendTls13ServerHello(ssl)) != 0) {
WOLFSSL_ERROR(ssl->error);
return SSL_FATAL_ERROR;
return WOLF_SSL_FATAL_ERROR;
}
ssl->options.acceptState = SERVER_HELLO_SENT;
WOLFSSL_MSG("accept state SERVER_HELLO_SENT");
@ -6991,7 +6991,7 @@ int wolfSSL_accept_TLSv13(WOLFSSL* ssl)
case SERVER_HELLO_SENT :
if ((ssl->error = SendTls13EncryptedExtensions(ssl)) != 0) {
WOLFSSL_ERROR(ssl->error);
return SSL_FATAL_ERROR;
return WOLF_SSL_FATAL_ERROR;
}
ssl->options.acceptState = SERVER_EXTENSIONS_SENT;
WOLFSSL_MSG("accept state SERVER_EXTENSIONS_SENT");
@ -7004,7 +7004,7 @@ int wolfSSL_accept_TLSv13(WOLFSSL* ssl)
ssl->error = SendTls13CertificateRequest(ssl, NULL, 0);
if (ssl->error != 0) {
WOLFSSL_ERROR(ssl->error);
return SSL_FATAL_ERROR;
return WOLF_SSL_FATAL_ERROR;
}
}
}
@ -7019,7 +7019,7 @@ int wolfSSL_accept_TLSv13(WOLFSSL* ssl)
if (!ssl->options.resuming && ssl->options.sendVerify) {
if ((ssl->error = SendTls13Certificate(ssl)) != 0) {
WOLFSSL_ERROR(ssl->error);
return SSL_FATAL_ERROR;
return WOLF_SSL_FATAL_ERROR;
}
}
#endif
@ -7032,7 +7032,7 @@ int wolfSSL_accept_TLSv13(WOLFSSL* ssl)
if (!ssl->options.resuming && ssl->options.sendVerify) {
if ((ssl->error = SendTls13CertificateVerify(ssl)) != 0) {
WOLFSSL_ERROR(ssl->error);
return SSL_FATAL_ERROR;
return WOLF_SSL_FATAL_ERROR;
}
}
#endif
@ -7043,7 +7043,7 @@ int wolfSSL_accept_TLSv13(WOLFSSL* ssl)
case CERT_VERIFY_SENT :
if ((ssl->error = SendTls13Finished(ssl)) != 0) {
WOLFSSL_ERROR(ssl->error);
return SSL_FATAL_ERROR;
return WOLF_SSL_FATAL_ERROR;
}
ssl->options.acceptState = ACCEPT_FINISHED_DONE;
@ -7051,7 +7051,7 @@ int wolfSSL_accept_TLSv13(WOLFSSL* ssl)
#ifdef WOLFSSL_EARLY_DATA
if (ssl->earlyData) {
ssl->options.handShakeState = SERVER_FINISHED_COMPLETE;
return SSL_SUCCESS;
return WOLF_SSL_SUCCESS;
}
#endif
FALL_THROUGH;
@ -7063,7 +7063,7 @@ int wolfSSL_accept_TLSv13(WOLFSSL* ssl)
!ssl->options.noTicketTls13 && ssl->ctx->ticketEncCb != NULL) {
if ((ssl->error = SendTls13NewSessionTicket(ssl)) != 0) {
WOLFSSL_ERROR(ssl->error);
return SSL_FATAL_ERROR;
return WOLF_SSL_FATAL_ERROR;
}
}
#endif
@ -7076,7 +7076,7 @@ int wolfSSL_accept_TLSv13(WOLFSSL* ssl)
while (ssl->options.clientState < CLIENT_FINISHED_COMPLETE)
if ( (ssl->error = ProcessReply(ssl)) < 0) {
WOLFSSL_ERROR(ssl->error);
return SSL_FATAL_ERROR;
return WOLF_SSL_FATAL_ERROR;
}
ssl->options.acceptState = ACCEPT_SECOND_REPLY_DONE;
@ -7094,7 +7094,7 @@ int wolfSSL_accept_TLSv13(WOLFSSL* ssl)
!ssl->options.noTicketTls13 && ssl->ctx->ticketEncCb != NULL) {
if ((ssl->error = SendTls13NewSessionTicket(ssl)) != 0) {
WOLFSSL_ERROR(ssl->error);
return SSL_FATAL_ERROR;
return WOLF_SSL_FATAL_ERROR;
}
}
#endif /* HAVE_SESSION_TICKET */
@ -7109,17 +7109,17 @@ int wolfSSL_accept_TLSv13(WOLFSSL* ssl)
if (cbret < 0) {
ssl->error = cbret;
WOLFSSL_MSG("HandShake Done Cb don't continue error");
return SSL_FATAL_ERROR;
return WOLF_SSL_FATAL_ERROR;
}
}
#endif /* NO_HANDSHAKE_DONE_CB */
WOLFSSL_LEAVE("SSL_accept()", SSL_SUCCESS);
return SSL_SUCCESS;
WOLFSSL_LEAVE("SSL_accept()", WOLF_SSL_SUCCESS);
return WOLF_SSL_SUCCESS;
default :
WOLFSSL_MSG("Unknown accept state ERROR");
return SSL_FATAL_ERROR;
return WOLF_SSL_FATAL_ERROR;
}
}
#endif
@ -7197,7 +7197,7 @@ int wolfSSL_write_early_data(WOLFSSL* ssl, const void* data, int sz, int* outSz)
ssl->earlyData = 1;
ret = wolfSSL_connect_TLSv13(ssl);
if (ret <= 0)
return SSL_FATAL_ERROR;
return WOLF_SSL_FATAL_ERROR;
}
if (ssl->options.handShakeState == CLIENT_HELLO_COMPLETE) {
ret = SendData(ssl, data, sz);
@ -7208,7 +7208,7 @@ int wolfSSL_write_early_data(WOLFSSL* ssl, const void* data, int sz, int* outSz)
WOLFSSL_LEAVE("SSL_write_early_data()", ret);
if (ret < 0)
ret = SSL_FATAL_ERROR;
ret = WOLF_SSL_FATAL_ERROR;
return ret;
}
@ -7241,14 +7241,14 @@ int wolfSSL_read_early_data(WOLFSSL* ssl, void* data, int sz, int* outSz)
ssl->earlyData = 1;
ret = wolfSSL_accept_TLSv13(ssl);
if (ret <= 0)
return SSL_FATAL_ERROR;
return WOLF_SSL_FATAL_ERROR;
}
if (ssl->options.handShakeState == SERVER_FINISHED_COMPLETE) {
ret = ReceiveData(ssl, (byte*)data, sz, FALSE);
if (ret > 0)
*outSz = ret;
if (ssl->error == ZERO_RETURN)
ssl->error = SSL_ERROR_NONE;
ssl->error = WOLF_SSL_ERROR_NONE;
}
else
ret = 0;
@ -7256,7 +7256,7 @@ int wolfSSL_read_early_data(WOLFSSL* ssl, void* data, int sz, int* outSz)
WOLFSSL_LEAVE("wolfSSL_read_early_data()", ret);
if (ret < 0)
ret = SSL_FATAL_ERROR;
ret = WOLF_SSL_FATAL_ERROR;
return ret;
}
#endif

26
src/wolfio.c
View File

@ -417,7 +417,7 @@ int EmbedGenerateCookie(WOLFSSL* ssl, byte *buf, int sz, void *ctx)
int sd = ssl->wfd;
SOCKADDR_S peer;
XSOCKLENT peerSz = sizeof(peer);
byte digest[SHA256_DIGEST_SIZE];
byte digest[WC_SHA256_DIGEST_SIZE];
int ret = 0;
(void)ctx;
@ -432,8 +432,8 @@ int EmbedGenerateCookie(WOLFSSL* ssl, byte *buf, int sz, void *ctx)
if (ret != 0)
return ret;
if (sz > SHA256_DIGEST_SIZE)
sz = SHA256_DIGEST_SIZE;
if (sz > WC_SHA256_DIGEST_SIZE)
sz = WC_SHA256_DIGEST_SIZE;
XMEMCPY(buf, digest, sz);
return sz;
@ -460,7 +460,7 @@ int EmbedGenerateCookie(WOLFSSL* ssl, byte *buf, int sz, void *ctx)
/* get peer information stored in ssl struct */
peerSz = sizeof(SOCKADDR_S);
if ((ret = wolfSSL_dtls_get_peer(ssl, (void*)&peer, &peerSz))
!= SSL_SUCCESS) {
!= WOLF_SSL_SUCCESS) {
return ret;
}
@ -494,7 +494,7 @@ int EmbedGenerateCookie(WOLFSSL* ssl, byte *buf, int sz, void *ctx)
ip[*ipSz - 1] = '\0'; /* make sure has terminator */
*ipSz = (word16)XSTRLEN(ip);
return SSL_SUCCESS;
return WOLF_SSL_SUCCESS;
}
/* set the peer information in human readable form (ip, port, family)
@ -524,7 +524,7 @@ int EmbedGenerateCookie(WOLFSSL* ssl, byte *buf, int sz, void *ctx)
/* peer sa is free'd in SSL_ResourceFree */
if ((ret = wolfSSL_dtls_set_peer(ssl, (SOCKADDR_IN*)&addr,
sizeof(SOCKADDR_IN)))!= SSL_SUCCESS) {
sizeof(SOCKADDR_IN)))!= WOLF_SSL_SUCCESS) {
WOLFSSL_MSG("Import DTLS peer info error");
return ret;
}
@ -541,7 +541,7 @@ int EmbedGenerateCookie(WOLFSSL* ssl, byte *buf, int sz, void *ctx)
/* peer sa is free'd in SSL_ResourceFree */
if ((ret = wolfSSL_dtls_set_peer(ssl, (SOCKADDR_IN6*)&addr,
sizeof(SOCKADDR_IN6)))!= SSL_SUCCESS) {
sizeof(SOCKADDR_IN6)))!= WOLF_SSL_SUCCESS) {
WOLFSSL_MSG("Import DTLS peer info error");
return ret;
}
@ -553,7 +553,7 @@ int EmbedGenerateCookie(WOLFSSL* ssl, byte *buf, int sz, void *ctx)
return BUFFER_E;
}
return SSL_SUCCESS;
return WOLF_SSL_SUCCESS;
}
#endif /* WOLFSSL_SESSION_EXPORT */
#endif /* WOLFSSL_DTLS */
@ -1280,7 +1280,7 @@ int wolfIO_HttpProcessResponseCrl(WOLFSSL_CRL* crl, int sfd, byte* httpBuf,
result = wolfIO_HttpProcessResponse(sfd, "application/pkix-crl",
&respBuf, httpBuf, httpBufSz, DYNAMIC_TYPE_CRL, crl->heap);
if (result >= 0) {
result = BufferLoadCRL(crl, respBuf, result, SSL_FILETYPE_ASN1, 0);
result = BufferLoadCRL(crl, respBuf, result, WOLF_SSL_FILETYPE_ASN1, 0);
}
XFREE(respBuf, crl->heap, DYNAMIC_TYPE_CRL);
@ -1747,14 +1747,14 @@ int MicriumGenerateCookie(WOLFSSL* ssl, byte *buf, int sz, void *ctx)
{
NET_SOCK_ADDR peer;
NET_SOCK_ADDR_LEN peerSz = sizeof(peer);
byte digest[SHA_DIGEST_SIZE];
byte digest[WC_SHA_DIGEST_SIZE];
int ret = 0;
(void)ctx;
XMEMSET(&peer, 0, sizeof(peer));
if (wolfSSL_dtls_get_peer(ssl, (void*)&peer,
(unsigned int*)&peerSz) != SSL_SUCCESS) {
(unsigned int*)&peerSz) != WOLF_SSL_SUCCESS) {
WOLFSSL_MSG("getpeername failed in MicriumGenerateCookie");
return GEN_COOKIE_E;
}
@ -1763,8 +1763,8 @@ int MicriumGenerateCookie(WOLFSSL* ssl, byte *buf, int sz, void *ctx)
if (ret != 0)
return ret;
if (sz > SHA_DIGEST_SIZE)
sz = SHA_DIGEST_SIZE;
if (sz > WC_SHA_DIGEST_SIZE)
sz = WC_SHA_DIGEST_SIZE;
XMEMCPY(buf, digest, sz);
return sz;

1270
tests/api.c
View File

File diff suppressed because it is too large Load Diff

78
tests/hash.c
View File

@ -254,9 +254,9 @@ int md4_test(void)
int md5_test(void)
{
Md5 md5;
int ret;
byte hash[MD5_DIGEST_SIZE];
wc_Md5 md5;
byte hash[WC_MD5_DIGEST_SIZE];
testVector a, b, c, d, e;
testVector test_md5[5];
@ -317,7 +317,7 @@ int md5_test(void)
return ret;
}
if (XMEMCMP(hash, test_md5[i].output, MD5_DIGEST_SIZE) != 0)
if (XMEMCMP(hash, test_md5[i].output, WC_MD5_DIGEST_SIZE) != 0)
return -5 - i;
}
@ -329,8 +329,8 @@ int md5_test(void)
#ifndef NO_SHA
int sha_test(void)
{
Sha sha;
byte hash[SHA_DIGEST_SIZE];
wc_Sha sha;
byte hash[WC_SHA_DIGEST_SIZE];
testVector a, b, c, d;
testVector test_sha[4];
@ -377,7 +377,7 @@ int sha_test(void)
wc_ShaUpdate(&sha, (byte*)test_sha[i].input, (word32)test_sha[i].inLen);
wc_ShaFinal(&sha, hash);
if (XMEMCMP(hash, test_sha[i].output, SHA_DIGEST_SIZE) != 0)
if (XMEMCMP(hash, test_sha[i].output, WC_SHA_DIGEST_SIZE) != 0)
return -10 - i;
}
@ -388,8 +388,8 @@ int sha_test(void)
#ifdef WOLFSSL_SHA224
int sha224_test(void)
{
Sha224 sha;
byte hash[SHA224_DIGEST_SIZE];
wc_Sha224 sha;
byte hash[WC_SHA224_DIGEST_SIZE];
testVector a, b;
testVector test_sha[2];
@ -400,13 +400,13 @@ int sha224_test(void)
a.output = "\x23\x09\x7d\x22\x34\x05\xd8\x22\x86\x42\xa4\x77\xbd\xa2\x55"
"\xb3\x2a\xad\xbc\xe4\xbd\xa0\xb3\xf7\xe3\x6c\x9d\xa7";
a.inLen = XSTRLEN(a.input);
a.outLen = SHA224_DIGEST_SIZE;
a.outLen = WC_SHA224_DIGEST_SIZE;
b.input = "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq";
b.output = "\x75\x38\x8b\x16\x51\x27\x76\xcc\x5d\xba\x5d\xa1\xfd\x89\x01"
"\x50\xb0\xc6\x45\x5c\xb4\xf5\x8b\x19\x52\x52\x25\x25";
b.inLen = XSTRLEN(b.input);
b.outLen = SHA224_DIGEST_SIZE;
b.outLen = WC_SHA224_DIGEST_SIZE;
test_sha[0] = a;
test_sha[1] = b;
@ -423,7 +423,7 @@ int sha224_test(void)
if (ret != 0)
return ret;
if (XMEMCMP(hash, test_sha[i].output, SHA224_DIGEST_SIZE) != 0)
if (XMEMCMP(hash, test_sha[i].output, WC_SHA224_DIGEST_SIZE) != 0)
return -10 - i;
}
@ -434,8 +434,8 @@ int sha224_test(void)
#ifndef NO_SHA256
int sha256_test(void)
{
Sha256 sha;
byte hash[SHA256_DIGEST_SIZE];
wc_Sha256 sha;
byte hash[WC_SHA256_DIGEST_SIZE];
testVector a, b;
testVector test_sha[2];
@ -472,7 +472,7 @@ int sha256_test(void)
if (ret != 0)
return ret;
if (XMEMCMP(hash, test_sha[i].output, SHA256_DIGEST_SIZE) != 0)
if (XMEMCMP(hash, test_sha[i].output, WC_SHA256_DIGEST_SIZE) != 0)
return -10 - i;
}
@ -483,8 +483,8 @@ int sha256_test(void)
#ifdef WOLFSSL_SHA512
int sha512_test(void)
{
Sha512 sha;
byte hash[SHA512_DIGEST_SIZE];
wc_Sha512 sha;
byte hash[WC_SHA512_DIGEST_SIZE];
testVector a, b;
testVector test_sha[2];
@ -526,7 +526,7 @@ int sha512_test(void)
if (ret != 0)
return ret;
if (XMEMCMP(hash, test_sha[i].output, SHA512_DIGEST_SIZE) != 0)
if (XMEMCMP(hash, test_sha[i].output, WC_SHA512_DIGEST_SIZE) != 0)
return -10 - i;
}
@ -537,8 +537,8 @@ int sha512_test(void)
#ifdef WOLFSSL_SHA384
int sha384_test()
{
Sha384 sha;
byte hash[SHA384_DIGEST_SIZE];
wc_Sha384 sha;
byte hash[WC_SHA384_DIGEST_SIZE];
testVector a, b;
testVector test_sha[2];
@ -578,7 +578,7 @@ int sha384_test()
if (ret != 0)
return ret;
if (XMEMCMP(hash, test_sha[i].output, SHA384_DIGEST_SIZE) != 0)
if (XMEMCMP(hash, test_sha[i].output, WC_SHA384_DIGEST_SIZE) != 0)
return -10 - i;
}
@ -656,7 +656,7 @@ int ripemd_test(void)
int hmac_md5_test(void)
{
Hmac hmac;
byte hash[MD5_DIGEST_SIZE];
byte hash[WC_MD5_DIGEST_SIZE];
const char* keys[]=
{
@ -705,7 +705,7 @@ int hmac_md5_test(void)
if (i == 1)
continue; /* fips not allowed */
#endif
ret = wc_HmacSetKey(&hmac, MD5, (byte*)keys[i], (word32)XSTRLEN(keys[i]));
ret = wc_HmacSetKey(&hmac, WC_MD5, (byte*)keys[i], (word32)XSTRLEN(keys[i]));
if (ret != 0)
return -4014;
ret = wc_HmacUpdate(&hmac, (byte*)test_hmac[i].input,
@ -716,7 +716,7 @@ int hmac_md5_test(void)
if (ret != 0)
return -4016;
if (XMEMCMP(hash, test_hmac[i].output, MD5_DIGEST_SIZE) != 0)
if (XMEMCMP(hash, test_hmac[i].output, WC_MD5_DIGEST_SIZE) != 0)
return -20 - i;
}
@ -730,7 +730,7 @@ int hmac_md5_test(void)
int hmac_sha_test(void)
{
Hmac hmac;
byte hash[SHA_DIGEST_SIZE];
byte hash[WC_SHA_DIGEST_SIZE];
const char* keys[]=
{
@ -781,7 +781,7 @@ int hmac_sha_test(void)
if (i == 1)
continue; /* fips not allowed */
#endif
ret = wc_HmacSetKey(&hmac, SHA, (byte*)keys[i], (word32)XSTRLEN(keys[i]));
ret = wc_HmacSetKey(&hmac, WC_SHA, (byte*)keys[i], (word32)XSTRLEN(keys[i]));
if (ret != 0)
return -4017;
ret = wc_HmacUpdate(&hmac, (byte*)test_hmac[i].input,
@ -792,7 +792,7 @@ int hmac_sha_test(void)
if (ret != 0)
return -4019;
if (XMEMCMP(hash, test_hmac[i].output, SHA_DIGEST_SIZE) != 0)
if (XMEMCMP(hash, test_hmac[i].output, WC_SHA_DIGEST_SIZE) != 0)
return -20 - i;
}
@ -806,7 +806,7 @@ int hmac_sha_test(void)
int hmac_sha224_test(void)
{
Hmac hmac;
byte hash[SHA224_DIGEST_SIZE];
byte hash[WC_SHA224_DIGEST_SIZE];
const char* keys[]=
{
@ -827,13 +827,13 @@ int hmac_sha224_test(void)
a.output = "\x89\x6f\xb1\x12\x8a\xbb\xdf\x19\x68\x32\x10\x7c\xd4\x9d\xf3"
"\x3f\x47\xb4\xb1\x16\x99\x12\xba\x4f\x53\x68\x4b\x22";
a.inLen = XSTRLEN(a.input);
a.outLen = SHA224_DIGEST_SIZE;
a.outLen = WC_SHA224_DIGEST_SIZE;
b.input = "what do ya want for nothing?";
b.output = "\xa3\x0e\x01\x09\x8b\xc6\xdb\xbf\x45\x69\x0f\x3a\x7e\x9e\x6d"
"\x0f\x8b\xbe\xa2\xa3\x9e\x61\x48\x00\x8f\xd0\x5e\x44";
b.inLen = XSTRLEN(b.input);
b.outLen = SHA224_DIGEST_SIZE;
b.outLen = WC_SHA224_DIGEST_SIZE;
c.input = "\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD"
"\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD"
@ -842,7 +842,7 @@ int hmac_sha224_test(void)
c.output = "\x7f\xb3\xcb\x35\x88\xc6\xc1\xf6\xff\xa9\x69\x4d\x7d\x6a\xd2"
"\x64\x93\x65\xb0\xc1\xf6\x5d\x69\xd1\xec\x83\x33\xea";
c.inLen = XSTRLEN(c.input);
c.outLen = SHA224_DIGEST_SIZE;
c.outLen = WC_SHA224_DIGEST_SIZE;
test_hmac[0] = a;
test_hmac[1] = b;
@ -857,7 +857,7 @@ int hmac_sha224_test(void)
if (i == 1)
continue; /* cavium can't handle short keys, fips not allowed */
#endif
ret = wc_HmacSetKey(&hmac, SHA224, (byte*)keys[i],(word32)XSTRLEN(keys[i]));
ret = wc_HmacSetKey(&hmac, WC_SHA224, (byte*)keys[i],(word32)XSTRLEN(keys[i]));
if (ret != 0)
return -4021;
ret = wc_HmacUpdate(&hmac, (byte*)test_hmac[i].input,
@ -868,7 +868,7 @@ int hmac_sha224_test(void)
if (ret != 0)
return -4023;
if (XMEMCMP(hash, test_hmac[i].output, SHA224_DIGEST_SIZE) != 0)
if (XMEMCMP(hash, test_hmac[i].output, WC_SHA224_DIGEST_SIZE) != 0)
return -20 - i;
}
@ -883,7 +883,7 @@ int hmac_sha224_test(void)
int hmac_sha256_test(void)
{
Hmac hmac;
byte hash[SHA256_DIGEST_SIZE];
byte hash[WC_SHA256_DIGEST_SIZE];
const char* keys[]=
{
@ -937,7 +937,8 @@ int hmac_sha256_test(void)
if (i == 1)
continue; /* fips not allowed */
#endif
ret = wc_HmacSetKey(&hmac,SHA256, (byte*)keys[i], (word32)XSTRLEN(keys[i]));
ret = wc_HmacSetKey(&hmac, WC_SHA256, (byte*)keys[i],
(word32)XSTRLEN(keys[i]));
if (ret != 0)
return -4020;
ret = wc_HmacUpdate(&hmac, (byte*)test_hmac[i].input,
@ -948,7 +949,7 @@ int hmac_sha256_test(void)
if (ret != 0)
return -4022;
if (XMEMCMP(hash, test_hmac[i].output, SHA256_DIGEST_SIZE) != 0)
if (XMEMCMP(hash, test_hmac[i].output, WC_SHA256_DIGEST_SIZE) != 0)
return -20 - i;
}
@ -963,7 +964,7 @@ int hmac_sha256_test(void)
int hmac_sha384_test(void)
{
Hmac hmac;
byte hash[SHA384_DIGEST_SIZE];
byte hash[WC_SHA384_DIGEST_SIZE];
const char* keys[]=
{
@ -1020,7 +1021,8 @@ int hmac_sha384_test(void)
if (i == 1)
continue; /* fips not allowed */
#endif
ret = wc_HmacSetKey(&hmac,SHA384, (byte*)keys[i], (word32)XSTRLEN(keys[i]));
ret = wc_HmacSetKey(&hmac, WC_SHA384, (byte*)keys[i],
(word32)XSTRLEN(keys[i]));
if (ret != 0)
return -4023;
ret = wc_HmacUpdate(&hmac, (byte*)test_hmac[i].input,
@ -1031,7 +1033,7 @@ int hmac_sha384_test(void)
if (ret != 0)
return -4025;
if (XMEMCMP(hash, test_hmac[i].output, SHA384_DIGEST_SIZE) != 0)
if (XMEMCMP(hash, test_hmac[i].output, WC_SHA384_DIGEST_SIZE) != 0)
return -20 - i;
}

8
tests/srp.c
View File

@ -430,20 +430,20 @@ static void test_SrpGetProofAndVerify(void)
static int sha512_key_gen(Srp* srp, byte* secret, word32 size)
{
Sha512 hash;
wc_Sha512 hash;
int r;
srp->key = (byte*)XMALLOC(SHA512_DIGEST_SIZE, NULL, DYNAMIC_TYPE_SRP);
srp->key = (byte*)XMALLOC(WC_SHA512_DIGEST_SIZE, NULL, DYNAMIC_TYPE_SRP);
if (srp->key == NULL)
return MEMORY_E;
srp->keySz = SHA512_DIGEST_SIZE;
srp->keySz = WC_SHA512_DIGEST_SIZE;
r = wc_InitSha512(&hash);
if (!r) r = wc_Sha512Update(&hash, secret, size);
if (!r) r = wc_Sha512Final(&hash, srp->key);
XMEMSET(&hash, 0, sizeof(Sha512));
XMEMSET(&hash, 0, sizeof(wc_Sha512));
return r;
}

6
tests/suites.c
View File

@ -143,13 +143,13 @@ static int IsValidCipherSuite(const char* line, char* suite)
#ifdef HAVE_QSH
if (XSTRNCMP(suite, "QSH", 3) == 0) {
if (wolfSSL_CTX_set_cipher_list(cipherSuiteCtx, suite + 4)
!= SSL_SUCCESS)
!= WOLF_SSL_SUCCESS)
return 0;
}
#endif
if (found) {
if (wolfSSL_CTX_set_cipher_list(cipherSuiteCtx, suite) == SSL_SUCCESS)
if (wolfSSL_CTX_set_cipher_list(cipherSuiteCtx, suite) == WOLF_SSL_SUCCESS)
valid = 1;
}
@ -539,7 +539,7 @@ int SuiteTest(void)
#ifdef WOLFSSL_STATIC_MEMORY
if (wolfSSL_CTX_load_static_memory(&cipherSuiteCtx, NULL,
memory, sizeof(memory), 0, 1)
!= SSL_SUCCESS) {
!= WOLF_SSL_SUCCESS) {
printf("unable to load static memory and create ctx");
args.return_code = EXIT_FAILURE;
goto exit;

22
testsuite/testsuite.c
View File

@ -28,18 +28,20 @@
#include <wolfssl/ssl.h>
#include <wolfssl/test.h>
#include "wolfcrypt/test/test.h"
#include <wolfcrypt/test/test.h>
#ifndef SINGLE_THREADED
#ifdef OPENSSL_EXTRA
#include <wolfssl/openssl/ssl.h>
#endif
#include <wolfssl/wolfcrypt/sha256.h>
#include "examples/echoclient/echoclient.h"
#include "examples/echoserver/echoserver.h"
#include "examples/server/server.h"
#include "examples/client/client.h"
#include <examples/echoclient/echoclient.h>
#include <examples/echoserver/echoserver.h>
#include <examples/server/server.h>
#include <examples/client/client.h>
#ifndef NO_SHA256
@ -187,8 +189,8 @@ int testsuite_test(int argc, char** argv)
/* validate output equals input */
{
#ifndef NO_SHA256
byte input[SHA256_DIGEST_SIZE];
byte output[SHA256_DIGEST_SIZE];
byte input[WC_SHA256_DIGEST_SIZE];
byte output[WC_SHA256_DIGEST_SIZE];
file_test("input", input);
file_test(outputName, output);
@ -362,9 +364,9 @@ void file_test(const char* file, byte* check)
{
FILE* f;
int i = 0, j, ret;
Sha256 sha256;
wc_Sha256 sha256;
byte buf[1024];
byte shasum[SHA256_DIGEST_SIZE];
byte shasum[WC_SHA256_DIGEST_SIZE];
ret = wc_InitSha256(&sha256);
if (ret != 0) {
@ -393,7 +395,7 @@ void file_test(const char* file, byte* check)
XMEMCPY(check, shasum, sizeof(shasum));
for(j = 0; j < SHA256_DIGEST_SIZE; ++j )
for(j = 0; j < WC_SHA256_DIGEST_SIZE; ++j )
printf( "%02x", shasum[j] );
printf(" %s\n", file);

34
wolfcrypt/benchmark/benchmark.c
View File

@ -1758,10 +1758,10 @@ void bench_chacha20_poly1305_aead(void)
#ifndef NO_MD5
void bench_md5(int doAsync)
{
Md5 hash[BENCH_MAX_PENDING];
wc_Md5 hash[BENCH_MAX_PENDING];
double start;
int ret, i, count = 0, times, pending = 0;
DECLARE_ARRAY(digest, byte, BENCH_MAX_PENDING, MD5_DIGEST_SIZE, HEAP_HINT);
DECLARE_ARRAY(digest, byte, BENCH_MAX_PENDING, WC_MD5_DIGEST_SIZE, HEAP_HINT);
/* clear for done cleanup */
XMEMSET(hash, 0, sizeof(hash));
@ -1827,10 +1827,10 @@ exit:
#ifndef NO_SHA
void bench_sha(int doAsync)
{
Sha hash[BENCH_MAX_PENDING];
wc_Sha hash[BENCH_MAX_PENDING];
double start;
int ret, i, count = 0, times, pending = 0;
DECLARE_ARRAY(digest, byte, BENCH_MAX_PENDING, SHA_DIGEST_SIZE, HEAP_HINT);
DECLARE_ARRAY(digest, byte, BENCH_MAX_PENDING, WC_SHA_DIGEST_SIZE, HEAP_HINT);
/* clear for done cleanup */
XMEMSET(hash, 0, sizeof(hash));
@ -1878,7 +1878,7 @@ void bench_sha(int doAsync)
} while (pending > 0);
} while (bench_stats_sym_check(start));
exit_sha:
bench_stats_sym_finish("SHA", doAsync, count, start, ret);
bench_stats_sym_finish("WC_SHA", doAsync, count, start, ret);
exit:
@ -1894,10 +1894,10 @@ exit:
#ifdef WOLFSSL_SHA224
void bench_sha224(int doAsync)
{
Sha224 hash[BENCH_MAX_PENDING];
wc_Sha224 hash[BENCH_MAX_PENDING];
double start;
int ret, i, count = 0, times, pending = 0;
DECLARE_ARRAY(digest, byte, BENCH_MAX_PENDING, SHA224_DIGEST_SIZE, HEAP_HINT);
DECLARE_ARRAY(digest, byte, BENCH_MAX_PENDING, WC_SHA224_DIGEST_SIZE, HEAP_HINT);
/* clear for done cleanup */
XMEMSET(hash, 0, sizeof(hash));
@ -1944,7 +1944,7 @@ void bench_sha224(int doAsync)
} while (pending > 0);
} while (bench_stats_sym_check(start));
exit_sha224:
bench_stats_sym_finish("SHA-224", doAsync, count, start, ret);
bench_stats_sym_finish("WC_SHA-224", doAsync, count, start, ret);
exit:
@ -1959,10 +1959,10 @@ exit:
#ifndef NO_SHA256
void bench_sha256(int doAsync)
{
Sha256 hash[BENCH_MAX_PENDING];
wc_Sha256 hash[BENCH_MAX_PENDING];
double start;
int ret, i, count = 0, times, pending = 0;
DECLARE_ARRAY(digest, byte, BENCH_MAX_PENDING, SHA256_DIGEST_SIZE, HEAP_HINT);
DECLARE_ARRAY(digest, byte, BENCH_MAX_PENDING, WC_SHA256_DIGEST_SIZE, HEAP_HINT);
/* clear for done cleanup */
XMEMSET(hash, 0, sizeof(hash));
@ -2009,7 +2009,7 @@ void bench_sha256(int doAsync)
} while (pending > 0);
} while (bench_stats_sym_check(start));
exit_sha256:
bench_stats_sym_finish("SHA-256", doAsync, count, start, ret);
bench_stats_sym_finish("WC_SHA-256", doAsync, count, start, ret);
exit:
@ -2024,10 +2024,10 @@ exit:
#ifdef WOLFSSL_SHA384
void bench_sha384(int doAsync)
{
Sha384 hash[BENCH_MAX_PENDING];
wc_Sha384 hash[BENCH_MAX_PENDING];
double start;
int ret, i, count = 0, times, pending = 0;
DECLARE_ARRAY(digest, byte, BENCH_MAX_PENDING, SHA384_DIGEST_SIZE, HEAP_HINT);
DECLARE_ARRAY(digest, byte, BENCH_MAX_PENDING, WC_SHA384_DIGEST_SIZE, HEAP_HINT);
/* clear for done cleanup */
XMEMSET(hash, 0, sizeof(hash));
@ -2074,7 +2074,7 @@ void bench_sha384(int doAsync)
} while (pending > 0);
} while (bench_stats_sym_check(start));
exit_sha384:
bench_stats_sym_finish("SHA-384", doAsync, count, start, ret);
bench_stats_sym_finish("WC_SHA-384", doAsync, count, start, ret);
exit:
@ -2089,10 +2089,10 @@ exit:
#ifdef WOLFSSL_SHA512
void bench_sha512(int doAsync)
{
Sha512 hash[BENCH_MAX_PENDING];
wc_Sha512 hash[BENCH_MAX_PENDING];
double start;
int ret, i, count = 0, times, pending = 0;
DECLARE_ARRAY(digest, byte, BENCH_MAX_PENDING, SHA512_DIGEST_SIZE, HEAP_HINT);
DECLARE_ARRAY(digest, byte, BENCH_MAX_PENDING, WC_SHA512_DIGEST_SIZE, HEAP_HINT);
/* clear for done cleanup */
XMEMSET(hash, 0, sizeof(hash));
@ -2139,7 +2139,7 @@ void bench_sha512(int doAsync)
} while (pending > 0);
} while (bench_stats_sym_check(start));
exit_sha512:
bench_stats_sym_finish("SHA-512", doAsync, count, start, ret);
bench_stats_sym_finish("WC_SHA-512", doAsync, count, start, ret);
exit:

44
wolfcrypt/src/asn.c
View File

@ -2264,25 +2264,25 @@ static int DecryptKey(const char* password, int passwordSz, byte* salt,
switch (id) {
case PBE_MD5_DES:
typeH = MD5;
typeH = WC_MD5;
derivedLen = 16; /* may need iv for v1.5 */
decryptionType = DES_TYPE;
break;
case PBE_SHA1_DES:
typeH = SHA;
typeH = WC_SHA;
derivedLen = 16; /* may need iv for v1.5 */
decryptionType = DES_TYPE;
break;
case PBE_SHA1_DES3:
typeH = SHA;
typeH = WC_SHA;
derivedLen = 32; /* may need iv for v1.5 */
decryptionType = DES3_TYPE;
break;
case PBE_SHA1_RC4_128:
typeH = SHA;
typeH = WC_SHA;
derivedLen = 16;
decryptionType = RC4_TYPE;
break;
@ -4368,27 +4368,27 @@ int wc_GetCTC_HashOID(int type)
return MD2h;
#endif
#ifndef NO_MD5
case MD5:
case WC_MD5:
return MD5h;
#endif
#ifndef NO_SHA
case SHA:
case WC_SHA:
return SHAh;
#endif
#ifdef WOLFSSL_SHA224
case SHA224:
case WC_SHA224:
return SHA224h;
#endif
#ifndef NO_SHA256
case SHA256:
case WC_SHA256:
return SHA256h;
#endif
#ifdef WOLFSSL_SHA384
case SHA384:
case WC_SHA384:
return SHA384h;
#endif
#ifdef WOLFSSL_SHA512
case SHA512:
case WC_SHA512:
return SHA512h;
#endif
default:
@ -4474,7 +4474,7 @@ static int HashForSignature(const byte* buf, word32 bufSz, word32 sigOID,
case CTC_MD5wRSA:
if ((ret = wc_Md5Hash(buf, bufSz, digest)) == 0) {
*typeH = MD5h;
*digestSz = MD5_DIGEST_SIZE;
*digestSz = WC_MD5_DIGEST_SIZE;
}
break;
#endif
@ -4484,7 +4484,7 @@ static int HashForSignature(const byte* buf, word32 bufSz, word32 sigOID,
case CTC_SHAwECDSA:
if ((ret = wc_ShaHash(buf, bufSz, digest)) == 0) {
*typeH = SHAh;
*digestSz = SHA_DIGEST_SIZE;
*digestSz = WC_SHA_DIGEST_SIZE;
}
break;
#endif
@ -4493,7 +4493,7 @@ static int HashForSignature(const byte* buf, word32 bufSz, word32 sigOID,
case CTC_SHA224wECDSA:
if ((ret = wc_Sha224Hash(buf, bufSz, digest)) == 0) {
*typeH = SHA224h;
*digestSz = SHA224_DIGEST_SIZE;
*digestSz = WC_SHA224_DIGEST_SIZE;
}
break;
#endif
@ -4502,7 +4502,7 @@ static int HashForSignature(const byte* buf, word32 bufSz, word32 sigOID,
case CTC_SHA256wECDSA:
if ((ret = wc_Sha256Hash(buf, bufSz, digest)) == 0) {
*typeH = SHA256h;
*digestSz = SHA256_DIGEST_SIZE;
*digestSz = WC_SHA256_DIGEST_SIZE;
}
break;
#endif
@ -4511,7 +4511,7 @@ static int HashForSignature(const byte* buf, word32 bufSz, word32 sigOID,
case CTC_SHA384wECDSA:
if ((ret = wc_Sha384Hash(buf, bufSz, digest)) == 0) {
*typeH = SHA384h;
*digestSz = SHA384_DIGEST_SIZE;
*digestSz = WC_SHA384_DIGEST_SIZE;
}
break;
#endif
@ -4520,7 +4520,7 @@ static int HashForSignature(const byte* buf, word32 bufSz, word32 sigOID,
case CTC_SHA512wECDSA:
if ((ret = wc_Sha512Hash(buf, bufSz, digest)) == 0) {
*typeH = SHA512h;
*digestSz = SHA512_DIGEST_SIZE;
*digestSz = WC_SHA512_DIGEST_SIZE;
}
break;
#endif
@ -9213,22 +9213,22 @@ static int SetKeyIdFromPublicKey(Cert *cert, RsaKey *rsakey, ecc_key *eckey,
#ifdef NO_SHA
if (kid_type == SKID_TYPE) {
ret = wc_Sha256Hash(buffer, bufferSz, cert->skid);
cert->skidSz = SHA256_DIGEST_SIZE;
cert->skidSz = WC_SHA256_DIGEST_SIZE;
}
else if (kid_type == AKID_TYPE) {
ret = wc_Sha256Hash(buffer, bufferSz, cert->akid);
cert->akidSz = SHA256_DIGEST_SIZE;
cert->akidSz = WC_SHA256_DIGEST_SIZE;
}
else
ret = BAD_FUNC_ARG;
#else /* NO_SHA */
if (kid_type == SKID_TYPE) {
ret = wc_ShaHash(buffer, bufferSz, cert->skid);
cert->skidSz = SHA_DIGEST_SIZE;
cert->skidSz = WC_SHA_DIGEST_SIZE;
}
else if (kid_type == AKID_TYPE) {
ret = wc_ShaHash(buffer, bufferSz, cert->akid);
cert->akidSz = SHA_DIGEST_SIZE;
cert->akidSz = WC_SHA_DIGEST_SIZE;
}
else
ret = BAD_FUNC_ARG;
@ -11276,7 +11276,7 @@ int CompareOcspReqResp(OcspRequest* req, OcspResponse* resp)
#endif
/* store SHA hash of NAME */
/* store WC_SHA hash of NAME */
WOLFSSL_LOCAL int GetNameHash(const byte* source, word32* idx, byte* hash,
int maxIdx)
{
@ -11462,7 +11462,7 @@ int ParseCRL(DecodedCRL* dcrl, const byte* buff, word32 sz, void* cm)
/* raw crl hash */
/* hash here if needed for optimized comparisons
* Sha sha;
* wc_Sha sha;
* wc_InitSha(&sha);
* wc_ShaUpdate(&sha, buff, sz);
* wc_ShaFinal(&sha, dcrl->crlHash); */

4
wolfcrypt/src/dsa.c
View File

@ -410,7 +410,7 @@ int wc_DsaSign(const byte* digest, byte* out, DsaKey* key, WC_RNG* rng)
ret = MP_MOD_E;
/* generate H from sha digest */
if (ret == 0 && mp_read_unsigned_bin(&H, digest,SHA_DIGEST_SIZE) != MP_OKAY)
if (ret == 0 && mp_read_unsigned_bin(&H, digest,WC_SHA_DIGEST_SIZE) != MP_OKAY)
ret = MP_READ_E;
/* generate s, s = (kInv * (H + x*r)) % q */
@ -483,7 +483,7 @@ int wc_DsaVerify(const byte* digest, const byte* sig, DsaKey* key, int* answer)
}
/* put H into u1 from sha digest */
if (ret == 0 && mp_read_unsigned_bin(&u1,digest,SHA_DIGEST_SIZE) != MP_OKAY)
if (ret == 0 && mp_read_unsigned_bin(&u1,digest,WC_SHA_DIGEST_SIZE) != MP_OKAY)
ret = MP_READ_E;
/* w = s invmod q */

12
wolfcrypt/src/ecc.c
View File

@ -7192,7 +7192,7 @@ static int ecc_get_key_sizes(ecEncCtx* ctx, int* encKeySz, int* ivSz,
switch (ctx->macAlgo) {
case ecHMAC_SHA256:
*digestSz = SHA256_DIGEST_SIZE;
*digestSz = WC_SHA256_DIGEST_SIZE;
break;
default:
return BAD_FUNC_ARG;
@ -7295,7 +7295,7 @@ int wc_ecc_encrypt(ecc_key* privKey, ecc_key* pubKey, const byte* msg,
if (ret == 0) {
switch (ctx->kdfAlgo) {
case ecHKDF_SHA256 :
ret = wc_HKDF(SHA256, sharedSecret, sharedSz, ctx->kdfSalt,
ret = wc_HKDF(WC_SHA256, sharedSecret, sharedSz, ctx->kdfSalt,
ctx->kdfSaltSz, ctx->kdfInfo, ctx->kdfInfoSz,
keys, keysLen);
break;
@ -7339,7 +7339,7 @@ int wc_ecc_encrypt(ecc_key* privKey, ecc_key* pubKey, const byte* msg,
Hmac hmac;
ret = wc_HmacInit(&hmac, NULL, INVALID_DEVID);
if (ret == 0) {
ret = wc_HmacSetKey(&hmac, SHA256, macKey, SHA256_DIGEST_SIZE);
ret = wc_HmacSetKey(&hmac, WC_SHA256, macKey, WC_SHA256_DIGEST_SIZE);
if (ret == 0)
ret = wc_HmacUpdate(&hmac, out, msgSz);
if (ret == 0)
@ -7457,7 +7457,7 @@ int wc_ecc_decrypt(ecc_key* privKey, ecc_key* pubKey, const byte* msg,
if (ret == 0) {
switch (ctx->kdfAlgo) {
case ecHKDF_SHA256 :
ret = wc_HKDF(SHA256, sharedSecret, sharedSz, ctx->kdfSalt,
ret = wc_HKDF(WC_SHA256, sharedSecret, sharedSz, ctx->kdfSalt,
ctx->kdfSaltSz, ctx->kdfInfo, ctx->kdfInfoSz,
keys, keysLen);
break;
@ -7476,12 +7476,12 @@ int wc_ecc_decrypt(ecc_key* privKey, ecc_key* pubKey, const byte* msg,
switch (ctx->macAlgo) {
case ecHMAC_SHA256:
{
byte verify[SHA256_DIGEST_SIZE];
byte verify[WC_SHA256_DIGEST_SIZE];
Hmac hmac;
ret = wc_HmacInit(&hmac, NULL, INVALID_DEVID);
if (ret == 0) {
ret = wc_HmacSetKey(&hmac, SHA256, macKey, SHA256_DIGEST_SIZE);
ret = wc_HmacSetKey(&hmac, WC_SHA256, macKey, WC_SHA256_DIGEST_SIZE);
if (ret == 0)
ret = wc_HmacUpdate(&hmac, msg, msgSz-digestSz);
if (ret == 0)

10
wolfcrypt/src/ed25519.c
View File

@ -112,10 +112,10 @@ int wc_ed25519_sign_msg(const byte* in, word32 inlen, byte* out,
#else
ge_p3 R;
#endif
byte nonce[SHA512_DIGEST_SIZE];
byte hram[SHA512_DIGEST_SIZE];
byte nonce[WC_SHA512_DIGEST_SIZE];
byte hram[WC_SHA512_DIGEST_SIZE];
byte az[ED25519_PRV_KEY_SIZE];
Sha512 sha;
wc_Sha512 sha;
int ret;
/* sanity check on arguments */
@ -214,13 +214,13 @@ int wc_ed25519_verify_msg(const byte* sig, word32 siglen, const byte* msg,
word32 msglen, int* res, ed25519_key* key)
{
byte rcheck[ED25519_KEY_SIZE];
byte h[SHA512_DIGEST_SIZE];
byte h[WC_SHA512_DIGEST_SIZE];
#ifndef FREESCALE_LTC_ECC
ge_p3 A;
ge_p2 R;
#endif
int ret;
Sha512 sha;
wc_Sha512 sha;
/* sanity check on arguments */
if (sig == NULL || msg == NULL || res == NULL || key == NULL)

36
wolfcrypt/src/evp.c
View File

@ -617,32 +617,32 @@ int wolfSSL_EVP_DigestSignInit(WOLFSSL_EVP_MD_CTX *ctx,
#endif
if (XSTRNCMP(type, "SHA256", 6) == 0) {
hashType = SHA256;
hashType = WC_SHA256;
}
#ifdef WOLFSSL_SHA224
else if (XSTRNCMP(type, "SHA224", 6) == 0) {
hashType = SHA224;
hashType = WC_SHA224;
}
#endif
#ifdef WOLFSSL_SHA384
else if (XSTRNCMP(type, "SHA384", 6) == 0) {
hashType = SHA384;
hashType = WC_SHA384;
}
#endif
#ifdef WOLFSSL_SHA512
else if (XSTRNCMP(type, "SHA512", 6) == 0) {
hashType = SHA512;
hashType = WC_SHA512;
}
#endif
#ifndef NO_MD5
else if (XSTRNCMP(type, "MD5", 3) == 0) {
hashType = MD5;
hashType = WC_MD5;
}
#endif
#ifndef NO_SHA
/* has to be last since would pick or 224, 256, 384, or 512 too */
else if (XSTRNCMP(type, "SHA", 3) == 0) {
hashType = SHA;
hashType = WC_SHA;
}
#endif /* NO_SHA */
else
@ -694,37 +694,37 @@ int wolfSSL_EVP_DigestSignFinal(WOLFSSL_EVP_MD_CTX *ctx,
switch (ctx->hash.hmac.macType) {
#ifndef NO_MD5
case MD5:
hashLen = MD5_DIGEST_SIZE;
case WC_MD5:
hashLen = WC_MD5_DIGEST_SIZE;
break;
#endif /* !NO_MD5 */
#ifndef NO_SHA
case SHA:
hashLen = SHA_DIGEST_SIZE;
case WC_SHA:
hashLen = WC_SHA_DIGEST_SIZE;
break;
#endif /* !NO_SHA */
#ifdef WOLFSSL_SHA224
case SHA224:
hashLen = SHA224_DIGEST_SIZE;
case WC_SHA224:
hashLen = WC_SHA224_DIGEST_SIZE;
break;
#endif /* WOLFSSL_SHA224 */
#ifndef NO_SHA256
case SHA256:
hashLen = SHA256_DIGEST_SIZE;
case WC_SHA256:
hashLen = WC_SHA256_DIGEST_SIZE;
break;
#endif /* !NO_SHA256 */
#ifdef WOLFSSL_SHA512
#ifdef WOLFSSL_SHA384
case SHA384:
hashLen = SHA384_DIGEST_SIZE;
case WC_SHA384:
hashLen = WC_SHA384_DIGEST_SIZE;
break;
#endif /* WOLFSSL_SHA384 */
case SHA512:
hashLen = SHA512_DIGEST_SIZE;
case WC_SHA512:
hashLen = WC_SHA512_DIGEST_SIZE;
break;
#endif /* WOLFSSL_SHA512 */

56
wolfcrypt/src/hash.c
View File

@ -109,37 +109,37 @@ int wc_HashGetDigestSize(enum wc_HashType hash_type)
{
case WC_HASH_TYPE_MD5:
#ifndef NO_MD5
dig_size = MD5_DIGEST_SIZE;
dig_size = WC_MD5_DIGEST_SIZE;
#endif
break;
case WC_HASH_TYPE_SHA:
#ifndef NO_SHA
dig_size = SHA_DIGEST_SIZE;
dig_size = WC_SHA_DIGEST_SIZE;
#endif
break;
case WC_HASH_TYPE_SHA224:
#ifdef WOLFSSL_SHA224
dig_size = SHA224_DIGEST_SIZE;
dig_size = WC_SHA224_DIGEST_SIZE;
#endif
break;
case WC_HASH_TYPE_SHA256:
#ifndef NO_SHA256
dig_size = SHA256_DIGEST_SIZE;
dig_size = WC_SHA256_DIGEST_SIZE;
#endif
break;
case WC_HASH_TYPE_SHA384:
#if defined(WOLFSSL_SHA512) && defined(WOLFSSL_SHA384)
dig_size = SHA384_DIGEST_SIZE;
dig_size = WC_SHA384_DIGEST_SIZE;
#endif
break;
case WC_HASH_TYPE_SHA512:
#ifdef WOLFSSL_SHA512
dig_size = SHA512_DIGEST_SIZE;
dig_size = WC_SHA512_DIGEST_SIZE;
#endif
break;
case WC_HASH_TYPE_MD5_SHA:
#if !defined(NO_MD5) && !defined(NO_SHA)
dig_size = MD5_DIGEST_SIZE + SHA_DIGEST_SIZE;
dig_size = WC_MD5_DIGEST_SIZE + WC_SHA_DIGEST_SIZE;
#endif
break;
@ -209,7 +209,7 @@ int wc_Hash(enum wc_HashType hash_type, const byte* data,
#if !defined(NO_MD5) && !defined(NO_SHA)
ret = wc_Md5Hash(data, data_len, hash);
if (ret == 0) {
ret = wc_ShaHash(data, data_len, &hash[MD5_DIGEST_SIZE]);
ret = wc_ShaHash(data, data_len, &hash[WC_MD5_DIGEST_SIZE]);
}
#endif
break;
@ -392,13 +392,13 @@ int wc_HashFinal(wc_HashAlg* hash, enum wc_HashType type, byte* out)
{
int ret;
#ifdef WOLFSSL_SMALL_STACK
Md5* md5;
wc_Md5* md5;
#else
Md5 md5[1];
wc_Md5 md5[1];
#endif
#ifdef WOLFSSL_SMALL_STACK
md5 = (Md5*)XMALLOC(sizeof(Md5), NULL, DYNAMIC_TYPE_TMP_BUFFER);
md5 = (wc_Md5*)XMALLOC(sizeof(wc_Md5), NULL, DYNAMIC_TYPE_TMP_BUFFER);
if (md5 == NULL)
return MEMORY_E;
#endif
@ -424,13 +424,13 @@ int wc_HashFinal(wc_HashAlg* hash, enum wc_HashType type, byte* out)
{
int ret = 0;
#ifdef WOLFSSL_SMALL_STACK
Sha* sha;
wc_Sha* sha;
#else
Sha sha[1];
wc_Sha sha[1];
#endif
#ifdef WOLFSSL_SMALL_STACK
sha = (Sha*)XMALLOC(sizeof(Sha), NULL, DYNAMIC_TYPE_TMP_BUFFER);
sha = (wc_Sha*)XMALLOC(sizeof(wc_Sha), NULL, DYNAMIC_TYPE_TMP_BUFFER);
if (sha == NULL)
return MEMORY_E;
#endif
@ -456,13 +456,14 @@ int wc_Sha224Hash(const byte* data, word32 len, byte* hash)
{
int ret = 0;
#ifdef WOLFSSL_SMALL_STACK
Sha224* sha224;
wc_Sha224* sha224;
#else
Sha224 sha224[1];
wc_Sha224 sha224[1];
#endif
#ifdef WOLFSSL_SMALL_STACK
sha224 = (Sha224*)XMALLOC(sizeof(Sha224), NULL, DYNAMIC_TYPE_TMP_BUFFER);
sha224 = (wc_Sha224*)XMALLOC(sizeof(wc_Sha224), NULL,
DYNAMIC_TYPE_TMP_BUFFER);
if (sha224 == NULL)
return MEMORY_E;
#endif
@ -490,13 +491,14 @@ int wc_Sha224Hash(const byte* data, word32 len, byte* hash)
{
int ret = 0;
#ifdef WOLFSSL_SMALL_STACK
Sha256* sha256;
wc_Sha256* sha256;
#else
Sha256 sha256[1];
wc_Sha256 sha256[1];
#endif
#ifdef WOLFSSL_SMALL_STACK
sha256 = (Sha256*)XMALLOC(sizeof(Sha256), NULL, DYNAMIC_TYPE_TMP_BUFFER);
sha256 = (wc_Sha256*)XMALLOC(sizeof(wc_Sha256), NULL,
DYNAMIC_TYPE_TMP_BUFFER);
if (sha256 == NULL)
return MEMORY_E;
#endif
@ -527,13 +529,14 @@ int wc_Sha224Hash(const byte* data, word32 len, byte* hash)
{
int ret = 0;
#ifdef WOLFSSL_SMALL_STACK
Sha512* sha512;
wc_Sha512* sha512;
#else
Sha512 sha512[1];
wc_Sha512 sha512[1];
#endif
#ifdef WOLFSSL_SMALL_STACK
sha512 = (Sha512*)XMALLOC(sizeof(Sha512), NULL, DYNAMIC_TYPE_TMP_BUFFER);
sha512 = (wc_Sha512*)XMALLOC(sizeof(wc_Sha512), NULL,
DYNAMIC_TYPE_TMP_BUFFER);
if (sha512 == NULL)
return MEMORY_E;
#endif
@ -560,13 +563,14 @@ int wc_Sha224Hash(const byte* data, word32 len, byte* hash)
{
int ret = 0;
#ifdef WOLFSSL_SMALL_STACK
Sha384* sha384;
wc_Sha384* sha384;
#else
Sha384 sha384[1];
wc_Sha384 sha384[1];
#endif
#ifdef WOLFSSL_SMALL_STACK
sha384 = (Sha384*)XMALLOC(sizeof(Sha384), NULL, DYNAMIC_TYPE_TMP_BUFFER);
sha384 = (wc_Sha384*)XMALLOC(sizeof(wc_Sha384), NULL,
DYNAMIC_TYPE_TMP_BUFFER);
if (sha384 == NULL)
return MEMORY_E;
#endif

173
wolfcrypt/src/hmac.c
View File

@ -45,8 +45,9 @@
int wc_HmacSetKey(Hmac* hmac, int type, const byte* key, word32 keySz)
{
if (hmac == NULL || (key == NULL && keySz != 0) ||
!(type == MD5 || type == SHA || type == SHA256 || type == SHA384
|| type == SHA512 || type == BLAKE2B_ID)) {
!(type == WC_MD5 || type == WC_SHA || type == WC_SHA224 ||
type == WC_SHA256 || type == WC_SHA384 || type == WC_SHA512 ||
type == BLAKE2B_ID)) {
return BAD_FUNC_ARG;
}
@ -110,45 +111,45 @@ int wc_HmacSizeByType(int type)
{
int ret;
if (!(type == MD5 || type == SHA || type == SHA256 || type == SHA384
|| type == SHA512 || type == BLAKE2B_ID
|| type == SHA224)) {
if (!(type == WC_MD5 || type == WC_SHA || type == WC_SHA224 ||
type == WC_SHA256 || type == WC_SHA384 || type == WC_SHA512 ||
type == BLAKE2B_ID)) {
return BAD_FUNC_ARG;
}
switch (type) {
#ifndef NO_MD5
case MD5:
ret = MD5_DIGEST_SIZE;
case WC_MD5:
ret = WC_MD5_DIGEST_SIZE;
break;
#endif /* !NO_MD5 */
#ifndef NO_SHA
case SHA:
ret = SHA_DIGEST_SIZE;
case WC_SHA:
ret = WC_SHA_DIGEST_SIZE;
break;
#endif /* !NO_SHA */
#ifdef WOLFSSL_SHA224
case SHA224:
ret = SHA224_DIGEST_SIZE;
case WC_SHA224:
ret = WC_SHA224_DIGEST_SIZE;
break;
#endif /* WOLFSSL_SHA224 */
#ifndef NO_SHA256
case SHA256:
ret = SHA256_DIGEST_SIZE;
case WC_SHA256:
ret = WC_SHA256_DIGEST_SIZE;
break;
#endif /* !NO_SHA256 */
#ifdef WOLFSSL_SHA512
#ifdef WOLFSSL_SHA384
case SHA384:
ret = SHA384_DIGEST_SIZE;
case WC_SHA384:
ret = WC_SHA384_DIGEST_SIZE;
break;
#endif /* WOLFSSL_SHA384 */
case SHA512:
ret = SHA512_DIGEST_SIZE;
case WC_SHA512:
ret = WC_SHA512_DIGEST_SIZE;
break;
#endif /* WOLFSSL_SHA512 */
@ -172,36 +173,36 @@ static int _InitHmac(Hmac* hmac, int type, void* heap)
switch (type) {
#ifndef NO_MD5
case MD5:
case WC_MD5:
ret = wc_InitMd5(&hmac->hash.md5);
break;
#endif /* !NO_MD5 */
#ifndef NO_SHA
case SHA:
case WC_SHA:
ret = wc_InitSha(&hmac->hash.sha);
break;
#endif /* !NO_SHA */
#ifdef WOLFSSL_SHA224
case SHA224:
case WC_SHA224:
ret = wc_InitSha224(&hmac->hash.sha224);
break;
#endif /* WOLFSSL_SHA224 */
#ifndef NO_SHA256
case SHA256:
case WC_SHA256:
ret = wc_InitSha256(&hmac->hash.sha256);
break;
#endif /* !NO_SHA256 */
#ifdef WOLFSSL_SHA512
#ifdef WOLFSSL_SHA384
case SHA384:
case WC_SHA384:
ret = wc_InitSha384(&hmac->hash.sha384);
break;
#endif /* WOLFSSL_SHA384 */
case SHA512:
case WC_SHA512:
ret = wc_InitSha512(&hmac->hash.sha512);
break;
#endif /* WOLFSSL_SHA512 */
@ -237,9 +238,9 @@ int wc_HmacSetKey(Hmac* hmac, int type, const byte* key, word32 length)
void* heap = NULL;
if (hmac == NULL || (key == NULL && length != 0) ||
!(type == MD5 || type == SHA || type == SHA256 || type == SHA384
|| type == SHA512 || type == BLAKE2B_ID
|| type == SHA224)) {
!(type == WC_MD5 || type == WC_SHA || type == WC_SHA224 ||
type == WC_SHA256 || type == WC_SHA384 || type == WC_SHA512 ||
type == BLAKE2B_ID)) {
return BAD_FUNC_ARG;
}
@ -277,9 +278,9 @@ int wc_HmacSetKey(Hmac* hmac, int type, const byte* key, word32 length)
switch (hmac->macType) {
#ifndef NO_MD5
case MD5:
hmac_block_size = MD5_BLOCK_SIZE;
if (length <= MD5_BLOCK_SIZE) {
case WC_MD5:
hmac_block_size = WC_MD5_BLOCK_SIZE;
if (length <= WC_MD5_BLOCK_SIZE) {
if (key != NULL) {
XMEMCPY(ip, key, length);
}
@ -291,15 +292,15 @@ int wc_HmacSetKey(Hmac* hmac, int type, const byte* key, word32 length)
ret = wc_Md5Final(&hmac->hash.md5, ip);
if (ret != 0)
break;
length = MD5_DIGEST_SIZE;
length = WC_MD5_DIGEST_SIZE;
}
break;
#endif /* !NO_MD5 */
#ifndef NO_SHA
case SHA:
hmac_block_size = SHA_BLOCK_SIZE;
if (length <= SHA_BLOCK_SIZE) {
case WC_SHA:
hmac_block_size = WC_SHA_BLOCK_SIZE;
if (length <= WC_SHA_BLOCK_SIZE) {
if (key != NULL) {
XMEMCPY(ip, key, length);
}
@ -312,16 +313,16 @@ int wc_HmacSetKey(Hmac* hmac, int type, const byte* key, word32 length)
if (ret != 0)
break;
length = SHA_DIGEST_SIZE;
length = WC_SHA_DIGEST_SIZE;
}
break;
#endif /* !NO_SHA */
#ifdef WOLFSSL_SHA224
case SHA224:
case WC_SHA224:
{
hmac_block_size = SHA224_BLOCK_SIZE;
if (length <= SHA224_BLOCK_SIZE) {
hmac_block_size = WC_SHA224_BLOCK_SIZE;
if (length <= WC_SHA224_BLOCK_SIZE) {
if (key != NULL) {
XMEMCPY(ip, key, length);
}
@ -334,16 +335,16 @@ int wc_HmacSetKey(Hmac* hmac, int type, const byte* key, word32 length)
if (ret != 0)
break;
length = SHA224_DIGEST_SIZE;
length = WC_SHA224_DIGEST_SIZE;
}
}
break;
#endif /* WOLFSSL_SHA224 */
#ifndef NO_SHA256
case SHA256:
hmac_block_size = SHA256_BLOCK_SIZE;
if (length <= SHA256_BLOCK_SIZE) {
case WC_SHA256:
hmac_block_size = WC_SHA256_BLOCK_SIZE;
if (length <= WC_SHA256_BLOCK_SIZE) {
if (key != NULL) {
XMEMCPY(ip, key, length);
}
@ -356,16 +357,16 @@ int wc_HmacSetKey(Hmac* hmac, int type, const byte* key, word32 length)
if (ret != 0)
break;
length = SHA256_DIGEST_SIZE;
length = WC_SHA256_DIGEST_SIZE;
}
break;
#endif /* !NO_SHA256 */
#ifdef WOLFSSL_SHA512
#ifdef WOLFSSL_SHA384
case SHA384:
hmac_block_size = SHA384_BLOCK_SIZE;
if (length <= SHA384_BLOCK_SIZE) {
case WC_SHA384:
hmac_block_size = WC_SHA384_BLOCK_SIZE;
if (length <= WC_SHA384_BLOCK_SIZE) {
if (key != NULL) {
XMEMCPY(ip, key, length);
}
@ -378,13 +379,13 @@ int wc_HmacSetKey(Hmac* hmac, int type, const byte* key, word32 length)
if (ret != 0)
break;
length = SHA384_DIGEST_SIZE;
length = WC_SHA384_DIGEST_SIZE;
}
break;
#endif /* WOLFSSL_SHA384 */
case SHA512:
hmac_block_size = SHA512_BLOCK_SIZE;
if (length <= SHA512_BLOCK_SIZE) {
case WC_SHA512:
hmac_block_size = WC_SHA512_BLOCK_SIZE;
if (length <= WC_SHA512_BLOCK_SIZE) {
if (key != NULL) {
XMEMCPY(ip, key, length);
}
@ -397,7 +398,7 @@ int wc_HmacSetKey(Hmac* hmac, int type, const byte* key, word32 length)
if (ret != 0)
break;
length = SHA512_DIGEST_SIZE;
length = WC_SHA512_DIGEST_SIZE;
}
break;
#endif /* WOLFSSL_SHA512 */
@ -461,43 +462,43 @@ static int HmacKeyInnerHash(Hmac* hmac)
switch (hmac->macType) {
#ifndef NO_MD5
case MD5:
case WC_MD5:
ret = wc_Md5Update(&hmac->hash.md5, (byte*)hmac->ipad,
MD5_BLOCK_SIZE);
WC_MD5_BLOCK_SIZE);
break;
#endif /* !NO_MD5 */
#ifndef NO_SHA
case SHA:
case WC_SHA:
ret = wc_ShaUpdate(&hmac->hash.sha, (byte*)hmac->ipad,
SHA_BLOCK_SIZE);
WC_SHA_BLOCK_SIZE);
break;
#endif /* !NO_SHA */
#ifdef WOLFSSL_SHA224
case SHA224:
case WC_SHA224:
ret = wc_Sha224Update(&hmac->hash.sha224, (byte*)hmac->ipad,
SHA224_BLOCK_SIZE);
WC_SHA224_BLOCK_SIZE);
break;
#endif /* WOLFSSL_SHA224 */
#ifndef NO_SHA256
case SHA256:
case WC_SHA256:
ret = wc_Sha256Update(&hmac->hash.sha256, (byte*)hmac->ipad,
SHA256_BLOCK_SIZE);
WC_SHA256_BLOCK_SIZE);
break;
#endif /* !NO_SHA256 */
#ifdef WOLFSSL_SHA512
#ifdef WOLFSSL_SHA384
case SHA384:
case WC_SHA384:
ret = wc_Sha384Update(&hmac->hash.sha384, (byte*)hmac->ipad,
SHA384_BLOCK_SIZE);
WC_SHA384_BLOCK_SIZE);
break;
#endif /* WOLFSSL_SHA384 */
case SHA512:
case WC_SHA512:
ret = wc_Sha512Update(&hmac->hash.sha512, (byte*)hmac->ipad,
SHA512_BLOCK_SIZE);
WC_SHA512_BLOCK_SIZE);
break;
#endif /* WOLFSSL_SHA512 */
@ -546,36 +547,36 @@ int wc_HmacUpdate(Hmac* hmac, const byte* msg, word32 length)
switch (hmac->macType) {
#ifndef NO_MD5
case MD5:
case WC_MD5:
ret = wc_Md5Update(&hmac->hash.md5, msg, length);
break;
#endif /* !NO_MD5 */
#ifndef NO_SHA
case SHA:
case WC_SHA:
ret = wc_ShaUpdate(&hmac->hash.sha, msg, length);
break;
#endif /* !NO_SHA */
#ifdef WOLFSSL_SHA224
case SHA224:
case WC_SHA224:
ret = wc_Sha224Update(&hmac->hash.sha224, msg, length);
break;
#endif /* WOLFSSL_SHA224 */
#ifndef NO_SHA256
case SHA256:
case WC_SHA256:
ret = wc_Sha256Update(&hmac->hash.sha256, msg, length);
break;
#endif /* !NO_SHA256 */
#ifdef WOLFSSL_SHA512
#ifdef WOLFSSL_SHA384
case SHA384:
case WC_SHA384:
ret = wc_Sha384Update(&hmac->hash.sha384, msg, length);
break;
#endif /* WOLFSSL_SHA384 */
case SHA512:
case WC_SHA512:
ret = wc_Sha512Update(&hmac->hash.sha512, msg, length);
break;
#endif /* WOLFSSL_SHA512 */
@ -625,16 +626,16 @@ int wc_HmacFinal(Hmac* hmac, byte* hash)
switch (hmac->macType) {
#ifndef NO_MD5
case MD5:
case WC_MD5:
ret = wc_Md5Final(&hmac->hash.md5, (byte*)hmac->innerHash);
if (ret != 0)
break;
ret = wc_Md5Update(&hmac->hash.md5, (byte*)hmac->opad,
MD5_BLOCK_SIZE);
WC_MD5_BLOCK_SIZE);
if (ret != 0)
break;
ret = wc_Md5Update(&hmac->hash.md5, (byte*)hmac->innerHash,
MD5_DIGEST_SIZE);
WC_MD5_DIGEST_SIZE);
if (ret != 0)
break;
ret = wc_Md5Final(&hmac->hash.md5, hash);
@ -642,16 +643,16 @@ int wc_HmacFinal(Hmac* hmac, byte* hash)
#endif /* !NO_MD5 */
#ifndef NO_SHA
case SHA:
case WC_SHA:
ret = wc_ShaFinal(&hmac->hash.sha, (byte*)hmac->innerHash);
if (ret != 0)
break;
ret = wc_ShaUpdate(&hmac->hash.sha, (byte*)hmac->opad,
SHA_BLOCK_SIZE);
WC_SHA_BLOCK_SIZE);
if (ret != 0)
break;
ret = wc_ShaUpdate(&hmac->hash.sha, (byte*)hmac->innerHash,
SHA_DIGEST_SIZE);
WC_SHA_DIGEST_SIZE);
if (ret != 0)
break;
ret = wc_ShaFinal(&hmac->hash.sha, hash);
@ -659,17 +660,17 @@ int wc_HmacFinal(Hmac* hmac, byte* hash)
#endif /* !NO_SHA */
#ifdef WOLFSSL_SHA224
case SHA224:
case WC_SHA224:
{
ret = wc_Sha224Final(&hmac->hash.sha224, (byte*)hmac->innerHash);
if (ret != 0)
break;
ret = wc_Sha224Update(&hmac->hash.sha224, (byte*)hmac->opad,
SHA224_BLOCK_SIZE);
WC_SHA224_BLOCK_SIZE);
if (ret != 0)
break;
ret = wc_Sha224Update(&hmac->hash.sha224, (byte*)hmac->innerHash,
SHA224_DIGEST_SIZE);
WC_SHA224_DIGEST_SIZE);
if (ret != 0)
break;
ret = wc_Sha224Final(&hmac->hash.sha224, hash);
@ -680,16 +681,16 @@ int wc_HmacFinal(Hmac* hmac, byte* hash)
#endif /* WOLFSSL_SHA224 */
#ifndef NO_SHA256
case SHA256:
case WC_SHA256:
ret = wc_Sha256Final(&hmac->hash.sha256, (byte*)hmac->innerHash);
if (ret != 0)
break;
ret = wc_Sha256Update(&hmac->hash.sha256, (byte*)hmac->opad,
SHA256_BLOCK_SIZE);
WC_SHA256_BLOCK_SIZE);
if (ret != 0)
break;
ret = wc_Sha256Update(&hmac->hash.sha256, (byte*)hmac->innerHash,
SHA256_DIGEST_SIZE);
WC_SHA256_DIGEST_SIZE);
if (ret != 0)
break;
ret = wc_Sha256Final(&hmac->hash.sha256, hash);
@ -698,31 +699,31 @@ int wc_HmacFinal(Hmac* hmac, byte* hash)
#ifdef WOLFSSL_SHA512
#ifdef WOLFSSL_SHA384
case SHA384:
case WC_SHA384:
ret = wc_Sha384Final(&hmac->hash.sha384, (byte*)hmac->innerHash);
if (ret != 0)
break;
ret = wc_Sha384Update(&hmac->hash.sha384, (byte*)hmac->opad,
SHA384_BLOCK_SIZE);
WC_SHA384_BLOCK_SIZE);
if (ret != 0)
break;
ret = wc_Sha384Update(&hmac->hash.sha384, (byte*)hmac->innerHash,
SHA384_DIGEST_SIZE);
WC_SHA384_DIGEST_SIZE);
if (ret != 0)
break;
ret = wc_Sha384Final(&hmac->hash.sha384, hash);
break;
#endif /* WOLFSSL_SHA384 */
case SHA512:
case WC_SHA512:
ret = wc_Sha512Final(&hmac->hash.sha512, (byte*)hmac->innerHash);
if (ret != 0)
break;
ret = wc_Sha512Update(&hmac->hash.sha512, (byte*)hmac->opad,
SHA512_BLOCK_SIZE);
WC_SHA512_BLOCK_SIZE);
if (ret != 0)
break;
ret = wc_Sha512Update(&hmac->hash.sha512, (byte*)hmac->innerHash,
SHA512_DIGEST_SIZE);
WC_SHA512_DIGEST_SIZE);
if (ret != 0)
break;
ret = wc_Sha512Final(&hmac->hash.sha512, hash);

72
wolfcrypt/src/md5.c
View File

@ -46,7 +46,7 @@
#endif
static INLINE void AddLength(Md5* md5, word32 len);
static INLINE void AddLength(wc_Md5* md5, word32 len);
/* Hardware Acceleration */
#if defined(STM32_HASH)
@ -60,7 +60,7 @@ static INLINE void AddLength(Md5* md5, word32 len);
/* STM32 register size, bytes */
#ifdef WOLFSSL_STM32_CUBEMX
#define MD5_REG_SIZE MD5_BLOCK_SIZE
#define MD5_REG_SIZE WC_MD5_BLOCK_SIZE
#else
#define MD5_REG_SIZE 4
/* STM32 struct notes:
@ -71,7 +71,7 @@ static INLINE void AddLength(Md5* md5, word32 len);
#endif
#define MD5_HW_TIMEOUT 0xFF
int wc_InitMd5_ex(Md5* md5, void* heap, int devId)
int wc_InitMd5_ex(wc_Md5* md5, void* heap, int devId)
{
if (md5 == NULL)
return BAD_FUNC_ARG;
@ -112,7 +112,7 @@ static INLINE void AddLength(Md5* md5, word32 len);
return 0;
}
int wc_Md5Update(Md5* md5, const byte* data, word32 len)
int wc_Md5Update(wc_Md5* md5, const byte* data, word32 len)
{
int ret = 0;
byte* local;
@ -153,7 +153,7 @@ static INLINE void AddLength(Md5* md5, word32 len);
return ret;
}
int wc_Md5Final(Md5* md5, byte* hash)
int wc_Md5Final(wc_Md5* md5, byte* hash)
{
int ret = 0;
@ -193,10 +193,10 @@ static INLINE void AddLength(Md5* md5, word32 len);
md5->digest[2] = HASH->HR[2];
md5->digest[3] = HASH->HR[3];
ByteReverseWords(md5->digest, md5->digest, MD5_DIGEST_SIZE);
ByteReverseWords(md5->digest, md5->digest, WC_MD5_DIGEST_SIZE);
#endif /* WOLFSSL_STM32_CUBEMX */
XMEMCPY(hash, md5->digest, MD5_DIGEST_SIZE);
XMEMCPY(hash, md5->digest, WC_MD5_DIGEST_SIZE);
(void)wc_InitMd5(md5); /* reset state */
@ -207,7 +207,7 @@ static INLINE void AddLength(Md5* md5, word32 len);
#include "cau_api.h"
#define XTRANSFORM(S,B) Transform((S), (B))
static int Transform(Md5* md5, byte* data)
static int Transform(wc_Md5* md5, byte* data)
{
int ret = wolfSSL_CryptHwMutexLock();
if(ret == 0) {
@ -243,7 +243,7 @@ static INLINE void AddLength(Md5* md5, word32 len);
#define MD5STEP(f, w, x, y, z, data, s) \
w = rotlFixed(w + f(x, y, z) + data, s) + x
static int Transform(Md5* md5)
static int Transform(wc_Md5* md5)
{
/* Copy context->state[] to working vars */
word32 a = md5->digest[0];
@ -330,7 +330,7 @@ static INLINE void AddLength(Md5* md5, word32 len);
#endif /* NEED_SOFT_MD5 */
#if !defined(HAVE_MD5_CUST_API) || defined(STM32_HASH)
static INLINE void AddLength(Md5* md5, word32 len)
static INLINE void AddLength(wc_Md5* md5, word32 len)
{
word32 tmp = md5->loLen;
if ((md5->loLen += len) < tmp) {
@ -340,7 +340,7 @@ static INLINE void AddLength(Md5* md5, word32 len)
#endif
#ifndef HAVE_MD5_CUST_API
static int _InitMd5(Md5* md5)
static int _InitMd5(wc_Md5* md5)
{
int ret = 0;
@ -356,7 +356,7 @@ static int _InitMd5(Md5* md5)
return ret;
}
int wc_InitMd5_ex(Md5* md5, void* heap, int devId)
int wc_InitMd5_ex(wc_Md5* md5, void* heap, int devId)
{
int ret = 0;
@ -378,7 +378,7 @@ int wc_InitMd5_ex(Md5* md5, void* heap, int devId)
return ret;
}
int wc_Md5Update(Md5* md5, const byte* data, word32 len)
int wc_Md5Update(wc_Md5* md5, const byte* data, word32 len)
{
int ret = 0;
byte* local;
@ -399,30 +399,30 @@ int wc_Md5Update(Md5* md5, const byte* data, word32 len)
local = (byte*)md5->buffer;
/* check that internal buffLen is valid */
if (md5->buffLen >= MD5_BLOCK_SIZE)
if (md5->buffLen >= WC_MD5_BLOCK_SIZE)
return BUFFER_E;
while (len) {
word32 add = min(len, MD5_BLOCK_SIZE - md5->buffLen);
word32 add = min(len, WC_MD5_BLOCK_SIZE - md5->buffLen);
XMEMCPY(&local[md5->buffLen], data, add);
md5->buffLen += add;
data += add;
len -= add;
if (md5->buffLen == MD5_BLOCK_SIZE) {
if (md5->buffLen == WC_MD5_BLOCK_SIZE) {
#if defined(BIG_ENDIAN_ORDER) && !defined(FREESCALE_MMCAU_SHA)
ByteReverseWords(md5->buffer, md5->buffer, MD5_BLOCK_SIZE);
ByteReverseWords(md5->buffer, md5->buffer, WC_MD5_BLOCK_SIZE);
#endif
XTRANSFORM(md5, local);
AddLength(md5, MD5_BLOCK_SIZE);
AddLength(md5, WC_MD5_BLOCK_SIZE);
md5->buffLen = 0;
}
}
return ret;
}
int wc_Md5Final(Md5* md5, byte* hash)
int wc_Md5Final(wc_Md5* md5, byte* hash)
{
byte* local;
@ -433,7 +433,7 @@ int wc_Md5Final(Md5* md5, byte* hash)
#if defined(WOLFSSL_ASYNC_CRYPT) && defined(WC_ASYNC_ENABLE_MD5)
if (md5->asyncDev.marker == WOLFSSL_ASYNC_MARKER_MD5) {
#if defined(HAVE_INTEL_QA)
return IntelQaSymMd5(&md5->asyncDev, hash, NULL, MD5_DIGEST_SIZE);
return IntelQaSymMd5(&md5->asyncDev, hash, NULL, WC_MD5_DIGEST_SIZE);
#endif
}
#endif /* WOLFSSL_ASYNC_CRYPT */
@ -444,20 +444,20 @@ int wc_Md5Final(Md5* md5, byte* hash)
local[md5->buffLen++] = 0x80; /* add 1 */
/* pad with zeros */
if (md5->buffLen > MD5_PAD_SIZE) {
XMEMSET(&local[md5->buffLen], 0, MD5_BLOCK_SIZE - md5->buffLen);
md5->buffLen += MD5_BLOCK_SIZE - md5->buffLen;
if (md5->buffLen > WC_MD5_PAD_SIZE) {
XMEMSET(&local[md5->buffLen], 0, WC_MD5_BLOCK_SIZE - md5->buffLen);
md5->buffLen += WC_MD5_BLOCK_SIZE - md5->buffLen;
#if defined(BIG_ENDIAN_ORDER) && !defined(FREESCALE_MMCAU_SHA)
ByteReverseWords(md5->buffer, md5->buffer, MD5_BLOCK_SIZE);
ByteReverseWords(md5->buffer, md5->buffer, WC_MD5_BLOCK_SIZE);
#endif
XTRANSFORM(md5, local);
md5->buffLen = 0;
}
XMEMSET(&local[md5->buffLen], 0, MD5_PAD_SIZE - md5->buffLen);
XMEMSET(&local[md5->buffLen], 0, WC_MD5_PAD_SIZE - md5->buffLen);
#if defined(BIG_ENDIAN_ORDER) && !defined(FREESCALE_MMCAU_SHA)
ByteReverseWords(md5->buffer, md5->buffer, MD5_BLOCK_SIZE);
ByteReverseWords(md5->buffer, md5->buffer, WC_MD5_BLOCK_SIZE);
#endif
/* put lengths in bits */
@ -467,22 +467,22 @@ int wc_Md5Final(Md5* md5, byte* hash)
/* store lengths */
/* ! length ordering dependent on digest endian type ! */
XMEMCPY(&local[MD5_PAD_SIZE], &md5->loLen, sizeof(word32));
XMEMCPY(&local[MD5_PAD_SIZE + sizeof(word32)], &md5->hiLen, sizeof(word32));
XMEMCPY(&local[WC_MD5_PAD_SIZE], &md5->loLen, sizeof(word32));
XMEMCPY(&local[WC_MD5_PAD_SIZE + sizeof(word32)], &md5->hiLen, sizeof(word32));
/* final transform and result to hash */
XTRANSFORM(md5, local);
#ifdef BIG_ENDIAN_ORDER
ByteReverseWords(md5->digest, md5->digest, MD5_DIGEST_SIZE);
ByteReverseWords(md5->digest, md5->digest, WC_MD5_DIGEST_SIZE);
#endif
XMEMCPY(hash, md5->digest, MD5_DIGEST_SIZE);
XMEMCPY(hash, md5->digest, WC_MD5_DIGEST_SIZE);
return _InitMd5(md5); /* reset state */
}
#endif /* !HAVE_MD5_CUST_API */
int wc_InitMd5(Md5* md5)
int wc_InitMd5(wc_Md5* md5)
{
if (md5 == NULL) {
return BAD_FUNC_ARG;
@ -490,7 +490,7 @@ int wc_InitMd5(Md5* md5)
return wc_InitMd5_ex(md5, NULL, INVALID_DEVID);
}
void wc_Md5Free(Md5* md5)
void wc_Md5Free(wc_Md5* md5)
{
if (md5 == NULL)
return;
@ -499,10 +499,10 @@ void wc_Md5Free(Md5* md5)
#endif /* WOLFSSL_ASYNC_CRYPT */
}
int wc_Md5GetHash(Md5* md5, byte* hash)
int wc_Md5GetHash(wc_Md5* md5, byte* hash)
{
int ret;
Md5 tmpMd5;
wc_Md5 tmpMd5;
if (md5 == NULL || hash == NULL)
return BAD_FUNC_ARG;
@ -515,14 +515,14 @@ int wc_Md5GetHash(Md5* md5, byte* hash)
return ret;
}
int wc_Md5Copy(Md5* src, Md5* dst)
int wc_Md5Copy(wc_Md5* src, wc_Md5* dst)
{
int ret = 0;
if (src == NULL || dst == NULL)
return BAD_FUNC_ARG;
XMEMCPY(dst, src, sizeof(Md5));
XMEMCPY(dst, src, sizeof(wc_Md5));
#ifdef WOLFSSL_ASYNC_CRYPT
ret = wolfAsync_DevCopy(&src->asyncDev, &dst->asyncDev);

16
wolfcrypt/src/pkcs12.c
View File

@ -499,26 +499,26 @@ static int wc_PKCS12_verify(WC_PKCS12* pkcs12, byte* data, word32 dataSz,
switch (mac->oid) {
#ifndef NO_SHA
case SHAh: /* 88 */
typeH = SHA;
kLen = SHA_DIGEST_SIZE;
typeH = WC_SHA;
kLen = WC_SHA_DIGEST_SIZE;
break;
#endif
#ifndef NO_SHA256
case SHA256h: /* 414 */
typeH = SHA256;
kLen = SHA256_DIGEST_SIZE;
typeH = WC_SHA256;
kLen = WC_SHA256_DIGEST_SIZE;
break;
#endif
#ifdef WOLFSSL_SHA384
case SHA384h: /* 415 */
typeH = SHA384;
kLen = SHA384_DIGEST_SIZE;
typeH = WC_SHA384;
kLen = WC_SHA384_DIGEST_SIZE;
break;
#endif
#ifdef WOLFSSL_SHA512
case SHA512h: /* 416 */
typeH = SHA512;
kLen = SHA512_DIGEST_SIZE;
typeH = WC_SHA512;
kLen = WC_SHA512_DIGEST_SIZE;
break;
#endif
default: /* May be SHA224 or was just not built in */

4
wolfcrypt/src/pkcs7.c
View File

@ -3217,7 +3217,7 @@ static int wc_PKCS7_DecodeKtri(PKCS7* pkcs7, byte* pkiMsg, word32 pkiMsgSz,
int keySz;
word32 encOID;
word32 keyIdx;
byte issuerHash[SHA_DIGEST_SIZE];
byte issuerHash[WC_SHA_DIGEST_SIZE];
byte* outKey = NULL;
#ifdef WC_RSA_BLINDING
@ -3245,7 +3245,7 @@ static int wc_PKCS7_DecodeKtri(PKCS7* pkcs7, byte* pkiMsg, word32 pkiMsgSz,
return ASN_PARSE_E;
/* if we found correct recipient, issuer hashes will match */
if (XMEMCMP(issuerHash, pkcs7->issuerHash, SHA_DIGEST_SIZE) == 0) {
if (XMEMCMP(issuerHash, pkcs7->issuerHash, WC_SHA_DIGEST_SIZE) == 0) {
*recipFound = 1;
}

98
wolfcrypt/src/port/arm/armv8-sha256.c
View File

@ -58,7 +58,7 @@ static const ALIGN32 word32 K[64] = {
};
static int InitSha256(Sha256* sha256)
static int InitSha256(wc_Sha256* sha256)
{
int ret = 0;
@ -82,7 +82,7 @@ static int InitSha256(Sha256* sha256)
return ret;
}
static INLINE void AddLength(Sha256* sha256, word32 len)
static INLINE void AddLength(wc_Sha256* sha256, word32 len)
{
word32 tmp = sha256->loLen;
if ((sha256->loLen += len) < tmp)
@ -93,7 +93,7 @@ static INLINE void AddLength(Sha256* sha256, word32 len)
#ifdef __aarch64__
/* ARMv8 hardware accleration */
static INLINE int Sha256Update(Sha256* sha256, const byte* data, word32 len)
static INLINE int Sha256Update(wc_Sha256* sha256, const byte* data, word32 len)
{
word32 add;
word32 numBlocks;
@ -101,20 +101,20 @@ static INLINE int Sha256Update(Sha256* sha256, const byte* data, word32 len)
/* only perform actions if a buffer is passed in */
if (len > 0) {
/* fill leftover buffer with data */
add = min(len, SHA256_BLOCK_SIZE - sha256->buffLen);
add = min(len, WC_SHA256_BLOCK_SIZE - sha256->buffLen);
XMEMCPY((byte*)(sha256->buffer) + sha256->buffLen, data, add);
sha256->buffLen += add;
data += add;
len -= add;
/* number of blocks in a row to complete */
numBlocks = (len + sha256->buffLen)/SHA256_BLOCK_SIZE;
numBlocks = (len + sha256->buffLen)/WC_SHA256_BLOCK_SIZE;
if (numBlocks > 0) {
word32* k = (word32*)K;
/* get leftover amount after blocks */
add = (len + sha256->buffLen) - numBlocks * SHA256_BLOCK_SIZE;
add = (len + sha256->buffLen) - numBlocks * WC_SHA256_BLOCK_SIZE;
__asm__ volatile (
"#load leftover data\n"
"LD1 {v0.2d-v3.2d}, %[buffer] \n"
@ -290,7 +290,7 @@ static INLINE int Sha256Update(Sha256* sha256, const byte* data, word32 len)
"v29", "v30", "v31", "w8"
);
AddLength(sha256, SHA256_BLOCK_SIZE * numBlocks);
AddLength(sha256, WC_SHA256_BLOCK_SIZE * numBlocks);
/* copy over any remaining data leftover */
XMEMCPY(sha256->buffer, data, add);
@ -306,7 +306,7 @@ static INLINE int Sha256Update(Sha256* sha256, const byte* data, word32 len)
}
static INLINE int Sha256Final(Sha256* sha256, byte* hash)
static INLINE int Sha256Final(wc_Sha256* sha256, byte* hash)
{
byte* local;
@ -316,10 +316,10 @@ static INLINE int Sha256Final(Sha256* sha256, byte* hash)
local[sha256->buffLen++] = 0x80; /* add 1 */
/* pad with zeros */
if (sha256->buffLen > SHA256_PAD_SIZE) {
if (sha256->buffLen > WC_SHA256_PAD_SIZE) {
XMEMSET(&local[sha256->buffLen], 0, SHA256_BLOCK_SIZE - sha256->buffLen);
sha256->buffLen += SHA256_BLOCK_SIZE - sha256->buffLen;
XMEMSET(&local[sha256->buffLen], 0, WC_SHA256_BLOCK_SIZE - sha256->buffLen);
sha256->buffLen += WC_SHA256_BLOCK_SIZE - sha256->buffLen;
__asm__ volatile (
"LD1 {v4.2d-v7.2d}, %[buffer] \n"
"MOV v0.16b, v4.16b \n"
@ -471,7 +471,7 @@ static INLINE int Sha256Final(Sha256* sha256, byte* hash)
sha256->buffLen = 0;
}
XMEMSET(&local[sha256->buffLen], 0, SHA256_PAD_SIZE - sha256->buffLen);
XMEMSET(&local[sha256->buffLen], 0, WC_SHA256_PAD_SIZE - sha256->buffLen);
/* put lengths in bits */
sha256->hiLen = (sha256->loLen >> (8*sizeof(sha256->loLen) - 3)) +
@ -493,8 +493,8 @@ static INLINE int Sha256Final(Sha256* sha256, byte* hash)
);
#endif
/* ! length ordering dependent on digest endian type ! */
XMEMCPY(&local[SHA256_PAD_SIZE], &sha256->hiLen, sizeof(word32));
XMEMCPY(&local[SHA256_PAD_SIZE + sizeof(word32)], &sha256->loLen,
XMEMCPY(&local[WC_SHA256_PAD_SIZE], &sha256->hiLen, sizeof(word32));
XMEMCPY(&local[WC_SHA256_PAD_SIZE + sizeof(word32)], &sha256->loLen,
sizeof(word32));
__asm__ volatile (
@ -655,7 +655,7 @@ static INLINE int Sha256Final(Sha256* sha256, byte* hash)
#else /* not using 64 bit */
/* ARMv8 hardware accleration Aarch32 */
static INLINE int Sha256Update(Sha256* sha256, const byte* data, word32 len)
static INLINE int Sha256Update(wc_Sha256* sha256, const byte* data, word32 len)
{
word32 add;
word32 numBlocks;
@ -663,20 +663,20 @@ static INLINE int Sha256Update(Sha256* sha256, const byte* data, word32 len)
/* only perform actions if a buffer is passed in */
if (len > 0) {
/* fill leftover buffer with data */
add = min(len, SHA256_BLOCK_SIZE - sha256->buffLen);
add = min(len, WC_SHA256_BLOCK_SIZE - sha256->buffLen);
XMEMCPY((byte*)(sha256->buffer) + sha256->buffLen, data, add);
sha256->buffLen += add;
data += add;
len -= add;
/* number of blocks in a row to complete */
numBlocks = (len + sha256->buffLen)/SHA256_BLOCK_SIZE;
numBlocks = (len + sha256->buffLen)/WC_SHA256_BLOCK_SIZE;
if (numBlocks > 0) {
word32* bufPt = sha256->buffer;
word32* digPt = sha256->digest;
/* get leftover amount after blocks */
add = (len + sha256->buffLen) - numBlocks * SHA256_BLOCK_SIZE;
add = (len + sha256->buffLen) - numBlocks * WC_SHA256_BLOCK_SIZE;
__asm__ volatile (
"#load leftover data\n"
"VLDM %[buffer]!, {q0-q3} \n"
@ -866,7 +866,7 @@ static INLINE int Sha256Update(Sha256* sha256, const byte* data, word32 len)
"q15", "r8"
);
AddLength(sha256, SHA256_BLOCK_SIZE * numBlocks);
AddLength(sha256, WC_SHA256_BLOCK_SIZE * numBlocks);
/* copy over any remaining data leftover */
XMEMCPY(sha256->buffer, data, add);
@ -882,7 +882,7 @@ static INLINE int Sha256Update(Sha256* sha256, const byte* data, word32 len)
}
static INLINE int Sha256Final(Sha256* sha256, byte* hash)
static INLINE int Sha256Final(wc_Sha256* sha256, byte* hash)
{
byte* local;
@ -896,11 +896,11 @@ static INLINE int Sha256Final(Sha256* sha256, byte* hash)
local[sha256->buffLen++] = 0x80; /* add 1 */
/* pad with zeros */
if (sha256->buffLen > SHA256_PAD_SIZE) {
if (sha256->buffLen > WC_SHA256_PAD_SIZE) {
word32* bufPt = sha256->buffer;
word32* digPt = sha256->digest;
XMEMSET(&local[sha256->buffLen], 0, SHA256_BLOCK_SIZE - sha256->buffLen);
sha256->buffLen += SHA256_BLOCK_SIZE - sha256->buffLen;
XMEMSET(&local[sha256->buffLen], 0, WC_SHA256_BLOCK_SIZE - sha256->buffLen);
sha256->buffLen += WC_SHA256_BLOCK_SIZE - sha256->buffLen;
__asm__ volatile (
"#load leftover data\n"
"VLDM %[buffer]!, {q0-q3} \n"
@ -1071,7 +1071,7 @@ static INLINE int Sha256Final(Sha256* sha256, byte* hash)
sha256->buffLen = 0;
}
XMEMSET(&local[sha256->buffLen], 0, SHA256_PAD_SIZE - sha256->buffLen);
XMEMSET(&local[sha256->buffLen], 0, WC_SHA256_PAD_SIZE - sha256->buffLen);
/* put lengths in bits */
sha256->hiLen = (sha256->loLen >> (8*sizeof(sha256->loLen) - 3)) +
@ -1100,8 +1100,8 @@ static INLINE int Sha256Final(Sha256* sha256, byte* hash)
);
#endif
/* ! length ordering dependent on digest endian type ! */
XMEMCPY(&local[SHA256_PAD_SIZE], &sha256->hiLen, sizeof(word32));
XMEMCPY(&local[SHA256_PAD_SIZE + sizeof(word32)], &sha256->loLen,
XMEMCPY(&local[WC_SHA256_PAD_SIZE], &sha256->hiLen, sizeof(word32));
XMEMCPY(&local[WC_SHA256_PAD_SIZE + sizeof(word32)], &sha256->loLen,
sizeof(word32));
bufPt = sha256->buffer;
@ -1285,7 +1285,7 @@ static INLINE int Sha256Final(Sha256* sha256, byte* hash)
#ifndef NO_SHA256
int wc_InitSha256_ex(Sha256* sha256, void* heap, int devId)
int wc_InitSha256_ex(wc_Sha256* sha256, void* heap, int devId)
{
if (sha256 == NULL)
return BAD_FUNC_ARG;
@ -1296,17 +1296,17 @@ int wc_InitSha256_ex(Sha256* sha256, void* heap, int devId)
return InitSha256(sha256);
}
int wc_InitSha256(Sha256* sha256)
int wc_InitSha256(wc_Sha256* sha256)
{
return wc_InitSha256_ex(sha256, NULL, INVALID_DEVID);
}
void wc_Sha256Free(Sha256* sha256)
void wc_Sha256Free(wc_Sha256* sha256)
{
(void)sha256;
}
int wc_Sha256Update(Sha256* sha256, const byte* data, word32 len)
int wc_Sha256Update(wc_Sha256* sha256, const byte* data, word32 len)
{
if (sha256 == NULL || (data == NULL && len != 0)) {
return BAD_FUNC_ARG;
@ -1315,7 +1315,7 @@ int wc_Sha256Update(Sha256* sha256, const byte* data, word32 len)
return Sha256Update(sha256, data, len);
}
int wc_Sha256Final(Sha256* sha256, byte* hash)
int wc_Sha256Final(wc_Sha256* sha256, byte* hash)
{
int ret;
@ -1330,10 +1330,10 @@ int wc_Sha256Final(Sha256* sha256, byte* hash)
return InitSha256(sha256); /* reset state */
}
int wc_Sha256GetHash(Sha256* sha256, byte* hash)
int wc_Sha256GetHash(wc_Sha256* sha256, byte* hash)
{
int ret;
Sha256 tmpSha256;
wc_Sha256 tmpSha256;
if (sha256 == NULL || hash == NULL)
return BAD_FUNC_ARG;
@ -1345,14 +1345,14 @@ int wc_Sha256GetHash(Sha256* sha256, byte* hash)
return ret;
}
int wc_Sha256Copy(Sha256* src, Sha256* dst)
int wc_Sha256Copy(wc_Sha256* src, wc_Sha256* dst)
{
int ret = 0;
if (src == NULL || dst == NULL)
return BAD_FUNC_ARG;
XMEMCPY(dst, src, sizeof(Sha256));
XMEMCPY(dst, src, sizeof(wc_Sha256));
return ret;
}
@ -1361,7 +1361,7 @@ int wc_Sha256Copy(Sha256* src, Sha256* dst)
#ifdef WOLFSSL_SHA224
static int InitSha224(Sha224* sha224)
static int InitSha224(wc_Sha224* sha224)
{
int ret = 0;
@ -1386,7 +1386,7 @@ int wc_Sha256Copy(Sha256* src, Sha256* dst)
return ret;
}
int wc_InitSha224_ex(Sha224* sha224, void* heap, int devId)
int wc_InitSha224_ex(wc_Sha224* sha224, void* heap, int devId)
{
if (sha224 == NULL)
return BAD_FUNC_ARG;
@ -1397,12 +1397,12 @@ int wc_Sha256Copy(Sha256* src, Sha256* dst)
return InitSha224(sha224);
}
int wc_InitSha224(Sha224* sha224)
int wc_InitSha224(wc_Sha224* sha224)
{
return wc_InitSha224_ex(sha224, NULL, INVALID_DEVID);
}
int wc_Sha224Update(Sha224* sha224, const byte* data, word32 len)
int wc_Sha224Update(wc_Sha224* sha224, const byte* data, word32 len)
{
int ret;
@ -1410,39 +1410,39 @@ int wc_Sha256Copy(Sha256* src, Sha256* dst)
return BAD_FUNC_ARG;
}
ret = Sha256Update((Sha256 *)sha224, data, len);
ret = Sha256Update((wc_Sha256 *)sha224, data, len);
return ret;
}
int wc_Sha224Final(Sha224* sha224, byte* hash)
int wc_Sha224Final(wc_Sha224* sha224, byte* hash)
{
int ret;
word32 hashTmp[SHA256_DIGEST_SIZE/sizeof(word32)];
word32 hashTmp[WC_SHA256_DIGEST_SIZE/sizeof(word32)];
if (sha224 == NULL || hash == NULL) {
return BAD_FUNC_ARG;
}
ret = Sha256Final((Sha256*)sha224, (byte*)hashTmp);
ret = Sha256Final((wc_Sha256*)sha224, (byte*)hashTmp);
if (ret != 0)
return ret;
XMEMCPY(hash, hashTmp, SHA224_DIGEST_SIZE);
XMEMCPY(hash, hashTmp, WC_SHA224_DIGEST_SIZE);
return InitSha224(sha224); /* reset state */
}
void wc_Sha224Free(Sha224* sha224)
void wc_Sha224Free(wc_Sha224* sha224)
{
if (sha224 == NULL)
return;
}
int wc_Sha224GetHash(Sha224* sha224, byte* hash)
int wc_Sha224GetHash(wc_Sha224* sha224, byte* hash)
{
int ret;
Sha224 tmpSha224;
wc_Sha224 tmpSha224;
if (sha224 == NULL || hash == NULL)
return BAD_FUNC_ARG;
@ -1453,14 +1453,14 @@ int wc_Sha256Copy(Sha256* src, Sha256* dst)
}
return ret;
}
int wc_Sha224Copy(Sha224* src, Sha224* dst)
int wc_Sha224Copy(wc_Sha224* src, wc_Sha224* dst)
{
int ret = 0;
if (src == NULL || dst == NULL)
return BAD_FUNC_ARG;
XMEMCPY(dst, src, sizeof(Sha224));
XMEMCPY(dst, src, sizeof(wc_Sha224));
return ret;
}

86
wolfcrypt/src/pwdbased.c
View File

@ -49,20 +49,20 @@
int wc_PBKDF1(byte* output, const byte* passwd, int pLen, const byte* salt,
int sLen, int iterations, int kLen, int hashType)
{
Sha sha;
wc_Sha sha;
#ifndef NO_MD5
Md5 md5;
wc_Md5 md5;
#endif
int hLen = (int)SHA_DIGEST_SIZE;
int hLen = (int)WC_SHA_DIGEST_SIZE;
int i, ret = 0;
byte buffer[SHA_DIGEST_SIZE]; /* max size */
byte buffer[WC_SHA_DIGEST_SIZE]; /* max size */
if (hashType != MD5 && hashType != SHA)
if (hashType != WC_MD5 && hashType != WC_SHA)
return BAD_FUNC_ARG;
#ifndef NO_MD5
if (hashType == MD5)
hLen = (int)MD5_DIGEST_SIZE;
if (hashType == WC_MD5)
hLen = (int)WC_MD5_DIGEST_SIZE;
#endif
if ((kLen > hLen) || (kLen < 0))
@ -73,7 +73,7 @@ int wc_PBKDF1(byte* output, const byte* passwd, int pLen, const byte* salt,
switch (hashType) {
#ifndef NO_MD5
case MD5:
case WC_MD5:
ret = wc_InitMd5(&md5);
if (ret != 0) {
return ret;
@ -92,7 +92,7 @@ int wc_PBKDF1(byte* output, const byte* passwd, int pLen, const byte* salt,
}
break;
#endif /* NO_MD5 */
case SHA:
case WC_SHA:
default:
ret = wc_InitSha(&sha);
if (ret != 0)
@ -104,7 +104,7 @@ int wc_PBKDF1(byte* output, const byte* passwd, int pLen, const byte* salt,
}
for (i = 1; i < iterations; i++) {
if (hashType == SHA) {
if (hashType == WC_SHA) {
wc_ShaUpdate(&sha, buffer, hLen);
wc_ShaFinal(&sha, buffer);
}
@ -134,23 +134,23 @@ int GetDigestSize(int hashType)
switch (hashType) {
#ifndef NO_MD5
case MD5:
hLen = MD5_DIGEST_SIZE;
case WC_MD5:
hLen = WC_MD5_DIGEST_SIZE;
break;
#endif
#ifndef NO_SHA
case SHA:
hLen = SHA_DIGEST_SIZE;
case WC_SHA:
hLen = WC_SHA_DIGEST_SIZE;
break;
#endif
#ifndef NO_SHA256
case SHA256:
hLen = SHA256_DIGEST_SIZE;
case WC_SHA256:
hLen = WC_SHA256_DIGEST_SIZE;
break;
#endif
#ifdef WOLFSSL_SHA512
case SHA512:
hLen = SHA512_DIGEST_SIZE;
case WC_SHA512:
hLen = WC_SHA512_DIGEST_SIZE;
break;
#endif
default:
@ -244,11 +244,11 @@ int wc_PBKDF2(byte* output, const byte* passwd, int pLen, const byte* salt,
}
#ifdef WOLFSSL_SHA512
#define PBKDF_DIGEST_SIZE SHA512_BLOCK_SIZE
#define PBKDF_DIGEST_SIZE WC_SHA512_BLOCK_SIZE
#elif !defined(NO_SHA256)
#define PBKDF_DIGEST_SIZE SHA256_BLOCK_SIZE
#define PBKDF_DIGEST_SIZE WC_SHA256_BLOCK_SIZE
#else
#define PBKDF_DIGEST_SIZE SHA_DIGEST_SIZE
#define PBKDF_DIGEST_SIZE WC_SHA_DIGEST_SIZE
#endif
/* helper for wc_PKCS12_PBKDF(), sets block and digest sizes */
@ -259,27 +259,27 @@ int GetPKCS12HashSizes(int hashType, word32* v, word32* u)
switch (hashType) {
#ifndef NO_MD5
case MD5:
*v = MD5_BLOCK_SIZE;
*u = MD5_DIGEST_SIZE;
case WC_MD5:
*v = WC_MD5_BLOCK_SIZE;
*u = WC_MD5_DIGEST_SIZE;
break;
#endif
#ifndef NO_SHA
case SHA:
*v = SHA_BLOCK_SIZE;
*u = SHA_DIGEST_SIZE;
case WC_SHA:
*v = WC_SHA_BLOCK_SIZE;
*u = WC_SHA_DIGEST_SIZE;
break;
#endif
#ifndef NO_SHA256
case SHA256:
*v = SHA256_BLOCK_SIZE;
*u = SHA256_DIGEST_SIZE;
case WC_SHA256:
*v = WC_SHA256_BLOCK_SIZE;
*u = WC_SHA256_DIGEST_SIZE;
break;
#endif
#ifdef WOLFSSL_SHA512
case SHA512:
*v = SHA512_BLOCK_SIZE;
*u = SHA512_DIGEST_SIZE;
case WC_SHA512:
*v = WC_SHA512_BLOCK_SIZE;
*u = WC_SHA512_DIGEST_SIZE;
break;
#endif
default:
@ -301,9 +301,9 @@ int DoPKCS12Hash(int hashType, byte* buffer, word32 totalLen,
switch (hashType) {
#ifndef NO_MD5
case MD5:
case WC_MD5:
{
Md5 md5;
wc_Md5 md5;
ret = wc_InitMd5(&md5);
if (ret != 0) {
break;
@ -331,9 +331,9 @@ int DoPKCS12Hash(int hashType, byte* buffer, word32 totalLen,
break;
#endif /* NO_MD5 */
#ifndef NO_SHA
case SHA:
case WC_SHA:
{
Sha sha;
wc_Sha sha;
ret = wc_InitSha(&sha);
if (ret != 0)
break;
@ -360,9 +360,9 @@ int DoPKCS12Hash(int hashType, byte* buffer, word32 totalLen,
break;
#endif /* NO_SHA */
#ifndef NO_SHA256
case SHA256:
case WC_SHA256:
{
Sha256 sha256;
wc_Sha256 sha256;
ret = wc_InitSha256(&sha256);
if (ret != 0)
break;
@ -388,9 +388,9 @@ int DoPKCS12Hash(int hashType, byte* buffer, word32 totalLen,
break;
#endif /* NO_SHA256 */
#ifdef WOLFSSL_SHA512
case SHA512:
case WC_SHA512:
{
Sha512 sha512;
wc_Sha512 sha512;
ret = wc_InitSha512(&sha512);
if (ret != 0)
break;
@ -804,7 +804,7 @@ int wc_scrypt(byte* output, const byte* passwd, int passLen,
/* Step 1. */
ret = wc_PBKDF2(blocks, passwd, passLen, salt, saltLen, 1, blocksSz,
SHA256);
WC_SHA256);
if (ret != 0)
goto end;
@ -814,7 +814,7 @@ int wc_scrypt(byte* output, const byte* passwd, int passLen,
/* Step 3. */
ret = wc_PBKDF2(output, passwd, passLen, blocks, blocksSz, 1, dkLen,
SHA256);
WC_SHA256);
end:
if (blocks != NULL)
XFREE(blocks, NULL, DYNAMIC_TYPE_TMP_BUFFER);

22
wolfcrypt/src/random.c
View File

@ -152,7 +152,7 @@ int wc_RNG_GenerateByte(WC_RNG* rng, byte* b)
/* Start NIST DRBG code */
#ifdef HAVE_HASHDRBG
#define OUTPUT_BLOCK_LEN (SHA256_DIGEST_SIZE)
#define OUTPUT_BLOCK_LEN (WC_SHA256_DIGEST_SIZE)
#define MAX_REQUEST_LEN (0x10000)
#define RESEED_INTERVAL WC_RESEED_INTERVAL
#define SECURITY_STRENGTH (256)
@ -173,7 +173,7 @@ int wc_RNG_GenerateByte(WC_RNG* rng, byte* b)
#define DRBG_FAILED 2
#define DRBG_CONT_FAILED 3
#define RNG_HEALTH_TEST_CHECK_SIZE (SHA256_DIGEST_SIZE * 4)
#define RNG_HEALTH_TEST_CHECK_SIZE (WC_SHA256_DIGEST_SIZE * 4)
/* Verify max gen block len */
#if RNG_MAX_BLOCK_LEN > MAX_REQUEST_LEN
@ -215,8 +215,8 @@ static int Hash_df(DRBG* drbg, byte* out, word32 outSz, byte type,
int i;
int len;
word32 bits = (outSz * 8); /* reverse byte order */
Sha256 sha;
DECLARE_VAR(digest, byte, SHA256_DIGEST_SIZE, drbg->heap);
wc_Sha256 sha;
DECLARE_VAR(digest, byte, WC_SHA256_DIGEST_SIZE, drbg->heap);
(void)drbg;
#ifdef WOLFSSL_ASYNC_CRYPT
@ -271,7 +271,7 @@ static int Hash_df(DRBG* drbg, byte* out, word32 outSz, byte type,
}
}
ForceZero(digest, SHA256_DIGEST_SIZE);
ForceZero(digest, WC_SHA256_DIGEST_SIZE);
FREE_VAR(digest, drbg->heap);
@ -321,8 +321,8 @@ static int Hash_gen(DRBG* drbg, byte* out, word32 outSz, const byte* V)
int i;
int len;
word32 checkBlock;
Sha256 sha;
DECLARE_VAR(digest, byte, SHA256_DIGEST_SIZE, drbg->heap);
wc_Sha256 sha;
DECLARE_VAR(digest, byte, WC_SHA256_DIGEST_SIZE, drbg->heap);
/* Special case: outSz is 0 and out is NULL. wc_Generate a block to save for
* the continuous test. */
@ -409,14 +409,14 @@ static INLINE void array_add(byte* d, word32 dLen, const byte* s, word32 sLen)
static int Hash_DRBG_Generate(DRBG* drbg, byte* out, word32 outSz)
{
int ret;
Sha256 sha;
wc_Sha256 sha;
byte type;
word32 reseedCtr;
if (drbg->reseedCtr == RESEED_INTERVAL) {
return DRBG_NEED_RESEED;
} else {
DECLARE_VAR(digest, byte, SHA256_DIGEST_SIZE, drbg->heap);
DECLARE_VAR(digest, byte, WC_SHA256_DIGEST_SIZE, drbg->heap);
type = drbgGenerateH;
reseedCtr = drbg->reseedCtr;
@ -437,7 +437,7 @@ static int Hash_DRBG_Generate(DRBG* drbg, byte* out, word32 outSz)
wc_Sha256Free(&sha);
if (ret == 0) {
array_add(drbg->V, sizeof(drbg->V), digest, SHA256_DIGEST_SIZE);
array_add(drbg->V, sizeof(drbg->V), digest, WC_SHA256_DIGEST_SIZE);
array_add(drbg->V, sizeof(drbg->V), drbg->C, sizeof(drbg->C));
#ifdef LITTLE_ENDIAN_ORDER
reseedCtr = ByteReverseWord32(reseedCtr);
@ -448,7 +448,7 @@ static int Hash_DRBG_Generate(DRBG* drbg, byte* out, word32 outSz)
}
drbg->reseedCtr++;
}
ForceZero(digest, SHA256_DIGEST_SIZE);
ForceZero(digest, WC_SHA256_DIGEST_SIZE);
FREE_VAR(digest, drbg->heap);
}

100
wolfcrypt/src/sha.c
View File

@ -33,14 +33,14 @@
/* fips wrapper calls, user can call direct */
#ifdef HAVE_FIPS
int wc_InitSha(Sha* sha)
int wc_InitSha(wc_Sha* sha)
{
if (sha == NULL) {
return BAD_FUNC_ARG;
}
return InitSha_fips(sha);
}
int wc_InitSha_ex(Sha* sha, void* heap, int devId)
int wc_InitSha_ex(wc_Sha* sha, void* heap, int devId)
{
(void)heap;
(void)devId;
@ -50,7 +50,7 @@
return InitSha_fips(sha);
}
int wc_ShaUpdate(Sha* sha, const byte* data, word32 len)
int wc_ShaUpdate(wc_Sha* sha, const byte* data, word32 len)
{
if (sha == NULL || (data == NULL && len > 0)) {
return BAD_FUNC_ARG;
@ -58,14 +58,14 @@
return ShaUpdate_fips(sha, data, len);
}
int wc_ShaFinal(Sha* sha, byte* out)
int wc_ShaFinal(wc_Sha* sha, byte* out)
{
if (sha == NULL || out == NULL) {
return BAD_FUNC_ARG;
}
return ShaFinal_fips(sha,out);
}
void wc_ShaFree(Sha* sha)
void wc_ShaFree(wc_Sha* sha)
{
(void)sha;
/* Not supported in FIPS */
@ -87,7 +87,7 @@
#include <wolfcrypt/src/misc.c>
#endif
static INLINE void AddLength(Sha* sha, word32 len);
static INLINE void AddLength(wc_Sha* sha, word32 len);
/* Hardware Acceleration */
@ -103,7 +103,7 @@ static INLINE void AddLength(Sha* sha, word32 len);
/* STM32 register size, bytes */
#ifdef WOLFSSL_STM32_CUBEMX
#define SHA_REG_SIZE SHA_BLOCK_SIZE
#define SHA_REG_SIZE WC_SHA_BLOCK_SIZE
#else
#define SHA_REG_SIZE 4
/* STM32 struct notes:
@ -114,7 +114,7 @@ static INLINE void AddLength(Sha* sha, word32 len);
#endif
#define SHA_HW_TIMEOUT 0xFF
int wc_InitSha_ex(Sha* sha, void* heap, int devId)
int wc_InitSha_ex(wc_Sha* sha, void* heap, int devId)
{
if (sha == NULL)
return BAD_FUNC_ARG;
@ -153,7 +153,7 @@ static INLINE void AddLength(Sha* sha, word32 len);
return 0;
}
int wc_ShaUpdate(Sha* sha, const byte* data, word32 len)
int wc_ShaUpdate(wc_Sha* sha, const byte* data, word32 len)
{
int ret = 0;
byte* local;
@ -194,7 +194,7 @@ static INLINE void AddLength(Sha* sha, word32 len);
return ret;
}
int wc_ShaFinal(Sha* sha, byte* hash)
int wc_ShaFinal(wc_Sha* sha, byte* hash)
{
int ret = 0;
@ -236,10 +236,10 @@ static INLINE void AddLength(Sha* sha, word32 len);
sha->digest[3] = HASH->HR[3];
sha->digest[4] = HASH->HR[4];
ByteReverseWords(sha->digest, sha->digest, SHA_DIGEST_SIZE);
ByteReverseWords(sha->digest, sha->digest, WC_SHA_DIGEST_SIZE);
#endif /* WOLFSSL_STM32_CUBEMX */
XMEMCPY(hash, sha->digest, SHA_DIGEST_SIZE);
XMEMCPY(hash, sha->digest, WC_SHA_DIGEST_SIZE);
(void)wc_InitSha_ex(sha, sha->heap, INVALID_DEVID); /* reset state */
@ -250,21 +250,21 @@ static INLINE void AddLength(Sha* sha, word32 len);
#elif defined(FREESCALE_LTC_SHA)
#include "fsl_ltc.h"
static int InitSha(Sha* sha)
static int InitSha(wc_Sha* sha)
{
LTC_HASH_Init(LTC_BASE, &sha->ctx, kLTC_Sha1, NULL, 0);
return 0;
}
int wc_ShaUpdate(Sha* sha, const byte* data, word32 len)
int wc_ShaUpdate(wc_Sha* sha, const byte* data, word32 len)
{
LTC_HASH_Update(&sha->ctx, data, len);
return 0;
}
int wc_ShaFinal(Sha* sha, byte* hash)
int wc_ShaFinal(wc_Sha* sha, byte* hash)
{
uint32_t hashlen = SHA_DIGEST_SIZE;
uint32_t hashlen = WC_SHA_DIGEST_SIZE;
LTC_HASH_Finish(&sha->ctx, hash, &hashlen);
return wc_InitSha(sha); /* reset state */
}
@ -281,7 +281,7 @@ static INLINE void AddLength(Sha* sha, word32 len);
#define USE_SHA_SOFTWARE_IMPL /* Only for API's, actual transform is here */
#define XTRANSFORM(S,B) Transform((S),(B))
static int InitSha(Sha* sha)
static int InitSha(wc_Sha* sha)
{
int ret = 0;
ret = wolfSSL_CryptHwMutexLock();
@ -302,7 +302,7 @@ static INLINE void AddLength(Sha* sha, word32 len);
return ret;
}
static int Transform(Sha* sha, byte* data)
static int Transform(wc_Sha* sha, byte* data)
{
int ret = wolfSSL_CryptHwMutexLock();
if(ret == 0) {
@ -321,7 +321,7 @@ static INLINE void AddLength(Sha* sha, word32 len);
/* Software implementation */
#define USE_SHA_SOFTWARE_IMPL
static int InitSha(Sha* sha)
static int InitSha(wc_Sha* sha)
{
int ret = 0;
@ -342,7 +342,7 @@ static INLINE void AddLength(Sha* sha, word32 len);
#if defined(USE_SHA_SOFTWARE_IMPL) || defined(STM32_HASH)
static INLINE void AddLength(Sha* sha, word32 len)
static INLINE void AddLength(wc_Sha* sha, word32 len)
{
word32 tmp = sha->loLen;
if ((sha->loLen += len) < tmp)
@ -354,7 +354,7 @@ static INLINE void AddLength(Sha* sha, word32 len)
/* Software implementation */
#ifdef USE_SHA_SOFTWARE_IMPL
/* Check if custom Sha transform is used */
/* Check if custom wc_Sha transform is used */
#ifndef XTRANSFORM
#define XTRANSFORM(S,B) Transform((S),(B))
@ -379,9 +379,9 @@ static INLINE void AddLength(Sha* sha, word32 len)
#define R4(v,w,x,y,z,i) (z)+= f4((w),(x),(y)) + blk1((i)) + 0xCA62C1D6+ \
rotlFixed((v),5); (w) = rotlFixed((w),30);
static void Transform(Sha* sha, byte* data)
static void Transform(wc_Sha* sha, byte* data)
{
word32 W[SHA_BLOCK_SIZE / sizeof(word32)];
word32 W[WC_SHA_BLOCK_SIZE / sizeof(word32)];
/* Copy context->state[] to working vars */
word32 a = sha->digest[0];
@ -458,7 +458,7 @@ static INLINE void AddLength(Sha* sha, word32 len)
#endif /* !USE_CUSTOM_SHA_TRANSFORM */
int wc_InitSha_ex(Sha* sha, void* heap, int devId)
int wc_InitSha_ex(wc_Sha* sha, void* heap, int devId)
{
int ret = 0;
@ -481,7 +481,7 @@ int wc_InitSha_ex(Sha* sha, void* heap, int devId)
return ret;
}
int wc_ShaUpdate(Sha* sha, const byte* data, word32 len)
int wc_ShaUpdate(wc_Sha* sha, const byte* data, word32 len)
{
byte* local;
@ -501,23 +501,23 @@ int wc_ShaUpdate(Sha* sha, const byte* data, word32 len)
#endif /* WOLFSSL_ASYNC_CRYPT */
/* check that internal buffLen is valid */
if (sha->buffLen >= SHA_BLOCK_SIZE)
if (sha->buffLen >= WC_SHA_BLOCK_SIZE)
return BUFFER_E;
while (len) {
word32 add = min(len, SHA_BLOCK_SIZE - sha->buffLen);
word32 add = min(len, WC_SHA_BLOCK_SIZE - sha->buffLen);
XMEMCPY(&local[sha->buffLen], data, add);
sha->buffLen += add;
data += add;
len -= add;
if (sha->buffLen == SHA_BLOCK_SIZE) {
if (sha->buffLen == WC_SHA_BLOCK_SIZE) {
#if defined(LITTLE_ENDIAN_ORDER) && !defined(FREESCALE_MMCAU_SHA)
ByteReverseWords(sha->buffer, sha->buffer, SHA_BLOCK_SIZE);
ByteReverseWords(sha->buffer, sha->buffer, WC_SHA_BLOCK_SIZE);
#endif
XTRANSFORM(sha, local);
AddLength(sha, SHA_BLOCK_SIZE);
AddLength(sha, WC_SHA_BLOCK_SIZE);
sha->buffLen = 0;
}
}
@ -525,7 +525,7 @@ int wc_ShaUpdate(Sha* sha, const byte* data, word32 len)
return 0;
}
int wc_ShaFinal(Sha* sha, byte* hash)
int wc_ShaFinal(wc_Sha* sha, byte* hash)
{
byte* local;
@ -538,7 +538,7 @@ int wc_ShaFinal(Sha* sha, byte* hash)
#if defined(WOLFSSL_ASYNC_CRYPT) && defined(WC_ASYNC_ENABLE_SHA)
if (sha->asyncDev.marker == WOLFSSL_ASYNC_MARKER_SHA) {
#if defined(HAVE_INTEL_QA)
return IntelQaSymSha(&sha->asyncDev, hash, NULL, SHA_DIGEST_SIZE);
return IntelQaSymSha(&sha->asyncDev, hash, NULL, WC_SHA_DIGEST_SIZE);
#endif
}
#endif /* WOLFSSL_ASYNC_CRYPT */
@ -548,20 +548,20 @@ int wc_ShaFinal(Sha* sha, byte* hash)
local[sha->buffLen++] = 0x80; /* add 1 */
/* pad with zeros */
if (sha->buffLen > SHA_PAD_SIZE) {
XMEMSET(&local[sha->buffLen], 0, SHA_BLOCK_SIZE - sha->buffLen);
sha->buffLen += SHA_BLOCK_SIZE - sha->buffLen;
if (sha->buffLen > WC_SHA_PAD_SIZE) {
XMEMSET(&local[sha->buffLen], 0, WC_SHA_BLOCK_SIZE - sha->buffLen);
sha->buffLen += WC_SHA_BLOCK_SIZE - sha->buffLen;
#if defined(LITTLE_ENDIAN_ORDER) && !defined(FREESCALE_MMCAU_SHA)
ByteReverseWords(sha->buffer, sha->buffer, SHA_BLOCK_SIZE);
ByteReverseWords(sha->buffer, sha->buffer, WC_SHA_BLOCK_SIZE);
#endif
XTRANSFORM(sha, local);
sha->buffLen = 0;
}
XMEMSET(&local[sha->buffLen], 0, SHA_PAD_SIZE - sha->buffLen);
XMEMSET(&local[sha->buffLen], 0, WC_SHA_PAD_SIZE - sha->buffLen);
#if defined(LITTLE_ENDIAN_ORDER) && !defined(FREESCALE_MMCAU_SHA)
ByteReverseWords(sha->buffer, sha->buffer, SHA_BLOCK_SIZE);
ByteReverseWords(sha->buffer, sha->buffer, WC_SHA_BLOCK_SIZE);
#endif
/* store lengths */
@ -570,21 +570,21 @@ int wc_ShaFinal(Sha* sha, byte* hash)
sha->loLen = sha->loLen << 3;
/* ! length ordering dependent on digest endian type ! */
XMEMCPY(&local[SHA_PAD_SIZE], &sha->hiLen, sizeof(word32));
XMEMCPY(&local[SHA_PAD_SIZE + sizeof(word32)], &sha->loLen, sizeof(word32));
XMEMCPY(&local[WC_SHA_PAD_SIZE], &sha->hiLen, sizeof(word32));
XMEMCPY(&local[WC_SHA_PAD_SIZE + sizeof(word32)], &sha->loLen, sizeof(word32));
#if defined(FREESCALE_MMCAU_SHA)
/* Kinetis requires only these bytes reversed */
ByteReverseWords(&sha->buffer[SHA_PAD_SIZE/sizeof(word32)],
&sha->buffer[SHA_PAD_SIZE/sizeof(word32)],
ByteReverseWords(&sha->buffer[WC_SHA_PAD_SIZE/sizeof(word32)],
&sha->buffer[WC_SHA_PAD_SIZE/sizeof(word32)],
2 * sizeof(word32));
#endif
XTRANSFORM(sha, local);
#ifdef LITTLE_ENDIAN_ORDER
ByteReverseWords(sha->digest, sha->digest, SHA_DIGEST_SIZE);
ByteReverseWords(sha->digest, sha->digest, WC_SHA_DIGEST_SIZE);
#endif
XMEMCPY(hash, sha->digest, SHA_DIGEST_SIZE);
XMEMCPY(hash, sha->digest, WC_SHA_DIGEST_SIZE);
return InitSha(sha); /* reset state */
}
@ -592,12 +592,12 @@ int wc_ShaFinal(Sha* sha, byte* hash)
#endif /* USE_SHA_SOFTWARE_IMPL */
int wc_InitSha(Sha* sha)
int wc_InitSha(wc_Sha* sha)
{
return wc_InitSha_ex(sha, NULL, INVALID_DEVID);
}
void wc_ShaFree(Sha* sha)
void wc_ShaFree(wc_Sha* sha)
{
if (sha == NULL)
return;
@ -611,10 +611,10 @@ void wc_ShaFree(Sha* sha)
#endif /* HAVE_FIPS */
#ifndef WOLFSSL_TI_HASH
int wc_ShaGetHash(Sha* sha, byte* hash)
int wc_ShaGetHash(wc_Sha* sha, byte* hash)
{
int ret;
Sha tmpSha;
wc_Sha tmpSha;
if (sha == NULL || hash == NULL)
return BAD_FUNC_ARG;
@ -626,14 +626,14 @@ int wc_ShaGetHash(Sha* sha, byte* hash)
return ret;
}
int wc_ShaCopy(Sha* src, Sha* dst)
int wc_ShaCopy(wc_Sha* src, wc_Sha* dst)
{
int ret = 0;
if (src == NULL || dst == NULL)
return BAD_FUNC_ARG;
XMEMCPY(dst, src, sizeof(Sha));
XMEMCPY(dst, src, sizeof(wc_Sha));
#ifdef WOLFSSL_ASYNC_CRYPT
ret = wolfAsync_DevCopy(&src->asyncDev, &dst->asyncDev);

155
wolfcrypt/src/sha256.c
View File

@ -37,14 +37,14 @@
/* fips wrapper calls, user can call direct */
#ifdef HAVE_FIPS
int wc_InitSha256(Sha256* sha)
int wc_InitSha256(wc_Sha256* sha)
{
if (sha == NULL) {
return BAD_FUNC_ARG;
}
return InitSha256_fips(sha);
}
int wc_InitSha256_ex(Sha256* sha, void* heap, int devId)
int wc_InitSha256_ex(wc_Sha256* sha, void* heap, int devId)
{
(void)heap;
(void)devId;
@ -53,21 +53,21 @@
}
return InitSha256_fips(sha);
}
int wc_Sha256Update(Sha256* sha, const byte* data, word32 len)
int wc_Sha256Update(wc_Sha256* sha, const byte* data, word32 len)
{
if (sha == NULL || (data == NULL && len > 0)) {
return BAD_FUNC_ARG;
}
return Sha256Update_fips(sha, data, len);
}
int wc_Sha256Final(Sha256* sha, byte* out)
int wc_Sha256Final(wc_Sha256* sha, byte* out)
{
if (sha == NULL || out == NULL) {
return BAD_FUNC_ARG;
}
return Sha256Final_fips(sha, out);
}
void wc_Sha256Free(Sha256* sha)
void wc_Sha256Free(wc_Sha256* sha)
{
(void)sha;
/* Not supported in FIPS */
@ -100,10 +100,10 @@
#endif
static INLINE void AddLength(Sha256* sha256, word32 len);
static INLINE void AddLength(wc_Sha256* sha256, word32 len);
#if !defined(WOLFSSL_PIC32MZ_HASH) && !defined(STM32_HASH)
static int InitSha256(Sha256* sha256)
static int InitSha256(wc_Sha256* sha256)
{
int ret = 0;
@ -144,7 +144,7 @@ static int InitSha256(Sha256* sha256)
#define HAVE_INTEL_RORX
int InitSha256(Sha256* sha256) {
int InitSha256(wc_Sha256* sha256) {
Save/Recover XMM, YMM
...
}
@ -192,15 +192,15 @@ static int InitSha256(Sha256* sha256)
*/
/* #if defined(HAVE_INTEL_AVX1/2) at the tail of sha256 */
static int Transform(Sha256* sha256);
static int Transform(wc_Sha256* sha256);
#if defined(HAVE_INTEL_AVX1)
static int Transform_AVX1(Sha256 *sha256);
static int Transform_AVX1(wc_Sha256 *sha256);
#endif
#if defined(HAVE_INTEL_AVX2)
static int Transform_AVX2(Sha256 *sha256);
static int Transform_AVX1_RORX(Sha256 *sha256);
static int Transform_AVX2(wc_Sha256 *sha256);
static int Transform_AVX1_RORX(wc_Sha256 *sha256);
#endif
static int (*Transform_p)(Sha256* sha256) /* = _Transform */;
static int (*Transform_p)(wc_Sha256* sha256) /* = _Transform */;
static int transform_check = 0;
static word32 intel_flags;
#define XTRANSFORM(S, B) (*Transform_p)((S))
@ -244,7 +244,7 @@ static int InitSha256(Sha256* sha256)
"xmm11","xmm12","xmm13","xmm14","xmm15")
#endif
int wc_InitSha256_ex(Sha256* sha256, void* heap, int devId)
int wc_InitSha256_ex(wc_Sha256* sha256, void* heap, int devId)
{
int ret = 0;
if (sha256 == NULL)
@ -270,7 +270,7 @@ static int InitSha256(Sha256* sha256)
}
#elif defined(FREESCALE_LTC_SHA)
int wc_InitSha256_ex(Sha256* sha256, void* heap, int devId)
int wc_InitSha256_ex(wc_Sha256* sha256, void* heap, int devId)
{
(void)heap;
(void)devId;
@ -290,7 +290,7 @@ static int InitSha256(Sha256* sha256)
#define XTRANSFORM(S, B) Transform((S), (B))
int wc_InitSha256_ex(Sha256* sha256, void* heap, int devId)
int wc_InitSha256_ex(wc_Sha256* sha256, void* heap, int devId)
{
int ret = 0;
@ -315,7 +315,7 @@ static int InitSha256(Sha256* sha256)
return ret;
}
static int Transform(Sha256* sha256, byte* buf)
static int Transform(wc_Sha256* sha256, byte* buf)
{
int ret = wolfSSL_CryptHwMutexLock();
if (ret == 0) {
@ -352,7 +352,7 @@ static int InitSha256(Sha256* sha256)
#endif
#define SHA256_HW_TIMEOUT 0xFF
int wc_InitSha256_ex(Sha256* sha256, void* heap, int devId)
int wc_InitSha256_ex(wc_Sha256* sha256, void* heap, int devId)
{
if (sha256 == NULL)
return BAD_FUNC_ARG;
@ -390,7 +390,7 @@ static int InitSha256(Sha256* sha256)
return 0;
}
int wc_Sha256Update(Sha256* sha256, const byte* data, word32 len)
int wc_Sha256Update(wc_Sha256* sha256, const byte* data, word32 len)
{
int ret = 0;
byte* local;
@ -431,7 +431,7 @@ static int InitSha256(Sha256* sha256)
return ret;
}
int wc_Sha256Final(Sha256* sha256, byte* hash)
int wc_Sha256Final(wc_Sha256* sha256, byte* hash)
{
int ret = 0;
@ -488,7 +488,7 @@ static int InitSha256(Sha256* sha256)
#else
#define NEED_SOFT_SHA256
int wc_InitSha256_ex(Sha256* sha256, void* heap, int devId)
int wc_InitSha256_ex(wc_Sha256* sha256, void* heap, int devId)
{
int ret = 0;
if (sha256 == NULL)
@ -553,7 +553,7 @@ static int InitSha256(Sha256* sha256)
#define XTRANSFORM(S, B) Transform((S))
#endif
static int Transform(Sha256* sha256)
static int Transform(wc_Sha256* sha256)
{
word32 S[8], t0, t1;
int i;
@ -561,12 +561,12 @@ static int InitSha256(Sha256* sha256)
#ifdef WOLFSSL_SMALL_STACK
word32* W;
W = (word32*)XMALLOC(sizeof(word32) * SHA256_BLOCK_SIZE, NULL,
W = (word32*)XMALLOC(sizeof(word32) * WC_SHA256_BLOCK_SIZE, NULL,
DYNAMIC_TYPE_TMP_BUFFER);
if (W == NULL)
return MEMORY_E;
#else
word32 W[SHA256_BLOCK_SIZE];
word32 W[WC_SHA256_BLOCK_SIZE];
#endif
/* Copy context->state[] to working vars */
@ -576,10 +576,10 @@ static int InitSha256(Sha256* sha256)
for (i = 0; i < 16; i++)
W[i] = sha256->buffer[i];
for (i = 16; i < SHA256_BLOCK_SIZE; i++)
for (i = 16; i < WC_SHA256_BLOCK_SIZE; i++)
W[i] = Gamma1(W[i-2]) + W[i-7] + Gamma0(W[i-15]) + W[i-16];
for (i = 0; i < SHA256_BLOCK_SIZE; i += 8) {
for (i = 0; i < WC_SHA256_BLOCK_SIZE; i += 8) {
RND(S[0],S[1],S[2],S[3],S[4],S[5],S[6],S[7],i+0);
RND(S[7],S[0],S[1],S[2],S[3],S[4],S[5],S[6],i+1);
RND(S[6],S[7],S[0],S[1],S[2],S[3],S[4],S[5],i+2);
@ -606,7 +606,7 @@ static int InitSha256(Sha256* sha256)
#if defined(XTRANSFORM) || defined(STM32_HASH)
static INLINE void AddLength(Sha256* sha256, word32 len)
static INLINE void AddLength(wc_Sha256* sha256, word32 len)
{
word32 tmp = sha256->loLen;
if ( (sha256->loLen += len) < tmp)
@ -617,7 +617,7 @@ static INLINE void AddLength(Sha256* sha256, word32 len)
#ifdef XTRANSFORM
static INLINE int Sha256Update(Sha256* sha256, const byte* data, word32 len)
static INLINE int Sha256Update(wc_Sha256* sha256, const byte* data, word32 len)
{
int ret = 0;
byte* local;
@ -638,27 +638,27 @@ static INLINE void AddLength(Sha256* sha256, word32 len)
local = (byte*)sha256->buffer;
/* check that internal buffLen is valid */
if (sha256->buffLen >= SHA256_BLOCK_SIZE)
if (sha256->buffLen >= WC_SHA256_BLOCK_SIZE)
return BUFFER_E;
SAVE_XMM_YMM; /* for Intel AVX */
while (len) {
word32 add = min(len, SHA256_BLOCK_SIZE - sha256->buffLen);
word32 add = min(len, WC_SHA256_BLOCK_SIZE - sha256->buffLen);
XMEMCPY(&local[sha256->buffLen], data, add);
sha256->buffLen += add;
data += add;
len -= add;
if (sha256->buffLen == SHA256_BLOCK_SIZE) {
if (sha256->buffLen == WC_SHA256_BLOCK_SIZE) {
#if defined(LITTLE_ENDIAN_ORDER) && !defined(FREESCALE_MMCAU_SHA)
#if defined(HAVE_INTEL_AVX1) || defined(HAVE_INTEL_AVX2)
if (!IS_INTEL_AVX1(intel_flags) && !IS_INTEL_AVX2(intel_flags))
#endif
{
ByteReverseWords(sha256->buffer, sha256->buffer,
SHA256_BLOCK_SIZE);
WC_SHA256_BLOCK_SIZE);
}
#endif
ret = XTRANSFORM(sha256, local);
@ -666,7 +666,7 @@ static INLINE void AddLength(Sha256* sha256, word32 len)
break;
}
AddLength(sha256, SHA256_BLOCK_SIZE);
AddLength(sha256, WC_SHA256_BLOCK_SIZE);
sha256->buffLen = 0;
}
}
@ -674,12 +674,12 @@ static INLINE void AddLength(Sha256* sha256, word32 len)
return ret;
}
int wc_Sha256Update(Sha256* sha256, const byte* data, word32 len)
int wc_Sha256Update(wc_Sha256* sha256, const byte* data, word32 len)
{
return Sha256Update(sha256, data, len);
}
static INLINE int Sha256Final(Sha256* sha256)
static INLINE int Sha256Final(wc_Sha256* sha256)
{
int ret;
@ -695,10 +695,10 @@ static INLINE void AddLength(Sha256* sha256, word32 len)
local[sha256->buffLen++] = 0x80; /* add 1 */
/* pad with zeros */
if (sha256->buffLen > SHA256_PAD_SIZE) {
if (sha256->buffLen > WC_SHA256_PAD_SIZE) {
XMEMSET(&local[sha256->buffLen], 0,
SHA256_BLOCK_SIZE - sha256->buffLen);
sha256->buffLen += SHA256_BLOCK_SIZE - sha256->buffLen;
WC_SHA256_BLOCK_SIZE - sha256->buffLen);
sha256->buffLen += WC_SHA256_BLOCK_SIZE - sha256->buffLen;
{
#if defined(LITTLE_ENDIAN_ORDER) && !defined(FREESCALE_MMCAU_SHA)
@ -707,7 +707,7 @@ static INLINE void AddLength(Sha256* sha256, word32 len)
#endif
{
ByteReverseWords(sha256->buffer, sha256->buffer,
SHA256_BLOCK_SIZE);
WC_SHA256_BLOCK_SIZE);
}
#endif
}
@ -718,7 +718,7 @@ static INLINE void AddLength(Sha256* sha256, word32 len)
sha256->buffLen = 0;
}
XMEMSET(&local[sha256->buffLen], 0, SHA256_PAD_SIZE - sha256->buffLen);
XMEMSET(&local[sha256->buffLen], 0, WC_SHA256_PAD_SIZE - sha256->buffLen);
/* put lengths in bits */
sha256->hiLen = (sha256->loLen >> (8 * sizeof(sha256->loLen) - 3)) +
@ -732,12 +732,12 @@ static INLINE void AddLength(Sha256* sha256, word32 len)
#endif
{
ByteReverseWords(sha256->buffer, sha256->buffer,
SHA256_BLOCK_SIZE);
WC_SHA256_BLOCK_SIZE);
}
#endif
/* ! length ordering dependent on digest endian type ! */
XMEMCPY(&local[SHA256_PAD_SIZE], &sha256->hiLen, sizeof(word32));
XMEMCPY(&local[SHA256_PAD_SIZE + sizeof(word32)], &sha256->loLen,
XMEMCPY(&local[WC_SHA256_PAD_SIZE], &sha256->hiLen, sizeof(word32));
XMEMCPY(&local[WC_SHA256_PAD_SIZE + sizeof(word32)], &sha256->loLen,
sizeof(word32));
#if defined(FREESCALE_MMCAU_SHA) || defined(HAVE_INTEL_AVX1) || \
@ -748,8 +748,8 @@ static INLINE void AddLength(Sha256* sha256, word32 len)
#endif
{
ByteReverseWords(
&sha256->buffer[SHA256_PAD_SIZE / sizeof(word32)],
&sha256->buffer[SHA256_PAD_SIZE / sizeof(word32)],
&sha256->buffer[WC_SHA256_PAD_SIZE / sizeof(word32)],
&sha256->buffer[WC_SHA256_PAD_SIZE / sizeof(word32)],
2 * sizeof(word32));
}
#endif
@ -757,7 +757,7 @@ static INLINE void AddLength(Sha256* sha256, word32 len)
return XTRANSFORM(sha256, local);
}
int wc_Sha256Final(Sha256* sha256, byte* hash)
int wc_Sha256Final(wc_Sha256* sha256, byte* hash)
{
int ret;
@ -769,7 +769,7 @@ static INLINE void AddLength(Sha256* sha256, word32 len)
if (sha256->asyncDev.marker == WOLFSSL_ASYNC_MARKER_SHA256) {
#if defined(HAVE_INTEL_QA)
return IntelQaSymSha256(&sha256->asyncDev, hash, NULL,
SHA256_DIGEST_SIZE);
WC_SHA256_DIGEST_SIZE);
#endif
}
#endif /* WOLFSSL_ASYNC_CRYPT */
@ -779,9 +779,9 @@ static INLINE void AddLength(Sha256* sha256, word32 len)
return ret;
#if defined(LITTLE_ENDIAN_ORDER)
ByteReverseWords(sha256->digest, sha256->digest, SHA256_DIGEST_SIZE);
ByteReverseWords(sha256->digest, sha256->digest, WC_SHA256_DIGEST_SIZE);
#endif
XMEMCPY(hash, sha256->digest, SHA256_DIGEST_SIZE);
XMEMCPY(hash, sha256->digest, WC_SHA256_DIGEST_SIZE);
return InitSha256(sha256); /* reset state */
}
@ -1216,7 +1216,7 @@ __asm__ volatile("vmovdqu %0, %"#mask3 ::"m"(mSHUF_DC00[0]));
#define BYTE_FLIP_MASK %xmm13
static int Transform_AVX1(Sha256* sha256)
static int Transform_AVX1(wc_Sha256* sha256)
{
ALIGN32 word32 W_K[64]; /* temp for W+K */
@ -1294,7 +1294,7 @@ static int Transform_AVX1(Sha256* sha256)
}
#if defined(HAVE_INTEL_RORX)
static int Transform_AVX1_RORX(Sha256* sha256)
static int Transform_AVX1_RORX(wc_Sha256* sha256)
{
ALIGN32 word32 W_K[64]; /* temp for W+K */
@ -1561,7 +1561,7 @@ static int Transform_AVX1_RORX(Sha256* sha256)
static const unsigned long mMAP3toW_I_2[] =
{ 0x8080808080808080, 0x8080808080808080, 0x8080808080808080, 0x0706050403020100 };
static int Transform_AVX2(Sha256* sha256)
static int Transform_AVX2(wc_Sha256* sha256)
{
#ifdef WOLFSSL_SMALL_STACK
word32* W_K;
@ -1942,7 +1942,7 @@ static int Transform_AVX2(Sha256* sha256)
/* STM32 register size, bytes */
#ifdef WOLFSSL_STM32_CUBEMX
#define SHA224_REG_SIZE SHA224_BLOCK_SIZE
#define SHA224_REG_SIZE WC_SHA224_BLOCK_SIZE
#else
#define SHA224_REG_SIZE 4
/* STM32 struct notes:
@ -1953,7 +1953,7 @@ static int Transform_AVX2(Sha256* sha256)
#endif
#define SHA224_HW_TIMEOUT 0xFF
static int InitSha224(Sha224* sha224)
static int InitSha224(wc_Sha224* sha224)
{
if (sha224 == NULL)
return BAD_FUNC_ARG;
@ -1990,7 +1990,7 @@ static int Transform_AVX2(Sha256* sha256)
return 0;
}
static int Sha224Update(Sha256* sha224, const byte* data, word32 len)
static int Sha224Update(wc_Sha256* sha224, const byte* data, word32 len)
{
int ret = 0;
byte* local;
@ -2027,7 +2027,7 @@ static int Transform_AVX2(Sha256* sha256)
return ret;
}
static int Sha224Final(Sha256* sha224)
static int Sha224Final(wc_Sha256* sha224)
{
int ret = 0;
@ -2075,9 +2075,8 @@ static int Transform_AVX2(Sha256* sha256)
#else
static int InitSha224(Sha224* sha224)
static int InitSha224(wc_Sha224* sha224)
{
int ret = 0;
if (sha224 == NULL) {
@ -2107,7 +2106,7 @@ static int Transform_AVX2(Sha256* sha256)
#endif /* STM32_HASH */
int wc_InitSha224_ex(Sha224* sha224, void* heap, int devId)
int wc_InitSha224_ex(wc_Sha224* sha224, void* heap, int devId)
{
int ret = 0;
@ -2130,12 +2129,12 @@ static int Transform_AVX2(Sha256* sha256)
return ret;
}
int wc_InitSha224(Sha224* sha224)
int wc_InitSha224(wc_Sha224* sha224)
{
return wc_InitSha224_ex(sha224, NULL, INVALID_DEVID);
}
int wc_Sha224Update(Sha224* sha224, const byte* data, word32 len)
int wc_Sha224Update(wc_Sha224* sha224, const byte* data, word32 len)
{
int ret;
@ -2151,12 +2150,12 @@ static int Transform_AVX2(Sha256* sha256)
}
#endif /* WOLFSSL_ASYNC_CRYPT */
ret = Sha256Update((Sha256*)sha224, data, len);
ret = Sha256Update((wc_Sha256*)sha224, data, len);
return ret;
}
int wc_Sha224Final(Sha224* sha224, byte* hash)
int wc_Sha224Final(wc_Sha224* sha224, byte* hash)
{
int ret;
@ -2168,24 +2167,24 @@ static int Transform_AVX2(Sha256* sha256)
if (sha224->asyncDev.marker == WOLFSSL_ASYNC_MARKER_SHA224) {
#if defined(HAVE_INTEL_QA)
return IntelQaSymSha224(&sha224->asyncDev, hash, NULL,
SHA224_DIGEST_SIZE);
WC_SHA224_DIGEST_SIZE);
#endif
}
#endif /* WOLFSSL_ASYNC_CRYPT */
ret = Sha256Final((Sha256*)sha224);
ret = Sha256Final((wc_Sha256*)sha224);
if (ret != 0)
return ret;
#if defined(LITTLE_ENDIAN_ORDER) && !defined(STM32_HASH)
ByteReverseWords(sha224->digest, sha224->digest, SHA224_DIGEST_SIZE);
ByteReverseWords(sha224->digest, sha224->digest, WC_SHA224_DIGEST_SIZE);
#endif
XMEMCPY(hash, sha224->digest, SHA224_DIGEST_SIZE);
XMEMCPY(hash, sha224->digest, WC_SHA224_DIGEST_SIZE);
return InitSha224(sha224); /* reset state */
}
void wc_Sha224Free(Sha224* sha224)
void wc_Sha224Free(wc_Sha224* sha224)
{
if (sha224 == NULL)
return;
@ -2198,12 +2197,12 @@ static int Transform_AVX2(Sha256* sha256)
#endif /* WOLFSSL_SHA224 */
int wc_InitSha256(Sha256* sha256)
int wc_InitSha256(wc_Sha256* sha256)
{
return wc_InitSha256_ex(sha256, NULL, INVALID_DEVID);
}
void wc_Sha256Free(Sha256* sha256)
void wc_Sha256Free(wc_Sha256* sha256)
{
if (sha256 == NULL)
return;
@ -2219,10 +2218,10 @@ void wc_Sha256Free(Sha256* sha256)
#ifndef WOLFSSL_TI_HASH
#ifdef WOLFSSL_SHA224
int wc_Sha224GetHash(Sha224* sha224, byte* hash)
int wc_Sha224GetHash(wc_Sha224* sha224, byte* hash)
{
int ret;
Sha224 tmpSha224;
wc_Sha224 tmpSha224;
if (sha224 == NULL || hash == NULL)
return BAD_FUNC_ARG;
@ -2233,14 +2232,14 @@ void wc_Sha256Free(Sha256* sha256)
}
return ret;
}
int wc_Sha224Copy(Sha224* src, Sha224* dst)
int wc_Sha224Copy(wc_Sha224* src, wc_Sha224* dst)
{
int ret = 0;
if (src == NULL || dst == NULL)
return BAD_FUNC_ARG;
XMEMCPY(dst, src, sizeof(Sha224));
XMEMCPY(dst, src, sizeof(wc_Sha224));
#ifdef WOLFSSL_ASYNC_CRYPT
ret = wolfAsync_DevCopy(&src->asyncDev, &dst->asyncDev);
@ -2250,10 +2249,10 @@ void wc_Sha256Free(Sha256* sha256)
}
#endif /* WOLFSSL_SHA224 */
int wc_Sha256GetHash(Sha256* sha256, byte* hash)
int wc_Sha256GetHash(wc_Sha256* sha256, byte* hash)
{
int ret;
Sha256 tmpSha256;
wc_Sha256 tmpSha256;
if (sha256 == NULL || hash == NULL)
return BAD_FUNC_ARG;
@ -2264,14 +2263,14 @@ int wc_Sha256GetHash(Sha256* sha256, byte* hash)
}
return ret;
}
int wc_Sha256Copy(Sha256* src, Sha256* dst)
int wc_Sha256Copy(wc_Sha256* src, wc_Sha256* dst)
{
int ret = 0;
if (src == NULL || dst == NULL)
return BAD_FUNC_ARG;
XMEMCPY(dst, src, sizeof(Sha256));
XMEMCPY(dst, src, sizeof(wc_Sha256));
#ifdef WOLFSSL_ASYNC_CRYPT
ret = wolfAsync_DevCopy(&src->asyncDev, &dst->asyncDev);

136
wolfcrypt/src/sha512.c
View File

@ -33,7 +33,7 @@
/* fips wrapper calls, user can call direct */
#ifdef HAVE_FIPS
int wc_InitSha512(Sha512* sha)
int wc_InitSha512(wc_Sha512* sha)
{
if (sha == NULL) {
return BAD_FUNC_ARG;
@ -41,7 +41,7 @@
return InitSha512_fips(sha);
}
int wc_InitSha512_ex(Sha512* sha, void* heap, int devId)
int wc_InitSha512_ex(wc_Sha512* sha, void* heap, int devId)
{
(void)heap;
(void)devId;
@ -50,7 +50,7 @@
}
return InitSha512_fips(sha);
}
int wc_Sha512Update(Sha512* sha, const byte* data, word32 len)
int wc_Sha512Update(wc_Sha512* sha, const byte* data, word32 len)
{
if (sha == NULL || (data == NULL && len > 0)) {
return BAD_FUNC_ARG;
@ -58,7 +58,7 @@
return Sha512Update_fips(sha, data, len);
}
int wc_Sha512Final(Sha512* sha, byte* out)
int wc_Sha512Final(wc_Sha512* sha, byte* out)
{
if (sha == NULL || out == NULL) {
return BAD_FUNC_ARG;
@ -66,21 +66,21 @@
return Sha512Final_fips(sha, out);
}
void wc_Sha512Free(Sha512* sha)
void wc_Sha512Free(wc_Sha512* sha)
{
(void)sha;
/* Not supported in FIPS */
}
#if defined(WOLFSSL_SHA384) || defined(HAVE_AESGCM)
int wc_InitSha384(Sha384* sha)
int wc_InitSha384(wc_Sha384* sha)
{
if (sha == NULL) {
return BAD_FUNC_ARG;
}
return InitSha384_fips(sha);
}
int wc_InitSha384_ex(Sha384* sha, void* heap, int devId)
int wc_InitSha384_ex(wc_Sha384* sha, void* heap, int devId)
{
(void)heap;
(void)devId;
@ -89,21 +89,21 @@
}
return InitSha384_fips(sha);
}
int wc_Sha384Update(Sha384* sha, const byte* data, word32 len)
int wc_Sha384Update(wc_Sha384* sha, const byte* data, word32 len)
{
if (sha == NULL || (data == NULL && len > 0)) {
return BAD_FUNC_ARG;
}
return Sha384Update_fips(sha, data, len);
}
int wc_Sha384Final(Sha384* sha, byte* out)
int wc_Sha384Final(wc_Sha384* sha, byte* out)
{
if (sha == NULL || out == NULL) {
return BAD_FUNC_ARG;
}
return Sha384Final_fips(sha, out);
}
void wc_Sha384Free(Sha384* sha)
void wc_Sha384Free(wc_Sha384* sha)
{
(void)sha;
/* Not supported in FIPS */
@ -166,7 +166,7 @@
}
#endif
static int InitSha512(Sha512* sha512)
static int InitSha512(wc_Sha512* sha512)
{
if (sha512 == NULL)
return BAD_FUNC_ARG;
@ -199,7 +199,7 @@ static int InitSha512(Sha512* sha512)
#define HAVE_INTEL_AVX2
#endif
int InitSha512(Sha512* sha512) {
int InitSha512(wc_Sha512* sha512) {
Save/Recover XMM, YMM
...
@ -261,16 +261,16 @@ static int InitSha512(Sha512* sha512)
*/
#if defined(HAVE_INTEL_AVX1)
static int Transform_AVX1(Sha512 *sha512);
static int Transform_AVX1(wc_Sha512 *sha512);
#endif
#if defined(HAVE_INTEL_AVX2)
static int Transform_AVX2(Sha512 *sha512);
static int Transform_AVX2(wc_Sha512 *sha512);
#if defined(HAVE_INTEL_AVX1) && defined(HAVE_INTEL_AVX2) && defined(HAVE_INTEL_RORX)
static int Transform_AVX1_RORX(Sha512 *sha512);
static int Transform_AVX1_RORX(wc_Sha512 *sha512);
#endif
#endif
static int _Transform(Sha512 *sha512);
static int (*Transform_p)(Sha512* sha512) = _Transform;
static int _Transform(wc_Sha512 *sha512);
static int (*Transform_p)(wc_Sha512* sha512) = _Transform;
static int transform_check = 0;
static int intel_flags;
#define Transform(sha512) (*Transform_p)(sha512)
@ -314,7 +314,7 @@ static int InitSha512(Sha512* sha512)
transform_check = 1;
}
int wc_InitSha512_ex(Sha512* sha512, void* heap, int devId)
int wc_InitSha512_ex(wc_Sha512* sha512, void* heap, int devId)
{
int ret = InitSha512(sha512);
@ -329,7 +329,7 @@ static int InitSha512(Sha512* sha512)
#else
#define Transform(sha512) _Transform(sha512)
int wc_InitSha512_ex(Sha512* sha512, void* heap, int devId)
int wc_InitSha512_ex(wc_Sha512* sha512, void* heap, int devId)
{
int ret = 0;
@ -427,7 +427,7 @@ static const word64 K512[80] = {
#define R(i) h(i)+=S1(e(i))+Ch(e(i),f(i),g(i))+K[i+j]+(j?blk2(i):blk0(i));\
d(i)+=h(i);h(i)+=S0(a(i))+Maj(a(i),b(i),c(i))
static int _Transform(Sha512* sha512)
static int _Transform(wc_Sha512* sha512)
{
const word64* K = K512;
@ -489,48 +489,48 @@ static int _Transform(Sha512* sha512)
}
static INLINE void AddLength(Sha512* sha512, word32 len)
static INLINE void AddLength(wc_Sha512* sha512, word32 len)
{
word64 tmp = sha512->loLen;
if ( (sha512->loLen += len) < tmp)
sha512->hiLen++; /* carry low to high */
}
static INLINE int Sha512Update(Sha512* sha512, const byte* data, word32 len)
static INLINE int Sha512Update(wc_Sha512* sha512, const byte* data, word32 len)
{
int ret = 0;
/* do block size increments */
byte* local = (byte*)sha512->buffer;
/* check that internal buffLen is valid */
if (sha512->buffLen >= SHA512_BLOCK_SIZE)
if (sha512->buffLen >= WC_SHA512_BLOCK_SIZE)
return BUFFER_E;
SAVE_XMM_YMM; /* for Intel AVX */
while (len) {
word32 add = min(len, SHA512_BLOCK_SIZE - sha512->buffLen);
word32 add = min(len, WC_SHA512_BLOCK_SIZE - sha512->buffLen);
XMEMCPY(&local[sha512->buffLen], data, add);
sha512->buffLen += add;
data += add;
len -= add;
if (sha512->buffLen == SHA512_BLOCK_SIZE) {
if (sha512->buffLen == WC_SHA512_BLOCK_SIZE) {
#if defined(LITTLE_ENDIAN_ORDER)
#if defined(HAVE_INTEL_AVX1) || defined(HAVE_INTEL_AVX2)
if (!IS_INTEL_AVX1(intel_flags) && !IS_INTEL_AVX2(intel_flags))
#endif
{
ByteReverseWords64(sha512->buffer, sha512->buffer,
SHA512_BLOCK_SIZE);
WC_SHA512_BLOCK_SIZE);
}
#endif
ret = Transform(sha512);
if (ret != 0)
break;
AddLength(sha512, SHA512_BLOCK_SIZE);
AddLength(sha512, WC_SHA512_BLOCK_SIZE);
sha512->buffLen = 0;
}
}
@ -538,7 +538,7 @@ static INLINE int Sha512Update(Sha512* sha512, const byte* data, word32 len)
return ret;
}
int wc_Sha512Update(Sha512* sha512, const byte* data, word32 len)
int wc_Sha512Update(wc_Sha512* sha512, const byte* data, word32 len)
{
if (sha512 == NULL || (data == NULL && len > 0)) {
return BAD_FUNC_ARG;
@ -556,7 +556,7 @@ int wc_Sha512Update(Sha512* sha512, const byte* data, word32 len)
}
static INLINE int Sha512Final(Sha512* sha512)
static INLINE int Sha512Final(wc_Sha512* sha512)
{
byte* local = (byte*)sha512->buffer;
int ret;
@ -571,16 +571,16 @@ static INLINE int Sha512Final(Sha512* sha512)
local[sha512->buffLen++] = 0x80; /* add 1 */
/* pad with zeros */
if (sha512->buffLen > SHA512_PAD_SIZE) {
XMEMSET(&local[sha512->buffLen], 0, SHA512_BLOCK_SIZE - sha512->buffLen);
sha512->buffLen += SHA512_BLOCK_SIZE - sha512->buffLen;
if (sha512->buffLen > WC_SHA512_PAD_SIZE) {
XMEMSET(&local[sha512->buffLen], 0, WC_SHA512_BLOCK_SIZE - sha512->buffLen);
sha512->buffLen += WC_SHA512_BLOCK_SIZE - sha512->buffLen;
#if defined(LITTLE_ENDIAN_ORDER)
#if defined(HAVE_INTEL_AVX1) || defined(HAVE_INTEL_AVX2)
if (!IS_INTEL_AVX1(intel_flags) && !IS_INTEL_AVX2(intel_flags))
#endif
{
ByteReverseWords64(sha512->buffer,sha512->buffer,
SHA512_BLOCK_SIZE);
WC_SHA512_BLOCK_SIZE);
}
#endif /* LITTLE_ENDIAN_ORDER */
ret = Transform(sha512);
@ -589,7 +589,7 @@ static INLINE int Sha512Final(Sha512* sha512)
sha512->buffLen = 0;
}
XMEMSET(&local[sha512->buffLen], 0, SHA512_PAD_SIZE - sha512->buffLen);
XMEMSET(&local[sha512->buffLen], 0, WC_SHA512_PAD_SIZE - sha512->buffLen);
/* put lengths in bits */
sha512->hiLen = (sha512->loLen >> (8 * sizeof(sha512->loLen) - 3)) +
@ -601,30 +601,30 @@ static INLINE int Sha512Final(Sha512* sha512)
#if defined(HAVE_INTEL_AVX1) || defined(HAVE_INTEL_AVX2)
if (!IS_INTEL_AVX1(intel_flags) && !IS_INTEL_AVX2(intel_flags))
#endif
ByteReverseWords64(sha512->buffer, sha512->buffer, SHA512_PAD_SIZE);
ByteReverseWords64(sha512->buffer, sha512->buffer, WC_SHA512_PAD_SIZE);
#endif
/* ! length ordering dependent on digest endian type ! */
sha512->buffer[SHA512_BLOCK_SIZE / sizeof(word64) - 2] = sha512->hiLen;
sha512->buffer[SHA512_BLOCK_SIZE / sizeof(word64) - 1] = sha512->loLen;
sha512->buffer[WC_SHA512_BLOCK_SIZE / sizeof(word64) - 2] = sha512->hiLen;
sha512->buffer[WC_SHA512_BLOCK_SIZE / sizeof(word64) - 1] = sha512->loLen;
#if defined(HAVE_INTEL_AVX1) || defined(HAVE_INTEL_AVX2)
if (IS_INTEL_AVX1(intel_flags) || IS_INTEL_AVX2(intel_flags))
ByteReverseWords64(&(sha512->buffer[SHA512_BLOCK_SIZE / sizeof(word64) - 2]),
&(sha512->buffer[SHA512_BLOCK_SIZE / sizeof(word64) - 2]),
SHA512_BLOCK_SIZE - SHA512_PAD_SIZE);
ByteReverseWords64(&(sha512->buffer[WC_SHA512_BLOCK_SIZE / sizeof(word64) - 2]),
&(sha512->buffer[WC_SHA512_BLOCK_SIZE / sizeof(word64) - 2]),
WC_SHA512_BLOCK_SIZE - WC_SHA512_PAD_SIZE);
#endif
ret = Transform(sha512);
if (ret != 0)
return ret;
#ifdef LITTLE_ENDIAN_ORDER
ByteReverseWords64(sha512->digest, sha512->digest, SHA512_DIGEST_SIZE);
ByteReverseWords64(sha512->digest, sha512->digest, WC_SHA512_DIGEST_SIZE);
#endif
return 0;
}
int wc_Sha512Final(Sha512* sha512, byte* hash)
int wc_Sha512Final(wc_Sha512* sha512, byte* hash)
{
int ret;
@ -636,7 +636,7 @@ int wc_Sha512Final(Sha512* sha512, byte* hash)
if (sha512->asyncDev.marker == WOLFSSL_ASYNC_MARKER_SHA512) {
#if defined(HAVE_INTEL_QA)
return IntelQaSymSha512(&sha512->asyncDev, hash, NULL,
SHA512_DIGEST_SIZE);
WC_SHA512_DIGEST_SIZE);
#endif
}
#endif /* WOLFSSL_ASYNC_CRYPT */
@ -645,18 +645,18 @@ int wc_Sha512Final(Sha512* sha512, byte* hash)
if (ret != 0)
return ret;
XMEMCPY(hash, sha512->digest, SHA512_DIGEST_SIZE);
XMEMCPY(hash, sha512->digest, WC_SHA512_DIGEST_SIZE);
return InitSha512(sha512); /* reset state */
}
int wc_InitSha512(Sha512* sha512)
int wc_InitSha512(wc_Sha512* sha512)
{
return wc_InitSha512_ex(sha512, NULL, INVALID_DEVID);
}
void wc_Sha512Free(Sha512* sha512)
void wc_Sha512Free(wc_Sha512* sha512)
{
if (sha512 == NULL)
return;
@ -1036,7 +1036,7 @@ static const unsigned long mBYTE_FLIP_MASK_Y[] =
/*** Transform Body ***/
#if defined(HAVE_INTEL_AVX1)
static int Transform_AVX1(Sha512* sha512)
static int Transform_AVX1(wc_Sha512* sha512)
{
const word64* K = K512;
word64 W_X[16+4] = {0};
@ -1090,7 +1090,7 @@ static int Transform_AVX1(Sha512* sha512)
#endif /* HAVE_INTEL_AVX1 */
#if defined(HAVE_INTEL_AVX2) && defined(HAVE_INTEL_AVX1) && defined(HAVE_INTEL_RORX)
static int Transform_AVX1_RORX(Sha512* sha512)
static int Transform_AVX1_RORX(wc_Sha512* sha512)
{
const word64* K = K512;
word64 W_X[16+4] = {0};
@ -1269,7 +1269,7 @@ static INLINE void Block_Y_12_11(void) { Block_Y_xx_11(12, W_12y, W_0y, W_4y, W_
static INLINE void Block_Y_12_12(word64 *w) { Block_Y_xx_12(12, W_12y, W_0y, W_4y, W_8y); }
static int Transform_AVX2(Sha512* sha512)
static int Transform_AVX2(wc_Sha512* sha512)
{
const word64* K = K512;
word64 w[4];
@ -1345,7 +1345,7 @@ static int Transform_AVX2(Sha512* sha512)
/* SHA384 */
/* -------------------------------------------------------------------------- */
#ifdef WOLFSSL_SHA384
static int InitSha384(Sha384* sha384)
static int InitSha384(wc_Sha384* sha384)
{
if (sha384 == NULL) {
return BAD_FUNC_ARG;
@ -1367,7 +1367,7 @@ static int InitSha384(Sha384* sha384)
return 0;
}
int wc_Sha384Update(Sha384* sha384, const byte* data, word32 len)
int wc_Sha384Update(wc_Sha384* sha384, const byte* data, word32 len)
{
if (sha384 == NULL || (data == NULL && len > 0)) {
return BAD_FUNC_ARG;
@ -1381,11 +1381,11 @@ int wc_Sha384Update(Sha384* sha384, const byte* data, word32 len)
}
#endif /* WOLFSSL_ASYNC_CRYPT */
return Sha512Update((Sha512*)sha384, data, len);
return Sha512Update((wc_Sha512*)sha384, data, len);
}
int wc_Sha384Final(Sha384* sha384, byte* hash)
int wc_Sha384Final(wc_Sha384* sha384, byte* hash)
{
int ret;
@ -1397,16 +1397,16 @@ int wc_Sha384Final(Sha384* sha384, byte* hash)
if (sha384->asyncDev.marker == WOLFSSL_ASYNC_MARKER_SHA384) {
#if defined(HAVE_INTEL_QA)
return IntelQaSymSha384(&sha384->asyncDev, hash, NULL,
SHA384_DIGEST_SIZE);
WC_SHA384_DIGEST_SIZE);
#endif
}
#endif /* WOLFSSL_ASYNC_CRYPT */
ret = Sha512Final((Sha512*)sha384);
ret = Sha512Final((wc_Sha512*)sha384);
if (ret != 0)
return ret;
XMEMCPY(hash, sha384->digest, SHA384_DIGEST_SIZE);
XMEMCPY(hash, sha384->digest, WC_SHA384_DIGEST_SIZE);
return InitSha384(sha384); /* reset state */
}
@ -1414,7 +1414,7 @@ int wc_Sha384Final(Sha384* sha384, byte* hash)
/* Hardware Acceleration */
#if defined(HAVE_INTEL_AVX1) || defined(HAVE_INTEL_AVX2)
int wc_InitSha384_ex(Sha384* sha384, void* heap, int devId)
int wc_InitSha384_ex(wc_Sha384* sha384, void* heap, int devId)
{
int ret = InitSha384(sha384);
@ -1426,7 +1426,7 @@ int wc_Sha384Final(Sha384* sha384, byte* hash)
return ret;
}
#else
int wc_InitSha384_ex(Sha384* sha384, void* heap, int devId)
int wc_InitSha384_ex(wc_Sha384* sha384, void* heap, int devId)
{
int ret;
@ -1450,12 +1450,12 @@ int wc_InitSha384_ex(Sha384* sha384, void* heap, int devId)
}
#endif
int wc_InitSha384(Sha384* sha384)
int wc_InitSha384(wc_Sha384* sha384)
{
return wc_InitSha384_ex(sha384, NULL, INVALID_DEVID);
}
void wc_Sha384Free(Sha384* sha384)
void wc_Sha384Free(wc_Sha384* sha384)
{
if (sha384 == NULL)
return;
@ -1470,10 +1470,10 @@ void wc_Sha384Free(Sha384* sha384)
#endif /* HAVE_FIPS */
int wc_Sha512GetHash(Sha512* sha512, byte* hash)
int wc_Sha512GetHash(wc_Sha512* sha512, byte* hash)
{
int ret;
Sha512 tmpSha512;
wc_Sha512 tmpSha512;
if (sha512 == NULL || hash == NULL)
return BAD_FUNC_ARG;
@ -1485,14 +1485,14 @@ int wc_Sha512GetHash(Sha512* sha512, byte* hash)
return ret;
}
int wc_Sha512Copy(Sha512* src, Sha512* dst)
int wc_Sha512Copy(wc_Sha512* src, wc_Sha512* dst)
{
int ret = 0;
if (src == NULL || dst == NULL)
return BAD_FUNC_ARG;
XMEMCPY(dst, src, sizeof(Sha512));
XMEMCPY(dst, src, sizeof(wc_Sha512));
#ifdef WOLFSSL_ASYNC_CRYPT
ret = wolfAsync_DevCopy(&src->asyncDev, &dst->asyncDev);
@ -1502,10 +1502,10 @@ int wc_Sha512Copy(Sha512* src, Sha512* dst)
}
#ifdef WOLFSSL_SHA384
int wc_Sha384GetHash(Sha384* sha384, byte* hash)
int wc_Sha384GetHash(wc_Sha384* sha384, byte* hash)
{
int ret;
Sha384 tmpSha384;
wc_Sha384 tmpSha384;
if (sha384 == NULL || hash == NULL)
return BAD_FUNC_ARG;
@ -1516,14 +1516,14 @@ int wc_Sha384GetHash(Sha384* sha384, byte* hash)
}
return ret;
}
int wc_Sha384Copy(Sha384* src, Sha384* dst)
int wc_Sha384Copy(wc_Sha384* src, wc_Sha384* dst)
{
int ret = 0;
if (src == NULL || dst == NULL)
return BAD_FUNC_ARG;
XMEMCPY(dst, src, sizeof(Sha384));
XMEMCPY(dst, src, sizeof(wc_Sha384));
#ifdef WOLFSSL_ASYNC_CRYPT
ret = wolfAsync_DevCopy(&src->asyncDev, &dst->asyncDev);

8
wolfcrypt/src/srp.c
View File

@ -157,28 +157,28 @@ static word32 SrpHashSize(SrpType type)
switch (type) {
case SRP_TYPE_SHA:
#ifndef NO_SHA
return SHA_DIGEST_SIZE;
return WC_SHA_DIGEST_SIZE;
#else
return 0;
#endif
case SRP_TYPE_SHA256:
#ifndef NO_SHA256
return SHA256_DIGEST_SIZE;
return WC_SHA256_DIGEST_SIZE;
#else
return 0;
#endif
case SRP_TYPE_SHA384:
#ifdef WOLFSSL_SHA384
return SHA384_DIGEST_SIZE;
return WC_SHA384_DIGEST_SIZE;
#else
return 0;
#endif
case SRP_TYPE_SHA512:
#ifdef WOLFSSL_SHA512
return SHA512_DIGEST_SIZE;
return WC_SHA512_DIGEST_SIZE;
#else
return 0;
#endif

287
wolfcrypt/test/test.c
View File

@ -1185,9 +1185,9 @@ int md2_test(void)
int md5_test(void)
{
int ret = 0;
Md5 md5;
byte hash[MD5_DIGEST_SIZE];
byte hashcopy[MD5_DIGEST_SIZE];
wc_Md5 md5;
byte hash[WC_MD5_DIGEST_SIZE];
byte hashcopy[WC_MD5_DIGEST_SIZE];
testVector a, b, c, d, e, f;
testVector test_md5[6];
int times = sizeof(test_md5) / sizeof(testVector), i;
@ -1196,39 +1196,39 @@ int md5_test(void)
a.output = "\xd4\x1d\x8c\xd9\x8f\x00\xb2\x04\xe9\x80\x09\x98\xec\xf8\x42"
"\x7e";
a.inLen = XSTRLEN(a.input);
a.outLen = MD5_DIGEST_SIZE;
a.outLen = WC_MD5_DIGEST_SIZE;
b.input = "abc";
b.output = "\x90\x01\x50\x98\x3c\xd2\x4f\xb0\xd6\x96\x3f\x7d\x28\xe1\x7f"
"\x72";
b.inLen = XSTRLEN(b.input);
b.outLen = MD5_DIGEST_SIZE;
b.outLen = WC_MD5_DIGEST_SIZE;
c.input = "message digest";
c.output = "\xf9\x6b\x69\x7d\x7c\xb7\x93\x8d\x52\x5a\x2f\x31\xaa\xf1\x61"
"\xd0";
c.inLen = XSTRLEN(c.input);
c.outLen = MD5_DIGEST_SIZE;
c.outLen = WC_MD5_DIGEST_SIZE;
d.input = "abcdefghijklmnopqrstuvwxyz";
d.output = "\xc3\xfc\xd3\xd7\x61\x92\xe4\x00\x7d\xfb\x49\x6c\xca\x67\xe1"
"\x3b";
d.inLen = XSTRLEN(d.input);
d.outLen = MD5_DIGEST_SIZE;
d.outLen = WC_MD5_DIGEST_SIZE;
e.input = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz012345"
"6789";
e.output = "\xd1\x74\xab\x98\xd2\x77\xd9\xf5\xa5\x61\x1c\x2c\x9f\x41\x9d"
"\x9f";
e.inLen = XSTRLEN(e.input);
e.outLen = MD5_DIGEST_SIZE;
e.outLen = WC_MD5_DIGEST_SIZE;
f.input = "1234567890123456789012345678901234567890123456789012345678"
"9012345678901234567890";
f.output = "\x57\xed\xf4\xa2\x2b\xe3\xc9\x55\xac\x49\xda\x2e\x21\x07\xb6"
"\x7a";
f.inLen = XSTRLEN(f.input);
f.outLen = MD5_DIGEST_SIZE;
f.outLen = WC_MD5_DIGEST_SIZE;
test_md5[0] = a;
test_md5[1] = b;
@ -1255,10 +1255,10 @@ int md5_test(void)
if (ret != 0)
ERROR_OUT(-1530 - i, exit);
if (XMEMCMP(hash, test_md5[i].output, MD5_DIGEST_SIZE) != 0)
if (XMEMCMP(hash, test_md5[i].output, WC_MD5_DIGEST_SIZE) != 0)
ERROR_OUT(-1540 - i, exit);
if (XMEMCMP(hash, hashcopy, MD5_DIGEST_SIZE) != 0)
if (XMEMCMP(hash, hashcopy, WC_MD5_DIGEST_SIZE) != 0)
ERROR_OUT(-1550 - i, exit);
}
@ -1283,7 +1283,7 @@ int md5_test(void)
ret = wc_Md5Final(&md5, hash);
if (ret != 0)
ERROR_OUT(-1561, exit);
if (XMEMCMP(hash, large_digest, MD5_DIGEST_SIZE) != 0)
if (XMEMCMP(hash, large_digest, WC_MD5_DIGEST_SIZE) != 0)
ERROR_OUT(-1562, exit);
} /* END LARGE HASH TEST */
@ -1379,9 +1379,9 @@ int md4_test(void)
int sha_test(void)
{
int ret = 0;
Sha sha;
byte hash[SHA_DIGEST_SIZE];
byte hashcopy[SHA_DIGEST_SIZE];
wc_Sha sha;
byte hash[WC_SHA_DIGEST_SIZE];
byte hashcopy[WC_SHA_DIGEST_SIZE];
testVector a, b, c, d, e;
testVector test_sha[5];
int times = sizeof(test_sha) / sizeof(struct testVector), i;
@ -1390,26 +1390,26 @@ int sha_test(void)
a.output = "\xda\x39\xa3\xee\x5e\x6b\x4b\x0d\x32\x55\xbf\xef\x95\x60\x18"
"\x90\xaf\xd8\x07\x09";
a.inLen = XSTRLEN(a.input);
a.outLen = SHA_DIGEST_SIZE;
a.outLen = WC_SHA_DIGEST_SIZE;
b.input = "abc";
b.output = "\xA9\x99\x3E\x36\x47\x06\x81\x6A\xBA\x3E\x25\x71\x78\x50\xC2"
"\x6C\x9C\xD0\xD8\x9D";
b.inLen = XSTRLEN(b.input);
b.outLen = SHA_DIGEST_SIZE;
b.outLen = WC_SHA_DIGEST_SIZE;
c.input = "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq";
c.output = "\x84\x98\x3E\x44\x1C\x3B\xD2\x6E\xBA\xAE\x4A\xA1\xF9\x51\x29"
"\xE5\xE5\x46\x70\xF1";
c.inLen = XSTRLEN(c.input);
c.outLen = SHA_DIGEST_SIZE;
c.outLen = WC_SHA_DIGEST_SIZE;
d.input = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaa";
d.output = "\x00\x98\xBA\x82\x4B\x5C\x16\x42\x7B\xD7\xA1\x12\x2A\x5A\x44"
"\x2A\x25\xEC\x64\x4D";
d.inLen = XSTRLEN(d.input);
d.outLen = SHA_DIGEST_SIZE;
d.outLen = WC_SHA_DIGEST_SIZE;
e.input = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
@ -1417,7 +1417,7 @@ int sha_test(void)
e.output = "\xAD\x5B\x3F\xDB\xCB\x52\x67\x78\xC2\x83\x9D\x2F\x15\x1E\xA7"
"\x53\x99\x5E\x26\xA0";
e.inLen = XSTRLEN(e.input);
e.outLen = SHA_DIGEST_SIZE;
e.outLen = WC_SHA_DIGEST_SIZE;
test_sha[0] = a;
test_sha[1] = b;
@ -1441,9 +1441,9 @@ int sha_test(void)
if (ret != 0)
ERROR_OUT(-1730 - i, exit);
if (XMEMCMP(hash, test_sha[i].output, SHA_DIGEST_SIZE) != 0)
if (XMEMCMP(hash, test_sha[i].output, WC_SHA_DIGEST_SIZE) != 0)
ERROR_OUT(-1740 - i, exit);
if (XMEMCMP(hash, hashcopy, SHA_DIGEST_SIZE) != 0)
if (XMEMCMP(hash, hashcopy, WC_SHA_DIGEST_SIZE) != 0)
ERROR_OUT(-1750 - i, exit);
}
@ -1469,7 +1469,7 @@ int sha_test(void)
ret = wc_ShaFinal(&sha, hash);
if (ret != 0)
ERROR_OUT(-1761, exit);
if (XMEMCMP(hash, large_digest, SHA_DIGEST_SIZE) != 0)
if (XMEMCMP(hash, large_digest, WC_SHA_DIGEST_SIZE) != 0)
ERROR_OUT(-1762, exit);
} /* END LARGE HASH TEST */
@ -1626,32 +1626,32 @@ int blake2b_test(void)
#ifdef WOLFSSL_SHA224
int sha224_test(void)
{
Sha224 sha;
byte hash[SHA224_DIGEST_SIZE];
byte hashcopy[SHA224_DIGEST_SIZE];
wc_Sha224 sha;
byte hash[WC_SHA224_DIGEST_SIZE];
byte hashcopy[WC_SHA224_DIGEST_SIZE];
int ret = 0;
testVector a, b, c;
testVector test_sha[3];
int ret = 0;
int times = sizeof(test_sha) / sizeof(struct testVector), i;
a.input = "";
a.output = "\xd1\x4a\x02\x8c\x2a\x3a\x2b\xc9\x47\x61\x02\xbb\x28\x82\x34"
"\xc4\x15\xa2\xb0\x1f\x82\x8e\xa6\x2a\xc5\xb3\xe4\x2f";
a.inLen = XSTRLEN(a.input);
a.outLen = SHA224_DIGEST_SIZE;
a.outLen = WC_SHA224_DIGEST_SIZE;
b.input = "abc";
b.output = "\x23\x09\x7d\x22\x34\x05\xd8\x22\x86\x42\xa4\x77\xbd\xa2\x55"
"\xb3\x2a\xad\xbc\xe4\xbd\xa0\xb3\xf7\xe3\x6c\x9d\xa7";
b.inLen = XSTRLEN(b.input);
b.outLen = SHA224_DIGEST_SIZE;
b.outLen = WC_SHA224_DIGEST_SIZE;
c.input = "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq";
c.output = "\x75\x38\x8b\x16\x51\x27\x76\xcc\x5d\xba\x5d\xa1\xfd\x89\x01"
"\x50\xb0\xc6\x45\x5c\xb4\xf5\x8b\x19\x52\x52\x25\x25";
c.inLen = XSTRLEN(c.input);
c.outLen = SHA224_DIGEST_SIZE;
c.outLen = WC_SHA224_DIGEST_SIZE;
test_sha[0] = a;
test_sha[1] = b;
@ -1673,9 +1673,9 @@ int sha224_test(void)
if (ret != 0)
ERROR_OUT(-2030 - i, exit);
if (XMEMCMP(hash, test_sha[i].output, SHA224_DIGEST_SIZE) != 0)
if (XMEMCMP(hash, test_sha[i].output, WC_SHA224_DIGEST_SIZE) != 0)
ERROR_OUT(-2040 - i, exit);
if (XMEMCMP(hash, hashcopy, SHA224_DIGEST_SIZE) != 0)
if (XMEMCMP(hash, hashcopy, WC_SHA224_DIGEST_SIZE) != 0)
ERROR_OUT(-2050 - i, exit);
}
@ -1690,10 +1690,11 @@ exit:
#ifndef NO_SHA256
int sha256_test(void)
{
int ret = 0;
Sha256 sha;
byte hash[SHA256_DIGEST_SIZE];
byte hashcopy[SHA256_DIGEST_SIZE];
wc_Sha256 sha;
byte hash[WC_SHA256_DIGEST_SIZE];
byte hashcopy[WC_SHA256_DIGEST_SIZE];
int ret = 0;
testVector a, b, c;
testVector test_sha[3];
int times = sizeof(test_sha) / sizeof(struct testVector), i;
@ -1703,21 +1704,21 @@ int sha256_test(void)
"\x24\x27\xae\x41\xe4\x64\x9b\x93\x4c\xa4\x95\x99\x1b\x78\x52"
"\xb8\x55";
a.inLen = XSTRLEN(a.input);
a.outLen = SHA256_DIGEST_SIZE;
a.outLen = WC_SHA256_DIGEST_SIZE;
b.input = "abc";
b.output = "\xBA\x78\x16\xBF\x8F\x01\xCF\xEA\x41\x41\x40\xDE\x5D\xAE\x22"
"\x23\xB0\x03\x61\xA3\x96\x17\x7A\x9C\xB4\x10\xFF\x61\xF2\x00"
"\x15\xAD";
b.inLen = XSTRLEN(b.input);
b.outLen = SHA256_DIGEST_SIZE;
b.outLen = WC_SHA256_DIGEST_SIZE;
c.input = "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq";
c.output = "\x24\x8D\x6A\x61\xD2\x06\x38\xB8\xE5\xC0\x26\x93\x0C\x3E\x60"
"\x39\xA3\x3C\xE4\x59\x64\xFF\x21\x67\xF6\xEC\xED\xD4\x19\xDB"
"\x06\xC1";
c.inLen = XSTRLEN(c.input);
c.outLen = SHA256_DIGEST_SIZE;
c.outLen = WC_SHA256_DIGEST_SIZE;
test_sha[0] = a;
test_sha[1] = b;
@ -1739,9 +1740,9 @@ int sha256_test(void)
if (ret != 0)
ERROR_OUT(-2130 - i, exit);
if (XMEMCMP(hash, test_sha[i].output, SHA256_DIGEST_SIZE) != 0)
if (XMEMCMP(hash, test_sha[i].output, WC_SHA256_DIGEST_SIZE) != 0)
ERROR_OUT(-2140 - i, exit);
if (XMEMCMP(hash, hashcopy, SHA256_DIGEST_SIZE) != 0)
if (XMEMCMP(hash, hashcopy, WC_SHA256_DIGEST_SIZE) != 0)
ERROR_OUT(-2150 - i, exit);
}
@ -1767,7 +1768,7 @@ int sha256_test(void)
ret = wc_Sha256Final(&sha, hash);
if (ret != 0)
ERROR_OUT(-2161, exit);
if (XMEMCMP(hash, large_digest, SHA256_DIGEST_SIZE) != 0)
if (XMEMCMP(hash, large_digest, WC_SHA256_DIGEST_SIZE) != 0)
ERROR_OUT(-2162, exit);
} /* END LARGE HASH TEST */
@ -1783,10 +1784,10 @@ exit:
#ifdef WOLFSSL_SHA512
int sha512_test(void)
{
Sha512 sha;
byte hash[SHA512_DIGEST_SIZE];
byte hashcopy[SHA512_DIGEST_SIZE];
int ret = 0;
wc_Sha512 sha;
byte hash[WC_SHA512_DIGEST_SIZE];
byte hashcopy[WC_SHA512_DIGEST_SIZE];
int ret = 0;
testVector a, b, c;
testVector test_sha[3];
@ -1799,7 +1800,7 @@ int sha512_test(void)
"\x7e\xec\x2f\x63\xb9\x31\xbd\x47\x41\x7a\x81\xa5\x38\x32\x7a"
"\xf9\x27\xda\x3e";
a.inLen = XSTRLEN(a.input);
a.outLen = SHA512_DIGEST_SIZE;
a.outLen = WC_SHA512_DIGEST_SIZE;
b.input = "abc";
b.output = "\xdd\xaf\x35\xa1\x93\x61\x7a\xba\xcc\x41\x73\x49\xae\x20\x41"
@ -1808,7 +1809,7 @@ int sha512_test(void)
"\xfe\xeb\xbd\x45\x4d\x44\x23\x64\x3c\xe8\x0e\x2a\x9a\xc9\x4f"
"\xa5\x4c\xa4\x9f";
b.inLen = XSTRLEN(b.input);
b.outLen = SHA512_DIGEST_SIZE;
b.outLen = WC_SHA512_DIGEST_SIZE;
c.input = "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhi"
"jklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu";
@ -1818,7 +1819,7 @@ int sha512_test(void)
"\xb5\x43\x3a\xc7\xd3\x29\xee\xb6\xdd\x26\x54\x5e\x96\xe5\x5b"
"\x87\x4b\xe9\x09";
c.inLen = XSTRLEN(c.input);
c.outLen = SHA512_DIGEST_SIZE;
c.outLen = WC_SHA512_DIGEST_SIZE;
test_sha[0] = a;
test_sha[1] = b;
@ -1840,9 +1841,9 @@ int sha512_test(void)
if (ret != 0)
ERROR_OUT(-2230 - i, exit);
if (XMEMCMP(hash, test_sha[i].output, SHA512_DIGEST_SIZE) != 0)
if (XMEMCMP(hash, test_sha[i].output, WC_SHA512_DIGEST_SIZE) != 0)
ERROR_OUT(-2240 - i, exit);
if (XMEMCMP(hash, hashcopy, SHA512_DIGEST_SIZE) != 0)
if (XMEMCMP(hash, hashcopy, WC_SHA512_DIGEST_SIZE) != 0)
ERROR_OUT(-2250 - i, exit);
}
@ -1867,7 +1868,7 @@ int sha512_test(void)
ret = wc_Sha512Final(&sha, hash);
if (ret != 0)
ERROR_OUT(-2261, exit);
if (XMEMCMP(hash, large_digest, SHA512_DIGEST_SIZE) != 0)
if (XMEMCMP(hash, large_digest, WC_SHA512_DIGEST_SIZE) != 0)
ERROR_OUT(-2262, exit);
} /* END LARGE HASH TEST */
@ -1882,10 +1883,10 @@ exit:
#ifdef WOLFSSL_SHA384
int sha384_test(void)
{
Sha384 sha;
byte hash[SHA384_DIGEST_SIZE];
byte hashcopy[SHA384_DIGEST_SIZE];
int ret = 0;
wc_Sha384 sha;
byte hash[WC_SHA384_DIGEST_SIZE];
byte hashcopy[WC_SHA384_DIGEST_SIZE];
int ret = 0;
testVector a, b, c;
testVector test_sha[3];
@ -1898,7 +1899,7 @@ int sha384_test(void)
"\xe1\xda\x27\x4e\xde\xbf\xe7\x6f\x65\xfb\xd5\x1a\xd2\xf1\x48"
"\x98\xb9\x5b";
a.inLen = XSTRLEN(a.input);
a.outLen = SHA384_DIGEST_SIZE;
a.outLen = WC_SHA384_DIGEST_SIZE;
b.input = "abc";
b.output = "\xcb\x00\x75\x3f\x45\xa3\x5e\x8b\xb5\xa0\x3d\x69\x9a\xc6\x50"
@ -1906,7 +1907,7 @@ int sha384_test(void)
"\x5b\xed\x80\x86\x07\x2b\xa1\xe7\xcc\x23\x58\xba\xec\xa1\x34"
"\xc8\x25\xa7";
b.inLen = XSTRLEN(b.input);
b.outLen = SHA384_DIGEST_SIZE;
b.outLen = WC_SHA384_DIGEST_SIZE;
c.input = "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhi"
"jklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu";
@ -1915,7 +1916,7 @@ int sha384_test(void)
"\xf7\x12\xfc\xc7\xc7\x1a\x55\x7e\x2d\xb9\x66\xc3\xe9\xfa\x91"
"\x74\x60\x39";
c.inLen = XSTRLEN(c.input);
c.outLen = SHA384_DIGEST_SIZE;
c.outLen = WC_SHA384_DIGEST_SIZE;
test_sha[0] = a;
test_sha[1] = b;
@ -1937,9 +1938,9 @@ int sha384_test(void)
if (ret != 0)
ERROR_OUT(-2330 - i, exit);
if (XMEMCMP(hash, test_sha[i].output, SHA384_DIGEST_SIZE) != 0)
if (XMEMCMP(hash, test_sha[i].output, WC_SHA384_DIGEST_SIZE) != 0)
ERROR_OUT(-2340 - i, exit);
if (XMEMCMP(hash, hashcopy, SHA384_DIGEST_SIZE) != 0)
if (XMEMCMP(hash, hashcopy, WC_SHA384_DIGEST_SIZE) != 0)
ERROR_OUT(-2350 - i, exit);
}
@ -1963,7 +1964,7 @@ int sha384_test(void)
ret = wc_Sha384Final(&sha, hash);
if (ret != 0)
ERROR_OUT(-2361, exit);
if (XMEMCMP(hash, large_digest, SHA384_DIGEST_SIZE) != 0)
if (XMEMCMP(hash, large_digest, WC_SHA384_DIGEST_SIZE) != 0)
ERROR_OUT(-2362, exit);
} /* END LARGE HASH TEST */
@ -2496,32 +2497,32 @@ int hash_test(void)
return -2483;
#endif
#ifndef NO_MD5
ret = wc_GetCTC_HashOID(MD5);
ret = wc_GetCTC_HashOID(WC_MD5);
if (ret == 0)
return -2484;
#endif
#ifndef NO_SHA
ret = wc_GetCTC_HashOID(SHA);
ret = wc_GetCTC_HashOID(WC_SHA);
if (ret == 0)
return -2485;
#endif
#ifdef WOLFSSL_SHA224
ret = wc_GetCTC_HashOID(SHA224);
ret = wc_GetCTC_HashOID(WC_SHA224);
if (ret == 0)
return -2486;
#endif
#ifndef NO_SHA256
ret = wc_GetCTC_HashOID(SHA256);
ret = wc_GetCTC_HashOID(WC_SHA256);
if (ret == 0)
return -2487;
#endif
#ifdef WOLFSSL_SHA384
ret = wc_GetCTC_HashOID(SHA384);
ret = wc_GetCTC_HashOID(WC_SHA384);
if (ret == 0)
return -2488;
#endif
#ifdef WOLFSSL_SHA512
ret = wc_GetCTC_HashOID(SHA512);
ret = wc_GetCTC_HashOID(WC_SHA512);
if (ret == 0)
return -2489;
#endif
@ -2537,7 +2538,7 @@ int hash_test(void)
int hmac_md5_test(void)
{
Hmac hmac;
byte hash[MD5_DIGEST_SIZE];
byte hash[WC_MD5_DIGEST_SIZE];
const char* keys[]=
{
@ -2556,13 +2557,13 @@ int hmac_md5_test(void)
a.output = "\x92\x94\x72\x7a\x36\x38\xbb\x1c\x13\xf4\x8e\xf8\x15\x8b\xfc"
"\x9d";
a.inLen = XSTRLEN(a.input);
a.outLen = MD5_DIGEST_SIZE;
a.outLen = WC_MD5_DIGEST_SIZE;
b.input = "what do ya want for nothing?";
b.output = "\x75\x0c\x78\x3e\x6a\xb0\xb5\x03\xea\xa8\x6e\x31\x0a\x5d\xb7"
"\x38";
b.inLen = XSTRLEN(b.input);
b.outLen = MD5_DIGEST_SIZE;
b.outLen = WC_MD5_DIGEST_SIZE;
c.input = "\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD"
"\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD"
@ -2571,7 +2572,7 @@ int hmac_md5_test(void)
c.output = "\x56\xbe\x34\x52\x1d\x14\x4c\x88\xdb\xb8\xc7\x33\xf0\xe8\xb3"
"\xf6";
c.inLen = XSTRLEN(c.input);
c.outLen = MD5_DIGEST_SIZE;
c.outLen = WC_MD5_DIGEST_SIZE;
test_hmac[0] = a;
test_hmac[1] = b;
@ -2588,7 +2589,7 @@ int hmac_md5_test(void)
return -2500;
}
ret = wc_HmacSetKey(&hmac, MD5, (byte*)keys[i],
ret = wc_HmacSetKey(&hmac, WC_MD5, (byte*)keys[i],
(word32)XSTRLEN(keys[i]));
if (ret != 0)
return -2501;
@ -2600,14 +2601,14 @@ int hmac_md5_test(void)
if (ret != 0)
return -2503;
if (XMEMCMP(hash, test_hmac[i].output, MD5_DIGEST_SIZE) != 0)
if (XMEMCMP(hash, test_hmac[i].output, WC_MD5_DIGEST_SIZE) != 0)
return -2504 - i;
wc_HmacFree(&hmac);
}
#ifndef HAVE_FIPS
if (wc_HmacSizeByType(MD5) != MD5_DIGEST_SIZE)
if (wc_HmacSizeByType(WC_MD5) != WC_MD5_DIGEST_SIZE)
return -2514;
#endif
@ -2619,7 +2620,7 @@ int hmac_md5_test(void)
int hmac_sha_test(void)
{
Hmac hmac;
byte hash[SHA_DIGEST_SIZE];
byte hash[WC_SHA_DIGEST_SIZE];
const char* keys[]=
{
@ -2640,13 +2641,13 @@ int hmac_sha_test(void)
a.output = "\xb6\x17\x31\x86\x55\x05\x72\x64\xe2\x8b\xc0\xb6\xfb\x37\x8c"
"\x8e\xf1\x46\xbe\x00";
a.inLen = XSTRLEN(a.input);
a.outLen = SHA_DIGEST_SIZE;
a.outLen = WC_SHA_DIGEST_SIZE;
b.input = "what do ya want for nothing?";
b.output = "\xef\xfc\xdf\x6a\xe5\xeb\x2f\xa2\xd2\x74\x16\xd5\xf1\x84\xdf"
"\x9c\x25\x9a\x7c\x79";
b.inLen = XSTRLEN(b.input);
b.outLen = SHA_DIGEST_SIZE;
b.outLen = WC_SHA_DIGEST_SIZE;
c.input = "\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD"
"\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD"
@ -2655,7 +2656,7 @@ int hmac_sha_test(void)
c.output = "\x12\x5d\x73\x42\xb9\xac\x11\xcd\x91\xa3\x9a\xf4\x8a\xa1\x7b"
"\x4f\x63\xf1\x75\xd3";
c.inLen = XSTRLEN(c.input);
c.outLen = SHA_DIGEST_SIZE;
c.outLen = WC_SHA_DIGEST_SIZE;
test_hmac[0] = a;
test_hmac[1] = b;
@ -2670,7 +2671,7 @@ int hmac_sha_test(void)
if (wc_HmacInit(&hmac, HEAP_HINT, devId) != 0)
return -20010;
ret = wc_HmacSetKey(&hmac, SHA, (byte*)keys[i],
ret = wc_HmacSetKey(&hmac, WC_SHA, (byte*)keys[i],
(word32)XSTRLEN(keys[i]));
if (ret != 0)
return -2601;
@ -2682,14 +2683,14 @@ int hmac_sha_test(void)
if (ret != 0)
return -2603;
if (XMEMCMP(hash, test_hmac[i].output, SHA_DIGEST_SIZE) != 0)
if (XMEMCMP(hash, test_hmac[i].output, WC_SHA_DIGEST_SIZE) != 0)
return -2604 - i;
wc_HmacFree(&hmac);
}
#ifndef HAVE_FIPS
if (wc_HmacSizeByType(SHA) != SHA_DIGEST_SIZE)
if (wc_HmacSizeByType(WC_SHA) != WC_SHA_DIGEST_SIZE)
return -2614;
#endif
@ -2702,7 +2703,7 @@ int hmac_sha_test(void)
int hmac_sha224_test(void)
{
Hmac hmac;
byte hash[SHA224_DIGEST_SIZE];
byte hash[WC_SHA224_DIGEST_SIZE];
const char* keys[]=
{
@ -2723,13 +2724,13 @@ int hmac_sha224_test(void)
a.output = "\x89\x6f\xb1\x12\x8a\xbb\xdf\x19\x68\x32\x10\x7c\xd4\x9d\xf3"
"\x3f\x47\xb4\xb1\x16\x99\x12\xba\x4f\x53\x68\x4b\x22";
a.inLen = XSTRLEN(a.input);
a.outLen = SHA224_DIGEST_SIZE;
a.outLen = WC_SHA224_DIGEST_SIZE;
b.input = "what do ya want for nothing?";
b.output = "\xa3\x0e\x01\x09\x8b\xc6\xdb\xbf\x45\x69\x0f\x3a\x7e\x9e\x6d"
"\x0f\x8b\xbe\xa2\xa3\x9e\x61\x48\x00\x8f\xd0\x5e\x44";
b.inLen = XSTRLEN(b.input);
b.outLen = SHA224_DIGEST_SIZE;
b.outLen = WC_SHA224_DIGEST_SIZE;
c.input = "\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD"
"\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD"
@ -2738,7 +2739,7 @@ int hmac_sha224_test(void)
c.output = "\x7f\xb3\xcb\x35\x88\xc6\xc1\xf6\xff\xa9\x69\x4d\x7d\x6a\xd2"
"\x64\x93\x65\xb0\xc1\xf6\x5d\x69\xd1\xec\x83\x33\xea";
c.inLen = XSTRLEN(c.input);
c.outLen = SHA224_DIGEST_SIZE;
c.outLen = WC_SHA224_DIGEST_SIZE;
test_hmac[0] = a;
test_hmac[1] = b;
@ -2753,7 +2754,7 @@ int hmac_sha224_test(void)
if (wc_HmacInit(&hmac, HEAP_HINT, devId) != 0)
return -2700;
ret = wc_HmacSetKey(&hmac, SHA224, (byte*)keys[i],
ret = wc_HmacSetKey(&hmac, WC_SHA224, (byte*)keys[i],
(word32)XSTRLEN(keys[i]));
if (ret != 0)
return -2701;
@ -2765,14 +2766,14 @@ int hmac_sha224_test(void)
if (ret != 0)
return -2703;
if (XMEMCMP(hash, test_hmac[i].output, SHA224_DIGEST_SIZE) != 0)
if (XMEMCMP(hash, test_hmac[i].output, WC_SHA224_DIGEST_SIZE) != 0)
return -2704 - i;
wc_HmacFree(&hmac);
}
#ifndef HAVE_FIPS
if (wc_HmacSizeByType(SHA224) != SHA224_DIGEST_SIZE)
if (wc_HmacSizeByType(WC_SHA224) != WC_SHA224_DIGEST_SIZE)
return -2714;
#endif
@ -2785,7 +2786,7 @@ int hmac_sha224_test(void)
int hmac_sha256_test(void)
{
Hmac hmac;
byte hash[SHA256_DIGEST_SIZE];
byte hash[WC_SHA256_DIGEST_SIZE];
const char* keys[]=
{
@ -2807,14 +2808,14 @@ int hmac_sha256_test(void)
"\x2b\x88\x1d\xc2\x00\xc9\x83\x3d\xa7\x26\xe9\x37\x6c\x2e\x32"
"\xcf\xf7";
a.inLen = XSTRLEN(a.input);
a.outLen = SHA256_DIGEST_SIZE;
a.outLen = WC_SHA256_DIGEST_SIZE;
b.input = "what do ya want for nothing?";
b.output = "\x5b\xdc\xc1\x46\xbf\x60\x75\x4e\x6a\x04\x24\x26\x08\x95\x75"
"\xc7\x5a\x00\x3f\x08\x9d\x27\x39\x83\x9d\xec\x58\xb9\x64\xec"
"\x38\x43";
b.inLen = XSTRLEN(b.input);
b.outLen = SHA256_DIGEST_SIZE;
b.outLen = WC_SHA256_DIGEST_SIZE;
c.input = "\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD"
"\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD"
@ -2824,7 +2825,7 @@ int hmac_sha256_test(void)
"\xa7\x29\x59\x09\x8b\x3e\xf8\xc1\x22\xd9\x63\x55\x14\xce\xd5"
"\x65\xfe";
c.inLen = XSTRLEN(c.input);
c.outLen = SHA256_DIGEST_SIZE;
c.outLen = WC_SHA256_DIGEST_SIZE;
test_hmac[0] = a;
test_hmac[1] = b;
@ -2839,7 +2840,7 @@ int hmac_sha256_test(void)
if (wc_HmacInit(&hmac, HEAP_HINT, devId) != 0)
return -2800;
ret = wc_HmacSetKey(&hmac, SHA256, (byte*)keys[i],
ret = wc_HmacSetKey(&hmac, WC_SHA256, (byte*)keys[i],
(word32)XSTRLEN(keys[i]));
if (ret != 0)
return -2801;
@ -2851,14 +2852,14 @@ int hmac_sha256_test(void)
if (ret != 0)
return -2803;
if (XMEMCMP(hash, test_hmac[i].output, SHA256_DIGEST_SIZE) != 0)
if (XMEMCMP(hash, test_hmac[i].output, WC_SHA256_DIGEST_SIZE) != 0)
return -2804 - i;
wc_HmacFree(&hmac);
}
#ifndef HAVE_FIPS
if (wc_HmacSizeByType(SHA256) != SHA256_DIGEST_SIZE)
if (wc_HmacSizeByType(WC_SHA256) != WC_SHA256_DIGEST_SIZE)
return -2814;
if (wc_HmacSizeByType(20) != BAD_FUNC_ARG)
return -2815;
@ -2964,7 +2965,7 @@ int hmac_blake2b_test(void)
int hmac_sha384_test(void)
{
Hmac hmac;
byte hash[SHA384_DIGEST_SIZE];
byte hash[WC_SHA384_DIGEST_SIZE];
const char* keys[]=
{
@ -2987,7 +2988,7 @@ int hmac_sha384_test(void)
"\xc5\x9c\xfa\xea\x9e\xa9\x07\x6e\xde\x7f\x4a\xf1\x52\xe8\xb2"
"\xfa\x9c\xb6";
a.inLen = XSTRLEN(a.input);
a.outLen = SHA384_DIGEST_SIZE;
a.outLen = WC_SHA384_DIGEST_SIZE;
b.input = "what do ya want for nothing?";
b.output = "\xaf\x45\xd2\xe3\x76\x48\x40\x31\x61\x7f\x78\xd2\xb5\x8a\x6b"
@ -2995,7 +2996,7 @@ int hmac_sha384_test(void)
"\x44\x5e\x8e\x22\x40\xca\x5e\x69\xe2\xc7\x8b\x32\x39\xec\xfa"
"\xb2\x16\x49";
b.inLen = XSTRLEN(b.input);
b.outLen = SHA384_DIGEST_SIZE;
b.outLen = WC_SHA384_DIGEST_SIZE;
c.input = "\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD"
"\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD"
@ -3006,7 +3007,7 @@ int hmac_sha384_test(void)
"\x14\x4b\x2a\x5a\xb3\x9d\xc1\x38\x14\xb9\x4e\x3a\xb6\xe1\x01"
"\xa3\x4f\x27";
c.inLen = XSTRLEN(c.input);
c.outLen = SHA384_DIGEST_SIZE;
c.outLen = WC_SHA384_DIGEST_SIZE;
test_hmac[0] = a;
test_hmac[1] = b;
@ -3021,7 +3022,7 @@ int hmac_sha384_test(void)
if (wc_HmacInit(&hmac, HEAP_HINT, devId) != 0)
return -3000;
ret = wc_HmacSetKey(&hmac, SHA384, (byte*)keys[i],
ret = wc_HmacSetKey(&hmac, WC_SHA384, (byte*)keys[i],
(word32)XSTRLEN(keys[i]));
if (ret != 0)
return -3001;
@ -3033,14 +3034,14 @@ int hmac_sha384_test(void)
if (ret != 0)
return -3003;
if (XMEMCMP(hash, test_hmac[i].output, SHA384_DIGEST_SIZE) != 0)
if (XMEMCMP(hash, test_hmac[i].output, WC_SHA384_DIGEST_SIZE) != 0)
return -3004 - i;
wc_HmacFree(&hmac);
}
#ifndef HAVE_FIPS
if (wc_HmacSizeByType(SHA384) != SHA384_DIGEST_SIZE)
if (wc_HmacSizeByType(WC_SHA384) != WC_SHA384_DIGEST_SIZE)
return -3013;
#endif
@ -3053,7 +3054,7 @@ int hmac_sha384_test(void)
int hmac_sha512_test(void)
{
Hmac hmac;
byte hash[SHA512_DIGEST_SIZE];
byte hash[WC_SHA512_DIGEST_SIZE];
const char* keys[]=
{
@ -3077,7 +3078,7 @@ int hmac_sha512_test(void)
"\xa3\xf4\xe4\xbe\x9d\x91\x4e\xeb\x61\xf1\x70\x2e\x69\x6c\x20"
"\x3a\x12\x68\x54";
a.inLen = XSTRLEN(a.input);
a.outLen = SHA512_DIGEST_SIZE;
a.outLen = WC_SHA512_DIGEST_SIZE;
b.input = "what do ya want for nothing?";
b.output = "\x16\x4b\x7a\x7b\xfc\xf8\x19\xe2\xe3\x95\xfb\xe7\x3b\x56\xe0"
@ -3086,7 +3087,7 @@ int hmac_sha512_test(void)
"\xf0\xe6\xfd\xca\xea\xb1\xa3\x4d\x4a\x6b\x4b\x63\x6e\x07\x0a"
"\x38\xbc\xe7\x37";
b.inLen = XSTRLEN(b.input);
b.outLen = SHA512_DIGEST_SIZE;
b.outLen = WC_SHA512_DIGEST_SIZE;
c.input = "\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD"
"\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD"
@ -3098,7 +3099,7 @@ int hmac_sha512_test(void)
"\x67\xc8\x07\xb9\x46\xa3\x37\xbe\xe8\x94\x26\x74\x27\x88\x59"
"\xe1\x32\x92\xfb";
c.inLen = XSTRLEN(c.input);
c.outLen = SHA512_DIGEST_SIZE;
c.outLen = WC_SHA512_DIGEST_SIZE;
test_hmac[0] = a;
test_hmac[1] = b;
@ -3113,7 +3114,7 @@ int hmac_sha512_test(void)
if (wc_HmacInit(&hmac, HEAP_HINT, devId) != 0)
return -3100;
ret = wc_HmacSetKey(&hmac, SHA512, (byte*)keys[i],
ret = wc_HmacSetKey(&hmac, WC_SHA512, (byte*)keys[i],
(word32)XSTRLEN(keys[i]));
if (ret != 0)
return -3101;
@ -3125,14 +3126,14 @@ int hmac_sha512_test(void)
if (ret != 0)
return -3103;
if (XMEMCMP(hash, test_hmac[i].output, SHA512_DIGEST_SIZE) != 0)
if (XMEMCMP(hash, test_hmac[i].output, WC_SHA512_DIGEST_SIZE) != 0)
return -3104 - i;
wc_HmacFree(&hmac);
}
#ifndef HAVE_FIPS
if (wc_HmacSizeByType(SHA512) != SHA512_DIGEST_SIZE)
if (wc_HmacSizeByType(WC_SHA512) != WC_SHA512_DIGEST_SIZE)
return -3113;
#endif
@ -6555,7 +6556,7 @@ int random_test(void)
0xa1, 0x80, 0x18, 0x3a, 0x07, 0xdf, 0xae, 0x17
};
byte output[SHA256_DIGEST_SIZE * 4];
byte output[WC_SHA256_DIGEST_SIZE * 4];
int ret;
ret = wc_RNG_HealthTest(0, test1Entropy, sizeof(test1Entropy), NULL, 0,
@ -7970,7 +7971,7 @@ int rsa_test(void)
If key size is less than (hash length * 2) + 2 then is invalid use
and test, since OAEP padding requires this.
BAD_FUNC_ARG is returned when this case is not met */
if (wc_RsaEncryptSize(&key) > ((int)SHA512_DIGEST_SIZE * 2) + 2) {
if (wc_RsaEncryptSize(&key) > ((int)WC_SHA512_DIGEST_SIZE * 2) + 2) {
XMEMSET(plain, 0, plainSz);
do {
#if defined(WOLFSSL_ASYNC_CRYPT)
@ -9262,8 +9263,8 @@ int dsa_test(void)
byte tmp[1024];
DsaKey key;
WC_RNG rng;
Sha sha;
byte hash[SHA_DIGEST_SIZE];
wc_Sha sha;
byte hash[WC_SHA_DIGEST_SIZE];
byte signature[40];
#ifdef USE_CERT_BUFFERS_1024
@ -9555,7 +9556,7 @@ int openssl_test(void)
{
EVP_MD_CTX md_ctx;
testVector a, b, c, d, e, f;
byte hash[SHA256_DIGEST_SIZE*2]; /* max size */
byte hash[WC_SHA256_DIGEST_SIZE*2]; /* max size */
(void)a;
(void)b;
@ -9581,7 +9582,7 @@ int openssl_test(void)
a.output = "\x57\xed\xf4\xa2\x2b\xe3\xc9\x55\xac\x49\xda\x2e\x21\x07\xb6"
"\x7a";
a.inLen = XSTRLEN(a.input);
a.outLen = MD5_DIGEST_SIZE;
a.outLen = WC_MD5_DIGEST_SIZE;
EVP_MD_CTX_init(&md_ctx);
EVP_DigestInit(&md_ctx, EVP_md5());
@ -9589,7 +9590,7 @@ int openssl_test(void)
EVP_DigestUpdate(&md_ctx, a.input, (unsigned long)a.inLen);
EVP_DigestFinal(&md_ctx, hash, 0);
if (XMEMCMP(hash, a.output, MD5_DIGEST_SIZE) != 0)
if (XMEMCMP(hash, a.output, WC_MD5_DIGEST_SIZE) != 0)
return -5901;
#endif /* NO_MD5 */
@ -9602,7 +9603,7 @@ int openssl_test(void)
b.output = "\xAD\x5B\x3F\xDB\xCB\x52\x67\x78\xC2\x83\x9D\x2F\x15\x1E\xA7"
"\x53\x99\x5E\x26\xA0";
b.inLen = XSTRLEN(b.input);
b.outLen = SHA_DIGEST_SIZE;
b.outLen = WC_SHA_DIGEST_SIZE;
EVP_MD_CTX_init(&md_ctx);
EVP_DigestInit(&md_ctx, EVP_sha1());
@ -9610,7 +9611,7 @@ int openssl_test(void)
EVP_DigestUpdate(&md_ctx, b.input, (unsigned long)b.inLen);
EVP_DigestFinal(&md_ctx, hash, 0);
if (XMEMCMP(hash, b.output, SHA_DIGEST_SIZE) != 0)
if (XMEMCMP(hash, b.output, WC_SHA_DIGEST_SIZE) != 0)
return -5902;
#endif /* NO_SHA */
@ -9622,7 +9623,7 @@ int openssl_test(void)
e.output = "\xc9\x7c\xa9\xa5\x59\x85\x0c\xe9\x7a\x04\xa9\x6d\xef\x6d\x99"
"\xa9\xe0\xe0\xe2\xab\x14\xe6\xb8\xdf\x26\x5f\xc0\xb3";
e.inLen = XSTRLEN(e.input);
e.outLen = SHA224_DIGEST_SIZE;
e.outLen = WC_SHA224_DIGEST_SIZE;
EVP_MD_CTX_init(&md_ctx);
EVP_DigestInit(&md_ctx, EVP_sha224());
@ -9630,7 +9631,7 @@ int openssl_test(void)
EVP_DigestUpdate(&md_ctx, e.input, (unsigned long)e.inLen);
EVP_DigestFinal(&md_ctx, hash, 0);
if (XMEMCMP(hash, e.output, SHA224_DIGEST_SIZE) != 0)
if (XMEMCMP(hash, e.output, WC_SHA224_DIGEST_SIZE) != 0)
return -5903;
#endif /* WOLFSSL_SHA224 */
@ -9641,7 +9642,7 @@ int openssl_test(void)
"\x39\xA3\x3C\xE4\x59\x64\xFF\x21\x67\xF6\xEC\xED\xD4\x19\xDB"
"\x06\xC1";
d.inLen = XSTRLEN(d.input);
d.outLen = SHA256_DIGEST_SIZE;
d.outLen = WC_SHA256_DIGEST_SIZE;
EVP_MD_CTX_init(&md_ctx);
EVP_DigestInit(&md_ctx, EVP_sha256());
@ -9649,7 +9650,7 @@ int openssl_test(void)
EVP_DigestUpdate(&md_ctx, d.input, (unsigned long)d.inLen);
EVP_DigestFinal(&md_ctx, hash, 0);
if (XMEMCMP(hash, d.output, SHA256_DIGEST_SIZE) != 0)
if (XMEMCMP(hash, d.output, WC_SHA256_DIGEST_SIZE) != 0)
return -5904;
#ifdef WOLFSSL_SHA384
@ -9661,7 +9662,7 @@ int openssl_test(void)
"\xf7\x12\xfc\xc7\xc7\x1a\x55\x7e\x2d\xb9\x66\xc3\xe9\xfa\x91"
"\x74\x60\x39";
e.inLen = XSTRLEN(e.input);
e.outLen = SHA384_DIGEST_SIZE;
e.outLen = WC_SHA384_DIGEST_SIZE;
EVP_MD_CTX_init(&md_ctx);
EVP_DigestInit(&md_ctx, EVP_sha384());
@ -9669,7 +9670,7 @@ int openssl_test(void)
EVP_DigestUpdate(&md_ctx, e.input, (unsigned long)e.inLen);
EVP_DigestFinal(&md_ctx, hash, 0);
if (XMEMCMP(hash, e.output, SHA384_DIGEST_SIZE) != 0)
if (XMEMCMP(hash, e.output, WC_SHA384_DIGEST_SIZE) != 0)
return -5905;
#endif /* WOLFSSL_SHA384 */
@ -9685,7 +9686,7 @@ int openssl_test(void)
"\xb5\x43\x3a\xc7\xd3\x29\xee\xb6\xdd\x26\x54\x5e\x96\xe5\x5b"
"\x87\x4b\xe9\x09";
f.inLen = XSTRLEN(f.input);
f.outLen = SHA512_DIGEST_SIZE;
f.outLen = WC_SHA512_DIGEST_SIZE;
EVP_MD_CTX_init(&md_ctx);
EVP_DigestInit(&md_ctx, EVP_sha512());
@ -9693,7 +9694,7 @@ int openssl_test(void)
EVP_DigestUpdate(&md_ctx, f.input, (unsigned long)f.inLen);
EVP_DigestFinal(&md_ctx, hash, 0);
if (XMEMCMP(hash, f.output, SHA512_DIGEST_SIZE) != 0)
if (XMEMCMP(hash, f.output, WC_SHA512_DIGEST_SIZE) != 0)
return -5906;
#endif /* WOLFSSL_SHA512 */
@ -9707,12 +9708,12 @@ int openssl_test(void)
c.output = "\x55\x78\xe8\x48\x4b\xcc\x93\x80\x93\xec\x53\xaf\x22\xd6\x14"
"\x76";
c.inLen = XSTRLEN(c.input);
c.outLen = MD5_DIGEST_SIZE;
c.outLen = WC_MD5_DIGEST_SIZE;
HMAC(EVP_md5(),
"JefeJefeJefeJefe", 16, (byte*)c.input, (int)c.inLen, hash, 0);
if (XMEMCMP(hash, c.output, MD5_DIGEST_SIZE) != 0)
if (XMEMCMP(hash, c.output, WC_MD5_DIGEST_SIZE) != 0)
return -5908;
#endif /* NO_MD5 */
@ -10380,7 +10381,7 @@ int pkcs12_test(void)
int kLen = 24;
int iterations = 1;
int ret = wc_PKCS12_PBKDF(derived, passwd, sizeof(passwd), salt, 8,
iterations, kLen, SHA256, id);
iterations, kLen, WC_SHA256, id);
if (ret < 0)
return -6100;
@ -10390,12 +10391,12 @@ int pkcs12_test(void)
iterations = 1000;
ret = wc_PKCS12_PBKDF(derived, passwd2, sizeof(passwd2), salt2, 8,
iterations, kLen, SHA256, id);
iterations, kLen, WC_SHA256, id);
if (ret < 0)
return -6102;
ret = wc_PKCS12_PBKDF_ex(derived, passwd2, sizeof(passwd2), salt2, 8,
iterations, kLen, SHA256, id, HEAP_HINT);
iterations, kLen, WC_SHA256, id, HEAP_HINT);
if (ret < 0)
return -6103;
@ -10420,7 +10421,7 @@ int pbkdf2_test(void)
};
int ret = wc_PBKDF2(derived, (byte*)passwd, (int)XSTRLEN(passwd), salt, 8,
iterations, kLen, SHA256);
iterations, kLen, WC_SHA256);
if (ret != 0)
return ret;
@ -10447,7 +10448,7 @@ int pbkdf1_test(void)
};
wc_PBKDF1(derived, (byte*)passwd, (int)XSTRLEN(passwd), salt, 8, iterations,
kLen, SHA);
kLen, WC_SHA);
if (XMEMCMP(derived, verify, sizeof(verify)) != 0)
return -6300;
@ -10521,7 +10522,7 @@ int hkdf_test(void)
(void)info1;
#ifndef NO_SHA
ret = wc_HKDF(SHA, ikm1, 22, NULL, 0, NULL, 0, okm1, L);
ret = wc_HKDF(WC_SHA, ikm1, 22, NULL, 0, NULL, 0, okm1, L);
if (ret != 0)
return -6400;
@ -10530,7 +10531,7 @@ int hkdf_test(void)
#ifndef HAVE_FIPS
/* fips can't have key size under 14 bytes, salt is key too */
ret = wc_HKDF(SHA, ikm1, 11, salt1, 13, info1, 10, okm1, L);
ret = wc_HKDF(WC_SHA, ikm1, 11, salt1, 13, info1, 10, okm1, L);
if (ret != 0)
return -6402;
@ -10540,7 +10541,7 @@ int hkdf_test(void)
#endif /* NO_SHA */
#ifndef NO_SHA256
ret = wc_HKDF(SHA256, ikm1, 22, NULL, 0, NULL, 0, okm1, L);
ret = wc_HKDF(WC_SHA256, ikm1, 22, NULL, 0, NULL, 0, okm1, L);
if (ret != 0)
return -6404;
@ -10549,7 +10550,7 @@ int hkdf_test(void)
#ifndef HAVE_FIPS
/* fips can't have key size under 14 bytes, salt is key too */
ret = wc_HKDF(SHA256, ikm1, 22, salt1, 13, info1, 10, okm1, L);
ret = wc_HKDF(WC_SHA256, ikm1, 22, salt1, 13, info1, 10, okm1, L);
if (ret != 0)
return -6406;
@ -14416,7 +14417,7 @@ static int pkcs7signed_run_vectors(byte* rsaCert, word32 rsaCertSz,
static byte senderNonceOid[] =
{ 0x06, 0x0a, 0x60, 0x86, 0x48, 0x01, 0x86, 0xF8, 0x45, 0x01,
0x09, 0x05 };
static byte transId[(SHA_DIGEST_SIZE + 1) * 2 + 1];
static byte transId[(WC_SHA_DIGEST_SIZE + 1) * 2 + 1];
static byte messageType[] = { 0x13, 2, '1', '9' };
static byte senderNonce[PKCS7_NONCE_SZ + 2];
@ -14560,12 +14561,12 @@ static int pkcs7signed_run_vectors(byte* rsaCert, word32 rsaCertSz,
/* generate trans ID */
{
Sha sha;
byte digest[SHA_DIGEST_SIZE];
wc_Sha sha;
byte digest[WC_SHA_DIGEST_SIZE];
int j,k;
transId[0] = 0x13;
transId[1] = SHA_DIGEST_SIZE * 2;
transId[1] = WC_SHA_DIGEST_SIZE * 2;
ret = wc_InitSha_ex(&sha, HEAP_HINT, devId);
if (ret != 0) {
@ -14577,7 +14578,7 @@ static int pkcs7signed_run_vectors(byte* rsaCert, word32 rsaCertSz,
wc_ShaFinal(&sha, digest);
wc_ShaFree(&sha);
for (j = 0, k = 2; j < SHA_DIGEST_SIZE; j++, k += 2) {
for (j = 0, k = 2; j < WC_SHA_DIGEST_SIZE; j++, k += 2) {
XSNPRINTF((char*)&transId[k], 3, "%02x", digest[j]);
}
}

48
wolfssl/internal.h
View File

@ -184,15 +184,15 @@
#endif
#ifdef NO_SHA
#define SHA_DIGEST_SIZE 20
#define WC_SHA_DIGEST_SIZE 20
#endif
#ifdef NO_SHA256
#define SHA256_DIGEST_SIZE 32
#define WC_SHA256_DIGEST_SIZE 32
#endif
#ifdef NO_MD5
#define MD5_DIGEST_SIZE 16
#define WC_MD5_DIGEST_SIZE 16
#endif
@ -967,7 +967,7 @@ enum Misc {
ENCRYPT_LEN = 512, /* allow 4096 bit static buffer */
#endif
SIZEOF_SENDER = 4, /* clnt or srvr */
FINISHED_SZ = 36, /* MD5_DIGEST_SIZE + SHA_DIGEST_SIZE */
FINISHED_SZ = 36, /* WC_MD5_DIGEST_SIZE + WC_SHA_DIGEST_SIZE */
MAX_RECORD_SIZE = 16384, /* 2^14, max size by standard */
MAX_MSG_EXTRA = 38 + MAX_DIGEST_SIZE,
/* max added to msg, mac + pad from */
@ -1565,9 +1565,9 @@ struct WOLFSSL_CIPHER {
typedef struct OcspEntry OcspEntry;
#ifdef NO_SHA
#define OCSP_DIGEST_SIZE SHA256_DIGEST_SIZE
#define OCSP_DIGEST_SIZE WC_SHA256_DIGEST_SIZE
#else
#define OCSP_DIGEST_SIZE SHA_DIGEST_SIZE
#define OCSP_DIGEST_SIZE WC_SHA_DIGEST_SIZE
#endif
#ifdef NO_ASN
@ -1605,9 +1605,9 @@ struct WOLFSSL_OCSP {
typedef struct CRL_Entry CRL_Entry;
#ifdef NO_SHA
#define CRL_DIGEST_SIZE SHA256_DIGEST_SIZE
#define CRL_DIGEST_SIZE WC_SHA256_DIGEST_SIZE
#else
#define CRL_DIGEST_SIZE SHA_DIGEST_SIZE
#define CRL_DIGEST_SIZE WC_SHA_DIGEST_SIZE
#endif
#ifdef NO_ASN
@ -2038,7 +2038,7 @@ typedef struct SecureRenegotiation {
enum key_cache_state cache_status; /* track key cache state */
byte client_verify_data[TLS_FINISHED_SZ]; /* cached */
byte server_verify_data[TLS_FINISHED_SZ]; /* cached */
byte subject_hash[SHA_DIGEST_SIZE]; /* peer cert hash */
byte subject_hash[WC_SHA_DIGEST_SIZE]; /* peer cert hash */
Keys tmp_keys; /* can't overwrite real keys yet */
} SecureRenegotiation;
@ -2222,10 +2222,10 @@ struct WOLFSSL_CTX {
DerBuffer* certChain;
/* chain after self, in DER, with leading size for each cert */
#ifdef OPENSSL_EXTRA
STACK_OF(WOLFSSL_X509_NAME)* ca_names;
WOLF_STACK_OF(WOLFSSL_X509_NAME)* ca_names;
#endif
#if defined(WOLFSSL_NGINX) || defined (WOLFSSL_HAPROXY)
STACK_OF(WOLFSSL_X509)* x509Chain;
WOLF_STACK_OF(WOLFSSL_X509)* x509Chain;
#endif
#ifdef WOLFSSL_TLS13
int certChainCnt;
@ -2584,19 +2584,19 @@ WOLFSSL_LOCAL void FreeCiphers(WOLFSSL* ssl);
/* hashes type */
typedef struct Hashes {
#if !defined(NO_MD5) && !defined(NO_OLD_TLS)
byte md5[MD5_DIGEST_SIZE];
byte md5[WC_MD5_DIGEST_SIZE];
#endif
#if !defined(NO_SHA)
byte sha[SHA_DIGEST_SIZE];
byte sha[WC_SHA_DIGEST_SIZE];
#endif
#ifndef NO_SHA256
byte sha256[SHA256_DIGEST_SIZE];
byte sha256[WC_SHA256_DIGEST_SIZE];
#endif
#ifdef WOLFSSL_SHA384
byte sha384[SHA384_DIGEST_SIZE];
byte sha384[WC_SHA384_DIGEST_SIZE];
#endif
#ifdef WOLFSSL_SHA512
byte sha512[SHA512_DIGEST_SIZE];
byte sha512[WC_SHA512_DIGEST_SIZE];
#endif
} Hashes;
@ -2605,13 +2605,13 @@ WOLFSSL_LOCAL int BuildCertHashes(WOLFSSL* ssl, Hashes* hashes);
#ifdef WOLFSSL_TLS13
typedef union Digest {
#ifndef NO_WOLFSSL_SHA256
Sha256 sha256;
wc_Sha256 sha256;
#endif
#ifdef WOLFSSL_SHA384
Sha384 sha384;
wc_Sha384 sha384;
#endif
#ifdef WOLFSSL_SHA512
Sha512 sha512;
wc_Sha512 sha512;
#endif
} Digest;
#endif
@ -3165,19 +3165,19 @@ typedef struct HS_Hashes {
Hashes verifyHashes;
Hashes certHashes; /* for cert verify */
#ifndef NO_SHA
Sha hashSha; /* sha hash of handshake msgs */
wc_Sha hashSha; /* sha hash of handshake msgs */
#endif
#if !defined(NO_MD5) && !defined(NO_OLD_TLS)
Md5 hashMd5; /* md5 hash of handshake msgs */
wc_Md5 hashMd5; /* md5 hash of handshake msgs */
#endif
#ifndef NO_SHA256
Sha256 hashSha256; /* sha256 hash of handshake msgs */
wc_Sha256 hashSha256; /* sha256 hash of handshake msgs */
#endif
#ifdef WOLFSSL_SHA384
Sha384 hashSha384; /* sha384 hash of handshake msgs */
wc_Sha384 hashSha384; /* sha384 hash of handshake msgs */
#endif
#ifdef WOLFSSL_SHA512
Sha512 hashSha512; /* sha512 hash of handshake msgs */
wc_Sha512 hashSha512; /* sha512 hash of handshake msgs */
#endif
} HS_Hashes;

2
wolfssl/ocsp.h
View File

@ -71,7 +71,7 @@ WOLFSSL_API WOLFSSL_OCSP_CERTID* wolfSSL_OCSP_cert_to_id(
WOLFSSL_API void wolfSSL_OCSP_BASICRESP_free(WOLFSSL_OCSP_BASICRESP* basicResponse);
WOLFSSL_API int wolfSSL_OCSP_basic_verify(WOLFSSL_OCSP_BASICRESP *bs,
STACK_OF(WOLFSSL_X509) *certs, WOLFSSL_X509_STORE *st, unsigned long flags);
WOLF_STACK_OF(WOLFSSL_X509) *certs, WOLFSSL_X509_STORE *st, unsigned long flags);
WOLFSSL_API void wolfSSL_OCSP_RESPONSE_free(OcspResponse* response);
WOLFSSL_API OcspResponse* wolfSSL_d2i_OCSP_RESPONSE_bio(WOLFSSL_BIO* bio,

274
wolfssl/ssl.h
View File

@ -59,11 +59,44 @@
#undef OCSP_RESPONSE
#endif
#ifdef OPENSSL_EXTRA
#ifdef OPENSSL_COEXIST
/* mode to allow wolfSSL and OpenSSL to exist together */
#ifdef TEST_OPENSSL_COEXIST
/*
./configure --enable-opensslcoexist \
CFLAGS="-I/usr/local/opt/openssl/include -DTEST_OPENSSL_COEXIST" \
LDFLAGS="-L/usr/local/opt/openssl/lib -lcrypto"
*/
#include <openssl/ssl.h>
#include <openssl/rand.h>
#include <openssl/err.h>
#include <openssl/ec.h>
#include <openssl/hmac.h>
#include <openssl/bn.h>
#endif
/* make sure old names are disabled */
#ifndef NO_OLD_SSL_NAMES
#define NO_OLD_SSL_NAMES
#endif
#ifndef NO_OLD_WC_NAMES
#define NO_OLD_WC_NAMES
#endif
#elif defined(OPENSSL_EXTRA)
#include <wolfssl/openssl/bn.h>
#include <wolfssl/openssl/hmac.h>
/* We need the old SSL names */
#ifdef NO_OLD_SSL_NAMES
#undef NO_OLD_SSL_NAMES
#endif
#ifdef NO_OLD_WC_NAMES
#undef NO_OLD_WC_NAMES
#endif
#endif
#ifdef __cplusplus
extern "C" {
#endif
@ -537,19 +570,18 @@ WOLFSSL_API void wolfSSL_ERR_error_string_n(unsigned long e, char* buf,
WOLFSSL_API const char* wolfSSL_ERR_reason_error_string(unsigned long);
/* extras */
#define STACK_OF(x) WOLFSSL_STACK
WOLFSSL_API int wolfSSL_sk_X509_push(STACK_OF(WOLFSSL_X509_NAME)* sk,
#define WOLF_STACK_OF(x) WOLFSSL_STACK
WOLFSSL_API int wolfSSL_sk_X509_push(WOLF_STACK_OF(WOLFSSL_X509_NAME)* sk,
WOLFSSL_X509* x509);
WOLFSSL_API WOLFSSL_X509* wolfSSL_sk_X509_pop(STACK_OF(WOLFSSL_X509_NAME)* sk);
WOLFSSL_API void wolfSSL_sk_X509_free(STACK_OF(WOLFSSL_X509_NAME)* sk);
WOLFSSL_API WOLFSSL_X509* wolfSSL_sk_X509_pop(WOLF_STACK_OF(WOLFSSL_X509_NAME)* sk);
WOLFSSL_API void wolfSSL_sk_X509_free(WOLF_STACK_OF(WOLFSSL_X509_NAME)* sk);
WOLFSSL_API WOLFSSL_ASN1_OBJECT* wolfSSL_ASN1_OBJECT_new(void);
WOLFSSL_API void wolfSSL_ASN1_OBJECT_free(WOLFSSL_ASN1_OBJECT* obj);
WOLFSSL_API int wolfSSL_sk_ASN1_OBJECT_push(STACK_OF(WOLFSSL_ASN1_OBJEXT)* sk,
WOLFSSL_API int wolfSSL_sk_ASN1_OBJECT_push(WOLF_STACK_OF(WOLFSSL_ASN1_OBJEXT)* sk,
WOLFSSL_ASN1_OBJECT* obj);
WOLFSSL_API WOLFSSL_ASN1_OBJECT* wolfSSL_sk_ASN1_OBJCET_pop(
STACK_OF(WOLFSSL_ASN1_OBJECT)* sk);
WOLFSSL_API void wolfSSL_sk_ASN1_OBJECT_free(STACK_OF(WOLFSSL_ASN1_OBJECT)* sk);
WOLF_STACK_OF(WOLFSSL_ASN1_OBJECT)* sk);
WOLFSSL_API void wolfSSL_sk_ASN1_OBJECT_free(WOLF_STACK_OF(WOLFSSL_ASN1_OBJECT)* sk);
WOLFSSL_API int wolfSSL_ASN1_STRING_to_UTF8(unsigned char **out, WOLFSSL_ASN1_STRING *in);
WOLFSSL_API int wolfSSL_set_ex_data(WOLFSSL*, int, void*);
@ -719,7 +751,7 @@ WOLFSSL_API int wolfSSL_X509_STORE_get_by_subject(WOLFSSL_X509_STORE_CT
int, WOLFSSL_X509_NAME*, WOLFSSL_X509_OBJECT*);
WOLFSSL_API WOLFSSL_X509_STORE_CTX* wolfSSL_X509_STORE_CTX_new(void);
WOLFSSL_API int wolfSSL_X509_STORE_CTX_init(WOLFSSL_X509_STORE_CTX*,
WOLFSSL_X509_STORE*, WOLFSSL_X509*, STACK_OF(WOLFSSL_X509)*);
WOLFSSL_X509_STORE*, WOLFSSL_X509*, WOLF_STACK_OF(WOLFSSL_X509)*);
WOLFSSL_API void wolfSSL_X509_STORE_CTX_free(WOLFSSL_X509_STORE_CTX*);
WOLFSSL_API void wolfSSL_X509_STORE_CTX_cleanup(WOLFSSL_X509_STORE_CTX*);
@ -752,13 +784,13 @@ WOLFSSL_API long wolfSSL_ASN1_INTEGER_get(const WOLFSSL_ASN1_INTEGER*);
#ifdef OPENSSL_EXTRA
WOLFSSL_API WOLFSSL_BIGNUM *wolfSSL_ASN1_INTEGER_to_BN(const WOLFSSL_ASN1_INTEGER *ai,
WOLFSSL_BIGNUM *bn);
WOLFSSL_API STACK_OF(WOLFSSL_X509_NAME)* wolfSSL_load_client_CA_file(const char*);
WOLFSSL_API WOLF_STACK_OF(WOLFSSL_X509_NAME)* wolfSSL_load_client_CA_file(const char*);
#endif
WOLFSSL_API STACK_OF(WOLFSSL_X509_NAME)* wolfSSL_SSL_CTX_get_client_CA_list(
WOLFSSL_API WOLF_STACK_OF(WOLFSSL_X509_NAME)* wolfSSL_SSL_CTX_get_client_CA_list(
const WOLFSSL_CTX *s);
WOLFSSL_API void wolfSSL_CTX_set_client_CA_list(WOLFSSL_CTX*,
STACK_OF(WOLFSSL_X509_NAME)*);
WOLF_STACK_OF(WOLFSSL_X509_NAME)*);
WOLFSSL_API void* wolfSSL_X509_STORE_CTX_get_ex_data(WOLFSSL_X509_STORE_CTX*, int);
WOLFSSL_API int wolfSSL_get_ex_data_X509_STORE_CTX_idx(void);
WOLFSSL_API void* wolfSSL_get_ex_data(const WOLFSSL*, int);
@ -830,6 +862,16 @@ WOLFSSL_API long wolfSSL_get_verify_result(const WOLFSSL *ssl);
#define WOLFSSL_DEFAULT_CIPHER_LIST "" /* default all */
#define WOLFSSL_RSA_F4 0x10001L
enum {
WOLFSSL_OCSP_URL_OVERRIDE = 1,
WOLFSSL_OCSP_NO_NONCE = 2,
WOLFSSL_OCSP_CHECKALL = 4,
WOLFSSL_CRL_CHECKALL = 1,
WOLFSSL_CRL_CHECK = 27,
};
#ifdef OPENSSL_EXTRA
/* seperated out from other enums because of size */
enum {
SSL_OP_MICROSOFT_SESS_ID_BUG = 0x00000001,
@ -864,8 +906,9 @@ enum {
SSL_OP_NO_TLSv1_3 = 0x20000000,
};
enum {
#ifdef HAVE_OCSP
/* OCSP Flags */
OCSP_NOCERTS = 1,
OCSP_NOINTERN = 2,
OCSP_NOSIGS = 4,
@ -879,17 +922,12 @@ enum {
OCSP_RESPID_KEY = 1024,
OCSP_NOTIME = 2048,
/* OCSP Types */
OCSP_CERTID = 2,
OCSP_REQUEST = 4,
OCSP_RESPONSE = 8,
OCSP_BASICRESP = 16,
WOLFSSL_OCSP_URL_OVERRIDE = 1,
WOLFSSL_OCSP_NO_NONCE = 2,
WOLFSSL_OCSP_CHECKALL = 4,
WOLFSSL_CRL_CHECKALL = 1,
WOLFSSL_CRL_CHECK = 27,
#endif
ASN1_GENERALIZEDTIME = 4,
SSL_MAX_SSL_SESSION_ID_LENGTH = 32,
@ -981,6 +1019,7 @@ enum {
ASN1_STRFLGS_ESC_MSB = 4
};
#endif
/* extras end */
@ -994,65 +1033,123 @@ WOLFSSL_API void wolfSSL_ERR_dump_errors_fp(FILE* fp);
#endif
#endif
#ifndef NO_OLD_SSL_NAMES
#define SSL_ERROR_NONE WOLF_SSL_ERROR_NONE
#define SSL_FAILURE WOLF_SSL_FAILURE
#define SSL_SUCCESS WOLF_SSL_SUCCESS
#define SSL_SHUTDOWN_NOT_DONE WOLF_WOLF_SSL_SHUTDOWN_NOT_DONE
#define SSL_ALPN_NOT_FOUND WOLF_SSL_ALPN_NOT_FOUND
#define SSL_BAD_CERTTYPE WOLF_SSL_BAD_CERTTYPE
#define SSL_BAD_STAT WOLF_SSL_BAD_STAT
#define SSL_BAD_PATH WOLF_SSL_BAD_PATH
#define SSL_BAD_FILETYPE WOLF_SSL_BAD_FILETYPE
#define SSL_BAD_FILE WOLF_SSL_BAD_FILE
#define SSL_NOT_IMPLEMENTED WOLF_SSL_NOT_IMPLEMENTED
#define SSL_UNKNOWN WOLF_SSL_UNKNOWN
#define SSL_FATAL_ERROR WOLF_SSL_FATAL_ERROR
#define SSL_FILETYPE_ASN1 WOLF_SSL_FILETYPE_ASN1
#define SSL_FILETYPE_PEM WOLF_SSL_FILETYPE_PEM
#define SSL_FILETYPE_DEFAULT WOLF_SSL_FILETYPE_DEFAULT
#define SSL_FILETYPE_RAW WOLF_SSL_FILETYPE_RAW
#define SSL_VERIFY_NONE WOLF_SSL_VERIFY_NONE
#define SSL_VERIFY_PEER WOLF_SSL_VERIFY_PEER
#define SSL_VERIFY_FAIL_IF_NO_PEER_CERT WOLF_SSL_VERIFY_FAIL_IF_NO_PEER_CERT
#define SSL_VERIFY_CLIENT_ONCE WOLF_SSL_VERIFY_CLIENT_ONCE
#define SSL_VERIFY_FAIL_EXCEPT_PSK WOLF_SSL_VERIFY_FAIL_EXCEPT_PSK
#define SSL_SESS_CACHE_OFF WOLF_SSL_SESS_CACHE_OFF
#define SSL_SESS_CACHE_CLIENT WOLF_SSL_SESS_CACHE_CLIENT
#define SSL_SESS_CACHE_SERVER WOLF_SSL_SESS_CACHE_SERVER
#define SSL_SESS_CACHE_BOTH WOLF_SSL_SESS_CACHE_BOTH
#define SSL_SESS_CACHE_NO_AUTO_CLEAR WOLF_SSL_SESS_CACHE_NO_AUTO_CLEAR
#define SSL_SESS_CACHE_NO_INTERNAL_LOOKUP WOLF_SSL_SESS_CACHE_NO_INTERNAL_LOOKUP
#define SSL_SESS_CACHE_NO_INTERNAL_STORE WOLF_SSL_SESS_CACHE_NO_INTERNAL_STORE
#define SSL_SESS_CACHE_NO_INTERNAL WOLF_SSL_SESS_CACHE_NO_INTERNAL
#define SSL_ERROR_WANT_READ WOLF_SSL_ERROR_WANT_READ
#define SSL_ERROR_WANT_WRITE WOLF_SSL_ERROR_WANT_WRITE
#define SSL_ERROR_WANT_CONNECT WOLF_SSL_ERROR_WANT_CONNECT
#define SSL_ERROR_WANT_ACCEPT WOLF_SSL_ERROR_WANT_ACCEPT
#define SSL_ERROR_SYSCALL WOLF_SSL_ERROR_SYSCALL
#define SSL_ERROR_WANT_X509_LOOKUP WOLF_SSL_ERROR_WANT_X509_LOOKUP
#define SSL_ERROR_ZERO_RETURN WOLF_SSL_ERROR_ZERO_RETURN
#define SSL_ERROR_SSL WOLF_SSL_ERROR_SSL
#define SSL_SENT_SHUTDOWN WOLF_SSL_SENT_SHUTDOWN
#define SSL_RECEIVED_SHUTDOWN WOLF_SSL_RECEIVED_SHUTDOWN
#define SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER WOLF_SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER
#define SSL_OP_NO_SSLv2 WOLF_SSL_OP_NO_SSLv2
#define SSL_R_SSL_HANDSHAKE_FAILURE WOLF_SSL_R_SSL_HANDSHAKE_FAILURE
#define SSL_R_TLSV1_ALERT_UNKNOWN_CA WOLF_SSL_R_TLSV1_ALERT_UNKNOWN_CA
#define SSL_R_SSLV3_ALERT_CERTIFICATE_UNKNOWN WOLF_SSL_R_SSLV3_ALERT_CERTIFICATE_UNKNOWN
#define SSL_R_SSLV3_ALERT_BAD_CERTIFICATE WOLF_SSL_R_SSLV3_ALERT_BAD_CERTIFICATE
#define PEM_BUFSIZE WOLF_PEM_BUFSIZE
#endif
enum { /* ssl Constants */
SSL_ERROR_NONE = 0, /* for most functions */
SSL_FAILURE = 0, /* for some functions */
SSL_SUCCESS = 1,
SSL_SHUTDOWN_NOT_DONE = 2, /* call wolfSSL_shutdown again to complete */
WOLF_SSL_ERROR_NONE = 0, /* for most functions */
WOLF_SSL_FAILURE = 0, /* for some functions */
WOLF_SSL_SUCCESS = 1,
WOLF_SSL_SHUTDOWN_NOT_DONE = 2, /* call wolfSSL_shutdown again to complete */
SSL_ALPN_NOT_FOUND = -9,
SSL_BAD_CERTTYPE = -8,
SSL_BAD_STAT = -7,
SSL_BAD_PATH = -6,
SSL_BAD_FILETYPE = -5,
SSL_BAD_FILE = -4,
SSL_NOT_IMPLEMENTED = -3,
SSL_UNKNOWN = -2,
SSL_FATAL_ERROR = -1,
WOLF_SSL_ALPN_NOT_FOUND = -9,
WOLF_SSL_BAD_CERTTYPE = -8,
WOLF_SSL_BAD_STAT = -7,
WOLF_SSL_BAD_PATH = -6,
WOLF_SSL_BAD_FILETYPE = -5,
WOLF_SSL_BAD_FILE = -4,
WOLF_SSL_NOT_IMPLEMENTED = -3,
WOLF_SSL_UNKNOWN = -2,
WOLF_SSL_FATAL_ERROR = -1,
SSL_FILETYPE_ASN1 = 2,
SSL_FILETYPE_PEM = 1,
SSL_FILETYPE_DEFAULT = 2, /* ASN1 */
SSL_FILETYPE_RAW = 3, /* NTRU raw key blob */
WOLF_SSL_FILETYPE_ASN1 = 2,
WOLF_SSL_FILETYPE_PEM = 1,
WOLF_SSL_FILETYPE_DEFAULT = 2, /* ASN1 */
WOLF_SSL_FILETYPE_RAW = 3, /* NTRU raw key blob */
SSL_VERIFY_NONE = 0,
SSL_VERIFY_PEER = 1,
SSL_VERIFY_FAIL_IF_NO_PEER_CERT = 2,
SSL_VERIFY_CLIENT_ONCE = 4,
SSL_VERIFY_FAIL_EXCEPT_PSK = 8,
WOLF_SSL_VERIFY_NONE = 0,
WOLF_SSL_VERIFY_PEER = 1,
WOLF_SSL_VERIFY_FAIL_IF_NO_PEER_CERT = 2,
WOLF_SSL_VERIFY_CLIENT_ONCE = 4,
WOLF_SSL_VERIFY_FAIL_EXCEPT_PSK = 8,
SSL_SESS_CACHE_OFF = 0x0000,
SSL_SESS_CACHE_CLIENT = 0x0001,
SSL_SESS_CACHE_SERVER = 0x0002,
SSL_SESS_CACHE_BOTH = 0x0003,
SSL_SESS_CACHE_NO_AUTO_CLEAR = 0x0008,
SSL_SESS_CACHE_NO_INTERNAL_LOOKUP = 0x0100,
SSL_SESS_CACHE_NO_INTERNAL_STORE = 0x0200,
SSL_SESS_CACHE_NO_INTERNAL = 0x0300,
WOLF_SSL_SESS_CACHE_OFF = 0x0000,
WOLF_SSL_SESS_CACHE_CLIENT = 0x0001,
WOLF_SSL_SESS_CACHE_SERVER = 0x0002,
WOLF_SSL_SESS_CACHE_BOTH = 0x0003,
WOLF_SSL_SESS_CACHE_NO_AUTO_CLEAR = 0x0008,
WOLF_SSL_SESS_CACHE_NO_INTERNAL_LOOKUP = 0x0100,
WOLF_SSL_SESS_CACHE_NO_INTERNAL_STORE = 0x0200,
WOLF_SSL_SESS_CACHE_NO_INTERNAL = 0x0300,
SSL_ERROR_WANT_READ = 2,
SSL_ERROR_WANT_WRITE = 3,
SSL_ERROR_WANT_CONNECT = 7,
SSL_ERROR_WANT_ACCEPT = 8,
SSL_ERROR_SYSCALL = 5,
SSL_ERROR_WANT_X509_LOOKUP = 83,
SSL_ERROR_ZERO_RETURN = 6,
SSL_ERROR_SSL = 85,
WOLF_SSL_ERROR_WANT_READ = 2,
WOLF_SSL_ERROR_WANT_WRITE = 3,
WOLF_SSL_ERROR_WANT_CONNECT = 7,
WOLF_SSL_ERROR_WANT_ACCEPT = 8,
WOLF_SSL_ERROR_SYSCALL = 5,
WOLF_SSL_ERROR_WANT_X509_LOOKUP = 83,
WOLF_SSL_ERROR_ZERO_RETURN = 6,
WOLF_SSL_ERROR_SSL = 85,
SSL_SENT_SHUTDOWN = 1,
SSL_RECEIVED_SHUTDOWN = 2,
SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER = 4,
SSL_OP_NO_SSLv2 = 8,
WOLF_SSL_SENT_SHUTDOWN = 1,
WOLF_SSL_RECEIVED_SHUTDOWN = 2,
WOLF_SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER = 4,
WOLF_SSL_OP_NO_SSLv2 = 8,
SSL_R_SSL_HANDSHAKE_FAILURE = 101,
SSL_R_TLSV1_ALERT_UNKNOWN_CA = 102,
SSL_R_SSLV3_ALERT_CERTIFICATE_UNKNOWN = 103,
SSL_R_SSLV3_ALERT_BAD_CERTIFICATE = 104,
WOLF_SSL_R_SSL_HANDSHAKE_FAILURE = 101,
WOLF_SSL_R_TLSV1_ALERT_UNKNOWN_CA = 102,
WOLF_SSL_R_SSLV3_ALERT_CERTIFICATE_UNKNOWN = 103,
WOLF_SSL_R_SSLV3_ALERT_BAD_CERTIFICATE = 104,
PEM_BUFSIZE = 1024
WOLF_PEM_BUFSIZE = 1024
};
#ifndef NO_PSK
typedef unsigned int (*wc_psk_client_callback)(WOLFSSL*, const char*, char*,
unsigned int, unsigned char*, unsigned int);
@ -1084,7 +1181,7 @@ enum { /* ssl Constants */
/* extra begins */
#ifdef OPENSSL_EXTRA
enum { /* ERR Constants */
ERR_TXT_STRING = 1
};
@ -1096,6 +1193,7 @@ enum {
WOLFSSL_BIO_SIZE = 17000 /* default BIO write size if not set */
};
#endif
WOLFSSL_API unsigned long wolfSSL_ERR_get_error_line_data(const char**, int*,
const char**, int *);
@ -1250,7 +1348,7 @@ typedef struct WC_PKCS12 WC_PKCS12;
WOLFSSL_API WC_PKCS12* wolfSSL_d2i_PKCS12_bio(WOLFSSL_BIO* bio,
WC_PKCS12** pkcs12);
WOLFSSL_API int wolfSSL_PKCS12_parse(WC_PKCS12* pkcs12, const char* psw,
WOLFSSL_EVP_PKEY** pkey, WOLFSSL_X509** cert, STACK_OF(WOLFSSL_X509)** ca);
WOLFSSL_EVP_PKEY** pkey, WOLFSSL_X509** cert, WOLF_STACK_OF(WOLFSSL_X509)** ca);
WOLFSSL_API void wolfSSL_PKCS12_PBE_add(void);
@ -1410,7 +1508,7 @@ WOLFSSL_API WC_RNG* wolfSSL_GetRNG(WOLFSSL*);
WOLFSSL_API int wolfSSL_CTX_SetMinVersion(WOLFSSL_CTX* ctx, int version);
WOLFSSL_API int wolfSSL_SetMinVersion(WOLFSSL* ssl, int version);
WOLFSSL_API int wolfSSL_GetObjectSize(void); /* object size based on build */
WOLFSSL_API int wolfSSL_CTX_GetObjectSize(void);
WOLFSSL_API int wolfSSL_CTX_GetObjectSize(void);
WOLFSSL_API int wolfSSL_METHOD_GetObjectSize(void);
WOLFSSL_API int wolfSSL_GetOutputSize(WOLFSSL*, int);
WOLFSSL_API int wolfSSL_GetMaxOutputSize(WOLFSSL*);
@ -2191,10 +2289,10 @@ WOLFSSL_API void* wolfSSL_get_app_data( const WOLFSSL *ssl);
WOLFSSL_API int wolfSSL_set_app_data(WOLFSSL *ssl, void *arg);
WOLFSSL_API WOLFSSL_ASN1_OBJECT * wolfSSL_X509_NAME_ENTRY_get_object(WOLFSSL_X509_NAME_ENTRY *ne);
WOLFSSL_API WOLFSSL_X509_NAME_ENTRY *wolfSSL_X509_NAME_get_entry(WOLFSSL_X509_NAME *name, int loc);
WOLFSSL_API void wolfSSL_sk_X509_NAME_pop_free(STACK_OF(WOLFSSL_X509_NAME)* sk, void f (WOLFSSL_X509_NAME*));
WOLFSSL_API void wolfSSL_sk_X509_NAME_pop_free(WOLF_STACK_OF(WOLFSSL_X509_NAME)* sk, void f (WOLFSSL_X509_NAME*));
WOLFSSL_API unsigned char *wolfSSL_SHA1(const unsigned char *d, size_t n, unsigned char *md);
WOLFSSL_API int wolfSSL_X509_check_private_key(WOLFSSL_X509*, WOLFSSL_EVP_PKEY*);
WOLFSSL_API STACK_OF(WOLFSSL_X509_NAME) *wolfSSL_dup_CA_list( STACK_OF(WOLFSSL_X509_NAME) *sk );
WOLFSSL_API WOLF_STACK_OF(WOLFSSL_X509_NAME) *wolfSSL_dup_CA_list( WOLF_STACK_OF(WOLFSSL_X509_NAME) *sk );
/* end lighttpd*/
#endif
@ -2249,9 +2347,9 @@ WOLFSSL_API int wolfSSL_RAND_set_rand_method(const void *meth);
WOLFSSL_API int wolfSSL_CIPHER_get_bits(const WOLFSSL_CIPHER *c, int *alg_bits);
WOLFSSL_API int wolfSSL_sk_X509_NAME_num(const STACK_OF(WOLFSSL_X509_NAME) *s);
WOLFSSL_API int wolfSSL_sk_X509_NAME_num(const WOLF_STACK_OF(WOLFSSL_X509_NAME) *s);
WOLFSSL_API int wolfSSL_sk_X509_num(const STACK_OF(WOLFSSL_X509) *s);
WOLFSSL_API int wolfSSL_sk_X509_num(const WOLF_STACK_OF(WOLFSSL_X509) *s);
WOLFSSL_API int wolfSSL_X509_NAME_print_ex(WOLFSSL_BIO*,WOLFSSL_X509_NAME*,int,
unsigned long);
@ -2267,11 +2365,11 @@ WOLFSSL_API int wolfSSL_version(WOLFSSL*);
WOLFSSL_API int wolfSSL_get_state(const WOLFSSL*);
WOLFSSL_API void* wolfSSL_sk_X509_NAME_value(const STACK_OF(WOLFSSL_X509_NAME)*, int);
WOLFSSL_API void* wolfSSL_sk_X509_NAME_value(const WOLF_STACK_OF(WOLFSSL_X509_NAME)*, int);
WOLFSSL_API void* wolfSSL_sk_X509_value(STACK_OF(WOLFSSL_X509)*, int);
WOLFSSL_API void* wolfSSL_sk_X509_value(WOLF_STACK_OF(WOLFSSL_X509)*, int);
WOLFSSL_API STACK_OF(WOLFSSL_X509)* wolfSSL_get_peer_cert_chain(const WOLFSSL*);
WOLFSSL_API WOLF_STACK_OF(WOLFSSL_X509)* wolfSSL_get_peer_cert_chain(const WOLFSSL*);
WOLFSSL_API void* wolfSSL_SESSION_get_ex_data(const WOLFSSL_SESSION*, int);
@ -2313,10 +2411,10 @@ WOLFSSL_API void wolfSSL_THREADID_set_callback(void (*threadid_func)(void*));
WOLFSSL_API void wolfSSL_THREADID_set_numeric(void* id, unsigned long val);
WOLFSSL_API STACK_OF(WOLFSSL_X509)* wolfSSL_X509_STORE_get1_certs(
WOLFSSL_API WOLF_STACK_OF(WOLFSSL_X509)* wolfSSL_X509_STORE_get1_certs(
WOLFSSL_X509_STORE_CTX*, WOLFSSL_X509_NAME*);
WOLFSSL_API void wolfSSL_sk_X509_pop_free(STACK_OF(WOLFSSL_X509)* sk, void f (WOLFSSL_X509*));
WOLFSSL_API void wolfSSL_sk_X509_pop_free(WOLF_STACK_OF(WOLFSSL_X509)* sk, void f (WOLFSSL_X509*));
#endif /* HAVE_STUNNEL || WOLFSSL_NGINX || WOLFSSL_HAPROXY */
#if defined(HAVE_STUNNEL) || defined(WOLFSSL_MYSQL_COMPATIBLE) \
@ -2363,7 +2461,7 @@ WOLFSSL_LOCAL char* wolfSSL_get_ocsp_url(WOLFSSL* ssl);
/* Not an OpenSSL API. */
WOLFSSL_API int wolfSSL_set_ocsp_url(WOLFSSL* ssl, char* url);
WOLFSSL_API STACK_OF(WOLFSSL_CIPHER) *wolfSSL_get_ciphers_compat(const WOLFSSL *ssl);
WOLFSSL_API WOLF_STACK_OF(WOLFSSL_CIPHER) *wolfSSL_get_ciphers_compat(const WOLFSSL *ssl);
WOLFSSL_API void wolfSSL_OPENSSL_config(char *config_name);
WOLFSSL_API int wolfSSL_X509_get_ex_new_index(int idx, void *arg, void *a,
void *b, void *c);
@ -2401,15 +2499,15 @@ WOLFSSL_API int wolfSSL_CTX_set_tlsext_ticket_key_cb(WOLFSSL_CTX *, int (*)(
#ifdef HAVE_OCSP
WOLFSSL_API int wolfSSL_CTX_get_extra_chain_certs(WOLFSSL_CTX* ctx,
STACK_OF(X509)** chain);
WOLF_STACK_OF(X509)** chain);
WOLFSSL_API int wolfSSL_CTX_set_tlsext_status_cb(WOLFSSL_CTX* ctx,
int(*)(WOLFSSL*, void*));
WOLFSSL_API int wolfSSL_X509_STORE_CTX_get1_issuer(WOLFSSL_X509 **issuer,
WOLFSSL_X509_STORE_CTX *ctx, WOLFSSL_X509 *x);
WOLFSSL_API void wolfSSL_X509_email_free(STACK_OF(WOLFSSL_STRING) *sk);
WOLFSSL_API STACK_OF(WOLFSSL_STRING) *wolfSSL_X509_get1_ocsp(WOLFSSL_X509 *x);
WOLFSSL_API void wolfSSL_X509_email_free(WOLF_STACK_OF(WOLFSSL_STRING) *sk);
WOLFSSL_API WOLF_STACK_OF(WOLFSSL_STRING) *wolfSSL_X509_get1_ocsp(WOLFSSL_X509 *x);
WOLFSSL_API int wolfSSL_X509_check_issued(WOLFSSL_X509 *issuer,
WOLFSSL_X509 *subject);
@ -2417,7 +2515,7 @@ WOLFSSL_API int wolfSSL_X509_check_issued(WOLFSSL_X509 *issuer,
WOLFSSL_API WOLFSSL_X509* wolfSSL_X509_dup(WOLFSSL_X509 *x);
WOLFSSL_API char* wolfSSL_sk_WOLFSSL_STRING_value(
STACK_OF(WOLFSSL_STRING)* strings, int idx);
WOLF_STACK_OF(WOLFSSL_STRING)* strings, int idx);
#endif /* HAVE_OCSP */
WOLFSSL_API int PEM_write_bio_WOLFSSL_X509(WOLFSSL_BIO *bio,
@ -2455,6 +2553,7 @@ WOLFSSL_API void wolfSSL_get0_next_proto_negotiated(const WOLFSSL *s, const unsi
unsigned *len);
#ifdef OPENSSL_EXTRA
#if defined(WOLFSSL_NGINX) || defined(WOLFSSL_HAPROXY)
WOLFSSL_API const unsigned char *SSL_SESSION_get0_id_context(
const WOLFSSL_SESSION *sess, unsigned int *sid_ctx_length);
@ -2472,12 +2571,13 @@ WOLFSSL_API int EVP_PKEY_bits(WOLFSSL_EVP_PKEY *pkey);
WOLFSSL_API int i2d_X509(WOLFSSL_X509 *x, unsigned char **out);
WOLFSSL_API int i2t_ASN1_OBJECT(char *buf, int buf_len, WOLFSSL_ASN1_OBJECT *a);
WOLFSSL_API void SSL_CTX_set_tmp_dh_callback(WOLFSSL_CTX *ctx, WOLFSSL_DH *(*dh) (WOLFSSL *ssl, int is_export, int keylength));
WOLFSSL_API STACK_OF(SSL_COMP) *SSL_COMP_get_compression_methods(void);
WOLFSSL_API WOLF_STACK_OF(SSL_COMP) *SSL_COMP_get_compression_methods(void);
WOLFSSL_API int X509_STORE_load_locations(WOLFSSL_X509_STORE *ctx, const char *file, const char *dir);
WOLFSSL_API int wolfSSL_sk_SSL_CIPHER_num(const void * p);
WOLFSSL_API int wolfSSL_sk_SSL_COMP_zero(WOLFSSL_STACK* st);
WOLFSSL_API WOLFSSL_CIPHER* wolfSSL_sk_SSL_CIPHER_value(void *ciphers, int idx);
WOLFSSL_API void ERR_load_SSL_strings(void);
#endif /* OPENSSL_EXTRA */
#ifdef __cplusplus
} /* extern "C" */

14
wolfssl/test.h
View File

@ -498,7 +498,7 @@ static INLINE void ShowX509(WOLFSSL_X509* x509, const char* hdr)
printf(" altname = %s\n", altName);
ret = wolfSSL_X509_get_serial_number(x509, serial, &sz);
if (ret == SSL_SUCCESS) {
if (ret == WOLF_SSL_SUCCESS) {
int i;
int strLen;
char serialMsg[80];
@ -1168,7 +1168,7 @@ static INLINE unsigned int my_psk_server_cb(WOLFSSL* ssl, const char* identity,
static INLINE void load_buffer(WOLFSSL_CTX* ctx, const char* fname, int type)
{
int format = SSL_FILETYPE_PEM;
int format = WOLF_SSL_FILETYPE_PEM;
byte* buff = NULL;
size_t sz = 0;
@ -1179,26 +1179,26 @@ static INLINE unsigned int my_psk_server_cb(WOLFSSL* ssl, const char* identity,
/* determine format */
if (strstr(fname, ".der"))
format = SSL_FILETYPE_ASN1;
format = WOLF_SSL_FILETYPE_ASN1;
if (type == WOLFSSL_CA) {
if (wolfSSL_CTX_load_verify_buffer(ctx, buff, (long)sz, format)
!= SSL_SUCCESS)
!= WOLF_SSL_SUCCESS)
err_sys("can't load buffer ca file");
}
else if (type == WOLFSSL_CERT) {
if (wolfSSL_CTX_use_certificate_buffer(ctx, buff, (long)sz,
format) != SSL_SUCCESS)
format) != WOLF_SSL_SUCCESS)
err_sys("can't load buffer cert file");
}
else if (type == WOLFSSL_KEY) {
if (wolfSSL_CTX_use_PrivateKey_buffer(ctx, buff, (long)sz,
format) != SSL_SUCCESS)
format) != WOLF_SSL_SUCCESS)
err_sys("can't load buffer key file");
}
else if (type == WOLFSSL_CERT_CHAIN) {
if (wolfSSL_CTX_use_certificate_chain_buffer_format(ctx, buff,
(long)sz, format) != SSL_SUCCESS)
(long)sz, format) != WOLF_SSL_SUCCESS)
err_sys("can't load cert chain buffer");
}

8
wolfssl/wolfcrypt/asn.h
View File

@ -136,9 +136,9 @@ enum Misc_ASN {
ASN_ECC_HEADER_SZ = 2, /* String type + 1 byte len */
ASN_ECC_CONTEXT_SZ = 2, /* Content specific type + 1 byte len */
#ifdef NO_SHA
KEYID_SIZE = SHA256_DIGEST_SIZE,
KEYID_SIZE = WC_SHA256_DIGEST_SIZE,
#else
KEYID_SIZE = SHA_DIGEST_SIZE,
KEYID_SIZE = WC_SHA_DIGEST_SIZE,
#endif
RSA_INTS = 8, /* RSA ints in private key */
DSA_INTS = 5, /* DSA ints in private key */
@ -674,9 +674,9 @@ extern const char* BEGIN_EDDSA_PRIV;
extern const char* END_EDDSA_PRIV;
#ifdef NO_SHA
#define SIGNER_DIGEST_SIZE SHA256_DIGEST_SIZE
#define SIGNER_DIGEST_SIZE WC_SHA256_DIGEST_SIZE
#else
#define SIGNER_DIGEST_SIZE SHA_DIGEST_SIZE
#define SIGNER_DIGEST_SIZE WC_SHA_DIGEST_SIZE
#endif
/* CA Signers */

24
wolfssl/wolfcrypt/hash.h
View File

@ -58,39 +58,39 @@ enum wc_HashType {
typedef union {
#ifndef NO_MD5
Md5 md5;
wc_Md5 md5;
#endif
#ifndef NO_SHA
Sha sha;
wc_Sha sha;
#endif
#ifdef WOLFSSL_SHA224
Sha224 sha224;
wc_Sha224 sha224;
#endif
#ifndef NO_SHA256
Sha256 sha256;
wc_Sha256 sha256;
#endif
#ifdef WOLFSSL_SHA384
Sha384 sha384;
wc_Sha384 sha384;
#endif
#ifdef WOLFSSL_SHA512
Sha512 sha512;
wc_Sha512 sha512;
#endif
} wc_HashAlg;
/* Find largest possible digest size
Note if this gets up to the size of 80 or over check smallstack build */
#if defined(WOLFSSL_SHA512)
#define WC_MAX_DIGEST_SIZE SHA512_DIGEST_SIZE
#define WC_MAX_DIGEST_SIZE WC_SHA512_DIGEST_SIZE
#elif defined(WOLFSSL_SHA384)
#define WC_MAX_DIGEST_SIZE SHA384_DIGEST_SIZE
#define WC_MAX_DIGEST_SIZE WC_SHA384_DIGEST_SIZE
#elif !defined(NO_SHA256)
#define WC_MAX_DIGEST_SIZE SHA256_DIGEST_SIZE
#define WC_MAX_DIGEST_SIZE WC_SHA256_DIGEST_SIZE
#elif defined(WOLFSSL_SHA224)
#define WC_MAX_DIGEST_SIZE SHA224_DIGEST_SIZE
#define WC_MAX_DIGEST_SIZE WC_SHA224_DIGEST_SIZE
#elif !defined(NO_SHA)
#define WC_MAX_DIGEST_SIZE SHA_DIGEST_SIZE
#define WC_MAX_DIGEST_SIZE WC_SHA_DIGEST_SIZE
#elif !defined(NO_MD5)
#define WC_MAX_DIGEST_SIZE MD5_DIGEST_SIZE
#define WC_MAX_DIGEST_SIZE WC_MD5_DIGEST_SIZE
#else
#define WC_MAX_DIGEST_SIZE 64 /* default to max size of 64 */
#endif

49
wolfssl/wolfcrypt/hmac.h
View File

@ -71,49 +71,50 @@ enum {
/* If any hash is not enabled, add the ID here. */
#ifdef NO_MD5
MD5 = 0,
WC_MD5 = 0,
#endif
#ifdef NO_SHA
SHA = 1,
WC_SHA = 1,
#endif
#ifdef NO_SHA256
SHA256 = 2,
WC_SHA256 = 2,
#endif
#ifndef WOLFSSL_SHA512
SHA512 = 4,
WC_SHA512 = 4,
#endif
#ifndef WOLFSSL_SHA384
SHA384 = 5,
WC_SHA384 = 5,
#endif
#ifndef HAVE_BLAKE2
BLAKE2B_ID = 7,
#endif
#ifndef WOLFSSL_SHA224
SHA224 = 8,
WC_SHA224 = 8,
#endif
/* Select the largest available hash for the buffer size. */
#if defined(WOLFSSL_SHA512)
MAX_DIGEST_SIZE = SHA512_DIGEST_SIZE,
HMAC_BLOCK_SIZE = SHA512_BLOCK_SIZE,
MAX_DIGEST_SIZE = WC_SHA512_DIGEST_SIZE,
HMAC_BLOCK_SIZE = WC_SHA512_BLOCK_SIZE,
#elif defined(HAVE_BLAKE2)
MAX_DIGEST_SIZE = BLAKE2B_OUTBYTES,
HMAC_BLOCK_SIZE = BLAKE2B_BLOCKBYTES,
#elif defined(WOLFSSL_SHA384)
MAX_DIGEST_SIZE = SHA384_DIGEST_SIZE,
HMAC_BLOCK_SIZE = SHA384_BLOCK_SIZE
MAX_DIGEST_SIZE = WC_SHA384_DIGEST_SIZE,
HMAC_BLOCK_SIZE = WC_SHA384_BLOCK_SIZE
#elif !defined(NO_SHA256)
MAX_DIGEST_SIZE = SHA256_DIGEST_SIZE,
HMAC_BLOCK_SIZE = SHA256_BLOCK_SIZE
MAX_DIGEST_SIZE = WC_SHA256_DIGEST_SIZE,
HMAC_BLOCK_SIZE = WC_SHA256_BLOCK_SIZE
#elif defined(WOLFSSL_SHA224)
MAX_DIGEST_SIZE = SHA224_DIGEST_SIZE,
HMAC_BLOCK_SIZE = SHA224_BLOCK_SIZE
MAX_DIGEST_SIZE = WC_SHA224_DIGEST_SIZE,
HMAC_BLOCK_SIZE = WC_SHA224_BLOCK_SIZE
#elif !defined(NO_SHA)
MAX_DIGEST_SIZE = SHA_DIGEST_SIZE,
HMAC_BLOCK_SIZE = SHA_BLOCK_SIZE,
MAX_DIGEST_SIZE = WC_SHA_DIGEST_SIZE,
HMAC_BLOCK_SIZE = WC_SHA_BLOCK_SIZE,
#elif !defined(NO_MD5)
MAX_DIGEST_SIZE = MD5_DIGEST_SIZE,
HMAC_BLOCK_SIZE = MD5_BLOCK_SIZE,
MAX_DIGEST_SIZE = WC_MD5_DIGEST_SIZE,
HMAC_BLOCK_SIZE = WC_MD5_BLOCK_SIZE,
#else
#error "You have to have some kind of hash if you want to use HMAC."
#endif
@ -123,22 +124,22 @@ enum {
/* hash union */
typedef union {
#ifndef NO_MD5
Md5 md5;
wc_Md5 md5;
#endif
#ifndef NO_SHA
Sha sha;
wc_Sha sha;
#endif
#ifdef WOLFSSL_SHA224
Sha224 sha224;
wc_Sha224 sha224;
#endif
#ifndef NO_SHA256
Sha256 sha256;
wc_Sha256 sha256;
#endif
#ifdef WOLFSSL_SHA512
#ifdef WOLFSSL_SHA384
Sha384 sha384;
wc_Sha384 sha384;
#endif
Sha512 sha512;
wc_Sha512 sha512;
#endif
#ifdef HAVE_BLAKE2
Blake2b blake2b;

40
wolfssl/wolfcrypt/md5.h
View File

@ -38,12 +38,20 @@
extern "C" {
#endif
#ifndef NO_OLD_WC_NAMES
#define Md5 wc_Md5
#define MD5 WC_MD5
#define MD5_BLOCK_SIZE WC_MD5_BLOCK_SIZE
#define MD5_DIGEST_SIZE WC_MD5_DIGEST_SIZE
#define WC_MD5_PAD_SIZE WC_MD5_PAD_SIZE
#endif
/* in bytes */
enum {
MD5 = 0, /* hash type unique */
MD5_BLOCK_SIZE = 64,
MD5_DIGEST_SIZE = 16,
MD5_PAD_SIZE = 56
WC_MD5 = 0, /* hash type unique */
WC_MD5_BLOCK_SIZE = 64,
WC_MD5_DIGEST_SIZE = 16,
WC_MD5_PAD_SIZE = 56
};
#ifdef WOLFSSL_MICROCHIP_PIC32MZ
@ -58,15 +66,15 @@ enum {
#else
/* MD5 digest */
typedef struct Md5 {
typedef struct wc_Md5 {
word32 buffLen; /* in bytes */
word32 loLen; /* length in bytes */
word32 hiLen; /* length in bytes */
word32 buffer[MD5_BLOCK_SIZE / sizeof(word32)];
word32 buffer[WC_MD5_BLOCK_SIZE / sizeof(word32)];
#ifdef WOLFSSL_PIC32MZ_HASH
word32 digest[PIC32_DIGEST_SIZE / sizeof(word32)];
#else
word32 digest[MD5_DIGEST_SIZE / sizeof(word32)];
word32 digest[WC_MD5_DIGEST_SIZE / sizeof(word32)];
#endif
void* heap;
#ifdef WOLFSSL_PIC32MZ_HASH
@ -78,21 +86,21 @@ typedef struct Md5 {
#ifdef WOLFSSL_ASYNC_CRYPT
WC_ASYNC_DEV asyncDev;
#endif /* WOLFSSL_ASYNC_CRYPT */
} Md5;
} wc_Md5;
#endif /* WOLFSSL_TI_HASH */
WOLFSSL_API int wc_InitMd5(Md5*);
WOLFSSL_API int wc_InitMd5_ex(Md5*, void*, int);
WOLFSSL_API int wc_Md5Update(Md5*, const byte*, word32);
WOLFSSL_API int wc_Md5Final(Md5*, byte*);
WOLFSSL_API void wc_Md5Free(Md5*);
WOLFSSL_API int wc_InitMd5(wc_Md5*);
WOLFSSL_API int wc_InitMd5_ex(wc_Md5*, void*, int);
WOLFSSL_API int wc_Md5Update(wc_Md5*, const byte*, word32);
WOLFSSL_API int wc_Md5Final(wc_Md5*, byte*);
WOLFSSL_API void wc_Md5Free(wc_Md5*);
WOLFSSL_API int wc_Md5GetHash(Md5*, byte*);
WOLFSSL_API int wc_Md5Copy(Md5*, Md5*);
WOLFSSL_API int wc_Md5GetHash(wc_Md5*, byte*);
WOLFSSL_API int wc_Md5Copy(wc_Md5*, wc_Md5*);
#ifdef WOLFSSL_PIC32MZ_HASH
WOLFSSL_API void wc_Md5SizeSet(Md5* md5, word32 len);
WOLFSSL_API void wc_Md5SizeSet(wc_Md5* md5, word32 len);
#endif
#ifdef __cplusplus

2
wolfssl/wolfcrypt/rsa.h
View File

@ -84,8 +84,10 @@ enum {
RSA_PSS_PAD_SZ = 8,
#ifdef OPENSSL_EXTRA
RSA_PKCS1_PADDING_SIZE = 11,
RSA_PKCS1_OAEP_PADDING_SIZE = 42 /* (2 * hashlen(SHA-1)) + 2 */
#endif
};

77
wolfssl/wolfcrypt/sha.h
View File

@ -49,42 +49,47 @@
#include <wolfssl/wolfcrypt/async.h>
#endif
#ifndef NO_OLD_WC_NAMES
#define Sha wc_Sha
#define SHA WC_SHA
#define SHA_BLOCK_SIZE WC_SHA_BLOCK_SIZE
#define SHA_DIGEST_SIZE WC_SHA_DIGEST_SIZE
#define SHA_PAD_SIZE WC_SHA_PAD_SIZE
#endif
/* in bytes */
enum {
SHA = 1, /* hash type unique */
SHA_BLOCK_SIZE = 64,
SHA_DIGEST_SIZE = 20,
SHA_PAD_SIZE = 56
WC_SHA = 1, /* hash type unique */
WC_SHA_BLOCK_SIZE = 64,
WC_SHA_DIGEST_SIZE = 20,
WC_SHA_PAD_SIZE = 56
};
#ifndef WOLFSSL_TI_HASH
/* Sha digest */
typedef struct Sha {
#ifdef FREESCALE_LTC_SHA
ltc_hash_ctx_t ctx;
#else
word32 buffLen; /* in bytes */
word32 loLen; /* length in bytes */
word32 hiLen; /* length in bytes */
word32 buffer[SHA_BLOCK_SIZE / sizeof(word32)];
#ifdef WOLFSSL_PIC32MZ_HASH
word32 digest[PIC32_DIGEST_SIZE / sizeof(word32)];
#else
word32 digest[SHA_DIGEST_SIZE / sizeof(word32)];
#endif
void* heap;
#ifdef WOLFSSL_PIC32MZ_HASH
hashUpdCache cache; /* cache for updates */
#endif
#if defined(STM32_HASH) && defined(WOLFSSL_STM32_CUBEMX)
HASH_HandleTypeDef hashHandle;
#endif
#ifdef WOLFSSL_ASYNC_CRYPT
WC_ASYNC_DEV asyncDev;
#endif /* WOLFSSL_ASYNC_CRYPT */
typedef struct wc_Sha {
#ifdef FREESCALE_LTC_SHA
ltc_hash_ctx_t ctx;
#else
word32 buffLen; /* in bytes */
word32 loLen; /* length in bytes */
word32 hiLen; /* length in bytes */
word32 buffer[WC_SHA_BLOCK_SIZE / sizeof(word32)];
#ifdef WOLFSSL_PIC32MZ_HASH
word32 digest[PIC32_DIGEST_SIZE / sizeof(word32)];
#else
word32 digest[WC_SHA_DIGEST_SIZE / sizeof(word32)];
#endif
void* heap;
#ifdef WOLFSSL_PIC32MZ_HASH
hashUpdCache cache; /* cache for updates */
#endif
#ifdef WOLFSSL_ASYNC_CRYPT
WC_ASYNC_DEV asyncDev;
#endif /* WOLFSSL_ASYNC_CRYPT */
#endif /* FREESCALE_LTC_SHA */
} Sha;
} wc_Sha;
#else
#include "wolfssl/wolfcrypt/port/ti/ti-hash.h"
@ -93,17 +98,17 @@ typedef struct Sha {
#endif /* HAVE_FIPS */
WOLFSSL_API int wc_InitSha(Sha*);
WOLFSSL_API int wc_InitSha_ex(Sha* sha, void* heap, int devId);
WOLFSSL_API int wc_ShaUpdate(Sha*, const byte*, word32);
WOLFSSL_API int wc_ShaFinal(Sha*, byte*);
WOLFSSL_API void wc_ShaFree(Sha*);
WOLFSSL_API int wc_InitSha(wc_Sha*);
WOLFSSL_API int wc_InitSha_ex(wc_Sha* sha, void* heap, int devId);
WOLFSSL_API int wc_ShaUpdate(wc_Sha*, const byte*, word32);
WOLFSSL_API int wc_ShaFinal(wc_Sha*, byte*);
WOLFSSL_API void wc_ShaFree(wc_Sha*);
WOLFSSL_API int wc_ShaGetHash(Sha*, byte*);
WOLFSSL_API int wc_ShaCopy(Sha*, Sha*);
WOLFSSL_API int wc_ShaGetHash(wc_Sha*, byte*);
WOLFSSL_API int wc_ShaCopy(wc_Sha*, wc_Sha*);
#ifdef WOLFSSL_PIC32MZ_HASH
WOLFSSL_API void wc_ShaSizeSet(Sha* sha, word32 len);
WOLFSSL_API void wc_ShaSizeSet(wc_Sha* sha, word32 len);
#endif
#ifdef __cplusplus

74
wolfssl/wolfcrypt/sha256.h
View File

@ -52,24 +52,32 @@
#include <wolfssl/wolfcrypt/async.h>
#endif
#ifndef NO_OLD_WC_NAMES
#define Sha256 wc_Sha256
#define SHA256 WC_SHA256
#define SHA256_BLOCK_SIZE WC_SHA256_BLOCK_SIZE
#define SHA256_DIGEST_SIZE WC_SHA256_DIGEST_SIZE
#define SHA256_PAD_SIZE WC_SHA256_PAD_SIZE
#endif
/* in bytes */
enum {
SHA256 = 2, /* hash type unique */
SHA256_BLOCK_SIZE = 64,
SHA256_DIGEST_SIZE = 32,
SHA256_PAD_SIZE = 56
WC_SHA256 = 2, /* hash type unique */
WC_SHA256_BLOCK_SIZE = 64,
WC_SHA256_DIGEST_SIZE = 32,
WC_SHA256_PAD_SIZE = 56
};
#ifndef WOLFSSL_TI_HASH
/* Sha256 digest */
typedef struct Sha256 {
/* wc_Sha256 digest */
typedef struct wc_Sha256 {
#ifdef FREESCALE_LTC_SHA
ltc_hash_ctx_t ctx;
#else
/* alignment on digest and buffer speeds up ARMv8 crypto operations */
ALIGN16 word32 digest[SHA256_DIGEST_SIZE / sizeof(word32)];
ALIGN16 word32 buffer[SHA256_BLOCK_SIZE / sizeof(word32)];
ALIGN16 word32 digest[WC_SHA256_DIGEST_SIZE / sizeof(word32)];
ALIGN16 word32 buffer[WC_SHA256_BLOCK_SIZE / sizeof(word32)];
word32 buffLen; /* in bytes */
word32 loLen; /* length in bytes */
word32 hiLen; /* length in bytes */
@ -84,7 +92,7 @@ typedef struct Sha256 {
WC_ASYNC_DEV asyncDev;
#endif /* WOLFSSL_ASYNC_CRYPT */
#endif /* FREESCALE_LTC_SHA */
} Sha256;
} wc_Sha256;
#else
#include "wolfssl/wolfcrypt/port/ti/ti-hash.h"
@ -92,41 +100,49 @@ typedef struct Sha256 {
#endif /* HAVE_FIPS */
WOLFSSL_API int wc_InitSha256(Sha256*);
WOLFSSL_API int wc_InitSha256_ex(Sha256*, void*, int);
WOLFSSL_API int wc_Sha256Update(Sha256*, const byte*, word32);
WOLFSSL_API int wc_Sha256Final(Sha256*, byte*);
WOLFSSL_API void wc_Sha256Free(Sha256*);
WOLFSSL_API int wc_InitSha256(wc_Sha256*);
WOLFSSL_API int wc_InitSha256_ex(wc_Sha256*, void*, int);
WOLFSSL_API int wc_Sha256Update(wc_Sha256*, const byte*, word32);
WOLFSSL_API int wc_Sha256Final(wc_Sha256*, byte*);
WOLFSSL_API void wc_Sha256Free(wc_Sha256*);
WOLFSSL_API int wc_Sha256GetHash(Sha256*, byte*);
WOLFSSL_API int wc_Sha256Copy(Sha256* src, Sha256* dst);
WOLFSSL_API int wc_Sha256GetHash(wc_Sha256*, byte*);
WOLFSSL_API int wc_Sha256Copy(wc_Sha256* src, wc_Sha256* dst);
#ifdef WOLFSSL_PIC32MZ_HASH
WOLFSSL_API void wc_Sha256SizeSet(Sha256*, word32);
WOLFSSL_API void wc_Sha256SizeSet(wc_Sha256*, word32);
#endif
#ifdef WOLFSSL_SHA224
#ifndef NO_OLD_WC_NAMES
#define Sha224 wc_Sha224
#define SHA224 WC_SHA224
#define SHA224_BLOCK_SIZE WC_SHA224_BLOCK_SIZE
#define SHA224_DIGEST_SIZE WC_SHA224_DIGEST_SIZE
#define SHA224_PAD_SIZE WC_SHA224_PAD_SIZE
#endif
#ifndef HAVE_FIPS /* avoid redefinition of structs */
/* in bytes */
enum {
SHA224 = 8, /* hash type unique */
SHA224_BLOCK_SIZE = SHA256_BLOCK_SIZE,
SHA224_DIGEST_SIZE = 28,
SHA224_PAD_SIZE = SHA256_PAD_SIZE
WC_SHA224 = 8, /* hash type unique */
WC_SHA224_BLOCK_SIZE = WC_SHA256_BLOCK_SIZE,
WC_SHA224_DIGEST_SIZE = 28,
WC_SHA224_PAD_SIZE = WC_SHA256_PAD_SIZE
};
typedef Sha256 Sha224;
typedef wc_Sha256 wc_Sha224;
#endif /* HAVE_FIPS */
WOLFSSL_API int wc_InitSha224(Sha224*);
WOLFSSL_API int wc_InitSha224_ex(Sha224*, void*, int);
WOLFSSL_API int wc_Sha224Update(Sha224*, const byte*, word32);
WOLFSSL_API int wc_Sha224Final(Sha224*, byte*);
WOLFSSL_API void wc_Sha224Free(Sha224*);
WOLFSSL_API int wc_InitSha224(wc_Sha224*);
WOLFSSL_API int wc_InitSha224_ex(wc_Sha224*, void*, int);
WOLFSSL_API int wc_Sha224Update(wc_Sha224*, const byte*, word32);
WOLFSSL_API int wc_Sha224Final(wc_Sha224*, byte*);
WOLFSSL_API void wc_Sha224Free(wc_Sha224*);
WOLFSSL_API int wc_Sha224GetHash(Sha224*, byte*);
WOLFSSL_API int wc_Sha224Copy(Sha224* src, Sha224* dst);
WOLFSSL_API int wc_Sha224GetHash(wc_Sha224*, byte*);
WOLFSSL_API int wc_Sha224Copy(wc_Sha224* src, wc_Sha224* dst);
#endif /* WOLFSSL_SHA224 */

73
wolfssl/wolfcrypt/sha512.h
View File

@ -46,61 +46,78 @@
#include <wolfssl/wolfcrypt/async.h>
#endif
#ifndef NO_OLD_WC_NAMES
#define Sha512 wc_Sha512
#define SHA512 WC_SHA512
#define SHA512_BLOCK_SIZE WC_SHA512_BLOCK_SIZE
#define SHA512_DIGEST_SIZE WC_SHA512_DIGEST_SIZE
#define SHA512_PAD_SIZE WC_SHA512_PAD_SIZE
#endif
/* in bytes */
enum {
SHA512 = 4, /* hash type unique */
SHA512_BLOCK_SIZE = 128,
SHA512_DIGEST_SIZE = 64,
SHA512_PAD_SIZE = 112
WC_SHA512 = 4, /* hash type unique */
WC_SHA512_BLOCK_SIZE = 128,
WC_SHA512_DIGEST_SIZE = 64,
WC_SHA512_PAD_SIZE = 112
};
/* Sha512 digest */
typedef struct Sha512 {
/* wc_Sha512 digest */
typedef struct wc_Sha512 {
word32 buffLen; /* in bytes */
word64 loLen; /* length in bytes */
word64 hiLen; /* length in bytes */
word64 digest[SHA512_DIGEST_SIZE / sizeof(word64)];
word64 buffer[SHA512_BLOCK_SIZE / sizeof(word64)];
word64 digest[WC_SHA512_DIGEST_SIZE / sizeof(word64)];
word64 buffer[WC_SHA512_BLOCK_SIZE / sizeof(word64)];
void* heap;
#ifdef WOLFSSL_ASYNC_CRYPT
WC_ASYNC_DEV asyncDev;
#endif /* WOLFSSL_ASYNC_CRYPT */
} Sha512;
} wc_Sha512;
#endif /* HAVE_FIPS */
WOLFSSL_API int wc_InitSha512(Sha512*);
WOLFSSL_API int wc_InitSha512_ex(Sha512*, void*, int);
WOLFSSL_API int wc_Sha512Update(Sha512*, const byte*, word32);
WOLFSSL_API int wc_Sha512Final(Sha512*, byte*);
WOLFSSL_API void wc_Sha512Free(Sha512*);
WOLFSSL_API int wc_InitSha512(wc_Sha512*);
WOLFSSL_API int wc_InitSha512_ex(wc_Sha512*, void*, int);
WOLFSSL_API int wc_Sha512Update(wc_Sha512*, const byte*, word32);
WOLFSSL_API int wc_Sha512Final(wc_Sha512*, byte*);
WOLFSSL_API void wc_Sha512Free(wc_Sha512*);
WOLFSSL_API int wc_Sha512GetHash(Sha512*, byte*);
WOLFSSL_API int wc_Sha512Copy(Sha512* src, Sha512* dst);
WOLFSSL_API int wc_Sha512GetHash(wc_Sha512*, byte*);
WOLFSSL_API int wc_Sha512Copy(wc_Sha512* src, wc_Sha512* dst);
#if defined(WOLFSSL_SHA384)
#ifndef HAVE_FIPS /* avoid redefinition of structs */
#ifndef NO_OLD_WC_NAMES
#define Sha384 wc_Sha384
#define SHA384 WC_SHA384
#define SHA384_BLOCK_SIZE WC_SHA384_BLOCK_SIZE
#define SHA384_DIGEST_SIZE WC_SHA384_DIGEST_SIZE
#define SHA384_PAD_SIZE WC_SHA384_PAD_SIZE
#endif
/* in bytes */
enum {
SHA384 = 5, /* hash type unique */
SHA384_BLOCK_SIZE = SHA512_BLOCK_SIZE,
SHA384_DIGEST_SIZE = 48,
SHA384_PAD_SIZE = SHA512_PAD_SIZE
WC_SHA384 = 5, /* hash type unique */
WC_SHA384_BLOCK_SIZE = WC_SHA512_BLOCK_SIZE,
WC_SHA384_DIGEST_SIZE = 48,
WC_SHA384_PAD_SIZE = WC_SHA512_PAD_SIZE
};
typedef Sha512 Sha384;
typedef wc_Sha512 wc_Sha384;
#endif /* HAVE_FIPS */
WOLFSSL_API int wc_InitSha384(Sha384*);
WOLFSSL_API int wc_InitSha384_ex(Sha384*, void*, int);
WOLFSSL_API int wc_Sha384Update(Sha384*, const byte*, word32);
WOLFSSL_API int wc_Sha384Final(Sha384*, byte*);
WOLFSSL_API void wc_Sha384Free(Sha384*);
WOLFSSL_API int wc_InitSha384(wc_Sha384*);
WOLFSSL_API int wc_InitSha384_ex(wc_Sha384*, void*, int);
WOLFSSL_API int wc_Sha384Update(wc_Sha384*, const byte*, word32);
WOLFSSL_API int wc_Sha384Final(wc_Sha384*, byte*);
WOLFSSL_API void wc_Sha384Free(wc_Sha384*);
WOLFSSL_API int wc_Sha384GetHash(Sha384*, byte*);
WOLFSSL_API int wc_Sha384Copy(Sha384* src, Sha384* dst);
WOLFSSL_API int wc_Sha384GetHash(wc_Sha384*, byte*);
WOLFSSL_API int wc_Sha384Copy(wc_Sha384* src, wc_Sha384* dst);
#endif /* WOLFSSL_SHA384 */

16
wolfssl/wolfcrypt/srp.h
View File

@ -37,13 +37,13 @@
/* Select the largest available hash for the buffer size. */
#if defined(WOLFSSL_SHA512)
#define SRP_MAX_DIGEST_SIZE SHA512_DIGEST_SIZE
#define SRP_MAX_DIGEST_SIZE WC_SHA512_DIGEST_SIZE
#elif defined(WOLFSSL_SHA384)
#define SRP_MAX_DIGEST_SIZE SHA384_DIGEST_SIZE
#define SRP_MAX_DIGEST_SIZE WC_SHA384_DIGEST_SIZE
#elif !defined(NO_SHA256)
#define SRP_MAX_DIGEST_SIZE SHA256_DIGEST_SIZE
#define SRP_MAX_DIGEST_SIZE WC_SHA256_DIGEST_SIZE
#elif !defined(NO_SHA)
#define SRP_MAX_DIGEST_SIZE SHA_DIGEST_SIZE
#define SRP_MAX_DIGEST_SIZE WC_SHA_DIGEST_SIZE
#else
#error "You have to have some kind of SHA hash if you want to use SRP."
#endif
@ -79,16 +79,16 @@ typedef struct {
byte type;
union {
#ifndef NO_SHA
Sha sha;
wc_Sha sha;
#endif
#ifndef NO_SHA256
Sha256 sha256;
wc_Sha256 sha256;
#endif
#ifdef WOLFSSL_SHA384
Sha384 sha384;
wc_Sha384 sha384;
#endif
#ifdef WOLFSSL_SHA512
Sha512 sha512;
wc_Sha512 sha512;
#endif
} data;
} SrpHash;