Update code to v1.0.14 (10)

android/extern/wolfssl/src/dtls.c

@@ -0,0 +1,708 @@
+/* dtls.c
+ *
+ * Copyright (C) 2006-2022 wolfSSL Inc.
+ *
+ * This file is part of wolfSSL.
+ *
+ * wolfSSL is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * wolfSSL is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA
+ */
+
+/*
+ * WOLFSSL_DTLS_NO_HVR_ON_RESUME
+ *     If defined, a DTLS server will not do a cookie exchange on successful
+ *     client resumption: the resumption will be faster (one RTT less) and
+ *     will consume less bandwidth (one ClientHello and one HelloVerifyRequest
+ *     less). On the other hand, if a valid SessionID is collected, forged
+ *     clientHello messages will consume resources on the server.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <wolfssl/wolfcrypt/settings.h>
+
+#ifndef WOLFCRYPT_ONLY
+
+#include <wolfssl/error-ssl.h>
+#include <wolfssl/internal.h>
+#include <wolfssl/ssl.h>
+#ifdef NO_INLINE
+    #include <wolfssl/wolfcrypt/misc.h>
+#else
+    #define WOLFSSL_MISC_INCLUDED
+    #include <wolfcrypt/src/misc.c>
+#endif
+
+#ifdef WOLFSSL_DTLS
+
+void DtlsResetState(WOLFSSL* ssl)
+{
+    /* Reset the state so that we can statelessly await the
+     * ClientHello that contains the cookie. Don't gate on IsAtLeastTLSv1_3
+     * to handle the edge case when the peer wants a lower version. */
+
+#ifdef WOLFSSL_SEND_HRR_COOKIE
+    /* Remove cookie so that it will get computed again */
+    TLSX_Remove(&ssl->extensions, TLSX_COOKIE, ssl->heap);
+#endif
+
+    /* Reset DTLS window */
+#ifdef WOLFSSL_DTLS13
+    w64Zero(&ssl->dtls13Epochs[0].nextSeqNumber);
+    w64Zero(&ssl->dtls13Epochs[0].nextPeerSeqNumber);
+    XMEMSET(ssl->dtls13Epochs[0].window, 0,
+        sizeof(ssl->dtls13Epochs[0].window));
+    Dtls13FreeFsmResources(ssl);
+#endif
+    ssl->keys.dtls_expected_peer_handshake_number = 0;
+    ssl->keys.dtls_handshake_number = 0;
+
+    /* Reset states */
+    ssl->options.serverState = NULL_STATE;
+    ssl->options.clientState = NULL_STATE;
+    ssl->options.connectState = CONNECT_BEGIN;
+    ssl->options.acceptState = ACCEPT_BEGIN;
+    ssl->options.handShakeState = NULL_STATE;
+    ssl->msgsReceived.got_client_hello = 0;
+    ssl->keys.dtls_handshake_number = 0;
+    ssl->keys.dtls_expected_peer_handshake_number = 0;
+    ssl->options.clientState = 0;
+    XMEMSET(ssl->keys.peerSeq->window, 0, sizeof(ssl->keys.peerSeq->window));
+    XMEMSET(ssl->keys.peerSeq->prevWindow, 0,
+        sizeof(ssl->keys.peerSeq->prevWindow));
+}
+
+#if !defined(NO_WOLFSSL_SERVER)
+
+#if defined(NO_SHA) && defined(NO_SHA256)
+#error "DTLS needs either SHA or SHA-256"
+#endif /* NO_SHA && NO_SHA256 */
+
+#if !defined(NO_SHA) && defined(NO_SHA256)
+#define DTLS_COOKIE_TYPE WC_SHA
+#define DTLS_COOKIE_SZ WC_SHA_DIGEST_SIZE
+#endif /* !NO_SHA && NO_SHA256 */
+
+#ifndef NO_SHA256
+#define DTLS_COOKIE_TYPE WC_SHA256
+#define DTLS_COOKIE_SZ WC_SHA256_DIGEST_SIZE
+#endif /* !NO_SHA256 */
+
+typedef struct WolfSSL_ConstVector {
+    word32 size;
+    const byte* elements;
+} WolfSSL_ConstVector;
+
+typedef struct WolfSSL_CH {
+    ProtocolVersion* pv;
+    const byte* random;
+    WolfSSL_ConstVector sessionId;
+    WolfSSL_ConstVector cookie;
+    WolfSSL_ConstVector cipherSuite;
+    WolfSSL_ConstVector compression;
+    WolfSSL_ConstVector extension;
+    word32 length;
+} WolfSSL_CH;
+
+static int ReadVector8(const byte* input, WolfSSL_ConstVector* v)
+{
+    v->size = *input;
+    v->elements = input + OPAQUE8_LEN;
+    return v->size + OPAQUE8_LEN;
+}
+
+static int ReadVector16(const byte* input, WolfSSL_ConstVector* v)
+{
+    word16 size16;
+    ato16(input, &size16);
+    v->size = (word32)size16;
+    v->elements = input + OPAQUE16_LEN;
+    return v->size + OPAQUE16_LEN;
+}
+
+static int CreateDtlsCookie(WOLFSSL* ssl, const WolfSSL_CH* ch, byte* cookie)
+{
+    Hmac cookieHmac;
+    int ret;
+
+    ret = wc_HmacInit(&cookieHmac, ssl->heap, ssl->devId);
+    if (ret != 0)
+        return ret;
+    ret = wc_HmacSetKey(&cookieHmac, DTLS_COOKIE_TYPE,
+        ssl->buffers.dtlsCookieSecret.buffer,
+        ssl->buffers.dtlsCookieSecret.length);
+    if (ret != 0)
+        goto out;
+    ret = wc_HmacUpdate(&cookieHmac, (const byte*)ssl->buffers.dtlsCtx.peer.sa,
+        ssl->buffers.dtlsCtx.peer.sz);
+    if (ret != 0)
+        goto out;
+    ret = wc_HmacUpdate(&cookieHmac, (byte*)ch->pv, OPAQUE16_LEN);
+    if (ret != 0)
+        goto out;
+    ret = wc_HmacUpdate(&cookieHmac, (byte*)ch->random, RAN_LEN);
+    if (ret != 0)
+        goto out;
+    ret = wc_HmacUpdate(&cookieHmac, (byte*)ch->sessionId.elements,
+        ch->sessionId.size);
+    if (ret != 0)
+        goto out;
+    ret = wc_HmacUpdate(&cookieHmac, (byte*)ch->cipherSuite.elements,
+        ch->cipherSuite.size);
+    if (ret != 0)
+        goto out;
+    ret = wc_HmacUpdate(&cookieHmac, (byte*)ch->compression.elements,
+        ch->compression.size);
+    if (ret != 0)
+        goto out;
+    ret = wc_HmacFinal(&cookieHmac, cookie);
+
+out:
+    wc_HmacFree(&cookieHmac);
+    return ret;
+}
+
+static int ParseClientHello(const byte* input, word32 helloSz, WolfSSL_CH* ch)
+{
+    word32 idx = 0;
+
+    /* protocol version, random and session id length check */
+    if (OPAQUE16_LEN + RAN_LEN + OPAQUE8_LEN > helloSz)
+        return BUFFER_ERROR;
+
+    ch->pv = (ProtocolVersion*)(input + idx);
+    idx += OPAQUE16_LEN;
+    ch->random = (byte*)(input + idx);
+    idx += RAN_LEN;
+    idx += ReadVector8(input + idx, &ch->sessionId);
+    if (idx > helloSz - OPAQUE8_LEN)
+        return BUFFER_ERROR;
+    idx += ReadVector8(input + idx, &ch->cookie);
+    if (idx > helloSz - OPAQUE16_LEN)
+        return BUFFER_ERROR;
+    idx += ReadVector16(input + idx, &ch->cipherSuite);
+    if (idx > helloSz - OPAQUE8_LEN)
+        return BUFFER_ERROR;
+    idx += ReadVector8(input + idx, &ch->compression);
+    if (idx > helloSz - OPAQUE16_LEN)
+        return BUFFER_ERROR;
+    idx += ReadVector16(input + idx, &ch->extension);
+    if (idx > helloSz)
+        return BUFFER_ERROR;
+    ch->length = idx;
+    return 0;
+}
+
+#ifdef WOLFSSL_DTLS_NO_HVR_ON_RESUME
+#ifdef HAVE_SESSION_TICKET
+static int TlsxFindByType(WolfSSL_ConstVector* ret, word16 extType,
+    WolfSSL_ConstVector exts)
+{
+    word32 len, idx = 0;
+    word16 type;
+    WolfSSL_ConstVector ext;
+
+    XMEMSET(ret, 0, sizeof(*ret));
+    len = exts.size;
+    /* type + len */
+    while (len >= OPAQUE16_LEN + OPAQUE16_LEN) {
+        ato16(exts.elements + idx, &type);
+        idx += OPAQUE16_LEN;
+        idx += ReadVector16(exts.elements + idx, &ext);
+        if (idx > exts.size)
+            return BUFFER_ERROR;
+        if (type == extType) {
+            XMEMCPY(ret, &ext, sizeof(ext));
+            return 0;
+        }
+        len = exts.size - idx;
+    }
+    return 0;
+}
+
+static int TlsTicketIsValid(WOLFSSL* ssl, WolfSSL_ConstVector exts,
+    byte* isValid)
+{
+    WolfSSL_ConstVector tlsxSessionTicket;
+    byte tempTicket[SESSION_TICKET_LEN];
+    InternalTicket* it;
+    int ret;
+
+    *isValid = 0;
+    ret = TlsxFindByType(&tlsxSessionTicket, TLSX_SESSION_TICKET, exts);
+    if (ret != 0)
+        return ret;
+    if (tlsxSessionTicket.size == 0)
+        return 0;
+    if (tlsxSessionTicket.size > SESSION_TICKET_LEN)
+        return 0;
+    XMEMCPY(tempTicket, tlsxSessionTicket.elements, tlsxSessionTicket.size);
+    ret = DoDecryptTicket(ssl, tempTicket, (word32)tlsxSessionTicket.size, &it);
+    if (ret != WOLFSSL_TICKET_RET_OK && ret != WOLFSSL_TICKET_RET_CREATE)
+        return 0;
+    ForceZero(it, sizeof(InternalTicket));
+    *isValid = 1;
+    return 0;
+}
+#endif /* HAVE_SESSION_TICKET */
+
+static int TlsSessionIdIsValid(WOLFSSL* ssl, WolfSSL_ConstVector sessionID,
+    byte* isValid)
+{
+    WOLFSSL_SESSION* sess;
+    word32 sessRow;
+    int ret;
+
+    *isValid = 0;
+    if (ssl->options.sessionCacheOff)
+        return 0;
+    if (sessionID.size != ID_LEN)
+        return 0;
+#ifdef HAVE_EXT_CACHE
+    {
+
+        if (ssl->ctx->get_sess_cb != NULL) {
+            int unused;
+            sess =
+                ssl->ctx->get_sess_cb(ssl, sessionID.elements, ID_LEN, &unused);
+            if (sess != NULL) {
+                *isValid = 1;
+                wolfSSL_FreeSession(ssl->ctx, sess);
+                return 0;
+            }
+        }
+        if (ssl->ctx->internalCacheLookupOff)
+            return 0;
+    }
+#endif
+    ret = TlsSessionCacheGetAndLock(sessionID.elements, &sess, &sessRow);
+    if (ret == 0 && sess != NULL) {
+        *isValid = 1;
+        TlsSessionCacheUnlockRow(sessRow);
+    }
+
+    return 0;
+}
+
+static int TlsResumptionIsValid(WOLFSSL* ssl, WolfSSL_CH* ch, byte* isValid)
+{
+    int ret;
+
+    *isValid = 0;
+#ifdef HAVE_SESSION_TICKET
+    ret = TlsTicketIsValid(ssl, ch->extension, isValid);
+    if (ret != 0)
+        return ret;
+    if (*isValid)
+        return 0;
+#endif /* HAVE_SESSION_TICKET */
+    ret = TlsSessionIdIsValid(ssl, ch->sessionId, isValid);
+    return ret;
+}
+#endif /* WOLFSSL_DTLS_NO_HVR_ON_RESUME */
+
+int DoClientHelloStateless(WOLFSSL* ssl, const byte* input, word32* inOutIdx,
+    word32 helloSz, byte* process)
+{
+    byte cookie[DTLS_COOKIE_SZ];
+    int ret;
+    WolfSSL_CH ch;
+
+    *process = 1;
+    ret = ParseClientHello(input + *inOutIdx, helloSz, &ch);
+    if (ret != 0)
+        return ret;
+
+#ifdef WOLFSSL_DTLS_NO_HVR_ON_RESUME
+    {
+        byte isValid = 0;
+        ret = TlsResumptionIsValid(ssl, &ch, &isValid);
+        if (ret != 0)
+            return ret;
+        if (isValid)
+            return 0;
+    }
+#endif /* WOLFSSL_DTLS_NO_HVR_ON_RESUME */
+
+    ret = CreateDtlsCookie(ssl, &ch, cookie);
+    if (ret != 0)
+        return ret;
+    if (ch.cookie.size != DTLS_COOKIE_SZ ||
+        XMEMCMP(ch.cookie.elements, cookie, DTLS_COOKIE_SZ) != 0) {
+        *process = 0;
+        ret = SendHelloVerifyRequest(ssl, cookie, DTLS_COOKIE_SZ);
+    }
+
+    return ret;
+}
+#endif /* !defined(NO_WOLFSSL_SERVER) */
+
+#if defined(WOLFSSL_DTLS_CID)
+
+typedef struct ConnectionID {
+    byte length;
+/* Ignore "nonstandard extension used : zero-sized array in struct/union"
+ * MSVC warning */
+#ifdef _MSC_VER
+#pragma warning(disable: 4200)
+#endif
+    byte id[];
+} ConnectionID;
+
+typedef struct CIDInfo {
+    ConnectionID* tx;
+    ConnectionID* rx;
+    byte negotiated : 1;
+} CIDInfo;
+
+static ConnectionID* DtlsCidNew(const byte* cid, byte size, void* heap)
+{
+    ConnectionID* ret;
+
+    ret = (ConnectionID*)XMALLOC(sizeof(ConnectionID) + size, heap,
+        DYNAMIC_TYPE_TLSX);
+    if (ret == NULL)
+        return NULL;
+
+    ret->length = size;
+    XMEMCPY(ret->id, cid, size);
+
+    return ret;
+}
+
+static WC_INLINE CIDInfo* DtlsCidGetInfo(WOLFSSL* ssl)
+{
+    return ssl->dtlsCidInfo;
+}
+
+static int DtlsCidGetSize(WOLFSSL* ssl, unsigned int* size, int rx)
+{
+    ConnectionID* id;
+    CIDInfo* info;
+
+    if (ssl == NULL || size == NULL)
+        return BAD_FUNC_ARG;
+
+    info = DtlsCidGetInfo(ssl);
+    if (info == NULL)
+        return WOLFSSL_FAILURE;
+
+    id = rx ? info->rx : info->tx;
+    if (id == NULL) {
+        *size = 0;
+        return WOLFSSL_SUCCESS;
+    }
+
+    *size = id->length;
+    return WOLFSSL_SUCCESS;
+}
+
+static int DtlsCidGet(WOLFSSL* ssl, unsigned char* buf, int bufferSz, int rx)
+{
+    ConnectionID* id;
+    CIDInfo* info;
+
+    if (ssl == NULL || buf == NULL)
+        return BAD_FUNC_ARG;
+
+    info = DtlsCidGetInfo(ssl);
+    if (info == NULL)
+        return WOLFSSL_FAILURE;
+
+    id = rx ? info->rx : info->tx;
+    if (id == NULL || id->length == 0)
+        return WOLFSSL_SUCCESS;
+
+    if (id->length > bufferSz)
+        return LENGTH_ERROR;
+
+    XMEMCPY(buf, id->id, id->length);
+    return WOLFSSL_SUCCESS;
+}
+
+static CIDInfo* DtlsCidGetInfoFromExt(byte* ext)
+{
+    WOLFSSL** sslPtr;
+    WOLFSSL* ssl;
+
+    if (ext == NULL)
+        return NULL;
+    sslPtr = (WOLFSSL**)ext;
+    ssl = *sslPtr;
+    if (ssl == NULL)
+        return NULL;
+    return ssl->dtlsCidInfo;
+}
+
+static void DtlsCidUnsetInfoFromExt(byte* ext)
+{
+    WOLFSSL** sslPtr;
+    WOLFSSL* ssl;
+
+    if (ext == NULL)
+        return;
+    sslPtr = (WOLFSSL**)ext;
+    ssl = *sslPtr;
+    if (ssl == NULL)
+        return;
+    ssl->dtlsCidInfo = NULL;
+}
+
+void TLSX_ConnectionID_Free(byte* ext, void* heap)
+{
+    CIDInfo* info;
+    (void)heap;
+
+    info = DtlsCidGetInfoFromExt(ext);
+    if (info == NULL)
+        return;
+    if (info->rx != NULL)
+        XFREE(info->rx, heap, DYNAMIC_TYPE_TLSX);
+    if (info->tx != NULL)
+        XFREE(info->tx, heap, DYNAMIC_TYPE_TLSX);
+    XFREE(info, heap, DYNAMIC_TYPE_TLSX);
+    DtlsCidUnsetInfoFromExt(ext);
+    XFREE(ext, heap, DYNAMIC_TYPE_TLSX);
+}
+
+word16 TLSX_ConnectionID_Write(byte* ext, byte* output)
+{
+    CIDInfo* info;
+
+    info = DtlsCidGetInfoFromExt(ext);
+    if (info == NULL)
+        return 0;
+
+    /* empty CID */
+    if (info->rx == NULL) {
+        *output = 0;
+        return OPAQUE8_LEN;
+    }
+
+    *output = info->rx->length;
+    XMEMCPY(output + OPAQUE8_LEN, info->rx->id, info->rx->length);
+    return OPAQUE8_LEN + info->rx->length;
+}
+
+word16 TLSX_ConnectionID_GetSize(byte* ext)
+{
+    CIDInfo* info = DtlsCidGetInfoFromExt(ext);
+    if (info == NULL)
+        return 0;
+    return info->rx == NULL ? OPAQUE8_LEN : OPAQUE8_LEN + info->rx->length;
+}
+
+int TLSX_ConnectionID_Use(WOLFSSL* ssl)
+{
+    CIDInfo* info;
+    WOLFSSL** ext;
+    int ret;
+
+    ext = (WOLFSSL**)TLSX_Find(ssl->extensions, TLSX_CONNECTION_ID);
+    if (ext != NULL)
+        return 0;
+
+    info = (CIDInfo*)XMALLOC(sizeof(CIDInfo), ssl->heap, DYNAMIC_TYPE_TLSX);
+    if (info == NULL)
+        return MEMORY_ERROR;
+    ext = (WOLFSSL**)XMALLOC(sizeof(WOLFSSL**), ssl->heap, DYNAMIC_TYPE_TLSX);
+    if (ext == NULL) {
+        XFREE(info, ssl->heap, DYNAMIC_TYPE_TLSX);
+        return MEMORY_ERROR;
+    }
+    XMEMSET(info, 0, sizeof(CIDInfo));
+    /* CIDInfo needs to be accessed every time we send or receive a record. To
+     * avoid the cost of the extension lookup save a pointer to the structure
+     * inside the SSL object itself, and save a pointer to the SSL object in the
+     * extension. The extension freeing routine uses te pointer to the SSL
+     * object to find the structure and to set ssl->dtlsCidInfo pointer to NULL
+     * after freeing the structure. */
+    ssl->dtlsCidInfo = info;
+    *ext = ssl;
+    ret =
+        TLSX_Push(&ssl->extensions, TLSX_CONNECTION_ID, (void*)ext, ssl->heap);
+    if (ret != 0) {
+        XFREE(info, ssl->heap, DYNAMIC_TYPE_TLSX);
+        XFREE(ext, ssl->heap, DYNAMIC_TYPE_TLSX);
+        ssl->dtlsCidInfo = NULL;
+        return ret;
+    }
+
+    return 0;
+}
+
+int TLSX_ConnectionID_Parse(WOLFSSL* ssl, const byte* input, word16 length,
+    byte isRequest)
+{
+    ConnectionID* id;
+    CIDInfo* info;
+    byte cidSize;
+    TLSX* ext;
+
+    ext = TLSX_Find(ssl->extensions, TLSX_CONNECTION_ID);
+    if (ext == NULL) {
+        /* CID not enabled */
+        if (isRequest) {
+            WOLFSSL_MSG("Received CID ext but it's not enabled, ignoring");
+            return 0;
+        }
+        else {
+            WOLFSSL_MSG("CID ext not requested by the Client, aborting");
+            return UNSUPPORTED_EXTENSION;
+        }
+    }
+
+    info = DtlsCidGetInfo(ssl);
+    if (info == NULL)
+        return BAD_STATE_E;
+
+    /* it may happen if we process two ClientHello because the server sent an
+     * HRR request */
+    if (info->tx != NULL) {
+        if (ssl->options.side != WOLFSSL_SERVER_END &&
+            ssl->options.serverState != SERVER_HELLO_RETRY_REQUEST_COMPLETE)
+            return BAD_STATE_E;
+
+        XFREE(info->tx, ssl->heap, DYNAMIC_TYPE_TLSX);
+        info->tx = NULL;
+    }
+
+    if (length < OPAQUE8_LEN)
+        return BUFFER_ERROR;
+
+    cidSize = *input;
+    if (cidSize + OPAQUE8_LEN > length)
+        return BUFFER_ERROR;
+
+    if (cidSize > 0) {
+        id = (ConnectionID*)XMALLOC(sizeof(*id) + cidSize, ssl->heap,
+            DYNAMIC_TYPE_TLSX);
+        if (id == NULL)
+            return MEMORY_ERROR;
+        XMEMCPY(id->id, input + OPAQUE8_LEN, cidSize);
+        id->length = cidSize;
+        info->tx = id;
+    }
+
+    info->negotiated = 1;
+    if (isRequest)
+        ext->resp = 1;
+
+    return 0;
+}
+
+void DtlsCIDOnExtensionsParsed(WOLFSSL* ssl)
+{
+    CIDInfo* info;
+
+    info = DtlsCidGetInfo(ssl);
+    if (info == NULL)
+        return;
+
+    if (!info->negotiated) {
+        TLSX_Remove(&ssl->extensions, TLSX_CONNECTION_ID, ssl->heap);
+        return;
+    }
+}
+
+byte DtlsCIDCheck(WOLFSSL* ssl, const byte* input, word16 inputSize)
+{
+    CIDInfo* info;
+    info = DtlsCidGetInfo(ssl);
+    if (info == NULL || info->rx == NULL || info->rx->length == 0)
+        return 0;
+    if (inputSize < info->rx->length)
+        return 0;
+    return XMEMCMP(input, info->rx->id, info->rx->length) == 0;
+}
+
+int wolfSSL_dtls_cid_use(WOLFSSL* ssl)
+{
+    int ret;
+
+    /* CID is supported on DTLSv1.3 only */
+    if (!IsAtLeastTLSv1_3(ssl->version))
+        return WOLFSSL_FAILURE;
+
+    ssl->options.useDtlsCID = 1;
+    ret = TLSX_ConnectionID_Use(ssl);
+    if (ret != 0)
+        return ret;
+    return WOLFSSL_SUCCESS;
+}
+
+int wolfSSL_dtls_cid_is_enabled(WOLFSSL* ssl)
+{
+    return DtlsCidGetInfo(ssl) != NULL;
+}
+
+int wolfSSL_dtls_cid_set(WOLFSSL* ssl, unsigned char* cid, unsigned int size)
+{
+    ConnectionID* newCid;
+    CIDInfo* cidInfo;
+
+    if (!ssl->options.useDtlsCID)
+        return WOLFSSL_FAILURE;
+
+    cidInfo = DtlsCidGetInfo(ssl);
+    if (cidInfo == NULL)
+        return WOLFSSL_FAILURE;
+
+    if (cidInfo->rx != NULL) {
+        XFREE(cidInfo->rx, ssl->heap, DYNAMIC_TYPE_TLSX);
+        cidInfo->rx = NULL;
+    }
+
+    /* empty CID */
+    if (size == 0)
+        return WOLFSSL_SUCCESS;
+
+    if (size > DTLS_CID_MAX_SIZE)
+        return LENGTH_ERROR;
+
+    newCid = DtlsCidNew(cid, (byte)size, ssl->heap);
+    if (newCid == NULL)
+        return MEMORY_ERROR;
+    cidInfo->rx = newCid;
+    return WOLFSSL_SUCCESS;
+}
+
+int wolfSSL_dtls_cid_get_rx_size(WOLFSSL* ssl, unsigned int* size)
+{
+    return DtlsCidGetSize(ssl, size, 1);
+}
+
+int wolfSSL_dtls_cid_get_rx(WOLFSSL* ssl, unsigned char* buf,
+    unsigned int bufferSz)
+{
+    return DtlsCidGet(ssl, buf, bufferSz, 1);
+}
+
+int wolfSSL_dtls_cid_get_tx_size(WOLFSSL* ssl, unsigned int* size)
+{
+    return DtlsCidGetSize(ssl, size, 0);
+}
+
+int wolfSSL_dtls_cid_get_tx(WOLFSSL* ssl, unsigned char* buf,
+    unsigned int bufferSz)
+{
+    return DtlsCidGet(ssl, buf, bufferSz, 0);
+}
+
+#endif /* WOLFSSL_DTLS_CID */
+#endif /* WOLFSSL_DTLS */
+
+#endif /* WOLFCRYPT_ONLY */

android/extern/wolfssl/src/include.am

@@ -0,0 +1,764 @@
+# vim:ft=automake
+# included from Top Level Makefile.am
+# All paths should be given relative to the root
+
+FIPS_FILES =					\
+	ctaocrypt/src/fips.c			\
+	ctaocrypt/src/fips_test.c		\
+	wolfcrypt/src/async.c			\
+	wolfcrypt/src/fips.c			\
+	wolfcrypt/src/fips_test.c		\
+	wolfcrypt/src/selftest.c		\
+	wolfcrypt/src/wolfcrypt_first.c		\
+	wolfcrypt/src/wolfcrypt_last.c
+
+BUILT_SOURCES+= $(FIPS_FILES)
+
+MAINTAINERCLEANFILES+= $(FIPS_FILES)
+
+EXTRA_DIST += src/bio.c
+EXTRA_DIST += src/conf.c
+EXTRA_DIST += src/ssl_misc.c
+EXTRA_DIST += src/pk.c
+EXTRA_DIST += src/x509.c
+EXTRA_DIST += src/x509_str.c
+
+$(FIPS_FILES):
+	$(AM_V_at)touch $(srcdir)/$@
+
+if !BUILD_NO_LIBRARY
+lib_LTLIBRARIES+= src/libwolfssl.la
+endif
+src_libwolfssl_la_SOURCES =
+src_libwolfssl_la_LDFLAGS = ${AM_LDFLAGS} -no-undefined -version-info ${WOLFSSL_LIBRARY_VERSION}
+src_libwolfssl_la_LIBADD = $(LIBM) $(LIB_ADD) $(LIB_STATIC_ADD)
+src_libwolfssl_la_CFLAGS = -DBUILDING_WOLFSSL $(AM_CFLAGS) -DLIBWOLFSSL_GLOBAL_EXTRA_CFLAGS="\" $(EXTRA_CFLAGS)\""
+src_libwolfssl_la_CPPFLAGS = -DBUILDING_WOLFSSL $(AM_CPPFLAGS)
+
+# install the packaged IPP libraries
+if BUILD_FAST_RSA
+
+# Link needed IPP libraries
+noinst_SCRIPTS+=IPP_links
+IPP_links:
+	@$(IPPLINK)
+
+ippdir = $(libdir)
+ipp_DATA = $(IPPLIBS)
+
+include_HEADERS+=$(IPPHEADERS)
+endif # BUILD_FAST_RSA
+
+if BUILD_FIPS
+
+if BUILD_FIPS_V1
+# fips first  file
+src_libwolfssl_la_SOURCES += ctaocrypt/src/wolfcrypt_first.c
+
+src_libwolfssl_la_SOURCES += \
+               ctaocrypt/src/hmac.c \
+               ctaocrypt/src/random.c \
+               ctaocrypt/src/sha256.c
+
+if BUILD_RSA
+src_libwolfssl_la_SOURCES += ctaocrypt/src/rsa.c
+endif
+
+if BUILD_AES
+src_libwolfssl_la_SOURCES += ctaocrypt/src/aes.c
+endif
+
+if BUILD_DES3
+src_libwolfssl_la_SOURCES += ctaocrypt/src/des3.c
+endif
+
+if BUILD_SHA
+src_libwolfssl_la_SOURCES += ctaocrypt/src/sha.c
+endif
+
+if BUILD_SHA512
+src_libwolfssl_la_SOURCES += ctaocrypt/src/sha512.c
+endif
+
+src_libwolfssl_la_SOURCES += ctaocrypt/src/fips.c
+src_libwolfssl_la_SOURCES += ctaocrypt/src/fips_test.c
+
+# fips last file
+src_libwolfssl_la_SOURCES += ctaocrypt/src/wolfcrypt_last.c
+endif BUILD_FIPS_V1
+
+if BUILD_FIPS_V2
+# FIPSv2 first file
+src_libwolfssl_la_SOURCES += \
+               wolfcrypt/src/wolfcrypt_first.c
+
+src_libwolfssl_la_SOURCES += \
+               wolfcrypt/src/hmac.c \
+               wolfcrypt/src/random.c \
+               wolfcrypt/src/sha256.c
+
+if BUILD_RSA
+src_libwolfssl_la_SOURCES += wolfcrypt/src/rsa.c
+endif
+
+if BUILD_ECC
+src_libwolfssl_la_SOURCES += wolfcrypt/src/ecc.c
+endif
+
+if BUILD_AES
+src_libwolfssl_la_SOURCES += wolfcrypt/src/aes.c
+endif
+
+if BUILD_AESNI
+src_libwolfssl_la_SOURCES += wolfcrypt/src/aes_asm.S
+if BUILD_X86_ASM
+src_libwolfssl_la_SOURCES += wolfcrypt/src/aes_gcm_x86_asm.S
+else
+src_libwolfssl_la_SOURCES += wolfcrypt/src/aes_gcm_asm.S
+endif
+endif
+
+if BUILD_DES3
+src_libwolfssl_la_SOURCES += wolfcrypt/src/des3.c
+endif
+
+if BUILD_SHA
+src_libwolfssl_la_SOURCES += wolfcrypt/src/sha.c
+endif
+
+if BUILD_INTELASM
+src_libwolfssl_la_SOURCES += wolfcrypt/src/sha256_asm.S
+endif
+
+if BUILD_SHA512
+src_libwolfssl_la_SOURCES += wolfcrypt/src/sha512.c
+if BUILD_INTELASM
+src_libwolfssl_la_SOURCES += wolfcrypt/src/sha512_asm.S
+endif
+endif
+
+if BUILD_SHA3
+src_libwolfssl_la_SOURCES += wolfcrypt/src/sha3.c
+if BUILD_INTELASM
+src_libwolfssl_la_SOURCES += wolfcrypt/src/sha3_asm.S
+endif
+endif
+
+if BUILD_DH
+src_libwolfssl_la_SOURCES += wolfcrypt/src/dh.c
+endif
+
+if BUILD_CMAC
+src_libwolfssl_la_SOURCES += wolfcrypt/src/cmac.c
+endif
+
+src_libwolfssl_la_SOURCES += wolfcrypt/src/fips.c \
+                             wolfcrypt/src/fips_test.c
+
+# fips last file
+src_libwolfssl_la_SOURCES += wolfcrypt/src/wolfcrypt_last.c
+endif BUILD_FIPS_V2
+
+if BUILD_FIPS_RAND
+src_libwolfssl_la_SOURCES += \
+               wolfcrypt/src/wolfcrypt_first.c \
+               wolfcrypt/src/hmac.c \
+               wolfcrypt/src/random.c \
+               wolfcrypt/src/sha256.c \
+               wolfcrypt/src/sha256_asm.S \
+               wolfcrypt/src/fips.c \
+               wolfcrypt/src/fips_test.c \
+               wolfcrypt/src/wolfcrypt_last.c
+endif BUILD_FIPS_RAND
+
+if BUILD_FIPS_V5
+# FIPS 140-3 first file
+src_libwolfssl_la_SOURCES += \
+               wolfcrypt/src/wolfcrypt_first.c
+
+src_libwolfssl_la_SOURCES += \
+               wolfcrypt/src/hmac.c \
+               wolfcrypt/src/random.c
+
+src_libwolfssl_la_SOURCES += wolfcrypt/src/kdf.c
+
+if BUILD_RSA
+src_libwolfssl_la_SOURCES += wolfcrypt/src/rsa.c
+endif
+
+if BUILD_ECC
+src_libwolfssl_la_SOURCES += wolfcrypt/src/ecc.c
+endif
+
+if BUILD_AES
+src_libwolfssl_la_SOURCES += wolfcrypt/src/aes.c
+if BUILD_ARMASM
+src_libwolfssl_la_SOURCES += wolfcrypt/src/port/arm/armv8-aes.c
+if !BUILD_ARMASM_CRYPTO
+src_libwolfssl_la_SOURCES += wolfcrypt/src/port/arm/armv8-32-aes-asm.S
+endif
+endif
+endif
+
+if BUILD_AESNI
+src_libwolfssl_la_SOURCES += wolfcrypt/src/aes_asm.S
+if BUILD_X86_ASM
+src_libwolfssl_la_SOURCES += wolfcrypt/src/aes_gcm_x86_asm.S
+else
+src_libwolfssl_la_SOURCES += wolfcrypt/src/aes_gcm_asm.S
+endif
+endif
+
+if BUILD_SHA
+src_libwolfssl_la_SOURCES += wolfcrypt/src/sha.c
+endif
+
+if BUILD_ARMASM
+src_libwolfssl_la_SOURCES += wolfcrypt/src/port/arm/armv8-sha256.c
+if BUILD_ARMASM_INLINE
+src_libwolfssl_la_SOURCES += wolfcrypt/src/port/arm/armv8-32-sha256-asm_c.c
+else
+src_libwolfssl_la_SOURCES += wolfcrypt/src/port/arm/armv8-32-sha256-asm.S
+endif
+else
+src_libwolfssl_la_SOURCES += wolfcrypt/src/sha256.c
+if BUILD_INTELASM
+src_libwolfssl_la_SOURCES += wolfcrypt/src/sha256_asm.S
+endif
+endif
+
+if BUILD_SHA512
+if BUILD_ARMASM
+src_libwolfssl_la_SOURCES += wolfcrypt/src/port/arm/armv8-sha512.c
+if BUILD_ARMASM_INLINE
+src_libwolfssl_la_SOURCES += wolfcrypt/src/port/arm/armv8-sha512-asm_c.c
+src_libwolfssl_la_SOURCES += wolfcrypt/src/port/arm/armv8-32-sha512-asm_c.c
+else
+src_libwolfssl_la_SOURCES += wolfcrypt/src/port/arm/armv8-sha512-asm.S
+src_libwolfssl_la_SOURCES += wolfcrypt/src/port/arm/armv8-32-sha512-asm.S
+endif
+else
+src_libwolfssl_la_SOURCES += wolfcrypt/src/sha512.c
+if BUILD_INTELASM
+src_libwolfssl_la_SOURCES += wolfcrypt/src/sha512_asm.S
+endif
+endif
+endif
+
+if BUILD_SHA3
+src_libwolfssl_la_SOURCES += wolfcrypt/src/sha3.c
+if BUILD_ARMASM
+if BUILD_ARMASM_INLINE
+src_libwolfssl_la_SOURCES += wolfcrypt/src/port/arm/armv8-sha3-asm_c.c
+else
+src_libwolfssl_la_SOURCES += wolfcrypt/src/port/arm/armv8-sha3-asm.S
+endif
+endif
+if BUILD_INTELASM
+src_libwolfssl_la_SOURCES += wolfcrypt/src/sha3_asm.S
+endif
+endif
+
+if BUILD_DH
+src_libwolfssl_la_SOURCES += wolfcrypt/src/dh.c
+endif
+
+if BUILD_CMAC
+src_libwolfssl_la_SOURCES += wolfcrypt/src/cmac.c
+endif
+
+src_libwolfssl_la_SOURCES += wolfcrypt/src/fips.c \
+                             wolfcrypt/src/fips_test.c
+
+# fips last file
+src_libwolfssl_la_SOURCES += wolfcrypt/src/wolfcrypt_last.c
+endif BUILD_FIPS_V5
+
+endif BUILD_FIPS
+
+# For wolfRand, exclude everything else.
+if !BUILD_FIPS_RAND
+
+# For FIPSV2, exclude the wolfCrypt files included above.
+# For wolfRand, exclude just a couple files.
+# For old FIPS, keep the wolfCrypt versions of the
+# CtaoCrypt files included above.
+if !BUILD_FIPS_CURRENT
+if BUILD_HMAC
+src_libwolfssl_la_SOURCES += wolfcrypt/src/hmac.c
+endif
+endif !BUILD_FIPS_CURRENT
+
+# CAVP self test
+if BUILD_SELFTEST
+src_libwolfssl_la_SOURCES += wolfcrypt/src/selftest.c
+endif
+
+endif !BUILD_FIPS_RAND
+
+src_libwolfssl_la_SOURCES += wolfcrypt/src/hash.c
+
+if !BUILD_DO178
+src_libwolfssl_la_SOURCES += wolfcrypt/src/cpuid.c
+endif !BUILD_DO178
+
+if !BUILD_FIPS_RAND
+
+if !BUILD_FIPS_V5
+if BUILD_KDF
+src_libwolfssl_la_SOURCES += wolfcrypt/src/kdf.c
+endif
+endif !BUILD_FIPS_V5
+
+if !BUILD_FIPS_CURRENT
+if BUILD_RNG
+src_libwolfssl_la_SOURCES += wolfcrypt/src/random.c
+endif
+endif !BUILD_FIPS_CURRENT
+
+if !BUILD_FIPS_CURRENT
+src_libwolfssl_la_SOURCES += wolfcrypt/src/sha256.c
+if BUILD_ARMASM
+src_libwolfssl_la_SOURCES += wolfcrypt/src/port/arm/armv8-sha256.c
+if BUILD_ARMASM_INLINE
+src_libwolfssl_la_SOURCES += wolfcrypt/src/port/arm/armv8-32-sha256-asm_c.c
+else
+src_libwolfssl_la_SOURCES += wolfcrypt/src/port/arm/armv8-32-sha256-asm.S
+endif
+else
+if BUILD_INTELASM
+src_libwolfssl_la_SOURCES += wolfcrypt/src/sha256_asm.S
+endif
+endif
+endif !BUILD_FIPS_CURRENT
+
+if BUILD_AFALG
+src_libwolfssl_la_SOURCES += wolfcrypt/src/port/af_alg/afalg_hash.c
+endif
+
+if BUILD_KCAPI
+src_libwolfssl_la_SOURCES += wolfcrypt/src/port/kcapi/kcapi_aes.c
+src_libwolfssl_la_SOURCES += wolfcrypt/src/port/kcapi/kcapi_hash.c
+src_libwolfssl_la_SOURCES += wolfcrypt/src/port/kcapi/kcapi_hmac.c
+src_libwolfssl_la_SOURCES += wolfcrypt/src/port/kcapi/kcapi_ecc.c
+src_libwolfssl_la_SOURCES += wolfcrypt/src/port/kcapi/kcapi_rsa.c
+src_libwolfssl_la_SOURCES += wolfcrypt/src/port/kcapi/kcapi_dh.c
+endif
+
+if BUILD_WOLFEVENT
+src_libwolfssl_la_SOURCES += wolfcrypt/src/wolfevent.c
+endif
+
+if BUILD_ASYNCCRYPT
+src_libwolfssl_la_SOURCES += wolfcrypt/src/async.c
+endif
+
+if !BUILD_USER_RSA
+if BUILD_RSA
+if BUILD_FAST_RSA
+src_libwolfssl_la_SOURCES += wolfcrypt/user-crypto/src/rsa.c
+else
+if !BUILD_FIPS_CURRENT
+src_libwolfssl_la_SOURCES += wolfcrypt/src/rsa.c
+endif !BUILD_FIPS_CURRENT
+endif
+endif
+endif
+
+if BUILD_RC2
+src_libwolfssl_la_SOURCES += wolfcrypt/src/rc2.c
+endif
+
+if BUILD_SP
+if BUILD_SP_C32
+src_libwolfssl_la_SOURCES += wolfcrypt/src/sp_c32.c
+endif
+if BUILD_SP_C64
+src_libwolfssl_la_SOURCES += wolfcrypt/src/sp_c64.c
+endif
+
+if BUILD_SP_X86_64
+src_libwolfssl_la_SOURCES += wolfcrypt/src/sp_x86_64.c
+src_libwolfssl_la_SOURCES += wolfcrypt/src/sp_x86_64_asm.S
+endif
+if !BUILD_FIPS_V2
+if BUILD_SP_ARM32
+src_libwolfssl_la_SOURCES += wolfcrypt/src/sp_arm32.c
+endif
+endif
+if BUILD_SP_ARM_THUMB
+src_libwolfssl_la_SOURCES += wolfcrypt/src/sp_armthumb.c
+endif
+if !BUILD_FIPS_V2
+if BUILD_SP_ARM64
+src_libwolfssl_la_SOURCES += wolfcrypt/src/sp_arm64.c
+endif
+endif
+if BUILD_SP_ARM_CORTEX
+src_libwolfssl_la_SOURCES += wolfcrypt/src/sp_cortexm.c
+endif
+endif BUILD_SP
+if BUILD_SP_INT
+src_libwolfssl_la_SOURCES += wolfcrypt/src/sp_int.c
+endif
+
+if !BUILD_FIPS_CURRENT
+if BUILD_AES
+src_libwolfssl_la_SOURCES += wolfcrypt/src/aes.c
+if BUILD_ARMASM
+src_libwolfssl_la_SOURCES += wolfcrypt/src/port/arm/armv8-aes.c
+if !BUILD_ARMASM_CRYPTO
+src_libwolfssl_la_SOURCES += wolfcrypt/src/port/arm/armv8-32-aes-asm.S
+endif !BUILD_ARMASM_CRYPTO
+endif BUILD_ARMASM
+if BUILD_AFALG
+src_libwolfssl_la_SOURCES += wolfcrypt/src/port/af_alg/afalg_aes.c
+endif
+endif BUILD_AES
+endif !BUILD_FIPS_CURRENT
+
+if !BUILD_FIPS_CURRENT
+if BUILD_CMAC
+src_libwolfssl_la_SOURCES += wolfcrypt/src/cmac.c
+endif
+endif !BUILD_FIPS_CURRENT
+
+if !BUILD_FIPS_V2
+if BUILD_DES3
+src_libwolfssl_la_SOURCES += wolfcrypt/src/des3.c
+endif BUILD_DES3
+endif !BUILD_FIPS_V2
+
+if !BUILD_FIPS_CURRENT
+if BUILD_SHA
+src_libwolfssl_la_SOURCES += wolfcrypt/src/sha.c
+endif
+endif !BUILD_FIPS_CURRENT
+
+if !BUILD_FIPS_CURRENT
+if BUILD_SHA512
+if BUILD_ARMASM
+src_libwolfssl_la_SOURCES += wolfcrypt/src/port/arm/armv8-sha512.c
+if BUILD_ARMASM_INLINE
+src_libwolfssl_la_SOURCES += wolfcrypt/src/port/arm/armv8-sha512-asm_c.c
+src_libwolfssl_la_SOURCES += wolfcrypt/src/port/arm/armv8-32-sha512-asm_c.c
+else
+src_libwolfssl_la_SOURCES += wolfcrypt/src/port/arm/armv8-sha512-asm.S
+src_libwolfssl_la_SOURCES += wolfcrypt/src/port/arm/armv8-32-sha512-asm.S
+endif
+else
+src_libwolfssl_la_SOURCES += wolfcrypt/src/sha512.c
+if BUILD_INTELASM
+src_libwolfssl_la_SOURCES += wolfcrypt/src/sha512_asm.S
+endif
+endif
+endif
+endif !BUILD_FIPS_CURRENT
+
+if !BUILD_FIPS_CURRENT
+if BUILD_SHA3
+src_libwolfssl_la_SOURCES += wolfcrypt/src/sha3.c
+if BUILD_ARMASM
+if BUILD_ARMASM_INLINE
+src_libwolfssl_la_SOURCES += wolfcrypt/src/port/arm/armv8-sha3-asm_c.c
+else
+src_libwolfssl_la_SOURCES += wolfcrypt/src/port/arm/armv8-sha3-asm.S
+endif
+endif
+if BUILD_INTELASM
+src_libwolfssl_la_SOURCES += wolfcrypt/src/sha3_asm.S
+endif
+endif
+endif !BUILD_FIPS_CURRENT
+
+endif !BUILD_FIPS_RAND
+
+if BUILD_SIPHASH
+src_libwolfssl_la_SOURCES += wolfcrypt/src/siphash.c
+endif
+
+src_libwolfssl_la_SOURCES += \
+               wolfcrypt/src/logging.c \
+               wolfcrypt/src/wc_port.c
+
+if BUILD_ERROR_STRINGS
+src_libwolfssl_la_SOURCES += wolfcrypt/src/error.c
+endif
+
+if !BUILD_FIPS_RAND
+if !BUILD_DO178
+src_libwolfssl_la_SOURCES += \
+               wolfcrypt/src/wc_encrypt.c \
+               wolfcrypt/src/signature.c
+endif !BUILD_DO178
+src_libwolfssl_la_SOURCES += wolfcrypt/src/wolfmath.c
+endif !BUILD_FIPS_RAND
+
+if BUILD_MEMORY
+src_libwolfssl_la_SOURCES += wolfcrypt/src/memory.c
+endif
+
+if !BUILD_FIPS_RAND
+if !BUILD_FIPS_CURRENT
+if BUILD_DH
+src_libwolfssl_la_SOURCES += wolfcrypt/src/dh.c
+endif
+endif
+
+if BUILD_ASN
+src_libwolfssl_la_SOURCES += wolfcrypt/src/asn.c
+endif
+
+endif !BUILD_FIPS_RAND
+
+if BUILD_CODING
+src_libwolfssl_la_SOURCES += wolfcrypt/src/coding.c
+endif
+
+if !BUILD_FIPS_RAND
+
+if BUILD_POLY1305
+if BUILD_ARMASM
+src_libwolfssl_la_SOURCES += wolfcrypt/src/port/arm/armv8-poly1305.c
+endif
+src_libwolfssl_la_SOURCES += wolfcrypt/src/poly1305.c
+if BUILD_INTELASM
+src_libwolfssl_la_SOURCES += wolfcrypt/src/poly1305_asm.S
+endif
+endif
+
+if BUILD_RC4
+src_libwolfssl_la_SOURCES += wolfcrypt/src/arc4.c
+endif
+
+if BUILD_MD4
+src_libwolfssl_la_SOURCES += wolfcrypt/src/md4.c
+endif
+
+if BUILD_MD5
+src_libwolfssl_la_SOURCES += wolfcrypt/src/md5.c
+endif
+
+if BUILD_PWDBASED
+src_libwolfssl_la_SOURCES += wolfcrypt/src/pwdbased.c
+src_libwolfssl_la_SOURCES += wolfcrypt/src/pkcs12.c
+endif
+
+if BUILD_DSA
+src_libwolfssl_la_SOURCES += wolfcrypt/src/dsa.c
+endif
+
+if !BUILD_FIPS_CURRENT
+if BUILD_AESNI
+src_libwolfssl_la_SOURCES += wolfcrypt/src/aes_asm.S
+if BUILD_X86_ASM
+src_libwolfssl_la_SOURCES += wolfcrypt/src/aes_gcm_x86_asm.S
+else
+src_libwolfssl_la_SOURCES += wolfcrypt/src/aes_gcm_asm.S
+endif
+endif
+endif
+
+if BUILD_CAMELLIA
+src_libwolfssl_la_SOURCES += wolfcrypt/src/camellia.c
+endif
+
+if BUILD_MD2
+src_libwolfssl_la_SOURCES += wolfcrypt/src/md2.c
+endif
+
+if BUILD_RIPEMD
+src_libwolfssl_la_SOURCES += wolfcrypt/src/ripemd.c
+endif
+
+if BUILD_BLAKE2
+src_libwolfssl_la_SOURCES += wolfcrypt/src/blake2b.c
+endif
+if BUILD_BLAKE2S
+src_libwolfssl_la_SOURCES += wolfcrypt/src/blake2s.c
+endif
+
+if BUILD_CHACHA
+if BUILD_ARMASM
+src_libwolfssl_la_SOURCES += wolfcrypt/src/port/arm/armv8-chacha.c
+else
+src_libwolfssl_la_SOURCES += wolfcrypt/src/chacha.c
+if BUILD_INTELASM
+src_libwolfssl_la_SOURCES += wolfcrypt/src/chacha_asm.S
+endif
+endif
+if BUILD_POLY1305
+src_libwolfssl_la_SOURCES += wolfcrypt/src/chacha20_poly1305.c
+endif
+endif
+
+if !BUILD_INLINE
+src_libwolfssl_la_SOURCES += wolfcrypt/src/misc.c
+endif
+
+if BUILD_FASTMATH
+src_libwolfssl_la_SOURCES += wolfcrypt/src/tfm.c
+endif
+
+if BUILD_HEAPMATH
+src_libwolfssl_la_SOURCES += wolfcrypt/src/integer.c
+endif
+
+if !BUILD_FIPS_CURRENT
+if BUILD_ECC
+src_libwolfssl_la_SOURCES += wolfcrypt/src/ecc.c
+endif
+if BUILD_ECCSI
+src_libwolfssl_la_SOURCES += wolfcrypt/src/eccsi.c
+endif
+if BUILD_SAKKE
+src_libwolfssl_la_SOURCES += wolfcrypt/src/sakke.c
+endif
+endif
+
+if !BUILD_FIPS_CURRENT
+if BUILD_WC_KYBER
+src_libwolfssl_la_SOURCES += wolfcrypt/src/wc_kyber.c
+src_libwolfssl_la_SOURCES += wolfcrypt/src/wc_kyber_poly.c
+if BUILD_INTELASM
+src_libwolfssl_la_SOURCES += wolfcrypt/src/wc_kyber_asm.S
+endif
+endif
+endif
+
+if BUILD_CURVE25519
+src_libwolfssl_la_SOURCES += wolfcrypt/src/curve25519.c
+endif
+
+if BUILD_ED25519
+src_libwolfssl_la_SOURCES += wolfcrypt/src/ed25519.c
+endif
+
+if BUILD_FEMATH
+if BUILD_CURVE25519_SMALL
+src_libwolfssl_la_SOURCES += wolfcrypt/src/fe_low_mem.c
+else
+if BUILD_INTELASM
+src_libwolfssl_la_SOURCES += wolfcrypt/src/fe_x25519_asm.S
+else
+if BUILD_ARMASM
+if BUILD_ARMASM_INLINE
+src_libwolfssl_la_SOURCES += wolfcrypt/src/port/arm/armv8-32-curve25519_c.c
+src_libwolfssl_la_SOURCES += wolfcrypt/src/port/arm/armv8-curve25519_c.c
+else
+src_libwolfssl_la_SOURCES += wolfcrypt/src/port/arm/armv8-32-curve25519.S
+src_libwolfssl_la_SOURCES += wolfcrypt/src/port/arm/armv8-curve25519.S
+endif
+else
+src_libwolfssl_la_SOURCES += wolfcrypt/src/fe_operations.c
+endif
+endif
+endif
+endif
+
+if BUILD_GEMATH
+if BUILD_ED25519_SMALL
+src_libwolfssl_la_SOURCES += wolfcrypt/src/ge_low_mem.c
+else
+src_libwolfssl_la_SOURCES += wolfcrypt/src/ge_operations.c
+if !BUILD_FEMATH
+if BUILD_INTELASM
+src_libwolfssl_la_SOURCES += wolfcrypt/src/fe_x25519_asm.S
+else
+if BUILD_ARMASM
+if BUILD_ARMASM_INLINE
+src_libwolfssl_la_SOURCES += wolfcrypt/src/port/arm/armv8-curve25519_c.c
+else
+src_libwolfssl_la_SOURCES += wolfcrypt/src/port/arm/armv8-curve25519.S
+endif
+else
+src_libwolfssl_la_SOURCES += wolfcrypt/src/fe_operations.c
+endif
+endif
+endif
+endif
+endif
+
+if BUILD_CURVE448
+src_libwolfssl_la_SOURCES += wolfcrypt/src/curve448.c
+endif
+
+if BUILD_ED448
+src_libwolfssl_la_SOURCES += wolfcrypt/src/ed448.c
+endif
+
+if BUILD_FE448
+src_libwolfssl_la_SOURCES += wolfcrypt/src/fe_448.c
+endif
+
+if BUILD_GE448
+src_libwolfssl_la_SOURCES += wolfcrypt/src/ge_448.c
+if !BUILD_FE448
+src_libwolfssl_la_SOURCES += wolfcrypt/src/fe_448.c
+endif
+endif
+
+if BUILD_LIBOQS
+src_libwolfssl_la_SOURCES += wolfcrypt/src/falcon.c
+src_libwolfssl_la_SOURCES += wolfcrypt/src/dilithium.c
+src_libwolfssl_la_SOURCES += wolfcrypt/src/sphincs.c
+src_libwolfssl_la_SOURCES += wolfcrypt/src/ext_kyber.c
+endif
+
+if BUILD_LIBZ
+src_libwolfssl_la_SOURCES += wolfcrypt/src/compress.c
+endif
+
+if BUILD_PKCS7
+src_libwolfssl_la_SOURCES += wolfcrypt/src/pkcs7.c
+endif
+
+if BUILD_SRP
+src_libwolfssl_la_SOURCES += wolfcrypt/src/srp.c
+endif
+
+if BUILD_AFALG
+src_libwolfssl_la_SOURCES += wolfcrypt/src/port/af_alg/wc_afalg.c
+endif
+
+if !BUILD_CRYPTONLY
+# ssl files
+src_libwolfssl_la_SOURCES += \
+               src/internal.c \
+               src/wolfio.c \
+               src/keys.c \
+               src/ssl.c \
+               src/tls.c
+
+if BUILD_TLS13
+src_libwolfssl_la_SOURCES += src/tls13.c
+endif
+
+if BUILD_OCSP
+src_libwolfssl_la_SOURCES += src/ocsp.c
+endif
+
+if BUILD_CRL
+src_libwolfssl_la_SOURCES += src/crl.c
+endif
+
+if BUILD_SNIFFER
+src_libwolfssl_la_SOURCES += src/sniffer.c
+endif
+
+if BUILD_DTLS13
+src_libwolfssl_la_SOURCES += src/dtls13.c
+endif
+
+if BUILD_QUIC
+src_libwolfssl_la_SOURCES += src/quic.c
+endif
+
+if BUILD_DTLS
+src_libwolfssl_la_SOURCES += src/dtls.c
+endif
+
+endif !BUILD_CRYPTONLY
+
+
+endif !BUILD_FIPS_RAND

android/extern/wolfssl/src/ssl_misc.c

@@ -0,0 +1,296 @@
+/* ssl_misc.c
+ *
+ * Copyright (C) 2006-2022 wolfSSL Inc.
+ *
+ * This file is part of wolfSSL.
+ *
+ * wolfSSL is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * wolfSSL is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA
+ */
+
+#ifdef HAVE_CONFIG_H
+    #include <config.h>
+#endif
+
+#include <wolfssl/wolfcrypt/settings.h>
+
+#if !defined(WOLFSSL_SSL_MISC_INCLUDED)
+    #ifndef WOLFSSL_IGNORE_FILE_WARN
+        #warning ssl_misc.c does not need to be compiled separately from ssl.c
+    #endif
+#else
+
+#if defined(OPENSSL_EXTRA) && !defined(WOLFCRYPT_ONLY)
+#ifndef NO_BIO
+
+#ifdef WOLFSSL_NO_FSEEK
+/* Amount of memory to allocate/add. */
+#define READ_BIO_FILE_CHUNK     128
+
+/* Read a file in chunks.
+ *
+ * Allocates a chunk and reads into it until it is full.
+ *
+ * @param [in, out] bio   BIO object to read with.
+ * @param [out]     data  Read data in a new buffer.
+ * @return  Negative on error.
+ * @return  Number of bytes read on success.
+ */
+static int wolfssl_read_bio_file(WOLFSSL_BIO* bio, char** data)
+{
+    int ret = 0;
+    char* mem;
+    char* p;
+
+    /* Allocate buffer to hold a chunk of data. */
+    mem = (char*)XMALLOC(READ_BIO_FILE_CHUNK, bio->heap, DYNAMIC_TYPE_OPENSSL);
+    if (mem == NULL) {
+        WOLFSSL_ERROR_MSG("Memory allocation error");
+        ret = MEMORY_E;
+    }
+
+    if (ret == 0) {
+        int sz;
+
+        /* ret is the number of bytes read and is zero. */
+
+        /* p is where to read in next chunk. */
+        p = mem;
+        /* Memory available to read into is one chunk. */
+        sz = READ_BIO_FILE_CHUNK;
+        /* Keep reading in chunks until no more or an error. */
+        while ((sz = wolfSSL_BIO_read(bio, p, sz)) > 0) {
+            int remaining;
+
+            /* Update total read. */
+            ret += sz;
+            /* Calculate remaining unused memory. */
+            remaining = READ_BIO_FILE_CHUNK - (ret % READ_BIO_FILE_CHUNK);
+            /* Check for space remaining. */
+            if (remaining != READ_BIO_FILE_CHUNK) {
+                /* Update where data is read into. */
+                p += sz;
+                /* Maximum possible size is the remaining buffer size. */
+                sz = remaining;
+            }
+            else {
+                /* No space left for more data to be read - add a chunk. */
+                p = (char*)XREALLOC(mem, ret + READ_BIO_FILE_CHUNK, bio->heap,
+                    DYNAMIC_TYPE_OPENSSL);
+                if (p == NULL) {
+                    sz = MEMORY_E;
+                    break;
+                }
+
+                /* Set mem to new pointer. */
+                mem = p;
+                /* Set p to where to read in next chunk. */
+                p += ret;
+                /* Read in a new chunk. */
+                sz = READ_BIO_FILE_CHUNK;
+            }
+        }
+        if ((sz < 0) || (ret == 0)) {
+            /* Dispose of memory on error or no data read. */
+            XFREE(mem, bio->heap, DYNAMIC_TYPE_OPENSSL);
+            mem = NULL;
+            /* Return error. */
+            ret = sz;
+        }
+    }
+
+    *data = mem;
+    return ret;
+}
+#endif
+
+/* Read exactly the required amount into a newly allocated buffer.
+ *
+ * @param [in, out] bio   BIO object to read with.
+ * @param [in       sz    Amount of data to read.
+ * @param [out]     data  Read data in a new buffer.
+ * @return  Negative on error.
+ * @return  Number of bytes read on success.
+ */
+static int wolfssl_read_bio_len(WOLFSSL_BIO* bio, int sz, char** data)
+{
+    int ret = 0;
+    char* mem;
+
+    /* Allocate buffer to hold data. */
+    mem = (char*)XMALLOC(sz, bio->heap, DYNAMIC_TYPE_OPENSSL);
+    if (mem == NULL) {
+        WOLFSSL_ERROR_MSG("Memory allocation error");
+        ret = MEMORY_E;
+    }
+    else if ((ret = wolfSSL_BIO_read(bio, mem, sz)) != sz) {
+        /* Pending data not read. */
+        XFREE(mem, bio->heap, DYNAMIC_TYPE_OPENSSL);
+        mem = NULL;
+        ret = MEMORY_E;
+    }
+
+    *data = mem;
+    return ret;
+}
+
+/* Read all the data from a BIO.
+ *
+ * @param [in, out] bio         BIO object to read with.
+ * @param [out]     data        Read data in a buffer.
+ * @param [out]     dataSz      Amount of data read in bytes.
+ * @param [out]     memAlloced  Indicates whether return buffer was allocated.
+ * @return  Negative on error.
+ * @return  0 on success.
+ */
+static int wolfssl_read_bio(WOLFSSL_BIO* bio, char** data, int* dataSz,
+    int* memAlloced)
+{
+    int ret;
+    int sz;
+
+    if (bio->type == WOLFSSL_BIO_MEMORY) {
+        ret = wolfSSL_BIO_get_mem_data(bio, data);
+        if (ret > 0) {
+            bio->rdIdx += ret;
+        }
+        *memAlloced = 0;
+    }
+#ifndef WOLFSSL_NO_FSEEK
+    /* Get pending or, when a file BIO, get length of file. */
+    else if ((sz = wolfSSL_BIO_get_len(bio)) > 0) {
+        ret = wolfssl_read_bio_len(bio, sz, data);
+        if (ret > 0) {
+            *memAlloced = 1;
+        }
+    }
+#else
+    else if ((sz = wolfSSL_BIO_pending(bio)) > 0) {
+        ret = wolfssl_read_bio_len(bio, sz, data);
+        if (ret > 0) {
+            *memAlloced = 1;
+        }
+    }
+    else if (bio->type == WOLFSSL_BIO_FILE) {
+        ret = wolfssl_read_bio_file(bio, data);
+        if (ret > 0) {
+            *memAlloced = 1;
+        }
+    }
+#endif
+    else {
+        WOLFSSL_ERROR_MSG("No data read from bio");
+        *memAlloced = 0;
+        ret = NOT_COMPILED_IN;
+    }
+
+    if (ret >= 0) {
+        *dataSz = ret;
+        ret = 0;
+    }
+
+    return ret;
+}
+#endif /* !NO_BIO */
+
+#if !defined(NO_FILESYSTEM)
+/* Read all the data from a file.
+ *
+ * @param [in]  fp          File pointer to read with.
+ * @param [out] fileSz      Amount of data remaining in file in bytes.
+ * @return  WOLFSSL_BAD_FILE on error.
+ * @return  0 on success.
+ */
+static int wolfssl_file_len(XFILE fp, long* fileSz)
+{
+    int ret = 0;
+    long sz = 0;
+    long curr = 0;
+
+    if (fp == XBADFILE) {
+        ret = WOLFSSL_BAD_FILE;
+    }
+    if (ret == 0) {
+        /* Get file offset at end of file. */
+        curr = (long)XFTELL(fp);
+        if (curr < 0) {
+            ret = WOLFSSL_BAD_FILE;
+        }
+    }
+    /* Move to end of file. */
+    if ((ret == 0) && (XFSEEK(fp, 0, SEEK_END) != 0)) {
+        ret = WOLFSSL_BAD_FILE;
+    }
+    if (ret == 0) {
+        /* Get file offset at end of file and subtract current offset. */
+        sz = (long)XFTELL(fp) - curr;
+        if (sz < 0) {
+            ret = WOLFSSL_BAD_FILE;
+        }
+    }
+    /* Go back to original offset in file. */
+    if ((ret == 0) && (XFSEEK(fp, curr, SEEK_SET) != 0)) {
+        ret = WOLFSSL_BAD_FILE;
+    }
+    /* Validate size. */
+    if ((ret == 0) && ((sz > MAX_WOLFSSL_FILE_SIZE) || (sz <= 0L))) {
+        ret = WOLFSSL_BAD_FILE;
+    }
+    if (ret == 0) {
+        *fileSz = sz;
+    }
+
+    return ret;
+}
+
+/* Read all the data from a file.
+ *
+ * @param [in]  fp          File pointer to read with.
+ * @param [out] data        Read data in an allocated buffer.
+ * @param [out] dataSz      Amount of data read in bytes.
+ * @return  WOLFSSL_BAD_FILE when reading fails.
+ * @return  MEMORY_E when memory allocation fails.
+ * @return  0 on success.
+ */
+static int wolfssl_read_file(XFILE fp, char** data, int* dataSz)
+{
+    int ret = 0;
+    long sz = 0;
+    char* mem = NULL;
+
+    ret = wolfssl_file_len(fp, &sz);
+    if (ret == 0) {
+        /* Allocate memory big enough to hold whole file. */
+        mem = (char*)XMALLOC(sz, NULL, DYNAMIC_TYPE_TMP_BUFFER);
+        if (mem == NULL) {
+            ret = MEMORY_E;
+        }
+    }
+    /* Read whole file into new buffer. */
+    if ((ret == 0) && ((int)XFREAD(mem, 1, sz, fp) != sz)) {
+        ret = WOLFSSL_BAD_FILE;
+    }
+    if (ret == 0) {
+        *dataSz = (int)sz;
+        *data = mem;
+        mem = NULL;
+    }
+
+    XFREE(mem, NULL, DYNAMIC_TYPE_TMP_BUFFER);
+    return ret;
+}
+#endif /* !NO_FILESYSTEM */
+#endif /* OPENSSL_EXTRA && !WOLFCRYPT_ONLY */
+#endif /* !WOLFSSL_SSL_MISC_INCLUDED */
+