wolfSSL/wolfssl
1
0
Fork 1
mirror of https://github.com/wolfSSL/wolfssl.git synced 2025-07-31 19:24:42 +02:00
Code Issues Packages Projects Releases Wiki Activity

static method func / ocsp callbacks / heap test / alpn free func / remove timing resistant constraint

Browse Source
This commit is contained in:
Jacob Barthelmeh
2016-06-09 11:36:31 -06:00
parent 664d2190ba
commit 8be5409bc5
13 changed files with 237 additions and 262 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
configure.ac
View File

@@ -2554,7 +2554,11 @@ AC_ARG_ENABLE([staticmemory],
if test "x$ENABLED_STATICMEMORY" = "xyes"
then
AM_CFLAGS="$AM_CFLAGS -DWOLFSSL_STATIC_MEMORY -DTFM_TIMING_RESISTANT"
AM_CFLAGS="$AM_CFLAGS -DWOLFSSL_STATIC_MEMORY"
if test "x$ENABLED_FASTMATH" = "xno"
then
AC_MSG_ERROR([please use --enable-fastmath if enabling staticmemory.])
fi
fi

44
examples/server/server.c
View File

@@ -252,11 +252,7 @@ THREAD_RETURN CYASSL_THREAD server_test(void* args)
SOCKET_T sockfd = WOLFSSL_SOCKET_INVALID;
SOCKET_T clientfd = WOLFSSL_SOCKET_INVALID;
#ifdef WOLFSSL_STATIC_MEMORY
wolfSSLStaticMethod method = NULL;
#else
SSL_METHOD* method = 0;
#endif
wolfSSL_method_func method = NULL;
SSL_CTX* ctx = 0;
SSL* ssl = 0;
@@ -589,30 +585,18 @@ THREAD_RETURN CYASSL_THREAD server_test(void* args)
#ifndef NO_OLD_TLS
#ifdef WOLFSSL_ALLOW_SSLV3
case 0:
#ifdef WOLFSSL_STATIC_MEMORY
method = wolfSSLv3_server_static;
#else
method = SSLv3_server_method();
#endif
method = SSLv3_server_method;
break;
#endif
#ifndef NO_TLS
case 1:
#ifdef WOLFSSL_STATIC_MEMORY
method = wolfTLSv1_server_static;
#else
method = TLSv1_server_method();
#endif
method = TLSv1_server_method;
break;
case 2:
#ifdef WOLFSSL_STATIC_MEMORY
method = wolfTLSv1_1_server_static;
#else
method = TLSv1_1_server_method();
#endif
method = TLSv1_1_server_method;
break;
#endif
@@ -620,31 +604,19 @@ THREAD_RETURN CYASSL_THREAD server_test(void* args)
#ifndef NO_TLS
case 3:
#ifdef WOLFSSL_STATIC_MEMORY
method = wolfTLSv1_2_server_static;
#else
method = TLSv1_2_server_method();
#endif
method = TLSv1_2_server_method;
break;
#endif
#ifdef CYASSL_DTLS
#ifndef NO_OLD_TLS
case -1:
#ifdef WOLFSSL_STATIC_MEMORY
method = wolfDTLSv1_server_static;
#else
method = DTLSv1_server_method();
#endif
method = DTLSv1_server_method;
break;
#endif
case -2:
#ifdef WOLFSSL_STATIC_MEMORY
method = wolfDTLSv1_2_server_static;
#else
method = DTLSv1_2_server_method();
#endif
method = DTLSv1_2_server_method;
break;
#endif
@@ -666,7 +638,7 @@ THREAD_RETURN CYASSL_THREAD server_test(void* args)
!= SSL_SUCCESS)
err_sys("unable to load static memory and create ctx");
#else
ctx = SSL_CTX_new(method);
ctx = SSL_CTX_new(method());
#endif
if (ctx == NULL)
err_sys("unable to get ctx");

5
src/crl.c
View File

@@ -51,12 +51,7 @@ int InitCRL(WOLFSSL_CRL* crl, WOLFSSL_CERT_MANAGER* cm)
{
WOLFSSL_ENTER("InitCRL");
/* default heap hint to null or test value */
#ifdef WOLFSSL_HEAP_TEST
crl->heap = (void*)WOLFSSL_HEAP_TEST;
#else
crl->heap = cm->heap;
#endif
crl->cm = cm;
crl->crlList = NULL;
crl->monitors[0].path = NULL;

12
src/internal.c
View File

@@ -1366,16 +1366,7 @@ int InitSSL_Ctx(WOLFSSL_CTX* ctx, WOLFSSL_METHOD* method, void* heap)
#endif
#endif /* HAVE_WOLF_EVENT */
#ifdef WOLFSSL_STATIC_MEMORY
#ifdef WOLFSSL_HEAP_TEST
if (heap == NULL) {
ctx->heap = (void*)WOLFSSL_HEAP_TEST;
}
else
#endif
ctx->heap = heap; /* wolfSSL_CTX_load_static_memory sets */
#endif /* WOLFSSL_STATIC_MEMORY */
(void)heap;
return 0;
}
@@ -1444,6 +1435,7 @@ void SSL_CtxResourceFree(WOLFSSL_CTX* ctx)
#ifdef WOLFSSL_STATIC_MEMORY
if (ctx->heap != NULL) {
#ifdef WOLFSSL_HEAP_TEST
/* avoid derefrencing a test value */
if (ctx->heap != (void*)WOLFSSL_HEAP_TEST) {
#endif
WOLFSSL_HEAP_HINT* hint = (WOLFSSL_HEAP_HINT*)(ctx->heap);
@@ -3555,6 +3547,7 @@ void SSL_ResourceFree(WOLFSSL* ssl)
/* check if using fixed io buffers and free them */
if (ssl->heap != NULL) {
#ifdef WOLFSSL_HEAP_TEST
/* avoid dereferencing a test value */
if (ssl->heap != (void*)WOLFSSL_HEAP_TEST) {
#endif
WOLFSSL_HEAP_HINT* ssl_hint = (WOLFSSL_HEAP_HINT*)ssl->heap;
@@ -3730,6 +3723,7 @@ void FreeHandshakeResources(WOLFSSL* ssl)
/* when done with handshake decrement current handshake count */
if (ssl->heap != NULL) {
#ifdef WOLFSSL_HEAP_TEST
/* avoid dereferencing a test value */
if (ssl->heap != (void*)WOLFSSL_HEAP_TEST) {
#endif
WOLFSSL_HEAP_HINT* ssl_hint = (WOLFSSL_HEAP_HINT*)ssl->heap;

13
src/io.c
View File

@@ -779,7 +779,7 @@ static int decode_url(const char* url, int urlSz,
/* return: >0 OCSP Response Size
* -1 error */
static int process_http_response(int sfd, byte** respBuf,
byte* httpBuf, int httpBufSz)
byte* httpBuf, int httpBufSz, void* heap)
{
int result;
int len = 0;
@@ -868,7 +868,7 @@ static int process_http_response(int sfd, byte** respBuf,
}
} while (state != phr_http_end);
recvBuf = (byte*)XMALLOC(recvBufSz, NULL, DYNAMIC_TYPE_OCSP);
recvBuf = (byte*)XMALLOC(recvBufSz, heap, DYNAMIC_TYPE_OCSP);
if (recvBuf == NULL) {
WOLFSSL_MSG("process_http_response couldn't create response buffer");
return -1;
@@ -896,6 +896,7 @@ static int process_http_response(int sfd, byte** respBuf,
#define SCRATCH_BUFFER_SIZE 512
/* in default wolfSSL callback ctx is the heap pointer */
int EmbedOcspLookup(void* ctx, const char* url, int urlSz,
byte* ocspReqBuf, int ocspReqSz, byte** ocspRespBuf)
{
@@ -922,8 +923,6 @@ int EmbedOcspLookup(void* ctx, const char* url, int urlSz,
}
#endif
(void)ctx;
if (ocspReqBuf == NULL || ocspReqSz == 0) {
WOLFSSL_MSG("OCSP request is required for lookup");
}
@@ -937,7 +936,7 @@ int EmbedOcspLookup(void* ctx, const char* url, int urlSz,
/* Note, the library uses the EmbedOcspRespFree() callback to
* free this buffer. */
int httpBufSz = SCRATCH_BUFFER_SIZE;
byte* httpBuf = (byte*)XMALLOC(httpBufSz, NULL,
byte* httpBuf = (byte*)XMALLOC(httpBufSz, ctx,
DYNAMIC_TYPE_OCSP);
if (httpBuf == NULL) {
@@ -960,11 +959,11 @@ int EmbedOcspLookup(void* ctx, const char* url, int urlSz,
}
else {
ret = process_http_response(sfd, ocspRespBuf, httpBuf,
SCRATCH_BUFFER_SIZE);
SCRATCH_BUFFER_SIZE, ctx);
}
close(sfd);
XFREE(httpBuf, NULL, DYNAMIC_TYPE_OCSP);
XFREE(httpBuf, ctx, DYNAMIC_TYPE_OCSP);
}
}

225
src/ssl.c
View File

@@ -336,7 +336,12 @@ WOLFSSL_CTX* wolfSSL_CTX_new_ex(WOLFSSL_METHOD* method, void* heap)
WOLFSSL_CTX* wolfSSL_CTX_new(WOLFSSL_METHOD* method)
{
#ifdef WOLFSSL_HEAP_TEST
/* if testing the heap hint then set top level CTX to have test value */
return wolfSSL_CTX_new_ex(method, (void*)WOLFSSL_HEAP_TEST);
#else
return wolfSSL_CTX_new_ex(method, NULL);
#endif
}
@@ -632,10 +637,10 @@ int wolfSSL_init_memory_heap(WOLFSSL_HEAP* heap)
* having session certs enabled makes a 21k SSL struct */
#ifndef SESSION_CERTS
word32 wc_defaultMemSz[WOLFMEM_DEF_BUCKETS] =
{ 64, 128, 256, 512, 1024, 2400, 3408, 4544, 16128 };
{ 64, 128, 256, 512, 1024, 2432, 3456, 4544, 16128 };
#else
word32 wc_defaultMemSz[WOLFMEM_DEF_BUCKETS] =
{ 64, 128, 256, 512, 1024, 2400, 3408, 4544, 21000 };
{ 64, 128, 256, 512, 1024, 2432, 3456, 4544, 21056 };
#endif
word32 wc_defaultDist[WOLFMEM_DEF_BUCKETS] = { 8, 4, 4, 12, 4, 5, 2, 1, 1 };
@@ -658,7 +663,83 @@ int wolfSSL_init_memory_heap(WOLFSSL_HEAP* heap)
return SSL_SUCCESS;
}
int wolfSSL_CTX_load_static_memory(WOLFSSL_CTX** ctx, wolfSSLStaticMethod method,
static WOLFSSL_METHOD* GetMethod(wolfSSL_method_func method, void* heap)
{
#ifndef NO_WOLFSSL_SERVER
#ifndef NO_OLD_TLS
#ifdef WOLFSSL_ALLOW_SSLV3
if (method == wolfSSLv3_server_method) {
return wolfSSLv3_server_method_ex(heap);
}
#endif
if (method == wolfTLSv1_server_method) {
return wolfTLSv1_server_method_ex(heap);
}
if (method == wolfTLSv1_1_server_method) {
return wolfTLSv1_1_server_method_ex(heap);
}
#endif /* ! NO_OLD_TLS */
#ifndef NO_SHA256 /* can't use without SHA256 */
if (method == wolfTLSv1_2_server_method) {
return wolfTLSv1_2_server_method_ex(heap);
}
#endif
if (method == wolfSSLv23_server_method) {
return wolfSSLv23_server_method_ex(heap);
}
#endif /* NO_WOLFSSL_SERVER */
#ifndef NO_WOLFSSL_CLIENT
#ifndef NO_OLD_TLS
#ifdef WOLFSSL_ALLOW_SSLV3
if (method == wolfSSLv3_client_method) {
return wolfSSLv3_client_method_ex(heap);
}
#endif
if (method == wolfTLSv1_client_method) {
return wolfTLSv1_client_method_ex(heap);
}
if (method == wolfTLSv1_1_client_method) {
return wolfTLSv1_1_client_method_ex(heap);
}
#endif /* ! NO_OLD_TLS */
#ifndef NO_SHA256 /* can't use without SHA256 */
if (method == wolfTLSv1_2_client_method) {
return wolfTLSv1_2_client_method_ex(heap);
}
#endif
if (method == wolfSSLv23_client_method) {
return wolfSSLv23_client_method_ex(heap);
}
#endif /* NO_WOLFSSL_CLIENT */
#ifdef WOLFSSL_DTLS
if (method == wolfDTLSv1_client_method) {
return wolfDTLSv1_client_method_ex(heap);
}
if (method == wolfDTLSv1_server_method) {
return wolfDTLSv1_server_method_ex(heap);
}
if (method == wolfDTLSv1_2_client_method) {
return wolfDTLSv1_2_client_method_ex(heap);
}
if (method == wolfDTLSv1_2_server_method) {
return wolfDTLSv1_2_server_method_ex(heap);
}
#endif
WOLFSSL_MSG("Method function not found");
return NULL;
}
int wolfSSL_CTX_load_static_memory(WOLFSSL_CTX** ctx, wolfSSL_method_func method,
unsigned char* buf, unsigned int sz,
int flag, int max)
{
@@ -714,7 +795,7 @@ int wolfSSL_CTX_load_static_memory(WOLFSSL_CTX** ctx, wolfSSLStaticMethod method
/* create ctx if needed */
if (*ctx == NULL) {
*ctx = wolfSSL_CTX_new_ex(method(hint), hint);
*ctx = wolfSSL_CTX_new_ex(GetMethod(method, hint), hint);
if (*ctx == NULL) {
WOLFSSL_MSG("Error creating ctx");
return SSL_FAILURE;
@@ -1400,8 +1481,7 @@ int wolfSSL_ALPN_GetPeerProtocol(WOLFSSL* ssl, char **list, word16 *listSz)
if (*listSz == 0)
return BUFFER_ERROR;
/* leaving as null heap hint since user calls free on returned string */
*list = (char *)XMALLOC((*listSz)+1, NULL, DYNAMIC_TYPE_TLSX);
*list = (char *)XMALLOC((*listSz)+1, ssl->heap, DYNAMIC_TYPE_TLSX);
if (*list == NULL)
return MEMORY_ERROR;
@@ -1411,6 +1491,20 @@ int wolfSSL_ALPN_GetPeerProtocol(WOLFSSL* ssl, char **list, word16 *listSz)
return SSL_SUCCESS;
}
/* used to free memory allocated by wolfSSL_ALPN_GetPeerProtocol */
int wolfSSL_ALPN_FreePeerProtocol(WOLFSSL* ssl, char **list)
{
if (ssl == NULL) {
return BAD_FUNC_ARG;
}
XFREE(*list, ssl->heap, DYNAMIC_TYPE_TLSX);
*list = NULL;
return SSL_SUCCESS;
}
#endif /* HAVE_ALPN */
/* Secure Renegotiation */
@@ -2110,12 +2204,6 @@ WOLFSSL_CERT_MANAGER* wolfSSL_CertManagerNew_ex(void* heap)
#endif
#ifdef HAVE_ECC
cm->minEccKeySz = MIN_ECCKEY_SZ;
#endif
#ifdef WOLFSSL_HEAP_TEST
if (heap == NULL) {
cm->heap = (void*)WOLFSSL_HEAP_TEST;
}
else
#endif
cm->heap = heap;
}
@@ -4333,6 +4421,7 @@ int wolfSSL_CertManagerEnableOCSP(WOLFSSL_CERT_MANAGER* cm, int options)
#ifndef WOLFSSL_USER_IO
cm->ocspIOCb = EmbedOcspLookup;
cm->ocspRespFreeCb = EmbedOcspRespFree;
cm->ocspIOCtx = cm->heap;
#endif /* WOLFSSL_USER_IO */
#else
ret = NOT_COMPILED_IN;
@@ -5080,6 +5169,10 @@ int wolfSSL_PemCertToDer(const char* fileName, unsigned char* derBuf, int derSz)
ret = SSL_BAD_FILE;
}
else if (sz > (long)sizeof(staticBuffer)) {
#ifdef WOLFSSL_STATIC_MEMORY
WOLFSSL_MSG("File was larger then static buffer");
return MEMORY_E;
#endif
fileBuf = (byte*)XMALLOC(sz, 0, DYNAMIC_TYPE_FILE);
if (fileBuf == NULL)
ret = MEMORY_E;
@@ -5162,6 +5255,10 @@ int wolfSSL_PemPubKeyToDer(const char* fileName,
ret = SSL_BAD_FILE;
}
else if (sz > (long)sizeof(staticBuffer)) {
#ifdef WOLFSSL_STATIC_MEMORY
WOLFSSL_MSG("File was larger then static buffer");
return MEMORY_E;
#endif
fileBuf = (byte*)XMALLOC(sz, 0, DYNAMIC_TYPE_FILE);
if (fileBuf == NULL)
ret = MEMORY_E;
@@ -6592,13 +6689,8 @@ int wolfSSL_DTLS_SetCookieSecret(WOLFSSL* ssl,
#if defined(WOLFSSL_ALLOW_SSLV3) && !defined(NO_OLD_TLS)
WOLFSSL_METHOD* wolfSSLv3_client_method(void)
{
WOLFSSL_METHOD* method =
(WOLFSSL_METHOD*) XMALLOC(sizeof(WOLFSSL_METHOD),
0, DYNAMIC_TYPE_METHOD);
WOLFSSL_ENTER("SSLv3_client_method");
if (method)
InitSSL_Method(method, MakeSSLv3());
return method;
return wolfSSLv3_client_method_ex(NULL);
}
#endif
@@ -6607,36 +6699,25 @@ int wolfSSL_DTLS_SetCookieSecret(WOLFSSL* ssl,
#ifndef NO_OLD_TLS
WOLFSSL_METHOD* wolfDTLSv1_client_method(void)
{
WOLFSSL_METHOD* method =
(WOLFSSL_METHOD*) XMALLOC(sizeof(WOLFSSL_METHOD),
0, DYNAMIC_TYPE_METHOD);
WOLFSSL_ENTER("DTLSv1_client_method");
if (method)
InitSSL_Method(method, MakeDTLSv1());
return method;
return wolfDTLSv1_client_method_ex(NULL);
}
#endif /* NO_OLD_TLS */
WOLFSSL_METHOD* wolfDTLSv1_2_client_method(void)
{
WOLFSSL_METHOD* method =
(WOLFSSL_METHOD*) XMALLOC(sizeof(WOLFSSL_METHOD),
0, DYNAMIC_TYPE_METHOD);
WOLFSSL_ENTER("DTLSv1_2_client_method");
if (method)
InitSSL_Method(method, MakeDTLSv1_2());
return method;
return wolfDTLSv1_2_client_method_ex(NULL);
}
#endif
#ifdef WOLFSSL_STATIC_MEMORY
#if defined(WOLFSSL_ALLOW_SSLV3) && !defined(NO_OLD_TLS)
WOLFSSL_METHOD* wolfSSLv3_client_static(void* heap)
WOLFSSL_METHOD* wolfSSLv3_client_method_ex(void* heap)
{
WOLFSSL_METHOD* method =
(WOLFSSL_METHOD*) XMALLOC(sizeof(WOLFSSL_METHOD),
heap, DYNAMIC_TYPE_METHOD);
WOLFSSL_ENTER("SSLv3_client_static");
WOLFSSL_ENTER("SSLv3_client_method_ex");
if (method)
InitSSL_Method(method, MakeSSLv3());
return method;
@@ -6646,30 +6727,29 @@ int wolfSSL_DTLS_SetCookieSecret(WOLFSSL* ssl,
#ifdef WOLFSSL_DTLS
#ifndef NO_OLD_TLS
WOLFSSL_METHOD* wolfDTLSv1_client_static(void* heap)
WOLFSSL_METHOD* wolfDTLSv1_client_method_ex(void* heap)
{
WOLFSSL_METHOD* method =
(WOLFSSL_METHOD*) XMALLOC(sizeof(WOLFSSL_METHOD),
heap, DYNAMIC_TYPE_METHOD);
WOLFSSL_ENTER("DTLSv1_client_static");
WOLFSSL_ENTER("DTLSv1_client_method_ex");
if (method)
InitSSL_Method(method, MakeDTLSv1());
return method;
}
#endif /* NO_OLD_TLS */
WOLFSSL_METHOD* wolfDTLSv1_2_client_static(void* heap)
WOLFSSL_METHOD* wolfDTLSv1_2_client_method_ex(void* heap)
{
WOLFSSL_METHOD* method =
(WOLFSSL_METHOD*) XMALLOC(sizeof(WOLFSSL_METHOD),
heap, DYNAMIC_TYPE_METHOD);
WOLFSSL_ENTER("DTLSv1_2_client_static");
WOLFSSL_ENTER("DTLSv1_2_client_method_ex");
if (method)
InitSSL_Method(method, MakeDTLSv1_2());
return method;
}
#endif
#endif /* WOLFSSL_STATIC_MEMORY */
/* please see note at top of README if you get an error from connect */
int wolfSSL_connect(WOLFSSL* ssl)
@@ -6940,15 +7020,8 @@ int wolfSSL_DTLS_SetCookieSecret(WOLFSSL* ssl,
#if defined(WOLFSSL_ALLOW_SSLV3) && !defined(NO_OLD_TLS)
WOLFSSL_METHOD* wolfSSLv3_server_method(void)
{
WOLFSSL_METHOD* method =
(WOLFSSL_METHOD*) XMALLOC(sizeof(WOLFSSL_METHOD),
0, DYNAMIC_TYPE_METHOD);
WOLFSSL_ENTER("SSLv3_server_method");
if (method) {
InitSSL_Method(method, MakeSSLv3());
method->side = WOLFSSL_SERVER_END;
}
return method;
return wolfSSLv3_server_method_ex(NULL);
}
#endif
@@ -6958,40 +7031,25 @@ int wolfSSL_DTLS_SetCookieSecret(WOLFSSL* ssl,
#ifndef NO_OLD_TLS
WOLFSSL_METHOD* wolfDTLSv1_server_method(void)
{
WOLFSSL_METHOD* method =
(WOLFSSL_METHOD*) XMALLOC(sizeof(WOLFSSL_METHOD),
0, DYNAMIC_TYPE_METHOD);
WOLFSSL_ENTER("DTLSv1_server_method");
if (method) {
InitSSL_Method(method, MakeDTLSv1());
method->side = WOLFSSL_SERVER_END;
}
return method;
return wolfDTLSv1_server_method_ex(NULL);
}
#endif /* NO_OLD_TLS */
WOLFSSL_METHOD* wolfDTLSv1_2_server_method(void)
{
WOLFSSL_METHOD* method =
(WOLFSSL_METHOD*) XMALLOC(sizeof(WOLFSSL_METHOD),
0, DYNAMIC_TYPE_METHOD);
WOLFSSL_ENTER("DTLSv1_2_server_method");
if (method) {
InitSSL_Method(method, MakeDTLSv1_2());
method->side = WOLFSSL_SERVER_END;
}
return method;
return wolfDTLSv1_2_server_method_ex(NULL);
}
#endif
#ifdef WOLFSSL_STATIC_MEMORY
#if defined(WOLFSSL_ALLOW_SSLV3) && !defined(NO_OLD_TLS)
WOLFSSL_METHOD* wolfSSLv3_server_static(void* heap)
WOLFSSL_METHOD* wolfSSLv3_server_method_ex(void* heap)
{
WOLFSSL_METHOD* method =
(WOLFSSL_METHOD*) XMALLOC(sizeof(WOLFSSL_METHOD),
heap, DYNAMIC_TYPE_METHOD);
WOLFSSL_ENTER("SSLv3_server_static");
WOLFSSL_ENTER("SSLv3_server_method_ex");
if (method) {
InitSSL_Method(method, MakeSSLv3());
method->side = WOLFSSL_SERVER_END;
@@ -7004,12 +7062,12 @@ int wolfSSL_DTLS_SetCookieSecret(WOLFSSL* ssl,
#ifdef WOLFSSL_DTLS
#ifndef NO_OLD_TLS
WOLFSSL_METHOD* wolfDTLSv1_server_static(void* heap)
WOLFSSL_METHOD* wolfDTLSv1_server_method_ex(void* heap)
{
WOLFSSL_METHOD* method =
(WOLFSSL_METHOD*) XMALLOC(sizeof(WOLFSSL_METHOD),
heap, DYNAMIC_TYPE_METHOD);
WOLFSSL_ENTER("DTLSv1_server_static");
WOLFSSL_ENTER("DTLSv1_server_method_ex");
if (method) {
InitSSL_Method(method, MakeDTLSv1());
method->side = WOLFSSL_SERVER_END;
@@ -7018,12 +7076,12 @@ int wolfSSL_DTLS_SetCookieSecret(WOLFSSL* ssl,
}
#endif /* NO_OLD_TLS */
WOLFSSL_METHOD* wolfDTLSv1_2_server_static(void* heap)
WOLFSSL_METHOD* wolfDTLSv1_2_server_method_ex(void* heap)
{
WOLFSSL_METHOD* method =
(WOLFSSL_METHOD*) XMALLOC(sizeof(WOLFSSL_METHOD),
heap, DYNAMIC_TYPE_METHOD);
WOLFSSL_ENTER("DTLSv1_2_server_static");
WOLFSSL_ENTER("DTLSv1_2_server_method_ex");
if (method) {
InitSSL_Method(method, MakeDTLSv1_2());
method->side = WOLFSSL_SERVER_END;
@@ -7031,7 +7089,6 @@ int wolfSSL_DTLS_SetCookieSecret(WOLFSSL* ssl,
return method;
}
#endif
#endif /* WOLFSSL_STATIC_MEMORY */
int wolfSSL_accept(WOLFSSL* ssl)
{
@@ -10949,9 +11006,14 @@ static void ExternalFreeX509(WOLFSSL_X509* x509)
if (!name->sz) return in;
if (!in) {
#ifdef WOLFSSL_STATIC_MEMORY
WOLFSSL_MSG("Using static memory -- please pass in a buffer");
return NULL;
#else
in = (char*)XMALLOC(name->sz, NULL, DYNAMIC_TYPE_OPENSSL);
if (!in ) return in;
copySz = name->sz;
#endif
}
if (copySz == 0)
@@ -11071,9 +11133,14 @@ byte* wolfSSL_X509_get_device_type(WOLFSSL_X509* x509, byte* in, int *inOutSz)
copySz = min(*inOutSz, x509->deviceTypeSz);
if (!in) {
#ifdef WOLFSSL_STATIC_MEMORY
WOLFSSL_MSG("Using static memory -- please pass in a buffer");
return NULL;
#else
in = (byte*)XMALLOC(x509->deviceTypeSz, 0, DYNAMIC_TYPE_OPENSSL);
if (!in) return in;
copySz = x509->deviceTypeSz;
#endif
}
XMEMCPY(in, x509->deviceType, copySz);
@@ -11094,9 +11161,14 @@ byte* wolfSSL_X509_get_hw_type(WOLFSSL_X509* x509, byte* in, int* inOutSz)
copySz = min(*inOutSz, x509->hwTypeSz);
if (!in) {
#ifdef WOLFSSL_STATIC_MEMORY
WOLFSSL_MSG("Using static memory -- please pass in a buffer");
return NULL;
#else
in = (byte*)XMALLOC(x509->hwTypeSz, 0, DYNAMIC_TYPE_OPENSSL);
if (!in) return in;
copySz = x509->hwTypeSz;
#endif
}
XMEMCPY(in, x509->hwType, copySz);
@@ -11118,9 +11190,14 @@ byte* wolfSSL_X509_get_hw_serial_number(WOLFSSL_X509* x509,byte* in,
copySz = min(*inOutSz, x509->hwSerialNumSz);
if (!in) {
#ifdef WOLFSSL_STATIC_MEMORY
WOLFSSL_MSG("Using static memory -- please pass in a buffer");
return NULL;
#else
in = (byte*)XMALLOC(x509->hwSerialNumSz, 0, DYNAMIC_TYPE_OPENSSL);
if (!in) return in;
copySz = x509->hwSerialNumSz;
#endif
}
XMEMCPY(in, x509->hwSerialNum, copySz);
@@ -12319,14 +12396,16 @@ WOLFSSL_EVP_PKEY* wolfSSL_X509_get_pubkey(WOLFSSL_X509* x509)
WOLFSSL_EVP_PKEY* key = NULL;
if (x509 != NULL) {
key = (WOLFSSL_EVP_PKEY*)XMALLOC(
sizeof(WOLFSSL_EVP_PKEY), NULL, DYNAMIC_TYPE_PUBLIC_KEY);
sizeof(WOLFSSL_EVP_PKEY), x509->heap,
DYNAMIC_TYPE_PUBLIC_KEY);
if (key != NULL) {
key->type = x509->pubKeyOID;
key->save_type = 0;
key->pkey.ptr = (char*)XMALLOC(
x509->pubKey.length, NULL, DYNAMIC_TYPE_PUBLIC_KEY);
x509->pubKey.length, x509->heap,
DYNAMIC_TYPE_PUBLIC_KEY);
if (key->pkey.ptr == NULL) {
XFREE(key, NULL, DYNAMIC_TYPE_PUBLIC_KEY);
XFREE(key, x509->heap, DYNAMIC_TYPE_PUBLIC_KEY);
return NULL;
}
XMEMCPY(key->pkey.ptr,

107
src/tls.c
View File

@@ -4633,27 +4633,16 @@ int TLSX_Parse(WOLFSSL* ssl, byte* input, word16 length, byte isRequest,
WOLFSSL_METHOD* wolfTLSv1_client_method(void)
{
WOLFSSL_METHOD* method =
(WOLFSSL_METHOD*) XMALLOC(sizeof(WOLFSSL_METHOD), 0,
DYNAMIC_TYPE_METHOD);
if (method)
InitSSL_Method(method, MakeTLSv1());
return method;
return wolfTLSv1_client_method_ex(NULL);
}
WOLFSSL_METHOD* wolfTLSv1_1_client_method(void)
{
WOLFSSL_METHOD* method =
(WOLFSSL_METHOD*) XMALLOC(sizeof(WOLFSSL_METHOD), 0,
DYNAMIC_TYPE_METHOD);
if (method)
InitSSL_Method(method, MakeTLSv1_1());
return method;
return wolfTLSv1_1_client_method_ex(NULL);
}
#ifdef WOLFSSL_STATIC_MEMORY
WOLFSSL_METHOD* wolfTLSv1_client_static(void* heap)
WOLFSSL_METHOD* wolfTLSv1_client_method_ex(void* heap)
{
WOLFSSL_METHOD* method =
(WOLFSSL_METHOD*) XMALLOC(sizeof(WOLFSSL_METHOD),
@@ -4664,7 +4653,7 @@ int TLSX_Parse(WOLFSSL* ssl, byte* input, word16 length, byte isRequest,
}
WOLFSSL_METHOD* wolfTLSv1_1_client_static(void* heap)
WOLFSSL_METHOD* wolfTLSv1_1_client_method_ex(void* heap)
{
WOLFSSL_METHOD* method =
(WOLFSSL_METHOD*) XMALLOC(sizeof(WOLFSSL_METHOD),
@@ -4673,7 +4662,6 @@ int TLSX_Parse(WOLFSSL* ssl, byte* input, word16 length, byte isRequest,
InitSSL_Method(method, MakeTLSv1_1());
return method;
}
#endif /* WOLFSSL_STATIC_MEMORY */
#endif /* !NO_OLD_TLS */
@@ -4681,16 +4669,10 @@ int TLSX_Parse(WOLFSSL* ssl, byte* input, word16 length, byte isRequest,
WOLFSSL_METHOD* wolfTLSv1_2_client_method(void)
{
WOLFSSL_METHOD* method =
(WOLFSSL_METHOD*) XMALLOC(sizeof(WOLFSSL_METHOD), 0,
DYNAMIC_TYPE_METHOD);
if (method)
InitSSL_Method(method, MakeTLSv1_2());
return method;
return wolfTLSv1_2_client_method_ex(NULL);
}
#ifdef WOLFSSL_STATIC_MEMORY
WOLFSSL_METHOD* wolfTLSv1_2_client_static(void* heap)
WOLFSSL_METHOD* wolfTLSv1_2_client_method_ex(void* heap)
{
WOLFSSL_METHOD* method =
(WOLFSSL_METHOD*) XMALLOC(sizeof(WOLFSSL_METHOD),
@@ -4699,31 +4681,16 @@ int TLSX_Parse(WOLFSSL* ssl, byte* input, word16 length, byte isRequest,
InitSSL_Method(method, MakeTLSv1_2());
return method;
}
#endif /* WOLFSSL_STATIC_MEMORY */
#endif
WOLFSSL_METHOD* wolfSSLv23_client_method(void)
{
WOLFSSL_METHOD* method =
(WOLFSSL_METHOD*) XMALLOC(sizeof(WOLFSSL_METHOD), 0,
DYNAMIC_TYPE_METHOD);
if (method) {
#ifndef NO_SHA256 /* 1.2 requires SHA256 */
InitSSL_Method(method, MakeTLSv1_2());
#else
InitSSL_Method(method, MakeTLSv1_1());
#endif
#ifndef NO_OLD_TLS
method->downgrade = 1;
#endif
}
return method;
return wolfSSLv23_client_method_ex(NULL);
}
#ifdef WOLFSSL_STATIC_MEMORY
WOLFSSL_METHOD* wolfSSLv23_client_static(void* heap)
WOLFSSL_METHOD* wolfSSLv23_client_method_ex(void* heap)
{
WOLFSSL_METHOD* method =
(WOLFSSL_METHOD*) XMALLOC(sizeof(WOLFSSL_METHOD),
@@ -4740,7 +4707,6 @@ int TLSX_Parse(WOLFSSL* ssl, byte* input, word16 length, byte isRequest,
}
return method;
}
#endif /* WOLFSSL_STATIC_MEMORY */
#endif /* NO_WOLFSSL_CLIENT */
@@ -4752,31 +4718,16 @@ int TLSX_Parse(WOLFSSL* ssl, byte* input, word16 length, byte isRequest,
WOLFSSL_METHOD* wolfTLSv1_server_method(void)
{
WOLFSSL_METHOD* method =
(WOLFSSL_METHOD*) XMALLOC(sizeof(WOLFSSL_METHOD), 0,
DYNAMIC_TYPE_METHOD);
if (method) {
InitSSL_Method(method, MakeTLSv1());
method->side = WOLFSSL_SERVER_END;
}
return method;
return wolfTLSv1_server_method_ex(NULL);
}
WOLFSSL_METHOD* wolfTLSv1_1_server_method(void)
{
WOLFSSL_METHOD* method =
(WOLFSSL_METHOD*) XMALLOC(sizeof(WOLFSSL_METHOD), 0,
DYNAMIC_TYPE_METHOD);
if (method) {
InitSSL_Method(method, MakeTLSv1_1());
method->side = WOLFSSL_SERVER_END;
}
return method;
return wolfTLSv1_1_server_method_ex(NULL);
}
#ifdef WOLFSSL_STATIC_MEMORY
WOLFSSL_METHOD* wolfTLSv1_server_static(void* heap)
WOLFSSL_METHOD* wolfTLSv1_server_method_ex(void* heap)
{
WOLFSSL_METHOD* method =
(WOLFSSL_METHOD*) XMALLOC(sizeof(WOLFSSL_METHOD),
@@ -4789,7 +4740,7 @@ int TLSX_Parse(WOLFSSL* ssl, byte* input, word16 length, byte isRequest,
}
WOLFSSL_METHOD* wolfTLSv1_1_server_static(void* heap)
WOLFSSL_METHOD* wolfTLSv1_1_server_method_ex(void* heap)
{
WOLFSSL_METHOD* method =
(WOLFSSL_METHOD*) XMALLOC(sizeof(WOLFSSL_METHOD),
@@ -4800,25 +4751,16 @@ int TLSX_Parse(WOLFSSL* ssl, byte* input, word16 length, byte isRequest,
}
return method;
}
#endif /* WOLFSSL_STATIC_MEMORY */
#endif /* !NO_OLD_TLS */
#ifndef NO_SHA256 /* can't use without SHA256 */
WOLFSSL_METHOD* wolfTLSv1_2_server_method(void)
{
WOLFSSL_METHOD* method =
(WOLFSSL_METHOD*) XMALLOC(sizeof(WOLFSSL_METHOD), 0,
DYNAMIC_TYPE_METHOD);
if (method) {
InitSSL_Method(method, MakeTLSv1_2());
method->side = WOLFSSL_SERVER_END;
}
return method;
return wolfTLSv1_2_server_method_ex(NULL);
}
#ifdef WOLFSSL_STATIC_MEMORY
WOLFSSL_METHOD* wolfTLSv1_2_server_static(void* heap)
WOLFSSL_METHOD* wolfTLSv1_2_server_method_ex(void* heap)
{
WOLFSSL_METHOD* method =
(WOLFSSL_METHOD*) XMALLOC(sizeof(WOLFSSL_METHOD),
@@ -4829,32 +4771,16 @@ int TLSX_Parse(WOLFSSL* ssl, byte* input, word16 length, byte isRequest,
}
return method;
}
#endif /* WOLFSSL_STATIC_MEMORY */
#endif
WOLFSSL_METHOD* wolfSSLv23_server_method(void)
{
WOLFSSL_METHOD* method =
(WOLFSSL_METHOD*) XMALLOC(sizeof(WOLFSSL_METHOD), 0,
DYNAMIC_TYPE_METHOD);
if (method) {
#ifndef NO_SHA256 /* 1.2 requires SHA256 */
InitSSL_Method(method, MakeTLSv1_2());
#else
InitSSL_Method(method, MakeTLSv1_1());
#endif
method->side = WOLFSSL_SERVER_END;
#ifndef NO_OLD_TLS
method->downgrade = 1;
#endif /* !NO_OLD_TLS */
}
return method;
return wolfSSLv23_server_method_ex(NULL);
}
#ifdef WOLFSSL_STATIC_MEMORY
WOLFSSL_METHOD* wolfSSLv23_server_static(void* heap)
WOLFSSL_METHOD* wolfSSLv23_server_method_ex(void* heap)
{
WOLFSSL_METHOD* method =
(WOLFSSL_METHOD*) XMALLOC(sizeof(WOLFSSL_METHOD),
@@ -4872,7 +4798,6 @@ int TLSX_Parse(WOLFSSL* ssl, byte* input, word16 length, byte isRequest,
}
return method;
}
#endif /* WOLFSSL_STATIC_MEMORY */
#endif /* NO_WOLFSSL_SERVER */

2
tests/api.c
View File

@@ -1651,7 +1651,7 @@ static void verify_ALPN_client_list(WOLFSSL* ssl)
AssertIntEQ(1, sizeof(alpn_list) == clistSz);
AssertIntEQ(0, XMEMCMP(alpn_list, clist, clistSz));
XFREE(clist, 0, DYNAMIC_TYPE_TLSX);
AssertIntEQ(SSL_SUCCESS, wolfSSL_ALPN_FreePeerProtocol(ssl, &clist));
}
static void test_wolfSSL_UseALPN_connection(void)

15
wolfcrypt/src/memory.c
View File

@@ -218,7 +218,7 @@ int wolfSSL_load_static_memory(byte* buffer, word32 sz, int flag,
}
/* align pt */
while ((long)pt % WOLFSSL_STATIC_ALIGN && pt < (buffer + sz)) {
while ((wolfssl_word)pt % WOLFSSL_STATIC_ALIGN && pt < (buffer + sz)) {
*pt = 0x00;
pt++;
}
@@ -458,8 +458,10 @@ void* wolfSSL_Malloc(size_t size, void* heap, int type)
}
#ifdef WOLFSSL_MALLOC_CHECK
if (res == NULL)
puts("wolfSSL_malloc failed");
if ((wolfssl_word)res % WOLFSSL_STATIC_ALIGN) {
res = NULL;
WOLFSSL_MSG("ERROR memory is not alligned");
}
#endif
(void)i;
@@ -642,6 +644,13 @@ void* wolfSSL_Realloc(void *ptr, size_t size, void* heap, int type)
UnLockMutex(&(mem->memory_mutex));
}
#ifdef WOLFSSL_MALLOC_CHECK
if ((wolfssl_word)res % WOLFSSL_STATIC_ALIGN) {
res = NULL;
WOLFSSL_MSG("ERROR memory is not alligned");
}
#endif
(void)i;
(void)pt;
(void)type;

19
wolfssl/internal.h
View File

@@ -1208,6 +1208,25 @@ WOLFSSL_LOCAL ProtocolVersion MakeTLSv1(void);
WOLFSSL_LOCAL ProtocolVersion MakeTLSv1_1(void);
WOLFSSL_LOCAL ProtocolVersion MakeTLSv1_2(void);
WOLFSSL_LOCAL WOLFSSL_METHOD *wolfSSLv3_server_method_ex(void* heap);
WOLFSSL_LOCAL WOLFSSL_METHOD *wolfSSLv3_client_method_ex(void* heap);
WOLFSSL_LOCAL WOLFSSL_METHOD *wolfTLSv1_server_method_ex(void* heap);
WOLFSSL_LOCAL WOLFSSL_METHOD *wolfTLSv1_client_method_ex(void* heap);
WOLFSSL_LOCAL WOLFSSL_METHOD *wolfTLSv1_1_server_method_ex(void* heap);
WOLFSSL_LOCAL WOLFSSL_METHOD *wolfTLSv1_1_client_method_ex(void* heap);
WOLFSSL_LOCAL WOLFSSL_METHOD *wolfTLSv1_2_server_method_ex(void* heap);
WOLFSSL_LOCAL WOLFSSL_METHOD *wolfTLSv1_2_client_method_ex(void* heap);
WOLFSSL_LOCAL WOLFSSL_METHOD *wolfSSLv23_server_method_ex(void* heap);
WOLFSSL_LOCAL WOLFSSL_METHOD *wolfSSLv23_client_method_ex(void* heap);
#ifdef WOLFSSL_DTLS
WOLFSSL_LOCAL WOLFSSL_METHOD *wolfDTLSv1_client_method_ex(void* heap);
WOLFSSL_LOCAL WOLFSSL_METHOD *wolfDTLSv1_server_method_ex(void* heap);
WOLFSSL_LOCAL WOLFSSL_METHOD *wolfDTLSv1_2_client_method_ex(void* heap);
WOLFSSL_LOCAL WOLFSSL_METHOD *wolfDTLSv1_2_server_method_ex(void* heap);
#endif
#ifdef WOLFSSL_DTLS
WOLFSSL_LOCAL ProtocolVersion MakeDTLSv1(void);
WOLFSSL_LOCAL ProtocolVersion MakeDTLSv1_2(void);

34
wolfssl/ssl.h
View File

@@ -203,6 +203,7 @@ enum AlertLevel {
};
typedef WOLFSSL_METHOD* (*wolfSSL_method_func)(void);
WOLFSSL_API WOLFSSL_METHOD *wolfSSLv3_server_method(void);
WOLFSSL_API WOLFSSL_METHOD *wolfSSLv3_client_method(void);
WOLFSSL_API WOLFSSL_METHOD *wolfTLSv1_server_method(void);
@@ -219,27 +220,6 @@ WOLFSSL_API WOLFSSL_METHOD *wolfTLSv1_2_client_method(void);
WOLFSSL_API WOLFSSL_METHOD *wolfDTLSv1_2_server_method(void);
#endif
#ifdef WOLFSSL_STATIC_MEMORY
typedef WOLFSSL_METHOD* (*wolfSSLStaticMethod)(void*);
WOLFSSL_API WOLFSSL_METHOD *wolfSSLv3_server_static(void* heap);
WOLFSSL_API WOLFSSL_METHOD *wolfSSLv3_client_static(void* heap);
WOLFSSL_API WOLFSSL_METHOD *wolfTLSv1_server_static(void* heap);
WOLFSSL_API WOLFSSL_METHOD *wolfTLSv1_client_static(void* heap);
WOLFSSL_API WOLFSSL_METHOD *wolfTLSv1_1_server_static(void* heap);
WOLFSSL_API WOLFSSL_METHOD *wolfTLSv1_1_client_static(void* heap);
WOLFSSL_API WOLFSSL_METHOD *wolfTLSv1_2_server_static(void* heap);
WOLFSSL_API WOLFSSL_METHOD *wolfTLSv1_2_client_static(void* heap);
WOLFSSL_API WOLFSSL_METHOD *wolfSSLv23_server_static(void* heap);
WOLFSSL_API WOLFSSL_METHOD *wolfSSLv23_client_static(void* heap);
#ifdef WOLFSSL_DTLS
WOLFSSL_API WOLFSSL_METHOD *wolfDTLSv1_client_static(void* heap);
WOLFSSL_API WOLFSSL_METHOD *wolfDTLSv1_server_static(void* heap);
WOLFSSL_API WOLFSSL_METHOD *wolfDTLSv1_2_client_static(void* heap);
WOLFSSL_API WOLFSSL_METHOD *wolfDTLSv1_2_server_static(void* heap);
#endif
#endif /* WOLFSSL_STATIC_MEMORY */
#ifdef HAVE_POLY1305
WOLFSSL_API int wolfSSL_use_old_poly(WOLFSSL*, int);
#endif
@@ -259,16 +239,17 @@ WOLFSSL_API int wolfSSL_dtls_export(WOLFSSL* ssl, unsigned char* buf,
#endif /* WOLFSSL_SESSION_EXPORT */
#ifdef WOLFSSL_STATIC_MEMORY
typedef struct WOLFSSL_MEM_STATS WOLFSSL_MEM_STATS;
typedef struct WOLFSSL_MEM_CONN_STATS WOLFSSL_MEM_CONN_STATS;
/* use underscore to avoid possible redefinition of typdef from memory.h */
typedef struct WOLFSSL_MEM_STATS _WOLFSSL_MEM_STATS;
typedef struct WOLFSSL_MEM_CONN_STATS _WOLFSSL_MEM_CONN_STATS;
WOLFSSL_API int wolfSSL_CTX_load_static_memory(WOLFSSL_CTX** ctx,
wolfSSLStaticMethod method,
wolfSSL_method_func method,
unsigned char* buf, unsigned int sz,
int flag, int max);
WOLFSSL_API int wolfSSL_CTX_is_static_memory(WOLFSSL_CTX* ctx,
WOLFSSL_MEM_STATS* mem_stats);
_WOLFSSL_MEM_STATS* mem_stats);
WOLFSSL_API int wolfSSL_is_static_memory(WOLFSSL* ssl,
WOLFSSL_MEM_CONN_STATS* mem_stats);
_WOLFSSL_MEM_CONN_STATS* mem_stats);
#endif
#if !defined(NO_FILESYSTEM) && !defined(NO_CERTS)
@@ -1470,6 +1451,7 @@ WOLFSSL_API int wolfSSL_ALPN_GetProtocol(WOLFSSL* ssl, char **protocol_name,
WOLFSSL_API int wolfSSL_ALPN_GetPeerProtocol(WOLFSSL* ssl, char **list,
unsigned short *listSz);
WOLFSSL_API int wolfSSL_ALPN_FreePeerProtocol(WOLFSSL* ssl, char **list);
#endif /* HAVE_ALPN */
/* Maximum Fragment Length */

14
wolfssl/wolfcrypt/memory.h
View File

@@ -106,10 +106,10 @@ WOLFSSL_API int wolfSSL_SetAllocators(wolfSSL_Malloc_cb malloc_function,
int flag; /* flag used */
} WOLFSSL_MEM_STATS;
typedef struct wc_Memory wc_Memory; /* internal structure for mem bucket */
typedef struct wc_Memory _wc_Memory; /* internal structure for mem bucket */
typedef struct WOLFSSL_HEAP {
wc_Memory* ava[WOLFMEM_MAX_BUCKETS];
wc_Memory* io; /* list of buffers to use for IO */
_wc_Memory* ava[WOLFMEM_MAX_BUCKETS];
_wc_Memory* io; /* list of buffers to use for IO */
word32 maxHa; /* max concurent handshakes */
word32 curHa;
word32 maxIO; /* max concurrent IO connections */
@@ -130,8 +130,8 @@ WOLFSSL_API int wolfSSL_SetAllocators(wolfSSL_Malloc_cb malloc_function,
typedef struct WOLFSSL_HEAP_HINT {
WOLFSSL_HEAP* memory;
WOLFSSL_MEM_CONN_STATS* stats; /* hold individual connection stats */
wc_Memory* outBuf; /* set if using fixed io buffers */
wc_Memory* inBuf;
_wc_Memory* outBuf; /* set if using fixed io buffers */
_wc_Memory* inBuf;
} WOLFSSL_HEAP_HINT;
@@ -139,8 +139,8 @@ WOLFSSL_API int wolfSSL_SetAllocators(wolfSSL_Malloc_cb malloc_function,
int flag, WOLFSSL_HEAP* heap);
WOLFSSL_LOCAL int wolfSSL_GetMemStats(WOLFSSL_HEAP* heap,
WOLFSSL_MEM_STATS* stats);
WOLFSSL_LOCAL int SetFixedIO(WOLFSSL_HEAP* heap, wc_Memory** io);
WOLFSSL_LOCAL int FreeFixedIO(WOLFSSL_HEAP* heap, wc_Memory** io);
WOLFSSL_LOCAL int SetFixedIO(WOLFSSL_HEAP* heap, _wc_Memory** io);
WOLFSSL_LOCAL int FreeFixedIO(WOLFSSL_HEAP* heap, _wc_Memory** io);
#endif /* WOLFSSL_STATIC_MEMORY */
#ifdef __cplusplus

3
wolfssl/wolfcrypt/settings.h
View File

@@ -1252,9 +1252,6 @@ static char *fgets(char *buff, int sz, FILE *fp)
#ifdef WOLFSSL_SMALL_STACK
#error static memory does not support small stack please undefine
#endif
#ifndef TFM_TIMING_RESISTANT
#error please define TFM_TIMING_RESISTANT with use of static memory
#endif
#endif /* WOLFSSL_STATIC_MEMORY */
/* Place any other flags or defines here */