o Initial import.HEADmaster

121 files changed, 26322 insertions, 0 deletions

diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_aes.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_aes.c
new file mode 100644
index 0000000..66de4bb
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_aes.c
@@ -0,0 +1,887 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#include "sdk_common.h"
+#include <drivers/nrfx_common.h>
+#if NRF_MODULE_ENABLED(NRF_CRYPTO)
+
+#include <stdbool.h>
+#include "ssi_aes_error.h"
+#include "cc310_backend_aes.h"
+#include "cc310_backend_mutex.h"
+#include "cc310_backend_shared.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_CC310_AES)
+
+/**@internal @brief Type declarations of templates matching all possible context sizes
+ *                  for this backend.
+ */
+typedef struct
+{
+    nrf_crypto_aes_internal_context_t header;   /**< Common header for context. */
+    SaSiAesUserContext_t              context;  /**< AES context internal to mbed TLS. */
+    nrf_crypto_backend_aes_ctx_t      backend;  /**< Backend-specific internal context. */
+} nrf_crypto_backend_cc310_aes_any_context_t;
+
+/**@internal @brief Type declarations of templates matching all possible context sizes
+ *                  for this backend.
+ */
+typedef union
+{
+    nrf_crypto_backend_cc310_aes_any_context_t any;      /**< Common for all contexts. */
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_AES_ECB)
+    nrf_crypto_backend_aes_ecb_context_t ecb;
+#endif
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_AES_CBC)
+    nrf_crypto_backend_aes_cbc_context_t cbc;
+#endif
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_AES_CTR)
+    nrf_crypto_backend_aes_ctr_context_t ctr;
+#endif
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_AES_CBC_MAC)
+    nrf_crypto_backend_aes_cbc_mac_context_t cbc_mac;
+#endif
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_AES_CMAC)
+    nrf_crypto_backend_aes_cmac_context_t cmac;
+#endif
+} nrf_crypto_backend_cc310_aes_context_t;
+
+
+static ret_code_t result_get(SaSiError_t error)
+{
+    ret_code_t ret_val;
+    switch (error)
+    {
+        case SASI_SUCCESS:
+            ret_val = NRF_SUCCESS;
+            break;
+
+        case SASI_AES_INVALID_USER_CONTEXT_POINTER_ERROR:
+            ret_val = NRF_ERROR_CRYPTO_CONTEXT_NULL;
+            break;
+
+        case SASI_AES_ILLEGAL_KEY_SIZE_ERROR:
+        case SASI_AES_DATA_IN_SIZE_ILLEGAL:
+        case SASI_AES_DATA_IN_BUFFER_SIZE_ERROR:
+            ret_val = NRF_ERROR_CRYPTO_INPUT_LENGTH;
+            break;
+
+        case SASI_AES_INVALID_IV_OR_TWEAK_PTR_ERROR:
+        case SASI_AES_INVALID_KEY_POINTER_ERROR:
+        case SASI_AES_DATA_IN_POINTER_INVALID_ERROR:
+            ret_val = NRF_ERROR_CRYPTO_INPUT_NULL;
+            break;
+
+        case SASI_AES_ILLEGAL_OPERATION_MODE_ERROR:
+        case SASI_AES_KEY_TYPE_NOT_SUPPORTED_ERROR:
+        case SASI_AES_INVALID_ENCRYPT_MODE_ERROR:
+        case SASI_AES_ILLEGAL_PADDING_TYPE_ERROR:
+        case SASI_AES_INCORRECT_PADDING_ERROR:
+        case SASI_AES_DECRYPTION_NOT_ALLOWED_ON_THIS_MODE:
+        case SASI_AES_ADDITIONAL_BLOCK_NOT_PERMITTED_ERROR:
+        case SASI_AES_IS_NOT_SUPPORTED:
+            ret_val = NRF_ERROR_CRYPTO_FEATURE_UNAVAILABLE;
+            break;
+
+        case SASI_AES_DATA_OUT_BUFFER_SIZE_ERROR:
+            ret_val = NRF_ERROR_CRYPTO_OUTPUT_LENGTH;
+            break;
+
+        case SASI_AES_DATA_OUT_POINTER_INVALID_ERROR:
+        case SASI_AES_DATA_OUT_SIZE_POINTER_INVALID_ERROR:
+            ret_val = NRF_ERROR_CRYPTO_OUTPUT_NULL;
+            break;
+
+        case SASI_AES_CTX_SIZES_ERROR:
+        default:
+            ret_val = NRF_ERROR_CRYPTO_INTERNAL;
+            break;
+    }
+    return ret_val;
+}
+
+static ret_code_t params_validate(nrf_crypto_backend_cc310_aes_context_t const * const p_ctx,
+                                  SaSiAesOperationMode_t *                             p_mode,
+                                  nrf_crypto_operation_t                               operation)
+{
+    ret_code_t ret_val = NRF_SUCCESS;
+
+    switch (p_ctx->any.header.p_info->mode)
+    {
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_AES_ECB)
+        case NRF_CRYPTO_AES_MODE_ECB:
+        case NRF_CRYPTO_AES_MODE_ECB_PAD_PCKS7:
+            *p_mode = SASI_AES_MODE_ECB;
+            break;
+#endif
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_AES_CBC)
+        case NRF_CRYPTO_AES_MODE_CBC:
+        case NRF_CRYPTO_AES_MODE_CBC_PAD_PCKS7:
+            *p_mode = SASI_AES_MODE_CBC;
+            break;
+#endif
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_AES_CTR)
+        case NRF_CRYPTO_AES_MODE_CTR:
+            *p_mode = SASI_AES_MODE_CTR;
+            break;
+#endif
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_AES_CBC_MAC)
+        case NRF_CRYPTO_AES_MODE_CBC_MAC:
+        case NRF_CRYPTO_AES_MODE_CBC_MAC_PAD_PCKS7:
+            *p_mode = SASI_AES_MODE_CBC_MAC;
+            VERIFY_TRUE((operation == NRF_CRYPTO_MAC_CALCULATE), NRF_ERROR_CRYPTO_INVALID_PARAM);
+            break;
+#endif
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_AES_CMAC)
+        case NRF_CRYPTO_AES_MODE_CMAC:
+            *p_mode = SASI_AES_MODE_CMAC;
+            VERIFY_TRUE((operation == NRF_CRYPTO_MAC_CALCULATE), NRF_ERROR_CRYPTO_INVALID_PARAM);
+            break;
+#endif
+
+        default:
+            ret_val = NRF_ERROR_CRYPTO_FEATURE_UNAVAILABLE;
+            break;
+    }
+
+    return ret_val;
+}
+
+static ret_code_t backend_cc310_init(void * const p_context, nrf_crypto_operation_t operation)
+{
+    SaSiError_t result;
+    ret_code_t  ret_val;
+    bool        mutex_locked;
+
+    SaSiAesOperationMode_t mode;
+    SaSiAesEncryptMode_t   operation_cc310;
+
+    nrf_crypto_backend_cc310_aes_context_t * p_ctx =
+        (nrf_crypto_backend_cc310_aes_context_t *)p_context;
+
+    mutex_locked = cc310_backend_mutex_trylock();
+    VERIFY_TRUE(mutex_locked, NRF_ERROR_CRYPTO_BUSY);
+
+    if (!nrfx_is_in_ram(&p_ctx->any.context))
+    {
+        ret_val = NRF_ERROR_CRYPTO_INPUT_LOCATION;
+        goto exit;
+    }
+    if (p_ctx->any.header.p_info->key_size != NRF_CRYPTO_KEY_SIZE_128)
+    {
+        ret_val = NRF_ERROR_CRYPTO_KEY_SIZE;
+        goto exit;
+    }
+
+    ret_val = params_validate(p_ctx, &mode, operation);
+
+    if (ret_val != NRF_SUCCESS)
+    {
+        goto exit;
+    }
+
+    if (operation == NRF_CRYPTO_DECRYPT)
+    {
+        operation_cc310 = SASI_AES_DECRYPT;
+    }
+    else if ((operation == NRF_CRYPTO_ENCRYPT) || (operation == NRF_CRYPTO_MAC_CALCULATE))
+    {
+        operation_cc310 = SASI_AES_ENCRYPT;
+    }
+    else
+    {
+        ret_val = NRF_ERROR_CRYPTO_INVALID_PARAM;
+        goto exit;
+    }
+    p_ctx->any.backend.operation = operation;
+
+    result  = SaSi_AesInit(&p_ctx->any.context,
+                           operation_cc310,
+                           mode,
+                           SASI_AES_PADDING_NONE);  /* CC310 does not support padding */
+    ret_val = result_get(result);
+
+exit:
+    cc310_backend_mutex_unlock();
+    return ret_val;
+}
+
+static ret_code_t backend_cc310_uninit(void * const p_context)
+{
+    SaSiError_t result;
+    ret_code_t  ret_val;
+
+    nrf_crypto_backend_cc310_aes_context_t * p_ctx =
+        (nrf_crypto_backend_cc310_aes_context_t *)p_context;
+
+    bool mutex_locked = cc310_backend_mutex_trylock();
+    VERIFY_TRUE(mutex_locked, NRF_ERROR_CRYPTO_BUSY);
+
+    result  = SaSi_AesFree(&p_ctx->any.context);
+    ret_val = result_get(result);
+
+    cc310_backend_mutex_unlock();
+    return ret_val;
+}
+
+static ret_code_t backend_cc310_key_set(void * const p_context, uint8_t * p_key)
+{
+    SaSiError_t result;
+    ret_code_t  ret_val;
+    bool        mutex_locked;
+
+    SaSiAesUserKeyData_t key_data;
+
+    nrf_crypto_backend_cc310_aes_context_t * p_ctx =
+        (nrf_crypto_backend_cc310_aes_context_t *)p_context;
+
+    mutex_locked = cc310_backend_mutex_trylock();
+    VERIFY_TRUE(mutex_locked, NRF_ERROR_CRYPTO_BUSY);
+
+    if (!nrfx_is_in_ram(p_key))
+    {
+        ret_val = NRF_ERROR_CRYPTO_INPUT_LOCATION;
+        goto exit;
+    }
+
+    key_data.pKey    = p_key;
+    key_data.keySize = (p_ctx->any.header.p_info->key_size) >> 3; // change bits to bytes
+
+    result  = SaSi_AesSetKey(&p_ctx->any.context,
+                             SASI_AES_USER_KEY,
+                             &key_data,
+                             sizeof(key_data));
+    ret_val = result_get(result);
+
+exit:
+    cc310_backend_mutex_unlock();
+    return ret_val;
+}
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_AES_CBC)      ||  \
+    NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_AES_CTR)      ||  \
+    NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_AES_CBC_MAC)
+static ret_code_t backend_cc310_iv_set(void * const p_context, uint8_t * p_iv)
+{
+    SaSiError_t result;
+    ret_code_t  ret_val;
+    bool        mutex_locked;
+
+    nrf_crypto_backend_cc310_aes_context_t * p_ctx =
+        (nrf_crypto_backend_cc310_aes_context_t *)p_context;
+
+    mutex_locked = cc310_backend_mutex_trylock();
+    VERIFY_TRUE(mutex_locked, NRF_ERROR_CRYPTO_BUSY);
+
+    if (!nrfx_is_in_ram(p_iv))
+    {
+        ret_val = NRF_ERROR_CRYPTO_INPUT_LOCATION;
+        goto exit;
+    }
+
+    result  = SaSi_AesSetIv(&p_ctx->any.context, p_iv);
+    ret_val = result_get(result);
+
+exit:
+    cc310_backend_mutex_unlock();
+    return ret_val;
+}
+
+static ret_code_t backend_cc310_iv_get(void * const p_context, uint8_t * p_iv)
+{
+    SaSiError_t result;
+    ret_code_t  ret_val = NRF_ERROR_CRYPTO_INTERNAL;
+    bool        mutex_locked;
+
+    nrf_crypto_backend_cc310_aes_context_t * p_ctx =
+        (nrf_crypto_backend_cc310_aes_context_t *)p_context;
+
+    mutex_locked = cc310_backend_mutex_trylock();
+    VERIFY_TRUE(mutex_locked, NRF_ERROR_CRYPTO_BUSY);
+
+    if (!nrfx_is_in_ram(p_iv))
+    {
+        ret_val = NRF_ERROR_CRYPTO_INPUT_LOCATION;
+        goto exit;
+    }
+
+    result  = SaSi_AesGetIv(&p_ctx->any.context, p_iv);
+
+    /* Below code allows to read IV after calling nrf_crypto_aes_finalize */
+    if (result == SASI_AES_ILLEGAL_OPERATION_MODE_ERROR)
+    {
+        if (p_ctx->any.header.init_value == NRF_CRYPTO_AES_UNINIT_MAGIC_VALUE)
+        {
+            memcpy(p_iv, p_ctx->any.backend.iv, NRF_CRYPTO_MBEDTLS_AES_IV_SIZE);
+            ret_val = NRF_SUCCESS;
+        }
+    }
+    else
+    {
+        ret_val = result_get(result);
+    }
+
+exit:
+    cc310_backend_mutex_unlock();
+    return ret_val;
+}
+#endif
+
+static ret_code_t backend_cc310_update(void * const p_context,
+                                       uint8_t *    p_data_in,
+                                       size_t       data_size,
+                                       uint8_t *    p_data_out)
+{
+    SaSiError_t result;
+    ret_code_t  ret_val;
+    bool        mutex_locked;
+    size_t      size;
+    size_t      offset = 0;
+
+    nrf_crypto_backend_cc310_aes_context_t * p_ctx =
+        (nrf_crypto_backend_cc310_aes_context_t *)p_context;
+
+    mutex_locked = cc310_backend_mutex_trylock();
+    VERIFY_TRUE(mutex_locked, NRF_ERROR_CRYPTO_BUSY);
+
+    if (!nrfx_is_in_ram(p_data_in) || !nrfx_is_in_ram(p_data_out))
+    {
+        ret_val = NRF_ERROR_CRYPTO_INPUT_LOCATION;
+        goto exit;
+    }
+
+    do
+    {
+        /* CC310 allows only 64kB blocks, operation must be devided */
+        if (data_size > CC310_MAX_LENGTH_DMA_AES_OPERATIONS)
+        {
+            size       = CC310_MAX_LENGTH_DMA_AES_OPERATIONS;
+            data_size -= CC310_MAX_LENGTH_DMA_AES_OPERATIONS;
+        }
+        else
+        {
+            size       = data_size;
+            data_size  = 0;
+        }
+
+        cc310_backend_enable();
+
+        if (p_ctx->any.backend.operation == NRF_CRYPTO_MAC_CALCULATE)
+        {
+            result  = SaSi_AesBlock(&p_ctx->any.context,
+                                    p_data_in  + offset,
+                                    size,
+                                    p_data_out);
+        }
+        else
+        {
+            result  = SaSi_AesBlock(&p_ctx->any.context,
+                                    p_data_in  + offset,
+                                    size,
+                                    p_data_out + offset);
+        }
+
+        cc310_backend_disable();
+
+        offset += size;
+        ret_val = result_get(result);
+
+    } while ((data_size > 0) && (ret_val == NRF_SUCCESS));
+
+exit:
+    cc310_backend_mutex_unlock();
+    return ret_val;
+}
+
+static ret_code_t backend_cc310_finalize(void * const p_context,
+                                         uint8_t *    p_data_in,
+                                         size_t       data_size,
+                                         uint8_t *    p_data_out,
+                                         size_t *     p_data_out_size)
+{
+    SaSiError_t result;
+    ret_code_t  ret_val;
+    bool        mutex_locked;
+    size_t      size;
+    size_t      offset = 0;
+
+    nrf_crypto_backend_cc310_aes_context_t * p_ctx =
+        (nrf_crypto_backend_cc310_aes_context_t *)p_context;
+
+    mutex_locked = cc310_backend_mutex_trylock();
+        VERIFY_TRUE(mutex_locked, NRF_ERROR_CRYPTO_BUSY);
+
+    if (*p_data_out_size < data_size)
+    {
+        ret_val = NRF_ERROR_CRYPTO_OUTPUT_LENGTH;
+        goto exit;
+    }
+
+    /* This function does not support padding */
+    if (((data_size & 0xF) != 0) &&
+        (p_ctx->any.header.p_info->mode != NRF_CRYPTO_AES_MODE_CTR))
+    {
+        ret_val = NRF_ERROR_CRYPTO_INPUT_LENGTH;
+        goto exit;
+    }
+
+    if (!nrfx_is_in_ram(p_data_in) || !nrfx_is_in_ram(p_data_out))
+    {
+        ret_val = NRF_ERROR_CRYPTO_INPUT_LOCATION;
+        goto exit;
+    }
+
+    /* CC310 allows only 64kB blocks, operation must be devided */
+    while (data_size > CC310_MAX_LENGTH_DMA_AES_OPERATIONS)
+    {
+        size       = CC310_MAX_LENGTH_DMA_AES_OPERATIONS;
+        data_size -= CC310_MAX_LENGTH_DMA_AES_OPERATIONS;
+
+        cc310_backend_enable();
+
+        result  = SaSi_AesBlock(&p_ctx->any.context,
+                                p_data_in  + offset,
+                                size,
+                                p_data_out + offset);
+
+        cc310_backend_disable();
+
+        offset += size;
+        ret_val = result_get(result);
+
+        if (ret_val != NRF_SUCCESS)
+        {
+            goto exit;
+        }
+    }
+
+    /* Calculate space in the output buffer */
+    *p_data_out_size -= offset;
+
+    cc310_backend_enable();
+
+    result = SaSi_AesFinish(&p_ctx->any.context,
+                            data_size,
+                            p_data_in  + offset,
+                            data_size,
+                            p_data_out + offset,
+                            p_data_out_size);
+
+    cc310_backend_disable();
+
+    ret_val = result_get(result);
+
+    if (ret_val == NRF_SUCCESS)
+    {
+        /* update information about size of encrypted data */
+        *p_data_out_size += offset;
+    }
+
+    /* Store IV value in case it will be needed after finalize operation */
+    if ((p_ctx->any.header.p_info->mode == NRF_CRYPTO_AES_MODE_CBC) ||
+        (p_ctx->any.header.p_info->mode == NRF_CRYPTO_AES_MODE_CTR))
+    {
+        result  = SaSi_AesGetIv(&p_ctx->any.context, &p_ctx->any.backend.iv[0]);
+        ret_val = result_get(result);
+    }
+
+exit:
+    cc310_backend_mutex_unlock();
+    return ret_val;
+}
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_AES_CMAC)   || \
+    NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_AES_CBC_MAC)
+static ret_code_t backend_cc310_mac_finalize(void * const p_context,
+                                             uint8_t *    p_data_in,
+                                             size_t       data_size,
+                                             uint8_t *    p_data_out,
+                                             size_t *     p_data_out_size)
+{
+    SaSiError_t result;
+    ret_code_t  ret_val;
+    bool        mutex_locked;
+    size_t      size;
+    size_t      offset = 0;
+
+    nrf_crypto_backend_cc310_aes_context_t * p_ctx =
+        (nrf_crypto_backend_cc310_aes_context_t *)p_context;
+
+    mutex_locked = cc310_backend_mutex_trylock();
+    VERIFY_TRUE(mutex_locked, NRF_ERROR_CRYPTO_BUSY);
+
+    if (*p_data_out_size < NRF_CRYPTO_AES_BLOCK_SIZE)
+    {
+        ret_val = NRF_ERROR_CRYPTO_OUTPUT_LENGTH;
+        goto exit;
+    }
+
+    if (!nrfx_is_in_ram(p_data_in) || !nrfx_is_in_ram(p_data_out))
+    {
+        ret_val = NRF_ERROR_CRYPTO_INPUT_LOCATION;
+        goto exit;
+    }
+
+    /* This function does not support padding for CBC-MAC */
+    if (((data_size & 0xF) != 0) &&
+        (NRF_CRYPTO_AES_MODE_CBC_MAC == p_ctx->any.header.p_info->mode))
+    {
+        ret_val = NRF_ERROR_CRYPTO_INPUT_LENGTH;
+        goto exit;
+    }
+
+    /* CC310 allows only 64kB blocks, operation must be devided */
+    while (data_size > CC310_MAX_LENGTH_DMA_AES_OPERATIONS)
+    {
+        size       = CC310_MAX_LENGTH_DMA_AES_OPERATIONS;
+        data_size -= CC310_MAX_LENGTH_DMA_AES_OPERATIONS;
+
+        cc310_backend_enable();
+
+        result  = SaSi_AesBlock(&p_ctx->any.context,
+                                p_data_in  + offset,
+                                size,
+                                p_data_out);
+
+        cc310_backend_disable();
+
+        offset += size;
+        ret_val = result_get(result);
+
+        if (ret_val != NRF_SUCCESS)
+        {
+            goto exit;
+        }
+    }
+
+    cc310_backend_enable();
+
+    result = SaSi_AesFinish(&p_ctx->any.context,
+                            data_size,
+                            p_data_in  + offset,
+                            data_size,
+                            p_data_out,
+                            p_data_out_size);
+
+    cc310_backend_disable();
+
+    ret_val = result_get(result);
+
+    if (ret_val == NRF_SUCCESS)
+    {
+        /* update information about size of encrypted data */
+        *p_data_out_size = NRF_CRYPTO_AES_BLOCK_SIZE;
+    }
+
+    /* Store IV value in case it will be needed after finalize operation */
+    if (p_ctx->any.header.p_info->mode == NRF_CRYPTO_AES_MODE_CBC_MAC_PAD_PCKS7)
+    {
+        result  = SaSi_AesGetIv(&p_ctx->any.context, &p_ctx->any.backend.iv[0]);
+        ret_val = result_get(result);
+    }
+
+exit:
+    cc310_backend_mutex_unlock();
+    return ret_val;
+}
+#endif
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_AES_CBC_MAC)
+static ret_code_t backend_cc310_cbc_mac_padding_finalize(void * const p_context,
+                                                         uint8_t *    p_data_in,
+                                                         size_t       data_size,
+                                                         uint8_t *    p_data_out,
+                                                         size_t *     p_data_out_size)
+{
+    ret_code_t  ret_val;
+    uint8_t     padding_buffer[NRF_CRYPTO_AES_BLOCK_SIZE] = {0};
+    uint8_t     msg_ending = (uint8_t)(data_size & (size_t)0x0F);
+
+    if (*p_data_out_size < NRF_CRYPTO_AES_BLOCK_SIZE)
+    {
+        /* output buffer too small */
+        return NRF_ERROR_CRYPTO_OUTPUT_LENGTH;
+    }
+
+    data_size -= msg_ending;
+
+    if (data_size > 0)
+    {
+        ret_val = backend_cc310_update(p_context,
+                                       p_data_in,
+                                       data_size,
+                                       p_data_out);
+        VERIFY_SUCCESS(ret_val);
+    }
+
+    ret_val = padding_pkcs7_add(&padding_buffer[0],
+                                p_data_in + data_size,
+                                msg_ending);
+    VERIFY_SUCCESS(ret_val);
+
+    ret_val = backend_cc310_mac_finalize(p_context,
+                                         &padding_buffer[0],
+                                         NRF_CRYPTO_AES_BLOCK_SIZE,
+                                         p_data_out,
+                                         p_data_out_size);
+    VERIFY_SUCCESS(ret_val);
+
+    return ret_val;
+}
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_AES_CBC) || \
+    NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_AES_ECB)
+static ret_code_t backend_cc310_padding_finalize(void * const p_context,
+                                                 uint8_t *    p_data_in,
+                                                 size_t       data_size,
+                                                 uint8_t *    p_data_out,
+                                                 size_t *     p_data_out_size)
+{
+    SaSiError_t result;
+    ret_code_t  ret_val;
+    uint8_t     padding_buffer[NRF_CRYPTO_AES_BLOCK_SIZE] = {0};
+    uint8_t     msg_ending = (uint8_t)(data_size & (size_t)0x0F);
+    size_t      buff_out_size;
+
+    nrf_crypto_backend_cc310_aes_context_t * p_ctx =
+        (nrf_crypto_backend_cc310_aes_context_t *)p_context;
+
+    if (p_ctx->any.backend.operation == NRF_CRYPTO_DECRYPT)
+    {
+        ret_val = backend_cc310_finalize(p_context,
+                                         p_data_in,
+                                         data_size,
+                                         p_data_out,
+                                         p_data_out_size);
+        VERIFY_SUCCESS(ret_val);
+
+        
+        ret_val = padding_pkcs7_remove(p_data_out,
+                                       p_data_out_size);
+        return ret_val;
+    }
+
+    /* -------------- ENCRYPTION --------------*/
+    data_size -= msg_ending;
+
+    if (*p_data_out_size < (data_size + NRF_CRYPTO_AES_BLOCK_SIZE))
+    {
+        /* no space for padding */
+        return NRF_ERROR_CRYPTO_OUTPUT_LENGTH;
+    }
+
+    if (data_size > 0)
+    {
+        ret_val = backend_cc310_update(p_context,
+                                       p_data_in,
+                                       data_size,
+                                       p_data_out);
+        VERIFY_SUCCESS(ret_val);
+    }
+
+    ret_val = padding_pkcs7_add(&padding_buffer[0],
+                                p_data_in + data_size,
+                                msg_ending);
+    VERIFY_SUCCESS(ret_val);
+
+    buff_out_size = *p_data_out_size - data_size;
+
+    ret_val = backend_cc310_finalize(p_context,
+                                     &padding_buffer[0],
+                                     NRF_CRYPTO_AES_BLOCK_SIZE,
+                                     p_data_out + data_size,
+                                     &buff_out_size);
+    VERIFY_SUCCESS(ret_val);
+
+    *p_data_out_size = buff_out_size + data_size;
+
+    /* Store IV value in case it will be needed after finalize operation */
+    if (p_ctx->any.header.p_info->mode == NRF_CRYPTO_AES_MODE_CBC_PAD_PCKS7)
+    {
+        result  = SaSi_AesGetIv(&p_ctx->any.context, &p_ctx->any.backend.iv[0]);
+        ret_val = result_get(result);
+    }
+
+    return ret_val;
+}
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_AES_CBC)
+nrf_crypto_aes_info_t const g_nrf_crypto_aes_cbc_128_info =
+{
+    .mode           = NRF_CRYPTO_AES_MODE_CBC,
+    .key_size       = NRF_CRYPTO_KEY_SIZE_128,
+    .context_size   = sizeof(nrf_crypto_backend_aes_cbc_context_t),
+
+    .init_fn        = backend_cc310_init,
+    .uninit_fn      = backend_cc310_uninit,
+    .key_set_fn     = backend_cc310_key_set,
+    .iv_set_fn      = backend_cc310_iv_set,
+    .iv_get_fn      = backend_cc310_iv_get,
+    .update_fn      = backend_cc310_update,
+    .finalize_fn    = backend_cc310_finalize
+};
+
+nrf_crypto_aes_info_t const g_nrf_crypto_aes_cbc_128_pad_pkcs7_info =
+{
+    .mode           = NRF_CRYPTO_AES_MODE_CBC_PAD_PCKS7,
+    .key_size       = NRF_CRYPTO_KEY_SIZE_128,
+    .context_size   = sizeof(nrf_crypto_backend_aes_cbc_context_t),
+
+    .init_fn        = backend_cc310_init,
+    .uninit_fn      = backend_cc310_uninit,
+    .key_set_fn     = backend_cc310_key_set,
+    .iv_set_fn      = backend_cc310_iv_set,
+    .iv_get_fn      = backend_cc310_iv_get,
+    .update_fn      = backend_cc310_update,
+    .finalize_fn    = backend_cc310_padding_finalize
+};
+#endif
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_AES_CTR)
+nrf_crypto_aes_info_t const g_nrf_crypto_aes_ctr_128_info =
+{
+    .mode           = NRF_CRYPTO_AES_MODE_CTR,
+    .key_size       = NRF_CRYPTO_KEY_SIZE_128,
+    .context_size   = sizeof(nrf_crypto_backend_aes_ctr_context_t),
+
+    .init_fn        = backend_cc310_init,
+    .uninit_fn      = backend_cc310_uninit,
+    .key_set_fn     = backend_cc310_key_set,
+    .iv_set_fn      = backend_cc310_iv_set,
+    .iv_get_fn      = backend_cc310_iv_get,
+    .update_fn      = backend_cc310_update,
+    .finalize_fn    = backend_cc310_finalize
+};
+#endif
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_AES_ECB)
+nrf_crypto_aes_info_t const g_nrf_crypto_aes_ecb_128_info =
+{
+    .mode           = NRF_CRYPTO_AES_MODE_ECB,
+    .key_size       = NRF_CRYPTO_KEY_SIZE_128,
+    .context_size   = sizeof(nrf_crypto_backend_aes_ecb_context_t),
+
+    .init_fn        = backend_cc310_init,
+    .uninit_fn      = backend_cc310_uninit,
+    .key_set_fn     = backend_cc310_key_set,
+    .iv_set_fn      = NULL,
+    .iv_get_fn      = NULL,
+    .update_fn      = backend_cc310_update,
+    .finalize_fn    = backend_cc310_finalize
+};
+
+nrf_crypto_aes_info_t const g_nrf_crypto_aes_ecb_128_pad_pkcs7_info =
+{
+    .mode           = NRF_CRYPTO_AES_MODE_ECB_PAD_PCKS7,
+    .key_size       = NRF_CRYPTO_KEY_SIZE_128,
+    .context_size   = sizeof(nrf_crypto_backend_aes_ecb_context_t),
+
+    .init_fn        = backend_cc310_init,
+    .uninit_fn      = backend_cc310_uninit,
+    .key_set_fn     = backend_cc310_key_set,
+    .iv_set_fn      = NULL,
+    .iv_get_fn      = NULL,
+    .update_fn      = backend_cc310_update,
+    .finalize_fn    = backend_cc310_padding_finalize
+};
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_AES_CBC_MAC)
+nrf_crypto_aes_info_t const g_nrf_crypto_aes_cbc_mac_128_info =
+{
+    .mode           = NRF_CRYPTO_AES_MODE_CBC_MAC,
+    .key_size       = NRF_CRYPTO_KEY_SIZE_128,
+    .context_size   = sizeof(nrf_crypto_backend_aes_cbc_mac_context_t),
+
+    .init_fn        = backend_cc310_init,
+    .uninit_fn      = backend_cc310_uninit,
+    .key_set_fn     = backend_cc310_key_set,
+    .iv_set_fn      = backend_cc310_iv_set,
+    .iv_get_fn      = backend_cc310_iv_get,
+    .update_fn      = backend_cc310_update,
+    .finalize_fn    = backend_cc310_mac_finalize
+};
+
+nrf_crypto_aes_info_t const g_nrf_crypto_aes_cbc_mac_128_pad_pkcs7_info =
+{
+    .mode           = NRF_CRYPTO_AES_MODE_CBC_MAC_PAD_PCKS7,
+    .key_size       = NRF_CRYPTO_KEY_SIZE_128,
+    .context_size   = sizeof(nrf_crypto_backend_aes_cbc_mac_context_t),
+
+    .init_fn        = backend_cc310_init,
+    .uninit_fn      = backend_cc310_uninit,
+    .key_set_fn     = backend_cc310_key_set,
+    .iv_set_fn      = backend_cc310_iv_set,
+    .iv_get_fn      = backend_cc310_iv_get,
+    .update_fn      = backend_cc310_update,
+    .finalize_fn    = backend_cc310_cbc_mac_padding_finalize
+};
+#endif
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_AES_CMAC)
+nrf_crypto_aes_info_t const g_nrf_crypto_aes_cmac_128_info =
+{
+    .mode           = NRF_CRYPTO_AES_MODE_CMAC,
+    .key_size       = NRF_CRYPTO_KEY_SIZE_128,
+    .context_size   = sizeof(nrf_crypto_backend_aes_cmac_context_t),
+
+    .init_fn        = backend_cc310_init,
+    .uninit_fn      = backend_cc310_uninit,
+    .key_set_fn     = backend_cc310_key_set,
+    .iv_set_fn      = NULL,
+    .iv_get_fn      = NULL,
+    .update_fn      = backend_cc310_update,
+    .finalize_fn    = backend_cc310_mac_finalize
+};
+#endif
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_AES_BACKEND_CC310)
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO)
+
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_aes.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_aes.h
new file mode 100644
index 0000000..e7127a3
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_aes.h
@@ -0,0 +1,187 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef CC310_BACKEND_AES_H__
+#define CC310_BACKEND_AES_H__
+
+/** @file
+ *
+ * @defgroup nrf_crypto_cc310_backend_aes nrf_crypto CC310 backend AES
+ * @{
+ * @ingroup nrf_crypto_cc310_backend
+ *
+ * @brief AES functionality provided by the nrf_crypto CC310 backend.
+ */
+
+#include "sdk_config.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310) || defined(__SDK_DOXYGEN__)
+
+#include "ssi_aes.h"
+#include "nrf_crypto_error.h"
+#include "nrf_crypto_types.h"
+#include "nrf_crypto_aes_shared.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/* AES CBC */
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_AES_CBC)
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_AES_CBC)
+#error "Duplicate definition of AES CBC mode. More than one backend enabled");
+#endif
+#define NRF_CRYPTO_AES_CBC_ENABLED 1
+#undef  NRF_CRYPTO_AES_ENABLED
+#define NRF_CRYPTO_AES_ENABLED 1    // Flag that nrf_crypto_aes frontend can be compiled
+#undef  NRF_CRYPTO_CC310_AES_ENABLED
+#define NRF_CRYPTO_CC310_AES_ENABLED 1
+
+/* define for test purposes */
+#define NRF_CRYPTO_AES_CBC_128_ENABLED  1
+
+typedef struct
+{
+    nrf_crypto_aes_internal_context_t header;  /**< Common header for context. */
+    SaSiAesUserContext_t              context; /**< AES context internal to CC310. */
+    nrf_crypto_backend_aes_ctx_t      backend;
+} nrf_crypto_backend_aes_cbc_context_t;
+#endif
+
+/* AES CTR */
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_AES_CTR)
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_AES_CTR)
+#error "Duplicate definition of AES CTR mode. More than one backend enabled");
+#endif
+#define NRF_CRYPTO_AES_CTR_ENABLED 1
+#undef  NRF_CRYPTO_AES_ENABLED
+#define NRF_CRYPTO_AES_ENABLED 1    // Flag that nrf_crypto_aes frontend can be compiled
+#undef  NRF_CRYPTO_CC310_AES_ENABLED
+#define NRF_CRYPTO_CC310_AES_ENABLED 1
+
+/* define for test purposes */
+#define NRF_CRYPTO_AES_CTR_128_ENABLED 1
+
+typedef struct
+{
+    nrf_crypto_aes_internal_context_t header;  /**< Common header for context. */
+    SaSiAesUserContext_t              context; /**< AES context internal to CC310. */
+    nrf_crypto_backend_aes_ctx_t      backend;
+} nrf_crypto_backend_aes_ctr_context_t;
+#endif
+
+/* AES ECB */
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_AES_ECB)
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_AES_ECB)
+#error "Duplicate definition of AES ECB mode. More than one backend enabled");
+#endif
+#define NRF_CRYPTO_AES_ECB_ENABLED 1
+#undef  NRF_CRYPTO_AES_ENABLED
+#define NRF_CRYPTO_AES_ENABLED 1    // Flag that nrf_crypto_aes frontend can be compiled
+#undef  NRF_CRYPTO_CC310_AES_ENABLED
+#define NRF_CRYPTO_CC310_AES_ENABLED 1
+
+/* define for test purposes */
+#define NRF_CRYPTO_AES_ECB_128_ENABLED 1
+
+typedef struct
+{
+    nrf_crypto_aes_internal_context_t  header;  /**< Common header for context. */
+    SaSiAesUserContext_t               context; /**< AES context internal to CC310. */
+    nrf_crypto_backend_no_iv_aes_ctx_t backend;
+} nrf_crypto_backend_aes_ecb_context_t;
+#endif
+
+
+/* AES CBC_MAC */
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_AES_CBC_MAC)
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_AES_CBC_MAC)
+#error "Duplicate definition of AES CBC_MAC mode. More than one backend enabled");
+#endif
+#define NRF_CRYPTO_AES_CBC_MAC_ENABLED 1
+#undef  NRF_CRYPTO_AES_ENABLED
+#define NRF_CRYPTO_AES_ENABLED 1    // Flag that nrf_crypto_aes frontend can be compiled
+#undef  NRF_CRYPTO_CC310_AES_ENABLED
+#define NRF_CRYPTO_CC310_AES_ENABLED 1
+
+/* define for test purposes */
+#define NRF_CRYPTO_AES_CBC_MAC_128_ENABLED 1
+
+typedef struct
+{
+    nrf_crypto_aes_internal_context_t header;  /**< Common header for context. */
+    SaSiAesUserContext_t              context; /**< AES context internal to CC310. */
+    nrf_crypto_backend_aes_ctx_t      backend;
+} nrf_crypto_backend_aes_cbc_mac_context_t;
+#endif
+
+/* AES CMAC */
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_AES_CMAC)
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_AES_CMAC)
+#error "Duplicate definition of AES CMAC mode. More than one backend enabled");
+#endif
+#define NRF_CRYPTO_AES_CMAC_ENABLED 1
+#undef  NRF_CRYPTO_AES_ENABLED
+#define NRF_CRYPTO_AES_ENABLED 1    // Flag that nrf_crypto_aes frontend can be compiled
+#undef  NRF_CRYPTO_CC310_AES_ENABLED
+#define NRF_CRYPTO_CC310_AES_ENABLED 1
+
+/* define for test purposes */
+#define NRF_CRYPTO_AES_CMAC_128_ENABLED 1
+
+typedef struct
+{
+    nrf_crypto_aes_internal_context_t  header;  /**< Common header for context. */
+    SaSiAesUserContext_t               context; /**< AES context internal to CC310. */
+    nrf_crypto_backend_no_iv_aes_ctx_t backend;
+} nrf_crypto_backend_aes_cmac_context_t;
+
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310)
+
+/** @} */
+
+#endif // CC310_BACKEND_AES_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_aes_aead.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_aes_aead.c
new file mode 100644
index 0000000..e8e312e
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_aes_aead.c
@@ -0,0 +1,366 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#include "sdk_common.h"
+#include <drivers/nrfx_common.h>
+#if NRF_MODULE_ENABLED(NRF_CRYPTO)
+
+#include <stdbool.h>
+#include "crys_aesccm_error.h"
+#include "cc310_backend_aes_aead.h"
+#include "cc310_backend_mutex.h"
+#include "cc310_backend_shared.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_CC310_AES_AEAD)
+
+/**@internal @brief Type declaration of a template suiting all possible context sizes
+ *                  for this backend.
+ */
+typedef struct
+{
+    nrf_crypto_aead_internal_context_t header;  /**< Common header for context. */
+    CRYS_AESCCM_UserContext_t          context;
+    uint8_t                            key[16]; /**< Only supported key size by CC310 is 128 bit */
+} nrf_crypto_backend_cc310_aes_aead_context_t;
+
+static ret_code_t result_get(CRYSError_t error)
+{
+    ret_code_t ret_val;
+
+    switch (error)
+    {
+        case CRYS_OK:
+            ret_val = NRF_SUCCESS;
+            break;
+
+        case CRYS_AESCCM_INVALID_USER_CONTEXT_POINTER_ERROR:
+            ret_val = NRF_ERROR_CRYPTO_CONTEXT_NULL;
+            break;
+
+        case CRYS_AESCCM_ILLEGAL_KEY_SIZE_ERROR:
+            ret_val = NRF_ERROR_CRYPTO_KEY_SIZE;
+            break;
+
+        case CRYS_AESCCM_ILLEGAL_TAG_SIZE_ERROR:
+            ret_val = NRF_ERROR_CRYPTO_AEAD_MAC_SIZE;
+            break;
+
+        case CRYS_AESCCM_ILLEGAL_NONCE_SIZE_ERROR:
+            ret_val = NRF_ERROR_CRYPTO_AEAD_NONCE_SIZE;
+            break;
+
+        case CRYS_AESCCM_ILLEGAL_PARAMETER_SIZE_ERROR:
+        case CRYS_AESCCM_DATA_IN_SIZE_ILLEGAL:
+            ret_val = NRF_ERROR_CRYPTO_INPUT_LENGTH;
+            break;
+
+        case CRYS_AESCCM_INVALID_KEY_POINTER_ERROR:
+        case CRYS_AESCCM_ILLEGAL_PARAMETER_PTR_ERROR:
+        case CRYS_AESCCM_DATA_IN_POINTER_INVALID_ERROR:
+            ret_val = NRF_ERROR_CRYPTO_INPUT_NULL;
+            break;
+
+        case CRYS_AESCCM_IS_NOT_SUPPORTED:
+        case CRYS_AESCCM_INVALID_ENCRYPT_MODE_ERROR:
+            ret_val = NRF_ERROR_CRYPTO_FEATURE_UNAVAILABLE;
+            break;
+
+        case CRYS_AESCCM_DATA_OUT_SIZE_INVALID_ERROR:
+            ret_val = NRF_ERROR_CRYPTO_OUTPUT_LENGTH;
+            break;
+
+        case CRYS_AESCCM_DATA_OUT_POINTER_INVALID_ERROR:
+            ret_val = NRF_ERROR_CRYPTO_OUTPUT_NULL;
+            break;
+
+        case CRYS_AESCCM_ILLEGAL_PARAMETER_ERROR:
+            ret_val = NRF_ERROR_CRYPTO_INVALID_PARAM;
+            break;
+
+        case CRYS_AESCCM_CCM_MAC_INVALID_ERROR:
+            ret_val = NRF_ERROR_CRYPTO_AEAD_INVALID_MAC;
+            break;
+
+        case CRYS_AESCCM_CTX_SIZES_ERROR:
+        default:
+            ret_val = NRF_ERROR_CRYPTO_INTERNAL;
+            break;
+    }
+    return ret_val;
+}
+
+static ret_code_t backend_cc310_init(void * const p_context, uint8_t * p_key)
+{
+    ret_code_t ret_val;
+
+    nrf_crypto_backend_cc310_aes_aead_context_t * p_ctx =
+        (nrf_crypto_backend_cc310_aes_aead_context_t *)p_context;
+
+    if (!nrfx_is_in_ram(p_ctx))
+    {
+        return NRF_ERROR_CRYPTO_INPUT_LOCATION;
+    }
+    if (p_ctx->header.p_info->key_size != NRF_CRYPTO_KEY_SIZE_128)
+    {
+        return NRF_ERROR_CRYPTO_KEY_SIZE;
+    }
+
+    switch (p_ctx->header.p_info->mode)
+    {
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_AES_CCM)
+        case NRF_CRYPTO_AEAD_MODE_AES_CCM:
+            ret_val = NRF_SUCCESS;
+            break;
+#endif
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_AES_CCM_STAR)
+        case NRF_CRYPTO_AEAD_MODE_AES_CCM_STAR:
+            ret_val = NRF_SUCCESS;
+            break;
+#endif
+
+        default:
+            return NRF_ERROR_CRYPTO_FEATURE_UNAVAILABLE;
+    }
+
+    memcpy(p_ctx->key, p_key, sizeof(p_ctx->key));
+
+    return ret_val;
+}
+
+static ret_code_t backend_cc310_uninit(void * const p_context)
+{
+    nrf_crypto_backend_cc310_aes_aead_context_t * p_ctx =
+        (nrf_crypto_backend_cc310_aes_aead_context_t *)p_context;
+
+    memset(&p_ctx->context, 0, sizeof(CRYS_AESCCM_UserContext_t));
+
+    return NRF_SUCCESS;
+}
+
+static ret_code_t backend_cc310_crypt(void * const           p_context,
+                                      nrf_crypto_operation_t operation,
+                                      uint8_t *              p_nonce,
+                                      uint8_t                nonce_size,
+                                      uint8_t *              p_adata,
+                                      size_t                 adata_size,
+                                      uint8_t *              p_data_in,
+                                      size_t                 data_in_size,
+                                      uint8_t *              p_data_out,
+                                      uint8_t *              p_mac,
+                                      uint8_t                mac_size)
+
+{
+    uint32_t    mode;
+    CRYSError_t result;
+    ret_code_t  ret_val;
+    bool        mutex_locked;
+
+    SaSiAesEncryptMode_t  operation_cc310;
+    CRYS_AESCCM_Mac_Res_t mac_buffer;
+
+    nrf_crypto_backend_cc310_aes_aead_context_t * p_ctx =
+        (nrf_crypto_backend_cc310_aes_aead_context_t *)p_context;
+
+    mutex_locked = cc310_backend_mutex_trylock();
+    VERIFY_TRUE(mutex_locked, NRF_ERROR_CRYPTO_BUSY);
+
+    if (!nrfx_is_in_ram(p_adata) && (adata_size > 0))
+    {
+        ret_val = NRF_ERROR_CRYPTO_INPUT_LOCATION;
+        goto exit;
+    }
+
+    /* CC310 supports: CCM & CCM*, where nonce_size must be > 0, so p_nonce must always
+       point to RAM. */
+    if (!nrfx_is_in_ram(p_nonce)         ||
+        !nrfx_is_in_ram(p_data_in)  ||
+        !nrfx_is_in_ram(p_data_out) ||
+        !nrfx_is_in_ram(p_mac))
+    {
+        ret_val = NRF_ERROR_CRYPTO_INPUT_LOCATION;
+        goto exit;
+    }
+
+    if (operation == NRF_CRYPTO_DECRYPT)
+    {
+        operation_cc310 = SASI_AES_DECRYPT;
+    }
+    else if (operation == NRF_CRYPTO_ENCRYPT)
+    {
+        operation_cc310 = SASI_AES_ENCRYPT;
+    }
+    else
+    {
+        ret_val = NRF_ERROR_CRYPTO_INVALID_PARAM;
+        goto exit;
+    }
+
+    if (p_ctx->header.p_info->mode == NRF_CRYPTO_AEAD_MODE_AES_CCM)
+    {
+        mode = CRYS_AESCCM_MODE_CCM;
+
+        /* Allowed MAC size in CCM mode: [4, 6, 8, 10, 12, 14, 16] */
+        if ((mac_size < NRF_CRYPTO_AES_CCM_MAC_MIN) ||
+            (mac_size > NRF_CRYPTO_AES_CCM_MAC_MAX) ||
+            ((mac_size & 0x01) != 0))
+        {
+            ret_val = NRF_ERROR_CRYPTO_AEAD_MAC_SIZE;
+            goto exit;
+        }
+
+        if ((nonce_size < NRF_CRYPTO_AES_CCM_NONCE_SIZE_MIN) ||
+            (nonce_size > NRF_CRYPTO_AES_CCM_NONCE_SIZE_MAX))
+        {
+            ret_val = NRF_ERROR_CRYPTO_AEAD_NONCE_SIZE;
+            goto exit;
+        }
+    }
+    else
+    {
+        mode = CRYS_AESCCM_MODE_STAR;
+
+        /* Allowed MAC size in CCM* mode: [0, 4, 8, 16] */
+        if ((mac_size | NRF_CRYPTO_AES_CCM_STAR_MAC_BITMASK) != NRF_CRYPTO_AES_CCM_STAR_MAC_BITMASK)
+        {
+            ret_val = NRF_ERROR_CRYPTO_AEAD_MAC_SIZE;
+            goto exit;
+        }
+
+        /* Allowed nonce size in CCM* mode: [13] */
+        if (nonce_size != NRF_CRYPTO_AES_CCM_STAR_NONCE_SIZE)
+        {
+            ret_val = NRF_ERROR_CRYPTO_AEAD_NONCE_SIZE;
+            goto exit;
+        }
+    }
+
+    cc310_backend_enable();
+
+    result = CC_AESCCM_Init(&p_ctx->context,
+                            operation_cc310,
+                            p_ctx->key,
+                            CRYS_AES_Key128BitSize, // the only allowed key size for CC310
+                            (uint32_t)adata_size,
+                            (uint32_t)data_in_size,
+                            p_nonce,
+                            nonce_size,
+                            mac_size,
+                            mode);
+
+    cc310_backend_disable();
+
+    ret_val = result_get(result);
+
+    if (ret_val != NRF_SUCCESS)
+    {
+        goto exit;
+    }
+
+    if ((adata_size > 0) && (p_adata != NULL))
+    {
+        cc310_backend_enable();
+
+        result = CRYS_AESCCM_BlockAdata(&p_ctx->context,
+                                        p_adata,
+                                        (uint32_t)adata_size);
+
+        cc310_backend_disable();
+
+        ret_val = result_get(result);
+
+        if (ret_val != NRF_SUCCESS)
+        {
+            goto exit;
+        }
+    }
+
+    /* CC310 backend always needs 16 bytes buffer for MAC calculation. */
+    memcpy(mac_buffer, p_mac, mac_size);
+
+    cc310_backend_enable();
+
+    result = CRYS_AESCCM_Finish(&p_ctx->context,
+                                p_data_in,
+                                (uint32_t)data_in_size,
+                                p_data_out,
+                                mac_buffer,
+                                &mac_size);
+
+    cc310_backend_disable();
+
+    ret_val = result_get(result);
+    if (ret_val == NRF_SUCCESS)
+    {
+        memcpy(p_mac, mac_buffer, mac_size);
+    }
+
+exit:
+    cc310_backend_mutex_unlock();
+    return ret_val;
+}
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_AES_CCM)
+nrf_crypto_aead_info_t const g_nrf_crypto_aes_ccm_128_info =
+{
+    .key_size  = NRF_CRYPTO_KEY_SIZE_128,
+    .mode      = NRF_CRYPTO_AEAD_MODE_AES_CCM,
+
+    .init_fn   = backend_cc310_init,
+    .uninit_fn = backend_cc310_uninit,
+    .crypt_fn  = backend_cc310_crypt
+};
+#endif
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_AES_CCM_STAR)
+nrf_crypto_aead_info_t const g_nrf_crypto_aes_ccm_star_128_info =
+{
+    .key_size  = NRF_CRYPTO_KEY_SIZE_128,
+    .mode      = NRF_CRYPTO_AEAD_MODE_AES_CCM_STAR,
+
+    .init_fn   = backend_cc310_init,
+    .uninit_fn = backend_cc310_uninit,
+    .crypt_fn  = backend_cc310_crypt
+};
+#endif
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_CC310_AES_AEAD)
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO)
+
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_aes_aead.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_aes_aead.h
new file mode 100644
index 0000000..34622d9
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_aes_aead.h
@@ -0,0 +1,124 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef CC310_BACKEND_AES_AEAD_H__
+#define CC310_BACKEND_AES_AEAD_H__
+
+/** @file
+ *
+ * @defgroup nrf_crypto_cc310_backend_aes_aead nrf_crypto CC310 backend AES AEAD
+ * @{
+ * @ingroup nrf_crypto_cc310_backend
+ *
+ * @brief AES AEAD functionality provided by the nrf_crypto CC310 backend.
+ */
+
+#include "sdk_config.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310)
+
+#include "crys_aesccm.h"
+#include "nrf_crypto_error.h"
+#include "nrf_crypto_types.h"
+#include "nrf_crypto_aead_shared.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define NRF_CRYPTO_CC310_AES_BACKEND_KEY_SIZE (16)
+
+
+/* AES CCM */
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_AES_CCM)
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_AES_CCM)
+#error "Duplicate definition of AES CCM mode. More than one backend enabled");
+#endif
+#define NRF_CRYPTO_AES_CCM_ENABLED  1
+#undef  NRF_CRYPTO_AEAD_ENABLED
+#define NRF_CRYPTO_AEAD_ENABLED  1  // Flag that nrf_crypto_aead frontend can be compiled
+#undef  NRF_CRYPTO_CC310_AES_AEAD_ENABLED
+#define NRF_CRYPTO_CC310_AES_AEAD_ENABLED   1   // aead backend for cc310 can be compiled
+
+/* define for test purposes */
+#define NRF_CRYPTO_AES_CCM_128_ENABLED  1
+
+typedef struct
+{
+    nrf_crypto_aead_internal_context_t header;  /**< Common header for context. */
+    CRYS_AESCCM_UserContext_t          context; /**< AES CCM context internal to CC310. */
+
+    uint8_t key[NRF_CRYPTO_CC310_AES_BACKEND_KEY_SIZE];
+} nrf_crypto_backend_aes_ccm_context_t;
+#endif
+
+/* AES CCM* (CCM STAR) */
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_AES_CCM_STAR)
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_AES_CCM_STAR)
+#error "Duplicate definition of AES CCM* (star) mode. More than one backend enabled");
+#endif
+#define NRF_CRYPTO_AES_CCM_STAR_ENABLED 1
+#undef  NRF_CRYPTO_AEAD_ENABLED
+#define NRF_CRYPTO_AEAD_ENABLED  1  // Flag that nrf_crypto_aes_aead frontend can be compiled
+#undef  NRF_CRYPTO_CC310_AES_AEAD_ENABLED
+#define NRF_CRYPTO_CC310_AES_AEAD_ENABLED   1   // aead backend for cc310 can be compiled
+
+/* define for test purposes */
+#define NRF_CRYPTO_AES_CCM_STAR_128_ENABLED  1
+
+typedef struct
+{
+    nrf_crypto_aead_internal_context_t header;  /**< Common header for context. */
+    CRYS_AESCCM_UserContext_t          context; /**< AES CCM context internal to CC310. */
+
+    uint8_t key[NRF_CRYPTO_CC310_AES_BACKEND_KEY_SIZE];
+} nrf_crypto_backend_aes_ccm_star_context_t;
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310)
+
+/** @} */
+
+#endif // CC310_BACKEND_AES_AEAD_H__
+
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_chacha_poly_aead.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_chacha_poly_aead.c
new file mode 100644
index 0000000..16ca026
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_chacha_poly_aead.c
@@ -0,0 +1,214 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#include "sdk_common.h"
+#if NRF_MODULE_ENABLED(NRF_CRYPTO)
+
+#include <drivers/nrfx_common.h>
+#include <stdbool.h>
+#include "cc310_backend_mutex.h"
+#include "crys_chacha_poly_error.h"
+#include "cc310_backend_chacha_poly_aead.h"
+#include "cc310_backend_shared.h"
+#include "cc310_backend_shared.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_CC310_CHACHA_POLY_AEAD)
+
+static ret_code_t result_get(CRYSError_t error)
+{
+    ret_code_t ret_val;
+
+    switch (error)
+    {
+        case CRYS_OK:
+            ret_val = NRF_SUCCESS;
+            break;
+
+        /*! Invalid Additional data. */
+        case CRYS_CHACHA_POLY_DATA_INVALID_ERROR:
+        case CRYS_CHACHA_POLY_ADATA_INVALID_ERROR:
+            ret_val = NRF_ERROR_CRYPTO_INPUT_NULL;
+            break;
+
+        /*! Illegal encryption mode. */
+        case CRYS_CHACHA_POLY_ENC_MODE_INVALID_ERROR:
+            ret_val = NRF_ERROR_CRYPTO_INVALID_PARAM;
+            break;
+
+        /*! Illegal data size. */
+        case CRYS_CHACHA_POLY_DATA_SIZE_INVALID_ERROR:
+            ret_val = NRF_ERROR_CRYPTO_INPUT_LENGTH;
+            break;
+
+        /*! MAC comparison error. */
+        case CRYS_CHACHA_POLY_MAC_ERROR:
+            ret_val = NRF_ERROR_CRYPTO_AEAD_INVALID_MAC;
+            break;
+
+        default:
+            ret_val = NRF_ERROR_CRYPTO_INTERNAL;
+            break;
+    }
+    return ret_val;
+}
+
+static ret_code_t backend_cc310_init(void * const p_context, uint8_t * p_key)
+{
+    nrf_crypto_backend_chacha_poly_context_t * p_ctx =
+        (nrf_crypto_backend_chacha_poly_context_t *)p_context;
+
+    if (!nrfx_is_in_ram(p_ctx))
+    {
+        return NRF_ERROR_CRYPTO_INPUT_LOCATION;
+    }
+
+    if (p_ctx->header.p_info->key_size != NRF_CRYPTO_KEY_SIZE_256)
+    {
+        return NRF_ERROR_CRYPTO_KEY_SIZE;
+    }
+
+    memcpy(p_ctx->key, p_key, sizeof(p_ctx->key));
+    return NRF_SUCCESS;
+}
+
+static inline ret_code_t backend_cc310_uninit(void * const p_context)
+{
+    return NRF_SUCCESS;
+}
+
+static ret_code_t backend_cc310_crypt(void * const           p_context,
+                                      nrf_crypto_operation_t operation,
+                                      uint8_t *              p_nonce,
+                                      uint8_t                nonce_size,
+                                      uint8_t *              p_adata,
+                                      size_t                 adata_size,
+                                      uint8_t *              p_data_in,
+                                      size_t                 data_in_size,
+                                      uint8_t *              p_data_out,
+                                      uint8_t *              p_mac,
+                                      uint8_t                mac_size)
+
+{
+    CRYSError_t result;
+    ret_code_t  ret_val;
+    bool        mutex_locked;
+
+    CRYS_CHACHA_EncryptMode_t operation_cc310;
+
+    nrf_crypto_backend_chacha_poly_context_t * p_ctx =
+        (nrf_crypto_backend_chacha_poly_context_t *)p_context;
+
+    mutex_locked = cc310_backend_mutex_trylock();
+    VERIFY_TRUE(mutex_locked, NRF_ERROR_CRYPTO_BUSY);
+
+    if ((adata_size == 0) || (data_in_size == 0))
+    {
+        ret_val = NRF_ERROR_CRYPTO_INPUT_LENGTH;
+        goto exit;
+    }
+
+    if (mac_size   != NRF_CRYPTO_CHACHA_POLY_MAC_SIZE)
+    {
+        ret_val = NRF_ERROR_CRYPTO_AEAD_MAC_SIZE;
+        goto exit;
+    }
+
+    if (nonce_size != NRF_CRYPTO_CHACHA_POLY_NONCE_SIZE)
+    {
+        ret_val = NRF_ERROR_CRYPTO_AEAD_NONCE_SIZE;
+        goto exit;
+    }
+
+    if (!nrfx_is_in_ram(p_data_in) || !nrfx_is_in_ram(p_data_out) ||
+        !nrfx_is_in_ram(p_mac)          || !nrfx_is_in_ram(p_adata)      ||
+        !nrfx_is_in_ram(p_nonce))
+    {
+        ret_val = NRF_ERROR_CRYPTO_INPUT_LOCATION;
+        goto exit;
+    }
+
+    if (operation == NRF_CRYPTO_DECRYPT)
+    {
+        operation_cc310 = CRYS_CHACHA_Decrypt;
+    }
+    else if (operation == NRF_CRYPTO_ENCRYPT)
+    {
+        operation_cc310 = CRYS_CHACHA_Encrypt;
+    }
+    else
+    {
+        ret_val = NRF_ERROR_CRYPTO_INVALID_PARAM;
+        goto exit;
+    }
+
+    cc310_backend_enable();
+
+    result = CRYS_CHACHA_POLY(p_nonce,
+                              p_ctx->key,
+                              operation_cc310,
+                              p_adata,
+                              adata_size,
+                              p_data_in,
+                              data_in_size,
+                              p_data_out,
+                              (uint32_t *)p_mac);
+    cc310_backend_disable();
+
+    ret_val = result_get(result);
+
+exit:
+    cc310_backend_mutex_unlock();
+    return ret_val;
+}
+
+nrf_crypto_aead_info_t const g_nrf_crypto_chacha_poly_256_info =
+{
+    .key_size  = NRF_CRYPTO_KEY_SIZE_256,
+    .mode      = NRF_CRYPTO_AEAD_MODE_CHACHA_POLY,
+
+    .init_fn   = backend_cc310_init,
+    .uninit_fn = backend_cc310_uninit,
+    .crypt_fn  = backend_cc310_crypt
+};
+
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_CC310_CHACHA_POLY_AEAD)
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO)
+
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_chacha_poly_aead.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_chacha_poly_aead.h
new file mode 100644
index 0000000..4c1edf9
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_chacha_poly_aead.h
@@ -0,0 +1,99 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef CC310_BACKEND_CHACHA_POLY_AEAD_H__
+#define CC310_BACKEND_CHACHA_POLY_AEAD_H__
+
+/** @file
+ *
+ * @defgroup nrf_crypto_cc310_backend_chacha_poly_aead nrf_crypto CC310 backend CHACHA_POLY AEAD
+ * @{
+ * @ingroup nrf_crypto_cc310_backend
+ *
+ * @brief CHACHA_POLY AEAD functionality provided by the nrf_crypto CC310 backend.
+ */
+
+#include "sdk_config.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310)
+
+#include "crys_chacha_poly.h"
+#include "nrf_crypto_error.h"
+#include "nrf_crypto_types.h"
+#include "nrf_crypto_aead_shared.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define NRF_CRYPTO_CC310_CHACHA_POLY_BACKEND_KEY_SIZE (32)
+
+/* CHACHA-POLY */
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_CHACHA_POLY)
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_CHACHA_POLY)
+#error "Duplicate definition of CHACHA-POLY mode. More than one backend enabled");
+#endif
+#define NRF_CRYPTO_CHACHA_POLY_ENABLED  1
+#undef  NRF_CRYPTO_AEAD_ENABLED
+#define NRF_CRYPTO_AEAD_ENABLED  1  // Flag that nrf_crypto_aead frontend can be compiled
+#undef  NRF_CRYPTO_CC310_CHACHA_POLY_AEAD_ENABLED
+#define NRF_CRYPTO_CC310_CHACHA_POLY_AEAD_ENABLED   1   // aead backend for cc310 can be compiled
+
+/* defines for test purposes */
+#define NRF_CRYPTO_CHACHA_POLY_256_ENABLED  1
+
+typedef struct
+{
+    nrf_crypto_aead_internal_context_t header;  /**< Common header for context. */
+
+    uint8_t key[NRF_CRYPTO_CC310_CHACHA_POLY_BACKEND_KEY_SIZE];
+} nrf_crypto_backend_chacha_poly_context_t;
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310)
+
+/** @} */
+
+#endif // CC310_BACKEND_CHACHA_POLY_AEAD_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_ecc.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_ecc.c
new file mode 100644
index 0000000..e93230c
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_ecc.c
@@ -0,0 +1,464 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#include "sdk_config.h"
+#include "nordic_common.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310)
+
+#include <string.h>
+
+#include "nrf_crypto_mem.h"
+#include "nrf_crypto_ecc.h"
+#include "cc310_backend_ecc.h"
+#include "cc310_backend_shared.h"
+#include "cc310_backend_mutex.h"
+#include "crys_ecpki_kg.h"
+#include "crys_ecpki_domain.h"
+#include "crys_ecpki_build.h"
+#include "crys_ecpki_error.h"
+#include "crys_rnd_error.h"
+
+
+#define CC310_UNCOMPRESSED_PUBLIC_KEY_ID_BYTE 0x04 /**< @brief @internal Byte value used by CC310 library to prefix uncompressed public key. */
+
+
+ret_code_t nrf_crypto_backend_cc310_ecc_error_convert(uint32_t crys_error)
+{
+    switch (crys_error)
+    {
+        case CRYS_OK:
+            return NRF_SUCCESS;
+
+        case CRYS_ECDSA_VERIFY_INCONSISTENT_VERIFY_ERROR:
+            return NRF_ERROR_CRYPTO_ECDSA_INVALID_SIGNATURE;
+
+        case CRYS_RND_INSTANTIATION_NOT_DONE_ERROR:
+            return NRF_ERROR_CRYPTO_CONTEXT_NOT_INITIALIZED;
+
+        default:
+            return NRF_ERROR_CRYPTO_INTERNAL;
+    }
+}
+
+
+/** @internal @brief Returns domain value from @ref CRYS_ECPKI_DomainID_t enum based on
+ *  value from info structure.
+ *
+ * @param[in] p_info  Curve info.
+ * @returns           Pointer to CC310 domain.
+ */
+static CRYS_ECPKI_Domain_t const * get_domain(nrf_crypto_ecc_curve_info_t const * p_info)
+{
+    CRYS_ECPKI_DomainID_t       domain_id = (CRYS_ECPKI_DomainID_t)(intptr_t)p_info->p_backend_data;
+    const CRYS_ECPKI_Domain_t * domain    = CRYS_ECPKI_GetEcDomain(domain_id);
+    return domain;
+}
+
+
+ret_code_t nrf_crypto_backend_cc310_ecc_public_key_convert(
+    nrf_crypto_backend_cc310_ecc_public_key_t * p_pub,
+    CRYS_ECPKI_BUILD_TempData_t * p_temp_data)
+{
+    ret_code_t                   result;
+    CRYSError_t                  crys_error;
+    CRYS_ECPKI_Domain_t const  * p_domain;
+    uint8_t                      ucompressed_key[NRF_CRYPTO_ECC_RAW_PUBLIC_KEY_MAX_SIZE + 1];
+    bool                         mutex_locked;
+
+    nrf_crypto_ecc_curve_info_t const * p_info = p_pub->header.p_info;
+
+    if (p_pub->key_converted)
+    {
+        return NRF_SUCCESS;
+    }
+
+    p_domain = get_domain(p_info);
+
+    // Tell CC310 library that this is raw public key in uncompressed format.
+    ucompressed_key[0] = CC310_UNCOMPRESSED_PUBLIC_KEY_ID_BYTE;
+    memcpy(&ucompressed_key[1], p_pub->key.raw_public_key, p_info->raw_public_key_size);
+
+    mutex_locked = cc310_backend_mutex_trylock();
+    if (!mutex_locked)
+    {
+        return NRF_ERROR_CRYPTO_BUSY;
+    }
+
+    cc310_backend_enable();
+
+    crys_error = CRYS_ECPKI_BuildPublKeyFullCheck(p_domain,
+                                                  ucompressed_key,
+                                                  p_info->raw_public_key_size + 1,
+                                                  &p_pub->key.cc310_public_key,
+                                                  p_temp_data);
+
+    cc310_backend_disable();
+
+    cc310_backend_mutex_unlock();
+
+    result = nrf_crypto_backend_cc310_ecc_error_convert(crys_error);
+    if (result == NRF_SUCCESS)
+    {
+        p_pub->key_converted = true;
+    }
+    else
+    {
+        memcpy(p_pub->key.raw_public_key, &ucompressed_key[1], p_info->raw_public_key_size);
+    }
+
+    return result;
+}
+
+
+ret_code_t nrf_crypto_backend_cc310_key_pair_generate(
+    void * p_context,
+    void * p_private_key,
+    void * p_public_key)
+{
+    ret_code_t                   result;
+    CRYSError_t                  crys_error;
+    CRYS_ECPKI_Domain_t  const * p_domain;
+    bool                         mutex_locked;
+
+    nrf_crypto_backend_cc310_key_pair_generate_context_t * p_ctx =
+        (nrf_crypto_backend_cc310_key_pair_generate_context_t *)p_context;
+
+    nrf_crypto_backend_cc310_ecc_private_key_t * p_prv =
+        (nrf_crypto_backend_cc310_ecc_private_key_t *)p_private_key;
+
+    nrf_crypto_backend_cc310_ecc_public_key_t  * p_pub =
+        (nrf_crypto_backend_cc310_ecc_public_key_t *)p_public_key;
+
+    p_domain = get_domain(p_prv->header.p_info);
+
+    mutex_locked = cc310_backend_mutex_trylock();
+    VERIFY_TRUE(mutex_locked, NRF_ERROR_CRYPTO_BUSY);
+
+    cc310_backend_enable();
+
+    crys_error = CRYS_ECPKI_GenKeyPair(p_context,
+                                       nrf_crypto_backend_cc310_rng,
+                                       p_domain,
+                                       &p_prv->private_key,
+                                       &p_pub->key.cc310_public_key,
+                                       &p_ctx->temp_data,
+                                       NULL);
+    cc310_backend_disable();
+
+    cc310_backend_mutex_unlock();
+
+    p_pub->key_converted = true;
+
+    result = nrf_crypto_backend_cc310_ecc_error_convert(crys_error);
+    return result;
+}
+
+
+ret_code_t nrf_crypto_backend_cc310_private_key_from_raw(
+    void          * p_private_key,
+    uint8_t const * p_raw_data)
+{
+    ret_code_t                  result;
+    CRYSError_t                 crys_error;
+    CRYS_ECPKI_Domain_t const * p_domain;
+    bool                        mutex_locked;
+
+    nrf_crypto_backend_cc310_ecc_private_key_t * p_prv =
+            (nrf_crypto_backend_cc310_ecc_private_key_t *)p_private_key;
+
+    nrf_crypto_ecc_curve_info_t const * p_info = p_prv->header.p_info;
+
+    p_domain = get_domain(p_info);
+
+    mutex_locked = cc310_backend_mutex_trylock();
+    VERIFY_TRUE(mutex_locked, NRF_ERROR_CRYPTO_BUSY);
+
+    crys_error = CRYS_ECPKI_BuildPrivKey(p_domain,
+                                         p_raw_data,
+                                         p_info->raw_private_key_size,
+                                         &p_prv->private_key);
+
+    cc310_backend_mutex_unlock();
+
+    result = nrf_crypto_backend_cc310_ecc_error_convert(crys_error);
+    return result;
+}
+
+
+ret_code_t nrf_crypto_backend_cc310_private_key_to_raw(
+    void const * p_private_key,
+    uint8_t    * p_raw_data)
+{
+    ret_code_t    result;
+    CRYSError_t   crys_error;
+    uint32_t      key_size;
+
+    nrf_crypto_backend_cc310_ecc_private_key_t * p_prv =
+            (nrf_crypto_backend_cc310_ecc_private_key_t *)p_private_key;
+
+    nrf_crypto_ecc_curve_info_t const * p_info = p_prv->header.p_info;
+
+    key_size = p_info->raw_private_key_size;
+
+    crys_error = CRYS_ECPKI_ExportPrivKey(&p_prv->private_key,
+                                          p_raw_data,
+                                          &key_size);
+
+    if (key_size != p_info->raw_private_key_size)
+    {
+        return NRF_ERROR_CRYPTO_INTERNAL;
+    }
+
+    result = nrf_crypto_backend_cc310_ecc_error_convert(crys_error);
+
+    return result;
+}
+
+
+ret_code_t nrf_crypto_backend_cc310_public_key_from_raw(
+    void          * p_public_key,
+    uint8_t const * p_raw_data)
+{
+    nrf_crypto_backend_cc310_ecc_public_key_t  * p_pub =
+            (nrf_crypto_backend_cc310_ecc_public_key_t *)p_public_key;
+
+    nrf_crypto_ecc_curve_info_t const * p_info = p_pub->header.p_info;
+
+    memcpy(p_pub->key.raw_public_key, p_raw_data, p_info->raw_public_key_size);
+    p_pub->key_converted = false;
+
+    return NRF_SUCCESS;
+}
+
+
+ret_code_t nrf_crypto_backend_cc310_public_key_to_raw(
+    void const * p_public_key,
+    uint8_t    * p_raw_data)
+{
+    ret_code_t    result;
+    CRYSError_t   crys_error;
+    uint8_t       ucompressed_key[NRF_CRYPTO_ECC_RAW_PUBLIC_KEY_MAX_SIZE + 1];
+    uint32_t      key_size;
+    bool          mutex_locked;
+
+    nrf_crypto_backend_cc310_ecc_public_key_t * p_pub =
+            (nrf_crypto_backend_cc310_ecc_public_key_t *)p_public_key;
+
+    nrf_crypto_ecc_curve_info_t const * p_info = p_pub->header.p_info;
+
+    if (!p_pub->key_converted)
+    {
+        memcpy(p_raw_data, p_pub->key.raw_public_key, p_info->raw_public_key_size);
+        return NRF_SUCCESS;
+    }
+
+    mutex_locked = cc310_backend_mutex_trylock();
+    if (!mutex_locked)
+    {
+        return NRF_ERROR_CRYPTO_BUSY;
+    }
+
+    key_size = p_info->raw_public_key_size + 1;
+
+    crys_error = CRYS_ECPKI_ExportPublKey(&p_pub->key.cc310_public_key,
+                                          CRYS_EC_PointUncompressed,
+                                          ucompressed_key,
+                                          &key_size);
+
+    cc310_backend_mutex_unlock();
+
+    if ((key_size != p_info->raw_public_key_size + 1)
+        || (ucompressed_key[0] != CC310_UNCOMPRESSED_PUBLIC_KEY_ID_BYTE))
+    {
+        return NRF_ERROR_CRYPTO_INTERNAL;
+    }
+
+    memcpy(p_raw_data, &ucompressed_key[1], p_info->raw_public_key_size);
+
+    result = nrf_crypto_backend_cc310_ecc_error_convert(crys_error);
+    return result;
+}
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP160R1)
+const nrf_crypto_ecc_curve_info_t g_nrf_crypto_ecc_secp160r1_curve_info =
+{
+    .public_key_size      = sizeof(nrf_crypto_backend_cc310_ecc_public_key_t),
+    .private_key_size     = sizeof(nrf_crypto_backend_cc310_ecc_private_key_t),
+    .curve_type           = NRF_CRYPTO_ECC_SECP160R1_CURVE_TYPE,
+    .raw_private_key_size = NRF_CRYPTO_ECC_SECP160R1_RAW_PRIVATE_KEY_SIZE,
+    .raw_public_key_size  = NRF_CRYPTO_ECC_SECP160R1_RAW_PUBLIC_KEY_SIZE,
+    .p_backend_data       = (void *)CRYS_ECPKI_DomainID_secp160r1,
+};
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP160R2)
+const nrf_crypto_ecc_curve_info_t g_nrf_crypto_ecc_secp160r2_curve_info =
+{
+    .public_key_size      = sizeof(nrf_crypto_backend_cc310_ecc_public_key_t),
+    .private_key_size     = sizeof(nrf_crypto_backend_cc310_ecc_private_key_t),
+    .curve_type           = NRF_CRYPTO_ECC_SECP160R2_CURVE_TYPE,
+    .raw_private_key_size = NRF_CRYPTO_ECC_SECP160R2_RAW_PRIVATE_KEY_SIZE,
+    .raw_public_key_size  = NRF_CRYPTO_ECC_SECP160R2_RAW_PUBLIC_KEY_SIZE,
+    .p_backend_data       = (void *)CRYS_ECPKI_DomainID_secp160r2,
+};
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP192R1)
+const nrf_crypto_ecc_curve_info_t g_nrf_crypto_ecc_secp192r1_curve_info =
+{
+    .public_key_size      = sizeof(nrf_crypto_backend_cc310_ecc_public_key_t),
+    .private_key_size     = sizeof(nrf_crypto_backend_cc310_ecc_private_key_t),
+    .curve_type           = NRF_CRYPTO_ECC_SECP192R1_CURVE_TYPE,
+    .raw_private_key_size = NRF_CRYPTO_ECC_SECP192R1_RAW_PRIVATE_KEY_SIZE,
+    .raw_public_key_size  = NRF_CRYPTO_ECC_SECP192R1_RAW_PUBLIC_KEY_SIZE,
+    .p_backend_data       = (void *)CRYS_ECPKI_DomainID_secp192r1,
+};
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP224R1)
+const nrf_crypto_ecc_curve_info_t g_nrf_crypto_ecc_secp224r1_curve_info =
+{
+    .public_key_size      = sizeof(nrf_crypto_backend_cc310_ecc_public_key_t),
+    .private_key_size     = sizeof(nrf_crypto_backend_cc310_ecc_private_key_t),
+    .curve_type           = NRF_CRYPTO_ECC_SECP224R1_CURVE_TYPE,
+    .raw_private_key_size = NRF_CRYPTO_ECC_SECP224R1_RAW_PRIVATE_KEY_SIZE,
+    .raw_public_key_size  = NRF_CRYPTO_ECC_SECP224R1_RAW_PUBLIC_KEY_SIZE,
+    .p_backend_data       = (void *)CRYS_ECPKI_DomainID_secp224r1,
+};
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP256R1)
+const nrf_crypto_ecc_curve_info_t g_nrf_crypto_ecc_secp256r1_curve_info =
+{
+    .public_key_size      = sizeof(nrf_crypto_backend_cc310_ecc_public_key_t),
+    .private_key_size     = sizeof(nrf_crypto_backend_cc310_ecc_private_key_t),
+    .curve_type           = NRF_CRYPTO_ECC_SECP256R1_CURVE_TYPE,
+    .raw_private_key_size = NRF_CRYPTO_ECC_SECP256R1_RAW_PRIVATE_KEY_SIZE,
+    .raw_public_key_size  = NRF_CRYPTO_ECC_SECP256R1_RAW_PUBLIC_KEY_SIZE,
+    .p_backend_data       = (void *)CRYS_ECPKI_DomainID_secp256r1,
+};
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP384R1)
+const nrf_crypto_ecc_curve_info_t g_nrf_crypto_ecc_secp384r1_curve_info =
+{
+    .public_key_size      = sizeof(nrf_crypto_backend_cc310_ecc_public_key_t),
+    .private_key_size     = sizeof(nrf_crypto_backend_cc310_ecc_private_key_t),
+    .curve_type           = NRF_CRYPTO_ECC_SECP384R1_CURVE_TYPE,
+    .raw_private_key_size = NRF_CRYPTO_ECC_SECP384R1_RAW_PRIVATE_KEY_SIZE,
+    .raw_public_key_size  = NRF_CRYPTO_ECC_SECP384R1_RAW_PUBLIC_KEY_SIZE,
+    .p_backend_data       = (void *)CRYS_ECPKI_DomainID_secp384r1,
+};
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP521R1)
+const nrf_crypto_ecc_curve_info_t g_nrf_crypto_ecc_secp521r1_curve_info =
+{
+    .public_key_size      = sizeof(nrf_crypto_backend_cc310_ecc_public_key_t),
+    .private_key_size     = sizeof(nrf_crypto_backend_cc310_ecc_private_key_t),
+    .curve_type           = NRF_CRYPTO_ECC_SECP521R1_CURVE_TYPE,
+    .raw_private_key_size = NRF_CRYPTO_ECC_SECP521R1_RAW_PRIVATE_KEY_SIZE,
+    .raw_public_key_size  = NRF_CRYPTO_ECC_SECP521R1_RAW_PUBLIC_KEY_SIZE,
+    .p_backend_data       = (void *)CRYS_ECPKI_DomainID_secp521r1,
+};
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP160K1)
+const nrf_crypto_ecc_curve_info_t g_nrf_crypto_ecc_secp160k1_curve_info =
+{
+    .public_key_size      = sizeof(nrf_crypto_backend_cc310_ecc_public_key_t),
+    .private_key_size     = sizeof(nrf_crypto_backend_cc310_ecc_private_key_t),
+    .curve_type           = NRF_CRYPTO_ECC_SECP160K1_CURVE_TYPE,
+    .raw_private_key_size = NRF_CRYPTO_ECC_SECP160K1_RAW_PRIVATE_KEY_SIZE,
+    .raw_public_key_size  = NRF_CRYPTO_ECC_SECP160K1_RAW_PUBLIC_KEY_SIZE,
+    .p_backend_data       = (void *)CRYS_ECPKI_DomainID_secp160k1,
+};
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP192K1)
+const nrf_crypto_ecc_curve_info_t g_nrf_crypto_ecc_secp192k1_curve_info =
+{
+    .public_key_size      = sizeof(nrf_crypto_backend_cc310_ecc_public_key_t),
+    .private_key_size     = sizeof(nrf_crypto_backend_cc310_ecc_private_key_t),
+    .curve_type           = NRF_CRYPTO_ECC_SECP192K1_CURVE_TYPE,
+    .raw_private_key_size = NRF_CRYPTO_ECC_SECP192K1_RAW_PRIVATE_KEY_SIZE,
+    .raw_public_key_size  = NRF_CRYPTO_ECC_SECP192K1_RAW_PUBLIC_KEY_SIZE,
+    .p_backend_data       = (void *)CRYS_ECPKI_DomainID_secp192k1,
+};
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP224K1)
+const nrf_crypto_ecc_curve_info_t g_nrf_crypto_ecc_secp224k1_curve_info =
+{
+    .public_key_size      = sizeof(nrf_crypto_backend_cc310_ecc_public_key_t),
+    .private_key_size     = sizeof(nrf_crypto_backend_cc310_ecc_private_key_t),
+    .curve_type           = NRF_CRYPTO_ECC_SECP224K1_CURVE_TYPE,
+    .raw_private_key_size = NRF_CRYPTO_ECC_SECP224K1_RAW_PRIVATE_KEY_SIZE,
+    .raw_public_key_size  = NRF_CRYPTO_ECC_SECP224K1_RAW_PUBLIC_KEY_SIZE,
+    .p_backend_data       = (void *)CRYS_ECPKI_DomainID_secp224k1,
+};
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP256K1)
+const nrf_crypto_ecc_curve_info_t g_nrf_crypto_ecc_secp256k1_curve_info =
+{
+    .public_key_size      = sizeof(nrf_crypto_backend_cc310_ecc_public_key_t),
+    .private_key_size     = sizeof(nrf_crypto_backend_cc310_ecc_private_key_t),
+    .curve_type           = NRF_CRYPTO_ECC_SECP256K1_CURVE_TYPE,
+    .raw_private_key_size = NRF_CRYPTO_ECC_SECP256K1_RAW_PRIVATE_KEY_SIZE,
+    .raw_public_key_size  = NRF_CRYPTO_ECC_SECP256K1_RAW_PUBLIC_KEY_SIZE,
+    .p_backend_data       = (void *)CRYS_ECPKI_DomainID_secp256k1,
+};
+#endif
+
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310)
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_ecc.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_ecc.h
new file mode 100644
index 0000000..f9f20e2
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_ecc.h
@@ -0,0 +1,548 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef CC310_BACKEND_ECC_H__
+#define CC310_BACKEND_ECC_H__
+
+#include "sdk_config.h"
+#include "nordic_common.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310)
+
+#include <stdbool.h>
+#include "nrf_crypto_ecc_shared.h"
+#include "crys_ecpki_kg.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** @internal @brief Common structure holding private key for CC310.
+ */
+typedef struct
+{
+    nrf_crypto_internal_ecc_key_header_t header;      /**< @internal @brief Common ECC key header */
+    CRYS_ECPKI_UserPrivKey_t             private_key; /**< @internal @brief CC310 specific key representation */
+} nrf_crypto_backend_cc310_ecc_private_key_t;
+
+
+/** @internal @brief Common structure holding public key for CC310.
+ */
+typedef struct
+{
+    nrf_crypto_internal_ecc_key_header_t header;        /**< @internal @brief Common ECC key header */
+    bool                                 key_converted; /**< @internal @brief True if key was already converted from raw_public_key to cc310_public_key */
+    union
+    {
+        CRYS_ECPKI_UserPublKey_t cc310_public_key;    /**< @internal @brief CC310 specific key representation */
+        uint8_t                  raw_public_key[132]; /**< @internal @brief raw key representation */
+    } key;
+} nrf_crypto_backend_cc310_ecc_public_key_t;
+
+
+/** @internal @brief Common structure holding context for key pair generation.
+ */
+typedef struct
+{
+    CRYS_ECPKI_KG_TempData_t temp_data;           /**< @internal @brief Temporary buffer for CC310 internal storage */
+} nrf_crypto_backend_cc310_key_pair_generate_context_t;
+
+
+/** @internal See @ref nrf_crypto_backend_ecc_key_pair_generate_fn_t.
+ */
+ret_code_t nrf_crypto_backend_cc310_key_pair_generate(
+    void * p_context,
+    void * p_private_key,
+    void * p_public_key);
+
+
+/** @internal See @ref nrf_crypto_backend_ecc_private_key_from_raw_fn_t.
+*/
+ret_code_t nrf_crypto_backend_cc310_private_key_from_raw(
+    void          * p_private_key,
+    uint8_t const * p_raw_data);
+
+
+/** @internal See @ref nrf_crypto_backend_ecc_private_key_to_raw_fn_t.
+*/
+ret_code_t nrf_crypto_backend_cc310_private_key_to_raw(
+    void const * p_private_key,
+    uint8_t    * p_raw_data);
+
+
+/** @internal See @ref nrf_crypto_backend_ecc_public_key_from_raw_fn_t.
+*/
+ret_code_t nrf_crypto_backend_cc310_public_key_from_raw(
+    void          * p_public_key,
+    uint8_t const * p_raw_data);
+
+
+/** @internal See @ref nrf_crypto_backend_ecc_public_key_to_raw_fn_t.
+*/
+ret_code_t nrf_crypto_backend_cc310_public_key_to_raw(
+    void const * p_public_key,
+    uint8_t    * p_raw_data);
+
+
+/** @internal @brief Convert error code from CC310 to nrf_crypto error code.
+ *
+ *  @param[in]  crys_error   CC310 error code.
+ *  @return                  nrf_crypto error code.
+ */
+ret_code_t nrf_crypto_backend_cc310_ecc_error_convert(uint32_t crys_error);
+
+
+/** @internal @brief Converts public key from raw to CC310 representation if not converted already.
+ *
+ *  Data are read from p_pub->key.raw_public_key to stored into p_pub->cc310_public_key.
+ *
+ *  @param[in]  p_pub        Public key to convert.
+ *  @param[in]  p_temp_data  Buffer for temporary data used by CC310 lib.
+ *  @return                  nrf_crypto error code.
+ */
+ret_code_t nrf_crypto_backend_cc310_ecc_public_key_convert(
+    nrf_crypto_backend_cc310_ecc_public_key_t * p_pub,
+    CRYS_ECPKI_BUILD_TempData_t               * p_temp_data);
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP160R1)
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_ECC_SECP160R1)
+#error "More than one backend enabled for secp160r1 (NIST 160-bit).");
+#endif
+#define NRF_CRYPTO_ECC_SECP160R1_ENABLED 1
+
+// Aliases for one common CC310 implementation
+#define nrf_crypto_backend_secp160r1_key_pair_generate    nrf_crypto_backend_cc310_key_pair_generate
+#define nrf_crypto_backend_secp160r1_public_key_calculate NULL
+#define nrf_crypto_backend_secp160r1_private_key_from_raw nrf_crypto_backend_cc310_private_key_from_raw
+#define nrf_crypto_backend_secp160r1_private_key_to_raw   nrf_crypto_backend_cc310_private_key_to_raw
+#define nrf_crypto_backend_secp160r1_public_key_from_raw  nrf_crypto_backend_cc310_public_key_from_raw
+#define nrf_crypto_backend_secp160r1_public_key_to_raw    nrf_crypto_backend_cc310_public_key_to_raw
+#define nrf_crypto_backend_secp160r1_private_key_free     NULL
+#define nrf_crypto_backend_secp160r1_public_key_free      NULL
+
+// Context sizes required by CC310
+#define NRF_CRYPTO_BACKEND_SECP160R1_KEY_PAIR_GENERATE_CONTEXT_SIZE \
+    sizeof(nrf_crypto_backend_cc310_key_pair_generate_context_t)
+#define NRF_CRYPTO_BACKEND_SECP160R1_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE 0
+
+// All CC310 curve types share the same data structures for keys
+typedef nrf_crypto_backend_cc310_ecc_private_key_t nrf_crypto_backend_secp160r1_private_key_t;
+typedef nrf_crypto_backend_cc310_ecc_public_key_t  nrf_crypto_backend_secp160r1_public_key_t;
+
+// All CC310 curve types share the same data structures for context
+typedef nrf_crypto_backend_cc310_key_pair_generate_context_t
+    nrf_crypto_backend_secp160r1_key_pair_generate_context_t;
+
+// Dummy typedef for unused context
+typedef uint32_t nrf_crypto_backend_secp160r1_public_key_calculate_context_t;
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP160R1)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP160R2)
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_ECC_SECP160R2)
+#error "More than one backend enabled for secp160r2 (NIST 160-bit).");
+#endif
+#define NRF_CRYPTO_ECC_SECP160R2_ENABLED 1
+
+// Aliases for one common CC310 implementation
+#define nrf_crypto_backend_secp160r2_key_pair_generate    nrf_crypto_backend_cc310_key_pair_generate
+#define nrf_crypto_backend_secp160r2_public_key_calculate NULL
+#define nrf_crypto_backend_secp160r2_private_key_from_raw nrf_crypto_backend_cc310_private_key_from_raw
+#define nrf_crypto_backend_secp160r2_private_key_to_raw   nrf_crypto_backend_cc310_private_key_to_raw
+#define nrf_crypto_backend_secp160r2_public_key_from_raw  nrf_crypto_backend_cc310_public_key_from_raw
+#define nrf_crypto_backend_secp160r2_public_key_to_raw    nrf_crypto_backend_cc310_public_key_to_raw
+#define nrf_crypto_backend_secp160r2_private_key_free     NULL
+#define nrf_crypto_backend_secp160r2_public_key_free      NULL
+
+// Context sizes required by CC310
+#define NRF_CRYPTO_BACKEND_SECP160R2_KEY_PAIR_GENERATE_CONTEXT_SIZE \
+    sizeof(nrf_crypto_backend_cc310_key_pair_generate_context_t)
+#define NRF_CRYPTO_BACKEND_SECP160R2_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE 0
+
+// All CC310 curve types share the same data structures for keys
+typedef nrf_crypto_backend_cc310_ecc_private_key_t nrf_crypto_backend_secp160r2_private_key_t;
+typedef nrf_crypto_backend_cc310_ecc_public_key_t  nrf_crypto_backend_secp160r2_public_key_t;
+
+// All CC310 curve types share the same data structures for context
+typedef nrf_crypto_backend_cc310_key_pair_generate_context_t
+    nrf_crypto_backend_secp160r2_key_pair_generate_context_t;
+
+// Dummy typedef for unused context
+typedef uint32_t nrf_crypto_backend_secp160r2_public_key_calculate_context_t;
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP160R2)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP192R1)
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_ECC_SECP192R1)
+#error "More than one backend enabled for secp192r1 (NIST 192-bit).");
+#endif
+#define NRF_CRYPTO_ECC_SECP192R1_ENABLED 1
+
+// Aliases for one common CC310 implementation
+#define nrf_crypto_backend_secp192r1_key_pair_generate    nrf_crypto_backend_cc310_key_pair_generate
+#define nrf_crypto_backend_secp192r1_public_key_calculate NULL
+#define nrf_crypto_backend_secp192r1_private_key_from_raw nrf_crypto_backend_cc310_private_key_from_raw
+#define nrf_crypto_backend_secp192r1_private_key_to_raw   nrf_crypto_backend_cc310_private_key_to_raw
+#define nrf_crypto_backend_secp192r1_public_key_from_raw  nrf_crypto_backend_cc310_public_key_from_raw
+#define nrf_crypto_backend_secp192r1_public_key_to_raw    nrf_crypto_backend_cc310_public_key_to_raw
+#define nrf_crypto_backend_secp192r1_private_key_free     NULL
+#define nrf_crypto_backend_secp192r1_public_key_free      NULL
+
+// Context sizes required by CC310
+#define NRF_CRYPTO_BACKEND_SECP192R1_KEY_PAIR_GENERATE_CONTEXT_SIZE \
+    sizeof(nrf_crypto_backend_cc310_key_pair_generate_context_t)
+#define NRF_CRYPTO_BACKEND_SECP192R1_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE 0
+
+// All CC310 curve types share the same data structures for keys
+typedef nrf_crypto_backend_cc310_ecc_private_key_t nrf_crypto_backend_secp192r1_private_key_t;
+typedef nrf_crypto_backend_cc310_ecc_public_key_t  nrf_crypto_backend_secp192r1_public_key_t;
+
+// All CC310 curve types share the same data structures for context
+typedef nrf_crypto_backend_cc310_key_pair_generate_context_t
+    nrf_crypto_backend_secp192r1_key_pair_generate_context_t;
+
+// Dummy typedef for unused context
+typedef uint32_t nrf_crypto_backend_secp192r1_public_key_calculate_context_t;
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP192R1)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP224R1)
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_ECC_SECP224R1)
+#error "More than one backend enabled for secp224r1 (NIST 224-bit).");
+#endif
+#define NRF_CRYPTO_ECC_SECP224R1_ENABLED 1
+
+// Aliases for one common CC310 implementation
+#define nrf_crypto_backend_secp224r1_key_pair_generate    nrf_crypto_backend_cc310_key_pair_generate
+#define nrf_crypto_backend_secp224r1_public_key_calculate NULL
+#define nrf_crypto_backend_secp224r1_private_key_from_raw nrf_crypto_backend_cc310_private_key_from_raw
+#define nrf_crypto_backend_secp224r1_private_key_to_raw   nrf_crypto_backend_cc310_private_key_to_raw
+#define nrf_crypto_backend_secp224r1_public_key_from_raw  nrf_crypto_backend_cc310_public_key_from_raw
+#define nrf_crypto_backend_secp224r1_public_key_to_raw    nrf_crypto_backend_cc310_public_key_to_raw
+#define nrf_crypto_backend_secp224r1_private_key_free     NULL
+#define nrf_crypto_backend_secp224r1_public_key_free      NULL
+
+// Context sizes required by CC310
+#define NRF_CRYPTO_BACKEND_SECP224R1_KEY_PAIR_GENERATE_CONTEXT_SIZE \
+    sizeof(nrf_crypto_backend_cc310_key_pair_generate_context_t)
+#define NRF_CRYPTO_BACKEND_SECP224R1_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE 0
+
+// All CC310 curve types share the same data structures for keys
+typedef nrf_crypto_backend_cc310_ecc_private_key_t nrf_crypto_backend_secp224r1_private_key_t;
+typedef nrf_crypto_backend_cc310_ecc_public_key_t  nrf_crypto_backend_secp224r1_public_key_t;
+
+// All CC310 curve types share the same data structures for context
+typedef nrf_crypto_backend_cc310_key_pair_generate_context_t
+    nrf_crypto_backend_secp224r1_key_pair_generate_context_t;
+
+// Dummy typedef for unused context
+typedef uint32_t nrf_crypto_backend_secp224r1_public_key_calculate_context_t;
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP224R1)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP256R1)
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_ECC_SECP256R1)
+#error "More than one backend enabled for secp256r1 (NIST 256-bit).");
+#endif
+#define NRF_CRYPTO_ECC_SECP256R1_ENABLED 1
+
+// Aliases for one common CC310 implementation
+#define nrf_crypto_backend_secp256r1_key_pair_generate    nrf_crypto_backend_cc310_key_pair_generate
+#define nrf_crypto_backend_secp256r1_public_key_calculate NULL
+#define nrf_crypto_backend_secp256r1_private_key_from_raw nrf_crypto_backend_cc310_private_key_from_raw
+#define nrf_crypto_backend_secp256r1_private_key_to_raw   nrf_crypto_backend_cc310_private_key_to_raw
+#define nrf_crypto_backend_secp256r1_public_key_from_raw  nrf_crypto_backend_cc310_public_key_from_raw
+#define nrf_crypto_backend_secp256r1_public_key_to_raw    nrf_crypto_backend_cc310_public_key_to_raw
+#define nrf_crypto_backend_secp256r1_private_key_free     NULL
+#define nrf_crypto_backend_secp256r1_public_key_free      NULL
+
+// Context sizes required by CC310
+#define NRF_CRYPTO_BACKEND_SECP256R1_KEY_PAIR_GENERATE_CONTEXT_SIZE \
+    sizeof(nrf_crypto_backend_cc310_key_pair_generate_context_t)
+#define NRF_CRYPTO_BACKEND_SECP256R1_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE 0
+
+// All CC310 curve types share the same data structures for keys
+typedef nrf_crypto_backend_cc310_ecc_private_key_t nrf_crypto_backend_secp256r1_private_key_t;
+typedef nrf_crypto_backend_cc310_ecc_public_key_t  nrf_crypto_backend_secp256r1_public_key_t;
+
+// All CC310 curve types share the same data structures for context
+typedef nrf_crypto_backend_cc310_key_pair_generate_context_t
+    nrf_crypto_backend_secp256r1_key_pair_generate_context_t;
+
+// Dummy typedef for unused context
+typedef uint32_t nrf_crypto_backend_secp256r1_public_key_calculate_context_t;
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP256R1)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP384R1)
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_ECC_SECP384R1)
+#error "More than one backend enabled for secp384r1 (NIST 384-bit).");
+#endif
+#define NRF_CRYPTO_ECC_SECP384R1_ENABLED 1
+
+// Aliases for one common CC310 implementation
+#define nrf_crypto_backend_secp384r1_key_pair_generate    nrf_crypto_backend_cc310_key_pair_generate
+#define nrf_crypto_backend_secp384r1_public_key_calculate NULL
+#define nrf_crypto_backend_secp384r1_private_key_from_raw nrf_crypto_backend_cc310_private_key_from_raw
+#define nrf_crypto_backend_secp384r1_private_key_to_raw   nrf_crypto_backend_cc310_private_key_to_raw
+#define nrf_crypto_backend_secp384r1_public_key_from_raw  nrf_crypto_backend_cc310_public_key_from_raw
+#define nrf_crypto_backend_secp384r1_public_key_to_raw    nrf_crypto_backend_cc310_public_key_to_raw
+#define nrf_crypto_backend_secp384r1_private_key_free     NULL
+#define nrf_crypto_backend_secp384r1_public_key_free      NULL
+
+// Context sizes required by CC310
+#define NRF_CRYPTO_BACKEND_SECP384R1_KEY_PAIR_GENERATE_CONTEXT_SIZE \
+    sizeof(nrf_crypto_backend_cc310_key_pair_generate_context_t)
+#define NRF_CRYPTO_BACKEND_SECP384R1_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE 0
+
+// All CC310 curve types share the same data structures for keys
+typedef nrf_crypto_backend_cc310_ecc_private_key_t nrf_crypto_backend_secp384r1_private_key_t;
+typedef nrf_crypto_backend_cc310_ecc_public_key_t  nrf_crypto_backend_secp384r1_public_key_t;
+
+// All CC310 curve types share the same data structures for context
+typedef nrf_crypto_backend_cc310_key_pair_generate_context_t
+    nrf_crypto_backend_secp384r1_key_pair_generate_context_t;
+
+// Dummy typedef for unused context
+typedef uint32_t nrf_crypto_backend_secp384r1_public_key_calculate_context_t;
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP384R1)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP521R1)
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_ECC_SECP521R1)
+#error "More than one backend enabled for secp521r1 (NIST 521-bit).");
+#endif
+#define NRF_CRYPTO_ECC_SECP521R1_ENABLED 1
+
+// Aliases for one common CC310 implementation
+#define nrf_crypto_backend_secp521r1_key_pair_generate    nrf_crypto_backend_cc310_key_pair_generate
+#define nrf_crypto_backend_secp521r1_public_key_calculate NULL
+#define nrf_crypto_backend_secp521r1_private_key_from_raw nrf_crypto_backend_cc310_private_key_from_raw
+#define nrf_crypto_backend_secp521r1_private_key_to_raw   nrf_crypto_backend_cc310_private_key_to_raw
+#define nrf_crypto_backend_secp521r1_public_key_from_raw  nrf_crypto_backend_cc310_public_key_from_raw
+#define nrf_crypto_backend_secp521r1_public_key_to_raw    nrf_crypto_backend_cc310_public_key_to_raw
+#define nrf_crypto_backend_secp521r1_private_key_free     NULL
+#define nrf_crypto_backend_secp521r1_public_key_free      NULL
+
+// Context sizes required by CC310
+#define NRF_CRYPTO_BACKEND_SECP521R1_KEY_PAIR_GENERATE_CONTEXT_SIZE \
+    sizeof(nrf_crypto_backend_cc310_key_pair_generate_context_t)
+#define NRF_CRYPTO_BACKEND_SECP521R1_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE 0
+
+// All CC310 curve types share the same data structures for keys
+typedef nrf_crypto_backend_cc310_ecc_private_key_t nrf_crypto_backend_secp521r1_private_key_t;
+typedef nrf_crypto_backend_cc310_ecc_public_key_t  nrf_crypto_backend_secp521r1_public_key_t;
+
+// All CC310 curve types share the same data structures for context
+typedef nrf_crypto_backend_cc310_key_pair_generate_context_t
+    nrf_crypto_backend_secp521r1_key_pair_generate_context_t;
+
+// Dummy typedef for unused context
+typedef uint32_t nrf_crypto_backend_secp521r1_public_key_calculate_context_t;
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP521R1)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP160K1)
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_ECC_SECP160K1)
+#error "More than one backend enabled for secp160k1 (Koblitz 160-bit).");
+#endif
+#define NRF_CRYPTO_ECC_SECP160K1_ENABLED 1
+
+// Aliases for one common CC310 implementation
+#define nrf_crypto_backend_secp160k1_key_pair_generate    nrf_crypto_backend_cc310_key_pair_generate
+#define nrf_crypto_backend_secp160k1_public_key_calculate NULL
+#define nrf_crypto_backend_secp160k1_private_key_from_raw nrf_crypto_backend_cc310_private_key_from_raw
+#define nrf_crypto_backend_secp160k1_private_key_to_raw   nrf_crypto_backend_cc310_private_key_to_raw
+#define nrf_crypto_backend_secp160k1_public_key_from_raw  nrf_crypto_backend_cc310_public_key_from_raw
+#define nrf_crypto_backend_secp160k1_public_key_to_raw    nrf_crypto_backend_cc310_public_key_to_raw
+#define nrf_crypto_backend_secp160k1_private_key_free     NULL
+#define nrf_crypto_backend_secp160k1_public_key_free      NULL
+
+// Context sizes required by CC310
+#define NRF_CRYPTO_BACKEND_SECP160K1_KEY_PAIR_GENERATE_CONTEXT_SIZE \
+    sizeof(nrf_crypto_backend_cc310_key_pair_generate_context_t)
+#define NRF_CRYPTO_BACKEND_SECP160K1_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE 0
+
+// All CC310 curve types share the same data structures for keys
+typedef nrf_crypto_backend_cc310_ecc_private_key_t nrf_crypto_backend_secp160k1_private_key_t;
+typedef nrf_crypto_backend_cc310_ecc_public_key_t  nrf_crypto_backend_secp160k1_public_key_t;
+
+// All CC310 curve types share the same data structures for context
+typedef nrf_crypto_backend_cc310_key_pair_generate_context_t
+    nrf_crypto_backend_secp160k1_key_pair_generate_context_t;
+
+// Dummy typedef for unused context
+typedef uint32_t nrf_crypto_backend_secp160k1_public_key_calculate_context_t;
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP160K1)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP192K1)
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_ECC_SECP192K1)
+#error "More than one backend enabled for secp192k1 (Koblitz 192-bit).");
+#endif
+#define NRF_CRYPTO_ECC_SECP192K1_ENABLED 1
+
+// Aliases for one common CC310 implementation
+#define nrf_crypto_backend_secp192k1_key_pair_generate    nrf_crypto_backend_cc310_key_pair_generate
+#define nrf_crypto_backend_secp192k1_public_key_calculate NULL
+#define nrf_crypto_backend_secp192k1_private_key_from_raw nrf_crypto_backend_cc310_private_key_from_raw
+#define nrf_crypto_backend_secp192k1_private_key_to_raw   nrf_crypto_backend_cc310_private_key_to_raw
+#define nrf_crypto_backend_secp192k1_public_key_from_raw  nrf_crypto_backend_cc310_public_key_from_raw
+#define nrf_crypto_backend_secp192k1_public_key_to_raw    nrf_crypto_backend_cc310_public_key_to_raw
+#define nrf_crypto_backend_secp192k1_private_key_free     NULL
+#define nrf_crypto_backend_secp192k1_public_key_free      NULL
+
+// Context sizes required by CC310
+#define NRF_CRYPTO_BACKEND_SECP192K1_KEY_PAIR_GENERATE_CONTEXT_SIZE \
+    sizeof(nrf_crypto_backend_cc310_key_pair_generate_context_t)
+#define NRF_CRYPTO_BACKEND_SECP192K1_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE 0
+
+// All CC310 curve types share the same data structures for keys
+typedef nrf_crypto_backend_cc310_ecc_private_key_t nrf_crypto_backend_secp192k1_private_key_t;
+typedef nrf_crypto_backend_cc310_ecc_public_key_t  nrf_crypto_backend_secp192k1_public_key_t;
+
+// All CC310 curve types share the same data structures for context
+typedef nrf_crypto_backend_cc310_key_pair_generate_context_t
+    nrf_crypto_backend_secp192k1_key_pair_generate_context_t;
+
+// Dummy typedef for unused context
+typedef uint32_t nrf_crypto_backend_secp192k1_public_key_calculate_context_t;
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP192K1)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP224K1)
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_ECC_SECP224K1)
+#error "More than one backend enabled for secp224k1 (Koblitz 224-bit).");
+#endif
+#define NRF_CRYPTO_ECC_SECP224K1_ENABLED 1
+
+// Aliases for one common CC310 implementation
+#define nrf_crypto_backend_secp224k1_key_pair_generate    nrf_crypto_backend_cc310_key_pair_generate
+#define nrf_crypto_backend_secp224k1_public_key_calculate NULL
+#define nrf_crypto_backend_secp224k1_private_key_from_raw nrf_crypto_backend_cc310_private_key_from_raw
+#define nrf_crypto_backend_secp224k1_private_key_to_raw   nrf_crypto_backend_cc310_private_key_to_raw
+#define nrf_crypto_backend_secp224k1_public_key_from_raw  nrf_crypto_backend_cc310_public_key_from_raw
+#define nrf_crypto_backend_secp224k1_public_key_to_raw    nrf_crypto_backend_cc310_public_key_to_raw
+#define nrf_crypto_backend_secp224k1_private_key_free     NULL
+#define nrf_crypto_backend_secp224k1_public_key_free      NULL
+
+// Context sizes required by CC310
+#define NRF_CRYPTO_BACKEND_SECP224K1_KEY_PAIR_GENERATE_CONTEXT_SIZE \
+    sizeof(nrf_crypto_backend_cc310_key_pair_generate_context_t)
+#define NRF_CRYPTO_BACKEND_SECP224K1_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE 0
+
+// All CC310 curve types share the same data structures for keys
+typedef nrf_crypto_backend_cc310_ecc_private_key_t nrf_crypto_backend_secp224k1_private_key_t;
+typedef nrf_crypto_backend_cc310_ecc_public_key_t  nrf_crypto_backend_secp224k1_public_key_t;
+
+// All CC310 curve types share the same data structures for context
+typedef nrf_crypto_backend_cc310_key_pair_generate_context_t
+    nrf_crypto_backend_secp224k1_key_pair_generate_context_t;
+
+// Dummy typedef for unused context
+typedef uint32_t nrf_crypto_backend_secp224k1_public_key_calculate_context_t;
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP224K1)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP256K1)
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_ECC_SECP256K1)
+#error "More than one backend enabled for secp256k1 (Koblitz 256-bit).");
+#endif
+#define NRF_CRYPTO_ECC_SECP256K1_ENABLED 1
+
+// Aliases for one common CC310 implementation
+#define nrf_crypto_backend_secp256k1_key_pair_generate    nrf_crypto_backend_cc310_key_pair_generate
+#define nrf_crypto_backend_secp256k1_public_key_calculate NULL
+#define nrf_crypto_backend_secp256k1_private_key_from_raw nrf_crypto_backend_cc310_private_key_from_raw
+#define nrf_crypto_backend_secp256k1_private_key_to_raw   nrf_crypto_backend_cc310_private_key_to_raw
+#define nrf_crypto_backend_secp256k1_public_key_from_raw  nrf_crypto_backend_cc310_public_key_from_raw
+#define nrf_crypto_backend_secp256k1_public_key_to_raw    nrf_crypto_backend_cc310_public_key_to_raw
+#define nrf_crypto_backend_secp256k1_private_key_free     NULL
+#define nrf_crypto_backend_secp256k1_public_key_free      NULL
+
+// Context sizes required by CC310
+#define NRF_CRYPTO_BACKEND_SECP256K1_KEY_PAIR_GENERATE_CONTEXT_SIZE \
+    sizeof(nrf_crypto_backend_cc310_key_pair_generate_context_t)
+#define NRF_CRYPTO_BACKEND_SECP256K1_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE 0
+
+// All CC310 curve types share the same data structures for keys
+typedef nrf_crypto_backend_cc310_ecc_private_key_t nrf_crypto_backend_secp256k1_private_key_t;
+typedef nrf_crypto_backend_cc310_ecc_public_key_t  nrf_crypto_backend_secp256k1_public_key_t;
+
+// All CC310 curve types share the same data structures for context
+typedef nrf_crypto_backend_cc310_key_pair_generate_context_t
+    nrf_crypto_backend_secp256k1_key_pair_generate_context_t;
+
+// Dummy typedef for unused context
+typedef uint32_t nrf_crypto_backend_secp256k1_public_key_calculate_context_t;
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP256K1)
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310)
+
+#endif // CC310_BACKEND_ECC_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_ecdh.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_ecdh.c
new file mode 100644
index 0000000..48c2e5c
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_ecdh.c
@@ -0,0 +1,131 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#include "sdk_config.h"
+#include "nordic_common.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310)
+
+#include <string.h>
+
+#include "nrf_crypto_ecc_shared.h"
+#include "nrf_crypto_ecdh_shared.h"
+#include "nrf_crypto_ecdh.h"
+#include "nrf_crypto_mem.h"
+#include "cc310_backend_mutex.h"
+#include "cc310_backend_shared.h"
+#include "cc310_backend_ecdh.h"
+
+
+ret_code_t nrf_crypto_backend_cc310_ecdh_compute(
+    void       * p_context,
+    void const * p_private_key,
+    void const * p_public_key,
+    uint8_t    * p_shared_secret)
+{
+    ret_code_t    result;
+    CRYSError_t   crys_error;
+    uint32_t      shared_secret_size;
+    uint8_t       aligned_buffer[(NRF_CRYPTO_ECDH_SHARED_SECRET_MAX_SIZE + 3) & ~3];
+    uint8_t     * p_output_buffer;
+    bool          mutex_locked;
+
+    nrf_crypto_backend_cc310_ecdh_compute_context_t * p_ctx =
+        (nrf_crypto_backend_cc310_ecdh_compute_context_t *)p_context;
+
+    nrf_crypto_backend_cc310_ecc_private_key_t  * p_prv =
+        (nrf_crypto_backend_cc310_ecc_private_key_t *)p_private_key;
+
+    nrf_crypto_backend_cc310_ecc_public_key_t   * p_pub =
+        (nrf_crypto_backend_cc310_ecc_public_key_t *)p_public_key;
+
+    nrf_crypto_ecc_curve_info_t const * p_info = p_prv->header.p_info;
+
+    result = nrf_crypto_backend_cc310_ecc_public_key_convert(p_pub, &p_ctx->key_build_temp_data);
+    if (result != NRF_SUCCESS)
+    {
+        return result;
+    }
+
+    shared_secret_size = p_info->raw_private_key_size;
+
+    if ((shared_secret_size & 3) != 0) // Check if shared_secret_size is word aligned
+    {
+        shared_secret_size = (shared_secret_size + 3) & ~3;
+        p_output_buffer = &aligned_buffer[0];
+    }
+    else
+    {
+        p_output_buffer = p_shared_secret;
+    }
+
+    mutex_locked = cc310_backend_mutex_trylock();
+    if (!mutex_locked)
+    {
+        return NRF_ERROR_CRYPTO_BUSY;
+    }
+
+    cc310_backend_enable();
+
+    crys_error = CRYS_ECDH_SVDP_DH(&p_pub->key.cc310_public_key,
+                                   &p_prv->private_key,
+                                   p_output_buffer,
+                                   &shared_secret_size,
+                                   &p_ctx->temp_data);
+
+    cc310_backend_disable();
+
+    cc310_backend_mutex_unlock();
+
+    if (p_output_buffer != p_shared_secret)
+    {
+        //lint -save -e645 (Symbol 'aligned_buffer' may not have been initialized)
+        memcpy(p_shared_secret,
+            &aligned_buffer[3 - ((p_info->raw_private_key_size + 3) & 3)], // Bytes at the beginning that were added during padding are now skipped
+            p_info->raw_private_key_size);
+        //lint -restore
+    }
+
+    result = nrf_crypto_backend_cc310_ecc_error_convert(crys_error);
+    return result;
+}
+
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310)
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_ecdh.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_ecdh.h
new file mode 100644
index 0000000..0fe1dc4
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_ecdh.h
@@ -0,0 +1,182 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef CC310_BACKEND_ECDH_H__
+#define CC310_BACKEND_ECDH_H__
+
+#include "sdk_config.h"
+#include "nordic_common.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310)
+
+#include "nrf_crypto_ecc.h"
+#include "nrf_crypto_ecdh_shared.h"
+#include "crys_ecpki_dh.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/** @internal @brief Common structure holding context for ECDH.
+ */
+typedef union
+{
+    CRYS_ECDH_TempData_t        temp_data;           /**< @internal @brief Temporary buffer for CC310 internal storage */
+    CRYS_ECPKI_BUILD_TempData_t key_build_temp_data; /**< @internal @brief Temporary buffer for CC310 public key build */
+} nrf_crypto_backend_cc310_ecdh_compute_context_t;
+
+
+/** @internal See @ref nrf_crypto_backend_ecdh_compute_fn_t.
+ */
+ret_code_t nrf_crypto_backend_cc310_ecdh_compute(
+    void       * p_context,
+    void const * p_private_key,
+    void const * p_public_key,
+    uint8_t    * p_shared_secret);
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP160R1)
+// Aliases for one common CC310 implementation
+#define nrf_crypto_backend_secp160r1_ecdh_compute nrf_crypto_backend_cc310_ecdh_compute
+#define NRF_CRYPTO_BACKEND_SECP160R1_ECDH_CONTEXT_SIZE \
+    sizeof(nrf_crypto_backend_cc310_ecdh_compute_context_t)
+typedef nrf_crypto_backend_cc310_ecdh_compute_context_t nrf_crypto_backend_secp160r1_ecdh_context_t;
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP160R1)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP160R2)
+// Aliases for one common CC310 implementation
+#define nrf_crypto_backend_secp160r2_ecdh_compute nrf_crypto_backend_cc310_ecdh_compute
+#define NRF_CRYPTO_BACKEND_SECP160R2_ECDH_CONTEXT_SIZE \
+    sizeof(nrf_crypto_backend_cc310_ecdh_compute_context_t)
+typedef nrf_crypto_backend_cc310_ecdh_compute_context_t nrf_crypto_backend_secp160r2_ecdh_context_t;
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP160R2)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP192R1)
+// Aliases for one common CC310 implementation
+#define nrf_crypto_backend_secp192r1_ecdh_compute nrf_crypto_backend_cc310_ecdh_compute
+#define NRF_CRYPTO_BACKEND_SECP192R1_ECDH_CONTEXT_SIZE \
+    sizeof(nrf_crypto_backend_cc310_ecdh_compute_context_t)
+typedef nrf_crypto_backend_cc310_ecdh_compute_context_t nrf_crypto_backend_secp192r1_ecdh_context_t;
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP192R1)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP224R1)
+// Aliases for one common CC310 implementation
+#define nrf_crypto_backend_secp224r1_ecdh_compute nrf_crypto_backend_cc310_ecdh_compute
+#define NRF_CRYPTO_BACKEND_SECP224R1_ECDH_CONTEXT_SIZE \
+    sizeof(nrf_crypto_backend_cc310_ecdh_compute_context_t)
+typedef nrf_crypto_backend_cc310_ecdh_compute_context_t nrf_crypto_backend_secp224r1_ecdh_context_t;
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP224R1)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP256R1)
+// Aliases for one common CC310 implementation
+#define nrf_crypto_backend_secp256r1_ecdh_compute nrf_crypto_backend_cc310_ecdh_compute
+#define NRF_CRYPTO_BACKEND_SECP256R1_ECDH_CONTEXT_SIZE \
+    sizeof(nrf_crypto_backend_cc310_ecdh_compute_context_t)
+typedef nrf_crypto_backend_cc310_ecdh_compute_context_t nrf_crypto_backend_secp256r1_ecdh_context_t;
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP256R1)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP384R1)
+// Aliases for one common CC310 implementation
+#define nrf_crypto_backend_secp384r1_ecdh_compute nrf_crypto_backend_cc310_ecdh_compute
+#define NRF_CRYPTO_BACKEND_SECP384R1_ECDH_CONTEXT_SIZE \
+    sizeof(nrf_crypto_backend_cc310_ecdh_compute_context_t)
+typedef nrf_crypto_backend_cc310_ecdh_compute_context_t nrf_crypto_backend_secp384r1_ecdh_context_t;
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP384R1)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP521R1)
+// Aliases for one common CC310 implementation
+#define nrf_crypto_backend_secp521r1_ecdh_compute nrf_crypto_backend_cc310_ecdh_compute
+#define NRF_CRYPTO_BACKEND_SECP521R1_ECDH_CONTEXT_SIZE \
+    sizeof(nrf_crypto_backend_cc310_ecdh_compute_context_t)
+typedef nrf_crypto_backend_cc310_ecdh_compute_context_t nrf_crypto_backend_secp521r1_ecdh_context_t;
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP521R1)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP160K1)
+// Aliases for one common CC310 implementation
+#define nrf_crypto_backend_secp160k1_ecdh_compute nrf_crypto_backend_cc310_ecdh_compute
+#define NRF_CRYPTO_BACKEND_SECP160K1_ECDH_CONTEXT_SIZE \
+    sizeof(nrf_crypto_backend_cc310_ecdh_compute_context_t)
+typedef nrf_crypto_backend_cc310_ecdh_compute_context_t nrf_crypto_backend_secp160k1_ecdh_context_t;
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP160K1)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP192K1)
+// Aliases for one common CC310 implementation
+#define nrf_crypto_backend_secp192k1_ecdh_compute nrf_crypto_backend_cc310_ecdh_compute
+#define NRF_CRYPTO_BACKEND_SECP192K1_ECDH_CONTEXT_SIZE \
+    sizeof(nrf_crypto_backend_cc310_ecdh_compute_context_t)
+typedef nrf_crypto_backend_cc310_ecdh_compute_context_t nrf_crypto_backend_secp192k1_ecdh_context_t;
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP192K1)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP224K1)
+// Aliases for one common CC310 implementation
+#define nrf_crypto_backend_secp224k1_ecdh_compute nrf_crypto_backend_cc310_ecdh_compute
+#define NRF_CRYPTO_BACKEND_SECP224K1_ECDH_CONTEXT_SIZE \
+    sizeof(nrf_crypto_backend_cc310_ecdh_compute_context_t)
+typedef nrf_crypto_backend_cc310_ecdh_compute_context_t nrf_crypto_backend_secp224k1_ecdh_context_t;
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP224K1)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP256K1)
+// Aliases for one common CC310 implementation
+#define nrf_crypto_backend_secp256k1_ecdh_compute nrf_crypto_backend_cc310_ecdh_compute
+#define NRF_CRYPTO_BACKEND_SECP256K1_ECDH_CONTEXT_SIZE \
+    sizeof(nrf_crypto_backend_cc310_ecdh_compute_context_t)
+typedef nrf_crypto_backend_cc310_ecdh_compute_context_t nrf_crypto_backend_secp256k1_ecdh_context_t;
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP256K1)
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310)
+
+#endif // CC310_BACKEND_ECDH_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_ecdsa.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_ecdsa.c
new file mode 100644
index 0000000..69a1a86
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_ecdsa.c
@@ -0,0 +1,223 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#include "sdk_config.h"
+#include "nordic_common.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310)
+
+#include <string.h>
+#include "ssi_pal_types.h"
+#include "ssi_pal_mem.h"
+#include "sns_silib.h"
+#include "crys_rnd.h"
+#include "crys_ecpki_ecdsa.h"
+#include "crys_ecpki_error.h"
+#include "crys_kdf_error.h"
+#include "crys_hash_error.h"
+#include "nrf_crypto_error.h"
+#include "nrf_crypto_ecc_shared.h"
+#include "nrf_crypto_ecdsa_shared.h"
+#include "nrf_crypto_ecdsa.h"
+#include "cc310_backend_ecdsa.h"
+#include "cc310_backend_shared.h"
+#include "cc310_backend_mutex.h"
+
+
+#define CC310_SHA1_DIGEST_SIZE   (160 / 8)  /**< @internal @brief Digest size of SHA-1 */
+#define CC310_SHA224_DIGEST_SIZE (224 / 8)  /**< @internal @brief Digest size of SHA-224 */
+#define CC310_SHA256_DIGEST_SIZE (256 / 8)  /**< @internal @brief Digest size of SHA-256 */
+#define CC310_SHA384_DIGEST_SIZE (384 / 8)  /**< @internal @brief Digest size of SHA-384 */
+#define CC310_SHA512_DIGEST_SIZE (512 / 8)  /**< @internal @brief Digest size of SHA-512 */
+
+
+/** @internal @brief Returns enum value of @ref CRYS_ECPKI_HASH_OpMode_t based on provided hash size.
+ *
+ * @param[in] data_size  Hash size
+ * @return               Value from @ref CRYS_ECPKI_HASH_OpMode_t or CRYS_ECPKI_HASH_OpModeLast if
+ *                       cannot find implemented hash with provided size.
+ */
+static CRYS_ECPKI_HASH_OpMode_t hash_mode_from_size(uint32_t data_size)
+{
+    CRYS_ECPKI_HASH_OpMode_t hash_mode;
+
+    switch (data_size)
+    {
+        case CC310_SHA1_DIGEST_SIZE:
+            hash_mode = CRYS_ECPKI_AFTER_HASH_SHA1_mode;
+            break;
+
+        case CC310_SHA224_DIGEST_SIZE:
+            hash_mode = CRYS_ECPKI_AFTER_HASH_SHA224_mode;
+            break;
+
+        case CC310_SHA256_DIGEST_SIZE:
+            hash_mode = CRYS_ECPKI_AFTER_HASH_SHA256_mode;
+            break;
+
+        case CC310_SHA384_DIGEST_SIZE:
+            hash_mode = CRYS_ECPKI_AFTER_HASH_SHA384_mode;
+            break;
+
+        case CC310_SHA512_DIGEST_SIZE:
+            hash_mode = CRYS_ECPKI_AFTER_HASH_SHA512_mode;
+            break;
+
+        default:
+            hash_mode = CRYS_ECPKI_HASH_OpModeLast;
+            break;
+    }
+
+    return hash_mode;
+}
+
+
+ret_code_t nrf_crypto_backend_cc310_sign(
+    void           * p_context,
+    void     const * p_private_key,
+    uint8_t  const * p_data,
+    size_t           data_size,
+    uint8_t        * p_signature)
+{
+    ret_code_t               result;
+    CRYSError_t              crys_error;
+    uint32_t                 signature_size;
+    CRYS_ECPKI_HASH_OpMode_t hash_mode = hash_mode_from_size(data_size);
+    bool                     mutex_locked;
+
+    nrf_crypto_backend_cc310_sign_context_t * p_ctx =
+        (nrf_crypto_backend_cc310_sign_context_t *)p_context;
+
+    nrf_crypto_backend_cc310_ecc_private_key_t * p_prv =
+        (nrf_crypto_backend_cc310_ecc_private_key_t *)p_private_key;
+
+    nrf_crypto_ecc_curve_info_t const * p_info = p_prv->header.p_info;
+
+    if (hash_mode == CRYS_ECPKI_HASH_OpModeLast)
+    {
+        return NRF_ERROR_CRYPTO_INPUT_LENGTH;
+    }
+
+    signature_size = p_info->raw_public_key_size;
+
+    mutex_locked = cc310_backend_mutex_trylock();
+    VERIFY_TRUE(mutex_locked, NRF_ERROR_CRYPTO_BUSY);
+
+    cc310_backend_enable();
+
+    crys_error = CRYS_ECDSA_Sign(p_context,
+                                 nrf_crypto_backend_cc310_rng,
+                                 &p_ctx->user_context,
+                                 &p_prv->private_key,
+                                 hash_mode,
+                                 (uint8_t *)p_data,
+                                 data_size,
+                                 p_signature,
+                                 &signature_size);
+
+    cc310_backend_disable();
+
+    cc310_backend_mutex_unlock();
+
+    result = nrf_crypto_backend_cc310_ecc_error_convert(crys_error);
+
+    if (result == NRF_SUCCESS && signature_size != p_info->raw_public_key_size)
+    {
+        return NRF_ERROR_CRYPTO_INTERNAL;
+    }
+
+    return result;
+}
+
+
+ret_code_t nrf_crypto_backend_cc310_verify(
+    void           * p_context,
+    void     const * p_public_key,
+    uint8_t  const * p_data,
+    size_t           data_size,
+    uint8_t  const * p_signature)
+{
+    ret_code_t               result;
+    CRYSError_t              crys_error;
+    CRYS_ECPKI_HASH_OpMode_t hash_mode = hash_mode_from_size(data_size);
+    bool                     mutex_locked;
+
+    nrf_crypto_backend_cc310_verify_context_t * p_ctx =
+        (nrf_crypto_backend_cc310_verify_context_t *)p_context;
+
+    nrf_crypto_backend_cc310_ecc_public_key_t * p_pub =
+        (nrf_crypto_backend_cc310_ecc_public_key_t *)p_public_key;
+
+    nrf_crypto_ecc_curve_info_t const * p_info = p_pub->header.p_info;
+
+    result = nrf_crypto_backend_cc310_ecc_public_key_convert(p_pub, &p_ctx->key_build_temp_data);
+    if (result != NRF_SUCCESS)
+    {
+        return result;
+    }
+
+    if (hash_mode == CRYS_ECPKI_HASH_OpModeLast)
+    {
+        return NRF_ERROR_CRYPTO_INPUT_LENGTH;
+    }
+
+    mutex_locked = cc310_backend_mutex_trylock();
+    VERIFY_TRUE(mutex_locked, NRF_ERROR_CRYPTO_BUSY);
+
+    cc310_backend_enable();
+
+    crys_error = CRYS_ECDSA_Verify(&p_ctx->user_context,
+                                   &p_pub->key.cc310_public_key,
+                                   hash_mode,
+                                   (uint8_t *)p_signature,
+                                   p_info->raw_public_key_size,
+                                   (uint8_t *)p_data,
+                                   data_size);
+
+    cc310_backend_disable();
+
+    cc310_backend_mutex_unlock();
+
+    result = nrf_crypto_backend_cc310_ecc_error_convert(crys_error);
+    return result;
+}
+
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310)
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_ecdsa.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_ecdsa.h
new file mode 100644
index 0000000..b57c18e
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_ecdsa.h
@@ -0,0 +1,234 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef CC310_BACKEND_ECDSA_H__
+#define CC310_BACKEND_ECDSA_H__
+
+#include "sdk_config.h"
+#include "nordic_common.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310)
+
+#include "nrf_crypto_ecc_shared.h"
+#include "nrf_crypto_ecdsa_shared.h"
+#include "crys_ecpki_types.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/** @internal @brief Common structure holding context for ECDSA sign.
+ */
+typedef struct
+{
+    CRYS_ECDSA_SignUserContext_t user_context;        /**< @internal @brief Temporary buffer for CC310 internal storage */
+} nrf_crypto_backend_cc310_sign_context_t;
+
+
+/** @internal @brief Common structure holding context for ECDSA verify.
+ */
+typedef union
+{
+    CRYS_ECDSA_VerifyUserContext_t user_context;        /**< @internal @brief Temporary buffer for CC310 internal storage */
+    CRYS_ECPKI_BUILD_TempData_t    key_build_temp_data; /**< @internal @brief Temporary buffer for CC310 public key build */
+} nrf_crypto_backend_cc310_verify_context_t;
+
+
+/** @internal See @ref nrf_crypto_backend_ecdsa_sign_fn_t.
+ */
+ret_code_t nrf_crypto_backend_cc310_sign(
+    void           * p_context,
+    void     const * p_private_key,
+    uint8_t  const * p_data,
+    size_t           data_size,
+    uint8_t        * p_signature);
+
+
+/** @internal See @ref nrf_crypto_backend_ecdsa_verify_fn_t.
+ */
+ret_code_t nrf_crypto_backend_cc310_verify(
+    void           * p_context,
+    void     const * p_public_key,
+    uint8_t  const * p_data,
+    size_t           data_size,
+    uint8_t  const * p_signature);
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP160R1)
+#define NRF_CRYPTO_BACKEND_SECP160R1_SIGN_CONTEXT_SIZE \
+    sizeof(nrf_crypto_backend_cc310_sign_context_t)
+#define NRF_CRYPTO_BACKEND_SECP160R1_VERIFY_CONTEXT_SIZE \
+    sizeof(nrf_crypto_backend_cc310_verify_context_t)
+typedef nrf_crypto_backend_cc310_sign_context_t   nrf_crypto_backend_secp160r1_sign_context_t;
+typedef nrf_crypto_backend_cc310_verify_context_t nrf_crypto_backend_secp160r1_verify_context_t;
+#define nrf_crypto_backend_secp160r1_sign         nrf_crypto_backend_cc310_sign
+#define nrf_crypto_backend_secp160r1_verify       nrf_crypto_backend_cc310_verify
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP160R2)
+#define NRF_CRYPTO_BACKEND_SECP160R2_SIGN_CONTEXT_SIZE \
+    sizeof(nrf_crypto_backend_cc310_sign_context_t)
+#define NRF_CRYPTO_BACKEND_SECP160R2_VERIFY_CONTEXT_SIZE \
+    sizeof(nrf_crypto_backend_cc310_verify_context_t)
+typedef nrf_crypto_backend_cc310_sign_context_t   nrf_crypto_backend_secp160r2_sign_context_t;
+typedef nrf_crypto_backend_cc310_verify_context_t nrf_crypto_backend_secp160r2_verify_context_t;
+#define nrf_crypto_backend_secp160r2_sign         nrf_crypto_backend_cc310_sign
+#define nrf_crypto_backend_secp160r2_verify       nrf_crypto_backend_cc310_verify
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP192R1)
+#define NRF_CRYPTO_BACKEND_SECP192R1_SIGN_CONTEXT_SIZE \
+    sizeof(nrf_crypto_backend_cc310_sign_context_t)
+#define NRF_CRYPTO_BACKEND_SECP192R1_VERIFY_CONTEXT_SIZE \
+    sizeof(nrf_crypto_backend_cc310_verify_context_t)
+typedef nrf_crypto_backend_cc310_sign_context_t   nrf_crypto_backend_secp192r1_sign_context_t;
+typedef nrf_crypto_backend_cc310_verify_context_t nrf_crypto_backend_secp192r1_verify_context_t;
+#define nrf_crypto_backend_secp192r1_sign         nrf_crypto_backend_cc310_sign
+#define nrf_crypto_backend_secp192r1_verify       nrf_crypto_backend_cc310_verify
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP224R1)
+#define NRF_CRYPTO_BACKEND_SECP224R1_SIGN_CONTEXT_SIZE \
+    sizeof(nrf_crypto_backend_cc310_sign_context_t)
+#define NRF_CRYPTO_BACKEND_SECP224R1_VERIFY_CONTEXT_SIZE \
+    sizeof(nrf_crypto_backend_cc310_verify_context_t)
+typedef nrf_crypto_backend_cc310_sign_context_t   nrf_crypto_backend_secp224r1_sign_context_t;
+typedef nrf_crypto_backend_cc310_verify_context_t nrf_crypto_backend_secp224r1_verify_context_t;
+#define nrf_crypto_backend_secp224r1_sign         nrf_crypto_backend_cc310_sign
+#define nrf_crypto_backend_secp224r1_verify       nrf_crypto_backend_cc310_verify
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP256R1)
+#define NRF_CRYPTO_BACKEND_SECP256R1_SIGN_CONTEXT_SIZE \
+    sizeof(nrf_crypto_backend_cc310_sign_context_t)
+#define NRF_CRYPTO_BACKEND_SECP256R1_VERIFY_CONTEXT_SIZE \
+    sizeof(nrf_crypto_backend_cc310_verify_context_t)
+typedef nrf_crypto_backend_cc310_sign_context_t   nrf_crypto_backend_secp256r1_sign_context_t;
+typedef nrf_crypto_backend_cc310_verify_context_t nrf_crypto_backend_secp256r1_verify_context_t;
+#define nrf_crypto_backend_secp256r1_sign         nrf_crypto_backend_cc310_sign
+#define nrf_crypto_backend_secp256r1_verify       nrf_crypto_backend_cc310_verify
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP384R1)
+#define NRF_CRYPTO_BACKEND_SECP384R1_SIGN_CONTEXT_SIZE \
+    sizeof(nrf_crypto_backend_cc310_sign_context_t)
+#define NRF_CRYPTO_BACKEND_SECP384R1_VERIFY_CONTEXT_SIZE \
+    sizeof(nrf_crypto_backend_cc310_verify_context_t)
+typedef nrf_crypto_backend_cc310_sign_context_t   nrf_crypto_backend_secp384r1_sign_context_t;
+typedef nrf_crypto_backend_cc310_verify_context_t nrf_crypto_backend_secp384r1_verify_context_t;
+#define nrf_crypto_backend_secp384r1_sign         nrf_crypto_backend_cc310_sign
+#define nrf_crypto_backend_secp384r1_verify       nrf_crypto_backend_cc310_verify
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP521R1)
+#define NRF_CRYPTO_BACKEND_SECP521R1_SIGN_CONTEXT_SIZE \
+    sizeof(nrf_crypto_backend_cc310_sign_context_t)
+#define NRF_CRYPTO_BACKEND_SECP521R1_VERIFY_CONTEXT_SIZE \
+    sizeof(nrf_crypto_backend_cc310_verify_context_t)
+typedef nrf_crypto_backend_cc310_sign_context_t   nrf_crypto_backend_secp521r1_sign_context_t;
+typedef nrf_crypto_backend_cc310_verify_context_t nrf_crypto_backend_secp521r1_verify_context_t;
+#define nrf_crypto_backend_secp521r1_sign         nrf_crypto_backend_cc310_sign
+#define nrf_crypto_backend_secp521r1_verify       nrf_crypto_backend_cc310_verify
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP160K1)
+#define NRF_CRYPTO_BACKEND_SECP160K1_SIGN_CONTEXT_SIZE \
+    sizeof(nrf_crypto_backend_cc310_sign_context_t)
+#define NRF_CRYPTO_BACKEND_SECP160K1_VERIFY_CONTEXT_SIZE \
+    sizeof(nrf_crypto_backend_cc310_verify_context_t)
+typedef nrf_crypto_backend_cc310_sign_context_t   nrf_crypto_backend_secp160k1_sign_context_t;
+typedef nrf_crypto_backend_cc310_verify_context_t nrf_crypto_backend_secp160k1_verify_context_t;
+#define nrf_crypto_backend_secp160k1_sign         nrf_crypto_backend_cc310_sign
+#define nrf_crypto_backend_secp160k1_verify       nrf_crypto_backend_cc310_verify
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP192K1)
+#define NRF_CRYPTO_BACKEND_SECP192K1_SIGN_CONTEXT_SIZE \
+    sizeof(nrf_crypto_backend_cc310_sign_context_t)
+#define NRF_CRYPTO_BACKEND_SECP192K1_VERIFY_CONTEXT_SIZE \
+    sizeof(nrf_crypto_backend_cc310_verify_context_t)
+typedef nrf_crypto_backend_cc310_sign_context_t   nrf_crypto_backend_secp192k1_sign_context_t;
+typedef nrf_crypto_backend_cc310_verify_context_t nrf_crypto_backend_secp192k1_verify_context_t;
+#define nrf_crypto_backend_secp192k1_sign         nrf_crypto_backend_cc310_sign
+#define nrf_crypto_backend_secp192k1_verify       nrf_crypto_backend_cc310_verify
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP224K1)
+#define NRF_CRYPTO_BACKEND_SECP224K1_SIGN_CONTEXT_SIZE \
+    sizeof(nrf_crypto_backend_cc310_sign_context_t)
+#define NRF_CRYPTO_BACKEND_SECP224K1_VERIFY_CONTEXT_SIZE \
+    sizeof(nrf_crypto_backend_cc310_verify_context_t)
+typedef nrf_crypto_backend_cc310_sign_context_t   nrf_crypto_backend_secp224k1_sign_context_t;
+typedef nrf_crypto_backend_cc310_verify_context_t nrf_crypto_backend_secp224k1_verify_context_t;
+#define nrf_crypto_backend_secp224k1_sign         nrf_crypto_backend_cc310_sign
+#define nrf_crypto_backend_secp224k1_verify       nrf_crypto_backend_cc310_verify
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_ECC_SECP256K1)
+#define NRF_CRYPTO_BACKEND_SECP256K1_SIGN_CONTEXT_SIZE \
+    sizeof(nrf_crypto_backend_cc310_sign_context_t)
+#define NRF_CRYPTO_BACKEND_SECP256K1_VERIFY_CONTEXT_SIZE \
+    sizeof(nrf_crypto_backend_cc310_verify_context_t)
+typedef nrf_crypto_backend_cc310_sign_context_t   nrf_crypto_backend_secp256k1_sign_context_t;
+typedef nrf_crypto_backend_cc310_verify_context_t nrf_crypto_backend_secp256k1_verify_context_t;
+#define nrf_crypto_backend_secp256k1_sign         nrf_crypto_backend_cc310_sign
+#define nrf_crypto_backend_secp256k1_verify       nrf_crypto_backend_cc310_verify
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310)
+
+#endif // CC310_BACKEND_ECDSA_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_hash.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_hash.c
new file mode 100644
index 0000000..b1f91e1
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_hash.c
@@ -0,0 +1,311 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#include "sdk_common.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310)
+
+#include "nrf.h"
+#include "cc310_backend_hash.h"
+#include "crys_hash.h"
+#include "crys_hash_error.h"
+#include "nrf_crypto_init.h"
+#include "nrf_crypto_types.h"
+#include "nrf_crypto_error.h"
+#include "nrf_crypto_hash_shared.h"
+#include "sdk_macros.h"
+#include "nrf_log.h"
+#include "nrf_assert.h"
+#include "cc310_backend_mutex.h"
+#include "cc310_backend_shared.h"
+#include <drivers/nrfx_common.h>
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_HASH_SHA256) || \
+    NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_HASH_SHA512) 
+
+static ret_code_t hash_result_get(CRYSError_t error)
+{
+    ret_code_t ret_val;
+
+    switch (error)
+    {
+        case CRYS_OK:
+            ret_val = NRF_SUCCESS;
+            break;
+
+        case CRYS_HASH_INVALID_USER_CONTEXT_POINTER_ERROR:
+            ret_val = NRF_ERROR_CRYPTO_CONTEXT_NULL;
+            break;
+
+        case CRYS_HASH_ILLEGAL_OPERATION_MODE_ERROR:
+            ret_val = NRF_ERROR_CRYPTO_FEATURE_UNAVAILABLE;
+            break;
+
+        case CRYS_HASH_USER_CONTEXT_CORRUPTED_ERROR:
+            ret_val = NRF_ERROR_CRYPTO_CONTEXT_NOT_INITIALIZED;
+            break;
+
+        // May be added to specialized errors for hash.
+        case CRYS_HASH_LAST_BLOCK_ALREADY_PROCESSED_ERROR:
+            ret_val = NRF_ERROR_CRYPTO_INTERNAL;
+            break;
+
+        case CRYS_HASH_IS_NOT_SUPPORTED:
+            ret_val = NRF_ERROR_CRYPTO_FEATURE_UNAVAILABLE;
+            break;
+
+        default:
+            ret_val = NRF_ERROR_CRYPTO_INTERNAL;
+            break;
+    }
+
+    return ret_val;
+}
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_HASH_SHA256)
+
+static ret_code_t cc310_backend_hash_sha256_init(void * const p_context)
+{
+    uint32_t                        ret_val;
+    CRYSError_t                     crys_error;
+    CRYS_HASH_OperationMode_t       hash_mode = CRYS_HASH_SHA256_mode;
+
+    // No parameter testing on this level.
+    // This has been done on upper level.
+
+    CRYS_HASHUserContext_t * const p_backend_context
+        = &(((nrf_crypto_backend_hash_sha256_context_t *)p_context)->context);
+
+    crys_error = CRYS_HASH_Init(p_backend_context, hash_mode);
+
+    ret_val = hash_result_get(crys_error);
+
+    return ret_val;
+}
+
+
+static ret_code_t cc310_backend_hash_sha256_update(void        * const p_context,
+                                                   uint8_t     const * p_data,
+                                                   size_t              size)
+{
+    ret_code_t          ret_val;
+    CRYSError_t         crys_error;
+    bool                mutex_locked;
+    size_t              cur_len;
+    size_t              len_left  = size;
+    uint8_t const *     p_cur     = p_data;
+
+    // Limited parameter testing on this level.
+    // This has been done on upper level.
+
+    CRYS_HASHUserContext_t * const p_backend_context
+        = &(((nrf_crypto_backend_hash_sha256_context_t *)p_context)->context);
+
+    // Data in flash could lead to silently calculating wrong Hash.
+    VERIFY_TRUE(nrfx_is_in_ram(p_data), NRF_ERROR_CRYPTO_INPUT_LOCATION);
+
+    mutex_locked = cc310_backend_mutex_trylock();
+    VERIFY_TRUE(mutex_locked, NRF_ERROR_CRYPTO_BUSY);
+
+    cc310_backend_enable();
+
+    // If the input is larger than CC310_MAX_LENGTH_DMA_OPERATIONS, split into smaller
+    do
+    {
+        cur_len = (len_left > CC310_MAX_LENGTH_DMA_OPERATIONS) ?
+            CC310_MAX_LENGTH_DMA_OPERATIONS : len_left;
+
+        crys_error = CRYS_HASH_Update(p_backend_context, (uint8_t *)p_cur, cur_len);
+
+        len_left -= cur_len;
+        p_cur += cur_len;
+
+    } while (crys_error == CRYS_OK && len_left > 0);
+
+    cc310_backend_disable();
+
+    cc310_backend_mutex_unlock();
+
+    ret_val = hash_result_get(crys_error);
+
+
+    return ret_val;
+}
+
+
+static ret_code_t cc310_backend_hash_sha256_finalize(void      * const p_context,
+                                                     uint8_t         * p_digest,
+                                                     size_t    * const p_digest_size)
+{
+    ret_code_t              ret_val;
+    CRYSError_t             crys_error;
+    bool                    mutex_locked;
+    CRYS_HASH_Result_t    * p_int_digest = (CRYS_HASH_Result_t *)p_digest;
+
+    // Limited parameter testing on this level.
+    // This has been done on upper level.
+
+    CRYS_HASHUserContext_t * const p_backend_context
+        = &(((nrf_crypto_backend_hash_sha256_context_t * )p_context)->context);
+
+    mutex_locked = cc310_backend_mutex_trylock();
+    VERIFY_TRUE(mutex_locked, NRF_ERROR_CRYPTO_BUSY);
+
+    // Do the hash finalize calculation
+    cc310_backend_enable();
+
+    crys_error = CRYS_HASH_Finish(p_backend_context, *p_int_digest);
+
+    cc310_backend_disable();
+
+    cc310_backend_mutex_unlock();
+
+    ret_val = hash_result_get(crys_error);
+    if (ret_val == NRF_SUCCESS)
+    {
+        *p_digest_size = NRF_CRYPTO_HASH_SIZE_SHA256;
+    }
+
+    return ret_val;
+}
+
+
+const nrf_crypto_hash_info_t g_nrf_crypto_hash_sha256_info =
+{
+    .init_fn        = cc310_backend_hash_sha256_init,
+    .update_fn      = cc310_backend_hash_sha256_update,
+    .finalize_fn    = cc310_backend_hash_sha256_finalize,
+    .digest_size    = NRF_CRYPTO_HASH_SIZE_SHA256,
+    .context_size   = sizeof(nrf_crypto_backend_hash_sha256_context_t),
+    .hash_mode      = NRF_CRYPTO_HASH_MODE_SHA256
+};
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_HASH_SHA256)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_HASH_SHA512)
+
+// SHA-512 does not use CC310 hardware and therefore will not use a mutex lock
+
+static ret_code_t cc310_backend_hash_sha512_init(void * p_context)
+{
+    uint32_t                                    ret_val;
+    CRYSError_t                                 crys_error;
+    CRYS_HASH_OperationMode_t                   hash_mode = CRYS_HASH_SHA512_mode;
+
+    // No parameter testing on this level.
+    // This has been done on upper level.
+
+    CRYS_HASHUserContext_t * const p_backend_context
+        = &(((nrf_crypto_backend_hash_sha512_context_t * ) p_context)->context);
+
+    crys_error = CRYS_HASH_Init(p_backend_context, hash_mode);
+    ret_val = hash_result_get(crys_error);
+
+    return ret_val;
+}
+
+
+static ret_code_t cc310_backend_hash_sha512_update(void     * const p_context,
+                                                   uint8_t  const * p_data,
+                                                   size_t           size)
+{
+    ret_code_t      ret_val;
+    CRYSError_t     crys_error;
+
+    // Limited parameter testing on this level.
+    // This has been done on upper level.
+
+    CRYS_HASHUserContext_t * const p_backend_context
+        = &(((nrf_crypto_backend_hash_sha512_context_t *)p_context)->context);
+
+    // Data in flash could lead to silently calculating wrong Hash.
+    VERIFY_TRUE(nrfx_is_in_ram(p_data), NRF_ERROR_CRYPTO_INPUT_LOCATION);
+
+    crys_error = CRYS_HASH_Update(p_backend_context, (uint8_t *)p_data, size);
+
+    ret_val = hash_result_get(crys_error);
+
+    return ret_val;
+}
+
+
+static ret_code_t cc310_backend_hash_sha512_finalize(void       * const p_context,
+                                                     uint8_t          * p_digest,
+                                                     size_t     * const p_digest_size)
+{
+    ret_code_t              ret_val;
+    CRYSError_t             crys_error;
+    CRYS_HASH_Result_t *    p_int_digest = (CRYS_HASH_Result_t *)p_digest;
+
+    // Limited parameter testing on this level.
+    // This has been done on upper level.
+
+    CRYS_HASHUserContext_t * const p_backend_context
+        = &(((nrf_crypto_backend_hash_sha512_context_t *) p_context)->context);
+
+    crys_error = CRYS_HASH_Finish(p_backend_context, *p_int_digest);
+    ret_val = hash_result_get(crys_error);
+
+    if (ret_val == NRF_SUCCESS)
+    {
+        *p_digest_size = NRF_CRYPTO_HASH_SIZE_SHA512;
+    }
+
+    return ret_val;
+}
+
+
+const nrf_crypto_hash_info_t g_nrf_crypto_hash_sha512_info =
+{
+    .init_fn        = cc310_backend_hash_sha512_init,
+    .update_fn      = cc310_backend_hash_sha512_update,
+    .finalize_fn    = cc310_backend_hash_sha512_finalize,
+    .digest_size    = NRF_CRYPTO_HASH_SIZE_SHA512,
+    .context_size   = sizeof(nrf_crypto_backend_hash_sha512_context_t),
+    .hash_mode      = NRF_CRYPTO_HASH_MODE_SHA512
+};
+
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_HASH_SHA512)
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_HASH_SHA256) || NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_HASH_SHA512) 
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO) && #if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310)
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_hash.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_hash.h
new file mode 100644
index 0000000..3da4dd3
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_hash.h
@@ -0,0 +1,122 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef CC310_BACKEND_HASH_H__
+#define CC310_BACKEND_HASH_H__
+
+/** @file
+ *
+ * @defgroup nrf_crypto_cc310_backend_hash nrf_crypto CC310 backend hash
+ * @{
+ * @ingroup nrf_crypto_cc310_backend
+ *
+ * @brief Hash functionality provided by the nrf_crypto CC310 backend.
+ */
+
+#include "sdk_common.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310)
+
+#include "sdk_errors.h"
+#include "nrf_crypto_hash_shared.h"
+#include "crys_hash.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_HASH_SHA256)
+
+// Flag that nrf_crypto_hash frontend can be compiled
+#undef  NRF_CRYPTO_HASH_ENABLED
+#define NRF_CRYPTO_HASH_ENABLED 1
+
+// Flag that SHA-256 is enabled in backend
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_HASH_SHA256)
+#error "Duplicate definition of SHA-256. More than one backend enabled");
+#endif
+#define NRF_CRYPTO_HASH_SHA256_ENABLED 1
+
+
+/**@internal @brief nrf_crypto_hash context for SHA-256 in nrf_crypto CC310 backend. */
+typedef struct
+{
+    nrf_crypto_hash_internal_context_t  header;     /**< Common header for context. */
+    CRYS_HASHUserContext_t              context;    /**< Hash context internal to CC310. */
+} nrf_crypto_backend_hash_sha256_context_t;
+
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_HASH_SHA256)
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_HASH_SHA512)
+
+// Flag that nrf_crypto_hash frontend can be compiled
+#undef  NRF_CRYPTO_HASH_ENABLED
+#define NRF_CRYPTO_HASH_ENABLED 1
+
+// Duplicate backend enabled test for SHA-512
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_HASH_SHA512)
+#error "Duplicate definition of SHA-512. More than one backend enabled");
+#endif
+
+// Flag that SHA-512 is enabled in backend
+#define NRF_CRYPTO_HASH_SHA512_ENABLED 1
+
+
+/**@internal @brief nrf_crypto_hash context for SHA-512 in nrf_crypto CC310 backend. */
+typedef struct
+{
+    nrf_crypto_hash_internal_context_t  header;         /**< Common header for context. */
+    CRYS_HASHUserContext_t              context;        /**< Hash context internal to CC310. */
+} nrf_crypto_backend_hash_sha512_context_t;
+
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_HASH_SHA512)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310)
+
+/**@} */
+
+#endif // CC310_BACKEND_HASH_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_hmac.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_hmac.c
new file mode 100644
index 0000000..2e909f9
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_hmac.c
@@ -0,0 +1,273 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#include "sdk_common.h"
+#if NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310)
+
+#include "sdk_common.h"
+#include "nrf_log.h"
+#include "nrf_crypto_hmac_shared.h"
+#include "cc310_backend_hmac.h"
+#include "nrf_crypto_error.h"
+#include "nrf_crypto_types.h"
+#include <drivers/nrfx_common.h>
+#include "crys_hmac.h"
+#include "crys_hmac_defs.h"
+#include "crys_hmac_error.h"
+#include "crys_hash.h"
+#include "cc310_backend_mutex.h"
+#include "cc310_backend_shared.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_HMAC_SHA256) || \
+    NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_HMAC_SHA512)
+
+static ret_code_t result_get(CRYSError_t err_code)
+{
+    ret_code_t ret_val;
+
+    switch (err_code)
+    {
+        case CRYS_OK:
+            ret_val = NRF_SUCCESS;
+            break;
+
+        case CRYS_HMAC_INVALID_USER_CONTEXT_POINTER_ERROR:
+            ret_val = NRF_ERROR_CRYPTO_CONTEXT_NULL;
+            break;
+
+        case CRYS_HMAC_USER_CONTEXT_CORRUPTED_ERROR:
+            ret_val = NRF_ERROR_CRYPTO_CONTEXT_NOT_INITIALIZED;
+            break;
+
+        case CRYS_HMAC_DATA_IN_POINTER_INVALID_ERROR:
+        case CRYS_HMAC_INVALID_KEY_POINTER_ERROR:
+            ret_val = NRF_ERROR_CRYPTO_INPUT_NULL;
+            break;
+
+        case CRYS_HMAC_INVALID_RESULT_BUFFER_POINTER_ERROR:
+            ret_val = NRF_ERROR_CRYPTO_OUTPUT_NULL;
+            break;
+
+        case CRYS_HMAC_ILLEGAL_PARAMS_ERROR:
+            ret_val = NRF_ERROR_CRYPTO_INVALID_PARAM;
+            break;
+
+        case CRYS_HMAC_UNVALID_KEY_SIZE_ERROR:
+        case CRYS_HMAC_DATA_SIZE_ILLEGAL:
+            ret_val = NRF_ERROR_CRYPTO_INPUT_LENGTH;
+            break;
+
+        case CRYS_HMAC_ILLEGAL_OPERATION_MODE_ERROR:
+        case CRYS_HMAC_LAST_BLOCK_ALREADY_PROCESSED_ERROR:
+        case CRYS_HMAC_IS_NOT_SUPPORTED:
+        case CRYS_HMAC_CTX_SIZES_ERROR:
+        default:
+            ret_val = NRF_ERROR_CRYPTO_INTERNAL;
+            break;
+    }
+    return ret_val;
+}
+
+
+static ret_code_t cc310_backend_hmac_init(void      * const p_context,
+                                          uint8_t   const * p_key,
+                                          size_t            key_size)
+{
+    CRYSError_t                 err_code;
+    CRYS_HASH_OperationMode_t   hash_mode;
+    ret_code_t                  ret_val;
+    bool                        mutex_locked;
+
+
+    nrf_crypto_backend_cc310_hmac_context_t * p_ctx =
+        (nrf_crypto_backend_cc310_hmac_context_t *)p_context;
+
+    switch (p_ctx->header.p_info->type)
+    {
+        case NRF_CRYPTO_HMAC_SHA256_TYPE:
+        {
+            hash_mode = CRYS_HASH_SHA256_mode;
+        } break;
+        case NRF_CRYPTO_HMAC_SHA512_TYPE:
+        {
+            hash_mode = CRYS_HASH_SHA512_mode;
+        } break;
+        default:
+        {
+            NRF_LOG_ERROR("Hash algorithm not supported by CC310 backend wrapper");
+            return NRF_ERROR_CRYPTO_FEATURE_UNAVAILABLE;
+        }
+    }
+
+    // Key in flash could lead to silently calculating wrong HMAC.
+    VERIFY_TRUE(nrfx_is_in_ram(p_key), NRF_ERROR_CRYPTO_INPUT_LOCATION);
+
+    mutex_locked = cc310_backend_mutex_trylock();
+    VERIFY_TRUE(mutex_locked, NRF_ERROR_CRYPTO_BUSY);
+
+    cc310_backend_enable();
+
+    err_code = CRYS_HMAC_Init(&p_ctx->crys_context, hash_mode, (uint8_t *)p_key, key_size);
+
+    cc310_backend_disable();
+
+    cc310_backend_mutex_unlock();
+
+    ret_val = result_get(err_code);
+
+    return ret_val;
+}
+
+
+static ret_code_t cc310_backend_hmac_update(void    * const p_context,
+                                            uint8_t const * p_data,
+                                            size_t          size)
+{
+    CRYSError_t         err_code;
+    ret_code_t          ret_val;
+    bool                mutex_locked;
+    size_t              cur_len;
+    size_t              len_left  = size;
+    uint8_t const *     p_cur     = p_data;
+
+    nrf_crypto_backend_cc310_hmac_context_t * p_ctx =
+        (nrf_crypto_backend_cc310_hmac_context_t *)p_context;
+
+    // Data in flash could lead to silently calculating wrong HMAC.
+    VERIFY_TRUE(nrfx_is_in_ram(p_data), NRF_ERROR_CRYPTO_INPUT_LOCATION);
+
+    mutex_locked = cc310_backend_mutex_trylock();
+    VERIFY_TRUE(mutex_locked, NRF_ERROR_CRYPTO_BUSY);
+
+    cc310_backend_enable();
+
+    // If the input is larger than CC310_MAX_LENGTH_DMA_OPERATIONS, split into smaller
+    do
+    {
+        cur_len = (len_left > CC310_MAX_LENGTH_DMA_OPERATIONS) ?
+            CC310_MAX_LENGTH_DMA_OPERATIONS : len_left;
+
+        err_code = CRYS_HMAC_Update(&p_ctx->crys_context, (uint8_t *)p_cur, cur_len);
+
+        len_left -= cur_len;
+        p_cur += cur_len;
+
+    } while (err_code == CRYS_OK && len_left > 0);
+
+    cc310_backend_disable();
+
+    cc310_backend_mutex_unlock();
+
+    ret_val = result_get(err_code);
+
+    return ret_val;
+}
+
+
+static ret_code_t cc310_backend_hmac_finalize(void      * const p_context,
+                                              uint8_t         * p_digest,
+                                              size_t    * const p_size)
+{
+    CRYSError_t     err_code;
+    ret_code_t      ret_val;
+    bool            mutex_locked;
+
+    nrf_crypto_backend_cc310_hmac_context_t * p_ctx =
+        (nrf_crypto_backend_cc310_hmac_context_t *)p_context;
+
+    // Set the digest length to 0 so that this is used in case of any error.
+    *p_size = 0;
+
+    mutex_locked = cc310_backend_mutex_trylock();
+    VERIFY_TRUE(mutex_locked, NRF_ERROR_CRYPTO_BUSY);
+
+    cc310_backend_enable();
+
+    err_code = CRYS_HMAC_Finish(&p_ctx->crys_context, p_ctx->crys_result);
+
+    cc310_backend_disable();
+
+    cc310_backend_mutex_unlock();
+
+    ret_val = result_get(err_code);
+    if (err_code != NRF_SUCCESS)
+    {
+        return ret_val;
+    }
+
+    *p_size = p_ctx->header.p_info->digest_size;
+
+    memcpy(p_digest, p_ctx->crys_result, *p_size);
+
+    return ret_val;
+}
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_HMAC_SHA256)
+
+// Information structure for HMAC SHA256 using CC310 backend.
+const nrf_crypto_hmac_info_t g_nrf_crypto_hmac_sha256_info =
+{
+    .init_fn        = cc310_backend_hmac_init,
+    .update_fn      = cc310_backend_hmac_update,
+    .finalize_fn    = cc310_backend_hmac_finalize,
+    .digest_size    = NRF_CRYPTO_HASH_SIZE_SHA256,
+    .context_size   = sizeof(nrf_crypto_backend_hmac_sha256_context_t),
+    .type           = NRF_CRYPTO_HMAC_SHA256_TYPE,
+};
+
+#endif // NRF_CRYPTO_BACKEND_CC310_HMAC_SHA256_ENABLED
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_HMAC_SHA512)
+
+// Information structure for HMAC SHA512 using CC310 backend.
+const nrf_crypto_hmac_info_t g_nrf_crypto_hmac_sha512_info =
+{
+    .init_fn        = cc310_backend_hmac_init,
+    .update_fn      = cc310_backend_hmac_update,
+    .finalize_fn    = cc310_backend_hmac_finalize,
+    .digest_size    = NRF_CRYPTO_HASH_SIZE_SHA512,
+    .context_size   = sizeof(nrf_crypto_backend_hmac_sha512_context_t),
+    .type = NRF_CRYPTO_HMAC_SHA512_TYPE,
+};
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_HMAC_SHA512)
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_HMAC_SHA256) || NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_HMAC_SHA512)
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310)
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_hmac.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_hmac.h
new file mode 100644
index 0000000..ea065f1
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_hmac.h
@@ -0,0 +1,123 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef CC310_BACKEND_HMAC_H__
+#define CC310_BACKEND_HMAC_H__
+
+/** @file
+ *
+ * @defgroup nrf_crypto_cc310_backend_hmac CC310 backend for HMAC
+ * @{
+ * @ingroup nrf_crypto_cc310_backend
+ *
+ * @brief Backend wrapper for CryptoCell (CC310). None of these types should be used directly by the
+ * application.
+ */
+
+#include "sdk_common.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310) &&                   \
+        ( NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_HMAC_SHA256) || \
+          NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_HMAC_SHA512) )
+
+#include "nrf_crypto_hmac_shared.h"
+#include "crys_hmac.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#undef  NRF_CRYPTO_HMAC_ENABLED
+#define NRF_CRYPTO_HMAC_ENABLED         1
+
+
+/**
+ * @internal @brief Internal context object used by the CC310 backend wrapper.
+ *
+ * @details The same type is used for all variants (hash types).
+ *
+ * @note This should never be used directly. Use @ref nrf_crypto_backend_hmac_sha256_context_t or
+ * @ref nrf_crypto_backend_hmac_sha512_context_t instead.
+ */
+typedef struct
+{
+    nrf_crypto_hmac_internal_context_t  header;         //!< Internal nrf_crypto_hmac context header.
+    CRYS_HMACUserContext_t              crys_context;   //!< CC310 context object.
+    CRYS_HASH_Result_t                  crys_result;    //!< Temporary result buffer needed as CC310 always requires a result buffer of 64 bytes, even when actual result is smaller.
+} nrf_crypto_backend_cc310_hmac_context_t;
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_HMAC_SHA256)
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_HMAC_SHA256)
+#error "Duplicate definition of HMAC SHA-256. More than one backend enabled"
+#endif // NRF_CRYPTO_HMAC_SHA256_ENABLED
+#define NRF_CRYPTO_HMAC_SHA256_ENABLED  1
+
+/**
+ * @internal @brief Context for HMAC SHA256 using CC310 backend.
+ */
+typedef nrf_crypto_backend_cc310_hmac_context_t nrf_crypto_backend_hmac_sha256_context_t;
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_HMAC_SHA256)
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_HMAC_SHA512)
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_HMAC_SHA512)
+#error "Duplicate definition of HMAC SHA-512. More than one backend enabled"
+#endif // NRF_CRYPTO_HMAC_SHA512_ENABLED
+#define NRF_CRYPTO_HMAC_SHA512_ENABLED  1
+
+/**
+ * @internal @brief Context for HMAC SHA512 using CC310 backend.
+ */
+typedef nrf_crypto_backend_cc310_hmac_context_t nrf_crypto_backend_hmac_sha512_context_t;
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_HMAC_SHA256)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310) && ( NRF_MODULE_ENABLED((NRF_CRYPTO_BACKEND_CC310_HMAC_SHA256) || NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_HMAC_SHA512) )
+
+/**@} */
+
+#endif // CC310_BACKEND_HMAC_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_init.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_init.c
new file mode 100644
index 0000000..d930436
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_init.c
@@ -0,0 +1,151 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#include "sdk_common.h"
+#if NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310)
+
+#include "nrf.h"
+#include "nrf_crypto_init.h"
+#include "cc310_backend_shared.h"
+#include "sns_silib.h"
+#include "cc310_backend_mutex.h"
+#include "nrf_crypto_rng.h"
+
+/**@internal @brief Function to enable CC310 (in HW)
+ */
+void cc310_backend_enable(void);
+
+
+/**@internal @brief Function to disable CC310 (in HW)
+ */
+void cc310_backend_disable(void);
+
+static uint32_t init_result_get(uint32_t crys_error)
+{
+    uint32_t ret_val = NRF_ERROR_INTERNAL;
+    switch (crys_error)
+    {
+        case CRYS_OK:
+            ret_val = NRF_SUCCESS;
+            break;
+
+        default:
+            ret_val = NRF_ERROR_INTERNAL;
+            break;
+    }
+
+    return ret_val;
+}
+
+static ret_code_t cc310_backend_init(void)
+{
+    uint32_t    ret_val;
+    CRYSError_t crys_error;
+
+    cc310_backend_mutex_init();
+
+    // Enable the CC310 HW.
+    NRF_CRYPTOCELL->ENABLE = 1;
+
+    // Initialize the CC310 run-time library
+    crys_error = SaSi_LibInit();
+
+    // Shut down CC310 after initialization.
+    NRF_CRYPTOCELL->ENABLE = 0;
+
+    ret_val = init_result_get(crys_error);
+    VERIFY_SUCCESS(ret_val);
+
+#if defined(NRF_CRYPTO_RNG_AUTO_INIT_ENABLED) && (NRF_CRYPTO_RNG_AUTO_INIT_ENABLED == 1)
+
+    ret_val = nrf_crypto_rng_init(NULL, NULL);
+    VERIFY_SUCCESS(ret_val);
+
+#elif defined(NRF_CRYPTO_RNG_AUTO_INIT_ENABLED) && (NRF_CRYPTO_RNG_AUTO_INIT_ENABLED == 0)
+
+    // Do nothing
+
+#else
+
+    #warning NRF_CRYPTO_RNG_AUTO_INIT_ENABLED define not found in sdk_config.h (Is the sdk_config.h valid?).
+
+#endif // NRF_CRYPTO_RNG_AUTO_INIT_ENABLED
+
+    return ret_val;
+}
+
+
+static ret_code_t cc310_backend_uninit(void)
+{
+#if defined(NRF_CRYPTO_RNG_AUTO_INIT_ENABLED) && (NRF_CRYPTO_RNG_AUTO_INIT_ENABLED == 1)
+
+    uint32_t ret_val;
+    ret_val = nrf_crypto_rng_init(NULL, NULL);
+    VERIFY_SUCCESS(ret_val);
+
+#elif defined(NRF_CRYPTO_RNG_AUTO_INIT_ENABLED) && (NRF_CRYPTO_RNG_AUTO_INIT_ENABLED == 0)
+
+    // Do nothing
+
+#else
+
+    #warning NRF_CRYPTO_RNG_AUTO_INIT_ENABLED define not found in sdk_config.h (Is the sdk_config.h valid?).
+
+#endif // NRF_CRYPTO_RNG_AUTO_INIT_ENABLED
+
+    // Initialize the CC310 HW to do shutdown.
+    NRF_CRYPTOCELL->ENABLE = 1;
+
+    SaSi_LibFini();
+
+    // Shut down CC310 after shutdown.
+    NRF_CRYPTOCELL->ENABLE = 0;
+
+    return NRF_SUCCESS;
+}
+
+
+CRYPTO_BACKEND_REGISTER(nrf_crypto_backend_info_t const cc310_backend) =
+{
+    .init_fn    = cc310_backend_init,
+    .uninit_fn  = cc310_backend_uninit,
+};
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310)
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_mutex.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_mutex.c
new file mode 100644
index 0000000..f383251
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_mutex.c
@@ -0,0 +1,53 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#include "sdk_common.h"
+#include <drivers/nrfx_common.h>
+#if NRF_MODULE_ENABLED(NRF_CRYPTO)
+
+#include <stdbool.h>
+#include "cc310_backend_mutex.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310)
+
+nrf_mtx_t g_cc310_mutex;
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310)
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO)
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_mutex.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_mutex.h
new file mode 100644
index 0000000..3cd6241
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_mutex.h
@@ -0,0 +1,111 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef CC310_BACKEND_MUTEX_H__
+#define CC310_BACKEND_MUTEX_H__
+
+/** @file
+ *
+ * @defgroup nrf_crypto_cc310_backend_mutex nrf_crypto CC310 backend mutex.
+ * @{
+ * @ingroup nrf_crypto_cc310_backend
+ *
+ * @brief Mutex control for the nrf_crypto CC310 backend.
+ */
+
+#include "sdk_config.h"
+#include "nrf_mtx.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310) || NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_BL)
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern nrf_mtx_t g_cc310_mutex;
+
+__STATIC_INLINE void cc310_backend_mutex_init(void);
+__STATIC_INLINE bool cc310_backend_mutex_trylock(void);
+__STATIC_INLINE void cc310_backend_mutex_unlock(void);
+
+#ifndef SUPPRESS_INLINE_IMPLEMENTATION
+/**@internal @brief Function initializing CC310 mutex.
+ *
+ *  This function _must_ be called before other mutex operations.
+ */
+__STATIC_INLINE void cc310_backend_mutex_init(void)
+{
+    nrf_mtx_init(&g_cc310_mutex);
+}
+
+/**@internal @brief Function try to lock a CC310 mutex.
+ *
+ * @return true if lock was acquired, false if not.
+ */
+__STATIC_INLINE bool cc310_backend_mutex_trylock(void)
+{
+    return nrf_mtx_trylock(&g_cc310_mutex);
+}
+
+
+/**@internal @brief Unlock a CC310 mutex.
+ *
+ * This function _must_ only be called when holding the lock. Unlocking a mutex which you do not
+ * hold will give undefined behavior.
+ *
+ */
+__STATIC_INLINE void cc310_backend_mutex_unlock(void)
+{
+    nrf_mtx_unlock(&g_cc310_mutex);
+}
+
+#endif // SUPPRESS_INLINE_IMPLEMENTATION
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310) || NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_BL)
+
+/** @} */
+
+#endif // CC310_BACKEND_MUTEX_H__
+
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_rng.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_rng.c
new file mode 100644
index 0000000..25fd96e
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_rng.c
@@ -0,0 +1,272 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#include "sdk_common.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO)
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310)
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_RNG)
+
+#include "nrf_crypto_error.h"
+#include "nrf_log.h"
+#include "cc310_backend_mutex.h"
+#include "cc310_backend_rng.h"
+#include "crys_rnd.h"
+#include "crys_rnd_error.h"
+#include "cc310_backend_shared.h"
+
+static ret_code_t result_get(CRYSError_t err_code)
+{
+    ret_code_t ret_val;
+
+    switch (err_code)
+    {
+        case CRYS_OK:
+            ret_val = NRF_SUCCESS;
+            break;
+
+        case CRYS_RND_ILLEGAL_PARAMETER_ERROR:
+            ret_val = NRF_ERROR_CRYPTO_INVALID_PARAM;
+            break;
+
+        case CRYS_RND_INIT_FAILED:
+        case CRYS_RND_STARTUP_FAILED:
+        case CRYS_RND_INSTANTIATION_ERROR:
+            ret_val = NRF_ERROR_CRYPTO_RNG_INIT_FAILED;
+            break;
+
+        case CRYS_RND_IS_NOT_SUPPORTED:
+        case CRYS_RND_CAN_NOT_GENERATE_RAND_IN_RANGE:
+        case CRYS_RND_TRNG_KAT_NOT_SUPPORTED_ERROR:
+        case CRYS_RND_SRAM_NOT_SUPPORTED_ERROR:
+        case CRYS_RND_OPERATION_IS_NOT_SUPPORTED_ERROR:
+            ret_val = NRF_ERROR_CRYPTO_FEATURE_UNAVAILABLE;
+            break;
+
+        case CRYS_RND_DATA_OUT_POINTER_INVALID_ERROR:
+        case CRYS_RND_VECTOR_OUT_PTR_ERROR:
+            ret_val = NRF_ERROR_CRYPTO_OUTPUT_NULL;
+            break;
+
+        case CRYS_RND_ADDITIONAL_INPUT_BUFFER_NULL:
+        case CRYS_RND_WORK_BUFFER_PTR_INVALID_ERROR:
+        case CRYS_RND_ILLEGAL_DATA_PTR_ERROR:
+            ret_val = NRF_ERROR_CRYPTO_INPUT_NULL;
+            break;
+
+        case CRYS_RND_DATA_SIZE_OVERFLOW_ERROR:
+        case CRYS_RND_ADDITIONAL_INPUT_SIZE_ERROR:
+        case CRYS_RND_ILLEGAL_DATA_SIZE_ERROR:
+        case CRYS_RND_MAX_VECTOR_IS_TOO_SMALL_ERROR:
+            ret_val = NRF_ERROR_CRYPTO_INPUT_LENGTH;
+            break;
+
+        case CRYS_RND_ILLEGAL_AES_KEY_SIZE_ERROR:
+        case CRYS_RND_VECTOR_OUT_SIZE_ERROR:
+        case CRYS_RND_VECTOR_SIZE_ERROR:
+            ret_val = NRF_ERROR_CRYPTO_OUTPUT_LENGTH;
+            break;
+
+        case CRYS_RND_CONTEXT_PTR_INVALID_ERROR:
+        case CRYS_RND_STATE_PTR_INVALID_ERROR:
+            ret_val = NRF_ERROR_CRYPTO_CONTEXT_NULL;
+            break;
+
+        case CRYS_RND_INSTANTIATION_NOT_DONE_ERROR:
+            ret_val = NRF_ERROR_CRYPTO_CONTEXT_NOT_INITIALIZED;
+            break;
+
+        case CRYS_RND_RESEED_COUNTER_OVERFLOW_ERROR:
+            ret_val = NRF_ERROR_CRYPTO_RNG_RESEED_REQUIRED;
+            break;
+
+        case CRYS_RND_CPRNG_TEST_FAIL_ERROR:
+        case CRYS_RND_TRNG_LOSS_SAMPLES_ERROR:
+        case CRYS_RND_TRNG_TIME_EXCEED_ERROR:
+        case CRYS_RND_TRNG_LOSS_SAMPLES_AND_TIME_EXCEED_ERROR:
+        case CRYS_RND_IS_KAT_MODE_ERROR:
+        case CRYS_RND_STATE_VALIDATION_TAG_ERROR:
+        case CRYS_RND_GEN_VECTOR_FUNC_ERROR:
+        case CRYS_RND_TRNG_ERRORS_ERROR:
+        case CRYS_RND_KAT_DATA_PARAMS_ERROR:
+        case CRYS_RND_AES_ERROR:
+        default:
+            ret_val = NRF_ERROR_CRYPTO_INTERNAL;
+            break;
+    }
+    return ret_val;
+}
+
+
+ret_code_t nrf_crypto_rng_backend_init(void * const p_context,
+                                       void * const p_temp_buffer)
+{
+    bool                                mutex_locked;
+    CRYSError_t                         err_code;
+    ret_code_t                          ret_val;
+    CRYS_RND_WorkBuff_t               * p_work_buffer   = (CRYS_RND_WorkBuff_t *)p_temp_buffer;
+    nrf_crypto_backend_rng_context_t  * p_ctx = (nrf_crypto_backend_rng_context_t *)p_context;
+
+    // Save time by not reinitializing an already valid CC310 RNG context.
+    // (Useful for example in case the context was stored in retained memory during system OFF.)
+    if (p_ctx->header.init_value == NRF_CRYPTO_RNG_CONTEXT_INIT_MAGIC_VALUE)
+    {
+        return NRF_SUCCESS;
+    }
+
+    mutex_locked = cc310_backend_mutex_trylock();
+    VERIFY_TRUE(mutex_locked, NRF_ERROR_CRYPTO_BUSY);
+
+    cc310_backend_enable();
+
+    err_code = CRYS_RndInit(&p_ctx->crys_rnd_state, p_work_buffer);
+    ret_val = result_get(err_code);
+
+    cc310_backend_disable();
+
+    cc310_backend_mutex_unlock();
+
+    return ret_val;
+}
+
+
+ret_code_t nrf_crypto_rng_backend_uninit(void   * const p_context)
+{
+    bool                mutex_locked;
+    CRYSError_t         err_code;
+    ret_code_t          ret_val;
+    CRYS_RND_State_t  * p_crys_rnd_state =
+        &((nrf_crypto_backend_rng_context_t *)p_context)->crys_rnd_state;
+
+
+    mutex_locked = cc310_backend_mutex_trylock();
+    VERIFY_TRUE(mutex_locked, NRF_ERROR_CRYPTO_BUSY);
+
+    cc310_backend_enable();
+
+    err_code = CRYS_RND_UnInstantiation(p_crys_rnd_state);
+
+    cc310_backend_disable();
+
+    ret_val = result_get(err_code);
+
+    cc310_backend_mutex_unlock();
+
+    return ret_val;
+}
+
+
+ret_code_t nrf_crypto_rng_backend_vector_generate(void      * const p_context,
+                                                  uint8_t   * const p_target,
+                                                  size_t            size,
+                                                  bool              use_mutex)
+{
+    bool                mutex_locked;
+    CRYSError_t         err_code;
+    ret_code_t          ret_val;
+    CRYS_RND_State_t  * p_crys_rnd_state =
+        &((nrf_crypto_backend_rng_context_t *)p_context)->crys_rnd_state;
+
+    if (use_mutex)
+    {
+        mutex_locked = cc310_backend_mutex_trylock();
+        VERIFY_TRUE(mutex_locked, NRF_ERROR_CRYPTO_BUSY);
+    }
+
+    cc310_backend_enable();
+
+    err_code = CRYS_RND_GenerateVector(p_crys_rnd_state, size, p_target);
+
+    cc310_backend_disable();
+
+    ret_val = result_get(err_code);
+
+    if (use_mutex)
+    {
+        cc310_backend_mutex_unlock();
+    }
+
+    return ret_val;
+}
+
+
+ret_code_t nrf_crypto_rng_backend_reseed(void   * const p_context,
+                                         void         * p_temp_buffer,
+                                         uint8_t      * p_input_data,
+                                         size_t         size)
+{
+    bool                    mutex_locked;
+    CRYSError_t             err_code;
+    ret_code_t              ret_val = NRF_SUCCESS;
+    CRYS_RND_WorkBuff_t   * p_work_buffer = (CRYS_RND_WorkBuff_t *)p_temp_buffer;
+    CRYS_RND_State_t      * p_crys_rnd_state =
+        &((nrf_crypto_backend_rng_context_t *)p_context)->crys_rnd_state;
+
+    VERIFY_TRUE(size <= CRYS_RND_ADDITINAL_INPUT_MAX_SIZE_WORDS, NRF_ERROR_CRYPTO_INPUT_LENGTH);
+    VERIFY_TRUE((size & 0x3) == 0, NRF_ERROR_CRYPTO_INTERNAL);
+
+    mutex_locked = cc310_backend_mutex_trylock();
+    VERIFY_TRUE(mutex_locked, NRF_ERROR_CRYPTO_BUSY);
+
+    cc310_backend_enable();
+
+    if (size > 0)
+    {
+        err_code = CRYS_RND_AddAdditionalInput(p_crys_rnd_state, p_input_data, size);
+        ret_val = result_get(err_code);
+        if (ret_val != NRF_SUCCESS)
+        {
+            goto exit;
+        }
+    }
+
+    err_code = CRYS_RND_Reseeding(p_crys_rnd_state, p_work_buffer);
+    ret_val = result_get(err_code);
+
+exit:
+    cc310_backend_disable();
+    cc310_backend_mutex_unlock();
+    return ret_val;
+}
+
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_RNG)
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310)
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO)
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_rng.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_rng.h
new file mode 100644
index 0000000..ab1806a
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_rng.h
@@ -0,0 +1,97 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef CC310_BACKEND_RNG_H__
+#define CC310_BACKEND_RNG_H__
+
+/** @file
+ *
+ * @defgroup nrf_crypto_cc310_backend_rng nRF Crypto CC310 RNG backend
+ * @{
+ * @ingroup nrf_crypto_cc310_backend
+ *
+ * @brief RNG functionality provided by the nrf_crypto CC310 backend.
+ */
+
+#include "sdk_common.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310)
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_RNG)
+
+#include "nrf_crypto_rng_shared.h"
+#include "crys_rnd.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_RNG)
+#error "More than one RNG backend enabled."
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_RNG)
+#define NRF_CRYPTO_RNG_ENABLED 1
+
+
+/**
+ * @internal @brief Internal context for CC310 RNG.
+ */
+typedef struct
+{
+    nrf_crypto_rng_internal_context_t   header;         //!< Internal common context header.
+    CRYS_RND_State_t                    crys_rnd_state; //!< CC310 RNG context
+} nrf_crypto_backend_rng_context_t;
+
+
+/**
+ * @internal @brief Temporary work buffer needed during initialization of the CC310 backend.
+ */
+typedef CRYS_RND_WorkBuff_t nrf_crypto_backend_rng_temp_buffer_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_RNG)
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310)
+
+/**@} */
+
+#endif // CC310_BACKEND_RNG_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_shared.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_shared.c
new file mode 100644
index 0000000..d5f2351
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_shared.c
@@ -0,0 +1,115 @@
+/**
+ * Copyright (c) 2017 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#include "sdk_common.h"
+#if NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310)
+
+#include "nrf.h"
+#include "cc310_backend_shared.h"
+#include "nrf_crypto_error.h"
+#include "nrf_crypto_rng.h"
+#include "crys_rnd_error.h"
+#include "nrf_crypto_shared.h"
+#include "cc310_backend_shared.h"
+
+
+static uint32_t m_use_count = 0;
+
+void cc310_backend_enable(void)
+{
+    m_use_count++;
+
+    if (m_use_count == 1)
+    {
+        // Enable the CryptoCell hardware
+        NRF_CRYPTOCELL->ENABLE = 1;
+
+        // Enable the CryptoCell IRQ
+        NVIC_EnableIRQ(CRYPTOCELL_IRQn);
+    }
+}
+
+void cc310_backend_disable(void)
+{
+    m_use_count--;
+
+    // If no more users. Disable HW/IRQ
+    if (m_use_count == 0)
+    {
+        // Disable the CryptoCell hardware
+        NRF_CRYPTOCELL->ENABLE = 0;
+
+        // Disable the CryptoCell IRQ
+        NVIC_DisableIRQ(CRYPTOCELL_IRQn);
+    }
+}
+
+
+uint32_t nrf_crypto_backend_cc310_rng(void * p_state, uint16_t size, uint8_t * p_data)
+{
+#if defined(NRF_CRYPTO_RNG_ENABLED) && (NRF_CRYPTO_RNG_ENABLED == 1)
+
+    ret_code_t result = nrf_crypto_rng_vector_generate_no_mutex(p_data, (size_t)size);
+    if (result == NRF_SUCCESS)
+    {
+        return CRYS_OK;
+    }
+    else if (result == NRF_ERROR_CRYPTO_CONTEXT_NOT_INITIALIZED)
+    {
+        return CRYS_RND_INSTANTIATION_NOT_DONE_ERROR;
+    }
+    else
+    {
+        return CRYS_RND_IS_NOT_SUPPORTED;
+    }
+
+#elif defined(NRF_CRYPTO_RNG_ENABLED) && (NRF_CRYPTO_RNG_ENABLED == 0)
+
+    return NRF_ERROR_CRYPTO_FEATURE_UNAVAILABLE;
+
+#else
+
+    #warning NRF_CRYPTO_RNG_ENABLED define not found in sdk_config.h (Is the sdk_config.h valid?).
+
+#endif // NRF_CRYPTO_RNG_ENABLED
+}
+
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310)
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_shared.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_shared.h
new file mode 100644
index 0000000..56fae0e
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310/cc310_backend_shared.h
@@ -0,0 +1,87 @@
+/**
+ * Copyright (c) 2017 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef CC310_BACKEND_SHARED_H__
+#define CC310_BACKEND_SHARED_H__
+
+/** @file
+ *
+ * @defgroup nrf_crypto_cc310_backend_shared nrf_crypto CC310 backend shared
+ * @{
+ * @ingroup nrf_crypto_cc310_backend
+ *
+ * @brief Shared functionality for the nrf_crypto CC310 backend.
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**@internal @brief Macro definition for largest possible input data on CC310 DMA. */
+#define CC310_MAX_LENGTH_DMA_OPERATIONS         (0xFFFF)
+#define CC310_MAX_LENGTH_DMA_AES_OPERATIONS     (0xFFF0)
+
+
+/**@internal @brief Function to enable CC310 (in HW)
+ */
+void cc310_backend_enable(void);
+
+
+/**@internal @brief Function to disable CC310 (in HW)
+ */
+void cc310_backend_disable(void);
+
+
+/**@internal @brief Function to pass to CC310 library API as random number generator. It uses
+ * nrf_crypto libary frontend API to generate random number.
+ * @param[in,out] p_state Unused. Required by CC310 library API.
+ * @param[in]     size    Number of bytes in generated vector.
+ * @param[out]    p_data  Place where generated bytes will be written.
+ */
+uint32_t nrf_crypto_backend_cc310_rng(void * p_state, uint16_t size, uint8_t * p_data);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+/**@} */
+
+#endif // CC310_BACKEND_SHARED_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310_bl/cc310_bl_backend_ecc.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310_bl/cc310_bl_backend_ecc.c
new file mode 100644
index 0000000..cec2ec7
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310_bl/cc310_bl_backend_ecc.c
@@ -0,0 +1,165 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#include "sdk_config.h"
+#include "nordic_common.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_BL)
+
+#include <string.h>
+
+#include "nrf_crypto_mem.h"
+#include "nrf_crypto_ecc.h"
+#include "nrf_crypto_shared.h"
+#include "cc310_bl_backend_ecc.h"
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_BL_ECC_LITTLE_ENDIAN)
+#define ENDIAN_MEM_COPY nrf_crypto_internal_swap_endian
+#else
+#define ENDIAN_MEM_COPY memcpy
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_BL_ECC_SECP224R1)
+
+
+ret_code_t nrf_crypto_backend_secp224r1_public_key_from_raw(
+    void          * p_public_key,
+    uint8_t const * p_raw_data)
+{
+    nrf_crypto_backend_secp224r1_public_key_t * p_pub =
+        (nrf_crypto_backend_secp224r1_public_key_t *)p_public_key;
+
+    ENDIAN_MEM_COPY(&p_pub->public_key.x[0],
+                    &p_raw_data[0],
+                    NRF_CRYPTO_ECC_SECP224R1_RAW_PRIVATE_KEY_SIZE);
+    ENDIAN_MEM_COPY(&p_pub->public_key.y[0],
+                    &p_raw_data[NRF_CRYPTO_ECC_SECP224R1_RAW_PRIVATE_KEY_SIZE],
+                    NRF_CRYPTO_ECC_SECP224R1_RAW_PRIVATE_KEY_SIZE);
+
+    return NRF_SUCCESS;
+}
+
+
+ret_code_t nrf_crypto_backend_secp224r1_public_key_to_raw(
+    void const * p_public_key,
+    uint8_t    * p_raw_data)
+{
+    nrf_crypto_backend_secp224r1_public_key_t const * p_pub =
+        (nrf_crypto_backend_secp224r1_public_key_t const *)p_public_key;
+
+    ENDIAN_MEM_COPY(&p_raw_data[0],
+                    &p_pub->public_key.x[0],
+                    NRF_CRYPTO_ECC_SECP224R1_RAW_PRIVATE_KEY_SIZE);
+    ENDIAN_MEM_COPY(&p_raw_data[NRF_CRYPTO_ECC_SECP224R1_RAW_PRIVATE_KEY_SIZE],
+                    &p_pub->public_key.y[0],
+                    NRF_CRYPTO_ECC_SECP224R1_RAW_PRIVATE_KEY_SIZE);
+
+    return NRF_SUCCESS;
+}
+
+
+nrf_crypto_ecc_curve_info_t const g_nrf_crypto_ecc_secp224r1_curve_info =
+{
+    .public_key_size      = sizeof(nrf_crypto_backend_secp224r1_public_key_t),
+    .private_key_size     = 0,
+    .curve_type           = NRF_CRYPTO_ECC_SECP224R1_CURVE_TYPE,
+    .raw_private_key_size = NRF_CRYPTO_ECC_SECP224R1_RAW_PRIVATE_KEY_SIZE,
+    .raw_public_key_size  = NRF_CRYPTO_ECC_SECP224R1_RAW_PUBLIC_KEY_SIZE,
+};
+
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_BL_ECC_SECP224R1)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_BL_ECC_SECP256R1)
+
+
+ret_code_t nrf_crypto_backend_secp256r1_public_key_from_raw(
+    void          * p_public_key,
+    uint8_t const * p_raw_data)
+{
+    nrf_crypto_backend_secp256r1_public_key_t * p_pub =
+        (nrf_crypto_backend_secp256r1_public_key_t *)p_public_key;
+
+    ENDIAN_MEM_COPY(&p_pub->public_key.x[0],
+                    &p_raw_data[0],
+                    NRF_CRYPTO_ECC_SECP256R1_RAW_PRIVATE_KEY_SIZE);
+    ENDIAN_MEM_COPY(&p_pub->public_key.y[0],
+                    &p_raw_data[NRF_CRYPTO_ECC_SECP256R1_RAW_PRIVATE_KEY_SIZE],
+                    NRF_CRYPTO_ECC_SECP256R1_RAW_PRIVATE_KEY_SIZE);
+
+    return NRF_SUCCESS;
+}
+
+
+ret_code_t nrf_crypto_backend_secp256r1_public_key_to_raw(
+    void const * p_public_key,
+    uint8_t    * p_raw_data)
+{
+    nrf_crypto_backend_secp256r1_public_key_t const * p_pub =
+        (nrf_crypto_backend_secp256r1_public_key_t const *)p_public_key;
+
+    ENDIAN_MEM_COPY(&p_raw_data[0],
+                    &p_pub->public_key.x[0],
+                    NRF_CRYPTO_ECC_SECP256R1_RAW_PRIVATE_KEY_SIZE);
+    ENDIAN_MEM_COPY(&p_raw_data[NRF_CRYPTO_ECC_SECP256R1_RAW_PRIVATE_KEY_SIZE],
+                    &p_pub->public_key.y[0],
+                    NRF_CRYPTO_ECC_SECP256R1_RAW_PRIVATE_KEY_SIZE);
+
+    return NRF_SUCCESS;
+}
+
+
+nrf_crypto_ecc_curve_info_t const g_nrf_crypto_ecc_secp256r1_curve_info =
+{
+    .public_key_size      = sizeof(nrf_crypto_backend_secp256r1_public_key_t),
+    .private_key_size     = 0,
+    .curve_type           = NRF_CRYPTO_ECC_SECP256R1_CURVE_TYPE,
+    .raw_private_key_size = NRF_CRYPTO_ECC_SECP256R1_RAW_PRIVATE_KEY_SIZE,
+    .raw_public_key_size  = NRF_CRYPTO_ECC_SECP256R1_RAW_PUBLIC_KEY_SIZE,
+};
+
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_BL_ECC_SECP256R1)
+
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_BL)
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310_bl/cc310_bl_backend_ecc.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310_bl/cc310_bl_backend_ecc.h
new file mode 100644
index 0000000..381c642
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310_bl/cc310_bl_backend_ecc.h
@@ -0,0 +1,155 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef CC310_BL_BACKEND_ECC_H__
+#define CC310_BL_BACKEND_ECC_H__
+
+#include "sdk_config.h"
+#include "nordic_common.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_BL)
+
+#include "nrf_crypto_ecc_shared.h"
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_BL_ECC_SECP224R1)
+#include "nrf_cc310_bl_ecdsa_verify_secp224r1.h"
+#endif
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_BL_ECC_SECP256R1)
+#include "nrf_cc310_bl_ecdsa_verify_secp256r1.h"
+#endif
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_BL_ECC_SECP224R1)
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_ECC_SECP224R1)
+#error "More than one backend enabled for secp224r1 (NIST 224-bit).");
+#endif
+#define NRF_CRYPTO_ECC_SECP224R1_ENABLED 1
+
+typedef struct
+{
+    nrf_crypto_internal_ecc_key_header_t header;        /**< @internal @brief Common ECC key header */
+    nrf_cc310_bl_ecc_public_key_secp224r1_t public_key; /**< @internal @brief CC310_BL specific key representation */
+} nrf_crypto_backend_secp224r1_public_key_t;
+
+/** @internal See @ref nrf_crypto_backend_ecc_public_key_from_raw_fn_t.
+*/
+ret_code_t nrf_crypto_backend_secp224r1_public_key_from_raw(
+    void          * p_public_key,
+    uint8_t const * p_raw_data);
+
+/** @internal See @ref nrf_crypto_backend_ecc_public_key_to_raw_fn_t.
+*/
+ret_code_t nrf_crypto_backend_secp224r1_public_key_to_raw(
+    void const * p_public_key,
+    uint8_t    * p_raw_data);
+
+// Dummy and empty definitions for unused symbols
+#define nrf_crypto_backend_secp224r1_key_pair_generate    NULL
+#define nrf_crypto_backend_secp224r1_public_key_calculate NULL
+#define nrf_crypto_backend_secp224r1_private_key_from_raw NULL
+#define nrf_crypto_backend_secp224r1_private_key_to_raw   NULL
+#define nrf_crypto_backend_secp224r1_private_key_free     NULL
+#define nrf_crypto_backend_secp224r1_public_key_free      NULL
+
+#define NRF_CRYPTO_BACKEND_SECP224R1_KEY_PAIR_GENERATE_CONTEXT_SIZE    0
+#define NRF_CRYPTO_BACKEND_SECP224R1_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE 0
+
+typedef uint32_t nrf_crypto_backend_secp224r1_private_key_t;
+typedef uint32_t nrf_crypto_backend_secp224r1_key_pair_generate_context_t;
+typedef uint32_t nrf_crypto_backend_secp224r1_public_key_calculate_context_t;
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_BL_ECC_SECP224R1)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_BL_ECC_SECP256R1)
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_ECC_SECP256R1)
+#error "More than one backend enabled for secp256r1 (NIST 256-bit).");
+#endif
+#define NRF_CRYPTO_ECC_SECP256R1_ENABLED 1
+
+typedef struct
+{
+    nrf_crypto_internal_ecc_key_header_t header;        /**< @internal @brief Common ECC key header */
+    nrf_cc310_bl_ecc_public_key_secp256r1_t public_key; /**< @internal @brief CC310_BL specific key representation */
+} nrf_crypto_backend_secp256r1_public_key_t;
+
+/** @internal See @ref nrf_crypto_backend_ecc_public_key_from_raw_fn_t.
+*/
+ret_code_t nrf_crypto_backend_secp256r1_public_key_from_raw(
+    void          * p_public_key,
+    uint8_t const * p_raw_data);
+
+/** @internal See @ref nrf_crypto_backend_ecc_public_key_to_raw_fn_t.
+*/
+ret_code_t nrf_crypto_backend_secp256r1_public_key_to_raw(
+    void const * p_public_key,
+    uint8_t    * p_raw_data);
+
+// Dummy and empty definitions for unused symbols
+#define nrf_crypto_backend_secp256r1_key_pair_generate    NULL
+#define nrf_crypto_backend_secp256r1_public_key_calculate NULL
+#define nrf_crypto_backend_secp256r1_private_key_from_raw NULL
+#define nrf_crypto_backend_secp256r1_private_key_to_raw   NULL
+#define nrf_crypto_backend_secp256r1_private_key_free     NULL
+#define nrf_crypto_backend_secp256r1_public_key_free      NULL
+
+#define NRF_CRYPTO_BACKEND_SECP256R1_KEY_PAIR_GENERATE_CONTEXT_SIZE    0
+#define NRF_CRYPTO_BACKEND_SECP256R1_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE 0
+
+typedef uint32_t nrf_crypto_backend_secp256r1_private_key_t;
+typedef uint32_t nrf_crypto_backend_secp256r1_key_pair_generate_context_t;
+typedef uint32_t nrf_crypto_backend_secp256r1_public_key_calculate_context_t;
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_BL_ECC_SECP256R1)
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_BL)
+
+#endif // CC310_BL_BACKEND_ECC_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310_bl/cc310_bl_backend_ecdh.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310_bl/cc310_bl_backend_ecdh.h
new file mode 100644
index 0000000..ce52194
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310_bl/cc310_bl_backend_ecdh.h
@@ -0,0 +1,75 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef CC310_BL_BACKEND_ECDH_H__
+#define CC310_BL_BACKEND_ECDH_H__
+
+#include "sdk_config.h"
+#include "nordic_common.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_BL)
+
+#include "nrf_crypto_ecc.h"
+#include "nrf_crypto_ecdh_shared.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_BL_ECC_SECP224R1)
+#define nrf_crypto_backend_secp224r1_ecdh_compute NULL
+typedef uint32_t nrf_crypto_backend_secp224r1_ecdh_context_t;
+#define NRF_CRYPTO_BACKEND_SECP224R1_ECDH_CONTEXT_SIZE 0
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_BL_ECC_SECP224R1)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_BL_ECC_SECP256R1)
+#define nrf_crypto_backend_secp256r1_ecdh_compute NULL
+typedef uint32_t nrf_crypto_backend_secp256r1_ecdh_context_t;
+#define NRF_CRYPTO_BACKEND_SECP256R1_ECDH_CONTEXT_SIZE 0
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_BL_ECC_SECP256R1)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_BL)
+
+#endif // CC310_BL_BACKEND_ECDH_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310_bl/cc310_bl_backend_ecdsa.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310_bl/cc310_bl_backend_ecdsa.c
new file mode 100644
index 0000000..5b99a83
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310_bl/cc310_bl_backend_ecdsa.c
@@ -0,0 +1,267 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#include "sdk_config.h"
+#include "nordic_common.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_BL)
+
+#include <string.h>
+#include "app_util.h"
+#include "nrf_crypto_error.h"
+#include "nrf_crypto_mem.h"
+#include "nrf_crypto_shared.h"
+#include "cc310_bl_backend_ecdsa.h"
+#include "cc310_bl_backend_shared.h"
+#include "cc310_backend_mutex.h"
+#include "crys_ecpki_error.h"
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_BL_ECC_SECP224R1) || \
+    NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_BL_ECC_SECP256R1)
+
+static ret_code_t crys_error_to_ret_code(CRYSError_t crys_error)
+{
+    switch (crys_error)
+    {
+        case CRYS_OK:
+            return NRF_SUCCESS;
+
+        case CRYS_ECDSA_VERIFY_INCONSISTENT_VERIFY_ERROR:
+            return NRF_ERROR_CRYPTO_ECDSA_INVALID_SIGNATURE;
+
+        default:
+            break;
+    }
+
+    return NRF_ERROR_CRYPTO_INTERNAL;
+}
+
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_BL_ECC_SECP224R1)
+
+STATIC_ASSERT(offsetof(nrf_cc310_bl_ecc_signature_secp224r1_t, r) == 0,
+              "Offset of r in nrf_cc310_bl_ecc_signature_secp224r1_t is unexpected");
+STATIC_ASSERT(offsetof(nrf_cc310_bl_ecc_signature_secp224r1_t, s) ==
+              NRF_CRYPTO_ECC_SECP224R1_RAW_PRIVATE_KEY_SIZE,
+              "Offset of s in nrf_cc310_bl_ecc_signature_secp224r1_t is unexpected");
+
+
+ret_code_t nrf_crypto_backend_secp224r1_verify(
+    void           * p_context,
+    void     const * p_public_key,
+    uint8_t  const * p_data,
+    size_t           data_size,
+    uint8_t  const * p_signature)
+{
+    ret_code_t  result;
+    CRYSError_t crys_error;
+    bool        mutex_locked;
+
+    nrf_crypto_backend_secp224r1_verify_context_t * p_ctx =
+        (nrf_crypto_backend_secp224r1_verify_context_t *)p_context;
+
+    nrf_crypto_backend_secp224r1_public_key_t * p_pub =
+        (nrf_crypto_backend_secp224r1_public_key_t *)p_public_key;
+
+    p_ctx->user_context.init_val = NRF_CC310_BL_ECDSA_CONTEXT_INITIALIZED;
+
+#if defined(NRF_CRYPTO_BACKEND_CC310_BL_ECC_LITTLE_ENDIAN_ENABLED) && (NRF_CRYPTO_BACKEND_CC310_BL_ECC_LITTLE_ENDIAN_ENABLED == 1)
+
+    size_t    hash_size = MIN(data_size, NRF_CRYPTO_ECC_SECP224R1_RAW_PRIVATE_KEY_SIZE);
+    uint8_t * p_hash_and_sig_le =
+        NRF_CRYPTO_ALLOC(hash_size + 2 * NRF_CRYPTO_ECC_SECP224R1_RAW_PRIVATE_KEY_SIZE);
+    
+    if (p_hash_and_sig_le == NULL)
+    {
+        return NRF_ERROR_CRYPTO_ALLOC_FAILED;
+    }
+
+    nrf_crypto_internal_swap_endian(p_hash_and_sig_le, p_data, hash_size);
+
+    nrf_crypto_internal_double_swap_endian(&p_hash_and_sig_le[hash_size],
+                                           p_signature,
+                                           NRF_CRYPTO_ECC_SECP224R1_RAW_PRIVATE_KEY_SIZE);
+
+    mutex_locked = cc310_backend_mutex_trylock();
+    VERIFY_TRUE(mutex_locked, NRF_ERROR_CRYPTO_BUSY);
+
+    cc310_bl_backend_enable();
+
+    crys_error = nrf_cc310_bl_ecdsa_verify_secp224r1(
+        &p_ctx->user_context,
+        &p_pub->public_key,
+        (nrf_cc310_bl_ecc_signature_secp224r1_t const *)&p_hash_and_sig_le[hash_size],
+        p_hash_and_sig_le,
+        hash_size);
+
+    cc310_bl_backend_disable();
+
+    cc310_backend_mutex_unlock();
+
+    NRF_CRYPTO_FREE(p_hash_and_sig_le);
+
+#elif defined(NRF_CRYPTO_BACKEND_CC310_BL_ECC_LITTLE_ENDIAN_ENABLED) && (NRF_CRYPTO_BACKEND_CC310_BL_ECC_LITTLE_ENDIAN_ENABLED == 0)
+
+    mutex_locked = cc310_backend_mutex_trylock();
+    VERIFY_TRUE(mutex_locked, NRF_ERROR_CRYPTO_BUSY);
+
+    cc310_bl_backend_enable();        
+
+    crys_error = nrf_cc310_bl_ecdsa_verify_secp224r1(
+        &p_ctx->user_context,
+        &p_pub->public_key,
+        (nrf_cc310_bl_ecc_signature_secp224r1_t const *)p_signature,
+        p_data,
+        data_size);
+
+    cc310_bl_backend_disable();
+
+    cc310_backend_mutex_unlock();
+
+#else
+
+    #error NRF_CRYPTO_BACKEND_CC310_BL_ECC_LITTLE_ENDIAN_ENABLED define not found in sdk_config.h Inalid sdk_config.h!
+
+#endif
+
+    result = crys_error_to_ret_code(crys_error);
+
+    return result;
+}
+
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_BL_ECC_SECP224R1)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_BL_ECC_SECP256R1)
+
+
+STATIC_ASSERT(offsetof(nrf_cc310_bl_ecc_signature_secp256r1_t, r) == 0,
+              "Offset of r in nrf_cc310_bl_ecc_signature_secp256r1_t is unexpected");
+
+STATIC_ASSERT(offsetof(nrf_cc310_bl_ecc_signature_secp256r1_t, s) ==
+              NRF_CRYPTO_ECC_SECP256R1_RAW_PRIVATE_KEY_SIZE,
+              "Offset of s in nrf_cc310_bl_ecc_signature_secp256r1_t is unexpected");
+
+
+ret_code_t nrf_crypto_backend_secp256r1_verify(
+    void           * p_context,
+    void     const * p_public_key,
+    uint8_t  const * p_data,
+    size_t           data_size,
+    uint8_t  const * p_signature)
+{
+    ret_code_t  result;
+    CRYSError_t crys_error;
+    bool        mutex_locked;
+    
+
+    nrf_crypto_backend_secp256r1_verify_context_t * p_ctx =
+        (nrf_crypto_backend_secp256r1_verify_context_t *)p_context;
+
+    nrf_crypto_backend_secp256r1_public_key_t * p_pub =
+        (nrf_crypto_backend_secp256r1_public_key_t *)p_public_key;
+
+    p_ctx->user_context.init_val = NRF_CC310_BL_ECDSA_CONTEXT_INITIALIZED;
+
+#if defined(NRF_CRYPTO_BACKEND_CC310_BL_ECC_LITTLE_ENDIAN_ENABLED) && (NRF_CRYPTO_BACKEND_CC310_BL_ECC_LITTLE_ENDIAN_ENABLED == 1)
+    
+    uint8_t     hash_le[NRF_CRYPTO_HASH_SIZE_SHA256];
+    uint8_t     signature_le[NRF_CRYPTO_ECC_SECP256R1_RAW_PRIVATE_KEY_SIZE * 2];
+    size_t      hash_size = MIN(data_size, NRF_CRYPTO_HASH_SIZE_SHA256);
+
+    nrf_crypto_internal_swap_endian(hash_le, p_data, hash_size);
+
+    nrf_crypto_internal_double_swap_endian(signature_le,
+                                           p_signature,
+                                           NRF_CRYPTO_ECC_SECP256R1_RAW_PRIVATE_KEY_SIZE);
+
+    mutex_locked = cc310_backend_mutex_trylock();
+    VERIFY_TRUE(mutex_locked, NRF_ERROR_CRYPTO_BUSY);
+
+    cc310_bl_backend_enable();
+
+    crys_error = nrf_cc310_bl_ecdsa_verify_secp256r1(
+        &p_ctx->user_context,
+        &p_pub->public_key,
+        (nrf_cc310_bl_ecc_signature_secp256r1_t const *)signature_le,
+        hash_le,
+        hash_size);
+
+    cc310_bl_backend_disable();
+
+    cc310_backend_mutex_unlock();
+
+#elif defined(NRF_CRYPTO_BACKEND_CC310_BL_ECC_LITTLE_ENDIAN_ENABLED) && (NRF_CRYPTO_BACKEND_CC310_BL_ECC_LITTLE_ENDIAN_ENABLED == 0)
+
+    mutex_locked = cc310_backend_mutex_trylock();
+    VERIFY_TRUE(mutex_locked, NRF_ERROR_CRYPTO_BUSY);
+
+    cc310_bl_backend_enable();
+
+    crys_error = nrf_cc310_bl_ecdsa_verify_secp256r1(
+        &p_ctx->user_context,
+        &p_pub->public_key,
+        (nrf_cc310_bl_ecc_signature_secp256r1_t const *)p_signature,
+        p_data,
+        data_size);
+
+    cc310_bl_backend_disable();
+
+    cc310_backend_mutex_unlock();
+
+#else
+    
+    #error NRF_CRYPTO_BACKEND_CC310_BL_ECC_LITTLE_ENDIAN_ENABLED define not found in sdk_config.h. Invalid sdk_config.file!
+
+#endif
+
+    result = crys_error_to_ret_code(crys_error);
+
+    return result;
+}
+
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_BL_ECC_SECP256R1)
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_BL)
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310_bl/cc310_bl_backend_ecdsa.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310_bl/cc310_bl_backend_ecdsa.h
new file mode 100644
index 0000000..f75a035
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310_bl/cc310_bl_backend_ecdsa.h
@@ -0,0 +1,124 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef CC310_BL_BACKEND_ECDSA_H__
+#define CC310_BL_BACKEND_ECDSA_H__
+
+#include "sdk_config.h"
+#include "nordic_common.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_BL)
+
+#include "nrf_crypto_ecc_shared.h"
+#include "nrf_crypto_ecdsa_shared.h"
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_BL_ECC_SECP224R1)
+#include "nrf_cc310_bl_ecdsa_verify_secp224r1.h"
+#endif
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_BL_ECC_SECP256R1)
+#include "nrf_cc310_bl_ecdsa_verify_secp256r1.h"
+#endif
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_BL_ECC_SECP224R1)
+
+/** @internal @brief Common structure holding context for ECDSA verify.
+ */
+typedef struct
+{
+    nrf_cc310_bl_ecdsa_verify_context_secp224r1_t user_context;          /**< @internal @brief Temporary buffer for CC310_BL internal storage */
+} nrf_crypto_backend_secp224r1_verify_context_t;
+
+#define NRF_CRYPTO_BACKEND_SECP224R1_VERIFY_CONTEXT_SIZE \
+    sizeof(nrf_crypto_backend_secp224r1_verify_context_t)
+
+ret_code_t nrf_crypto_backend_secp224r1_verify(
+    void           * p_context,
+    void     const * p_public_key,
+    uint8_t  const * p_data,
+    size_t           data_size,
+    uint8_t  const * p_signature);
+
+// Dummy and empty definitions for unused symbols
+#define NRF_CRYPTO_BACKEND_SECP224R1_SIGN_CONTEXT_SIZE 0
+typedef uint32_t nrf_crypto_backend_secp224r1_sign_context_t;
+#define nrf_crypto_backend_secp224r1_sign NULL
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_BL_ECC_SECP224R1)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_BL_ECC_SECP256R1)
+
+/** @internal @brief Common structure holding context for ECDSA verify.
+ */
+typedef struct
+{
+    nrf_cc310_bl_ecdsa_verify_context_secp256r1_t user_context;          /**< @internal @brief Temporary buffer for CC310_BL internal storage */
+} nrf_crypto_backend_secp256r1_verify_context_t;
+
+#define NRF_CRYPTO_BACKEND_SECP256R1_VERIFY_CONTEXT_SIZE \
+    sizeof(nrf_crypto_backend_secp256r1_verify_context_t)
+
+ret_code_t nrf_crypto_backend_secp256r1_verify(
+    void           * p_context,
+    void     const * p_public_key,
+    uint8_t  const * p_data,
+    size_t           data_size,
+    uint8_t  const * p_signature);
+
+// Dummy and empty definitions for unused symbols
+#define NRF_CRYPTO_BACKEND_SECP256R1_SIGN_CONTEXT_SIZE 0
+typedef uint32_t nrf_crypto_backend_secp256r1_sign_context_t;
+#define nrf_crypto_backend_secp256r1_sign NULL
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_BL_ECC_SECP256R1)
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_BL)
+
+#endif // CC310_BL_BACKEND_ECDSA_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310_bl/cc310_bl_backend_hash.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310_bl/cc310_bl_backend_hash.c
new file mode 100644
index 0000000..59010f5
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310_bl/cc310_bl_backend_hash.c
@@ -0,0 +1,281 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+#include "sdk_common.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_BL)
+
+#include "nrf.h"
+#include "cc310_bl_backend_hash.h"
+#include "cc310_bl_backend_shared.h"
+#include "cc310_backend_mutex.h"
+#include "cc310_backend_shared.h"
+#include "nrf_cc310_bl_hash_sha256.h"
+#include "crys_hash_error.h"
+#include "nrf_crypto_init.h"
+#include "nrf_crypto_types.h"
+#include "nrf_crypto_error.h"
+#include "nrf_crypto_shared.h"
+#include "nrf_crypto_hash_shared.h"
+#include "sdk_macros.h"
+#include "nrf_log.h"
+#include "nrf_assert.h"
+#include <drivers/nrfx_common.h>
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_BL_HASH_SHA256)
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_BL_HASH_AUTOMATIC_RAM_BUFFER)
+
+__ALIGN(4) static uint8_t  m_hash_buffer[NRF_CRYPTO_BACKEND_CC310_BL_HASH_AUTOMATIC_RAM_BUFFER_SIZE];
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_BL_HASH_AUTOMATIC_RAM_BUFFER)
+
+
+static ret_code_t hash_result_get(CRYSError_t error)
+{
+    ret_code_t ret_val;
+
+    switch (error)
+    {
+        case CRYS_OK:
+            ret_val = NRF_SUCCESS;
+            break;
+
+        case CRYS_HASH_INVALID_USER_CONTEXT_POINTER_ERROR:
+            ret_val = NRF_ERROR_CRYPTO_CONTEXT_NULL;
+            break;
+
+        case CRYS_HASH_ILLEGAL_OPERATION_MODE_ERROR:
+            ret_val = NRF_ERROR_CRYPTO_FEATURE_UNAVAILABLE;
+            break;
+
+        case CRYS_HASH_USER_CONTEXT_CORRUPTED_ERROR:
+            ret_val = NRF_ERROR_CRYPTO_CONTEXT_NOT_INITIALIZED;
+            break;
+
+        // May be added to specialized errors for hash.
+        case CRYS_HASH_LAST_BLOCK_ALREADY_PROCESSED_ERROR:
+            ret_val = NRF_ERROR_CRYPTO_INTERNAL;
+            break;
+
+        case CRYS_HASH_IS_NOT_SUPPORTED:
+            ret_val = NRF_ERROR_CRYPTO_FEATURE_UNAVAILABLE;
+            break;
+
+        default:
+            ret_val = NRF_ERROR_CRYPTO_INTERNAL;
+            break;
+    }
+
+    return ret_val;
+}
+
+
+static ret_code_t cc310_bl_backend_hash_sha256_init(void * const p_context)
+{
+    uint32_t    ret_val;
+    CRYSError_t crys_error;
+
+    // Limited parameter testing on this level.
+    // This has been done on upper level.
+
+    nrf_cc310_bl_hash_context_sha256_t * const p_backend_context
+        = &(((nrf_crypto_backend_hash_sha256_context_t *)p_context)->context);
+
+    crys_error = nrf_cc310_bl_hash_sha256_init(p_backend_context);
+
+    ret_val = hash_result_get(crys_error);
+
+    return ret_val;
+}
+
+
+static uint32_t cc310_bl_backend_hash_sha256_update(void      * const p_context,
+                                                    uint8_t   const * p_data,
+                                                    size_t            size)
+{
+    ret_code_t  ret_val;
+    CRYSError_t crys_error;
+    uint32_t    cur_size;
+    uint32_t    size_left;
+    uint8_t   * p_cur;
+    bool        mutex_locked;
+
+    // Limited parameter testing on this level.
+    // This has been done on upper level.
+
+    nrf_cc310_bl_hash_context_sha256_t * const p_backend_context
+        = &(((nrf_crypto_backend_hash_sha256_context_t *)p_context)->context);
+
+    p_cur = (uint8_t *)p_data;
+    size_left = size;
+
+    mutex_locked = cc310_backend_mutex_trylock();
+    VERIFY_TRUE(mutex_locked, NRF_ERROR_CRYPTO_BUSY);
+
+    cc310_bl_backend_enable();
+
+#if defined (NRF_CRYPTO_BACKEND_CC310_BL_HASH_AUTOMATIC_RAM_BUFFER_ENABLED) && (NRF_CRYPTO_BACKEND_CC310_BL_HASH_AUTOMATIC_RAM_BUFFER_ENABLED == 1)
+
+    do
+    {
+        // Copy a block from FLASH to RAM for use in CC310
+        cur_size = (size_left > NRF_CRYPTO_BACKEND_CC310_BL_HASH_AUTOMATIC_RAM_BUFFER_SIZE) ?
+            NRF_CRYPTO_BACKEND_CC310_BL_HASH_AUTOMATIC_RAM_BUFFER_SIZE : size_left;
+
+        // Copy from FLASH to ram
+        memcpy(m_hash_buffer, p_cur, cur_size);
+
+        // Update the hash with current input.
+        crys_error = nrf_cc310_bl_hash_sha256_update(p_backend_context, m_hash_buffer, cur_size);
+
+        size_left -= cur_size;
+        p_cur += cur_size;
+
+    } while(crys_error == SASI_OK && size_left > 0);
+
+#elif defined(NRF_CRYPTO_BACKEND_CC310_BL_HASH_AUTOMATIC_RAM_BUFFER_ENABLED) && (NRF_CRYPTO_BACKEND_CC310_BL_HASH_AUTOMATIC_RAM_BUFFER_ENABLED == 0) 
+
+    // Verify that the data is in RAM (required for CC310 hashing)
+    VERIFY_TRUE(nrfx_is_in_ram(p_data), NRF_ERROR_CRYPTO_INPUT_LOCATION);
+
+    do
+    {
+        // Get the largest block that can sent to the CC310 through DMA
+        cur_size = (size_left > CC310_MAX_LENGTH_DMA_OPERATIONS) ?
+            CC310_MAX_LENGTH_DMA_OPERATIONS : size_left;
+
+        crys_error = nrf_cc310_bl_hash_sha256_update(p_backend_context, p_cur, cur_size);
+
+        size_left -= cur_size;
+        p_cur += cur_size;
+    } while(crys_error == SASI_OK && size_left > 0);
+
+#else
+
+    UNUSED_PARAMETER(p_backend_context);
+    UNUSED_PARAMETER(cur_size);
+    UNUSED_PARAMETER(size_left);
+    UNUSED_PARAMETER(p_cur);
+
+    #warning NRF_CRYPTO_BACKEND_CC310_BL_HASH_AUTOMATIC_RAM_BUFFER_ENABLED define not found in sdk_config.h (Is the sdk_config.h valid?).
+
+#endif
+
+    cc310_bl_backend_disable();
+
+    cc310_backend_mutex_unlock();
+
+    ret_val = hash_result_get(crys_error);
+
+    return ret_val;
+}
+
+
+static uint32_t cc310_bl_backend_hash_sha256_finalize(void    * const p_context,
+                                                      uint8_t        * p_digest,
+                                                      size_t   * const p_digest_size)
+{
+    ret_code_t  ret_val;
+    CRYSError_t crys_error;
+    bool        mutex_locked;
+
+    // Limited parameter testing on this level.
+    // This has been done on upper level.
+
+    nrf_cc310_bl_hash_context_sha256_t * const p_backend_context
+        = &(((nrf_crypto_backend_hash_sha256_context_t * )p_context)->context);
+
+    nrf_cc310_bl_hash_digest_sha256_t * p_int_digest
+        = (nrf_cc310_bl_hash_digest_sha256_t *)p_digest;
+
+    if (NRF_CRYPTO_HASH_SIZE_SHA256 > *p_digest_size)
+    {
+        return NRF_ERROR_CRYPTO_OUTPUT_LENGTH;
+    }
+
+    mutex_locked = cc310_backend_mutex_trylock();
+    VERIFY_TRUE(mutex_locked, NRF_ERROR_CRYPTO_BUSY);
+
+    cc310_bl_backend_enable();
+
+    // Do the hash finalize calculation
+    crys_error = nrf_cc310_bl_hash_sha256_finalize(p_backend_context, p_int_digest);
+
+    cc310_bl_backend_disable();
+
+    cc310_backend_mutex_unlock();
+
+    ret_val = hash_result_get(crys_error);
+
+    if (ret_val == NRF_SUCCESS)
+    {
+        *p_digest_size = NRF_CRYPTO_HASH_SIZE_SHA256;
+    }
+
+#if defined(NRF_CRYPTO_BACKEND_CC310_BL_HASH_LITTLE_ENDIAN_DIGEST_ENABLED) && (NRF_CRYPTO_BACKEND_CC310_BL_HASH_LITTLE_ENDIAN_DIGEST_ENABLED == 1)
+
+    nrf_crypto_internal_swap_endian_in_place(p_digest, NRF_CRYPTO_HASH_SIZE_SHA256);
+
+#elif defined(NRF_CRYPTO_BACKEND_CC310_BL_HASH_LITTLE_ENDIAN_DIGEST_ENABLED) && (NRF_CRYPTO_BACKEND_CC310_BL_HASH_LITTLE_ENDIAN_DIGEST_ENABLED == 0)
+
+    // Do nothing
+
+#else
+
+    #warning NRF_CRYPTO_BACKEND_CC310_BL_HASH_LITTLE_ENDIAN_DIGEST_ENABLED define not found in sdk_config.h (Is the sdk_config.h valid?).
+
+#endif
+
+    return ret_val;
+}
+
+const nrf_crypto_hash_info_t g_nrf_crypto_hash_sha256_info =
+{
+    .init_fn        = cc310_bl_backend_hash_sha256_init,
+    .update_fn      = cc310_bl_backend_hash_sha256_update,
+    .finalize_fn    = cc310_bl_backend_hash_sha256_finalize,
+    .digest_size    = NRF_CRYPTO_HASH_SIZE_SHA256,
+    .hash_mode      = NRF_CRYPTO_HASH_MODE_SHA256
+};
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_BL_HASH_SHA256)
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO) && #if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_BL)
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310_bl/cc310_bl_backend_hash.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310_bl/cc310_bl_backend_hash.h
new file mode 100644
index 0000000..6882c04
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310_bl/cc310_bl_backend_hash.h
@@ -0,0 +1,97 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef CC310_BL_BACKEND_HASH_H__
+#define CC310_BL_BACKEND_HASH_H__
+
+/** @file
+ *
+ * @defgroup nrf_crypto_cc310_bl_backend_hash nrf_crypto CC310_BL backend hash
+ * @{
+ * @ingroup nrf_crypto_cc310_bl_backend
+ *
+ * @brief Hash functionality provided by the nrf_crypto CC310_BL backend.
+ */
+
+#include "sdk_common.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_BL)
+
+#include "sdk_errors.h"
+#include "nrf_crypto_hash_shared.h"
+#include "nrf_cc310_bl_hash_sha256.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_BL_HASH_SHA256)
+
+// Flag that nrf_crypto_hash frontend can be compiled
+#undef  NRF_CRYPTO_HASH_ENABLED
+#define NRF_CRYPTO_HASH_ENABLED 1
+
+// Flag that SHA-256 is enabled in backend
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_HASH_SHA256)
+#error "Duplicate definition of SHA-256. More than one backend enabled");
+#endif
+#define NRF_CRYPTO_HASH_SHA256_ENABLED 1
+
+
+/**@internal @brief nrf_crypto_hash context for SHA-256 in nrf_crypto CC310_BL backend. */
+typedef struct
+{
+    nrf_crypto_hash_internal_context_t header;     /**< Common header for context. */
+    nrf_cc310_bl_hash_context_sha256_t context;    /**< Hash context internal to CC310_BL. */
+} nrf_crypto_backend_hash_sha256_context_t;
+
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_BL_HASH_SHA256)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_BL)
+
+/**@} */
+
+#endif // CC310_BL_BACKEND_HASH_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310_bl/cc310_bl_backend_init.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310_bl/cc310_bl_backend_init.c
new file mode 100644
index 0000000..38f440c
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310_bl/cc310_bl_backend_init.c
@@ -0,0 +1,115 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#include "sdk_common.h"
+#if NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_BL)
+
+#include "nrf.h"
+#include "nrf_crypto_init.h"
+#include "nrf_crypto_error.h"
+
+#include "cc310_bl_backend_shared.h"
+#include "cc310_backend_mutex.h"
+#include "sns_silib.h"
+#include "nrf_cc310_bl_init.h"
+
+/**@brief Mutex to ensure single access to nrf_cc310_bl resources */
+nrf_mtx_t g_cc310_mutex;
+
+static uint32_t init_result_get(uint32_t crys_error)
+{
+    uint32_t ret_val = NRF_ERROR_INTERNAL;
+    switch (crys_error)
+    {
+        case SA_SILIB_RET_OK:
+            ret_val = NRF_SUCCESS;
+            break;
+
+        case SA_SILIB_RET_EINVAL_HW_VERSION:
+            ret_val = NRF_ERROR_CRYPTO_FEATURE_UNAVAILABLE;
+            break;
+
+        default:
+            ret_val = NRF_ERROR_INTERNAL;
+            break;
+    }
+
+    return ret_val;
+}
+
+
+static ret_code_t cc310_bl_backend_init(void)
+{
+    uint32_t                ret_val;
+    CRYSError_t             crys_error;
+
+    cc310_backend_mutex_init();
+
+    // Enable the CC310 HW.
+    NRF_CRYPTOCELL->ENABLE = 1;
+
+    // Initialize the CC310_BL run-time library
+    crys_error = nrf_cc310_bl_init();
+
+    // Disable the CC310 HW after initialization.
+    NRF_CRYPTOCELL->ENABLE = 0;
+
+    ret_val = init_result_get(crys_error);
+
+    return ret_val;
+}
+
+
+static ret_code_t cc310_bl_backend_uninit(void)
+{
+    // Disable the CC310 HW.
+    NRF_CRYPTOCELL->ENABLE = 0;
+
+    return NRF_SUCCESS;
+}
+
+
+CRYPTO_BACKEND_REGISTER(nrf_crypto_backend_info_t const cc310_bl_backend) =
+{
+    .init_fn    = cc310_bl_backend_init,
+    .uninit_fn  = cc310_bl_backend_uninit
+};
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_BL)
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310_bl/cc310_bl_backend_shared.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310_bl/cc310_bl_backend_shared.c
new file mode 100644
index 0000000..520a116
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310_bl/cc310_bl_backend_shared.c
@@ -0,0 +1,68 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+#include "sdk_common.h"
+#if NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_BL)
+
+#include "nrf.h"
+#include "cc310_bl_backend_shared.h"
+#include "nrf_crypto_error.h"
+
+
+void cc310_bl_backend_enable(void)
+{
+    // Enable the cryptocell hardware
+    NRF_CRYPTOCELL->ENABLE = 1;
+
+    // Enable the CryptoCell IRQ
+    NVIC_EnableIRQ(CRYPTOCELL_IRQn);
+}
+
+
+void cc310_bl_backend_disable(void)
+{
+    // Enable the cryptocell hardware
+    NRF_CRYPTOCELL->ENABLE = 0;
+
+    // Disable the CryptoCell IRQ
+    NVIC_DisableIRQ(CRYPTOCELL_IRQn);
+}
+
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_BL)
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310_bl/cc310_bl_backend_shared.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310_bl/cc310_bl_backend_shared.h
new file mode 100644
index 0000000..db7c933
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cc310_bl/cc310_bl_backend_shared.h
@@ -0,0 +1,83 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef CC310_BL_BACKEND_SHARED_H__
+#define CC310_BL_BACKEND_SHARED_H__
+
+/** @file
+ *
+ * @defgroup nrf_crypto_cc310_bl_backend_shared nrf_crypto CC310_BL backend shared
+ * @{
+ * @ingroup nrf_crypto_cc310_bl_backend
+ *
+ * @brief Shared functionality for the nrf_crypto CC310_BL backend.
+ */
+
+#include "sdk_common.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_BL)
+
+#include "sdk_errors.h"
+#include "nrf_crypto_hash_shared.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/**@internal @brief Function to enable CC310 (in HW)
+ */
+void cc310_bl_backend_enable(void);
+
+
+/**@internal @brief Function to disable CC310 (in HW)
+ */
+void cc310_bl_backend_disable(void);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_BL)
+
+/**@} */
+
+#endif // CC310_BL_BACKEND_SHARED_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cifra/cifra_backend_aes_aead.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cifra/cifra_backend_aes_aead.c
new file mode 100644
index 0000000..23b3cb6
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cifra/cifra_backend_aes_aead.c
@@ -0,0 +1,205 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#include "sdk_common.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO)
+
+#include <stdbool.h>
+#include "cifra_backend_aes_aead.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_CIFRA_AES_AEAD)
+
+/**@internal @brief Type declaration of a template matching all possible context sizes
+ *                  for this backend.
+ */
+typedef struct
+{
+    nrf_crypto_aead_internal_context_t header;   /**< Common header for context. */
+    cf_aes_context                     context;
+} nrf_crypto_backend_cifra_aes_aead_context_t;
+
+
+static ret_code_t result_get(int error)
+{
+    switch (error)
+    {
+        case 0:
+            return NRF_SUCCESS;
+
+        case 1:
+            return NRF_ERROR_CRYPTO_AEAD_INVALID_MAC;
+
+        default:
+            return NRF_ERROR_CRYPTO_INTERNAL;
+    }
+}
+
+static ret_code_t backend_cifra_init(void * const p_context, uint8_t * p_key)
+{
+    nrf_crypto_backend_cifra_aes_aead_context_t * p_ctx =
+        (nrf_crypto_backend_cifra_aes_aead_context_t *)p_context;
+
+    if ((p_ctx->header.p_info->key_size != NRF_CRYPTO_KEY_SIZE_128) &&
+        (p_ctx->header.p_info->key_size != NRF_CRYPTO_KEY_SIZE_192) &&
+        (p_ctx->header.p_info->key_size != NRF_CRYPTO_KEY_SIZE_256))
+    {
+        return NRF_ERROR_CRYPTO_KEY_SIZE;
+    }
+
+    VERIFY_TRUE((p_ctx->header.p_info->mode == NRF_CRYPTO_AEAD_MODE_AES_EAX),
+                NRF_ERROR_CRYPTO_FEATURE_UNAVAILABLE);
+
+    cf_aes_init(&p_ctx->context,
+                p_key,
+                (p_ctx->header.p_info->key_size)>>3);  // >>3: changes bits to bytes
+
+    return NRF_SUCCESS;
+}
+
+
+static ret_code_t backend_cifra_uninit(void * const p_context)
+{
+    nrf_crypto_backend_cifra_aes_aead_context_t * p_ctx =
+        (nrf_crypto_backend_cifra_aes_aead_context_t *)p_context;
+
+    cf_aes_finish(&p_ctx->context);
+
+    return NRF_SUCCESS;
+}
+
+static ret_code_t backend_cifra_crypt(void * const           p_context,
+                                      nrf_crypto_operation_t operation,
+                                      uint8_t *              p_nonce,
+                                      uint8_t                nonce_size,
+                                      uint8_t *              p_adata,
+                                      size_t                 adata_size,
+                                      uint8_t *              p_data_in,
+                                      size_t                 data_in_size,
+                                      uint8_t *              p_data_out,
+                                      uint8_t *              p_mac,
+                                      uint8_t                mac_size)
+{
+
+    int        result;
+    ret_code_t ret_val;
+
+    nrf_crypto_backend_cifra_aes_aead_context_t * p_ctx =
+        (nrf_crypto_backend_cifra_aes_aead_context_t *)p_context;
+
+    ret_val = NRF_SUCCESS;
+
+    /* EAX mode allows following mac size: [1 ... 16] */
+    if ((mac_size < 1) || (mac_size > NRF_CRYPTO_AES_BLOCK_SIZE))
+    {
+        return NRF_ERROR_CRYPTO_AEAD_MAC_SIZE;
+    }
+
+    if (operation == NRF_CRYPTO_ENCRYPT)
+    {
+        cf_eax_encrypt(&cf_aes,
+                       &p_ctx->context,
+                       p_data_in,
+                       data_in_size,
+                       p_adata,
+                       adata_size,
+                       p_nonce,
+                       (size_t)nonce_size,
+                       p_data_out,
+                       p_mac,
+                       mac_size);
+    }
+    else if (operation == NRF_CRYPTO_DECRYPT)
+    {
+        result = cf_eax_decrypt(&cf_aes,
+                                &p_ctx->context,
+                                p_data_in,
+                                data_in_size,
+                                p_adata,
+                                adata_size,
+                                p_nonce,
+                                (size_t)nonce_size,
+                                p_mac,
+                                mac_size,
+                                p_data_out);
+        ret_val = result_get(result);
+    }
+    else
+    {
+        return NRF_ERROR_CRYPTO_INVALID_PARAM;
+    }
+
+    return ret_val;
+}
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CIFRA_AES_EAX)
+nrf_crypto_aead_info_t const g_nrf_crypto_aes_eax_128_info =
+{
+    .key_size  = NRF_CRYPTO_KEY_SIZE_128,
+    .mode      = NRF_CRYPTO_AEAD_MODE_AES_EAX,
+
+    .init_fn   = backend_cifra_init,
+    .uninit_fn = backend_cifra_uninit,
+    .crypt_fn  = backend_cifra_crypt
+};
+
+nrf_crypto_aead_info_t const g_nrf_crypto_aes_eax_192_info =
+{
+    .key_size  = NRF_CRYPTO_KEY_SIZE_192,
+    .mode      = NRF_CRYPTO_AEAD_MODE_AES_EAX,
+
+    .init_fn   = backend_cifra_init,
+    .uninit_fn = backend_cifra_uninit,
+    .crypt_fn  = backend_cifra_crypt
+};
+
+nrf_crypto_aead_info_t const g_nrf_crypto_aes_eax_256_info =
+{
+    .key_size  = NRF_CRYPTO_KEY_SIZE_256,
+    .mode      = NRF_CRYPTO_AEAD_MODE_AES_EAX,
+
+    .init_fn   = backend_cifra_init,
+    .uninit_fn = backend_cifra_uninit,
+    .crypt_fn  = backend_cifra_crypt
+};
+#endif
+
+#endif // MODULE_ENABLED(NRF_CRYPTO_AES_CCM_BACKEND_MBEDTLS)
+#endif // MODULE_ENABLED(NRF_CRYPTO)
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cifra/cifra_backend_aes_aead.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cifra/cifra_backend_aes_aead.h
new file mode 100644
index 0000000..d0575ac
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/cifra/cifra_backend_aes_aead.h
@@ -0,0 +1,98 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef CIFRA_BACKEND_AES_AEAD_H__
+#define CIFRA_BACKEND_AES_AEAD_H__
+
+/** @file
+ *
+ * @defgroup nrf_crypto_cifra_backend_aes_aead nrf_crypto Cifra backend AES AEAD
+ * @{
+ * @ingroup nrf_crypto_cifra_backend
+ *
+ * @brief AES AEAD functionality provided by the nrf_crypto Cifra backend.
+ */
+
+#include "sdk_config.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CIFRA)
+
+#include "modes.h"
+#include "cifra_eax_aes.h"
+#include "nrf_crypto_error.h"
+#include "nrf_crypto_types.h"
+#include "nrf_crypto_aead_shared.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* AES EAX */
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CIFRA_AES_EAX)
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_AES_EAX)
+#error "Duplicate definition of AES EAX mode. More than one backend enabled");
+#endif
+#define NRF_CRYPTO_AES_EAX_ENABLED  1
+#undef  NRF_CRYPTO_AEAD_ENABLED
+#define NRF_CRYPTO_AEAD_ENABLED  1  // Flag that nrf_crypto_aes_aead frontend can be compiled
+#undef  NRF_CRYPTO_CIFRA_AES_AEAD_ENABLED
+#define NRF_CRYPTO_CIFRA_AES_AEAD_ENABLED   1   // aes_aead backend cifra can be compiled
+
+/* defines for test purposes */
+#define NRF_CRYPTO_AES_EAX_128_ENABLED  1
+#define NRF_CRYPTO_AES_EAX_192_ENABLED  1
+#define NRF_CRYPTO_AES_EAX_256_ENABLED  1
+
+typedef struct
+{
+    nrf_crypto_aead_internal_context_t header;  /**< Common header for context. */
+    cf_aes_context                     context; /**< AES EAX context internal to Cifra. */
+} nrf_crypto_backend_aes_eax_context_t;
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CIFRA)
+
+/** @} */
+
+#endif // CIFRA_BACKEND_AES_AEAD_H__
+
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/mbedtls/mbedtls_backend_aes.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/mbedtls/mbedtls_backend_aes.c
new file mode 100644
index 0000000..9433471
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/mbedtls/mbedtls_backend_aes.c
@@ -0,0 +1,1213 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#include "sdk_common.h"
+#if NRF_MODULE_ENABLED(NRF_CRYPTO)
+
+/*lint -save -e????*/
+#include "mbedtls/md.h"
+#include "mbedtls/aes.h"
+#include "mbedtls/cipher.h"
+/*lint -restore*/
+#include "nrf_crypto_error.h"
+#include "mbedtls_backend_aes.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_MBEDTLS_AES)
+
+/* macro changing bits to bytes */
+#define BITS_TO_BYTES(bits)     ((bits)>>3)
+#define BACKEND_ERROR_CHECK(error)      \
+    do {                                \
+        if ((error) != 0)               \
+        {                               \
+            return result_get((error)); \
+        }                               \
+    } while (0);
+
+/**@internal @brief Type declarations of templates matching all possible context sizes
+ *                  for this backend.
+ */
+typedef struct
+{
+    nrf_crypto_aes_internal_context_t header;       /**< Common header for context. */
+    nrf_crypto_backend_aes_ctx_t      backend;      /**< Backend-specific internal context. */
+    uint32_t                          context[1];   /**< AES context internal to mbed TLS. */
+} nrf_crypto_backend_mbedtls_aes_any_context_t;
+
+/**@internal @brief Type declarations of templates matching all possible context sizes
+ *                  for this backend.
+ */
+typedef union
+{
+    nrf_crypto_backend_mbedtls_aes_any_context_t any;      /**< Common for all contexts. */
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_ECB)
+    nrf_crypto_backend_aes_ecb_context_t ecb;
+#endif
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CBC)
+    nrf_crypto_backend_aes_cbc_context_t cbc;
+#endif
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CTR)
+    nrf_crypto_backend_aes_ctr_context_t ctr;
+#endif
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CFB)
+    nrf_crypto_backend_aes_cfb_context_t cfb;
+#endif
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CBC_MAC)
+    nrf_crypto_backend_aes_cbc_mac_context_t cbc_mac;
+#endif
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CMAC)
+    nrf_crypto_backend_aes_cmac_context_t cmac;
+#endif
+} nrf_crypto_backend_mbedtls_aes_context_t;
+
+
+static ret_code_t result_get(int error)
+{
+    ret_code_t ret_val;
+    switch (error)
+    {
+        case 0:
+            ret_val = NRF_SUCCESS;
+            break;
+
+        case MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH:
+            ret_val = NRF_ERROR_CRYPTO_INPUT_LENGTH;
+            break;
+
+        case MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA:
+            ret_val = NRF_ERROR_CRYPTO_INPUT_LENGTH;
+            break;
+
+        case MBEDTLS_ERR_CIPHER_ALLOC_FAILED:
+            ret_val = NRF_ERROR_CRYPTO_ALLOC_FAILED;
+            break;
+
+        case MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE:
+            ret_val = NRF_ERROR_CRYPTO_FEATURE_UNAVAILABLE;
+            break;
+
+        case MBEDTLS_ERR_MD_BAD_INPUT_DATA:
+            ret_val = NRF_ERROR_CRYPTO_INVALID_PARAM;
+            break;
+
+        default:
+            ret_val = NRF_ERROR_CRYPTO_INTERNAL;
+            break;
+    }
+
+    return ret_val;
+}
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CMAC)
+static ret_code_t backend_cmac_init(nrf_crypto_backend_aes_cmac_context_t * const p_cmac_ctx)
+{
+    int error;
+
+    mbedtls_cipher_type_t         cipher_type;
+    mbedtls_cipher_info_t const * p_cipher_info;
+
+    mbedtls_cipher_init(&p_cmac_ctx->context);
+
+    switch (p_cmac_ctx->header.p_info->key_size)
+    {
+        case NRF_CRYPTO_KEY_SIZE_128:
+                cipher_type = MBEDTLS_CIPHER_AES_128_ECB;
+                break;
+
+        case NRF_CRYPTO_KEY_SIZE_192:
+            cipher_type = MBEDTLS_CIPHER_AES_192_ECB;
+            break;
+
+        case NRF_CRYPTO_KEY_SIZE_256:
+            cipher_type = MBEDTLS_CIPHER_AES_256_ECB;
+            break;
+
+        default:
+                return NRF_ERROR_CRYPTO_CONTEXT_NOT_INITIALIZED;
+    }
+
+    p_cipher_info = mbedtls_cipher_info_from_type(cipher_type);
+
+    if (p_cipher_info == NULL)
+    {
+        return NRF_ERROR_CRYPTO_INTERNAL;
+    }
+
+    error = mbedtls_cipher_setup(&p_cmac_ctx->context, p_cipher_info);
+    BACKEND_ERROR_CHECK(error);
+
+    return NRF_SUCCESS;
+}
+#endif
+
+static ret_code_t backend_mbedtls_init(void * const p_context, nrf_crypto_operation_t operation)
+{
+    ret_code_t ret_val = NRF_SUCCESS;
+
+    nrf_crypto_backend_mbedtls_aes_context_t * p_ctx =
+        (nrf_crypto_backend_mbedtls_aes_context_t *)p_context;
+
+    switch (p_ctx->any.header.p_info->key_size)
+    {
+        case NRF_CRYPTO_KEY_SIZE_128:
+        case NRF_CRYPTO_KEY_SIZE_192:
+        case NRF_CRYPTO_KEY_SIZE_256:
+            break;
+
+        default:
+            return NRF_ERROR_CRYPTO_KEY_SIZE;
+    }
+
+    switch (p_ctx->any.header.p_info->mode)
+    {
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CBC)
+        case NRF_CRYPTO_AES_MODE_CBC:
+        case NRF_CRYPTO_AES_MODE_CBC_PAD_PCKS7:
+            VERIFY_FALSE(((operation != NRF_CRYPTO_ENCRYPT) && (operation != NRF_CRYPTO_DECRYPT)),
+                         NRF_ERROR_CRYPTO_INVALID_PARAM);
+            memset(&p_ctx->cbc.backend, 0, sizeof(p_ctx->cbc.backend));
+
+            mbedtls_aes_init(&p_ctx->cbc.context);
+            break;
+#endif
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CTR)
+        case NRF_CRYPTO_AES_MODE_CTR:
+            VERIFY_FALSE(((operation != NRF_CRYPTO_ENCRYPT) && (operation != NRF_CRYPTO_DECRYPT)),
+                         NRF_ERROR_CRYPTO_INVALID_PARAM);
+            memset(&p_ctx->ctr.backend, 0, sizeof(p_ctx->ctr.backend));
+
+            mbedtls_aes_init(&p_ctx->ctr.context);
+            break;
+#endif
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CFB)
+        case NRF_CRYPTO_AES_MODE_CFB:
+            VERIFY_FALSE(((operation != NRF_CRYPTO_ENCRYPT) && (operation != NRF_CRYPTO_DECRYPT)),
+                         NRF_ERROR_CRYPTO_INVALID_PARAM);
+            memset(&p_ctx->cfb.backend, 0, sizeof(p_ctx->cfb.backend));
+
+            mbedtls_aes_init(&p_ctx->cfb.context);
+            break;
+#endif
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_ECB)
+        case NRF_CRYPTO_AES_MODE_ECB:
+        case NRF_CRYPTO_AES_MODE_ECB_PAD_PCKS7:
+            VERIFY_FALSE(((operation != NRF_CRYPTO_ENCRYPT) && (operation != NRF_CRYPTO_DECRYPT)),
+                         NRF_ERROR_CRYPTO_INVALID_PARAM);
+            memset(&p_ctx->ecb.backend, 0, sizeof(p_ctx->ecb.backend));
+
+            mbedtls_aes_init(&p_ctx->ecb.context);
+            break;
+#endif
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CBC_MAC)
+        case NRF_CRYPTO_AES_MODE_CBC_MAC:
+        case NRF_CRYPTO_AES_MODE_CBC_MAC_PAD_PCKS7:
+            VERIFY_TRUE((operation == NRF_CRYPTO_MAC_CALCULATE), NRF_ERROR_CRYPTO_INVALID_PARAM);
+            memset(&p_ctx->cbc_mac.backend, 0, sizeof(p_ctx->cbc_mac.backend));
+
+            mbedtls_aes_init(&p_ctx->cbc_mac.context);
+            break;
+#endif
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CMAC)
+        case NRF_CRYPTO_AES_MODE_CMAC:
+            VERIFY_TRUE((operation == NRF_CRYPTO_MAC_CALCULATE), NRF_ERROR_CRYPTO_INVALID_PARAM);
+
+            ret_val = backend_cmac_init(&p_ctx->cmac);
+            break;
+#endif
+        default:
+            ret_val = NRF_ERROR_CRYPTO_FEATURE_UNAVAILABLE;
+            break;
+    }
+
+    p_ctx->any.backend.operation = operation;
+
+    return ret_val;
+}
+
+static ret_code_t backend_mbedtls_uninit(void * const p_context)
+{
+    nrf_crypto_backend_mbedtls_aes_context_t * p_ctx =
+        (nrf_crypto_backend_mbedtls_aes_context_t *)p_context;
+
+    switch (p_ctx->any.header.p_info->mode)
+    {
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CBC)
+        case NRF_CRYPTO_AES_MODE_CBC:
+        case NRF_CRYPTO_AES_MODE_CBC_PAD_PCKS7:
+            mbedtls_aes_free(&p_ctx->cbc.context);
+            break;
+#endif
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CTR)
+        case NRF_CRYPTO_AES_MODE_CTR:
+            mbedtls_aes_free(&p_ctx->ctr.context);
+            break;
+#endif
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CFB)
+        case NRF_CRYPTO_AES_MODE_CFB:
+            mbedtls_aes_free(&p_ctx->cfb.context);
+            break;
+#endif
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_ECB)
+        case NRF_CRYPTO_AES_MODE_ECB:
+        case NRF_CRYPTO_AES_MODE_ECB_PAD_PCKS7:
+            mbedtls_aes_free(&p_ctx->ecb.context);
+            break;
+#endif
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CBC_MAC)
+        case NRF_CRYPTO_AES_MODE_CBC_MAC:
+        case NRF_CRYPTO_AES_MODE_CBC_MAC_PAD_PCKS7:
+            mbedtls_aes_free(&p_ctx->cbc_mac.context);
+            break;
+#endif
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CMAC)
+        case NRF_CRYPTO_AES_MODE_CMAC:
+            mbedtls_cipher_free(&p_ctx->cmac.context);
+            break;
+#endif
+
+        default:
+            return NRF_ERROR_CRYPTO_FEATURE_UNAVAILABLE;
+    }
+
+    return NRF_SUCCESS;
+}
+
+static ret_code_t backend_mbedtls_key_set(void * const p_context, uint8_t * p_key)
+{
+    int        error;
+    ret_code_t ret_val;
+
+    nrf_crypto_backend_mbedtls_aes_context_t * p_ctx =
+        (nrf_crypto_backend_mbedtls_aes_context_t *)p_context;
+
+    switch (p_ctx->any.header.p_info->mode)
+    {
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CBC)
+        case NRF_CRYPTO_AES_MODE_CBC:
+        case NRF_CRYPTO_AES_MODE_CBC_PAD_PCKS7:
+            if (p_ctx->cbc.backend.operation == NRF_CRYPTO_ENCRYPT)
+            {
+                error = mbedtls_aes_setkey_enc(&p_ctx->cbc.context,
+                                               (uint8_t const *)p_key,
+                                               p_ctx->cbc.header.p_info->key_size);
+            }
+            else
+            {
+                error = mbedtls_aes_setkey_dec(&p_ctx->cbc.context,
+                                               (uint8_t const *)p_key,
+                                               p_ctx->cbc.header.p_info->key_size);
+            }
+            break;
+#endif
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CTR)
+        case NRF_CRYPTO_AES_MODE_CTR:
+            /* Due to the nature of CFB / CTR, you should use the same key schedule for both
+               encryption and decryption.*/
+            error = mbedtls_aes_setkey_enc(&p_ctx->ctr.context,
+                                           (uint8_t const *)p_key,
+                                           p_ctx->ctr.header.p_info->key_size);
+            break;
+#endif
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CFB)
+        case NRF_CRYPTO_AES_MODE_CFB:
+            /* Due to the nature of CFB / CTR, you should use the same key schedule for both
+               encryption and decryption.*/
+            error = mbedtls_aes_setkey_enc(&p_ctx->cfb.context,
+                                           (uint8_t const *)p_key,
+                                           p_ctx->cfb.header.p_info->key_size);
+            break;
+#endif
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_ECB)
+        case NRF_CRYPTO_AES_MODE_ECB:
+        case NRF_CRYPTO_AES_MODE_ECB_PAD_PCKS7:
+            if (p_ctx->ecb.backend.operation == NRF_CRYPTO_ENCRYPT)
+            {
+                error = mbedtls_aes_setkey_enc(&p_ctx->ecb.context,
+                                               (uint8_t const *)p_key,
+                                               p_ctx->ecb.header.p_info->key_size);
+            }
+            else
+            {
+                error = mbedtls_aes_setkey_dec(&p_ctx->ecb.context,
+                                               (uint8_t const *)p_key,
+                                               p_ctx->ecb.header.p_info->key_size);
+            }
+            break;
+#endif
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CBC_MAC)
+        case NRF_CRYPTO_AES_MODE_CBC_MAC:
+        case NRF_CRYPTO_AES_MODE_CBC_MAC_PAD_PCKS7:
+            error = mbedtls_aes_setkey_enc(&p_ctx->cbc_mac.context,
+                                           (uint8_t const *)p_key,
+                                           p_ctx->cbc_mac.header.p_info->key_size);
+            break;
+#endif
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CMAC)
+                case NRF_CRYPTO_AES_MODE_CMAC:
+                    error = mbedtls_cipher_cmac_starts(&p_ctx->cmac.context,
+                                                       p_key,
+                                                       p_ctx->cmac.header.p_info->key_size);
+                    break;
+#endif
+
+        default:
+            return NRF_ERROR_CRYPTO_FEATURE_UNAVAILABLE;
+    }
+
+    ret_val = result_get(error);
+
+    return ret_val;
+}
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CBC)      ||  \
+    NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CTR)      ||  \
+    NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CFB)      ||  \
+    NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CBC_MAC)
+static ret_code_t backend_mbedtls_iv_set(void * const p_context, uint8_t * p_iv)
+{
+    nrf_crypto_backend_mbedtls_aes_context_t * p_ctx =
+        (nrf_crypto_backend_mbedtls_aes_context_t *)p_context;
+
+    memcpy(&p_ctx->any.backend.iv[0], p_iv, sizeof(p_ctx->any.backend.iv));
+
+    return NRF_SUCCESS;
+}
+
+static ret_code_t backend_mbedtls_iv_get(void * const p_context, uint8_t * p_iv)
+{
+    nrf_crypto_backend_mbedtls_aes_context_t * p_ctx =
+        (nrf_crypto_backend_mbedtls_aes_context_t *)p_context;
+
+    memcpy(p_iv, p_ctx->any.backend.iv, sizeof(p_ctx->any.backend.iv));
+
+    return NRF_SUCCESS;
+}
+#endif
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_ECB)
+/* Function extending mbedtls_aes_crypt_ecb functionality. It allows to process more than 1
+   data block. It is returning MBEDTLS error type. */
+static int backend_mbedtls_ecb_crypt(nrf_crypto_backend_aes_ecb_context_t * const p_ctx,
+                                     uint8_t *                                    p_text_in,
+                                     uint8_t *                                    p_text_out,
+                                     size_t                                       text_size)
+{
+    int    error        = 0;
+    size_t crypted_text = 0;
+
+    if ((text_size & 0x0F) != 0)
+    {
+        return MBEDTLS_ERR_AES_INVALID_INPUT_LENGTH;
+    }
+
+    while (crypted_text < text_size)
+    {
+        error = mbedtls_aes_crypt_ecb(&p_ctx->context,
+                                      (int)p_ctx->backend.operation,
+                                      p_text_in  + crypted_text,
+                                      p_text_out + crypted_text);
+        if (error != 0)
+        {
+            break;
+        }
+        crypted_text += NRF_CRYPTO_AES_BLOCK_SIZE;
+    }
+
+    return error;
+}
+#endif
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CBC_MAC)
+static int backend_mbedtls_cbc_mac_update(void * const p_context,
+                                          uint8_t *    p_data_in,
+                                          size_t       data_size,
+                                          uint8_t *    p_data_out)
+{
+    int error = 0;
+
+    nrf_crypto_backend_mbedtls_aes_context_t * p_ctx =
+        (nrf_crypto_backend_mbedtls_aes_context_t *)p_context;
+
+    for (size_t i = 0; i < data_size; i += NRF_CRYPTO_AES_BLOCK_SIZE)
+    {
+        error = mbedtls_aes_crypt_cbc(&p_ctx->cbc_mac.context,
+                                      MBEDTLS_AES_ENCRYPT,
+                                      NRF_CRYPTO_AES_BLOCK_SIZE,
+                                      p_ctx->cbc_mac.backend.iv,
+                                      (uint8_t const *)p_data_in + i,
+                                      p_data_out);
+        if (error != 0)
+        {
+            return error;
+        }
+    }
+
+    return error;
+}
+
+static ret_code_t backend_mbedtls_cbc_mac_finalize(void * const p_context,
+                                                   uint8_t *    p_data_in,
+                                                   size_t       data_size,
+                                                   uint8_t *    p_data_out,
+                                                   size_t *     p_data_out_size)
+{
+    int error;
+
+    if (*p_data_out_size < NRF_CRYPTO_AES_BLOCK_SIZE)
+    {
+        return NRF_ERROR_CRYPTO_OUTPUT_LENGTH;
+    }
+
+    /* this function does not support padding */
+    if ((data_size & 0xF) != 0)
+    {
+        return NRF_ERROR_CRYPTO_INPUT_LENGTH;
+    }
+
+    error = backend_mbedtls_cbc_mac_update(p_context, p_data_in, data_size, p_data_out);
+    BACKEND_ERROR_CHECK(error);
+
+    *p_data_out_size = NRF_CRYPTO_AES_BLOCK_SIZE;
+
+    return NRF_SUCCESS;
+}
+
+static ret_code_t backend_mbedtls_cbc_mac_padding_finalize(void * const p_context,
+                                                           uint8_t *    p_data_in,
+                                                           size_t       data_size,
+                                                           uint8_t *    p_data_out,
+                                                           size_t *     p_data_out_size)
+{
+    ret_code_t  ret_val;
+    uint8_t     padding_buffer[NRF_CRYPTO_AES_BLOCK_SIZE] = {0};
+    uint8_t     msg_ending = (uint8_t)(data_size & (size_t)0x0F);
+
+    if (*p_data_out_size < NRF_CRYPTO_AES_BLOCK_SIZE)
+    {
+        /* output buffer too small */
+        return NRF_ERROR_CRYPTO_OUTPUT_LENGTH;
+    }
+
+    data_size -= msg_ending;
+
+    if (data_size > 0)
+    {
+        ret_val = backend_mbedtls_cbc_mac_update(p_context,
+                                                 p_data_in,
+                                                 data_size,
+                                                 p_data_out);
+        VERIFY_SUCCESS(ret_val);
+    }
+
+    ret_val = padding_pkcs7_add(&padding_buffer[0],
+                                p_data_in + data_size,
+                                msg_ending);
+    VERIFY_SUCCESS(ret_val);
+
+    ret_val = backend_mbedtls_cbc_mac_finalize(p_context,
+                                               &padding_buffer[0],
+                                               NRF_CRYPTO_AES_BLOCK_SIZE,
+                                               p_data_out,
+                                               p_data_out_size);
+    VERIFY_SUCCESS(ret_val);
+
+    return ret_val;
+}
+#endif
+
+static ret_code_t backend_mbedtls_update(void * const p_context,
+                                         uint8_t *    p_data_in,
+                                         size_t       data_size,
+                                         uint8_t *    p_data_out)
+{
+    int error;
+
+    nrf_crypto_backend_mbedtls_aes_context_t * p_ctx =
+        (nrf_crypto_backend_mbedtls_aes_context_t *)p_context;
+
+    switch (p_ctx->any.header.p_info->mode)
+    {
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CBC)
+        case NRF_CRYPTO_AES_MODE_CBC:
+        case NRF_CRYPTO_AES_MODE_CBC_PAD_PCKS7:
+            error = mbedtls_aes_crypt_cbc(&p_ctx->cbc.context,
+                                          (int)p_ctx->cbc.backend.operation,
+                                          data_size,
+                                          p_ctx->cbc.backend.iv,
+                                          (uint8_t const *)p_data_in,
+                                          p_data_out);
+            break;
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CTR)
+        case NRF_CRYPTO_AES_MODE_CTR:
+        {
+            size_t  nc_off = 0;
+            uint8_t stream_block[NRF_CRYPTO_AES_BLOCK_SIZE];
+
+            error = mbedtls_aes_crypt_ctr(&p_ctx->ctr.context,
+                                          data_size,
+                                          &nc_off,
+                                          p_ctx->ctr.backend.iv,
+                                          stream_block,
+                                          (uint8_t const *)p_data_in,
+                                          p_data_out);
+            break;
+        }
+#endif
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CFB)
+        case NRF_CRYPTO_AES_MODE_CFB:
+            error = mbedtls_aes_crypt_cfb8(&p_ctx->cfb.context,
+                                           (int)p_ctx->cfb.backend.operation,
+                                           data_size,
+                                           p_ctx->cfb.backend.iv,
+                                           (uint8_t const *)p_data_in,
+                                           p_data_out);
+            break;
+#endif
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_ECB)
+        case NRF_CRYPTO_AES_MODE_ECB:
+        case NRF_CRYPTO_AES_MODE_ECB_PAD_PCKS7:
+            error = backend_mbedtls_ecb_crypt(&p_ctx->ecb, p_data_in, p_data_out, data_size);
+            break;
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CBC_MAC)
+        case NRF_CRYPTO_AES_MODE_CBC_MAC:
+        case NRF_CRYPTO_AES_MODE_CBC_MAC_PAD_PCKS7:
+            error = backend_mbedtls_cbc_mac_update(p_context, p_data_in, data_size, p_data_out);
+            break;
+#endif
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CMAC)
+        case NRF_CRYPTO_AES_MODE_CMAC:
+            error = mbedtls_cipher_cmac_update(&p_ctx->cmac.context,
+                                               p_data_in,
+                                               data_size);
+            break;
+#endif
+
+        default:
+            return NRF_ERROR_CRYPTO_CONTEXT_NOT_INITIALIZED;
+    }
+    BACKEND_ERROR_CHECK(error);
+
+    return NRF_SUCCESS;
+}
+
+static ret_code_t backend_mbedtls_finalize(void * const p_context,
+                                           uint8_t *    p_data_in,
+                                           size_t       data_size,
+                                           uint8_t *    p_data_out,
+                                           size_t *     p_data_out_size)
+{
+    ret_code_t ret_val;
+
+    nrf_crypto_backend_mbedtls_aes_context_t * p_ctx =
+        (nrf_crypto_backend_mbedtls_aes_context_t *)p_context;
+
+    if (*p_data_out_size < data_size)
+    {
+        return NRF_ERROR_CRYPTO_OUTPUT_LENGTH;
+    }
+
+    /* data is not multiple of 16 bytes */
+    if ((data_size & 0x0F) != 0)
+    {
+        if ((p_ctx->any.header.p_info->mode != NRF_CRYPTO_AES_MODE_CTR) &&
+            (p_ctx->any.header.p_info->mode != NRF_CRYPTO_AES_MODE_CFB))
+        {
+            /* There are separate handlers for AES modes with padding and for MAC modes. */
+            return NRF_ERROR_CRYPTO_INPUT_LENGTH;
+        }
+    }
+
+    ret_val = backend_mbedtls_update(p_context, p_data_in, data_size, p_data_out);
+    VERIFY_SUCCESS(ret_val);
+
+    *p_data_out_size = data_size;
+
+    return ret_val;
+}
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CMAC)
+static ret_code_t backend_mbedtls_cmac_finalize(void * const p_context,
+                                                uint8_t *    p_data_in,
+                                                size_t       data_size,
+                                                uint8_t *    p_data_out,
+                                                size_t *     p_data_out_size)
+{
+    int        error;
+
+    nrf_crypto_backend_mbedtls_aes_context_t * p_ctx =
+        (nrf_crypto_backend_mbedtls_aes_context_t *)p_context;
+
+    if (*p_data_out_size < NRF_CRYPTO_AES_BLOCK_SIZE)
+    {
+        return NRF_ERROR_CRYPTO_OUTPUT_LENGTH;
+    }
+
+    error = mbedtls_cipher_cmac_update(&p_ctx->cmac.context, p_data_in, data_size);
+    BACKEND_ERROR_CHECK(error);
+
+    error = mbedtls_cipher_cmac_finish(&p_ctx->cmac.context, p_data_out);
+    BACKEND_ERROR_CHECK(error);
+
+    *p_data_out_size = NRF_CRYPTO_AES_BLOCK_SIZE;
+
+    return NRF_SUCCESS;
+}
+#endif
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CBC) || \
+    NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_ECB)
+static ret_code_t backend_mbedtls_padding_finalize(void * const p_context,
+                                                   uint8_t *    p_data_in,
+                                                   size_t       data_size,
+                                                   uint8_t *    p_data_out,
+                                                   size_t *     p_data_out_size)
+{
+    ret_code_t ret_val;
+    size_t     buff_out_size;
+    uint8_t    padding_buffer[NRF_CRYPTO_AES_BLOCK_SIZE] = {0};
+    uint8_t    msg_ending = (uint8_t)(data_size & (size_t)0x0F);
+
+    nrf_crypto_backend_mbedtls_aes_context_t * p_ctx =
+        (nrf_crypto_backend_mbedtls_aes_context_t *)p_context;
+
+    if (p_ctx->any.backend.operation == NRF_CRYPTO_DECRYPT)
+    {
+        ret_val = backend_mbedtls_finalize(p_context,
+                                           p_data_in,
+                                           data_size,
+                                           p_data_out,
+                                           p_data_out_size);
+        VERIFY_SUCCESS(ret_val);
+
+        ret_val = padding_pkcs7_remove(p_data_out,
+                                       p_data_out_size);
+        return ret_val;
+    }
+
+    /* -------------- ENCRYPTION --------------*/
+    data_size -= msg_ending;
+
+    if (*p_data_out_size < (data_size + NRF_CRYPTO_AES_BLOCK_SIZE))
+    {
+        /* no space for padding */
+        return NRF_ERROR_CRYPTO_OUTPUT_LENGTH;
+    }
+
+    if (data_size > 0)
+    {
+        /* Encrypt 16 byte blocks */
+        ret_val = backend_mbedtls_update(p_context,
+                                         p_data_in,
+                                         data_size,
+                                         p_data_out);
+        VERIFY_SUCCESS(ret_val);
+    }
+
+    ret_val = padding_pkcs7_add(&padding_buffer[0],
+                                p_data_in + data_size,
+                                msg_ending);
+    VERIFY_SUCCESS(ret_val);
+
+    buff_out_size = *p_data_out_size - data_size;
+
+    ret_val = backend_mbedtls_finalize(p_context,
+                                       &padding_buffer[0],
+                                       NRF_CRYPTO_AES_BLOCK_SIZE,
+                                       p_data_out + data_size,
+                                       &buff_out_size);
+    VERIFY_SUCCESS(ret_val);
+
+    *p_data_out_size = buff_out_size + data_size;
+
+    return ret_val;
+}
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CBC)
+nrf_crypto_aes_info_t const g_nrf_crypto_aes_cbc_128_info =
+{
+    .mode           = NRF_CRYPTO_AES_MODE_CBC,
+    .key_size       = NRF_CRYPTO_KEY_SIZE_128,
+    .context_size   = sizeof(nrf_crypto_backend_aes_cbc_context_t),
+
+    .init_fn        = backend_mbedtls_init,
+    .uninit_fn      = backend_mbedtls_uninit,
+    .key_set_fn     = backend_mbedtls_key_set,
+    .iv_set_fn      = backend_mbedtls_iv_set,
+    .iv_get_fn      = backend_mbedtls_iv_get,
+    .update_fn      = backend_mbedtls_update,
+    .finalize_fn    = backend_mbedtls_finalize
+};
+
+nrf_crypto_aes_info_t const g_nrf_crypto_aes_cbc_192_info =
+{
+    .mode           = NRF_CRYPTO_AES_MODE_CBC,
+    .key_size       = NRF_CRYPTO_KEY_SIZE_192,
+    .context_size   = sizeof(nrf_crypto_backend_aes_cbc_context_t),
+
+    .init_fn        = backend_mbedtls_init,
+    .uninit_fn      = backend_mbedtls_uninit,
+    .key_set_fn     = backend_mbedtls_key_set,
+    .iv_set_fn      = backend_mbedtls_iv_set,
+    .iv_get_fn      = backend_mbedtls_iv_get,
+    .update_fn      = backend_mbedtls_update,
+    .finalize_fn    = backend_mbedtls_finalize
+};
+
+nrf_crypto_aes_info_t const g_nrf_crypto_aes_cbc_256_info =
+{
+    .mode           = NRF_CRYPTO_AES_MODE_CBC,
+    .key_size       = NRF_CRYPTO_KEY_SIZE_256,
+    .context_size   = sizeof(nrf_crypto_backend_aes_cbc_context_t),
+
+    .init_fn        = backend_mbedtls_init,
+    .uninit_fn      = backend_mbedtls_uninit,
+    .key_set_fn     = backend_mbedtls_key_set,
+    .iv_set_fn      = backend_mbedtls_iv_set,
+    .iv_get_fn      = backend_mbedtls_iv_get,
+    .update_fn      = backend_mbedtls_update,
+    .finalize_fn    = backend_mbedtls_finalize
+};
+
+nrf_crypto_aes_info_t const g_nrf_crypto_aes_cbc_128_pad_pkcs7_info =
+{
+    .mode           = NRF_CRYPTO_AES_MODE_CBC_PAD_PCKS7,
+    .key_size       = NRF_CRYPTO_KEY_SIZE_128,
+    .context_size   = sizeof(nrf_crypto_backend_aes_cbc_context_t),
+
+    .init_fn        = backend_mbedtls_init,
+    .uninit_fn      = backend_mbedtls_uninit,
+    .key_set_fn     = backend_mbedtls_key_set,
+    .iv_set_fn      = backend_mbedtls_iv_set,
+    .iv_get_fn      = backend_mbedtls_iv_get,
+    .update_fn      = backend_mbedtls_update,
+    .finalize_fn    = backend_mbedtls_padding_finalize
+};
+
+nrf_crypto_aes_info_t const g_nrf_crypto_aes_cbc_192_pad_pkcs7_info =
+{
+    .mode           = NRF_CRYPTO_AES_MODE_CBC_PAD_PCKS7,
+    .key_size       = NRF_CRYPTO_KEY_SIZE_192,
+    .context_size   = sizeof(nrf_crypto_backend_aes_cbc_context_t),
+
+    .init_fn        = backend_mbedtls_init,
+    .uninit_fn      = backend_mbedtls_uninit,
+    .key_set_fn     = backend_mbedtls_key_set,
+    .iv_set_fn      = backend_mbedtls_iv_set,
+    .iv_get_fn      = backend_mbedtls_iv_get,
+    .update_fn      = backend_mbedtls_update,
+    .finalize_fn    = backend_mbedtls_padding_finalize
+};
+
+nrf_crypto_aes_info_t const g_nrf_crypto_aes_cbc_256_pad_pkcs7_info =
+{
+    .mode           = NRF_CRYPTO_AES_MODE_CBC_PAD_PCKS7,
+    .key_size       = NRF_CRYPTO_KEY_SIZE_256,
+    .context_size   = sizeof(nrf_crypto_backend_aes_cbc_context_t),
+
+    .init_fn        = backend_mbedtls_init,
+    .uninit_fn      = backend_mbedtls_uninit,
+    .key_set_fn     = backend_mbedtls_key_set,
+    .iv_set_fn      = backend_mbedtls_iv_set,
+    .iv_get_fn      = backend_mbedtls_iv_get,
+    .update_fn      = backend_mbedtls_update,
+    .finalize_fn    = backend_mbedtls_padding_finalize
+};
+#endif
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CTR)
+nrf_crypto_aes_info_t const g_nrf_crypto_aes_ctr_128_info =
+{
+    .mode           = NRF_CRYPTO_AES_MODE_CTR,
+    .key_size       = NRF_CRYPTO_KEY_SIZE_128,
+    .context_size   = sizeof(nrf_crypto_backend_aes_ctr_context_t),
+
+    .init_fn        = backend_mbedtls_init,
+    .uninit_fn      = backend_mbedtls_uninit,
+    .key_set_fn     = backend_mbedtls_key_set,
+    .iv_set_fn      = backend_mbedtls_iv_set,
+    .iv_get_fn      = backend_mbedtls_iv_get,
+    .update_fn      = backend_mbedtls_update,
+    .finalize_fn    = backend_mbedtls_finalize
+};
+
+nrf_crypto_aes_info_t const g_nrf_crypto_aes_ctr_192_info =
+{
+    .mode           = NRF_CRYPTO_AES_MODE_CTR,
+    .key_size       = NRF_CRYPTO_KEY_SIZE_192,
+    .context_size   = sizeof(nrf_crypto_backend_aes_ctr_context_t),
+
+    .init_fn        = backend_mbedtls_init,
+    .uninit_fn      = backend_mbedtls_uninit,
+    .key_set_fn     = backend_mbedtls_key_set,
+    .iv_set_fn      = backend_mbedtls_iv_set,
+    .iv_get_fn      = backend_mbedtls_iv_get,
+    .update_fn      = backend_mbedtls_update,
+    .finalize_fn    = backend_mbedtls_finalize
+};
+
+nrf_crypto_aes_info_t const g_nrf_crypto_aes_ctr_256_info =
+{
+    .mode           = NRF_CRYPTO_AES_MODE_CTR,
+    .key_size       = NRF_CRYPTO_KEY_SIZE_256,
+    .context_size   = sizeof(nrf_crypto_backend_aes_ctr_context_t),
+
+    .init_fn        = backend_mbedtls_init,
+    .uninit_fn      = backend_mbedtls_uninit,
+    .key_set_fn     = backend_mbedtls_key_set,
+    .iv_set_fn      = backend_mbedtls_iv_set,
+    .iv_get_fn      = backend_mbedtls_iv_get,
+    .update_fn      = backend_mbedtls_update,
+    .finalize_fn    = backend_mbedtls_finalize
+};
+#endif
+
+// CFB
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CFB)
+nrf_crypto_aes_info_t const g_nrf_crypto_aes_cfb_128_info =
+{
+    .mode           = NRF_CRYPTO_AES_MODE_CFB,
+    .key_size       = NRF_CRYPTO_KEY_SIZE_128,
+    .context_size   = sizeof(nrf_crypto_backend_aes_cfb_context_t),
+
+    .init_fn        = backend_mbedtls_init,
+    .uninit_fn      = backend_mbedtls_uninit,
+    .key_set_fn     = backend_mbedtls_key_set,
+    .iv_set_fn      = backend_mbedtls_iv_set,
+    .iv_get_fn      = backend_mbedtls_iv_get,
+    .update_fn      = backend_mbedtls_update,
+    .finalize_fn    = backend_mbedtls_finalize
+};
+
+nrf_crypto_aes_info_t const g_nrf_crypto_aes_cfb_192_info =
+{
+    .mode           = NRF_CRYPTO_AES_MODE_CFB,
+    .key_size       = NRF_CRYPTO_KEY_SIZE_192,
+    .context_size   = sizeof(nrf_crypto_backend_aes_cfb_context_t),
+
+    .init_fn        = backend_mbedtls_init,
+    .uninit_fn      = backend_mbedtls_uninit,
+    .key_set_fn     = backend_mbedtls_key_set,
+    .iv_set_fn      = backend_mbedtls_iv_set,
+    .iv_get_fn      = backend_mbedtls_iv_get,
+    .update_fn      = backend_mbedtls_update,
+    .finalize_fn    = backend_mbedtls_finalize
+};
+
+nrf_crypto_aes_info_t const g_nrf_crypto_aes_cfb_256_info =
+{
+    .mode           = NRF_CRYPTO_AES_MODE_CFB,
+    .key_size       = NRF_CRYPTO_KEY_SIZE_256,
+    .context_size   = sizeof(nrf_crypto_backend_aes_cfb_context_t),
+
+    .init_fn        = backend_mbedtls_init,
+    .uninit_fn      = backend_mbedtls_uninit,
+    .key_set_fn     = backend_mbedtls_key_set,
+    .iv_set_fn      = backend_mbedtls_iv_set,
+    .iv_get_fn      = backend_mbedtls_iv_get,
+    .update_fn      = backend_mbedtls_update,
+    .finalize_fn    = backend_mbedtls_finalize
+};
+#endif
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_ECB)
+nrf_crypto_aes_info_t const g_nrf_crypto_aes_ecb_128_info =
+{
+    .mode           = NRF_CRYPTO_AES_MODE_ECB,
+    .key_size       = NRF_CRYPTO_KEY_SIZE_128,
+    .context_size   = sizeof(nrf_crypto_backend_aes_ecb_context_t),
+
+    .init_fn        = backend_mbedtls_init,
+    .uninit_fn      = backend_mbedtls_uninit,
+    .key_set_fn     = backend_mbedtls_key_set,
+    .iv_set_fn      = NULL,
+    .iv_get_fn      = NULL,
+    .update_fn      = backend_mbedtls_update,
+    .finalize_fn    = backend_mbedtls_finalize
+};
+
+nrf_crypto_aes_info_t const g_nrf_crypto_aes_ecb_192_info =
+{
+    .mode           = NRF_CRYPTO_AES_MODE_ECB,
+    .key_size       = NRF_CRYPTO_KEY_SIZE_192,
+    .context_size   = sizeof(nrf_crypto_backend_aes_ecb_context_t),
+
+    .init_fn        = backend_mbedtls_init,
+    .uninit_fn      = backend_mbedtls_uninit,
+    .key_set_fn     = backend_mbedtls_key_set,
+    .iv_set_fn      = NULL,
+    .iv_get_fn      = NULL,
+    .update_fn      = backend_mbedtls_update,
+    .finalize_fn    = backend_mbedtls_finalize
+};
+
+nrf_crypto_aes_info_t const g_nrf_crypto_aes_ecb_256_info =
+{
+    .mode           = NRF_CRYPTO_AES_MODE_ECB,
+    .key_size       = NRF_CRYPTO_KEY_SIZE_256,
+    .context_size   = sizeof(nrf_crypto_backend_aes_ecb_context_t),
+
+    .init_fn        = backend_mbedtls_init,
+    .uninit_fn      = backend_mbedtls_uninit,
+    .key_set_fn     = backend_mbedtls_key_set,
+    .iv_set_fn      = NULL,
+    .iv_get_fn      = NULL,
+    .update_fn      = backend_mbedtls_update,
+    .finalize_fn    = backend_mbedtls_finalize
+};
+
+nrf_crypto_aes_info_t const g_nrf_crypto_aes_ecb_128_pad_pkcs7_info =
+{
+    .mode           = NRF_CRYPTO_AES_MODE_ECB_PAD_PCKS7,
+    .key_size       = NRF_CRYPTO_KEY_SIZE_128,
+    .context_size   = sizeof(nrf_crypto_backend_aes_ecb_context_t),
+
+    .init_fn        = backend_mbedtls_init,
+    .uninit_fn      = backend_mbedtls_uninit,
+    .key_set_fn     = backend_mbedtls_key_set,
+    .iv_set_fn      = NULL,
+    .iv_get_fn      = NULL,
+    .update_fn      = backend_mbedtls_update,
+    .finalize_fn    = backend_mbedtls_padding_finalize
+};
+
+nrf_crypto_aes_info_t const g_nrf_crypto_aes_ecb_192_pad_pkcs7_info =
+{
+    .mode           = NRF_CRYPTO_AES_MODE_ECB_PAD_PCKS7,
+    .key_size       = NRF_CRYPTO_KEY_SIZE_192,
+    .context_size   = sizeof(nrf_crypto_backend_aes_ecb_context_t),
+
+    .init_fn        = backend_mbedtls_init,
+    .uninit_fn      = backend_mbedtls_uninit,
+    .key_set_fn     = backend_mbedtls_key_set,
+    .iv_set_fn      = NULL,
+    .iv_get_fn      = NULL,
+    .update_fn      = backend_mbedtls_update,
+    .finalize_fn    = backend_mbedtls_padding_finalize
+};
+
+nrf_crypto_aes_info_t const g_nrf_crypto_aes_ecb_256_pad_pkcs7_info =
+{
+    .mode           = NRF_CRYPTO_AES_MODE_ECB_PAD_PCKS7,
+    .key_size       = NRF_CRYPTO_KEY_SIZE_256,
+    .context_size   = sizeof(nrf_crypto_backend_aes_ecb_context_t),
+
+    .init_fn        = backend_mbedtls_init,
+    .uninit_fn      = backend_mbedtls_uninit,
+    .key_set_fn     = backend_mbedtls_key_set,
+    .iv_set_fn      = NULL,
+    .iv_get_fn      = NULL,
+    .update_fn      = backend_mbedtls_update,
+    .finalize_fn    = backend_mbedtls_padding_finalize
+};
+#endif
+
+
+// CBC MAC
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CBC_MAC)
+nrf_crypto_aes_info_t const g_nrf_crypto_aes_cbc_mac_128_info =
+{
+    .mode           = NRF_CRYPTO_AES_MODE_CBC_MAC,
+    .key_size       = NRF_CRYPTO_KEY_SIZE_128,
+    .context_size   = sizeof(nrf_crypto_backend_aes_cbc_mac_context_t),
+
+    .init_fn        = backend_mbedtls_init,
+    .uninit_fn      = backend_mbedtls_uninit,
+    .key_set_fn     = backend_mbedtls_key_set,
+    .iv_set_fn      = backend_mbedtls_iv_set,
+    .iv_get_fn      = backend_mbedtls_iv_get,
+    .update_fn      = backend_mbedtls_update,
+    .finalize_fn    = backend_mbedtls_cbc_mac_finalize
+};
+
+nrf_crypto_aes_info_t const g_nrf_crypto_aes_cbc_mac_192_info =
+{
+    .mode           = NRF_CRYPTO_AES_MODE_CBC_MAC,
+    .key_size       = NRF_CRYPTO_KEY_SIZE_192,
+    .context_size   = sizeof(nrf_crypto_backend_aes_cbc_mac_context_t),
+
+    .init_fn        = backend_mbedtls_init,
+    .uninit_fn      = backend_mbedtls_uninit,
+    .key_set_fn     = backend_mbedtls_key_set,
+    .iv_set_fn      = backend_mbedtls_iv_set,
+    .iv_get_fn      = backend_mbedtls_iv_get,
+    .update_fn      = backend_mbedtls_update,
+    .finalize_fn    = backend_mbedtls_cbc_mac_finalize
+};
+
+nrf_crypto_aes_info_t const g_nrf_crypto_aes_cbc_mac_256_info =
+{
+    .mode           = NRF_CRYPTO_AES_MODE_CBC_MAC,
+    .key_size       = NRF_CRYPTO_KEY_SIZE_256,
+    .context_size   = sizeof(nrf_crypto_backend_aes_cbc_mac_context_t),
+
+    .init_fn        = backend_mbedtls_init,
+    .uninit_fn      = backend_mbedtls_uninit,
+    .key_set_fn     = backend_mbedtls_key_set,
+    .iv_set_fn      = backend_mbedtls_iv_set,
+    .iv_get_fn      = backend_mbedtls_iv_get,
+    .update_fn      = backend_mbedtls_update,
+    .finalize_fn    = backend_mbedtls_cbc_mac_finalize
+};
+
+nrf_crypto_aes_info_t const g_nrf_crypto_aes_cbc_mac_128_pad_pkcs7_info =
+{
+    .mode           = NRF_CRYPTO_AES_MODE_CBC_MAC_PAD_PCKS7,
+    .key_size       = NRF_CRYPTO_KEY_SIZE_128,
+    .context_size   = sizeof(nrf_crypto_backend_aes_cbc_mac_context_t),
+
+    .init_fn        = backend_mbedtls_init,
+    .uninit_fn      = backend_mbedtls_uninit,
+    .key_set_fn     = backend_mbedtls_key_set,
+    .iv_set_fn      = backend_mbedtls_iv_set,
+    .iv_get_fn      = backend_mbedtls_iv_get,
+    .update_fn      = backend_mbedtls_update,
+    .finalize_fn    = backend_mbedtls_cbc_mac_padding_finalize
+};
+
+nrf_crypto_aes_info_t const g_nrf_crypto_aes_cbc_mac_192_pad_pkcs7_info =
+{
+    .mode           = NRF_CRYPTO_AES_MODE_CBC_MAC_PAD_PCKS7,
+    .key_size       = NRF_CRYPTO_KEY_SIZE_192,
+    .context_size   = sizeof(nrf_crypto_backend_aes_cbc_mac_context_t),
+
+    .init_fn        = backend_mbedtls_init,
+    .uninit_fn      = backend_mbedtls_uninit,
+    .key_set_fn     = backend_mbedtls_key_set,
+    .iv_set_fn      = backend_mbedtls_iv_set,
+    .iv_get_fn      = backend_mbedtls_iv_get,
+    .update_fn      = backend_mbedtls_update,
+    .finalize_fn    = backend_mbedtls_cbc_mac_padding_finalize
+};
+
+nrf_crypto_aes_info_t const g_nrf_crypto_aes_cbc_mac_256_pad_pkcs7_info =
+{
+    .mode           = NRF_CRYPTO_AES_MODE_CBC_MAC_PAD_PCKS7,
+    .key_size       = NRF_CRYPTO_KEY_SIZE_256,
+    .context_size   = sizeof(nrf_crypto_backend_aes_cbc_mac_context_t),
+
+    .init_fn        = backend_mbedtls_init,
+    .uninit_fn      = backend_mbedtls_uninit,
+    .key_set_fn     = backend_mbedtls_key_set,
+    .iv_set_fn      = backend_mbedtls_iv_set,
+    .iv_get_fn      = backend_mbedtls_iv_get,
+    .update_fn      = backend_mbedtls_update,
+    .finalize_fn    = backend_mbedtls_cbc_mac_padding_finalize
+};
+
+#endif
+
+// CMAC
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CMAC)
+nrf_crypto_aes_info_t const g_nrf_crypto_aes_cmac_128_info =
+{
+    .mode           = NRF_CRYPTO_AES_MODE_CMAC,
+    .key_size       = NRF_CRYPTO_KEY_SIZE_128,
+    .context_size   = sizeof(nrf_crypto_backend_aes_cmac_context_t),
+
+    .init_fn        = backend_mbedtls_init,
+    .uninit_fn      = backend_mbedtls_uninit,
+    .key_set_fn     = backend_mbedtls_key_set,
+    .iv_set_fn      = NULL,
+    .iv_get_fn      = NULL,
+    .update_fn      = backend_mbedtls_update,
+    .finalize_fn    = backend_mbedtls_cmac_finalize
+};
+
+nrf_crypto_aes_info_t const g_nrf_crypto_aes_cmac_192_info =
+{
+    .mode           = NRF_CRYPTO_AES_MODE_CMAC,
+    .key_size       = NRF_CRYPTO_KEY_SIZE_192,
+    .context_size   = sizeof(nrf_crypto_backend_aes_cmac_context_t),
+
+    .init_fn        = backend_mbedtls_init,
+    .uninit_fn      = backend_mbedtls_uninit,
+    .key_set_fn     = backend_mbedtls_key_set,
+    .iv_set_fn      = NULL,
+    .iv_get_fn      = NULL,
+    .update_fn      = backend_mbedtls_update,
+    .finalize_fn    = backend_mbedtls_cmac_finalize
+};
+
+nrf_crypto_aes_info_t const g_nrf_crypto_aes_cmac_256_info =
+{
+    .mode           = NRF_CRYPTO_AES_MODE_CMAC,
+    .key_size       = NRF_CRYPTO_KEY_SIZE_256,
+    .context_size   = sizeof(nrf_crypto_backend_aes_cmac_context_t),
+
+    .init_fn        = backend_mbedtls_init,
+    .uninit_fn      = backend_mbedtls_uninit,
+    .key_set_fn     = backend_mbedtls_key_set,
+    .iv_set_fn      = NULL,
+    .iv_get_fn      = NULL,
+    .update_fn      = backend_mbedtls_update,
+    .finalize_fn    = backend_mbedtls_cmac_finalize
+};
+#endif
+
+#endif // #if NRF_MODULE_ENABLED(NRF_CRYPTO_MBEDTLS_AES)
+#endif // MODULE_ENABLED(NRF_CRYPTO)
+
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/mbedtls/mbedtls_backend_aes.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/mbedtls/mbedtls_backend_aes.h
new file mode 100644
index 0000000..3813eb3
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/mbedtls/mbedtls_backend_aes.h
@@ -0,0 +1,227 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef MBEDTLS_BACKEND_AES_H__
+#define MBEDTLS_BACKEND_AES_H__
+
+/** @file
+ *
+ * @defgroup nrf_crypto_mbedtls_backend_aes nrf_crypto mbed TLS backend AES
+ * @{
+ * @ingroup nrf_crypto_mbedtls_backend
+ *
+ * @brief AES functionality provided by the nrf_crypto mbed TLS backend.
+ */
+
+#include "sdk_config.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS)
+
+/*lint -save -e????*/
+#include "mbedtls/aes.h"
+#include "mbedtls/cmac.h"
+#include "mbedtls/platform.h"
+/*lint -restore*/
+#include "nrf_crypto_error.h"
+#include "nrf_crypto_types.h"
+#include "nrf_crypto_aes_shared.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* AES CBC */
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CBC)
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_AES_CBC)
+#error "Duplicate definition of AES CBC mode. More than one backend enabled");
+#endif
+/* Flag that AES CBC is enabled in backend */
+#define NRF_CRYPTO_AES_CBC_ENABLED 1
+#undef  NRF_CRYPTO_AES_ENABLED
+#define NRF_CRYPTO_AES_ENABLED 1    // Flag that nrf_crypto_aes frontend can be compiled
+#undef  NRF_CRYPTO_MBEDTLS_AES_ENABLED
+#define NRF_CRYPTO_MBEDTLS_AES_ENABLED 1
+
+/* defines for test purposes */
+#define NRF_CRYPTO_AES_CBC_128_ENABLED  1
+#define NRF_CRYPTO_AES_CBC_192_ENABLED  1
+#define NRF_CRYPTO_AES_CBC_256_ENABLED  1
+
+typedef struct
+{
+    nrf_crypto_aes_internal_context_t header;   /**< Common header for context. */
+    nrf_crypto_backend_aes_ctx_t      backend;  /**< Backend-specific internal context. */
+    mbedtls_aes_context               context;  /**< AES context internal to mbed TLS. */
+} nrf_crypto_backend_aes_cbc_context_t;
+#endif
+
+
+/* AES CTR */
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CTR)
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_AES_CTR)
+#error "Duplicate definition of AES CTR mode. More than one backend enabled");
+#endif
+#define NRF_CRYPTO_AES_CTR_ENABLED 1
+#undef  NRF_CRYPTO_AES_ENABLED
+#define NRF_CRYPTO_AES_ENABLED 1    // Flag that nrf_crypto_aes frontend can be compiled
+#undef  NRF_CRYPTO_MBEDTLS_AES_ENABLED
+#define NRF_CRYPTO_MBEDTLS_AES_ENABLED 1
+
+/* defines for test purposes */
+#define NRF_CRYPTO_AES_CTR_128_ENABLED  1
+#define NRF_CRYPTO_AES_CTR_192_ENABLED  1
+#define NRF_CRYPTO_AES_CTR_256_ENABLED  1
+
+typedef struct
+{
+    nrf_crypto_aes_internal_context_t header;   /**< Common header for context. */
+    nrf_crypto_backend_aes_ctx_t      backend;  /**< Backend-specific internal context. */
+    mbedtls_aes_context               context;  /**< AES context internal to mbed TLS. */
+} nrf_crypto_backend_aes_ctr_context_t;
+#endif
+
+/* AES CFB */
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CFB)
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_AES_CFB)
+#error "Duplicate definition of AES CFB mode. More than one backend enabled");
+#endif
+#define NRF_CRYPTO_AES_CFB_ENABLED 1
+#undef  NRF_CRYPTO_AES_ENABLED
+#define NRF_CRYPTO_AES_ENABLED 1    // Flag that nrf_crypto_aes frontend can be compiled
+#undef  NRF_CRYPTO_MBEDTLS_AES_ENABLED
+#define NRF_CRYPTO_MBEDTLS_AES_ENABLED 1
+
+/* defines for test purposes */
+#define NRF_CRYPTO_AES_CFB_128_ENABLED  1
+#define NRF_CRYPTO_AES_CFB_192_ENABLED  1
+#define NRF_CRYPTO_AES_CFB_256_ENABLED  1
+
+typedef struct
+{
+    nrf_crypto_aes_internal_context_t header;   /**< Common header for context. */
+    nrf_crypto_backend_aes_ctx_t      backend;  /**< Backend-specific internal context. */
+    mbedtls_aes_context               context;  /**< AES context internal to mbed TLS. */
+} nrf_crypto_backend_aes_cfb_context_t;
+#endif
+
+/* AES ECB */
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_ECB)
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_AES_ECB)
+#error "Duplicate definition of AES ECB mode. More than one backend enabled");
+#endif
+#define NRF_CRYPTO_AES_ECB_ENABLED 1
+#undef  NRF_CRYPTO_AES_ENABLED
+#define NRF_CRYPTO_AES_ENABLED 1
+#undef  NRF_CRYPTO_MBEDTLS_AES_ENABLED
+#define NRF_CRYPTO_MBEDTLS_AES_ENABLED 1
+
+/* defines for test purposes */
+#define NRF_CRYPTO_AES_ECB_128_ENABLED  1
+#define NRF_CRYPTO_AES_ECB_192_ENABLED  1
+#define NRF_CRYPTO_AES_ECB_256_ENABLED  1
+
+typedef struct
+{
+    nrf_crypto_aes_internal_context_t   header;   /**< Common header for context. */
+    nrf_crypto_backend_no_iv_aes_ctx_t  backend;  /**< Backend-specific internal context. */
+    mbedtls_aes_context                 context;  /**< AES context internal to mbed TLS. */
+} nrf_crypto_backend_aes_ecb_context_t;
+#endif
+
+
+/* AES CBC MAC */
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CBC_MAC)
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_AES_CBC_MAC)
+#error "Duplicate definition of AES CBC MAC mode. More than one backend enabled");
+#endif
+/* Flag that AES CBC MAC is enabled in backend */
+#define NRF_CRYPTO_AES_CBC_MAC_ENABLED 1
+#undef  NRF_CRYPTO_AES_ENABLED
+#define NRF_CRYPTO_AES_ENABLED 1    // Flag that nrf_crypto_aes frontend can be compiled
+#undef  NRF_CRYPTO_MBEDTLS_AES_ENABLED
+#define NRF_CRYPTO_MBEDTLS_AES_ENABLED 1
+
+/* defines for test purposes */
+#define NRF_CRYPTO_AES_CBC_MAC_128_ENABLED  1
+#define NRF_CRYPTO_AES_CBC_MAC_192_ENABLED  1
+#define NRF_CRYPTO_AES_CBC_MAC_256_ENABLED  1
+
+typedef struct
+{
+    nrf_crypto_aes_internal_context_t header;   /**< Common header for context. */
+    nrf_crypto_backend_aes_ctx_t      backend;  /**< Backend-specific internal context. */
+    mbedtls_aes_context               context;  /**< AES context internal to mbed TLS. */
+} nrf_crypto_backend_aes_cbc_mac_context_t;
+#endif
+
+
+/* AES CMAC */
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CMAC)
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_AES_CMAC)
+#error "Duplicate definition of AES CMAC mode. More than one backend enabled");
+#endif
+#define NRF_CRYPTO_AES_CMAC_ENABLED 1
+#undef  NRF_CRYPTO_AES_ENABLED
+#define NRF_CRYPTO_AES_ENABLED 1    // Flag that nrf_crypto_aes frontend can be compiled
+#undef  NRF_CRYPTO_MBEDTLS_AES_ENABLED
+#define NRF_CRYPTO_MBEDTLS_AES_ENABLED 1
+
+/* defines for test purposes */
+#define NRF_CRYPTO_AES_CMAC_128_ENABLED  1
+#define NRF_CRYPTO_AES_CMAC_192_ENABLED  1
+#define NRF_CRYPTO_AES_CMAC_256_ENABLED  1
+
+typedef struct
+{
+    nrf_crypto_aes_internal_context_t  header;   /**< Common header for context. */
+    nrf_crypto_backend_no_iv_aes_ctx_t backend;  /**< Backend-specific internal context. */
+    mbedtls_cipher_context_t           context;  /**< AES context internal to mbedtls. */
+} nrf_crypto_backend_aes_cmac_context_t;
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS)
+
+/** @} */
+
+#endif // MBEDTLS_BACKEND_AES_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/mbedtls/mbedtls_backend_aes_aead.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/mbedtls/mbedtls_backend_aes_aead.c
new file mode 100644
index 0000000..eb0319e
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/mbedtls/mbedtls_backend_aes_aead.c
@@ -0,0 +1,384 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#include "sdk_common.h"
+#include <drivers/nrfx_common.h>
+#if NRF_MODULE_ENABLED(NRF_CRYPTO)
+
+#include "nrf_crypto_error.h"
+#include "mbedtls_backend_aes_aead.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_MBEDTLS_AES_AEAD)
+
+/**@internal @brief Type declaration of a template suiting all possible context sizes
+ *                  for this backend.
+ */
+typedef union
+{
+    nrf_crypto_aead_internal_context_t header;      /**< Common header for context. */
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CCM)
+    nrf_crypto_backend_aes_ccm_context_t ccm;
+#endif
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_GCM)
+    nrf_crypto_backend_aes_gcm_context_t gcm;
+#endif
+} nrf_crypto_backend_mbedtls_aes_aead_context_t;
+
+
+static ret_code_t result_get(int error)
+{
+    ret_code_t ret_val;
+
+    switch (error)
+    {
+        case 0:
+            ret_val = NRF_SUCCESS;
+            break;
+
+        case MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA:
+            ret_val = NRF_ERROR_CRYPTO_INPUT_LENGTH;
+            break;
+
+        case MBEDTLS_ERR_CIPHER_ALLOC_FAILED:
+            ret_val = NRF_ERROR_CRYPTO_ALLOC_FAILED;
+            break;
+
+        case MBEDTLS_ERR_CIPHER_FEATURE_UNAVAILABLE:
+            ret_val = NRF_ERROR_CRYPTO_FEATURE_UNAVAILABLE;
+            break;
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CCM)
+        case MBEDTLS_ERR_CCM_BAD_INPUT:
+            ret_val = NRF_ERROR_CRYPTO_INVALID_PARAM;
+            break;
+
+        case MBEDTLS_ERR_CCM_AUTH_FAILED:
+            ret_val = NRF_ERROR_CRYPTO_AEAD_INVALID_MAC;
+            break;
+#endif
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_GCM)
+         case MBEDTLS_ERR_GCM_BAD_INPUT:
+            ret_val = NRF_ERROR_CRYPTO_INVALID_PARAM;
+            break;
+
+         case MBEDTLS_ERR_GCM_AUTH_FAILED:
+            ret_val = NRF_ERROR_CRYPTO_AEAD_INVALID_MAC;
+            break;
+#endif
+
+        default:
+            ret_val = NRF_ERROR_CRYPTO_INTERNAL;
+            break;
+    }
+    return ret_val;
+}
+
+static ret_code_t backend_mbedtls_init(void * const p_context, uint8_t * p_key)
+{
+    int        result;
+    ret_code_t ret_val;
+
+    nrf_crypto_backend_mbedtls_aes_aead_context_t * p_ctx =
+        (nrf_crypto_backend_mbedtls_aes_aead_context_t *)p_context;
+
+    if ((p_ctx->header.p_info->key_size != NRF_CRYPTO_KEY_SIZE_128) &&
+        (p_ctx->header.p_info->key_size != NRF_CRYPTO_KEY_SIZE_192) &&
+        (p_ctx->header.p_info->key_size != NRF_CRYPTO_KEY_SIZE_256))
+    {
+        return NRF_ERROR_CRYPTO_KEY_SIZE;
+    }
+
+    switch (p_ctx->header.p_info->mode)
+    {
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CCM)
+        case NRF_CRYPTO_AEAD_MODE_AES_CCM:
+            mbedtls_ccm_init(&p_ctx->ccm.context);
+
+            result = mbedtls_ccm_setkey(&p_ctx->ccm.context,
+                                        MBEDTLS_CIPHER_ID_AES,
+                                        p_key,
+                                        p_ctx->header.p_info->key_size);
+            break;
+#endif
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_GCM)
+        case NRF_CRYPTO_AEAD_MODE_AES_GCM:
+            mbedtls_gcm_init(&p_ctx->gcm.context);
+
+            result = mbedtls_gcm_setkey(&p_ctx->gcm.context,
+                                        MBEDTLS_CIPHER_ID_AES,
+                                        p_key,
+                                        p_ctx->header.p_info->key_size);
+            break;
+#endif
+
+        default:
+            return NRF_ERROR_CRYPTO_FEATURE_UNAVAILABLE;
+    }
+
+    if (result != 0)
+    {
+        ret_val = result_get(result);
+        return ret_val;
+    }
+
+    return NRF_SUCCESS;
+}
+
+static ret_code_t backend_mbedtls_uninit(void * const p_context)
+{
+    nrf_crypto_backend_mbedtls_aes_aead_context_t * p_ctx =
+        (nrf_crypto_backend_mbedtls_aes_aead_context_t *)p_context;
+
+    if (p_ctx->header.p_info->mode == NRF_CRYPTO_AEAD_MODE_AES_CCM)
+    {
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CCM)
+        mbedtls_ccm_free(&p_ctx->ccm.context);
+#endif
+    }
+    else
+    {
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_GCM)
+        mbedtls_gcm_free(&p_ctx->gcm.context);
+#endif
+    }
+
+    return NRF_SUCCESS;
+}
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CCM)
+static ret_code_t backend_mbedtls_ccm_crypt(void * const            p_context,
+                                            nrf_crypto_operation_t  operation,
+                                            uint8_t *               p_nonce,
+                                            uint8_t                 nonce_size,
+                                            uint8_t *               p_adata,
+                                            size_t                  adata_size,
+                                            uint8_t *               p_data_in,
+                                            size_t                  data_in_size,
+                                            uint8_t *               p_data_out,
+                                            uint8_t *               p_mac,
+                                            uint8_t                 mac_size)
+{
+    int        result;
+    ret_code_t ret_val;
+
+    nrf_crypto_backend_mbedtls_aes_aead_context_t * p_ctx =
+        (nrf_crypto_backend_mbedtls_aes_aead_context_t *)p_context;
+
+    /* CCM mode allows following MAC sizes: [4, 6, 8, 10, 12, 14, 16] */
+    if ((mac_size < NRF_CRYPTO_AES_CCM_MAC_MIN) || (mac_size > NRF_CRYPTO_AES_CCM_MAC_MAX) ||
+        ((mac_size & 0x01) != 0))
+    {
+        return NRF_ERROR_CRYPTO_AEAD_MAC_SIZE;
+    }
+
+    if ((nonce_size < NRF_CRYPTO_AES_CCM_NONCE_SIZE_MIN) ||
+        (nonce_size > NRF_CRYPTO_AES_CCM_NONCE_SIZE_MAX))
+    {
+        return NRF_ERROR_CRYPTO_AEAD_NONCE_SIZE;
+    }
+
+    if (operation == NRF_CRYPTO_ENCRYPT)
+    {
+        result = mbedtls_ccm_encrypt_and_tag(&p_ctx->ccm.context,
+                                             data_in_size,
+                                             p_nonce,
+                                             nonce_size,
+                                             p_adata,
+                                             adata_size,
+                                             p_data_in,
+                                             p_data_out,
+                                             p_mac,
+                                             (size_t)mac_size);
+    }
+    else if (operation == NRF_CRYPTO_DECRYPT)
+    {
+        result = mbedtls_ccm_auth_decrypt(&p_ctx->ccm.context,
+                                          data_in_size,
+                                          p_nonce,
+                                          nonce_size,
+                                          p_adata,
+                                          adata_size,
+                                          p_data_in,
+                                          p_data_out,
+                                          p_mac,
+                                          (size_t)mac_size);
+    }
+    else
+    {
+        return NRF_ERROR_CRYPTO_INVALID_PARAM;
+    }
+
+    ret_val = result_get(result);
+
+    return ret_val;
+}
+#endif
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_GCM)
+static ret_code_t backend_mbedtls_gcm_crypt(void * const            p_context,
+                                            nrf_crypto_operation_t  operation,
+                                            uint8_t *               p_nonce,
+                                            uint8_t                 nonce_size,
+                                            uint8_t *               p_adata,
+                                            size_t                  adata_size,
+                                            uint8_t *               p_data_in,
+                                            size_t                  data_in_size,
+                                            uint8_t *               p_data_out,
+                                            uint8_t *               p_mac,
+                                            uint8_t                 mac_size)
+{
+    int        result;
+    ret_code_t ret_val;
+
+    nrf_crypto_backend_mbedtls_aes_aead_context_t * p_ctx =
+        (nrf_crypto_backend_mbedtls_aes_aead_context_t *)p_context;
+
+    /* GCM allows following MAC size: [4 ... 16] */
+    if ((mac_size < NRF_CRYPTO_AES_GCM_MAC_MIN) || (mac_size > NRF_CRYPTO_AES_GCM_MAC_MAX))
+    {
+        return NRF_ERROR_CRYPTO_AEAD_MAC_SIZE;
+    }
+
+    if (operation == NRF_CRYPTO_ENCRYPT)
+    {
+        result = mbedtls_gcm_crypt_and_tag(&p_ctx->gcm.context,
+                                           MBEDTLS_GCM_ENCRYPT,
+                                           data_in_size,
+                                           p_nonce,
+                                           nonce_size,
+                                           p_adata,
+                                           adata_size,
+                                           p_data_in,
+                                           p_data_out,
+                                           (size_t)mac_size,
+                                           p_mac);
+    ret_val = result_get(result);
+    }
+    else if (operation == NRF_CRYPTO_DECRYPT)
+    {
+        result = mbedtls_gcm_auth_decrypt(&p_ctx->gcm.context,
+                                          data_in_size,
+                                          p_nonce,
+                                          nonce_size,
+                                          p_adata,
+                                          adata_size,
+                                          p_mac,
+                                          (size_t)mac_size,
+                                          p_data_in,
+                                          p_data_out);
+        ret_val = result_get(result);
+    }
+    else
+    {
+        return NRF_ERROR_CRYPTO_INVALID_PARAM;
+    }
+
+    return ret_val;
+}
+#endif
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CCM)
+nrf_crypto_aead_info_t const g_nrf_crypto_aes_ccm_128_info =
+{
+    .key_size  = NRF_CRYPTO_KEY_SIZE_128,
+    .mode      = NRF_CRYPTO_AEAD_MODE_AES_CCM,
+
+    .init_fn   = backend_mbedtls_init,
+    .uninit_fn = backend_mbedtls_uninit,
+    .crypt_fn  = backend_mbedtls_ccm_crypt
+};
+
+nrf_crypto_aead_info_t const g_nrf_crypto_aes_ccm_192_info =
+{
+    .key_size  = NRF_CRYPTO_KEY_SIZE_192,
+    .mode      = NRF_CRYPTO_AEAD_MODE_AES_CCM,
+
+    .init_fn   = backend_mbedtls_init,
+    .uninit_fn = backend_mbedtls_uninit,
+    .crypt_fn  = backend_mbedtls_ccm_crypt
+};
+
+nrf_crypto_aead_info_t const g_nrf_crypto_aes_ccm_256_info =
+{
+    .key_size  = NRF_CRYPTO_KEY_SIZE_256,
+    .mode      = NRF_CRYPTO_AEAD_MODE_AES_CCM,
+
+    .init_fn   = backend_mbedtls_init,
+    .uninit_fn = backend_mbedtls_uninit,
+    .crypt_fn  = backend_mbedtls_ccm_crypt
+};
+#endif
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_GCM)
+nrf_crypto_aead_info_t const g_nrf_crypto_aes_gcm_128_info =
+{
+    .key_size  = NRF_CRYPTO_KEY_SIZE_128,
+    .mode      = NRF_CRYPTO_AEAD_MODE_AES_GCM,
+
+    .init_fn   = backend_mbedtls_init,
+    .uninit_fn = backend_mbedtls_uninit,
+    .crypt_fn  = backend_mbedtls_gcm_crypt
+};
+
+nrf_crypto_aead_info_t const g_nrf_crypto_aes_gcm_192_info =
+{
+    .key_size  = NRF_CRYPTO_KEY_SIZE_192,
+    .mode      = NRF_CRYPTO_AEAD_MODE_AES_GCM,
+
+    .init_fn   = backend_mbedtls_init,
+    .uninit_fn = backend_mbedtls_uninit,
+    .crypt_fn  = backend_mbedtls_gcm_crypt
+};
+
+nrf_crypto_aead_info_t const g_nrf_crypto_aes_gcm_256_info =
+{
+    .key_size  = NRF_CRYPTO_KEY_SIZE_256,
+    .mode      = NRF_CRYPTO_AEAD_MODE_AES_GCM,
+
+    .init_fn   = backend_mbedtls_init,
+    .uninit_fn = backend_mbedtls_uninit,
+    .crypt_fn  = backend_mbedtls_gcm_crypt
+};
+#endif
+
+#endif // MODULE_ENABLED(NRF_CRYPTO_MBEDTLS_AES_AEAD)
+#endif // MODULE_ENABLED(NRF_CRYPTO)
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/mbedtls/mbedtls_backend_aes_aead.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/mbedtls/mbedtls_backend_aes_aead.h
new file mode 100644
index 0000000..05f24f5
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/mbedtls/mbedtls_backend_aes_aead.h
@@ -0,0 +1,123 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef MBEDTLS_BACKEND_AES_AEAD_H__
+#define MBEDTLS_BACKEND_AES_AEAD_H__
+
+/** @file
+ *
+ * @defgroup nrf_crypto_mbedtls_backend_aes_aead nrf_crypto mbed TLS backend AES AEAD
+ * @{
+ * @ingroup nrf_crypto_mbedtls_backend
+ *
+ * @brief AES AEAD functionality provided by the nrf_crypto mbed TLS backend.
+ */
+
+#include "sdk_config.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS)
+/*lint -save -e????*/
+#include "mbedtls/ccm.h"
+#include "mbedtls/gcm.h"
+#include "mbedtls/platform.h"
+/*lint -restore*/
+#include "nrf_crypto_error.h"
+#include "nrf_crypto_aead_shared.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* AES CCM */
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_CCM)
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_AES_CCM)
+#error "Duplicate definition of AES CCM mode. More than one backend enabled");
+#endif
+#define NRF_CRYPTO_AES_CCM_ENABLED 1
+#undef  NRF_CRYPTO_AEAD_ENABLED
+#define NRF_CRYPTO_AEAD_ENABLED 1
+#undef  NRF_CRYPTO_MBEDTLS_AES_AEAD_ENABLED
+#define NRF_CRYPTO_MBEDTLS_AES_AEAD_ENABLED 1
+
+/* defines for test purposes */
+#define NRF_CRYPTO_AES_CCM_128_ENABLED  1
+#define NRF_CRYPTO_AES_CCM_192_ENABLED  1
+#define NRF_CRYPTO_AES_CCM_256_ENABLED  1
+
+typedef struct
+{
+    nrf_crypto_aead_internal_context_t header;   /**< Common header for context. */
+    mbedtls_ccm_context                context;  /**< AES CCM context internal to mbed TLS. */
+} nrf_crypto_backend_aes_ccm_context_t;
+#endif
+
+/* AES GCM */
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_AES_GCM)
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_AES_GCM)
+#error "Duplicate definition of AES GCM mode. More than one backend enabled");
+#endif
+#define NRF_CRYPTO_AES_GCM_ENABLED 1
+#undef  NRF_CRYPTO_AEAD_ENABLED
+#define NRF_CRYPTO_AEAD_ENABLED 1
+#undef  NRF_CRYPTO_MBEDTLS_AES_AEAD_ENABLED
+#define NRF_CRYPTO_MBEDTLS_AES_AEAD_ENABLED 1
+
+/* defines for test purposes */
+#define NRF_CRYPTO_AES_GCM_128_ENABLED  1
+#define NRF_CRYPTO_AES_GCM_192_ENABLED  1
+#define NRF_CRYPTO_AES_GCM_256_ENABLED  1
+
+typedef struct
+{
+    nrf_crypto_aead_internal_context_t header;   /**< Common header for context. */
+    mbedtls_gcm_context                context;  /**< AES GCM context internal to mbed TLS. */
+} nrf_crypto_backend_aes_gcm_context_t;
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS)
+
+/** @} */
+
+#endif // MBEDTLS_BACKEND_AES_AEAD_H__
+
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/mbedtls/mbedtls_backend_ecc.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/mbedtls/mbedtls_backend_ecc.c
new file mode 100644
index 0000000..a69ab7c
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/mbedtls/mbedtls_backend_ecc.c
@@ -0,0 +1,531 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#include "sdk_config.h"
+#include "nordic_common.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS)
+
+#include <stdbool.h>
+#include <string.h>
+
+#include "nrf_crypto_ecc.h"
+#include "nrf_crypto_ecdh.h"
+#include "nrf_crypto_mem.h"
+#include "nrf_crypto_rng.h"
+#include "nrf_assert.h"
+#include "mbedtls_backend_ecc.h"
+
+/*lint -save -e????*/
+#if !defined(MBEDTLS_CONFIG_FILE)
+#include "mbedtls/config.h"
+#else
+#include MBEDTLS_CONFIG_FILE
+#endif
+#include "mbedtls/ecp.h"
+#include "mbedtls/bignum.h"
+/*lint -restore*/
+
+
+bool nrf_crypto_backend_mbedtls_ecc_group_load(
+    mbedtls_ecp_group                        * p_group,
+    struct nrf_crypto_ecc_curve_info_s const * p_info)
+{
+    int result;
+
+    mbedtls_ecp_group_init(p_group);
+    result = mbedtls_ecp_group_load(p_group,
+                                    (mbedtls_ecp_group_id)(intptr_t)p_info->p_backend_data);
+
+    if (result != 0)
+    {
+        return false;
+    }
+    return true;
+}
+
+
+int nrf_crypto_backend_mbedtls_ecc_mbedtls_rng(void * p_param, unsigned char * p_data, size_t size)
+{
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_RNG)
+
+    ret_code_t result;
+
+    result = nrf_crypto_rng_vector_generate(p_data, size);
+
+    if (result != NRF_SUCCESS)
+    {
+        return MBEDTLS_ERR_ECP_RANDOM_FAILED;
+    }
+    return 0;
+
+#else
+    return MBEDTLS_ERR_ECP_FEATURE_UNAVAILABLE;
+#endif
+}
+
+
+ret_code_t nrf_crypto_backend_mbedtls_key_pair_generate(
+    void * p_context,
+    void * p_private_key,
+    void * p_public_key)
+{
+    int result;
+    mbedtls_ecp_group group;
+
+    nrf_crypto_backend_mbedtls_ecc_private_key_t * p_prv =
+            (nrf_crypto_backend_mbedtls_ecc_private_key_t *)p_private_key;
+
+    nrf_crypto_backend_mbedtls_ecc_public_key_t  * p_pub =
+            (nrf_crypto_backend_mbedtls_ecc_public_key_t *)p_public_key;
+
+    nrf_crypto_ecc_curve_info_t const * p_info = p_pub->header.p_info;
+
+    if (!nrf_crypto_backend_mbedtls_ecc_group_load(&group, p_info))
+    {
+        return NRF_ERROR_CRYPTO_INTERNAL;
+    }
+
+    mbedtls_ecp_point_init(&p_pub->key);
+    mbedtls_mpi_init(&p_prv->key);
+    result = mbedtls_ecp_gen_keypair(&group,
+                                     &p_prv->key,
+                                     &p_pub->key,
+                                     nrf_crypto_backend_mbedtls_ecc_mbedtls_rng,
+                                     NULL);
+
+    mbedtls_ecp_group_free(&group);
+
+    if (result != 0)
+    {
+        mbedtls_mpi_free(&p_prv->key);
+        mbedtls_ecp_point_free(&p_pub->key);
+        return NRF_ERROR_CRYPTO_INTERNAL;
+    }
+    return NRF_SUCCESS;
+}
+
+
+ret_code_t nrf_crypto_backend_mbedtls_public_key_calculate(
+    void       * p_context,
+    void const * p_private_key,
+    void       * p_public_key)
+{
+    int result;
+    mbedtls_ecp_group group;
+
+    nrf_crypto_backend_mbedtls_ecc_private_key_t const * p_prv =
+            (nrf_crypto_backend_mbedtls_ecc_private_key_t const *)p_private_key;
+
+    nrf_crypto_backend_mbedtls_ecc_public_key_t  * p_pub =
+            (nrf_crypto_backend_mbedtls_ecc_public_key_t *)p_public_key;
+
+    nrf_crypto_ecc_curve_info_t const * p_info = p_pub->header.p_info;
+
+    if (!nrf_crypto_backend_mbedtls_ecc_group_load(&group, p_info))
+    {
+        return NRF_ERROR_CRYPTO_INTERNAL;
+    }
+
+    mbedtls_ecp_point_init(&p_pub->key);
+    result = mbedtls_ecp_mul(&group,
+                             &p_pub->key,
+                             &p_prv->key,
+                             &group.G,
+                             nrf_crypto_backend_mbedtls_ecc_mbedtls_rng,
+                             NULL);
+
+    mbedtls_ecp_group_free(&group);
+
+    if (result != 0)
+    {
+        mbedtls_ecp_point_free(&p_pub->key);
+        return NRF_ERROR_CRYPTO_INTERNAL;
+    }
+    return NRF_SUCCESS;
+}
+
+
+ret_code_t nrf_crypto_backend_mbedtls_private_key_from_raw(
+    void          * p_private_key,
+    uint8_t const * p_raw_data)
+{
+    int result;
+    mbedtls_ecp_group group;
+
+    nrf_crypto_backend_mbedtls_ecc_private_key_t * p_prv =
+            (nrf_crypto_backend_mbedtls_ecc_private_key_t *)p_private_key;
+
+    nrf_crypto_ecc_curve_info_t const * p_info = p_prv->header.p_info;
+
+    if (!nrf_crypto_backend_mbedtls_ecc_group_load(&group, p_info))
+    {
+        return NRF_ERROR_CRYPTO_INTERNAL;
+    }
+
+    mbedtls_mpi_init(&p_prv->key);
+    result = mbedtls_mpi_read_binary(&p_prv->key, p_raw_data, p_info->raw_private_key_size);
+
+    if (result == 0)
+    {
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_CURVE25519)
+        // Update bits in Curve25519 private key
+        if (p_prv->header.p_info->curve_type == NRF_CRYPTO_ECC_CURVE25519_CURVE_TYPE)
+        {
+            result = mbedtls_mpi_set_bit(&p_prv->key, 0, 0);
+            ASSERT(result == 0);
+            result = mbedtls_mpi_set_bit(&p_prv->key, 1, 0);
+            ASSERT(result == 0);
+            result = mbedtls_mpi_set_bit(&p_prv->key, 2, 0);
+            ASSERT(result == 0);
+            result = mbedtls_mpi_set_bit(&p_prv->key, 254, 1);
+            ASSERT(result == 0);
+            result = mbedtls_mpi_set_bit(&p_prv->key, 255, 0);
+            ASSERT(result == 0);
+        }
+#endif
+        if (mbedtls_ecp_check_privkey(&group, &p_prv->key) != 0)
+        {
+            result = MBEDTLS_ERR_ECP_INVALID_KEY;
+        }
+    }
+
+    mbedtls_ecp_group_free(&group);
+
+    if (result != 0)
+    {
+        mbedtls_mpi_free(&p_prv->key);
+        return NRF_ERROR_CRYPTO_INTERNAL;
+    }
+    return NRF_SUCCESS;
+}
+
+
+ret_code_t nrf_crypto_backend_mbedtls_private_key_to_raw(
+    void    const * p_private_key,
+    uint8_t       * p_raw_data)
+{
+    int result;
+
+    nrf_crypto_backend_mbedtls_ecc_private_key_t const * p_prv =
+            (nrf_crypto_backend_mbedtls_ecc_private_key_t const *)p_private_key;
+
+    nrf_crypto_ecc_curve_info_t const * p_info = p_prv->header.p_info;
+
+    result = mbedtls_mpi_write_binary(&p_prv->key, p_raw_data, p_info->raw_private_key_size);
+
+    if (result != 0)
+    {
+        return NRF_ERROR_CRYPTO_INTERNAL;
+    }
+    return NRF_SUCCESS;
+}
+
+
+ret_code_t nrf_crypto_backend_mbedtls_public_key_from_raw(
+    void          * p_public_key,
+    uint8_t const * p_raw_data)
+{
+    int result;
+    mbedtls_ecp_group group;
+
+    nrf_crypto_backend_mbedtls_ecc_public_key_t * p_pub =
+        (nrf_crypto_backend_mbedtls_ecc_public_key_t *)p_public_key;
+
+    nrf_crypto_ecc_curve_info_t const * p_info = p_pub->header.p_info;
+
+    mbedtls_ecp_point_init(&p_pub->key);
+
+    result = mbedtls_mpi_read_binary(&p_pub->key.X,
+                                     p_raw_data,
+                                     p_info->raw_private_key_size);
+    if (result != 0)
+    {
+        goto error_exit;
+    }
+
+    if (p_info->raw_public_key_size > p_info->raw_private_key_size)
+    {
+        result = mbedtls_mpi_read_binary(&p_pub->key.Y,
+                                         &p_raw_data[p_info->raw_private_key_size],
+                                         p_info->raw_private_key_size);
+    }
+
+    if (result != 0)
+    {
+        goto error_exit;
+    }
+
+    result = mbedtls_mpi_lset(&p_pub->key.Z, 1);
+
+    if (result == 0)
+    {
+        if (!nrf_crypto_backend_mbedtls_ecc_group_load(&group, p_info))
+        {
+            goto error_exit;
+        }
+        result = mbedtls_ecp_check_pubkey(&group, &p_pub->key);
+        mbedtls_ecp_group_free(&group);
+    }
+
+    if (result != 0)
+    {
+        goto error_exit;
+    }
+    return NRF_SUCCESS;
+
+error_exit:
+    mbedtls_ecp_point_free(&p_pub->key);
+    return NRF_ERROR_CRYPTO_INTERNAL;
+}
+
+
+ret_code_t nrf_crypto_backend_mbedtls_public_key_to_raw(
+    void const * p_public_key,
+    uint8_t    * p_raw_data)
+{
+    int result;
+
+    nrf_crypto_backend_mbedtls_ecc_public_key_t const * p_pub =
+        (nrf_crypto_backend_mbedtls_ecc_public_key_t const *)p_public_key;
+
+    nrf_crypto_ecc_curve_info_t const * p_info = p_pub->header.p_info;
+
+    result = mbedtls_mpi_write_binary(&p_pub->key.X,
+                                      p_raw_data,
+                                      p_info->raw_private_key_size);
+    if (result != 0)
+    {
+        return NRF_ERROR_CRYPTO_INTERNAL;
+    }
+
+    if (p_info->raw_public_key_size > p_info->raw_private_key_size)
+    {
+        result = mbedtls_mpi_write_binary(&p_pub->key.Y,
+                                          &p_raw_data[p_info->raw_private_key_size],
+                                          p_info->raw_private_key_size);
+    }
+
+    if (result != 0)
+    {
+        return NRF_ERROR_CRYPTO_INTERNAL;
+    }
+    return NRF_SUCCESS;
+}
+
+
+ret_code_t nrf_crypto_backend_mbedtls_private_key_free(
+    void * p_private_key)
+{
+    nrf_crypto_backend_mbedtls_ecc_private_key_t * p_prv =
+            (nrf_crypto_backend_mbedtls_ecc_private_key_t *)p_private_key;
+
+    mbedtls_mpi_free(&p_prv->key);
+    return NRF_SUCCESS;
+}
+
+ret_code_t nrf_crypto_backend_mbedtls_public_key_free(
+    void * p_public_key)
+{
+    nrf_crypto_backend_mbedtls_ecc_public_key_t * p_pub =
+            (nrf_crypto_backend_mbedtls_ecc_public_key_t *)p_public_key;
+
+    mbedtls_ecp_point_free(&p_pub->key);
+    return NRF_SUCCESS;
+}
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_SECP192R1)
+const nrf_crypto_ecc_curve_info_t g_nrf_crypto_ecc_secp192r1_curve_info =
+{
+    .public_key_size      = sizeof(nrf_crypto_backend_mbedtls_ecc_public_key_t),
+    .private_key_size     = sizeof(nrf_crypto_backend_mbedtls_ecc_private_key_t),
+    .curve_type           = NRF_CRYPTO_ECC_SECP192R1_CURVE_TYPE,
+    .raw_private_key_size = NRF_CRYPTO_ECC_SECP192R1_RAW_PRIVATE_KEY_SIZE,
+    .raw_public_key_size  = NRF_CRYPTO_ECC_SECP192R1_RAW_PUBLIC_KEY_SIZE,
+    .p_backend_data       = (void *)MBEDTLS_ECP_DP_SECP192R1,
+};
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_SECP224R1)
+const nrf_crypto_ecc_curve_info_t g_nrf_crypto_ecc_secp224r1_curve_info =
+{
+    .public_key_size      = sizeof(nrf_crypto_backend_mbedtls_ecc_public_key_t),
+    .private_key_size     = sizeof(nrf_crypto_backend_mbedtls_ecc_private_key_t),
+    .curve_type           = NRF_CRYPTO_ECC_SECP224R1_CURVE_TYPE,
+    .raw_private_key_size = NRF_CRYPTO_ECC_SECP224R1_RAW_PRIVATE_KEY_SIZE,
+    .raw_public_key_size  = NRF_CRYPTO_ECC_SECP224R1_RAW_PUBLIC_KEY_SIZE,
+    .p_backend_data       = (void *)MBEDTLS_ECP_DP_SECP224R1,
+};
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_SECP256R1)
+const nrf_crypto_ecc_curve_info_t g_nrf_crypto_ecc_secp256r1_curve_info =
+{
+    .public_key_size      = sizeof(nrf_crypto_backend_mbedtls_ecc_public_key_t),
+    .private_key_size     = sizeof(nrf_crypto_backend_mbedtls_ecc_private_key_t),
+    .curve_type           = NRF_CRYPTO_ECC_SECP256R1_CURVE_TYPE,
+    .raw_private_key_size = NRF_CRYPTO_ECC_SECP256R1_RAW_PRIVATE_KEY_SIZE,
+    .raw_public_key_size  = NRF_CRYPTO_ECC_SECP256R1_RAW_PUBLIC_KEY_SIZE,
+    .p_backend_data       = (void *)MBEDTLS_ECP_DP_SECP256R1,
+};
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_SECP384R1)
+const nrf_crypto_ecc_curve_info_t g_nrf_crypto_ecc_secp384r1_curve_info =
+{
+    .public_key_size      = sizeof(nrf_crypto_backend_mbedtls_ecc_public_key_t),
+    .private_key_size     = sizeof(nrf_crypto_backend_mbedtls_ecc_private_key_t),
+    .curve_type           = NRF_CRYPTO_ECC_SECP384R1_CURVE_TYPE,
+    .raw_private_key_size = NRF_CRYPTO_ECC_SECP384R1_RAW_PRIVATE_KEY_SIZE,
+    .raw_public_key_size  = NRF_CRYPTO_ECC_SECP384R1_RAW_PUBLIC_KEY_SIZE,
+    .p_backend_data       = (void *)MBEDTLS_ECP_DP_SECP384R1,
+};
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_SECP521R1)
+const nrf_crypto_ecc_curve_info_t g_nrf_crypto_ecc_secp521r1_curve_info =
+{
+    .public_key_size      = sizeof(nrf_crypto_backend_mbedtls_ecc_public_key_t),
+    .private_key_size     = sizeof(nrf_crypto_backend_mbedtls_ecc_private_key_t),
+    .curve_type           = NRF_CRYPTO_ECC_SECP521R1_CURVE_TYPE,
+    .raw_private_key_size = NRF_CRYPTO_ECC_SECP521R1_RAW_PRIVATE_KEY_SIZE,
+    .raw_public_key_size  = NRF_CRYPTO_ECC_SECP521R1_RAW_PUBLIC_KEY_SIZE,
+    .p_backend_data       = (void *)MBEDTLS_ECP_DP_SECP521R1,
+};
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_SECP192K1)
+const nrf_crypto_ecc_curve_info_t g_nrf_crypto_ecc_secp192k1_curve_info =
+{
+    .public_key_size      = sizeof(nrf_crypto_backend_mbedtls_ecc_public_key_t),
+    .private_key_size     = sizeof(nrf_crypto_backend_mbedtls_ecc_private_key_t),
+    .curve_type           = NRF_CRYPTO_ECC_SECP192K1_CURVE_TYPE,
+    .raw_private_key_size = NRF_CRYPTO_ECC_SECP192K1_RAW_PRIVATE_KEY_SIZE,
+    .raw_public_key_size  = NRF_CRYPTO_ECC_SECP192K1_RAW_PUBLIC_KEY_SIZE,
+    .p_backend_data       = (void *)MBEDTLS_ECP_DP_SECP192K1,
+};
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_SECP224K1)
+const nrf_crypto_ecc_curve_info_t g_nrf_crypto_ecc_secp224k1_curve_info =
+{
+    .public_key_size      = sizeof(nrf_crypto_backend_mbedtls_ecc_public_key_t),
+    .private_key_size     = sizeof(nrf_crypto_backend_mbedtls_ecc_private_key_t),
+    .curve_type           = NRF_CRYPTO_ECC_SECP224K1_CURVE_TYPE,
+    .raw_private_key_size = NRF_CRYPTO_ECC_SECP224K1_RAW_PRIVATE_KEY_SIZE,
+    .raw_public_key_size  = NRF_CRYPTO_ECC_SECP224K1_RAW_PUBLIC_KEY_SIZE,
+    .p_backend_data       = (void *)MBEDTLS_ECP_DP_SECP224K1,
+};
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_SECP256K1)
+const nrf_crypto_ecc_curve_info_t g_nrf_crypto_ecc_secp256k1_curve_info =
+{
+    .public_key_size      = sizeof(nrf_crypto_backend_mbedtls_ecc_public_key_t),
+    .private_key_size     = sizeof(nrf_crypto_backend_mbedtls_ecc_private_key_t),
+    .curve_type           = NRF_CRYPTO_ECC_SECP256K1_CURVE_TYPE,
+    .raw_private_key_size = NRF_CRYPTO_ECC_SECP256K1_RAW_PRIVATE_KEY_SIZE,
+    .raw_public_key_size  = NRF_CRYPTO_ECC_SECP256K1_RAW_PUBLIC_KEY_SIZE,
+    .p_backend_data       = (void *)MBEDTLS_ECP_DP_SECP256K1,
+};
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_BP256R1)
+const nrf_crypto_ecc_curve_info_t g_nrf_crypto_ecc_bp256r1_curve_info =
+{
+    .public_key_size      = sizeof(nrf_crypto_backend_mbedtls_ecc_public_key_t),
+    .private_key_size     = sizeof(nrf_crypto_backend_mbedtls_ecc_private_key_t),
+    .curve_type           = NRF_CRYPTO_ECC_BP256R1_CURVE_TYPE,
+    .raw_private_key_size = NRF_CRYPTO_ECC_BP256R1_RAW_PRIVATE_KEY_SIZE,
+    .raw_public_key_size  = NRF_CRYPTO_ECC_BP256R1_RAW_PUBLIC_KEY_SIZE,
+    .p_backend_data       = (void *)MBEDTLS_ECP_DP_BP256R1,
+};
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_BP384R1)
+const nrf_crypto_ecc_curve_info_t g_nrf_crypto_ecc_bp384r1_curve_info =
+{
+    .public_key_size      = sizeof(nrf_crypto_backend_mbedtls_ecc_public_key_t),
+    .private_key_size     = sizeof(nrf_crypto_backend_mbedtls_ecc_private_key_t),
+    .curve_type           = NRF_CRYPTO_ECC_BP384R1_CURVE_TYPE,
+    .raw_private_key_size = NRF_CRYPTO_ECC_BP384R1_RAW_PRIVATE_KEY_SIZE,
+    .raw_public_key_size  = NRF_CRYPTO_ECC_BP384R1_RAW_PUBLIC_KEY_SIZE,
+    .p_backend_data       = (void *)MBEDTLS_ECP_DP_BP384R1,
+};
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_BP512R1)
+const nrf_crypto_ecc_curve_info_t g_nrf_crypto_ecc_bp512r1_curve_info =
+{
+    .public_key_size      = sizeof(nrf_crypto_backend_mbedtls_ecc_public_key_t),
+    .private_key_size     = sizeof(nrf_crypto_backend_mbedtls_ecc_private_key_t),
+    .curve_type           = NRF_CRYPTO_ECC_BP512R1_CURVE_TYPE,
+    .raw_private_key_size = NRF_CRYPTO_ECC_BP512R1_RAW_PRIVATE_KEY_SIZE,
+    .raw_public_key_size  = NRF_CRYPTO_ECC_BP512R1_RAW_PUBLIC_KEY_SIZE,
+    .p_backend_data       = (void *)MBEDTLS_ECP_DP_BP512R1,
+};
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_CURVE25519)
+const nrf_crypto_ecc_curve_info_t g_nrf_crypto_ecc_curve25519_curve_info =
+{
+    .public_key_size      = sizeof(nrf_crypto_backend_mbedtls_ecc_public_key_t),
+    .private_key_size     = sizeof(nrf_crypto_backend_mbedtls_ecc_private_key_t),
+    .curve_type           = NRF_CRYPTO_ECC_CURVE25519_CURVE_TYPE,
+    .raw_private_key_size = NRF_CRYPTO_ECC_CURVE25519_RAW_PRIVATE_KEY_SIZE,
+    .raw_public_key_size  = NRF_CRYPTO_ECC_CURVE25519_RAW_PUBLIC_KEY_SIZE,
+    .p_backend_data       = (void *)MBEDTLS_ECP_DP_CURVE25519,
+};
+#endif
+
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS)
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/mbedtls/mbedtls_backend_ecc.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/mbedtls/mbedtls_backend_ecc.h
new file mode 100644
index 0000000..288c39c
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/mbedtls/mbedtls_backend_ecc.h
@@ -0,0 +1,519 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef MBEDTLS_BACKEND_ECC_H__
+#define MBEDTLS_BACKEND_ECC_H__
+
+#include "sdk_config.h"
+#include "nordic_common.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS)
+
+#include <stdint.h>
+#include <stdbool.h>
+#include "nrf_crypto_ecc_shared.h"
+
+/*lint -save -e????*/
+#if !defined(MBEDTLS_CONFIG_FILE)
+#include "mbedtls/config.h"
+#else
+#include MBEDTLS_CONFIG_FILE
+#endif
+#include "mbedtls/ecp.h"
+/*lint -restore*/
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/** @internal @brief Common structure holding private key for mbed TLS.
+ */
+typedef struct
+{
+    nrf_crypto_internal_ecc_key_header_t header; /**< @internal @brief Common ECC key header */
+    mbedtls_mpi key;                             /**< @internal @brief mbed TLS specific key representation */
+} nrf_crypto_backend_mbedtls_ecc_private_key_t;
+
+
+/** @internal @brief Common structure holding public key for mbed TLS.
+ */
+typedef struct
+{
+    nrf_crypto_internal_ecc_key_header_t header; /**< @internal @brief Common ECC key header */
+    mbedtls_ecp_point key;                       /**< @internal @brief mbed TLS specific key representation */
+} nrf_crypto_backend_mbedtls_ecc_public_key_t;
+
+
+/** @internal See @ref nrf_crypto_backend_ecc_key_pair_generate_fn_t.
+ */
+ret_code_t nrf_crypto_backend_mbedtls_key_pair_generate(
+    void * p_context,
+    void * p_private_key,
+    void * p_public_key);
+
+
+/** @internal See @ref nrf_crypto_backend_ecc_public_key_calculate_fn_t.
+*/
+ret_code_t nrf_crypto_backend_mbedtls_public_key_calculate(
+    void       * p_context,
+    void const * p_private_key,
+    void       * p_public_key);
+
+
+/** @internal See @ref nrf_crypto_backend_ecc_private_key_from_raw_fn_t.
+*/
+ret_code_t nrf_crypto_backend_mbedtls_private_key_from_raw(
+    void          * p_private_key,
+    uint8_t const * p_raw_data);
+
+
+/** @internal See @ref nrf_crypto_backend_ecc_private_key_to_raw_fn_t.
+*/
+ret_code_t nrf_crypto_backend_mbedtls_private_key_to_raw(
+    void    const * p_private_key,
+    uint8_t       * p_raw_data);
+
+
+/** @internal See @ref nrf_crypto_backend_ecc_public_key_from_raw_fn_t.
+*/
+ret_code_t nrf_crypto_backend_mbedtls_public_key_from_raw(
+    void          * p_public_key,
+    uint8_t const * p_raw_data);
+
+
+/** @internal See @ref nrf_crypto_backend_ecc_public_key_to_raw_fn_t.
+*/
+ret_code_t nrf_crypto_backend_mbedtls_public_key_to_raw(
+    void const * p_public_key,
+    uint8_t    * p_raw_data);
+
+
+/** @internal See @ref nrf_crypto_backend_ecc_key_free_fn_t.
+*/
+ret_code_t nrf_crypto_backend_mbedtls_private_key_free(
+    void * p_private_key);
+
+
+/** @internal See @ref nrf_crypto_backend_ecc_key_free_fn_t.
+*/
+ret_code_t nrf_crypto_backend_mbedtls_public_key_free(
+    void * p_public_key);
+
+
+/** @internal @brief Loads mbed TLS ECC group of specified curve type.
+ *
+ *  @param[out] p_group    Pointer to place where to load a group. Data have to be later deallocated.
+ *  @param[in]  curve_type ECC curve type from enum @ref nrf_crypto_ecc_curve_type_t.
+ *  @returns               true on success, false if curve is not supported or no found in mbed TLS.
+ */
+bool nrf_crypto_backend_mbedtls_ecc_group_load(
+    mbedtls_ecp_group                        * p_group,
+    struct nrf_crypto_ecc_curve_info_s const * p_info);
+
+
+/** @internal @brief Function that can be used as a parameter to mbed TLS functions requiring random
+ *  number generator.
+ *
+ *  It uses RNG from libary front end to generate random numbers.
+ *
+ *  @param[in]  p_param   Opaque pointer passed by mbed TLS. Unused by this implementation.
+ *  @param[out] p_data    Pointer where to put random number.
+ *  @returns              0 on success, mbed TLS error code on error.
+ */
+int nrf_crypto_backend_mbedtls_ecc_mbedtls_rng(void * p_param, unsigned char * p_data, size_t size);
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_SECP192R1)
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_ECC_SECP192R1)
+#error "More than one backend enabled for secp192r1 (NIST 192-bit).");
+#endif
+#define NRF_CRYPTO_ECC_SECP192R1_ENABLED 1
+
+// Aliases for one common MBEDTLS implementation
+#define nrf_crypto_backend_secp192r1_key_pair_generate    nrf_crypto_backend_mbedtls_key_pair_generate
+#define nrf_crypto_backend_secp192r1_public_key_calculate nrf_crypto_backend_mbedtls_public_key_calculate
+#define nrf_crypto_backend_secp192r1_private_key_from_raw nrf_crypto_backend_mbedtls_private_key_from_raw
+#define nrf_crypto_backend_secp192r1_private_key_to_raw   nrf_crypto_backend_mbedtls_private_key_to_raw
+#define nrf_crypto_backend_secp192r1_public_key_from_raw  nrf_crypto_backend_mbedtls_public_key_from_raw
+#define nrf_crypto_backend_secp192r1_public_key_to_raw    nrf_crypto_backend_mbedtls_public_key_to_raw
+#define nrf_crypto_backend_secp192r1_private_key_free     nrf_crypto_backend_mbedtls_private_key_free
+#define nrf_crypto_backend_secp192r1_public_key_free      nrf_crypto_backend_mbedtls_public_key_free
+// mbed TLS does not require context, so its size is 0.
+#define NRF_CRYPTO_BACKEND_SECP192R1_KEY_PAIR_GENERATE_CONTEXT_SIZE    0
+#define NRF_CRYPTO_BACKEND_SECP192R1_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE 0
+// All MBEDTLS curve types share the same data structures
+typedef nrf_crypto_backend_mbedtls_ecc_private_key_t nrf_crypto_backend_secp192r1_private_key_t;
+typedef nrf_crypto_backend_mbedtls_ecc_public_key_t  nrf_crypto_backend_secp192r1_public_key_t;
+// Dummy typedef for unused context
+typedef uint32_t nrf_crypto_backend_secp192r1_key_pair_generate_context_t;
+typedef uint32_t nrf_crypto_backend_secp192r1_public_key_calculate_context_t;
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_SECP192R1)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_SECP224R1)
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_ECC_SECP224R1)
+#error "More than one backend enabled for secp224r1 (NIST 224-bit).");
+#endif
+#define NRF_CRYPTO_ECC_SECP224R1_ENABLED 1
+
+// Aliases for one common MBEDTLS implementation
+#define nrf_crypto_backend_secp224r1_key_pair_generate    nrf_crypto_backend_mbedtls_key_pair_generate
+#define nrf_crypto_backend_secp224r1_public_key_calculate nrf_crypto_backend_mbedtls_public_key_calculate
+#define nrf_crypto_backend_secp224r1_private_key_from_raw nrf_crypto_backend_mbedtls_private_key_from_raw
+#define nrf_crypto_backend_secp224r1_private_key_to_raw   nrf_crypto_backend_mbedtls_private_key_to_raw
+#define nrf_crypto_backend_secp224r1_public_key_from_raw  nrf_crypto_backend_mbedtls_public_key_from_raw
+#define nrf_crypto_backend_secp224r1_public_key_to_raw    nrf_crypto_backend_mbedtls_public_key_to_raw
+#define nrf_crypto_backend_secp224r1_private_key_free     nrf_crypto_backend_mbedtls_private_key_free
+#define nrf_crypto_backend_secp224r1_public_key_free      nrf_crypto_backend_mbedtls_public_key_free
+// mbed TLS does not require context, so its size is 0.
+#define NRF_CRYPTO_BACKEND_SECP224R1_KEY_PAIR_GENERATE_CONTEXT_SIZE    0
+#define NRF_CRYPTO_BACKEND_SECP224R1_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE 0
+// All MBEDTLS curve types share the same data structures
+typedef nrf_crypto_backend_mbedtls_ecc_private_key_t nrf_crypto_backend_secp224r1_private_key_t;
+typedef nrf_crypto_backend_mbedtls_ecc_public_key_t  nrf_crypto_backend_secp224r1_public_key_t;
+// Dummy typedef for unused context
+typedef uint32_t nrf_crypto_backend_secp224r1_key_pair_generate_context_t;
+typedef uint32_t nrf_crypto_backend_secp224r1_public_key_calculate_context_t;
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_SECP224R1)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_SECP256R1)
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_ECC_SECP256R1)
+#error "More than one backend enabled for secp256r1 (NIST 256-bit).");
+#endif
+#define NRF_CRYPTO_ECC_SECP256R1_ENABLED 1
+
+// Aliases for one common MBEDTLS implementation
+#define nrf_crypto_backend_secp256r1_key_pair_generate    nrf_crypto_backend_mbedtls_key_pair_generate
+#define nrf_crypto_backend_secp256r1_public_key_calculate nrf_crypto_backend_mbedtls_public_key_calculate
+#define nrf_crypto_backend_secp256r1_private_key_from_raw nrf_crypto_backend_mbedtls_private_key_from_raw
+#define nrf_crypto_backend_secp256r1_private_key_to_raw   nrf_crypto_backend_mbedtls_private_key_to_raw
+#define nrf_crypto_backend_secp256r1_public_key_from_raw  nrf_crypto_backend_mbedtls_public_key_from_raw
+#define nrf_crypto_backend_secp256r1_public_key_to_raw    nrf_crypto_backend_mbedtls_public_key_to_raw
+#define nrf_crypto_backend_secp256r1_private_key_free     nrf_crypto_backend_mbedtls_private_key_free
+#define nrf_crypto_backend_secp256r1_public_key_free      nrf_crypto_backend_mbedtls_public_key_free
+// mbed TLS does not require context, so its size is 0.
+#define NRF_CRYPTO_BACKEND_SECP256R1_KEY_PAIR_GENERATE_CONTEXT_SIZE    0
+#define NRF_CRYPTO_BACKEND_SECP256R1_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE 0
+// All MBEDTLS curve types share the same data structures
+typedef nrf_crypto_backend_mbedtls_ecc_private_key_t nrf_crypto_backend_secp256r1_private_key_t;
+typedef nrf_crypto_backend_mbedtls_ecc_public_key_t  nrf_crypto_backend_secp256r1_public_key_t;
+// Dummy typedef for unused context
+typedef uint32_t nrf_crypto_backend_secp256r1_key_pair_generate_context_t;
+typedef uint32_t nrf_crypto_backend_secp256r1_public_key_calculate_context_t;
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_SECP256R1)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_SECP384R1)
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_ECC_SECP384R1)
+#error "More than one backend enabled for secp384r1 (NIST 384-bit).");
+#endif
+#define NRF_CRYPTO_ECC_SECP384R1_ENABLED 1
+
+// Aliases for one common MBEDTLS implementation
+#define nrf_crypto_backend_secp384r1_key_pair_generate    nrf_crypto_backend_mbedtls_key_pair_generate
+#define nrf_crypto_backend_secp384r1_public_key_calculate nrf_crypto_backend_mbedtls_public_key_calculate
+#define nrf_crypto_backend_secp384r1_private_key_from_raw nrf_crypto_backend_mbedtls_private_key_from_raw
+#define nrf_crypto_backend_secp384r1_private_key_to_raw   nrf_crypto_backend_mbedtls_private_key_to_raw
+#define nrf_crypto_backend_secp384r1_public_key_from_raw  nrf_crypto_backend_mbedtls_public_key_from_raw
+#define nrf_crypto_backend_secp384r1_public_key_to_raw    nrf_crypto_backend_mbedtls_public_key_to_raw
+#define nrf_crypto_backend_secp384r1_private_key_free     nrf_crypto_backend_mbedtls_private_key_free
+#define nrf_crypto_backend_secp384r1_public_key_free      nrf_crypto_backend_mbedtls_public_key_free
+// mbed TLS does not require context, so its size is 0.
+#define NRF_CRYPTO_BACKEND_SECP384R1_KEY_PAIR_GENERATE_CONTEXT_SIZE    0
+#define NRF_CRYPTO_BACKEND_SECP384R1_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE 0
+// All MBEDTLS curve types share the same data structures
+typedef nrf_crypto_backend_mbedtls_ecc_private_key_t nrf_crypto_backend_secp384r1_private_key_t;
+typedef nrf_crypto_backend_mbedtls_ecc_public_key_t  nrf_crypto_backend_secp384r1_public_key_t;
+// Dummy typedef for unused context
+typedef uint32_t nrf_crypto_backend_secp384r1_key_pair_generate_context_t;
+typedef uint32_t nrf_crypto_backend_secp384r1_public_key_calculate_context_t;
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_SECP384R1)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_SECP521R1)
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_ECC_SECP521R1)
+#error "More than one backend enabled for secp521r1 (NIST 521-bit).");
+#endif
+#define NRF_CRYPTO_ECC_SECP521R1_ENABLED 1
+
+// Aliases for one common MBEDTLS implementation
+#define nrf_crypto_backend_secp521r1_key_pair_generate    nrf_crypto_backend_mbedtls_key_pair_generate
+#define nrf_crypto_backend_secp521r1_public_key_calculate nrf_crypto_backend_mbedtls_public_key_calculate
+#define nrf_crypto_backend_secp521r1_private_key_from_raw nrf_crypto_backend_mbedtls_private_key_from_raw
+#define nrf_crypto_backend_secp521r1_private_key_to_raw   nrf_crypto_backend_mbedtls_private_key_to_raw
+#define nrf_crypto_backend_secp521r1_public_key_from_raw  nrf_crypto_backend_mbedtls_public_key_from_raw
+#define nrf_crypto_backend_secp521r1_public_key_to_raw    nrf_crypto_backend_mbedtls_public_key_to_raw
+#define nrf_crypto_backend_secp521r1_private_key_free     nrf_crypto_backend_mbedtls_private_key_free
+#define nrf_crypto_backend_secp521r1_public_key_free      nrf_crypto_backend_mbedtls_public_key_free
+// mbed TLS does not require context, so its size is 0.
+#define NRF_CRYPTO_BACKEND_SECP521R1_KEY_PAIR_GENERATE_CONTEXT_SIZE    0
+#define NRF_CRYPTO_BACKEND_SECP521R1_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE 0
+// All MBEDTLS curve types share the same data structures
+typedef nrf_crypto_backend_mbedtls_ecc_private_key_t nrf_crypto_backend_secp521r1_private_key_t;
+typedef nrf_crypto_backend_mbedtls_ecc_public_key_t  nrf_crypto_backend_secp521r1_public_key_t;
+// Dummy typedef for unused context
+typedef uint32_t nrf_crypto_backend_secp521r1_key_pair_generate_context_t;
+typedef uint32_t nrf_crypto_backend_secp521r1_public_key_calculate_context_t;
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_SECP521R1)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_SECP192K1)
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_ECC_SECP192K1)
+#error "More than one backend enabled for secp192k1 (Koblitz 192-bit).");
+#endif
+#define NRF_CRYPTO_ECC_SECP192K1_ENABLED 1
+
+// Aliases for one common MBEDTLS implementation
+#define nrf_crypto_backend_secp192k1_key_pair_generate    nrf_crypto_backend_mbedtls_key_pair_generate
+#define nrf_crypto_backend_secp192k1_public_key_calculate nrf_crypto_backend_mbedtls_public_key_calculate
+#define nrf_crypto_backend_secp192k1_private_key_from_raw nrf_crypto_backend_mbedtls_private_key_from_raw
+#define nrf_crypto_backend_secp192k1_private_key_to_raw   nrf_crypto_backend_mbedtls_private_key_to_raw
+#define nrf_crypto_backend_secp192k1_public_key_from_raw  nrf_crypto_backend_mbedtls_public_key_from_raw
+#define nrf_crypto_backend_secp192k1_public_key_to_raw    nrf_crypto_backend_mbedtls_public_key_to_raw
+#define nrf_crypto_backend_secp192k1_private_key_free     nrf_crypto_backend_mbedtls_private_key_free
+#define nrf_crypto_backend_secp192k1_public_key_free      nrf_crypto_backend_mbedtls_public_key_free
+// mbed TLS does not require context, so its size is 0.
+#define NRF_CRYPTO_BACKEND_SECP192K1_KEY_PAIR_GENERATE_CONTEXT_SIZE    0
+#define NRF_CRYPTO_BACKEND_SECP192K1_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE 0
+// All MBEDTLS curve types share the same data structures
+typedef nrf_crypto_backend_mbedtls_ecc_private_key_t nrf_crypto_backend_secp192k1_private_key_t;
+typedef nrf_crypto_backend_mbedtls_ecc_public_key_t  nrf_crypto_backend_secp192k1_public_key_t;
+// Dummy typedef for unused context
+typedef uint32_t nrf_crypto_backend_secp192k1_key_pair_generate_context_t;
+typedef uint32_t nrf_crypto_backend_secp192k1_public_key_calculate_context_t;
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_SECP192K1)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_SECP224K1)
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_ECC_SECP224K1)
+#error "More than one backend enabled for secp224k1 (Koblitz 224-bit).");
+#endif
+#define NRF_CRYPTO_ECC_SECP224K1_ENABLED 1
+
+// Aliases for one common MBEDTLS implementation
+#define nrf_crypto_backend_secp224k1_key_pair_generate    nrf_crypto_backend_mbedtls_key_pair_generate
+#define nrf_crypto_backend_secp224k1_public_key_calculate nrf_crypto_backend_mbedtls_public_key_calculate
+#define nrf_crypto_backend_secp224k1_private_key_from_raw nrf_crypto_backend_mbedtls_private_key_from_raw
+#define nrf_crypto_backend_secp224k1_private_key_to_raw   nrf_crypto_backend_mbedtls_private_key_to_raw
+#define nrf_crypto_backend_secp224k1_public_key_from_raw  nrf_crypto_backend_mbedtls_public_key_from_raw
+#define nrf_crypto_backend_secp224k1_public_key_to_raw    nrf_crypto_backend_mbedtls_public_key_to_raw
+#define nrf_crypto_backend_secp224k1_private_key_free     nrf_crypto_backend_mbedtls_private_key_free
+#define nrf_crypto_backend_secp224k1_public_key_free      nrf_crypto_backend_mbedtls_public_key_free
+// mbed TLS does not require context, so its size is 0.
+#define NRF_CRYPTO_BACKEND_SECP224K1_KEY_PAIR_GENERATE_CONTEXT_SIZE    0
+#define NRF_CRYPTO_BACKEND_SECP224K1_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE 0
+// All MBEDTLS curve types share the same data structures
+typedef nrf_crypto_backend_mbedtls_ecc_private_key_t nrf_crypto_backend_secp224k1_private_key_t;
+typedef nrf_crypto_backend_mbedtls_ecc_public_key_t  nrf_crypto_backend_secp224k1_public_key_t;
+// Dummy typedef for unused context
+typedef uint32_t nrf_crypto_backend_secp224k1_key_pair_generate_context_t;
+typedef uint32_t nrf_crypto_backend_secp224k1_public_key_calculate_context_t;
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_SECP224K1)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_SECP256K1)
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_ECC_SECP256K1)
+#error "More than one backend enabled for secp256k1 (Koblitz 256-bit).");
+#endif
+#define NRF_CRYPTO_ECC_SECP256K1_ENABLED 1
+
+// Aliases for one common MBEDTLS implementation
+#define nrf_crypto_backend_secp256k1_key_pair_generate    nrf_crypto_backend_mbedtls_key_pair_generate
+#define nrf_crypto_backend_secp256k1_public_key_calculate nrf_crypto_backend_mbedtls_public_key_calculate
+#define nrf_crypto_backend_secp256k1_private_key_from_raw nrf_crypto_backend_mbedtls_private_key_from_raw
+#define nrf_crypto_backend_secp256k1_private_key_to_raw   nrf_crypto_backend_mbedtls_private_key_to_raw
+#define nrf_crypto_backend_secp256k1_public_key_from_raw  nrf_crypto_backend_mbedtls_public_key_from_raw
+#define nrf_crypto_backend_secp256k1_public_key_to_raw    nrf_crypto_backend_mbedtls_public_key_to_raw
+#define nrf_crypto_backend_secp256k1_private_key_free     nrf_crypto_backend_mbedtls_private_key_free
+#define nrf_crypto_backend_secp256k1_public_key_free      nrf_crypto_backend_mbedtls_public_key_free
+// mbed TLS does not require context, so its size is 0.
+#define NRF_CRYPTO_BACKEND_SECP256K1_KEY_PAIR_GENERATE_CONTEXT_SIZE    0
+#define NRF_CRYPTO_BACKEND_SECP256K1_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE 0
+// All MBEDTLS curve types share the same data structures
+typedef nrf_crypto_backend_mbedtls_ecc_private_key_t nrf_crypto_backend_secp256k1_private_key_t;
+typedef nrf_crypto_backend_mbedtls_ecc_public_key_t  nrf_crypto_backend_secp256k1_public_key_t;
+// Dummy typedef for unused context
+typedef uint32_t nrf_crypto_backend_secp256k1_key_pair_generate_context_t;
+typedef uint32_t nrf_crypto_backend_secp256k1_public_key_calculate_context_t;
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_SECP256K1)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_BP256R1)
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_ECC_BP256R1)
+#error "More than one backend enabled for bp256r1 (Brainpool 256-bit).");
+#endif
+#define NRF_CRYPTO_ECC_BP256R1_ENABLED 1
+
+// Aliases for one common MBEDTLS implementation
+#define nrf_crypto_backend_bp256r1_key_pair_generate    nrf_crypto_backend_mbedtls_key_pair_generate
+#define nrf_crypto_backend_bp256r1_public_key_calculate nrf_crypto_backend_mbedtls_public_key_calculate
+#define nrf_crypto_backend_bp256r1_private_key_from_raw nrf_crypto_backend_mbedtls_private_key_from_raw
+#define nrf_crypto_backend_bp256r1_private_key_to_raw   nrf_crypto_backend_mbedtls_private_key_to_raw
+#define nrf_crypto_backend_bp256r1_public_key_from_raw  nrf_crypto_backend_mbedtls_public_key_from_raw
+#define nrf_crypto_backend_bp256r1_public_key_to_raw    nrf_crypto_backend_mbedtls_public_key_to_raw
+#define nrf_crypto_backend_bp256r1_private_key_free     nrf_crypto_backend_mbedtls_private_key_free
+#define nrf_crypto_backend_bp256r1_public_key_free      nrf_crypto_backend_mbedtls_public_key_free
+// mbed TLS does not require context, so its size is 0.
+#define NRF_CRYPTO_BACKEND_BP256R1_KEY_PAIR_GENERATE_CONTEXT_SIZE    0
+#define NRF_CRYPTO_BACKEND_BP256R1_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE 0
+// All MBEDTLS curve types share the same data structures
+typedef nrf_crypto_backend_mbedtls_ecc_private_key_t nrf_crypto_backend_bp256r1_private_key_t;
+typedef nrf_crypto_backend_mbedtls_ecc_public_key_t  nrf_crypto_backend_bp256r1_public_key_t;
+// Dummy typedef for unused context
+typedef uint32_t nrf_crypto_backend_bp256r1_key_pair_generate_context_t;
+typedef uint32_t nrf_crypto_backend_bp256r1_public_key_calculate_context_t;
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_BP256R1)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_BP384R1)
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_ECC_BP384R1)
+#error "More than one backend enabled for bp384r1 (Brainpool 384-bit).");
+#endif
+#define NRF_CRYPTO_ECC_BP384R1_ENABLED 1
+
+// Aliases for one common MBEDTLS implementation
+#define nrf_crypto_backend_bp384r1_key_pair_generate    nrf_crypto_backend_mbedtls_key_pair_generate
+#define nrf_crypto_backend_bp384r1_public_key_calculate nrf_crypto_backend_mbedtls_public_key_calculate
+#define nrf_crypto_backend_bp384r1_private_key_from_raw nrf_crypto_backend_mbedtls_private_key_from_raw
+#define nrf_crypto_backend_bp384r1_private_key_to_raw   nrf_crypto_backend_mbedtls_private_key_to_raw
+#define nrf_crypto_backend_bp384r1_public_key_from_raw  nrf_crypto_backend_mbedtls_public_key_from_raw
+#define nrf_crypto_backend_bp384r1_public_key_to_raw    nrf_crypto_backend_mbedtls_public_key_to_raw
+#define nrf_crypto_backend_bp384r1_private_key_free     nrf_crypto_backend_mbedtls_private_key_free
+#define nrf_crypto_backend_bp384r1_public_key_free      nrf_crypto_backend_mbedtls_public_key_free
+// mbed TLS does not require context, so its size is 0.
+#define NRF_CRYPTO_BACKEND_BP384R1_KEY_PAIR_GENERATE_CONTEXT_SIZE    0
+#define NRF_CRYPTO_BACKEND_BP384R1_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE 0
+// All MBEDTLS curve types share the same data structures
+typedef nrf_crypto_backend_mbedtls_ecc_private_key_t nrf_crypto_backend_bp384r1_private_key_t;
+typedef nrf_crypto_backend_mbedtls_ecc_public_key_t  nrf_crypto_backend_bp384r1_public_key_t;
+// Dummy typedef for unused context
+typedef uint32_t nrf_crypto_backend_bp384r1_key_pair_generate_context_t;
+typedef uint32_t nrf_crypto_backend_bp384r1_public_key_calculate_context_t;
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_BP384R1)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_BP512R1)
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_ECC_BP512R1)
+#error "More than one backend enabled for bp512r1 (Brainpool 512-bit).");
+#endif
+#define NRF_CRYPTO_ECC_BP512R1_ENABLED 1
+
+// Aliases for one common MBEDTLS implementation
+#define nrf_crypto_backend_bp512r1_key_pair_generate    nrf_crypto_backend_mbedtls_key_pair_generate
+#define nrf_crypto_backend_bp512r1_public_key_calculate nrf_crypto_backend_mbedtls_public_key_calculate
+#define nrf_crypto_backend_bp512r1_private_key_from_raw nrf_crypto_backend_mbedtls_private_key_from_raw
+#define nrf_crypto_backend_bp512r1_private_key_to_raw   nrf_crypto_backend_mbedtls_private_key_to_raw
+#define nrf_crypto_backend_bp512r1_public_key_from_raw  nrf_crypto_backend_mbedtls_public_key_from_raw
+#define nrf_crypto_backend_bp512r1_public_key_to_raw    nrf_crypto_backend_mbedtls_public_key_to_raw
+#define nrf_crypto_backend_bp512r1_private_key_free     nrf_crypto_backend_mbedtls_private_key_free
+#define nrf_crypto_backend_bp512r1_public_key_free      nrf_crypto_backend_mbedtls_public_key_free
+// mbed TLS does not require context, so its size is 0.
+#define NRF_CRYPTO_BACKEND_BP512R1_KEY_PAIR_GENERATE_CONTEXT_SIZE    0
+#define NRF_CRYPTO_BACKEND_BP512R1_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE 0
+// All MBEDTLS curve types share the same data structures
+typedef nrf_crypto_backend_mbedtls_ecc_private_key_t nrf_crypto_backend_bp512r1_private_key_t;
+typedef nrf_crypto_backend_mbedtls_ecc_public_key_t  nrf_crypto_backend_bp512r1_public_key_t;
+// Dummy typedef for unused context
+typedef uint32_t nrf_crypto_backend_bp512r1_key_pair_generate_context_t;
+typedef uint32_t nrf_crypto_backend_bp512r1_public_key_calculate_context_t;
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_BP512R1)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_CURVE25519)
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_ECC_CURVE25519)
+#error "More than one backend enabled for Curve25519.");
+#endif
+#define NRF_CRYPTO_ECC_CURVE25519_ENABLED 1
+
+// Aliases for one common MBEDTLS implementation
+#define nrf_crypto_backend_curve25519_key_pair_generate    nrf_crypto_backend_mbedtls_key_pair_generate
+#define nrf_crypto_backend_curve25519_public_key_calculate nrf_crypto_backend_mbedtls_public_key_calculate
+#define nrf_crypto_backend_curve25519_private_key_from_raw nrf_crypto_backend_mbedtls_private_key_from_raw
+#define nrf_crypto_backend_curve25519_private_key_to_raw   nrf_crypto_backend_mbedtls_private_key_to_raw
+#define nrf_crypto_backend_curve25519_public_key_from_raw  nrf_crypto_backend_mbedtls_public_key_from_raw
+#define nrf_crypto_backend_curve25519_public_key_to_raw    nrf_crypto_backend_mbedtls_public_key_to_raw
+#define nrf_crypto_backend_curve25519_private_key_free     nrf_crypto_backend_mbedtls_private_key_free
+#define nrf_crypto_backend_curve25519_public_key_free      nrf_crypto_backend_mbedtls_public_key_free
+// mbed TLS does not require context, so its size is 0.
+#define NRF_CRYPTO_BACKEND_CURVE25519_KEY_PAIR_GENERATE_CONTEXT_SIZE    0
+#define NRF_CRYPTO_BACKEND_CURVE25519_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE 0
+// All MBEDTLS curve types share the same data structures
+typedef nrf_crypto_backend_mbedtls_ecc_private_key_t nrf_crypto_backend_curve25519_private_key_t;
+typedef nrf_crypto_backend_mbedtls_ecc_public_key_t  nrf_crypto_backend_curve25519_public_key_t;
+// Dummy typedef for unused context
+typedef uint32_t nrf_crypto_backend_curve25519_key_pair_generate_context_t;
+typedef uint32_t nrf_crypto_backend_curve25519_public_key_calculate_context_t;
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_CURVE25519)
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS)
+
+#endif // MBEDTLS_BACKEND_ECC_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/mbedtls/mbedtls_backend_ecdh.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/mbedtls/mbedtls_backend_ecdh.c
new file mode 100644
index 0000000..02de8d7
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/mbedtls/mbedtls_backend_ecdh.c
@@ -0,0 +1,113 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#include "sdk_config.h"
+#include "nordic_common.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS)
+
+#include <string.h>
+
+#include "nrf_crypto_ecc_shared.h"
+#include "nrf_crypto_ecdh_shared.h"
+#include "nrf_crypto_ecdh.h"
+
+/*lint -save -e????*/
+#if !defined(MBEDTLS_CONFIG_FILE)
+#include "mbedtls/config.h"
+#else
+#include MBEDTLS_CONFIG_FILE
+#endif
+#include "mbedtls/ecp.h"
+#include "mbedtls/ecdh.h"
+/*lint -restore*/
+
+
+ret_code_t nrf_crypto_backend_mbedtls_ecdh_compute(
+    void       * p_context,
+    void const * p_private_key,
+    void const * p_public_key,
+    uint8_t    * p_shared_secret)
+{
+    int               result;
+    mbedtls_mpi       shared_secret_mpi;
+    mbedtls_ecp_group group;
+
+    nrf_crypto_backend_mbedtls_ecc_private_key_t const * p_prv =
+            (nrf_crypto_backend_mbedtls_ecc_private_key_t const *)p_private_key;
+
+    nrf_crypto_backend_mbedtls_ecc_public_key_t  const * p_pub =
+            (nrf_crypto_backend_mbedtls_ecc_public_key_t const *)p_public_key;
+
+    nrf_crypto_ecc_curve_info_t const * p_info = p_prv->header.p_info;
+
+    if (!nrf_crypto_backend_mbedtls_ecc_group_load(&group, p_info))
+    {
+        return NRF_ERROR_CRYPTO_INTERNAL;
+    }
+
+    mbedtls_mpi_init(&shared_secret_mpi);
+    result = mbedtls_ecdh_compute_shared(&group,
+                                         &shared_secret_mpi,
+                                         &p_pub->key,
+                                         &p_prv->key,
+                                         nrf_crypto_backend_mbedtls_ecc_mbedtls_rng,
+                                         NULL);
+
+    if (result == 0)
+    {
+        result = mbedtls_mpi_write_binary(&shared_secret_mpi,
+                                          p_shared_secret,
+                                          p_info->raw_private_key_size);
+    }
+
+    mbedtls_mpi_free(&shared_secret_mpi);
+    mbedtls_ecp_group_free(&group);
+
+    if (result != 0)
+    {
+        return NRF_ERROR_CRYPTO_INTERNAL;
+    }
+    return NRF_SUCCESS;
+}
+
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS)
+
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/mbedtls/mbedtls_backend_ecdh.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/mbedtls/mbedtls_backend_ecdh.h
new file mode 100644
index 0000000..fac0e83
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/mbedtls/mbedtls_backend_ecdh.h
@@ -0,0 +1,169 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef MBEDTLS_BACKEND_ECDH_H__
+#define MBEDTLS_BACKEND_ECDH_H__
+
+#include "sdk_config.h"
+#include "nordic_common.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS)
+
+#include "nrf_crypto_ecc.h"
+#include "nrf_crypto_ecdh_shared.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/** @internal See @ref nrf_crypto_backend_ecdh_compute_fn_t.
+ */
+ret_code_t nrf_crypto_backend_mbedtls_ecdh_compute(
+    void       * p_context,
+    void const * p_private_key,
+    void const * p_public_key,
+    uint8_t    * p_shared_secret);
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_SECP192R1)
+// Aliases for one common MBEDTLS implementation
+#define nrf_crypto_backend_secp192r1_ecdh_compute nrf_crypto_backend_mbedtls_ecdh_compute
+typedef uint32_t nrf_crypto_backend_secp192r1_ecdh_context_t;
+#define NRF_CRYPTO_BACKEND_SECP192R1_ECDH_CONTEXT_SIZE 0
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_SECP192R1)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_SECP224R1)
+// Aliases for one common MBEDTLS implementation
+#define nrf_crypto_backend_secp224r1_ecdh_compute nrf_crypto_backend_mbedtls_ecdh_compute
+typedef uint32_t nrf_crypto_backend_secp224r1_ecdh_context_t;
+#define NRF_CRYPTO_BACKEND_SECP224R1_ECDH_CONTEXT_SIZE 0
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_SECP224R1)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_SECP256R1)
+// Aliases for one common MBEDTLS implementation
+#define nrf_crypto_backend_secp256r1_ecdh_compute nrf_crypto_backend_mbedtls_ecdh_compute
+typedef uint32_t nrf_crypto_backend_secp256r1_ecdh_context_t;
+#define NRF_CRYPTO_BACKEND_SECP256R1_ECDH_CONTEXT_SIZE 0
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_SECP256R1)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_SECP384R1)
+// Aliases for one common MBEDTLS implementation
+#define nrf_crypto_backend_secp384r1_ecdh_compute nrf_crypto_backend_mbedtls_ecdh_compute
+typedef uint32_t nrf_crypto_backend_secp384r1_ecdh_context_t;
+#define NRF_CRYPTO_BACKEND_SECP384R1_ECDH_CONTEXT_SIZE 0
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_SECP384R1)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_SECP521R1)
+// Aliases for one common MBEDTLS implementation
+#define nrf_crypto_backend_secp521r1_ecdh_compute nrf_crypto_backend_mbedtls_ecdh_compute
+typedef uint32_t nrf_crypto_backend_secp521r1_ecdh_context_t;
+#define NRF_CRYPTO_BACKEND_SECP521R1_ECDH_CONTEXT_SIZE 0
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_SECP521R1)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_SECP192K1)
+// Aliases for one common MBEDTLS implementation
+#define nrf_crypto_backend_secp192k1_ecdh_compute nrf_crypto_backend_mbedtls_ecdh_compute
+typedef uint32_t nrf_crypto_backend_secp192k1_ecdh_context_t;
+#define NRF_CRYPTO_BACKEND_SECP192K1_ECDH_CONTEXT_SIZE 0
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_SECP192K1)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_SECP224K1)
+// Aliases for one common MBEDTLS implementation
+#define nrf_crypto_backend_secp224k1_ecdh_compute nrf_crypto_backend_mbedtls_ecdh_compute
+typedef uint32_t nrf_crypto_backend_secp224k1_ecdh_context_t;
+#define NRF_CRYPTO_BACKEND_SECP224K1_ECDH_CONTEXT_SIZE 0
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_SECP224K1)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_SECP256K1)
+// Aliases for one common MBEDTLS implementation
+#define nrf_crypto_backend_secp256k1_ecdh_compute nrf_crypto_backend_mbedtls_ecdh_compute
+typedef uint32_t nrf_crypto_backend_secp256k1_ecdh_context_t;
+#define NRF_CRYPTO_BACKEND_SECP256K1_ECDH_CONTEXT_SIZE 0
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_SECP256K1)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_BP256R1)
+// Aliases for one common MBEDTLS implementation
+#define nrf_crypto_backend_bp256r1_ecdh_compute nrf_crypto_backend_mbedtls_ecdh_compute
+typedef uint32_t nrf_crypto_backend_bp256r1_ecdh_context_t;
+#define NRF_CRYPTO_BACKEND_BP256R1_ECDH_CONTEXT_SIZE 0
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_BP256R1)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_BP384R1)
+// Aliases for one common MBEDTLS implementation
+#define nrf_crypto_backend_bp384r1_ecdh_compute nrf_crypto_backend_mbedtls_ecdh_compute
+typedef uint32_t nrf_crypto_backend_bp384r1_ecdh_context_t;
+#define NRF_CRYPTO_BACKEND_BP384R1_ECDH_CONTEXT_SIZE 0
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_BP384R1)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_BP512R1)
+// Aliases for one common MBEDTLS implementation
+#define nrf_crypto_backend_bp512r1_ecdh_compute nrf_crypto_backend_mbedtls_ecdh_compute
+typedef uint32_t nrf_crypto_backend_bp512r1_ecdh_context_t;
+#define NRF_CRYPTO_BACKEND_BP512R1_ECDH_CONTEXT_SIZE 0
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_BP512R1)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_CURVE25519)
+// Aliases for one common MBEDTLS implementation
+#define nrf_crypto_backend_curve25519_ecdh_compute nrf_crypto_backend_mbedtls_ecdh_compute
+typedef uint32_t nrf_crypto_backend_curve25519_ecdh_context_t;
+#define NRF_CRYPTO_BACKEND_CURVE25519_ECDH_CONTEXT_SIZE 0
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_CURVE25519)
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS)
+
+#endif // MBEDTLS_BACKEND_ECDH_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/mbedtls/mbedtls_backend_ecdsa.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/mbedtls/mbedtls_backend_ecdsa.c
new file mode 100644
index 0000000..04a5a90
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/mbedtls/mbedtls_backend_ecdsa.c
@@ -0,0 +1,176 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#include "sdk_config.h"
+#include "nordic_common.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS)
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <string.h>
+
+#include "nrf_crypto_ecc.h"
+#include "nrf_crypto_ecdsa.h"
+
+/*lint -save -e????*/
+#if !defined(MBEDTLS_CONFIG_FILE)
+#include "mbedtls/config.h"
+#else
+#include MBEDTLS_CONFIG_FILE
+#endif
+#include "mbedtls/ecp.h"
+#include "mbedtls/ecdsa.h"
+#include "mbedtls/sha256.h"
+#include "mbedtls/sha512.h"
+/*lint -restore*/
+
+
+ret_code_t nrf_crypto_backend_mbedtls_sign(
+    void           * p_context,
+    void     const * p_private_key,
+    uint8_t  const * p_data,
+    size_t           data_size,
+    uint8_t        * p_signature)
+{
+    int               result;
+    mbedtls_mpi       r_mpi;
+    mbedtls_mpi       s_mpi;
+    mbedtls_ecp_group group;
+
+    nrf_crypto_backend_mbedtls_ecc_private_key_t const * p_prv =
+        (nrf_crypto_backend_mbedtls_ecc_private_key_t const *)p_private_key;
+
+    nrf_crypto_ecc_curve_info_t const * p_info = p_prv->header.p_info;
+
+    if (!nrf_crypto_backend_mbedtls_ecc_group_load(&group, p_info))
+    {
+        return NRF_ERROR_CRYPTO_INTERNAL;
+    }
+
+    mbedtls_mpi_init(&r_mpi);
+    mbedtls_mpi_init(&s_mpi);
+    result = mbedtls_ecdsa_sign(&group,
+                                &r_mpi,
+                                &s_mpi,
+                                &p_prv->key,
+                                p_data,
+                                data_size,
+                                nrf_crypto_backend_mbedtls_ecc_mbedtls_rng,
+                                NULL);
+
+    mbedtls_ecp_group_free(&group);
+
+    if (result == 0)
+    {
+        result = mbedtls_mpi_write_binary(&r_mpi, p_signature, p_info->raw_private_key_size);
+        if (result == 0)
+        {
+            result = mbedtls_mpi_write_binary(&s_mpi,
+                                              &p_signature[p_info->raw_private_key_size],
+                                              p_info->raw_private_key_size);
+        }
+    }
+
+    mbedtls_mpi_free(&r_mpi);
+    mbedtls_mpi_free(&s_mpi);
+
+    if (result != 0)
+    {
+        return NRF_ERROR_CRYPTO_INTERNAL;
+    }
+    return NRF_SUCCESS;
+}
+
+
+ret_code_t nrf_crypto_backend_mbedtls_verify(
+    void           * p_context,
+    void     const * p_public_key,
+    uint8_t  const * p_data,
+    size_t           data_size,
+    uint8_t  const * p_signature)
+{
+    int               result;
+    mbedtls_mpi       r_mpi;
+    mbedtls_mpi       s_mpi;
+    mbedtls_ecp_group group;
+
+    nrf_crypto_backend_mbedtls_ecc_public_key_t const * p_pub =
+        (nrf_crypto_backend_mbedtls_ecc_public_key_t const *)p_public_key;
+
+    nrf_crypto_ecc_curve_info_t const * p_info = p_pub->header.p_info;
+
+    if (!nrf_crypto_backend_mbedtls_ecc_group_load(&group, p_info))
+    {
+        return NRF_ERROR_CRYPTO_INTERNAL;
+    }
+
+    mbedtls_mpi_init(&r_mpi);
+    mbedtls_mpi_init(&s_mpi);
+
+    result = mbedtls_mpi_read_binary(&r_mpi, p_signature, p_info->raw_private_key_size);
+    if (result == 0)
+    {
+        result = mbedtls_mpi_read_binary(&s_mpi,
+                                         &p_signature[p_info->raw_private_key_size],
+                                         p_info->raw_private_key_size);
+        if (result == 0)
+        {
+            result = mbedtls_ecdsa_verify(&group, p_data, data_size, &p_pub->key, &r_mpi, &s_mpi);
+        }
+    }
+
+    mbedtls_ecp_group_free(&group);
+    mbedtls_mpi_free(&r_mpi);
+    mbedtls_mpi_free(&s_mpi);
+
+    if (result == MBEDTLS_ERR_ECP_VERIFY_FAILED)
+    {
+        return NRF_ERROR_CRYPTO_ECDSA_INVALID_SIGNATURE;
+    }
+    else if (result != 0)
+    {
+        return NRF_ERROR_CRYPTO_INTERNAL;
+    }
+    return NRF_SUCCESS;
+}
+
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS)
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/mbedtls/mbedtls_backend_ecdsa.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/mbedtls/mbedtls_backend_ecdsa.h
new file mode 100644
index 0000000..7ad85a9
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/mbedtls/mbedtls_backend_ecdsa.h
@@ -0,0 +1,240 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef MBEDTLS_BACKEND_ECDSA_H__
+#define MBEDTLS_BACKEND_ECDSA_H__
+
+#include "sdk_config.h"
+#include "nordic_common.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS)
+
+#include "nrf_crypto_ecc_shared.h"
+#include "nrf_crypto_ecdsa_shared.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/** @internal See @ref nrf_crypto_backend_ecdsa_sign_fn_t.
+ */
+ret_code_t nrf_crypto_backend_mbedtls_sign(
+    void           * p_context,
+    void     const * p_private_key,
+    uint8_t  const * p_data,
+    size_t           data_size,
+    uint8_t        * p_signature);
+
+
+/** @internal See @ref nrf_crypto_backend_ecdsa_verify_fn_t.
+ */
+ret_code_t nrf_crypto_backend_mbedtls_verify(
+    void           * p_context,
+    void     const * p_public_key,
+    uint8_t  const * p_data,
+    size_t           data_size,
+    uint8_t  const * p_signature);
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_SECP192R1)
+// Context is not used by mbed TLS, so its size is 0
+#define NRF_CRYPTO_BACKEND_SECP192R1_SIGN_CONTEXT_SIZE   0
+#define NRF_CRYPTO_BACKEND_SECP192R1_VERIFY_CONTEXT_SIZE 0
+// Dummy typedefs for unused contexts
+typedef uint32_t nrf_crypto_backend_secp192r1_sign_context_t;
+typedef uint32_t nrf_crypto_backend_secp192r1_verify_context_t;
+// Alias for common mbed TLS
+#define nrf_crypto_backend_secp192r1_sign   nrf_crypto_backend_mbedtls_sign
+#define nrf_crypto_backend_secp192r1_verify nrf_crypto_backend_mbedtls_verify
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_SECP224R1)
+// Context is not used by mbed TLS, so its size is 0
+#define NRF_CRYPTO_BACKEND_SECP224R1_SIGN_CONTEXT_SIZE   0
+#define NRF_CRYPTO_BACKEND_SECP224R1_VERIFY_CONTEXT_SIZE 0
+// Dummy typedefs for unused contexts
+typedef uint32_t nrf_crypto_backend_secp224r1_sign_context_t;
+typedef uint32_t nrf_crypto_backend_secp224r1_verify_context_t;
+// Alias for common mbed TLS
+#define nrf_crypto_backend_secp224r1_sign   nrf_crypto_backend_mbedtls_sign
+#define nrf_crypto_backend_secp224r1_verify nrf_crypto_backend_mbedtls_verify
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_SECP256R1)
+// Context is not used by mbed TLS, so its size is 0
+#define NRF_CRYPTO_BACKEND_SECP256R1_SIGN_CONTEXT_SIZE   0
+#define NRF_CRYPTO_BACKEND_SECP256R1_VERIFY_CONTEXT_SIZE 0
+// Dummy typedefs for unused contexts
+typedef uint32_t nrf_crypto_backend_secp256r1_sign_context_t;
+typedef uint32_t nrf_crypto_backend_secp256r1_verify_context_t;
+// Alias for common mbed TLS
+#define nrf_crypto_backend_secp256r1_sign   nrf_crypto_backend_mbedtls_sign
+#define nrf_crypto_backend_secp256r1_verify nrf_crypto_backend_mbedtls_verify
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_SECP384R1)
+// Context is not used by mbed TLS, so its size is 0
+#define NRF_CRYPTO_BACKEND_SECP384R1_SIGN_CONTEXT_SIZE   0
+#define NRF_CRYPTO_BACKEND_SECP384R1_VERIFY_CONTEXT_SIZE 0
+// Dummy typedefs for unused contexts
+typedef uint32_t nrf_crypto_backend_secp384r1_sign_context_t;
+typedef uint32_t nrf_crypto_backend_secp384r1_verify_context_t;
+// Alias for common mbed TLS
+#define nrf_crypto_backend_secp384r1_sign   nrf_crypto_backend_mbedtls_sign
+#define nrf_crypto_backend_secp384r1_verify nrf_crypto_backend_mbedtls_verify
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_SECP521R1)
+// Context is not used by mbed TLS, so its size is 0
+#define NRF_CRYPTO_BACKEND_SECP521R1_SIGN_CONTEXT_SIZE   0
+#define NRF_CRYPTO_BACKEND_SECP521R1_VERIFY_CONTEXT_SIZE 0
+// Dummy typedefs for unused contexts
+typedef uint32_t nrf_crypto_backend_secp521r1_sign_context_t;
+typedef uint32_t nrf_crypto_backend_secp521r1_verify_context_t;
+// Alias for common mbed TLS
+#define nrf_crypto_backend_secp521r1_sign   nrf_crypto_backend_mbedtls_sign
+#define nrf_crypto_backend_secp521r1_verify nrf_crypto_backend_mbedtls_verify
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_SECP192K1)
+// Context is not used by mbed TLS, so its size is 0
+#define NRF_CRYPTO_BACKEND_SECP192K1_SIGN_CONTEXT_SIZE   0
+#define NRF_CRYPTO_BACKEND_SECP192K1_VERIFY_CONTEXT_SIZE 0
+// Dummy typedefs for unused contexts
+typedef uint32_t nrf_crypto_backend_secp192k1_sign_context_t;
+typedef uint32_t nrf_crypto_backend_secp192k1_verify_context_t;
+// Alias for common mbed TLS
+#define nrf_crypto_backend_secp192k1_sign   nrf_crypto_backend_mbedtls_sign
+#define nrf_crypto_backend_secp192k1_verify nrf_crypto_backend_mbedtls_verify
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_SECP224K1)
+// Context is not used by mbed TLS, so its size is 0
+#define NRF_CRYPTO_BACKEND_SECP224K1_SIGN_CONTEXT_SIZE   0
+#define NRF_CRYPTO_BACKEND_SECP224K1_VERIFY_CONTEXT_SIZE 0
+// Dummy typedefs for unused contexts
+typedef uint32_t nrf_crypto_backend_secp224k1_sign_context_t;
+typedef uint32_t nrf_crypto_backend_secp224k1_verify_context_t;
+// Alias for common mbed TLS
+#define nrf_crypto_backend_secp224k1_sign   nrf_crypto_backend_mbedtls_sign
+#define nrf_crypto_backend_secp224k1_verify nrf_crypto_backend_mbedtls_verify
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_SECP256K1)
+// Context is not used by mbed TLS, so its size is 0
+#define NRF_CRYPTO_BACKEND_SECP256K1_SIGN_CONTEXT_SIZE   0
+#define NRF_CRYPTO_BACKEND_SECP256K1_VERIFY_CONTEXT_SIZE 0
+// Dummy typedefs for unused contexts
+typedef uint32_t nrf_crypto_backend_secp256k1_sign_context_t;
+typedef uint32_t nrf_crypto_backend_secp256k1_verify_context_t;
+// Alias for common mbed TLS
+#define nrf_crypto_backend_secp256k1_sign   nrf_crypto_backend_mbedtls_sign
+#define nrf_crypto_backend_secp256k1_verify nrf_crypto_backend_mbedtls_verify
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_BP256R1)
+// Context is not used by mbed TLS, so its size is 0
+#define NRF_CRYPTO_BACKEND_BP256R1_SIGN_CONTEXT_SIZE   0
+#define NRF_CRYPTO_BACKEND_BP256R1_VERIFY_CONTEXT_SIZE 0
+// Dummy typedefs for unused contexts
+typedef uint32_t nrf_crypto_backend_bp256r1_sign_context_t;
+typedef uint32_t nrf_crypto_backend_bp256r1_verify_context_t;
+// Alias for common mbed TLS
+#define nrf_crypto_backend_bp256r1_sign   nrf_crypto_backend_mbedtls_sign
+#define nrf_crypto_backend_bp256r1_verify nrf_crypto_backend_mbedtls_verify
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_BP384R1)
+// Context is not used by mbed TLS, so its size is 0
+#define NRF_CRYPTO_BACKEND_BP384R1_SIGN_CONTEXT_SIZE   0
+#define NRF_CRYPTO_BACKEND_BP384R1_VERIFY_CONTEXT_SIZE 0
+// Dummy typedefs for unused contexts
+typedef uint32_t nrf_crypto_backend_bp384r1_sign_context_t;
+typedef uint32_t nrf_crypto_backend_bp384r1_verify_context_t;
+// Alias for common mbed TLS
+#define nrf_crypto_backend_bp384r1_sign   nrf_crypto_backend_mbedtls_sign
+#define nrf_crypto_backend_bp384r1_verify nrf_crypto_backend_mbedtls_verify
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_BP512R1)
+// Context is not used by mbed TLS, so its size is 0
+#define NRF_CRYPTO_BACKEND_BP512R1_SIGN_CONTEXT_SIZE   0
+#define NRF_CRYPTO_BACKEND_BP512R1_VERIFY_CONTEXT_SIZE 0
+// Dummy typedefs for unused contexts
+typedef uint32_t nrf_crypto_backend_bp512r1_sign_context_t;
+typedef uint32_t nrf_crypto_backend_bp512r1_verify_context_t;
+// Alias for common mbed TLS
+#define nrf_crypto_backend_bp512r1_sign   nrf_crypto_backend_mbedtls_sign
+#define nrf_crypto_backend_bp512r1_verify nrf_crypto_backend_mbedtls_verify
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_ECC_CURVE25519)
+// Context is not used by mbed TLS, so its size is 0
+#define NRF_CRYPTO_BACKEND_CURVE25519_SIGN_CONTEXT_SIZE   0
+#define NRF_CRYPTO_BACKEND_CURVE25519_VERIFY_CONTEXT_SIZE 0
+// Dummy typedefs for unused contexts
+typedef uint32_t nrf_crypto_backend_curve25519_sign_context_t;
+typedef uint32_t nrf_crypto_backend_curve25519_verify_context_t;
+// No ECDSA implementation for Curve25519
+#define nrf_crypto_backend_curve25519_sign   NULL
+#define nrf_crypto_backend_curve25519_verify NULL
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS)
+
+#endif // MBEDTLS_BACKEND_ECDSA_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/mbedtls/mbedtls_backend_hash.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/mbedtls/mbedtls_backend_hash.c
new file mode 100644
index 0000000..b244e0a
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/mbedtls/mbedtls_backend_hash.c
@@ -0,0 +1,196 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#include "sdk_common.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS)
+
+#include "mbedtls_backend_hash.h"
+#include "nrf_crypto_init.h"
+#include "nrf_crypto_types.h"
+#include "nrf_crypto_error.h"
+#include "nrf_crypto_hash_shared.h"
+#include "sdk_macros.h"
+#include "nrf_log.h"
+#include "nrf_assert.h"
+
+/*lint -save -e????*/
+#if !defined(MBEDTLS_CONFIG_FILE)
+#include "mbedtls/config.h"
+#else
+#include MBEDTLS_CONFIG_FILE
+#endif
+
+#include "mbedtls/md.h"
+#include "mbedtls/sha256.h"
+#include "mbedtls/sha512.h"
+/*lint -restore*/
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_HASH_SHA256)
+
+static ret_code_t mbedtls_backend_hash_sha256_init(void * const p_context)
+{
+    // No parameter testing on this level.
+    // This has been done on upper level.
+
+    mbedtls_sha256_context * p_backend_context
+        = &(((nrf_crypto_backend_hash_sha256_context_t *)p_context)->context);
+
+    mbedtls_sha256_init(p_backend_context);
+
+    mbedtls_sha256_starts(p_backend_context, 0);
+
+    return NRF_SUCCESS;
+}
+
+static uint32_t mbedtls_backend_hash_sha256_update(void     * const p_context,
+                                                   uint8_t  const * p_data,
+                                                   size_t           size)
+{
+    // Limited parameter testing on this level.
+    // This has been done on upper level.
+
+    mbedtls_sha256_context * p_backend_context
+        = &(((nrf_crypto_backend_hash_sha256_context_t *)p_context)->context);
+
+    mbedtls_sha256_update(p_backend_context, p_data, size);
+
+    return NRF_SUCCESS;
+}
+
+
+static uint32_t mbedtls_backend_hash_sha256_finalize(void       * const p_context,
+                                                     uint8_t          * p_digest,
+                                                     size_t     * const p_digest_size)
+{
+    // Limited parameter testing on this level.
+    // This has been done on upper level.
+
+    mbedtls_sha256_context * p_backend_context
+        = &(((nrf_crypto_backend_hash_sha256_context_t *)p_context)->context);
+
+    mbedtls_sha256_finish(p_backend_context, p_digest);
+
+    *p_digest_size = NRF_CRYPTO_HASH_SIZE_SHA256;
+
+    return NRF_SUCCESS;
+}
+
+
+const nrf_crypto_hash_info_t g_nrf_crypto_hash_sha256_info =
+{
+    .init_fn        = mbedtls_backend_hash_sha256_init,
+    .update_fn      = mbedtls_backend_hash_sha256_update,
+    .finalize_fn    = mbedtls_backend_hash_sha256_finalize,
+    .digest_size    = NRF_CRYPTO_HASH_SIZE_SHA256,
+    .context_size   = sizeof(nrf_crypto_backend_hash_sha256_context_t),
+    .hash_mode      = NRF_CRYPTO_HASH_MODE_SHA256
+};
+
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_HASH_SHA256)
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_HASH_SHA512)
+
+
+static ret_code_t mbedtls_backend_hash_sha512_init(void * p_context)
+{
+    // No parameter testing on this level.
+    // This has been done on upper level.
+
+    mbedtls_sha512_context * p_backend_context
+        = &(((nrf_crypto_backend_hash_sha512_context_t *)p_context)->context);
+
+    mbedtls_sha512_init(p_backend_context);
+
+    mbedtls_sha512_starts(p_backend_context, 0);
+
+    return NRF_SUCCESS;
+}
+
+
+static ret_code_t mbedtls_backend_hash_sha512_update(void       * const p_context,
+                                                     uint8_t    const * p_data,
+                                                     size_t             size)
+{
+    // Limited parameter testing on this level.
+    // This has been done on upper level.
+
+    mbedtls_sha512_context * p_backend_context
+        = &(((nrf_crypto_backend_hash_sha512_context_t *)p_context)->context);
+
+    mbedtls_sha512_update(p_backend_context, p_data, size);
+
+    return NRF_SUCCESS;
+}
+
+
+static ret_code_t mbedtls_backend_hash_sha512_finalize(void     * const p_context,
+                                                       uint8_t        * p_digest,
+                                                       size_t   * const p_digest_size)
+{
+    // Limited parameter testing on this level.
+    // This has been done on upper level.
+
+    mbedtls_sha512_context * p_backend_context
+        = &(((nrf_crypto_backend_hash_sha512_context_t *)p_context)->context);
+
+    mbedtls_sha512_finish(p_backend_context, p_digest);
+
+    *p_digest_size = NRF_CRYPTO_HASH_SIZE_SHA512;
+
+    return NRF_SUCCESS;
+}
+
+
+const nrf_crypto_hash_info_t g_nrf_crypto_hash_sha512_info =
+{
+    .init_fn        = mbedtls_backend_hash_sha512_init,
+    .update_fn      = mbedtls_backend_hash_sha512_update,
+    .finalize_fn    = mbedtls_backend_hash_sha512_finalize,
+    .digest_size    = NRF_CRYPTO_HASH_SIZE_SHA512,
+    .context_size   = sizeof(nrf_crypto_backend_hash_sha512_context_t),
+    .hash_mode      = NRF_CRYPTO_HASH_MODE_SHA512
+};
+
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_HASH_SHA512)
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS)
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/mbedtls/mbedtls_backend_hash.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/mbedtls/mbedtls_backend_hash.h
new file mode 100644
index 0000000..f69be9b
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/mbedtls/mbedtls_backend_hash.h
@@ -0,0 +1,128 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef MBEDTLS_BACKEND_HASH_H__
+#define MBEDTLS_BACKEND_HASH_H__
+
+/** @file
+ *
+ * @defgroup nrf_crypto_mbedtls_backend_hash nrf_crypto mbedtls backend hash
+ * @{
+ * @ingroup nrf_crypto_mbedtls_backend
+ *
+ * @brief Hash functionality provided by the nrf_crypto mbedtls backend.
+ */
+
+#include "sdk_common.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS)
+
+#include "sdk_errors.h"
+#include "nrf_crypto_hash_shared.h"
+
+/*lint -save -e????*/
+#include "mbedtls/sha256.h"
+#include "mbedtls/sha512.h"
+/*lint -restore*/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_HASH_SHA256)
+
+// Flag that nrf_crypto_hash frontend can be compiled
+#undef  NRF_CRYPTO_HASH_ENABLED
+#define NRF_CRYPTO_HASH_ENABLED 1
+
+// Duplicate backend enabled test for SHA-256
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_HASH_SHA256)
+#error "Duplicate definition of SHA-256. More than one backend enabled");
+#endif
+
+// Flag that SHA-256 is enabled in backend
+#define NRF_CRYPTO_HASH_SHA256_ENABLED 1
+
+
+/**brief nrf_crypto_hash context for SHA-256 in nrf_crypto mbedtls backend. */
+typedef struct
+{
+    nrf_crypto_hash_internal_context_t  header;         /**< Common header for context. */
+    mbedtls_sha256_context              context;        /**< Hash context internal to mbedtls. */
+} nrf_crypto_backend_hash_sha256_context_t;
+
+
+#endif // NRF_CRYPTO_BACKEND_MBEDTLS_HASH_SHA256_ENABLED
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_HASH_SHA512)
+
+// Flag that nrf_crypto_hash frontend can be compiled
+#undef  NRF_CRYPTO_HASH_ENABLED
+#define NRF_CRYPTO_HASH_ENABLED 1
+
+// Duplicate backend enabled test for SHA-512
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_HASH_SHA512)
+#error "Duplicate definition of SHA-512. More than one backend enabled");
+#endif
+
+// Flag that SHA-512 is enabled in backend
+#define NRF_CRYPTO_HASH_SHA512_ENABLED 1
+
+
+/**brief nrf_crypto_hash context for SHA-512 in nrf_crypto mbedtls backend. */
+typedef struct
+{
+    nrf_crypto_hash_internal_context_t  header;         /**< Common header for context. */
+    mbedtls_sha512_context              context;        /**< Hash context internal to mbedtls. */
+} nrf_crypto_backend_hash_sha512_context_t;
+
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_HASH_SHA512)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS)
+
+/**@} */
+
+#endif //MBEDTLS_BACKEND_HASH_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/mbedtls/mbedtls_backend_hmac.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/mbedtls/mbedtls_backend_hmac.c
new file mode 100644
index 0000000..0a6658c
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/mbedtls/mbedtls_backend_hmac.c
@@ -0,0 +1,230 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#include "sdk_common.h"
+#if NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS)
+
+#include "nrf_log.h"
+#include "nrf_crypto_error.h"
+#include "nrf_crypto_types.h"
+#include "mbedtls_backend_hmac.h"
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_HMAC_SHA256)
+
+static ret_code_t mbedtls_backend_hmac_init_sha256(void     * const p_context,
+                                                   uint8_t  const * p_key,
+                                                   size_t           key_size)
+{
+    int err_code;
+    nrf_crypto_backend_mbedtls_hmac_sha256_context_t * p_ctx =
+        (nrf_crypto_backend_mbedtls_hmac_sha256_context_t *)p_context;
+
+    // Memset context to 0. This is equevalend with a call to mbedtls_md_init().
+    memset(p_ctx->md_ctx_buffer, 0, sizeof(p_ctx->md_ctx_buffer));
+    memset(p_ctx->hmac_ctx_buffer, 0, sizeof(p_ctx->hmac_ctx_buffer));
+
+    // Set info and context pointers to buffer allocated by user.
+    // This is Normally handled by mbedtls_md_setup(), but has to be done here in order
+    // to avoid dynamic allocation of memory inside mbed TLS.
+    p_ctx->mbedtls_ctx.md_info = mbedtls_md_info_from_type(MBEDTLS_MD_SHA256);
+    p_ctx->mbedtls_ctx.md_ctx = p_ctx->md_ctx_buffer;
+    p_ctx->mbedtls_ctx.hmac_ctx = p_ctx->hmac_ctx_buffer;
+
+    // Enter key to start
+    err_code = mbedtls_md_hmac_starts(&p_ctx->mbedtls_ctx,
+                                      p_key,
+                                      key_size);
+
+    if (err_code != 0)
+    {
+        NRF_LOG_ERROR("Error in mbedtls_md_hmac_starts: %u", err_code);
+        return NRF_ERROR_CRYPTO_INTERNAL;
+    }
+
+    return NRF_SUCCESS;
+}
+
+
+static ret_code_t mbedtls_backend_hmac_update_sha256(void       * const p_context,
+                                                     uint8_t    const * p_data,
+                                                     size_t             size)
+{
+    int err_code;
+    nrf_crypto_backend_mbedtls_hmac_sha256_context_t * p_ctx =
+        (nrf_crypto_backend_mbedtls_hmac_sha256_context_t *)p_context;
+
+    err_code = mbedtls_md_hmac_update(&p_ctx->mbedtls_ctx, p_data, size);
+    if (err_code != 0)
+    {
+        NRF_LOG_ERROR("Error in mbedtls_md_hmac_update: %u", err_code);
+        return NRF_ERROR_CRYPTO_INTERNAL;
+    }
+
+    return NRF_SUCCESS;
+}
+
+
+static ret_code_t mbedtls_backend_hmac_finalize_sha256(void     * const p_context,
+                                                       uint8_t        * p_digest,
+                                                       size_t   * const p_size)
+{
+    int err_code;
+    nrf_crypto_backend_mbedtls_hmac_sha256_context_t * const p_ctx =
+        (nrf_crypto_backend_mbedtls_hmac_sha256_context_t *)p_context;
+
+    // Set the digest length to 0 so that this is used in case of any error.
+    *p_size = 0;
+
+    err_code = mbedtls_md_hmac_finish(&p_ctx->mbedtls_ctx, p_digest);
+    if (err_code != 0)
+    {
+        NRF_LOG_ERROR("Error in mbedtls_md_hmac_finish: %u", err_code);
+        return NRF_ERROR_CRYPTO_INTERNAL;
+    }
+
+    *p_size = p_ctx->header.p_info->digest_size;
+
+    return NRF_SUCCESS;
+}
+
+
+// Information structure for HMAC SHA256 using mbed TLS backend.
+const nrf_crypto_hmac_info_t g_nrf_crypto_hmac_sha256_info =
+{
+    .init_fn        = mbedtls_backend_hmac_init_sha256,
+    .update_fn      = mbedtls_backend_hmac_update_sha256,
+    .finalize_fn    = mbedtls_backend_hmac_finalize_sha256,
+    .digest_size    = NRF_CRYPTO_HASH_SIZE_SHA256,
+    .context_size   = sizeof(nrf_crypto_backend_hmac_sha256_context_t),
+    .type           = NRF_CRYPTO_HMAC_SHA256_TYPE
+};
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_HMAC_SHA256)
+
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_HMAC_SHA512)
+
+static ret_code_t mbedtls_backend_hmac_init_sha512(void     * const p_context,
+                                                   uint8_t  const * p_key,
+                                                   size_t           key_size)
+{
+    int err_code;
+    nrf_crypto_backend_mbedtls_hmac_sha512_context_t * p_ctx =
+        (nrf_crypto_backend_mbedtls_hmac_sha512_context_t *)p_context;
+
+    // Memset context to 0. This is equevalend with a call to mbedtls_md_init().
+    memset(p_ctx->md_ctx_buffer, 0, sizeof(p_ctx->md_ctx_buffer));
+    memset(p_ctx->hmac_ctx_buffer, 0, sizeof(p_ctx->hmac_ctx_buffer));
+
+    // Set info and context pointers to buffer allocated by user.
+    // (Normally handled by mbedtls_md_setup())
+    p_ctx->mbedtls_ctx.md_info = mbedtls_md_info_from_type(MBEDTLS_MD_SHA512);
+    p_ctx->mbedtls_ctx.md_ctx = p_ctx->md_ctx_buffer;
+    p_ctx->mbedtls_ctx.hmac_ctx = p_ctx->hmac_ctx_buffer;
+
+    // Enter key to start
+    err_code = mbedtls_md_hmac_starts(&p_ctx->mbedtls_ctx, p_key, key_size);
+    if (err_code != 0)
+    {
+        NRF_LOG_ERROR("Error in mbedtls_md_hmac_starts: %u", err_code);
+        return NRF_ERROR_CRYPTO_INTERNAL;
+    }
+
+    return NRF_SUCCESS;
+}
+
+
+static ret_code_t mbedtls_backend_hmac_update_sha512(void       * const p_context,
+                                                     uint8_t    const * p_data,
+                                                     size_t             size)
+{
+    int err_code;
+    nrf_crypto_backend_mbedtls_hmac_sha512_context_t * p_ctx =
+        (nrf_crypto_backend_mbedtls_hmac_sha512_context_t *)p_context;
+
+    err_code = mbedtls_md_hmac_update(&p_ctx->mbedtls_ctx, p_data, size);
+    if (err_code != 0)
+    {
+        NRF_LOG_ERROR("Error in mbedtls_md_hmac_update: %u", err_code);
+        return NRF_ERROR_CRYPTO_INTERNAL;
+    }
+
+    return NRF_SUCCESS;
+}
+
+
+static ret_code_t mbedtls_backend_hmac_finalize_sha512(void     * const p_context,
+                                                       uint8_t        * p_digest,
+                                                       size_t   * const p_size)
+{
+    int err_code;
+    nrf_crypto_backend_mbedtls_hmac_sha512_context_t * p_ctx =
+        (nrf_crypto_backend_mbedtls_hmac_sha512_context_t *)p_context;
+
+    // Set the digest length to 0 so that this is used in case of any error.
+    *p_size = 0;
+
+    err_code = mbedtls_md_hmac_finish(&p_ctx->mbedtls_ctx, p_digest);
+    if (err_code != 0)
+    {
+        NRF_LOG_ERROR("Error in mbedtls_md_hmac_finish: %u", err_code);
+        return NRF_ERROR_CRYPTO_INTERNAL;    }
+
+    *p_size = p_ctx->header.p_info->digest_size;
+
+    return NRF_SUCCESS;
+}
+
+
+// Information structure for HMAC SHA512 using mbed TLS backend.
+const nrf_crypto_hmac_info_t g_nrf_crypto_hmac_sha512_info =
+{
+    .init_fn        = mbedtls_backend_hmac_init_sha512,
+    .update_fn      = mbedtls_backend_hmac_update_sha512,
+    .finalize_fn    = mbedtls_backend_hmac_finalize_sha512,
+    .digest_size    = NRF_CRYPTO_HASH_SIZE_SHA512,
+    .context_size   = sizeof(nrf_crypto_backend_hmac_sha512_context_t),
+    .type           = NRF_CRYPTO_HMAC_SHA512_TYPE
+};
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_HMAC_SHA512)
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS)
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/mbedtls/mbedtls_backend_hmac.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/mbedtls/mbedtls_backend_hmac.h
new file mode 100644
index 0000000..2645bba
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/mbedtls/mbedtls_backend_hmac.h
@@ -0,0 +1,140 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef MBEDTLS_BACKEND_HMAC_H__
+#define MBEDTLS_BACKEND_HMAC_H__
+
+/** @file
+ *
+ * @defgroup nrf_crypto_mbedtls_backend_hmac mbed TLS backend for HMAC
+ * @{
+ * @ingroup nrf_crypto_mbedtls_backend
+ *
+ * @brief Backend wrapper for mbed TLS. None of these types should be used directly by the
+ * application.
+ */
+
+#include "sdk_common.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS) &&                   \
+        ( NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_HMAC_SHA256) || \
+          NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_HMAC_SHA512) )
+
+#include "nrf_crypto_hmac_shared.h"
+/*lint -save -e????*/
+#include "mbedtls/md.h"
+#include "mbedtls/sha256.h"
+#include "mbedtls/sha512.h"
+/*lint -restore*/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#undef  NRF_CRYPTO_HMAC_ENABLED
+#define NRF_CRYPTO_HMAC_ENABLED 1
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_HMAC_SHA256)
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_HMAC_SHA256)
+#error "Duplicate definition of HMAC SHA-256. More than one backend enabled"
+#endif // NRF_CRYPTO_HMAC_SHA256_ENABLED
+#define NRF_CRYPTO_HMAC_SHA256_ENABLED 1
+
+/**
+ * @internal @brief Internal context object used by the mbed TLS backend wrapper for HMAC SHA256.
+ *
+ * @note This should never be used directly. Use @ref nrf_crypto_backend_hmac_sha256_context_t
+ * instead.
+ */
+typedef struct
+{
+    nrf_crypto_hmac_internal_context_t  header;                                         //!< Internal nrf_crypto_hmac context.
+    mbedtls_md_context_t                mbedtls_ctx;                                    //!< Mbed TLS context object.
+    uint8_t                             md_ctx_buffer[sizeof(mbedtls_sha256_context)];  //!< Message digest buffer for mbed TLS.
+    uint16_t                            hmac_ctx_buffer[64];                            //!< Hash buffer for mbed TLS of size defined in mbedtls_sha256_info in md_internal.h.
+} nrf_crypto_backend_mbedtls_hmac_sha256_context_t;
+
+/**
+ * @internal @brief Context for HMAC SHA256 using mbed TLS backend.
+ */
+typedef nrf_crypto_backend_mbedtls_hmac_sha256_context_t nrf_crypto_backend_hmac_sha256_context_t;
+
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_HMAC_SHA256)
+
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_HMAC_SHA512)
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_HMAC_SHA512)
+#error "Duplicate definition of HMAC SHA-512. More than one backend enabled"
+#endif // NRF_CRYPTO_HMAC_SHA512_ENABLED
+#define NRF_CRYPTO_HMAC_SHA512_ENABLED 1
+
+/**
+ * @internal @brief Internal context object used by the mbed TLS backend wrapper for HMAC SHA512.
+ *
+ * @note This should never be used directly. Use @ref nrf_crypto_backend_hmac_sha512_context_t
+ * instead.
+ */
+typedef struct
+{
+    nrf_crypto_hmac_internal_context_t  header;                                         //!< Internal nrf_crypto_hmac context header.
+    mbedtls_md_context_t                mbedtls_ctx;                                    //!< Mbed TLS context object.
+    uint8_t                             md_ctx_buffer[sizeof(mbedtls_sha512_context)];  //!< Message digest buffer for mbed TLS.
+    uint16_t                            hmac_ctx_buffer[128];                           //!< Hash buffer for mbed TLS of size defined in mbedtls_sha512_info in md_internal.h.
+} nrf_crypto_backend_mbedtls_hmac_sha512_context_t;
+
+/**
+ * @internal @brief Context for HMAC SHA512 using mbed TLS backend.
+ */
+typedef nrf_crypto_backend_mbedtls_hmac_sha512_context_t nrf_crypto_backend_hmac_sha512_context_t;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_HMAC_SHA512)
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS) && ( NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_HMAC_SHA256) || NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS_HMAC_SHA512) )
+
+/**@} */
+
+#endif // MBEDTLS_BACKEND_HMAC_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/mbedtls/mbedtls_backend_init.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/mbedtls/mbedtls_backend_init.c
new file mode 100644
index 0000000..aa37d67
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/mbedtls/mbedtls_backend_init.c
@@ -0,0 +1,106 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#include "sdk_common.h"
+#include "sdk_config.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS)
+
+#include <string.h>
+#include <stdint.h>
+#include "nrf_crypto_init.h"
+#include "nrf_crypto_mem.h"
+/*lint -save -e????*/
+#include "mbedtls/platform.h"
+/*lint -restore*/
+
+
+#if NRF_CRYPTO_ALLOC_ON_STACK
+#error "MBED TLS backend does not support memory allocation on stack. Use different allocator."
+#endif
+
+
+/** @internal @brief Function to use NRF_CRYPTO_ALLOC for MBED TLS memory allocation.
+ */
+static void * mbedtls_backend_calloc(size_t count, size_t size)
+{
+    size_t total_size = count * size;
+    void * p_data = NRF_CRYPTO_ALLOC(total_size);
+    if (p_data != NULL)
+    {
+        memset(p_data, 0, total_size);
+    }
+    return p_data;
+}
+
+
+/** @internal @brief Function to use NRF_CRYPTO_FREE for MBED TLS memory deallocation.
+ */
+static void mbedtls_backend_free(void * p_data)
+{
+    NRF_CRYPTO_FREE(p_data);
+}
+
+
+/** @internal @brief Function to initialize MBED TLS backend - setup memory management for.
+ */
+static ret_code_t mbedtls_backend_init(void)
+{
+    (void)mbedtls_platform_set_calloc_free(mbedtls_backend_calloc, mbedtls_backend_free);
+    return NRF_SUCCESS;
+}
+
+
+/** @internal @brief Function to uninitialize MBED TLS backend - currently no implementation is required.
+ */
+static ret_code_t mbedtls_backend_uninit(void)
+{
+    // Empty implementation
+    return NRF_SUCCESS;
+}
+
+
+CRYPTO_BACKEND_REGISTER(nrf_crypto_backend_info_t const mbedtls_backend) =
+{
+    .init_fn    = mbedtls_backend_init,
+    .uninit_fn  = mbedtls_backend_uninit,
+};
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS)
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/micro_ecc/micro_ecc_backend_ecc.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/micro_ecc/micro_ecc_backend_ecc.c
new file mode 100644
index 0000000..534d756
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/micro_ecc/micro_ecc_backend_ecc.c
@@ -0,0 +1,352 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#include "sdk_config.h"
+#include "nordic_common.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MICRO_ECC)
+
+#include <stdbool.h>
+#include <string.h>
+#include <stddef.h>
+
+#include "app_util.h"
+#include "nrf_crypto_ecc.h"
+#include "nrf_crypto_rng.h"
+#include "nrf_crypto_shared.h"
+#include "micro_ecc_backend_ecc.h"
+#include "micro_ecc_backend_shared.h"
+#include "uECC.h"
+
+
+typedef uECC_Curve (*micro_ecc_curve_fn_t)(void);
+
+
+int nrf_crypto_backend_micro_ecc_rng_callback(uint8_t * dest, unsigned size)
+{
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_RNG)
+
+    ret_code_t result;
+
+    result = nrf_crypto_rng_vector_generate(dest, size);
+
+    // Return values compatible with mbed TLS
+    if (result != NRF_SUCCESS)
+    {
+        return 0;
+    }
+    return 1;
+
+#else
+    UNUSED_PARAMETER(dest);
+    UNUSED_PARAMETER(size);
+    return 0;
+#endif
+}
+
+
+uECC_Curve nrf_crypto_backend_micro_ecc_curve_get(
+    nrf_crypto_backend_micro_ecc_common_key_t const * p_key)
+{
+    nrf_crypto_internal_ecc_key_header_t const * p_key_header =
+        (nrf_crypto_internal_ecc_key_header_t const *)p_key;
+
+    //lint -save -e611 (Suspicious cast)
+    micro_ecc_curve_fn_t micro_ecc_curve_fn =
+        (micro_ecc_curve_fn_t)p_key_header->p_info->p_backend_data;
+    //lint -restore
+
+    uECC_Curve p_micro_ecc_curve = micro_ecc_curve_fn();
+
+    return p_micro_ecc_curve;
+}
+
+
+ret_code_t nrf_crypto_backend_micro_ecc_key_pair_generate(
+    void * p_context,
+    void * p_private_key,
+    void * p_public_key)
+{
+    int result;
+
+    nrf_crypto_backend_micro_ecc_common_key_t * p_prv =
+        (nrf_crypto_backend_micro_ecc_common_key_t *)p_private_key;
+    nrf_crypto_backend_micro_ecc_common_key_t * p_pub =
+        (nrf_crypto_backend_micro_ecc_common_key_t *)p_public_key;
+
+    uECC_Curve p_micro_ecc_curve = nrf_crypto_backend_micro_ecc_curve_get(p_prv);
+
+    uECC_set_rng(nrf_crypto_backend_micro_ecc_rng_callback);
+
+    result = uECC_make_key((uint8_t *)(&p_pub->key[0]),
+                           (uint8_t *)(&p_prv->key[0]),
+                           p_micro_ecc_curve);
+
+    if (result == 0)
+    {
+        return NRF_ERROR_CRYPTO_INTERNAL;
+    }
+    return NRF_SUCCESS;
+}
+
+
+ret_code_t nrf_crypto_backend_micro_ecc_public_key_calculate(
+    void       * p_context,
+    void const * p_private_key,
+    void       * p_public_key)
+{
+    int result;
+
+    nrf_crypto_backend_micro_ecc_common_key_t const * p_prv =
+        (nrf_crypto_backend_micro_ecc_common_key_t const *)p_private_key;
+    nrf_crypto_backend_micro_ecc_common_key_t       * p_pub =
+        (nrf_crypto_backend_micro_ecc_common_key_t *)p_public_key;
+
+    uECC_Curve p_micro_ecc_curve = nrf_crypto_backend_micro_ecc_curve_get(p_prv);
+
+    result = uECC_compute_public_key((uint8_t *)(&p_prv->key[0]),
+                                     (uint8_t *)(&p_pub->key[0]),
+                                     p_micro_ecc_curve);
+
+    if (result == 0)
+    {
+        return NRF_ERROR_CRYPTO_INTERNAL;
+    }
+    return NRF_SUCCESS;
+}
+
+
+ret_code_t nrf_crypto_backend_micro_ecc_private_key_from_raw(
+    void          * p_private_key,
+    uint8_t const * p_raw_data)
+{
+    nrf_crypto_backend_micro_ecc_common_key_t * p_prv =
+        (nrf_crypto_backend_micro_ecc_common_key_t *)p_private_key;
+
+    nrf_crypto_ecc_curve_info_t const * p_info = p_prv->header.p_info;
+
+#if ECC_BACKEND_SWAP_BYTES
+    nrf_crypto_internal_swap_endian((uint8_t *)(&p_prv->key[0]),
+                                    p_raw_data,
+                                    p_info->raw_private_key_size);
+#else
+    memcpy(&p_prv->key[0], p_raw_data, p_info->raw_private_key_size);
+#endif
+
+    return NRF_SUCCESS;
+}
+
+
+ret_code_t nrf_crypto_backend_micro_ecc_private_key_to_raw(
+    void    const * p_private_key,
+    uint8_t       * p_raw_data)
+{
+    nrf_crypto_backend_micro_ecc_common_key_t const * p_prv =
+        (nrf_crypto_backend_micro_ecc_common_key_t const *)p_private_key;
+
+    nrf_crypto_ecc_curve_info_t const * p_info = p_prv->header.p_info;
+
+#if ECC_BACKEND_SWAP_BYTES
+    nrf_crypto_internal_swap_endian(p_raw_data,
+                                    (uint8_t *)(&p_prv->key[0]),
+                                    p_info->raw_private_key_size);
+#else
+    memcpy(p_raw_data, &p_prv->key[0], p_info->raw_private_key_size);
+#endif
+
+    return NRF_SUCCESS;
+}
+
+
+ret_code_t nrf_crypto_backend_micro_ecc_public_key_from_raw(
+    void          * p_public_key,
+    uint8_t const * p_raw_data)
+{
+    nrf_crypto_backend_micro_ecc_common_key_t * p_pub =
+        (nrf_crypto_backend_micro_ecc_common_key_t *)p_public_key;
+
+    nrf_crypto_ecc_curve_info_t const * p_info = p_pub->header.p_info;
+
+    uECC_Curve p_micro_ecc_curve = nrf_crypto_backend_micro_ecc_curve_get(p_pub);
+
+#if ECC_BACKEND_SWAP_BYTES
+    nrf_crypto_internal_double_swap_endian((uint8_t *)(&p_pub->key[0]),
+                                           p_raw_data,
+                                           p_info->raw_private_key_size);
+#else
+    memcpy(&p_pub->key[0], p_raw_data, p_info->raw_public_key_size);
+#endif
+
+#if !NRF_CRYPTO_BACKEND_MICRO_ECC_PUBLIC_KEY_TRUSTED_ENABLED
+    if (!uECC_valid_public_key((uint8_t *)(&p_pub->key[0]), p_micro_ecc_curve))
+    {
+        return NRF_ERROR_CRYPTO_ECC_INVALID_KEY;
+    }
+#else
+    UNUSED_PARAMETER(p_micro_ecc_curve);
+#endif
+
+    return NRF_SUCCESS;
+}
+
+
+ret_code_t nrf_crypto_backend_micro_ecc_public_key_to_raw(
+    void const * p_public_key,
+    uint8_t    * p_raw_data)
+{
+    nrf_crypto_backend_micro_ecc_common_key_t const * p_pub =
+        (nrf_crypto_backend_micro_ecc_common_key_t const *)p_public_key;
+
+    nrf_crypto_ecc_curve_info_t const * p_info = p_pub->header.p_info;
+
+#if ECC_BACKEND_SWAP_BYTES
+    nrf_crypto_internal_double_swap_endian(p_raw_data,
+                                           (uint8_t *)(&p_pub->key[0]),
+                                           p_info->raw_private_key_size);
+#else
+    memcpy(p_raw_data, &p_pub->key[0], p_info->raw_public_key_size);
+#endif
+
+    return NRF_SUCCESS;
+}
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MICRO_ECC_ECC_SECP192R1)
+
+// Make sure that common key structure match secp192r1 (NIST 192-bit) key structure to safely cast types.
+STATIC_ASSERT(offsetof(nrf_crypto_backend_micro_ecc_common_key_t, key) ==
+              offsetof(nrf_crypto_backend_secp192r1_private_key_t, key),
+              "Common uECC private key structure does not match secp192r1 (NIST 192-bit) one.");
+STATIC_ASSERT(offsetof(nrf_crypto_backend_micro_ecc_common_key_t, key) ==
+              offsetof(nrf_crypto_backend_secp192r1_public_key_t, key),
+              "Common ECC public key structure does not match secp192r1 (NIST 192-bit) one.");
+
+const nrf_crypto_ecc_curve_info_t g_nrf_crypto_ecc_secp192r1_curve_info =
+{
+    .public_key_size      = sizeof(nrf_crypto_backend_secp192r1_private_key_t),
+    .private_key_size     = sizeof(nrf_crypto_backend_secp192r1_public_key_t),
+    .curve_type           = NRF_CRYPTO_ECC_SECP192R1_CURVE_TYPE,
+    .raw_private_key_size = NRF_CRYPTO_ECC_SECP192R1_RAW_PRIVATE_KEY_SIZE,
+    .raw_public_key_size  = NRF_CRYPTO_ECC_SECP192R1_RAW_PUBLIC_KEY_SIZE,
+    //lint -save -e611 -e546 (Suspicious cast, Suspicious use of &)
+    .p_backend_data       = (void *)&uECC_secp192r1,
+    //lint -restore
+};
+
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MICRO_ECC_ECC_SECP224R1)
+
+// Make sure that common key structure match secp224r1 (NIST 224-bit) key structure to safely cast types.
+STATIC_ASSERT(offsetof(nrf_crypto_backend_micro_ecc_common_key_t, key) ==
+              offsetof(nrf_crypto_backend_secp224r1_private_key_t, key),
+              "Common uECC private key structure does not match secp224r1 (NIST 224-bit) one.");
+STATIC_ASSERT(offsetof(nrf_crypto_backend_micro_ecc_common_key_t, key) ==
+              offsetof(nrf_crypto_backend_secp224r1_public_key_t, key),
+              "Common ECC public key structure does not match secp224r1 (NIST 224-bit) one.");
+
+const nrf_crypto_ecc_curve_info_t g_nrf_crypto_ecc_secp224r1_curve_info =
+{
+    .public_key_size      = sizeof(nrf_crypto_backend_secp224r1_private_key_t),
+    .private_key_size     = sizeof(nrf_crypto_backend_secp224r1_public_key_t),
+    .curve_type           = NRF_CRYPTO_ECC_SECP224R1_CURVE_TYPE,
+    .raw_private_key_size = NRF_CRYPTO_ECC_SECP224R1_RAW_PRIVATE_KEY_SIZE,
+    .raw_public_key_size  = NRF_CRYPTO_ECC_SECP224R1_RAW_PUBLIC_KEY_SIZE,
+    //lint -save -e611 -e546 (Suspicious cast, Suspicious use of &)
+    .p_backend_data       = (void *)&uECC_secp224r1,
+    //lint -restore
+};
+
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MICRO_ECC_ECC_SECP256R1)
+
+// Make sure that common key structure match secp256r1 (NIST 256-bit) key structure to safely cast types.
+STATIC_ASSERT(offsetof(nrf_crypto_backend_micro_ecc_common_key_t, key) ==
+              offsetof(nrf_crypto_backend_secp256r1_private_key_t, key),
+              "Common uECC private key structure does not match secp256r1 (NIST 256-bit) one.");
+STATIC_ASSERT(offsetof(nrf_crypto_backend_micro_ecc_common_key_t, key) ==
+              offsetof(nrf_crypto_backend_secp256r1_public_key_t, key),
+              "Common ECC public key structure does not match secp256r1 (NIST 256-bit) one.");
+
+const nrf_crypto_ecc_curve_info_t g_nrf_crypto_ecc_secp256r1_curve_info =
+{
+    .public_key_size      = sizeof(nrf_crypto_backend_secp256r1_private_key_t),
+    .private_key_size     = sizeof(nrf_crypto_backend_secp256r1_public_key_t),
+    .curve_type           = NRF_CRYPTO_ECC_SECP256R1_CURVE_TYPE,
+    .raw_private_key_size = NRF_CRYPTO_ECC_SECP256R1_RAW_PRIVATE_KEY_SIZE,
+    .raw_public_key_size  = NRF_CRYPTO_ECC_SECP256R1_RAW_PUBLIC_KEY_SIZE,
+    //lint -save -e611 -e546 (Suspicious cast, Suspicious use of &)
+    .p_backend_data       = (void *)&uECC_secp256r1,
+    //lint -restore
+};
+
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MICRO_ECC_ECC_SECP256K1)
+
+// Make sure that common key structure match secp256k1 (Koblitz 256-bit) key structure to safely cast types.
+STATIC_ASSERT(offsetof(nrf_crypto_backend_micro_ecc_common_key_t, key) ==
+              offsetof(nrf_crypto_backend_secp256k1_private_key_t, key),
+              "Common uECC private key structure does not match secp256k1 (Koblitz 256-bit) one.");
+STATIC_ASSERT(offsetof(nrf_crypto_backend_micro_ecc_common_key_t, key) ==
+              offsetof(nrf_crypto_backend_secp256k1_public_key_t, key),
+              "Common ECC public key structure does not match secp256k1 (Koblitz 256-bit) one.");
+
+
+const nrf_crypto_ecc_curve_info_t g_nrf_crypto_ecc_secp256k1_curve_info =
+{
+    .public_key_size      = sizeof(nrf_crypto_backend_secp256k1_private_key_t),
+    .private_key_size     = sizeof(nrf_crypto_backend_secp256k1_public_key_t),
+    .curve_type           = NRF_CRYPTO_ECC_SECP256K1_CURVE_TYPE,
+    .raw_private_key_size = NRF_CRYPTO_ECC_SECP256K1_RAW_PRIVATE_KEY_SIZE,
+    .raw_public_key_size  = NRF_CRYPTO_ECC_SECP256K1_RAW_PUBLIC_KEY_SIZE,
+    //lint -save -e611 -e546 (Suspicious cast, Suspicious use of &)
+    .p_backend_data       = (void *)&uECC_secp256k1,
+    //lint -restore
+};
+
+#endif
+
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MICRO_ECC)
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/micro_ecc/micro_ecc_backend_ecc.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/micro_ecc/micro_ecc_backend_ecc.h
new file mode 100644
index 0000000..cafa506
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/micro_ecc/micro_ecc_backend_ecc.h
@@ -0,0 +1,303 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef MICRO_ECC_BACKEND_ECC_H__
+#define MICRO_ECC_BACKEND_ECC_H__
+
+#include "sdk_config.h"
+#include "nordic_common.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MICRO_ECC)
+
+#include <stdint.h>
+#include <stdbool.h>
+#include "nrf_crypto_ecc_shared.h"
+#include "uECC.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/** @internal See @ref nrf_crypto_backend_ecc_key_pair_generate_fn_t.
+ */
+ret_code_t nrf_crypto_backend_micro_ecc_key_pair_generate(
+    void * p_context,
+    void * p_private_key,
+    void * p_public_key);
+
+
+/** @internal See @ref nrf_crypto_backend_ecc_public_key_calculate_fn_t.
+*/
+ret_code_t nrf_crypto_backend_micro_ecc_public_key_calculate(
+    void       * p_context,
+    void const * p_private_key,
+    void       * p_public_key);
+
+
+/** @internal See @ref nrf_crypto_backend_ecc_private_key_from_raw_fn_t.
+*/
+ret_code_t nrf_crypto_backend_micro_ecc_private_key_from_raw(
+    void          * p_private_key,
+    uint8_t const * p_raw_data);
+
+
+/** @internal See @ref nrf_crypto_backend_ecc_private_key_to_raw_fn_t.
+*/
+ret_code_t nrf_crypto_backend_micro_ecc_private_key_to_raw(
+    void    const * p_private_key,
+    uint8_t       * p_raw_data);
+
+
+/** @internal See @ref nrf_crypto_backend_ecc_public_key_from_raw_fn_t.
+*/
+ret_code_t nrf_crypto_backend_micro_ecc_public_key_from_raw(
+    void          * p_public_key,
+    uint8_t const * p_raw_data);
+
+
+/** @internal See @ref nrf_crypto_backend_ecc_public_key_to_raw_fn_t.
+*/
+ret_code_t nrf_crypto_backend_micro_ecc_public_key_to_raw(
+    void const * p_public_key,
+    uint8_t    * p_raw_data);
+
+
+/** @internal @brief Represents common uECC backend key structure.
+ */
+typedef struct
+{
+    nrf_crypto_internal_ecc_key_header_t header; /**< @internal @brief Common ECC key header */
+    uint32_t key[1];                             /**< @internal @brief micro-ecc specific key representation */
+} nrf_crypto_backend_micro_ecc_common_key_t;
+
+
+/** @internal @brief Callback RNG function that can be provided to uECC API.
+ *  @param dest     Destination buffer.
+ *  @param size     Size of the buffer.
+ *  @return         1 on success, 0 on error.
+ */
+int nrf_crypto_backend_micro_ecc_rng_callback(uint8_t * dest, unsigned size);
+
+
+/** @internal @brief Gets uECC type based on provided key.
+ *  @param p_key    uECC backend key (public or private).
+ *  @return         uECC specific value representing a curve.
+ */
+uECC_Curve nrf_crypto_backend_micro_ecc_curve_get(
+    nrf_crypto_backend_micro_ecc_common_key_t const * p_key);
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MICRO_ECC_ECC_SECP192R1)
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_ECC_SECP192R1)
+#error "More than one backend enabled for secp192r1 (NIST 192-bit).");
+#endif
+#define NRF_CRYPTO_ECC_SECP192R1_ENABLED 1
+
+/** @internal @brief Structure holding private key for secp192r1 (NIST 192-bit) in micro-ecc.
+ */
+typedef struct
+{
+    nrf_crypto_internal_ecc_key_header_t header; /**< @internal @brief Common ECC key header */
+    uint32_t key[192 / 32];                      /**< @internal @brief micro-ecc specific key representation */
+} nrf_crypto_backend_secp192r1_private_key_t;
+
+/** @internal @brief Structure holding public key for secp192r1 (NIST 192-bit) in micro-ecc.
+ */
+typedef struct
+{
+    nrf_crypto_internal_ecc_key_header_t header; /**< @internal @brief Common ECC key header */
+    uint32_t key[2 * 192 / 32];                  /**< @internal @brief micro-ecc specific key representation */
+} nrf_crypto_backend_secp192r1_public_key_t;
+
+// Aliases for one common micro-ecc implementation
+#define nrf_crypto_backend_secp192r1_key_pair_generate nrf_crypto_backend_micro_ecc_key_pair_generate
+#define nrf_crypto_backend_secp192r1_public_key_calculate nrf_crypto_backend_micro_ecc_public_key_calculate
+#define nrf_crypto_backend_secp192r1_private_key_from_raw nrf_crypto_backend_micro_ecc_private_key_from_raw
+#define nrf_crypto_backend_secp192r1_private_key_to_raw nrf_crypto_backend_micro_ecc_private_key_to_raw
+#define nrf_crypto_backend_secp192r1_public_key_from_raw nrf_crypto_backend_micro_ecc_public_key_from_raw
+#define nrf_crypto_backend_secp192r1_public_key_to_raw nrf_crypto_backend_micro_ecc_public_key_to_raw
+#define nrf_crypto_backend_secp192r1_private_key_free NULL
+#define nrf_crypto_backend_secp192r1_public_key_free NULL
+#define NRF_CRYPTO_BACKEND_SECP192R1_KEY_PAIR_GENERATE_CONTEXT_SIZE 0
+#define NRF_CRYPTO_BACKEND_SECP192R1_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE 0
+
+// Dummy typedef for unused context
+typedef uint32_t nrf_crypto_backend_secp192r1_key_pair_generate_context_t;
+typedef uint32_t nrf_crypto_backend_secp192r1_public_key_calculate_context_t;
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MICRO_ECC_ECC_SECP192R1)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MICRO_ECC_ECC_SECP224R1)
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_ECC_SECP224R1)
+#error "More than one backend enabled for secp224r1 (NIST 224-bit).");
+#endif
+#define NRF_CRYPTO_ECC_SECP224R1_ENABLED 1
+
+/** @internal @brief Structure holding private key for secp224r1 (NIST 224-bit) in micro-ecc.
+ */
+typedef struct
+{
+    nrf_crypto_internal_ecc_key_header_t header; /**< @internal @brief Common ECC key header */
+    uint32_t key[224 / 32];                      /**< @internal @brief micro-ecc specific key representation */
+} nrf_crypto_backend_secp224r1_private_key_t;
+
+/** @internal @brief Structure holding public key for secp224r1 (NIST 224-bit) in micro-ecc.
+ */
+typedef struct
+{
+    nrf_crypto_internal_ecc_key_header_t header; /**< @internal @brief Common ECC key header */
+    uint32_t key[2 * 224 / 32];                  /**< @internal @brief micro-ecc specific key representation */
+} nrf_crypto_backend_secp224r1_public_key_t;
+
+// Aliases for one common micro-ecc implementation
+#define nrf_crypto_backend_secp224r1_key_pair_generate nrf_crypto_backend_micro_ecc_key_pair_generate
+#define nrf_crypto_backend_secp224r1_public_key_calculate nrf_crypto_backend_micro_ecc_public_key_calculate
+#define nrf_crypto_backend_secp224r1_private_key_from_raw nrf_crypto_backend_micro_ecc_private_key_from_raw
+#define nrf_crypto_backend_secp224r1_private_key_to_raw nrf_crypto_backend_micro_ecc_private_key_to_raw
+#define nrf_crypto_backend_secp224r1_public_key_from_raw nrf_crypto_backend_micro_ecc_public_key_from_raw
+#define nrf_crypto_backend_secp224r1_public_key_to_raw nrf_crypto_backend_micro_ecc_public_key_to_raw
+#define nrf_crypto_backend_secp224r1_private_key_free NULL
+#define nrf_crypto_backend_secp224r1_public_key_free NULL
+#define NRF_CRYPTO_BACKEND_SECP224R1_KEY_PAIR_GENERATE_CONTEXT_SIZE 0
+#define NRF_CRYPTO_BACKEND_SECP224R1_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE 0
+
+// Dummy typedef for unused context
+typedef uint32_t nrf_crypto_backend_secp224r1_key_pair_generate_context_t;
+typedef uint32_t nrf_crypto_backend_secp224r1_public_key_calculate_context_t;
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MICRO_ECC_ECC_SECP224R1)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MICRO_ECC_ECC_SECP256R1)
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_ECC_SECP256R1)
+#error "More than one backend enabled for secp256r1 (NIST 256-bit).");
+#endif
+#define NRF_CRYPTO_ECC_SECP256R1_ENABLED 1
+
+/** @internal @brief Structure holding private key for secp256r1 (NIST 256-bit) in micro-ecc.
+ */
+typedef struct
+{
+    nrf_crypto_internal_ecc_key_header_t header; /**< @internal @brief Common ECC key header */
+    uint32_t key[256 / 32];                      /**< @internal @brief micro-ecc specific key representation */
+} nrf_crypto_backend_secp256r1_private_key_t;
+
+/** @internal @brief Structure holding public key for secp256r1 (NIST 256-bit) in micro-ecc.
+ */
+typedef struct
+{
+    nrf_crypto_internal_ecc_key_header_t header; /**< @internal @brief Common ECC key header */
+    uint32_t key[2 * 256 / 32];                  /**< @internal @brief micro-ecc specific key representation */
+} nrf_crypto_backend_secp256r1_public_key_t;
+
+// Aliases for one common micro-ecc implementation
+#define nrf_crypto_backend_secp256r1_key_pair_generate nrf_crypto_backend_micro_ecc_key_pair_generate
+#define nrf_crypto_backend_secp256r1_public_key_calculate nrf_crypto_backend_micro_ecc_public_key_calculate
+#define nrf_crypto_backend_secp256r1_private_key_from_raw nrf_crypto_backend_micro_ecc_private_key_from_raw
+#define nrf_crypto_backend_secp256r1_private_key_to_raw nrf_crypto_backend_micro_ecc_private_key_to_raw
+#define nrf_crypto_backend_secp256r1_public_key_from_raw nrf_crypto_backend_micro_ecc_public_key_from_raw
+#define nrf_crypto_backend_secp256r1_public_key_to_raw nrf_crypto_backend_micro_ecc_public_key_to_raw
+#define nrf_crypto_backend_secp256r1_private_key_free NULL
+#define nrf_crypto_backend_secp256r1_public_key_free NULL
+#define NRF_CRYPTO_BACKEND_SECP256R1_KEY_PAIR_GENERATE_CONTEXT_SIZE 0
+#define NRF_CRYPTO_BACKEND_SECP256R1_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE 0
+
+// Dummy typedef for unused context
+typedef uint32_t nrf_crypto_backend_secp256r1_key_pair_generate_context_t;
+typedef uint32_t nrf_crypto_backend_secp256r1_public_key_calculate_context_t;
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MICRO_ECC_ECC_SECP256R1)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MICRO_ECC_ECC_SECP256K1)
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_ECC_SECP256K1)
+#error "More than one backend enabled for secp256k1 (Koblitz 256-bit).");
+#endif
+#define NRF_CRYPTO_ECC_SECP256K1_ENABLED 1
+
+/** @internal @brief Structure holding private key for secp256k1 (Koblitz 256-bit) in micro-ecc.
+ */
+typedef struct
+{
+    nrf_crypto_internal_ecc_key_header_t header; /**< @internal @brief Common ECC key header */
+    uint32_t key[256 / 32];                      /**< @internal @brief micro-ecc specific key representation */
+} nrf_crypto_backend_secp256k1_private_key_t;
+
+/** @internal @brief Structure holding public key for secp256k1 (Koblitz 256-bit) in micro-ecc.
+ */
+typedef struct
+{
+    nrf_crypto_internal_ecc_key_header_t header; /**< @internal @brief Common ECC key header */
+    uint32_t key[2 * 256 / 32];                  /**< @internal @brief micro-ecc specific key representation */
+} nrf_crypto_backend_secp256k1_public_key_t;
+
+// Aliases for one common micro-ecc implementation
+#define nrf_crypto_backend_secp256k1_key_pair_generate nrf_crypto_backend_micro_ecc_key_pair_generate
+#define nrf_crypto_backend_secp256k1_public_key_calculate nrf_crypto_backend_micro_ecc_public_key_calculate
+#define nrf_crypto_backend_secp256k1_private_key_from_raw nrf_crypto_backend_micro_ecc_private_key_from_raw
+#define nrf_crypto_backend_secp256k1_private_key_to_raw nrf_crypto_backend_micro_ecc_private_key_to_raw
+#define nrf_crypto_backend_secp256k1_public_key_from_raw nrf_crypto_backend_micro_ecc_public_key_from_raw
+#define nrf_crypto_backend_secp256k1_public_key_to_raw nrf_crypto_backend_micro_ecc_public_key_to_raw
+#define nrf_crypto_backend_secp256k1_private_key_free NULL
+#define nrf_crypto_backend_secp256k1_public_key_free NULL
+#define NRF_CRYPTO_BACKEND_SECP256K1_KEY_PAIR_GENERATE_CONTEXT_SIZE 0
+#define NRF_CRYPTO_BACKEND_SECP256K1_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE 0
+
+// Dummy typedef for unused context
+typedef uint32_t nrf_crypto_backend_secp256k1_key_pair_generate_context_t;
+typedef uint32_t nrf_crypto_backend_secp256k1_public_key_calculate_context_t;
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MICRO_ECC_ECC_SECP256K1)
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MICRO_ECC)
+
+#endif // MICRO_ECC_BACKEND_ECC_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/micro_ecc/micro_ecc_backend_ecdh.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/micro_ecc/micro_ecc_backend_ecdh.c
new file mode 100644
index 0000000..a63307e
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/micro_ecc/micro_ecc_backend_ecdh.c
@@ -0,0 +1,93 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#include "sdk_config.h"
+#include "nordic_common.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MICRO_ECC)
+
+#include <string.h>
+
+#include "nrf_crypto_ecc_shared.h"
+#include "nrf_crypto_ecdh_shared.h"
+#include "nrf_crypto_ecdh.h"
+#include "nrf_crypto_shared.h"
+#include "micro_ecc_backend_ecc.h"
+#include "micro_ecc_backend_shared.h"
+#include "uECC.h"
+
+
+ret_code_t nrf_crypto_backend_micro_ecc_ecdh_compute(
+    void       * p_context,
+    void const * p_private_key,
+    void const * p_public_key,
+    uint8_t    * p_shared_secret)
+{
+    int result;
+
+    nrf_crypto_backend_micro_ecc_common_key_t const * p_prv =
+        (nrf_crypto_backend_micro_ecc_common_key_t const *)p_private_key;
+    nrf_crypto_backend_micro_ecc_common_key_t const * p_pub =
+        (nrf_crypto_backend_micro_ecc_common_key_t const *)p_public_key;
+
+    nrf_crypto_ecc_curve_info_t const * p_info = p_prv->header.p_info;
+
+    uECC_Curve p_micro_ecc_curve = nrf_crypto_backend_micro_ecc_curve_get(p_prv);
+
+    result = uECC_shared_secret((uint8_t const *)(&p_pub->key[0]),
+                                (uint8_t const *)(&p_prv->key[0]),
+                                p_shared_secret,
+                                p_micro_ecc_curve);
+
+#if ECC_BACKEND_SWAP_BYTES
+    nrf_crypto_internal_swap_endian_in_place(p_shared_secret, p_info->raw_private_key_size);
+#else
+    UNUSED_PARAMETER(p_info);
+#endif
+
+    if (result == 0)
+    {
+        return NRF_ERROR_CRYPTO_INTERNAL;
+    }
+    return NRF_SUCCESS;
+}
+
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MICRO_ECC)
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/micro_ecc/micro_ecc_backend_ecdh.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/micro_ecc/micro_ecc_backend_ecdh.h
new file mode 100644
index 0000000..cdf366b
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/micro_ecc/micro_ecc_backend_ecdh.h
@@ -0,0 +1,105 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef MICRO_ECC_BACKEND_ECDH_H__
+#define MICRO_ECC_BACKEND_ECDH_H__
+
+#include "sdk_config.h"
+#include "nordic_common.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MICRO_ECC)
+
+#include "nrf_crypto_ecc.h"
+#include "nrf_crypto_ecdh_shared.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/** @internal See @ref nrf_crypto_backend_ecdh_compute_fn_t.
+ */
+ret_code_t nrf_crypto_backend_micro_ecc_ecdh_compute(
+    void       * p_context,
+    void const * p_private_key,
+    void const * p_public_key,
+    uint8_t    * p_shared_secret);
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MICRO_ECC_ECC_SECP192R1)
+// Aliases for one common MICRO_ECC implementation
+#define nrf_crypto_backend_secp192r1_ecdh_compute nrf_crypto_backend_micro_ecc_ecdh_compute
+typedef uint32_t nrf_crypto_backend_secp192r1_ecdh_context_t;
+#define NRF_CRYPTO_BACKEND_SECP192R1_ECDH_CONTEXT_SIZE 0
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MICRO_ECC_ECC_SECP192R1)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MICRO_ECC_ECC_SECP224R1)
+// Aliases for one common MICRO_ECC implementation
+#define nrf_crypto_backend_secp224r1_ecdh_compute nrf_crypto_backend_micro_ecc_ecdh_compute
+typedef uint32_t nrf_crypto_backend_secp224r1_ecdh_context_t;
+#define NRF_CRYPTO_BACKEND_SECP224R1_ECDH_CONTEXT_SIZE 0
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MICRO_ECC_ECC_SECP224R1)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MICRO_ECC_ECC_SECP256R1)
+// Aliases for one common MICRO_ECC implementation
+#define nrf_crypto_backend_secp256r1_ecdh_compute nrf_crypto_backend_micro_ecc_ecdh_compute
+typedef uint32_t nrf_crypto_backend_secp256r1_ecdh_context_t;
+#define NRF_CRYPTO_BACKEND_SECP256R1_ECDH_CONTEXT_SIZE 0
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MICRO_ECC_ECC_SECP256R1)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MICRO_ECC_ECC_SECP256K1)
+// Aliases for one common MICRO_ECC implementation
+#define nrf_crypto_backend_secp256k1_ecdh_compute nrf_crypto_backend_micro_ecc_ecdh_compute
+typedef uint32_t nrf_crypto_backend_secp256k1_ecdh_context_t;
+#define NRF_CRYPTO_BACKEND_SECP256K1_ECDH_CONTEXT_SIZE 0
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MICRO_ECC_ECC_SECP256K1)
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MICRO_ECC)
+
+#endif // MICRO_ECC_BACKEND_ECDH_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/micro_ecc/micro_ecc_backend_ecdsa.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/micro_ecc/micro_ecc_backend_ecdsa.c
new file mode 100644
index 0000000..f72e6dc
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/micro_ecc/micro_ecc_backend_ecdsa.c
@@ -0,0 +1,166 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#include "sdk_config.h"
+#include "nordic_common.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MICRO_ECC)
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <string.h>
+
+#include "nrf_crypto_ecc.h"
+#include "nrf_crypto_ecdsa.h"
+#include "nrf_crypto_shared.h"
+#include "nrf_crypto_mem.h"
+#include "micro_ecc_backend_ecc.h"
+#include "micro_ecc_backend_shared.h"
+#include "uECC.h"
+
+
+ret_code_t nrf_crypto_backend_micro_ecc_sign(
+    void           * p_context,
+    void     const * p_private_key,
+    uint8_t  const * p_data,
+    size_t           data_size,
+    uint8_t        * p_signature)
+{
+    int result;
+
+    nrf_crypto_backend_micro_ecc_common_key_t const * p_prv =
+        (nrf_crypto_backend_micro_ecc_common_key_t const *)p_private_key;
+
+    uECC_Curve p_micro_ecc_curve = nrf_crypto_backend_micro_ecc_curve_get(p_prv);
+
+#if ECC_BACKEND_SWAP_BYTES
+
+    nrf_crypto_ecc_curve_info_t const * p_info = p_prv->header.p_info;
+
+    size_t    hash_size = MIN(data_size, p_info->raw_private_key_size);
+    uint8_t   hash_le[NRF_CRYPTO_ECC_RAW_PRIVATE_KEY_MAX_SIZE];
+
+    nrf_crypto_internal_swap_endian(hash_le, p_data, hash_size);
+
+    uECC_set_rng(nrf_crypto_backend_micro_ecc_rng_callback);
+
+    result = uECC_sign((uint8_t const *)(&p_prv->key[0]),
+                       hash_le,
+                       hash_size,
+                       p_signature,
+                       p_micro_ecc_curve);
+
+    nrf_crypto_internal_double_swap_endian_in_place(p_signature, p_info->raw_private_key_size);
+
+#else
+
+    uECC_set_rng(nrf_crypto_backend_micro_ecc_rng_callback);
+
+    result = uECC_sign((uint8_t const *)(&p_prv->key[0]),
+                       p_data,
+                       data_size,
+                       p_signature,
+                       p_micro_ecc_curve);
+
+#endif
+
+    if (result == 0)
+    {
+        return NRF_ERROR_CRYPTO_INTERNAL;
+    }
+    return NRF_SUCCESS;
+}
+
+
+ret_code_t nrf_crypto_backend_micro_ecc_verify(
+    void           * p_context,
+    void     const * p_public_key,
+    uint8_t  const * p_data,
+    size_t           data_size,
+    uint8_t  const * p_signature)
+{
+    int result;
+
+    nrf_crypto_backend_micro_ecc_common_key_t const * p_pub =
+        (nrf_crypto_backend_micro_ecc_common_key_t const *)p_public_key;
+
+    uECC_Curve p_micro_ecc_curve = nrf_crypto_backend_micro_ecc_curve_get(p_pub);
+
+#if ECC_BACKEND_SWAP_BYTES
+
+    nrf_crypto_ecc_curve_info_t const * p_info = p_pub->header.p_info;
+
+    size_t  hash_size = MIN(data_size, p_info->raw_private_key_size);
+    uint8_t hash_le     [NRF_CRYPTO_ECC_RAW_PRIVATE_KEY_MAX_SIZE];
+    uint8_t signature_le[NRF_CRYPTO_ECDSA_SIGNATURE_MAX_SIZE];
+
+    nrf_crypto_internal_swap_endian(hash_le, p_data, hash_size);
+
+    nrf_crypto_internal_double_swap_endian(signature_le,
+                                           p_signature,
+                                           p_info->raw_private_key_size);
+
+    result = uECC_verify((uint8_t const *)(&p_pub->key[0]),
+                         hash_le,
+                         hash_size,
+                         signature_le,
+                         p_micro_ecc_curve);
+
+#else
+
+    result = uECC_verify((uint8_t const *)(&p_pub->key[0]),
+                         p_data,
+                         data_size,
+                         p_signature,
+                         p_micro_ecc_curve);
+
+#endif
+
+    if (result == 0)
+    {
+        return NRF_ERROR_CRYPTO_ECDSA_INVALID_SIGNATURE;
+    }
+
+    return NRF_SUCCESS;
+}
+
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MICRO_ECC)
+
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/micro_ecc/micro_ecc_backend_ecdsa.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/micro_ecc/micro_ecc_backend_ecdsa.h
new file mode 100644
index 0000000..a52d193
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/micro_ecc/micro_ecc_backend_ecdsa.h
@@ -0,0 +1,124 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef MICRO_ECC_BACKEND_ECDSA_H__
+#define MICRO_ECC_BACKEND_ECDSA_H__
+
+#include "sdk_config.h"
+#include "nordic_common.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MICRO_ECC)
+
+#include "nrf_crypto_ecc_shared.h"
+#include "nrf_crypto_ecdsa_shared.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/** @internal See @ref nrf_crypto_backend_ecdsa_sign_fn_t.
+ */
+ret_code_t nrf_crypto_backend_micro_ecc_sign(
+    void           * p_context,
+    void     const * p_private_key,
+    uint8_t  const * p_data,
+    size_t           data_size,
+    uint8_t        * p_signature);
+
+
+/** @internal See @ref nrf_crypto_backend_ecdsa_verify_fn_t.
+ */
+ret_code_t nrf_crypto_backend_micro_ecc_verify(
+    void           * p_context,
+    void     const * p_public_key,
+    uint8_t  const * p_data,
+    size_t           data_size,
+    uint8_t  const * p_signature);
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MICRO_ECC_ECC_SECP192R1)
+#define NRF_CRYPTO_BACKEND_SECP192R1_SIGN_CONTEXT_SIZE 0
+#define NRF_CRYPTO_BACKEND_SECP192R1_VERIFY_CONTEXT_SIZE 0
+typedef uint32_t nrf_crypto_backend_secp192r1_sign_context_t;
+typedef uint32_t nrf_crypto_backend_secp192r1_verify_context_t;
+#define nrf_crypto_backend_secp192r1_sign nrf_crypto_backend_micro_ecc_sign
+#define nrf_crypto_backend_secp192r1_verify nrf_crypto_backend_micro_ecc_verify
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MICRO_ECC_ECC_SECP224R1)
+#define NRF_CRYPTO_BACKEND_SECP224R1_SIGN_CONTEXT_SIZE 0
+#define NRF_CRYPTO_BACKEND_SECP224R1_VERIFY_CONTEXT_SIZE 0
+typedef uint32_t nrf_crypto_backend_secp224r1_sign_context_t;
+typedef uint32_t nrf_crypto_backend_secp224r1_verify_context_t;
+#define nrf_crypto_backend_secp224r1_sign nrf_crypto_backend_micro_ecc_sign
+#define nrf_crypto_backend_secp224r1_verify nrf_crypto_backend_micro_ecc_verify
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MICRO_ECC_ECC_SECP256R1)
+#define NRF_CRYPTO_BACKEND_SECP256R1_SIGN_CONTEXT_SIZE 0
+#define NRF_CRYPTO_BACKEND_SECP256R1_VERIFY_CONTEXT_SIZE 0
+typedef uint32_t nrf_crypto_backend_secp256r1_sign_context_t;
+typedef uint32_t nrf_crypto_backend_secp256r1_verify_context_t;
+#define nrf_crypto_backend_secp256r1_sign nrf_crypto_backend_micro_ecc_sign
+#define nrf_crypto_backend_secp256r1_verify nrf_crypto_backend_micro_ecc_verify
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MICRO_ECC_ECC_SECP256K1)
+#define NRF_CRYPTO_BACKEND_SECP256K1_SIGN_CONTEXT_SIZE 0
+#define NRF_CRYPTO_BACKEND_SECP256K1_VERIFY_CONTEXT_SIZE 0
+typedef uint32_t nrf_crypto_backend_secp256k1_sign_context_t;
+typedef uint32_t nrf_crypto_backend_secp256k1_verify_context_t;
+#define nrf_crypto_backend_secp256k1_sign nrf_crypto_backend_micro_ecc_sign
+#define nrf_crypto_backend_secp256k1_verify nrf_crypto_backend_micro_ecc_verify
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MICRO_ECC)
+
+#endif // MICRO_ECC_BACKEND_ECDSA_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/micro_ecc/micro_ecc_backend_shared.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/micro_ecc/micro_ecc_backend_shared.h
new file mode 100644
index 0000000..019f280
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/micro_ecc/micro_ecc_backend_shared.h
@@ -0,0 +1,67 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+#ifndef MICRO_ECC_BACKEND_SHARED_H__
+#define MICRO_ECC_BACKEND_SHARED_H__
+
+#include "sdk_config.h"
+#include "nordic_common.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MICRO_ECC)
+
+#include "uECC.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MICRO_ECC_LITTLE_ENDIAN)
+#define ECC_BACKEND_SWAP_BYTES (!uECC_VLI_NATIVE_LITTLE_ENDIAN)
+#else
+#define ECC_BACKEND_SWAP_BYTES uECC_VLI_NATIVE_LITTLE_ENDIAN
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MICRO_ECC)
+
+#endif // MICRO_ECC_BACKEND_ECDSA_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/nrf_hw/nrf_hw_backend_init.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/nrf_hw/nrf_hw_backend_init.c
new file mode 100644
index 0000000..d202f35
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/nrf_hw/nrf_hw_backend_init.c
@@ -0,0 +1,95 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#include "sdk_common.h"
+#if NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_NRF_HW_RNG)
+
+#include "nrf.h"
+#include "nrf_crypto_init.h"
+#include "nrf_crypto_rng.h"
+
+
+static ret_code_t nrf_hw_backend_init(void)
+{
+#if defined(NRF_CRYPTO_RNG_AUTO_INIT_ENABLED) && (NRF_CRYPTO_RNG_AUTO_INIT_ENABLED == 1)
+
+    uint32_t ret_val;
+    ret_val = nrf_crypto_rng_init(NULL, NULL);
+    return ret_val;
+
+#elif defined(NRF_CRYPTO_RNG_AUTO_INIT_ENABLED) && (NRF_CRYPTO_RNG_AUTO_INIT_ENABLED == 0)
+
+    return NRF_SUCCESS;
+
+#else
+
+    #warning NRF_CRYPTO_RNG_AUTO_INIT_ENABLED define not found in sdk_config.h (Is the sdk_config.h valid?).
+
+#endif // NRF_CRYPTO_RNG_AUTO_INIT_ENABLED
+}
+
+
+static ret_code_t nrf_hw_backend_uninit(void)
+{
+#if defined(NRF_CRYPTO_RNG_AUTO_INIT_ENABLED) && (NRF_CRYPTO_RNG_AUTO_INIT_ENABLED == 1)
+
+    uint32_t ret_val;
+    ret_val = nrf_crypto_rng_uninit();
+    return ret_val;
+
+#elif defined(NRF_CRYPTO_RNG_AUTO_INIT_ENABLED) && (NRF_CRYPTO_RNG_AUTO_INIT_ENABLED == 0)
+
+    return NRF_SUCCESS;
+
+#else
+
+    #warning NRF_CRYPTO_RNG_AUTO_INIT_ENABLED define not found in sdk_config.h (Is the sdk_config.h valid?).
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_RNG_AUTO_INIT)
+}
+
+
+CRYPTO_BACKEND_REGISTER(nrf_crypto_backend_info_t const nrf_hw_backend) =
+{
+    .init_fn    = nrf_hw_backend_init,
+    .uninit_fn  = nrf_hw_backend_uninit
+};
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_NRF_HW_RNG)
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/nrf_hw/nrf_hw_backend_rng.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/nrf_hw/nrf_hw_backend_rng.c
new file mode 100644
index 0000000..e8331e1
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/nrf_hw/nrf_hw_backend_rng.c
@@ -0,0 +1,101 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#include "sdk_common.h"
+#if NRF_MODULE_ENABLED(NRF_CRYPTO) && \
+    NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_NRF_HW_RNG) && \
+    !NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_NRF_HW_RNG_MBEDTLS_CTR_DRBG)
+
+#include "nrf_crypto_rng.h"
+#include "nrf_drv_rng.h"
+
+
+ret_code_t nrf_crypto_rng_backend_init(void * const p_context,
+                                       void * const p_temp_buffer)
+{
+    ret_code_t ret_val;
+    
+    UNUSED_PARAMETER(p_context);
+    UNUSED_PARAMETER(p_temp_buffer);
+
+    ret_val = nrf_drv_rng_init(NULL);
+
+    return ret_val;
+}
+
+
+ret_code_t nrf_crypto_rng_backend_uninit(void * const p_context)
+{
+    UNUSED_PARAMETER(p_context);
+    
+    nrf_drv_rng_uninit();
+
+    return NRF_SUCCESS;
+}
+
+
+ret_code_t nrf_crypto_rng_backend_vector_generate(void      * const p_context,
+                                                  uint8_t   * const p_target,
+                                                  size_t            size,
+                                                  bool              use_mutex)
+{
+    UNUSED_PARAMETER(use_mutex);
+    UNUSED_PARAMETER(p_context);
+
+    nrf_drv_rng_block_rand(p_target, size);
+
+    return NRF_SUCCESS;
+}
+
+
+ret_code_t nrf_crypto_rng_backend_reseed(void   * const p_context,
+                                         void         * p_temp_buffer,
+                                         uint8_t      * p_input_data,
+                                         size_t         size)
+{
+    UNUSED_PARAMETER(p_context);
+    UNUSED_PARAMETER(p_temp_buffer);
+    UNUSED_PARAMETER(p_input_data);
+    UNUSED_PARAMETER(size);
+    
+    return NRF_ERROR_CRYPTO_FEATURE_UNAVAILABLE;
+}
+
+#endif //NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_NRF_HW_RNG) && !NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_NRF_HW_RNG_MBEDTLS_CTR_DRBG)
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/nrf_hw/nrf_hw_backend_rng.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/nrf_hw/nrf_hw_backend_rng.h
new file mode 100644
index 0000000..fcf6b8d
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/nrf_hw/nrf_hw_backend_rng.h
@@ -0,0 +1,104 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef NRF_HW_BACKEND_RNG_H__
+#define NRF_HW_BACKEND_RNG_H__
+
+/** @file
+ *
+ * @defgroup nrf_crypto_nrf_hw_backend_rng nrf_crypto HW RNG backend
+ * @{
+ * @ingroup nrf_crypto_backends
+ *
+ * @brief RNG functionality provided by the nrf_crypto nRF HW RNG backend.
+ */
+
+#include "sdk_common.h"
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_NRF_HW_RNG) && \
+    !NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_NRF_HW_RNG_MBEDTLS_CTR_DRBG)
+
+#if !NRF_MODULE_ENABLED(RNG)
+#error Enable RNG_ENABLED in sdk_config.h.
+#endif
+
+#if !NRFX_RNG_CONFIG_ERROR_CORRECTION
+#error Enable NRFX_RNG_CONFIG_ERROR_CORRECTION and RNG_CONFIG_ERROR_CORRECTION in sdk_config.h.
+#endif
+
+#include "nrf_crypto_rng_shared.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_RNG)
+#error "More than one RNG backend enabled."
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_RNG)
+#define NRF_CRYPTO_RNG_ENABLED 1
+
+
+/**
+ * @internal @brief Context for nRF RNG peripheral.
+ */
+typedef struct
+{
+    nrf_crypto_rng_internal_context_t   header;         //!< Internal common context header.
+} nrf_crypto_backend_rng_context_t;
+
+/**
+ * @internal @brief Dummy temp buffer for nRF RNG peripheral.
+ */
+typedef struct
+{
+    uint32_t reserved;
+} nrf_crypto_backend_rng_temp_buffer_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_NRF_HW_RNG) && !NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_NRF_HW_RNG_MBEDTLS_CTR_DRBG)
+
+/**@} */
+
+#endif // NRF_HW_BACKEND_RNG_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/nrf_hw/nrf_hw_backend_rng_mbedtls.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/nrf_hw/nrf_hw_backend_rng_mbedtls.c
new file mode 100644
index 0000000..649904b
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/nrf_hw/nrf_hw_backend_rng_mbedtls.c
@@ -0,0 +1,168 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#include "sdk_common.h"
+#if NRF_MODULE_ENABLED(NRF_CRYPTO) && \
+    NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_NRF_HW_RNG) && \
+    NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_NRF_HW_RNG_MBEDTLS_CTR_DRBG)
+
+#include "nrf_crypto_rng.h"
+#include "nrf_drv_rng.h"
+#include "nrf_hw_backend_rng_mbedtls.h"
+
+
+// Function to convert mbedtls error codes to ret_code_t.
+static ret_code_t result_get(int mbedtls_ret_val)
+{
+    ret_code_t ret_val;
+    switch (mbedtls_ret_val)
+    {
+        case 0:
+            ret_val = NRF_SUCCESS;
+            break;
+
+        case MBEDTLS_ERR_CTR_DRBG_INPUT_TOO_BIG:
+            ret_val = NRF_ERROR_CRYPTO_INPUT_LENGTH;
+            break;
+
+        case MBEDTLS_ERR_CTR_DRBG_REQUEST_TOO_BIG:
+            ret_val = NRF_ERROR_CRYPTO_OUTPUT_LENGTH;
+            break;
+
+        case MBEDTLS_ERR_CTR_DRBG_ENTROPY_SOURCE_FAILED:
+        default:
+            ret_val = NRF_ERROR_CRYPTO_INTERNAL;
+            break;
+    }
+
+    return ret_val;
+}
+
+
+// Callback function used by mbed TLS to seed and reseed.
+static int entropy_callback(void * p_entropy, unsigned char * p_buffer, size_t size)
+{
+    UNUSED_PARAMETER(p_entropy);
+
+    nrf_drv_rng_block_rand(p_buffer, size);
+
+    return 0;
+}
+
+
+ret_code_t nrf_crypto_rng_backend_init(void * const p_context, void * const p_temp_buffer)
+{
+    ret_code_t                  ret_val;
+    int                         mbedtls_ret_val;
+    mbedtls_ctr_drbg_context  * p_mbedtls_context =
+        &((nrf_crypto_backend_rng_context_t *)p_context)->mbedtls_context;
+
+    UNUSED_PARAMETER(p_temp_buffer);
+
+    ret_val = nrf_drv_rng_init(NULL);
+
+    if (ret_val != NRF_SUCCESS)
+    {
+        return ret_val;
+    }
+
+    mbedtls_ctr_drbg_init(p_mbedtls_context);
+
+    // Initial seeding. The nrf_crypto_rng API does not support additional entropy in the initial
+    // seeding. Additional entropy can be provided using nrf_crypto_rng_backend_reseed(),
+    // which calls mbedtls_ctr_drbg_reseed().
+    mbedtls_ret_val = mbedtls_ctr_drbg_seed(p_mbedtls_context,
+                                            entropy_callback,
+                                            NULL,
+                                            NULL,
+                                            0);
+
+    ret_val = result_get(mbedtls_ret_val);
+
+    return ret_val;
+}
+
+
+ret_code_t nrf_crypto_rng_backend_uninit(void * const p_context)
+{
+    mbedtls_ctr_drbg_context  * p_mbedtls_context =
+        &((nrf_crypto_backend_rng_context_t *)p_context)->mbedtls_context;
+
+    mbedtls_ctr_drbg_free(p_mbedtls_context);
+    nrf_drv_rng_uninit();
+
+    return NRF_SUCCESS;
+}
+
+
+ret_code_t nrf_crypto_rng_backend_vector_generate(void      * const p_context,
+                                                  uint8_t   * const p_target,
+                                                  size_t            size,
+                                                  bool              use_mutex)
+{
+    int                         mbedtls_ret_val;
+    mbedtls_ctr_drbg_context  * p_mbedtls_context =
+        &((nrf_crypto_backend_rng_context_t *)p_context)->mbedtls_context;
+
+    UNUSED_PARAMETER(use_mutex);
+
+    mbedtls_ret_val = mbedtls_ctr_drbg_random(p_mbedtls_context, p_target, size);
+
+    return result_get(mbedtls_ret_val);
+}
+
+
+ret_code_t nrf_crypto_rng_backend_reseed(void   * const p_context,
+                                         void         * p_temp_buffer,
+                                         uint8_t      * p_input_data,
+                                         size_t         size)
+{
+    int                         mbedtls_ret_val;
+    mbedtls_ctr_drbg_context  * p_mbedtls_context =
+        &((nrf_crypto_backend_rng_context_t *)p_context)->mbedtls_context;
+
+    UNUSED_PARAMETER(p_temp_buffer);
+
+    mbedtls_ret_val = mbedtls_ctr_drbg_reseed(p_mbedtls_context, p_input_data, size);
+
+    return result_get(mbedtls_ret_val);
+}
+
+#endif //NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_NRF_HW_RNG) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_NRF_HW_RNG_MBEDTLS_CTR_DRBG)
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/nrf_hw/nrf_hw_backend_rng_mbedtls.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/nrf_hw/nrf_hw_backend_rng_mbedtls.h
new file mode 100644
index 0000000..53daba0
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/nrf_hw/nrf_hw_backend_rng_mbedtls.h
@@ -0,0 +1,108 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef NRF_HW_BACKEND_RNG_MBEDTLS_H__
+#define NRF_HW_BACKEND_RNG_MBEDTLS_H__
+
+/** @file
+ *
+ * @defgroup nrf_crypto_nrf_hw_backend_rng_mbedtls nrf_crypto HW RNG backend using mbedtls CTR-DRBG
+ * @{
+ * @ingroup nrf_crypto_nrf_hw_backend_rng
+ *
+ * @brief RNG functionality provided by the nrf_crypto nRF HW RNG backend and mbedtls CTR-DRBG.
+ */
+
+#include "sdk_common.h"
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_NRF_HW_RNG) && \
+    NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_NRF_HW_RNG_MBEDTLS_CTR_DRBG)
+
+#if !NRF_MODULE_ENABLED(RNG)
+#error Enable RNG_ENABLED in sdk_config.h.
+#endif
+
+#if !NRFX_RNG_CONFIG_ERROR_CORRECTION
+#error Enable NRFX_RNG_CONFIG_ERROR_CORRECTION and RNG_CONFIG_ERROR_CORRECTION in sdk_config.h.
+#endif
+
+/*lint -save -e????*/
+#include "mbedtls/ctr_drbg.h"
+/*lint -restore*/
+#include "nrf_crypto_rng_shared.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_RNG)
+#error "More than one RNG backend enabled."
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_RNG)
+#define NRF_CRYPTO_RNG_ENABLED 1
+
+
+/**
+ * @internal @brief Context for nRF RNG peripheral with mbed tls CTR-DRBG.
+ */
+typedef struct
+{
+    nrf_crypto_rng_internal_context_t   header;             //!< Internal common context header.
+    mbedtls_ctr_drbg_context            mbedtls_context;    //!< mbed TLS CTR-DRBG context.
+} nrf_crypto_backend_rng_context_t;
+
+/**
+ * @internal @brief Dummy temp buffer for nRF RNG peripheral with mbed tls CTR-DRBG.
+ */
+typedef struct
+{
+    uint32_t reserved;
+} nrf_crypto_backend_rng_temp_buffer_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_NRF_HW_RNG) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_NRF_HW_RNG_MBEDTLS_CTR_DRBG)
+
+/**@} */
+
+#endif // NRF_HW_BACKEND_RNG_MBEDTLS_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/nrf_sw/nrf_sw_backend_hash.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/nrf_sw/nrf_sw_backend_hash.c
new file mode 100644
index 0000000..1360662
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/nrf_sw/nrf_sw_backend_hash.c
@@ -0,0 +1,149 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#include "sdk_common.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_NRF_SW)
+
+#include "nrf_sw_backend_hash.h"
+#include "sha256.h"
+#include "nrf_crypto_types.h"
+#include "nrf_crypto_error.h"
+#include "nrf_crypto_hash_shared.h"
+#include "sdk_macros.h"
+#include "nrf_log.h"
+#include "nrf_assert.h"
+
+#if defined(NRF_CRYPTO_BACKEND_NRF_SW_HASH_LITTLE_ENDIAN_DIGEST_ENABLED) &&     \
+    (NRF_CRYPTO_BACKEND_NRF_SW_HASH_LITTLE_ENDIAN_DIGEST_ENABLED == 1)
+
+    #define LITTLE_ENDIAN_HASH (true)
+
+#elif defined(NRF_CRYPTO_BACKEND_NRF_SW_HASH_LITTLE_ENDIAN_DIGEST_ENABLED) &&   \
+      (NRF_CRYPTO_BACKEND_NRF_SW_HASH_LITTLE_ENDIAN_DIGEST_ENABLED == 0)
+
+    #define LITTLE_ENDIAN_HASH (false)
+
+#else
+
+    #define LITTLE_ENDIAN_HASH (false)
+
+    #warning NRF_CRYPTO_BACKEND_NRF_SW_HASH_LITTLE_ENDIAN_DIGEST define not found in sdk_config.h (Is the sdk_config.h valid?).
+
+#endif
+
+static ret_code_t nrf_sw_backend_hash_sha256_init(void * const p_context)
+{
+    ret_code_t ret_val;
+
+    // No parameter testing on this level.
+    // This has been done on upper level.
+
+    sha256_context_t * p_backend_context
+        = &(((nrf_crypto_backend_hash_sha256_context_t *) p_context)->context);
+
+    ret_val = sha256_init(p_backend_context);
+
+    return ret_val;
+}
+
+static uint32_t nrf_sw_backend_hash_sha256_update(void     * const p_context,
+                                                  uint8_t  const * p_data,
+                                                  size_t           len)
+{
+    ret_code_t ret_val;
+
+    // Limited parameter testing on this level.
+    // This has been done on upper level.
+
+    sha256_context_t * p_backend_context
+        = &(((nrf_crypto_backend_hash_sha256_context_t * ) p_context)->context);
+
+    ret_val = sha256_update(p_backend_context, p_data, len);
+
+    return ret_val;
+}
+
+
+static uint32_t nrf_sw_backend_hash_sha256_finalize(void   * const p_context,
+                                                 uint8_t         * p_digest,
+                                                 size_t    * const p_digest_len)
+{
+    ret_code_t ret_val;
+
+    // Limited parameter testing on this level.
+    // This has been done on upper level.
+
+    sha256_context_t * p_backend_context
+        = &(((nrf_crypto_backend_hash_sha256_context_t * )p_context)->context);
+
+    if (NRF_CRYPTO_HASH_SIZE_SHA256 > *p_digest_len)
+    {
+        return NRF_ERROR_CRYPTO_OUTPUT_LENGTH;
+    }
+
+
+    ret_val = sha256_final(p_backend_context, p_digest, LITTLE_ENDIAN_HASH);
+
+    if (ret_val != NRF_SUCCESS)
+    {
+        return ret_val;
+    }
+
+    *p_digest_len = NRF_CRYPTO_HASH_SIZE_SHA256;
+
+    return NRF_SUCCESS;
+
+}
+
+
+const nrf_crypto_hash_info_t g_nrf_crypto_hash_sha256_info =
+{
+    .init_fn        = nrf_sw_backend_hash_sha256_init,
+    .update_fn      = nrf_sw_backend_hash_sha256_update,
+    .finalize_fn    = nrf_sw_backend_hash_sha256_finalize,
+    .digest_size    = NRF_CRYPTO_HASH_SIZE_SHA256,
+    .context_size   = sizeof(nrf_crypto_backend_hash_sha256_context_t),
+    .hash_mode      = NRF_CRYPTO_HASH_MODE_SHA256
+};
+
+
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_NRF_SW)
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/nrf_sw/nrf_sw_backend_hash.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/nrf_sw/nrf_sw_backend_hash.h
new file mode 100644
index 0000000..b5c025c
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/nrf_sw/nrf_sw_backend_hash.h
@@ -0,0 +1,99 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef NRF_SW_BACKEND_HASH_H__
+#define NRF_SW_BACKEND_HASH_H__
+
+/** @file
+ *
+ * @defgroup nrf_crypto_nrf_sw_backend_hash nrf_crypto nRF SW backend hash
+ * @{
+ * @ingroup nrf_crypto_nrf_sw_backend
+ *
+ * @brief Legacy hash functionality for bootloader use in nRFx devices
+ */
+
+#include "sdk_common.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_NRF_SW)
+
+#include "sha256.h"
+#include "nrf_crypto_error.h"
+#include "nrf_crypto_types.h"
+#include "nrf_crypto_hash_shared.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_NRF_SW_HASH_SHA256)
+
+// Flag that nrf_crypto_hash frontend can be compiled
+#undef  NRF_CRYPTO_HASH_ENABLED
+#define NRF_CRYPTO_HASH_ENABLED 1
+
+// Duplicate backend enabled test for SHA-256
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_HASH_SHA256)
+#error "Duplicate definition of SHA-256. More than one backend enabled");
+#endif
+
+// Flag that SHA-256 is enabled in backend
+#define NRF_CRYPTO_HASH_SHA256_ENABLED 1
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_NRF_SW_HASH_SHA256)
+
+
+/**@brief nrf_crypto_hash context for SHA-256 in nrf_crypto nrf_sw backend. */
+typedef struct
+{
+    nrf_crypto_hash_internal_context_t  header;     /**< Common header for context. */
+    sha256_context_t                    context;    /**< Hash context internal to nrf_sw. */
+} nrf_crypto_backend_hash_sha256_context_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_NRF_SW)
+
+/**@} */
+
+#endif // NRF_SW_BACKEND_HASH_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/oberon/oberon_backend_chacha_poly_aead.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/oberon/oberon_backend_chacha_poly_aead.c
new file mode 100644
index 0000000..14588d8
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/oberon/oberon_backend_chacha_poly_aead.c
@@ -0,0 +1,153 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#include "sdk_common.h"
+#if NRF_MODULE_ENABLED(NRF_CRYPTO)
+
+#include <stdbool.h>
+#include "oberon_backend_chacha_poly_aead.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_OBERON_CHACHA_POLY_AEAD)
+
+static ret_code_t backend_cc310_init(void * const p_context, uint8_t * p_key)
+{
+    nrf_crypto_backend_chacha_poly_context_t * p_ctx =
+        (nrf_crypto_backend_chacha_poly_context_t *)p_context;
+
+
+    if (p_ctx->header.p_info->key_size != NRF_CRYPTO_KEY_SIZE_256)
+    {
+        return NRF_ERROR_CRYPTO_KEY_SIZE;
+    }
+
+    memcpy(p_ctx->key, p_key, sizeof(p_ctx->key));
+
+    return NRF_SUCCESS;
+}
+
+static inline ret_code_t backend_cc310_uninit(void * const p_context)
+{
+    return NRF_SUCCESS;
+}
+
+static ret_code_t backend_cc310_crypt(void * const           p_context,
+                                      nrf_crypto_operation_t operation,
+                                      uint8_t *              p_nonce,
+                                      uint8_t                nonce_size,
+                                      uint8_t *              p_adata,
+                                      size_t                 adata_size,
+                                      uint8_t *              p_data_in,
+                                      size_t                 data_in_size,
+                                      uint8_t *              p_data_out,
+                                      uint8_t *              p_mac,
+                                      uint8_t                mac_size)
+
+{
+    int result;
+
+    nrf_crypto_backend_chacha_poly_context_t * p_ctx =
+        (nrf_crypto_backend_chacha_poly_context_t *)p_context;
+
+    if ((adata_size == 0) || (data_in_size == 0))
+    {
+        return NRF_ERROR_CRYPTO_INPUT_LENGTH;
+    }
+
+    if (mac_size   != NRF_CRYPTO_CHACHA_POLY_MAC_SIZE)
+    {
+        return NRF_ERROR_CRYPTO_AEAD_MAC_SIZE;
+    }
+
+    if (nonce_size != NRF_CRYPTO_CHACHA_POLY_NONCE_SIZE)
+    {
+        return NRF_ERROR_CRYPTO_AEAD_NONCE_SIZE;
+    }
+
+    if (operation == NRF_CRYPTO_ENCRYPT)
+    {
+        occ_chacha20_poly1305_encrypt_aad(p_mac,
+                                          p_data_out,
+                                          p_data_in,
+                                          data_in_size,
+                                          p_adata,
+                                          adata_size,
+                                          p_nonce,
+                                          (size_t)nonce_size,
+                                          p_ctx->key);
+    }
+    else if (operation == NRF_CRYPTO_DECRYPT)
+    {
+        result = occ_chacha20_poly1305_decrypt_aad(p_mac,
+                                                   p_data_out,
+                                                   p_data_in,
+                                                   data_in_size,
+                                                   p_adata,
+                                                   adata_size,
+                                                   p_nonce,
+                                                   (size_t)nonce_size,
+                                                   p_ctx->key);
+
+        if (result != 0)
+        {
+            return NRF_ERROR_CRYPTO_AEAD_INVALID_MAC;
+        }
+    }
+    else
+    {
+        return NRF_ERROR_CRYPTO_INVALID_PARAM;
+    }
+
+    return NRF_SUCCESS;
+}
+
+nrf_crypto_aead_info_t const g_nrf_crypto_chacha_poly_256_info =
+{
+    .key_size  = NRF_CRYPTO_KEY_SIZE_256,
+    .mode      = NRF_CRYPTO_AEAD_MODE_CHACHA_POLY,
+
+    .init_fn   = backend_cc310_init,
+    .uninit_fn = backend_cc310_uninit,
+    .crypt_fn  = backend_cc310_crypt
+};
+
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_CC310_CHACHA_POLY_AEAD)
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO)
+
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/oberon/oberon_backend_chacha_poly_aead.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/oberon/oberon_backend_chacha_poly_aead.h
new file mode 100644
index 0000000..990db3e
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/oberon/oberon_backend_chacha_poly_aead.h
@@ -0,0 +1,100 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef OBERON_BACKEND_CHACHA_POLY_AEAD_H__
+#define OBERON_BACKEND_CHACHA_POLY_AEAD_H__
+
+/** @file
+ *
+ * @defgroup nrf_crypto_oberon_backend_chacha_poly_aead nrf_crypto Oberon backend CHACHA_POLY AEAD
+ * @{
+ * @ingroup nrf_crypto_oberon_backend
+ *
+ * @brief AES AEAD functionality provided by the nrf_crypto Oberon backend.
+ */
+
+#include "sdk_config.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON)
+
+#include "nrf_crypto_aead_shared.h"
+#include "occ_chacha20_poly1305.h"
+#include "nrf_crypto_error.h"
+#include "nrf_crypto_types.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define NRF_CRYPTO_OBERON_CHACHA_POLY_BACKEND_KEY_SIZE (32)
+
+/* CHACHA-POLY */
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_CHACHA_POLY)
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_CHACHA_POLY)
+#error "Duplicate definition of CHACHA-POLY mode. More than one backend enabled");
+#endif
+#define NRF_CRYPTO_CHACHA_POLY_ENABLED  1
+#undef  NRF_CRYPTO_AEAD_ENABLED
+#define NRF_CRYPTO_AEAD_ENABLED  1  // Flag that nrf_crypto_aead frontend can be compiled
+#undef  NRF_CRYPTO_OBERON_CHACHA_POLY_AEAD_ENABLED
+#define NRF_CRYPTO_OBERON_CHACHA_POLY_AEAD_ENABLED   1   // aead backend for Oberon can be compiled
+
+/* defines for test purposes */
+#define NRF_CRYPTO_AES_CHACHA_POLY_256_ENABLED  1
+
+typedef struct
+{
+    nrf_crypto_aead_internal_context_t header;  /**< Common header for context. */
+
+    uint8_t key[NRF_CRYPTO_OBERON_CHACHA_POLY_BACKEND_KEY_SIZE];
+} nrf_crypto_backend_chacha_poly_context_t;
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON)
+
+/** @} */
+
+#endif // OBERON_BACKEND_CHACHA_POLY_AEAD_H__
+
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/oberon/oberon_backend_ecc.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/oberon/oberon_backend_ecc.c
new file mode 100644
index 0000000..ed8f510
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/oberon/oberon_backend_ecc.c
@@ -0,0 +1,458 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#include "sdk_config.h"
+#include "nordic_common.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON)
+
+#include <stdbool.h>
+#include <string.h>
+#include <stddef.h>
+
+#include "app_util.h"
+#include "nrf_crypto_ecc.h"
+#include "nrf_crypto_mem.h"
+#include "nrf_crypto_rng.h"
+#include "nrf_crypto_shared.h"
+#include "oberon_backend_ecc.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_ECC_SECP256R1)
+#include "occ_ecdh_p256.h"
+#endif
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_ECC_CURVE25519)
+#include "occ_curve25519.h"
+#endif
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_ECC_ED25519)
+#include "occ_ed25519.h"
+#endif
+
+
+/** @internal @brief Structure holding private key common to all curves implemented by the Oberon.
+ */
+typedef struct
+{
+    nrf_crypto_internal_ecc_key_header_t header;  /**< @internal @brief Common ECC key header. */
+    uint8_t key[32];                              /**< @internal @brief Raw key. */
+} nrf_crypto_backend_oberon_private_key_t;
+
+
+/** @internal @brief Structure holding public key common to all curves implemented by the Oberon.
+ */
+typedef struct
+{
+    nrf_crypto_internal_ecc_key_header_t header;  /**< @internal @brief Common ECC key header. */
+    uint8_t key[64];                              /**< @internal @brief Raw key. */
+} nrf_crypto_backend_oberon_public_key_t;
+
+
+/** @internal @brief Function to hold copy function (can be simple mem copy or copy with endian swap).
+ */
+typedef void (*copy_fn_t)(void * p_dest, void const * p_src, size_t size);
+
+
+ret_code_t nrf_crypto_backend_oberon_private_key_to_raw(
+    void    const * p_private_key,
+    uint8_t       * p_raw_data)
+{
+    nrf_crypto_backend_oberon_private_key_t const * p_prv =
+        (nrf_crypto_backend_oberon_private_key_t const *)p_private_key;
+
+    //lint -save -e611 (Suspicious cast)
+    copy_fn_t copy_fn = (copy_fn_t)p_prv->header.p_info->p_backend_data;
+    //lint -restore
+
+    copy_fn(p_raw_data, p_prv->key, p_prv->header.p_info->raw_private_key_size);
+
+    return NRF_SUCCESS;
+}
+
+
+ret_code_t nrf_crypto_backend_oberon_public_key_from_raw(
+    void          * p_public_key,
+    uint8_t const * p_raw_data)
+{
+    nrf_crypto_backend_oberon_public_key_t * p_pub =
+        (nrf_crypto_backend_oberon_public_key_t *)p_public_key;
+
+    //lint -save -e611 (Suspicious cast)
+    copy_fn_t copy_fn = (copy_fn_t)p_pub->header.p_info->p_backend_data;
+    //lint -restore
+
+    copy_fn(p_pub->key, p_raw_data, p_pub->header.p_info->raw_public_key_size);
+
+    return NRF_SUCCESS;
+}
+
+
+ret_code_t nrf_crypto_backend_oberon_public_key_to_raw(
+    void const * p_public_key,
+    uint8_t    * p_raw_data)
+{
+    nrf_crypto_backend_oberon_public_key_t const * p_pub =
+        (nrf_crypto_backend_oberon_public_key_t const *)p_public_key;
+
+    //lint -save -e611 (Suspicious cast)
+    copy_fn_t copy_fn = (copy_fn_t)p_pub->header.p_info->p_backend_data;
+    //lint -restore
+
+    copy_fn(p_raw_data, p_pub->key, p_pub->header.p_info->raw_public_key_size);
+
+    return NRF_SUCCESS;
+}
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_ECC_SECP256R1) \
+    || NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_ECC_CURVE25519)
+
+
+ret_code_t nrf_crypto_backend_oberon_private_key_from_raw(
+    void          * p_private_key,
+    uint8_t const * p_raw_data)
+{
+    nrf_crypto_backend_oberon_private_key_t * p_prv =
+        (nrf_crypto_backend_oberon_private_key_t *)p_private_key;
+
+    //lint -save -e611 (Suspicious cast)
+    copy_fn_t copy_fn = (copy_fn_t)p_prv->header.p_info->p_backend_data;
+    //lint -restore
+
+    copy_fn(p_prv->key, p_raw_data, p_prv->header.p_info->raw_private_key_size);
+
+    return NRF_SUCCESS;
+}
+
+
+#endif //NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_ECC_SECP256R1) || NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_ECC_CURVE25519)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_ECC_CURVE25519) \
+    || NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_ECC_ED25519)
+
+
+static ret_code_t oberon_vector_generate(uint8_t * p_data, size_t size)
+{
+#if defined(NRF_CRYPTO_RNG_ENABLED) && (NRF_CRYPTO_RNG_ENABLED == 1)
+
+    return nrf_crypto_rng_vector_generate(p_data, size);
+
+#elif defined(NRF_CRYPTO_RNG_ENABLED) && (NRF_CRYPTO_RNG_ENABLED == 0)
+
+    return NRF_ERROR_CRYPTO_FEATURE_UNAVAILABLE;
+
+#else
+
+    #warning NRF_CRYPTO_RNG_ENABLED define not found in sdk_config.h (Is the sdk_config.h valid?).
+
+#endif
+}
+
+
+#endif //NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_ECC_CURVE25519) || NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_ECC_ED25519)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_ECC_SECP256R1)
+
+
+// Make sure that common key structure match secp256r1 key structure to safely cast types.
+STATIC_ASSERT(offsetof(nrf_crypto_backend_oberon_private_key_t, key) ==
+              offsetof(nrf_crypto_backend_secp256r1_private_key_t, key),
+              "Common Oberon private key structure does not match secp256r1 one.");
+STATIC_ASSERT(offsetof(nrf_crypto_backend_oberon_public_key_t, key) ==
+              offsetof(nrf_crypto_backend_secp256r1_public_key_t, key),
+              "Common Oberon public key structure does not match secp256r1 one.");
+
+
+ret_code_t nrf_crypto_backend_oberon_ecc_secp256r1_rng(uint8_t data[32])
+{
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_RNG)
+
+    static const uint8_t min_value[32] =
+    {
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    };
+    static const uint8_t max_value[32] =
+    {
+        0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+        0xBC, 0xE6, 0xFA, 0xAD, 0xA7, 0x17, 0x9E, 0x84, 0xF3, 0xB9, 0xCA, 0xC2, 0xFC, 0x63, 0x25, 0x50,
+    };
+    return nrf_crypto_rng_vector_generate_in_range(data, min_value, max_value, 32);
+
+#else
+    return NRF_ERROR_CRYPTO_FEATURE_UNAVAILABLE;
+#endif
+}
+
+
+ret_code_t nrf_crypto_backend_secp256r1_key_pair_generate(
+    void * p_context,
+    void * p_private_key,
+    void * p_public_key)
+{
+    int result;
+
+    nrf_crypto_backend_secp256r1_private_key_t * p_prv =
+        (nrf_crypto_backend_secp256r1_private_key_t *)p_private_key;
+
+    nrf_crypto_backend_secp256r1_public_key_t * p_pub =
+        (nrf_crypto_backend_secp256r1_public_key_t *)p_public_key;
+
+    result = nrf_crypto_backend_oberon_ecc_secp256r1_rng(p_prv->key);
+
+    if (result != NRF_SUCCESS)
+    {
+        return result;
+    }
+
+    result = occ_ecdh_p256_public_key(p_pub->key, p_prv->key);
+
+    if (result != 0)
+    {
+        return NRF_ERROR_CRYPTO_INTERNAL;
+    }
+    return NRF_SUCCESS;
+}
+
+
+ret_code_t nrf_crypto_backend_secp256r1_public_key_calculate(
+    void       * p_context,
+    void const * p_private_key,
+    void       * p_public_key)
+{
+    int result;
+
+    nrf_crypto_backend_secp256r1_private_key_t const * p_prv =
+        (nrf_crypto_backend_secp256r1_private_key_t const *)p_private_key;
+
+    nrf_crypto_backend_secp256r1_public_key_t * p_pub =
+        (nrf_crypto_backend_secp256r1_public_key_t *)p_public_key;
+
+    result = occ_ecdh_p256_public_key(p_pub->key, p_prv->key);
+
+    if (result != 0)
+    {
+        return NRF_ERROR_CRYPTO_INTERNAL;
+    }
+    return NRF_SUCCESS;
+}
+
+
+const nrf_crypto_ecc_curve_info_t g_nrf_crypto_ecc_secp256r1_curve_info =
+{
+    .public_key_size      = sizeof(nrf_crypto_backend_secp256r1_public_key_t),
+    .private_key_size     = sizeof(nrf_crypto_backend_secp256r1_private_key_t),
+    .curve_type           = NRF_CRYPTO_ECC_SECP256R1_CURVE_TYPE,
+    .raw_private_key_size = NRF_CRYPTO_ECC_SECP256R1_RAW_PRIVATE_KEY_SIZE,
+    .raw_public_key_size  = NRF_CRYPTO_ECC_SECP256R1_RAW_PUBLIC_KEY_SIZE,
+    //lint -save -e611 -e546 (Suspicious cast, Suspicious use of &)
+    .p_backend_data       = (void *)&memcpy,
+    //lint -restore
+};
+
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_ECC_SECP256R1)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_ECC_CURVE25519)
+
+
+// Make sure that common key structure match Curve25519 key structure to safely cast types.
+STATIC_ASSERT(offsetof(nrf_crypto_backend_oberon_private_key_t, key) ==
+              offsetof(nrf_crypto_backend_curve25519_private_key_t, key),
+              "Common Oberon private key structure does not match Curve25519 one.");
+STATIC_ASSERT(offsetof(nrf_crypto_backend_oberon_public_key_t, key) ==
+              offsetof(nrf_crypto_backend_curve25519_public_key_t, key),
+              "Common Oberon public key structure does not match Curve25519 one.");
+
+
+ret_code_t nrf_crypto_backend_curve25519_key_pair_generate(
+    void * p_context,
+    void * p_private_key,
+    void * p_public_key)
+{
+    ret_code_t result;
+
+    nrf_crypto_backend_curve25519_private_key_t * p_prv =
+        (nrf_crypto_backend_curve25519_private_key_t *)p_private_key;
+
+    nrf_crypto_backend_curve25519_public_key_t * p_pub =
+        (nrf_crypto_backend_curve25519_public_key_t *)p_public_key;
+
+    result = oberon_vector_generate(p_prv->key, sizeof(p_prv->key));
+
+    if (result != NRF_SUCCESS)
+    {
+        return result;
+    }
+
+    p_prv->key[0]  &= 0xF8; // Private key is multiply of 8 (by definition), so lower 3 bits are 0.
+    p_prv->key[31] &= 0x7F; // Highest bit has to be 0, because private key is 255-bit long.
+    p_prv->key[31] |= 0x40; // Bit 254 has to be 1 (by definition)
+
+    occ_curve25519_scalarmult_base(p_pub->key, p_prv->key);
+
+    return NRF_SUCCESS;
+}
+
+
+ret_code_t nrf_crypto_backend_curve25519_public_key_calculate(
+    void       * p_context,
+    void const * p_private_key,
+    void       * p_public_key)
+{
+    nrf_crypto_backend_curve25519_private_key_t * p_prv =
+        (nrf_crypto_backend_curve25519_private_key_t *)p_private_key;
+
+    nrf_crypto_backend_curve25519_public_key_t * p_pub =
+        (nrf_crypto_backend_curve25519_public_key_t *)p_public_key;
+
+    // Private key bit fixing is done inside Oberon library.
+    occ_curve25519_scalarmult_base(p_pub->key, p_prv->key);
+
+    return NRF_SUCCESS;
+}
+
+
+const nrf_crypto_ecc_curve_info_t g_nrf_crypto_ecc_curve25519_curve_info =
+{
+    .public_key_size      = sizeof(nrf_crypto_backend_curve25519_public_key_t),
+    .private_key_size     = sizeof(nrf_crypto_backend_curve25519_private_key_t),
+    .curve_type           = NRF_CRYPTO_ECC_CURVE25519_CURVE_TYPE,
+    .raw_private_key_size = NRF_CRYPTO_ECC_CURVE25519_RAW_PRIVATE_KEY_SIZE,
+    .raw_public_key_size  = NRF_CRYPTO_ECC_CURVE25519_RAW_PUBLIC_KEY_SIZE,
+    //lint -save -e611 -e546 (Suspicious cast, Suspicious use of &)
+    .p_backend_data       = (void *)&nrf_crypto_internal_swap_endian,
+    //lint -restore
+};
+
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_ECC_CURVE25519)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_ECC_ED25519)
+
+
+// Make sure that common key structure match Ed25519 key structure to safely cast types.
+STATIC_ASSERT(offsetof(nrf_crypto_backend_oberon_private_key_t, key) ==
+              offsetof(nrf_crypto_backend_ed25519_private_key_t, private_part),
+              "Common Oberon private key structure does not match Ed25519 one.");
+STATIC_ASSERT(offsetof(nrf_crypto_backend_oberon_public_key_t, key) ==
+              offsetof(nrf_crypto_backend_ed25519_public_key_t, key),
+              "Common Oberon public key structure does not match Ed25519 one.");
+
+
+ret_code_t nrf_crypto_backend_ed25519_private_key_from_raw(
+    void          * p_private_key,
+    uint8_t const * p_raw_data)
+{
+    nrf_crypto_backend_ed25519_private_key_t * p_prv =
+        (nrf_crypto_backend_ed25519_private_key_t *)p_private_key;
+
+    memcpy(p_prv->private_part, p_raw_data, sizeof(p_prv->private_part));
+
+    occ_ed25519_public_key(p_prv->public_part, p_prv->private_part);
+
+    return NRF_SUCCESS;
+}
+
+
+ret_code_t nrf_crypto_backend_ed25519_key_pair_generate(
+    void * p_context,
+    void * p_private_key,
+    void * p_public_key)
+{
+    ret_code_t result;
+
+    nrf_crypto_backend_ed25519_private_key_t * p_prv =
+        (nrf_crypto_backend_ed25519_private_key_t *)p_private_key;
+
+    nrf_crypto_backend_ed25519_public_key_t * p_pub =
+        (nrf_crypto_backend_ed25519_public_key_t *)p_public_key;
+
+    result = oberon_vector_generate(p_prv->private_part, sizeof(p_prv->private_part));
+
+    if (result != NRF_SUCCESS)
+    {
+        return result;
+    }
+
+    occ_ed25519_public_key(p_prv->public_part, p_prv->private_part);
+
+    memcpy(p_pub->key, p_prv->public_part, sizeof(p_pub->key));
+
+    return NRF_SUCCESS;
+}
+
+
+ret_code_t nrf_crypto_backend_ed25519_public_key_calculate(
+    void       * p_context,
+    void const * p_private_key,
+    void       * p_public_key)
+{
+    nrf_crypto_backend_ed25519_private_key_t * p_prv =
+        (nrf_crypto_backend_ed25519_private_key_t *)p_private_key;
+
+    nrf_crypto_backend_ed25519_public_key_t * p_pub =
+        (nrf_crypto_backend_ed25519_public_key_t *)p_public_key;
+
+    memcpy(p_pub->key, p_prv->public_part, sizeof(p_pub->key));
+
+    return NRF_SUCCESS;
+}
+
+
+const nrf_crypto_ecc_curve_info_t g_nrf_crypto_ecc_ed25519_curve_info =
+{
+    .public_key_size      = sizeof(nrf_crypto_backend_ed25519_public_key_t),
+    .private_key_size     = sizeof(nrf_crypto_backend_ed25519_private_key_t),
+    .curve_type           = NRF_CRYPTO_ECC_ED25519_CURVE_TYPE,
+    .raw_private_key_size = NRF_CRYPTO_ECC_ED25519_RAW_PRIVATE_KEY_SIZE,
+    .raw_public_key_size  = NRF_CRYPTO_ECC_ED25519_RAW_PUBLIC_KEY_SIZE,
+    //lint -save -e611 -e546 (Suspicious cast, Suspicious use of &)
+    .p_backend_data       = (void *)&memcpy,
+    //lint -restore
+};
+
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_ECC_ED25519)
+
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON)
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/oberon/oberon_backend_ecc.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/oberon/oberon_backend_ecc.h
new file mode 100644
index 0000000..2fa7d1e
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/oberon/oberon_backend_ecc.h
@@ -0,0 +1,314 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef OBERON_BACKEND_ECC_H__
+#define OBERON_BACKEND_ECC_H__
+
+#include "sdk_config.h"
+#include "nordic_common.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON)
+
+#include <stdint.h>
+#include <stdbool.h>
+#include "nrf_crypto_ecc_shared.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/** @internal See @ref nrf_crypto_backend_ecc_private_key_from_raw_fn_t.
+*/
+ret_code_t nrf_crypto_backend_oberon_private_key_from_raw(
+    void          * p_private_key,
+    uint8_t const * p_raw_data);
+
+
+/** @internal See @ref nrf_crypto_backend_ecc_private_key_to_raw_fn_t.
+*/
+ret_code_t nrf_crypto_backend_oberon_private_key_to_raw(
+    void    const * p_private_key,
+    uint8_t       * p_raw_data);
+
+
+/** @internal See @ref nrf_crypto_backend_ecc_public_key_from_raw_fn_t.
+*/
+ret_code_t nrf_crypto_backend_oberon_public_key_from_raw(
+    void          * p_public_key,
+    uint8_t const * p_raw_data);
+
+
+/** @internal See @ref nrf_crypto_backend_ecc_public_key_to_raw_fn_t.
+*/
+ret_code_t nrf_crypto_backend_oberon_public_key_to_raw(
+    void const * p_public_key,
+    uint8_t    * p_raw_data);
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_ECC_SECP256R1)
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_ECC_SECP256R1)
+#error "More than one backend enabled for secp256r1 (NIST 256-bit).");
+#endif
+#define NRF_CRYPTO_ECC_SECP256R1_ENABLED 1
+
+
+/** @internal @brief Generates random number that can be used as a private key for secp256r1.
+ *
+ *  It uses RNG from libary frontend to generate random numbers.
+ *
+ *  @param[out] data    Array where generated random number will be placed.
+ *  @returns            NRF_SUCCESS or error code passed from RNG frontend.
+ */
+ret_code_t nrf_crypto_backend_oberon_ecc_secp256r1_rng(uint8_t data[32]);
+
+
+/** @internal @brief Structure holding private key for Oberon's secp256r1.
+ */
+typedef struct
+{
+    nrf_crypto_internal_ecc_key_header_t header;  /**< @internal @brief Common ECC key header. */
+    uint8_t key[32];                              /**< @internal @brief Raw key. */
+} nrf_crypto_backend_secp256r1_private_key_t;
+
+
+/** @internal @brief Structure holding public key for Oberon's secp256r1.
+ */
+typedef struct
+{
+    nrf_crypto_internal_ecc_key_header_t header;  /**< @internal @brief Common ECC key header. */
+    uint8_t key[64];                              /**< @internal @brief Raw key. */
+} nrf_crypto_backend_secp256r1_public_key_t;
+
+
+/** @internal See @ref nrf_crypto_backend_ecc_key_pair_generate_fn_t.
+ */
+ret_code_t nrf_crypto_backend_secp256r1_key_pair_generate(
+    void * p_context,
+    void * p_private_key,
+    void * p_public_key);
+
+
+/** @internal See @ref nrf_crypto_backend_ecc_public_key_calculate_fn_t.
+*/
+ret_code_t nrf_crypto_backend_secp256r1_public_key_calculate(
+    void       * p_context,
+    void const * p_private_key,
+    void       * p_public_key);
+
+
+// Common key conversion functions
+#define nrf_crypto_backend_secp256r1_private_key_from_raw \
+    nrf_crypto_backend_oberon_private_key_from_raw
+#define nrf_crypto_backend_secp256r1_private_key_to_raw \
+    nrf_crypto_backend_oberon_private_key_to_raw
+#define nrf_crypto_backend_secp256r1_public_key_from_raw \
+    nrf_crypto_backend_oberon_public_key_from_raw
+#define nrf_crypto_backend_secp256r1_public_key_to_raw \
+    nrf_crypto_backend_oberon_public_key_to_raw
+
+// Free is not required for oberon keys
+#define nrf_crypto_backend_secp256r1_private_key_free NULL
+#define nrf_crypto_backend_secp256r1_public_key_free NULL
+
+// Context is not used in oberon functions
+#define NRF_CRYPTO_BACKEND_SECP256R1_KEY_PAIR_GENERATE_CONTEXT_SIZE 0
+#define NRF_CRYPTO_BACKEND_SECP256R1_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE 0
+
+// Dummy typedef for unused context
+typedef uint32_t nrf_crypto_backend_secp256r1_key_pair_generate_context_t;
+typedef uint32_t nrf_crypto_backend_secp256r1_public_key_calculate_context_t;
+
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_ECC_SECP256R1)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_ECC_CURVE25519)
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_ECC_CURVE25519)
+#error "More than one backend enabled for Curve25519.");
+#endif
+#define NRF_CRYPTO_ECC_CURVE25519_ENABLED 1
+
+
+/** @internal @brief Structure holding private key for Oberon's Curve25519.
+ */
+typedef struct
+{
+    nrf_crypto_internal_ecc_key_header_t header;  /**< @internal @brief Common ECC key header. */
+    uint8_t key[32];                              /**< @internal @brief Raw key in little endian order. */
+} nrf_crypto_backend_curve25519_private_key_t;
+
+
+/** @internal @brief Structure holding public key for Oberon's Curve25519.
+ */
+typedef struct
+{
+    nrf_crypto_internal_ecc_key_header_t header; /**< @internal @brief Common ECC key header. */
+    uint8_t key[32];                             /**< @internal @brief Raw key in little endian order. */
+} nrf_crypto_backend_curve25519_public_key_t;
+
+
+/** @internal See @ref nrf_crypto_backend_ecc_key_pair_generate_fn_t.
+ */
+ret_code_t nrf_crypto_backend_curve25519_key_pair_generate(
+    void * p_context,
+    void * p_private_key,
+    void * p_public_key);
+
+
+/** @internal See @ref nrf_crypto_backend_ecc_public_key_calculate_fn_t.
+*/
+ret_code_t nrf_crypto_backend_curve25519_public_key_calculate(
+    void       * p_context,
+    void const * p_private_key,
+    void       * p_public_key);
+
+
+// Common key conversion functions
+#define nrf_crypto_backend_curve25519_private_key_from_raw \
+    nrf_crypto_backend_oberon_private_key_from_raw
+#define nrf_crypto_backend_curve25519_private_key_to_raw \
+    nrf_crypto_backend_oberon_private_key_to_raw
+#define nrf_crypto_backend_curve25519_public_key_from_raw \
+    nrf_crypto_backend_oberon_public_key_from_raw
+#define nrf_crypto_backend_curve25519_public_key_to_raw \
+    nrf_crypto_backend_oberon_public_key_to_raw
+
+// Free is not required for oberon keys
+#define nrf_crypto_backend_curve25519_private_key_free NULL
+#define nrf_crypto_backend_curve25519_public_key_free NULL
+
+// Context is not used in oberon functions
+#define NRF_CRYPTO_BACKEND_CURVE25519_KEY_PAIR_GENERATE_CONTEXT_SIZE 0
+#define NRF_CRYPTO_BACKEND_CURVE25519_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE 0
+
+// Dummy typedef for unused context
+typedef uint32_t nrf_crypto_backend_curve25519_key_pair_generate_context_t;
+typedef uint32_t nrf_crypto_backend_curve25519_public_key_calculate_context_t;
+
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_ECC_CURVE25519)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_ECC_ED25519)
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_ECC_ED25519)
+#error "More than one backend enabled for Ed25519.");
+#endif
+#define NRF_CRYPTO_ECC_ED25519_ENABLED 1
+
+
+
+/** @internal @brief Structure holding private key for Oberon's Ed25519.
+ */
+typedef struct
+{
+    nrf_crypto_internal_ecc_key_header_t header; /**< @internal @brief Common ECC key header. */
+    uint8_t private_part[32];                    /**< @internal @brief Raw private key. */
+    uint8_t public_part[32];                     /**< @internal @brief Raw public key. It is also required for Ed25519 signing. */
+} nrf_crypto_backend_ed25519_private_key_t;
+
+
+/** @internal @brief Structure holding private key for Oberon's Ed25519.
+ */
+typedef struct
+{
+    nrf_crypto_internal_ecc_key_header_t header; /**< @internal @brief Common ECC key header. */
+    uint8_t key[32];                             /**< @internal @brief Raw key. */
+} nrf_crypto_backend_ed25519_public_key_t;
+
+
+/** @internal See @ref nrf_crypto_backend_ecc_private_key_from_raw_fn_t.
+*/
+ret_code_t nrf_crypto_backend_ed25519_private_key_from_raw(
+    void          * p_private_key,
+    uint8_t const * p_raw_data);
+
+
+/** @internal See @ref nrf_crypto_backend_ecc_key_pair_generate_fn_t.
+ */
+ret_code_t nrf_crypto_backend_ed25519_key_pair_generate(
+    void * p_context,
+    void * p_private_key,
+    void * p_public_key);
+
+
+/** @internal See @ref nrf_crypto_backend_ecc_public_key_calculate_fn_t.
+*/
+ret_code_t nrf_crypto_backend_ed25519_public_key_calculate(
+    void       * p_context,
+    void const * p_private_key,
+    void       * p_public_key);
+
+
+// Common key conversion functions
+#define nrf_crypto_backend_ed25519_private_key_to_raw \
+    nrf_crypto_backend_oberon_private_key_to_raw
+#define nrf_crypto_backend_ed25519_public_key_from_raw \
+    nrf_crypto_backend_oberon_public_key_from_raw
+#define nrf_crypto_backend_ed25519_public_key_to_raw \
+    nrf_crypto_backend_oberon_public_key_to_raw
+
+// Free is not required for oberon keys
+#define nrf_crypto_backend_ed25519_private_key_free NULL
+#define nrf_crypto_backend_ed25519_public_key_free NULL
+
+// Context is not used in oberon functions
+#define NRF_CRYPTO_BACKEND_ED25519_KEY_PAIR_GENERATE_CONTEXT_SIZE 0
+#define NRF_CRYPTO_BACKEND_ED25519_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE 0
+
+// Dummy typedef for unused context
+typedef uint32_t nrf_crypto_backend_ed25519_key_pair_generate_context_t;
+typedef uint32_t nrf_crypto_backend_ed25519_public_key_calculate_context_t;
+
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_ECC_ED25519)
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON)
+
+#endif // OBERON_BACKEND_ECC_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/oberon/oberon_backend_ecdh.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/oberon/oberon_backend_ecdh.c
new file mode 100644
index 0000000..9dcba96
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/oberon/oberon_backend_ecdh.c
@@ -0,0 +1,114 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#include "sdk_config.h"
+#include "nordic_common.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON)
+
+#include <stdint.h>
+
+#include "nrf_crypto_ecc.h"
+#include "nrf_crypto_ecdh.h"
+#include "nrf_crypto_shared.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_ECC_SECP256R1)
+#include "occ_ecdh_p256.h"
+#endif
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_ECC_CURVE25519)
+#include "occ_curve25519.h"
+#endif
+
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_ECC_SECP256R1)
+
+ret_code_t nrf_crypto_backend_secp256r1_ecdh_compute(
+    void       * p_context,
+    void const * p_private_key,
+    void const * p_public_key,
+    uint8_t    * p_shared_secret)
+{
+    int result;
+
+    nrf_crypto_backend_secp256r1_private_key_t const * p_prv =
+        (nrf_crypto_backend_secp256r1_private_key_t const *)p_private_key;
+
+    nrf_crypto_backend_secp256r1_public_key_t const * p_pub =
+        (nrf_crypto_backend_secp256r1_public_key_t const *)p_public_key;
+
+    result = occ_ecdh_p256_common_secret(p_shared_secret, p_prv->key, p_pub->key);
+
+    if (result != 0)
+    {
+        return NRF_ERROR_CRYPTO_INTERNAL;
+    }
+    return NRF_SUCCESS;
+}
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_ECC_SECP256R1)
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_ECC_CURVE25519)
+
+ret_code_t nrf_crypto_backend_curve25519_ecdh_compute(
+    void       * p_context,
+    void const * p_private_key,
+    void const * p_public_key,
+    uint8_t    * p_shared_secret)
+{
+    nrf_crypto_backend_curve25519_private_key_t const * p_prv =
+        (nrf_crypto_backend_curve25519_private_key_t const *)p_private_key;
+
+    nrf_crypto_backend_curve25519_public_key_t const * p_pub =
+        (nrf_crypto_backend_curve25519_public_key_t const *)p_public_key;
+
+    // Private key can be completely random at this point.
+    // Oberon library updates bits in the key according to Curve25519 specification before use.
+    occ_curve25519_scalarmult(p_shared_secret, p_prv->key, p_pub->key);
+
+    nrf_crypto_internal_swap_endian_in_place(p_shared_secret,
+                                             NRF_CRYPTO_ECDH_CURVE25519_SHARED_SECRET_SIZE);
+
+    return NRF_SUCCESS;
+}
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_ECC_CURVE25519)
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON)
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/oberon/oberon_backend_ecdh.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/oberon/oberon_backend_ecdh.h
new file mode 100644
index 0000000..85dd0d0
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/oberon/oberon_backend_ecdh.h
@@ -0,0 +1,108 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef OBERON_BACKEND_ECDH_H__
+#define OBERON_BACKEND_ECDH_H__
+
+#include "sdk_config.h"
+#include "nordic_common.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON)
+
+#include <stdint.h>
+#include "nrf_crypto_ecc.h"
+#include "nrf_crypto_ecdh_shared.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_ECC_SECP256R1)
+
+
+/** @internal See @ref nrf_crypto_backend_ecdh_compute_fn_t.
+ */
+ret_code_t nrf_crypto_backend_secp256r1_ecdh_compute(
+    void       * p_context,
+    void const * p_private_key,
+    void const * p_public_key,
+    uint8_t    * p_shared_secret);
+
+// Context in not used in OBERON backend
+typedef uint32_t nrf_crypto_backend_secp256r1_ecdh_context_t;
+#define NRF_CRYPTO_BACKEND_SECP256R1_ECDH_CONTEXT_SIZE 0
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_ECC_SECP256R1)
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_ECC_CURVE25519)
+
+/** @internal See @ref nrf_crypto_backend_ecdh_compute_fn_t.
+ */
+ret_code_t nrf_crypto_backend_curve25519_ecdh_compute(
+    void       * p_context,
+    void const * p_private_key,
+    void const * p_public_key,
+    uint8_t    * p_shared_secret);
+
+// Context in not used in OBERON backend
+typedef uint32_t nrf_crypto_backend_curve25519_ecdh_context_t;
+#define NRF_CRYPTO_BACKEND_CURVE25519_ECDH_CONTEXT_SIZE 0
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_ECC_CURVE25519)
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_ECC_ED25519)
+
+// ECDH is not possible for Ed25519
+#define nrf_crypto_backend_ed25519_ecdh_compute NULL
+typedef uint32_t nrf_crypto_backend_ed25519_ecdh_context_t;
+#define NRF_CRYPTO_BACKEND_ED25519_ECDH_CONTEXT_SIZE 0
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_ECC_ED25519)
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON)
+
+#endif // OBERON_BACKEND_ECDH_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/oberon/oberon_backend_ecdsa.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/oberon/oberon_backend_ecdsa.c
new file mode 100644
index 0000000..5bbfc18
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/oberon/oberon_backend_ecdsa.c
@@ -0,0 +1,166 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#include "sdk_config.h"
+#include "nordic_common.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON)
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <string.h>
+
+#include "nrf_crypto_ecc.h"
+#include "nrf_crypto_rng.h"
+#include "nrf_crypto_ecdsa.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_ECC_SECP256R1)
+
+#include "occ_ecdsa_p256.h"
+
+
+#define OBERON_HASH_SIZE_FOR_SECP256R1 (256 / 8)
+
+
+ret_code_t nrf_crypto_backend_secp256r1_sign(
+    void          * p_context,
+    void    const * p_private_key,
+    uint8_t const * p_data,
+    size_t          data_size,
+    uint8_t       * p_signature)
+{
+    int     result;
+    uint8_t session_key[32];
+
+    nrf_crypto_backend_secp256r1_private_key_t const * p_prv =
+        (nrf_crypto_backend_secp256r1_private_key_t const *)p_private_key;
+
+    if (data_size < OBERON_HASH_SIZE_FOR_SECP256R1)
+    {
+        return NRF_ERROR_CRYPTO_INPUT_LENGTH;
+    }
+
+    result = nrf_crypto_backend_oberon_ecc_secp256r1_rng(session_key);
+    if (result != NRF_SUCCESS)
+    {
+        return result;
+    }
+
+    result = occ_ecdsa_p256_sign_hash(p_signature, p_data, p_prv->key, session_key);
+
+    return result == 0 ? NRF_SUCCESS : NRF_ERROR_CRYPTO_INTERNAL;
+}
+
+
+ret_code_t nrf_crypto_backend_secp256r1_verify(
+    void          * p_context,
+    void    const * p_public_key,
+    uint8_t const * p_data,
+    size_t          data_size,
+    uint8_t const * p_signature)
+{
+    int result;
+
+    nrf_crypto_backend_secp256r1_public_key_t const * p_pub =
+        (nrf_crypto_backend_secp256r1_public_key_t const *)p_public_key;
+
+    if (data_size < OBERON_HASH_SIZE_FOR_SECP256R1)
+    {
+        return NRF_ERROR_CRYPTO_INPUT_LENGTH;
+    }
+
+    result = occ_ecdsa_p256_verify_hash(p_signature, p_data, p_pub->key);
+
+    if (result != 0)
+    {
+        return NRF_ERROR_CRYPTO_ECDSA_INVALID_SIGNATURE;
+    }
+    return NRF_SUCCESS;
+}
+
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_ECC_SECP256R1)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_ECC_ED25519)
+
+#include "occ_ed25519.h"
+
+
+ret_code_t nrf_crypto_backend_ed25519_sign(
+    void          * p_context,
+    void    const * p_private_key,
+    uint8_t const * p_data,
+    size_t          data_size,
+    uint8_t       * p_signature)
+{
+    nrf_crypto_backend_ed25519_private_key_t const * p_prv =
+        (nrf_crypto_backend_ed25519_private_key_t const *)p_private_key;
+
+    occ_ed25519_sign(p_signature, p_data, data_size, p_prv->private_part, p_prv->public_part);
+
+    return NRF_SUCCESS;
+}
+
+ret_code_t nrf_crypto_backend_ed25519_verify(
+    void          * p_context,
+    void    const * p_public_key,
+    uint8_t const * p_data,
+    size_t          data_size,
+    uint8_t const * p_signature)
+{
+    int result;
+
+    nrf_crypto_backend_ed25519_public_key_t const * p_pub =
+        (nrf_crypto_backend_ed25519_public_key_t const *)p_public_key;
+
+    result = occ_ed25519_verify(p_signature, p_data, data_size, p_pub->key);
+
+    if (result != 0)
+    {
+        return NRF_ERROR_CRYPTO_ECDSA_INVALID_SIGNATURE;
+    }
+    return NRF_SUCCESS;
+}
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_ECC_ED25519)
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON)
+
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/oberon/oberon_backend_ecdsa.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/oberon/oberon_backend_ecdsa.h
new file mode 100644
index 0000000..070a8cf
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/oberon/oberon_backend_ecdsa.h
@@ -0,0 +1,141 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef OBERON_BACKEND_ECDSA_H__
+#define OBERON_BACKEND_ECDSA_H__
+
+#include "sdk_config.h"
+#include "nordic_common.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON)
+
+#include <stdint.h>
+#include "nrf_crypto_ecc_shared.h"
+#include "nrf_crypto_ecdsa_shared.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_ECC_SECP256R1)
+
+
+/** @internal See @ref nrf_crypto_backend_ecdsa_sign_fn_t.
+ */
+ret_code_t nrf_crypto_backend_secp256r1_sign(
+    void          * p_context,
+    void    const * p_private_key,
+    uint8_t const * p_data,
+    size_t          data_size,
+    uint8_t       * p_signature);
+
+
+/** @internal See @ref nrf_crypto_backend_ecdsa_verify_fn_t.
+ */
+ret_code_t nrf_crypto_backend_secp256r1_verify(
+    void          * p_context,
+    void    const * p_public_key,
+    uint8_t const * p_data,
+    size_t          data_size,
+    uint8_t const * p_signature);
+
+
+#define NRF_CRYPTO_BACKEND_SECP256R1_SIGN_CONTEXT_SIZE 0
+#define NRF_CRYPTO_BACKEND_SECP256R1_VERIFY_CONTEXT_SIZE 0
+typedef uint32_t nrf_crypto_backend_secp256r1_sign_context_t;
+typedef uint32_t nrf_crypto_backend_secp256r1_verify_context_t;
+
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_ECC_CURVE25519)
+
+// Curve25519 is not designed for ECDSA
+#define NRF_CRYPTO_BACKEND_CURVE25519_SIGN_CONTEXT_SIZE 0
+#define NRF_CRYPTO_BACKEND_CURVE25519_VERIFY_CONTEXT_SIZE 0
+typedef uint32_t nrf_crypto_backend_curve25519_sign_context_t;
+typedef uint32_t nrf_crypto_backend_curve25519_verify_context_t;
+#define nrf_crypto_backend_curve25519_sign NULL
+#define nrf_crypto_backend_curve25519_verify NULL
+
+#endif
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_ECC_ED25519)
+
+
+/** @internal See @ref nrf_crypto_backend_ecdsa_sign_fn_t.
+ */
+ret_code_t nrf_crypto_backend_ed25519_sign(
+    void          * p_context,
+    void    const * p_private_key,
+    uint8_t const * p_data,
+    size_t          data_size,
+    uint8_t       * p_signature);
+
+
+/** @internal See @ref nrf_crypto_backend_ecdsa_verify_fn_t.
+ */
+ret_code_t nrf_crypto_backend_ed25519_verify(
+    void          * p_context,
+    void    const * p_public_key,
+    uint8_t const * p_data,
+    size_t          data_size,
+    uint8_t const * p_signature);
+
+
+#define NRF_CRYPTO_BACKEND_ED25519_SIGN_CONTEXT_SIZE 0
+#define NRF_CRYPTO_BACKEND_ED25519_VERIFY_CONTEXT_SIZE 0
+typedef uint32_t nrf_crypto_backend_ed25519_sign_context_t;
+typedef uint32_t nrf_crypto_backend_ed25519_verify_context_t;
+
+
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON)
+
+#endif // OBERON_BACKEND_ECDSA_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/oberon/oberon_backend_hash.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/oberon/oberon_backend_hash.c
new file mode 100644
index 0000000..cf90e51
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/oberon/oberon_backend_hash.c
@@ -0,0 +1,184 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#include "sdk_common.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON)
+
+#include "oberon_backend_hash.h"
+#include "crys_hash.h"
+#include "crys_hash_error.h"
+#include "nrf_crypto_init.h"
+#include "nrf_crypto_types.h"
+#include "nrf_crypto_error.h"
+#include "nrf_crypto_hash_shared.h"
+#include "sdk_macros.h"
+#include "occ_sha256.h"
+#include "occ_sha512.h"
+#include "nrf_log.h"
+#include "nrf_assert.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_HASH_SHA256)
+
+static ret_code_t oberon_backend_hash_sha256_init(void * const p_context)
+{
+    // No parameter testing on this level.
+    // This has been done on upper level.
+
+    occ_sha256_ctx * p_backend_context
+        = &(((nrf_crypto_backend_hash_sha256_context_t *)p_context)->context);
+
+    occ_sha256_init(p_backend_context);
+
+    return NRF_SUCCESS;
+}
+
+
+static uint32_t oberon_backend_hash_sha256_update(void     * const p_context,
+                                                  uint8_t  const * p_data,
+                                                  size_t           size)
+{
+    // Limited parameter testing on this level.
+    // This has been done on upper level.
+
+    occ_sha256_ctx * p_backend_context
+        = &(((nrf_crypto_backend_hash_sha256_context_t *)p_context)->context);
+
+    occ_sha256_update(p_backend_context, p_data, size);
+
+    return NRF_SUCCESS;
+}
+
+
+static uint32_t oberon_backend_hash_sha256_finalize(void   * const p_context,
+                                                 uint8_t         * p_digest,
+                                                 size_t    * const p_digest_size)
+{
+    // Limited parameter testing on this level.
+    // This has been done on upper level.
+
+    occ_sha256_ctx * p_backend_context
+        = &(((nrf_crypto_backend_hash_sha256_context_t *)p_context)->context);
+
+    occ_sha256_final(p_digest, p_backend_context);
+
+    *p_digest_size = NRF_CRYPTO_HASH_SIZE_SHA256;
+
+    return NRF_SUCCESS;
+}
+
+
+const nrf_crypto_hash_info_t g_nrf_crypto_hash_sha256_info =
+{
+    .init_fn        = oberon_backend_hash_sha256_init,
+    .update_fn      = oberon_backend_hash_sha256_update,
+    .finalize_fn    = oberon_backend_hash_sha256_finalize,
+    .digest_size    = NRF_CRYPTO_HASH_SIZE_SHA256,
+    .context_size   = sizeof(nrf_crypto_backend_hash_sha256_context_t),
+    .hash_mode      = NRF_CRYPTO_HASH_MODE_SHA256
+};
+
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_HASH_SHA256)
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_HASH_SHA512)
+
+
+static ret_code_t oberon_backend_hash_sha512_init(void * p_context)
+{
+    // No parameter testing on this level.
+    // This has been done on upper level.
+
+    occ_sha512_ctx * p_backend_context
+        = &(((nrf_crypto_backend_hash_sha512_context_t *)p_context)->context);
+
+    occ_sha512_init(p_backend_context);
+
+    return NRF_SUCCESS;
+}
+
+
+static ret_code_t oberon_backend_hash_sha512_update(void    * const p_context,
+                                                    uint8_t const * p_data,
+                                                    size_t          size)
+{
+    // Limited parameter testing on this level.
+    // This has been done on upper level.
+
+    occ_sha512_ctx * p_backend_context
+        = &(((nrf_crypto_backend_hash_sha512_context_t *)p_context)->context);
+
+    occ_sha512_update(p_backend_context, p_data, size);
+
+    return NRF_SUCCESS;
+}
+
+
+static ret_code_t oberon_backend_hash_sha512_finalize(void  * const p_context,
+                                                 uint8_t          * p_digest,
+                                                 size_t     * const p_digest_size)
+{
+    // Limited parameter testing on this level.
+    // This has been done on upper level.
+
+    occ_sha512_ctx * p_backend_context
+        = &(((nrf_crypto_backend_hash_sha512_context_t *)p_context)->context);
+
+    occ_sha512_final(p_digest, p_backend_context);
+
+    *p_digest_size = NRF_CRYPTO_HASH_SIZE_SHA512;
+
+    return NRF_SUCCESS;
+}
+
+
+const nrf_crypto_hash_info_t g_nrf_crypto_hash_sha512_info =
+{
+    .init_fn        = oberon_backend_hash_sha512_init,
+    .update_fn      = oberon_backend_hash_sha512_update,
+    .finalize_fn    = oberon_backend_hash_sha512_finalize,
+    .digest_size    = NRF_CRYPTO_HASH_SIZE_SHA512,
+    .context_size   = sizeof(nrf_crypto_backend_hash_sha512_context_t),
+    .hash_mode      = NRF_CRYPTO_HASH_MODE_SHA512
+};
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_HASH_SHA512)
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON)
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/oberon/oberon_backend_hash.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/oberon/oberon_backend_hash.h
new file mode 100644
index 0000000..534f0ca
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/oberon/oberon_backend_hash.h
@@ -0,0 +1,123 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef OBERON_BACKEND_HASH_H__
+#define OBERON_BACKEND_HASH_H__
+
+/** @file
+ *
+ * @defgroup nrf_crypto_oberon_backend_hash Oberon backend hash
+ * @{
+ * @ingroup nrf_crypto_oberon_backend
+ *
+ * @brief Hash functionality provided by the Oberon nrf_crypto backend.
+ */
+#include "sdk_common.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON)
+
+#include "sdk_errors.h"
+#include "nrf_crypto_hash_shared.h"
+#include "occ_sha256.h"
+#include "occ_sha512.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_HASH_SHA256)
+
+// Flag that nrf_crypto_hash frontend can be compiled
+#undef  NRF_CRYPTO_HASH_ENABLED
+#define NRF_CRYPTO_HASH_ENABLED 1
+
+// Duplicate backend enabled test for SHA-256
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_HASH_SHA256)
+#error "Duplicate definition of SHA-256. More than one backend enabled");
+#endif
+
+// Flag that SHA-256 is enabled in backend
+#define NRF_CRYPTO_HASH_SHA256_ENABLED 1
+
+
+/**@brief nrf_crypto_hash context for SHA-256 in nrf_crypto Oberon backend. */
+typedef struct
+{
+    nrf_crypto_hash_internal_context_t  header;     /**< Common header for context. */
+    occ_sha256_ctx                      context;    /**< Hash context internal to Oberon. */
+} nrf_crypto_backend_hash_sha256_context_t;
+
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_HASH_SHA256)
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_HASH_SHA512)
+
+// Flag that nrf_crypto_hash frontend can be compiled
+#undef  NRF_CRYPTO_HASH_ENABLED
+#define NRF_CRYPTO_HASH_ENABLED 1
+
+// Duplicate backend enabled test for SHA-512
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_HASH_SHA512)
+#error "Duplicate definition of SHA-512. More than one backend enabled");
+#endif
+
+// Flag that SHA-512 is enabled in backend
+#define NRF_CRYPTO_HASH_SHA512_ENABLED 1
+
+
+/**@brief nrf_crypto_hash context for SHA-512 in nrf_crypto Oberon backend. */
+typedef struct
+{
+    nrf_crypto_hash_internal_context_t  header;     /**< Common header for context. */
+    occ_sha512_ctx                      context;    /**< Hash context internal to Oberon. */
+} nrf_crypto_backend_hash_sha512_context_t;
+
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_HASH_SHA512)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON)
+
+/**@} */
+
+#endif // OBERON_BACKEND_HASH_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/oberon/oberon_backend_hmac.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/oberon/oberon_backend_hmac.c
new file mode 100644
index 0000000..a89c4ac
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/oberon/oberon_backend_hmac.c
@@ -0,0 +1,169 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#include "sdk_common.h"
+#if NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON)
+
+#include "nrf_log.h"
+#include "nrf_crypto_error.h"
+#include "nrf_crypto_types.h"
+#include "oberon_backend_hmac.h"
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_HMAC_SHA256)
+
+#define HMAC_SHA256_BLOCK_SIZE 64
+
+static ret_code_t oberon_backend_hmac_init_sha256(void      * const p_context,
+                                                  uint8_t   const * p_key,
+                                                  size_t            key_size)
+{
+    nrf_crypto_backend_oberon_hmac_sha256_context_t * p_ctx =
+        (nrf_crypto_backend_oberon_hmac_sha256_context_t *)p_context;
+
+    occ_hmac_sha256_init(&p_ctx->oberon_ctx, p_key, key_size);
+
+    return NRF_SUCCESS;
+}
+
+
+static ret_code_t oberon_backend_hmac_update_sha256(void    * const p_context,
+                                                    uint8_t const * p_data,
+                                                    size_t          size)
+{
+    nrf_crypto_backend_oberon_hmac_sha256_context_t * p_ctx =
+        (nrf_crypto_backend_oberon_hmac_sha256_context_t *)p_context;
+
+    occ_hmac_sha256_update(&p_ctx->oberon_ctx, p_data, size);
+
+    return NRF_SUCCESS;
+}
+
+
+static ret_code_t oberon_backend_hmac_finalize_sha256(void      * const p_context,
+                                                      uint8_t         * p_digest,
+                                                      size_t    * const p_size)
+{
+    nrf_crypto_backend_oberon_hmac_sha256_context_t * const p_ctx =
+        (nrf_crypto_backend_oberon_hmac_sha256_context_t *)p_context;
+
+    occ_hmac_sha256_final(p_digest, &p_ctx->oberon_ctx);
+
+    // Assume operation was successful and update the digest size accordingly.
+    *p_size = p_ctx->header.p_info->digest_size;
+
+    return NRF_SUCCESS;
+}
+
+
+// Information structure for HMAC SHA256 using Oberon backend.
+const nrf_crypto_hmac_info_t g_nrf_crypto_hmac_sha256_info =
+{
+    .init_fn        = oberon_backend_hmac_init_sha256,
+    .update_fn      = oberon_backend_hmac_update_sha256,
+    .finalize_fn    = oberon_backend_hmac_finalize_sha256,
+    .digest_size    = NRF_CRYPTO_HASH_SIZE_SHA256,
+    .context_size   = sizeof(nrf_crypto_backend_oberon_hmac_sha256_context_t),
+    .type           = NRF_CRYPTO_HMAC_SHA256_TYPE
+};
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_HMAC_SHA256)
+
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_HMAC_SHA512)
+
+#define HMAC_SHA512_BLOCK_SIZE 128
+
+static ret_code_t oberon_backend_hmac_init_sha512(void      * const p_context,
+                                                  uint8_t   const * p_key,
+                                                  size_t            key_size)
+{
+    nrf_crypto_backend_oberon_hmac_sha512_context_t * p_ctx =
+        (nrf_crypto_backend_oberon_hmac_sha512_context_t *)p_context;
+
+    occ_hmac_sha512_init(&p_ctx->oberon_ctx, p_key, key_size);
+
+    return NRF_SUCCESS;
+}
+
+
+static ret_code_t oberon_backend_hmac_update_sha512(void    * const p_context,
+                                                    uint8_t const * p_data,
+                                                    size_t          size)
+{
+    nrf_crypto_backend_oberon_hmac_sha512_context_t * p_ctx =
+        (nrf_crypto_backend_oberon_hmac_sha512_context_t *)p_context;
+
+    occ_hmac_sha512_update(&p_ctx->oberon_ctx, p_data, size);
+
+    return NRF_SUCCESS;
+}
+
+
+static ret_code_t oberon_backend_hmac_finalize_sha512(void      * const p_context,
+                                                      uint8_t         * p_digest,
+                                                      size_t    * const p_size)
+{
+    nrf_crypto_backend_oberon_hmac_sha512_context_t * const p_ctx =
+        (nrf_crypto_backend_oberon_hmac_sha512_context_t *)p_context;
+
+    occ_hmac_sha512_final(p_digest, &p_ctx->oberon_ctx);
+
+    // Assume operation was successful and update the digest size accordingly.
+    *p_size = p_ctx->header.p_info->digest_size;
+
+    return NRF_SUCCESS;
+}
+
+
+// Information structure for HMAC SHA512 using Oberon backend.
+const nrf_crypto_hmac_info_t g_nrf_crypto_hmac_sha512_info =
+{
+    .init_fn        = oberon_backend_hmac_init_sha512,
+    .update_fn      = oberon_backend_hmac_update_sha512,
+    .finalize_fn    = oberon_backend_hmac_finalize_sha512,
+    .digest_size    = NRF_CRYPTO_HASH_SIZE_SHA512,
+    .context_size   = sizeof(nrf_crypto_backend_oberon_hmac_sha512_context_t),
+    .type           = NRF_CRYPTO_HMAC_SHA512_TYPE
+};
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_HMAC_SHA512)
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON)
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/oberon/oberon_backend_hmac.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/oberon/oberon_backend_hmac.h
new file mode 100644
index 0000000..d32274f
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/backend/oberon/oberon_backend_hmac.h
@@ -0,0 +1,136 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef OBERON_BACKEND_HMAC_H__
+#define OBERON_BACKEND_HMAC_H__
+
+/** @file
+ *
+ * @defgroup nrf_crypto_oberon_backend_hmac Oberon backend for HMAC
+ * @{
+ * @ingroup nrf_crypto_oberon_backend
+ *
+ * @brief Backend wrapper for Oberon. None of these types should be used directly by the
+ * application.
+ */
+
+#include "sdk_common.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON) &&                    \
+        ( NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_HMAC_SHA256) || \
+          NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_HMAC_SHA512) )
+
+#include "nrf_crypto_hmac_shared.h"
+#include "occ_hmac_sha256.h"
+#include "occ_hmac_sha512.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#undef  NRF_CRYPTO_HMAC_ENABLED
+#define NRF_CRYPTO_HMAC_ENABLED 1
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_HMAC_SHA256)
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_HMAC_SHA256)
+#error "Duplicate definition of HMAC SHA-256. More than one backend enabled"
+#endif // NRF_CRYPTO_HMAC_SHA256_ENABLED
+#define NRF_CRYPTO_HMAC_SHA256_ENABLED 1
+
+/**
+ * @internal @brief Internal context object used by the Oberon backend wrapper for HMAC SHA256.
+ *
+ * @note This should never be used directly. Use @ref nrf_crypto_backend_hmac_sha256_context_t
+ * instead.
+ */
+typedef struct
+{
+    nrf_crypto_hmac_internal_context_t  header;     //!< Internal nrf_crypto_hmac context.
+    occ_hmac_sha256_ctx                 oberon_ctx; //!< Oberon context object.
+} nrf_crypto_backend_oberon_hmac_sha256_context_t;
+
+
+/**
+ * @internal @brief Context for HMAC SHA256 using Oberon backend.
+ */
+typedef nrf_crypto_backend_oberon_hmac_sha256_context_t nrf_crypto_backend_hmac_sha256_context_t;
+
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_HMAC_SHA256)
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_HMAC_SHA512)
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_HMAC_SHA512)
+#error "Duplicate definition of HMAC SHA-512. More than one backend enabled"
+#endif // NRF_CRYPTO_HMAC_SHA512_ENABLED
+#define NRF_CRYPTO_HMAC_SHA512_ENABLED 1
+
+/**
+ * @internal @brief Internal context object used by the Oberon backend wrapper for HMAC SHA512.
+ *
+ * @note This should never be used directly. Use @ref nrf_crypto_backend_hmac_sha512_context_t
+ * instead.
+ */
+typedef struct
+{
+    nrf_crypto_hmac_internal_context_t  header;     //!< Internal nrf_crypto_hmac context header.
+    occ_hmac_sha512_ctx                 oberon_ctx; //!< Oberon context object.
+} nrf_crypto_backend_oberon_hmac_sha512_context_t;
+
+/**
+ * @internal @brief Context for HMAC SHA512 using Oberon backend.
+ */
+typedef nrf_crypto_backend_oberon_hmac_sha512_context_t nrf_crypto_backend_hmac_sha512_context_t;
+
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_HMAC_SHA512)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON && ( NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_HMAC_SHA256 || NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_OBERON_HMAC_SHA512) )
+
+/**@} */
+
+#endif // OBERON_BACKEND_HMAC_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto.h
new file mode 100644
index 0000000..e03ab04
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto.h
@@ -0,0 +1,77 @@
+/**
+ * Copyright (c) 2016 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef NRF_CRYPTO_H__
+#define NRF_CRYPTO_H__
+
+/**
+ * @defgroup nrf_crypto Cryptography library
+ * @ingroup app_common
+ * @{
+ *
+ * @brief   Cryptography library (nrf_crypto).
+ *
+ * @details The cryptography library provides cryptographic functionality in a portable way.
+ *
+ * @note The functions in this API can run in software or hardware, depending on the supported features of your SoC and the configuration of nrf_crypto backend in the application.
+ * See @ref lib_crypto_config for details on changing the nrf_crypto backend.
+ *
+ * @}
+ *
+ */
+ 
+
+
+#include <stdint.h>
+#include "nrf_crypto_init.h"
+#include "nrf_crypto_types.h"
+#include "nrf_crypto_mem.h"
+#include "nrf_crypto_ecc.h"
+#include "nrf_crypto_hash.h"
+#include "nrf_crypto_ecdsa.h"
+#include "nrf_crypto_ecdh.h"
+#include "nrf_crypto_rng.h"
+#include "nrf_crypto_aes.h"
+#include "nrf_crypto_aead.h"
+#include "nrf_crypto_hmac.h"
+#include "nrf_crypto_hkdf.h"
+
+
+#endif // NRF_CRYPTO_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_aead.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_aead.c
new file mode 100644
index 0000000..9459bc6
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_aead.c
@@ -0,0 +1,159 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#include "sdk_common.h"
+#if NRF_MODULE_ENABLED(NRF_CRYPTO)
+
+#include "nrf_crypto_error.h"
+#include "nrf_crypto_aead.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_AEAD)
+
+static ret_code_t context_verify(nrf_crypto_aead_internal_context_t const * p_context)
+{
+    VERIFY_TRUE((p_context != NULL), NRF_ERROR_CRYPTO_CONTEXT_NULL);
+
+    VERIFY_TRUE((p_context->init_value == NRF_CRYPTO_AEAD_INIT_MAGIC_VALUE),
+                NRF_ERROR_CRYPTO_CONTEXT_NOT_INITIALIZED);
+
+    return NRF_SUCCESS;
+}
+
+
+ret_code_t nrf_crypto_aead_init(nrf_crypto_aead_context_t * const    p_context,
+                                nrf_crypto_aead_info_t const * const p_info,
+                                uint8_t *                            p_key)
+{
+    ret_code_t ret_val;
+
+    nrf_crypto_aead_internal_context_t * p_int_context =
+        (nrf_crypto_aead_internal_context_t *)p_context;
+
+    VERIFY_TRUE((p_info != NULL), NRF_ERROR_CRYPTO_INPUT_NULL);
+
+    VERIFY_TRUE((p_key != NULL), NRF_ERROR_CRYPTO_INPUT_NULL);
+
+    ret_val = context_verify(p_int_context);
+    VERIFY_TRUE((ret_val == NRF_SUCCESS) || (ret_val == NRF_ERROR_CRYPTO_CONTEXT_NOT_INITIALIZED),
+                ret_val);
+
+    p_int_context->init_value = NRF_CRYPTO_AEAD_INIT_MAGIC_VALUE;
+    p_int_context->p_info     = p_info;
+
+    ret_val = p_info->init_fn(p_context, p_key);
+
+    if (ret_val != NRF_SUCCESS)
+    {
+        p_int_context->init_value = 0;
+    }
+
+    return ret_val;
+}
+
+ret_code_t nrf_crypto_aead_uninit(void * const p_context)
+{
+    ret_code_t ret_val;
+
+    nrf_crypto_aead_internal_context_t * p_int_context =
+        (nrf_crypto_aead_internal_context_t *)p_context;
+
+    ret_val = context_verify(p_int_context);
+    VERIFY_SUCCESS(ret_val);
+
+    ret_val = p_int_context->p_info->uninit_fn(p_context);
+
+    p_int_context->init_value = 0;
+
+    return ret_val;
+}
+
+ret_code_t nrf_crypto_aead_crypt(nrf_crypto_aead_context_t * const p_context,
+                                 nrf_crypto_operation_t            operation,
+                                 uint8_t *                         p_nonce,
+                                 uint8_t                           nonce_size,
+                                 uint8_t *                         p_adata,
+                                 size_t                            adata_size,
+                                 uint8_t *                         p_data_in,
+                                 size_t                            data_in_size,
+                                 uint8_t *                         p_data_out,
+                                 uint8_t *                         p_mac,
+                                 uint8_t                           mac_size)
+{
+    ret_code_t ret_val;
+
+    nrf_crypto_aead_internal_context_t * p_int_context =
+        (nrf_crypto_aead_internal_context_t *)p_context;
+
+    ret_val = context_verify(p_int_context);
+    VERIFY_SUCCESS(ret_val);
+
+    VERIFY_FALSE(((p_nonce == NULL) && (nonce_size != 0)),
+                 NRF_ERROR_CRYPTO_INPUT_NULL);
+
+    /* If mac_size == 0 MAC is updated and not stored under p_mac */
+    VERIFY_FALSE(((p_mac == NULL) && (mac_size != 0)),
+                 NRF_ERROR_CRYPTO_INPUT_NULL);
+
+    VERIFY_FALSE(((p_adata == NULL) && (adata_size != 0)),
+                 NRF_ERROR_CRYPTO_INPUT_NULL);
+
+    VERIFY_FALSE(((p_data_in == NULL) && (data_in_size != 0)),
+                 NRF_ERROR_CRYPTO_INPUT_NULL);
+
+    VERIFY_FALSE(((p_data_out == NULL) && (data_in_size != 0)),
+                 NRF_ERROR_CRYPTO_OUTPUT_NULL);
+
+    ret_val = p_int_context->p_info->crypt_fn(p_context,
+                                              operation,
+                                              p_nonce,
+                                              nonce_size,
+                                              p_adata,
+                                              adata_size,
+                                              p_data_in,
+                                              data_in_size,
+                                              p_data_out,
+                                              p_mac,
+                                              mac_size);
+    return ret_val;
+}
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_AEAD)
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO)
+
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_aead.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_aead.h
new file mode 100644
index 0000000..a0de689
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_aead.h
@@ -0,0 +1,235 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef NRF_CRYPTO_AEAD_H__
+#define NRF_CRYPTO_AEAD_H__
+
+/** @file
+ *
+ * @defgroup nrf_crypto_aead AEAD (Authenticated Encryption with Associated Data) related
+ * functions.
+ * @{
+ * @ingroup nrf_crypto
+ *
+ * @brief Provides AEAD related functionality through nrf_crypto.
+ */
+
+#include "sdk_common.h"
+#if NRF_MODULE_ENABLED(NRF_CRYPTO) || defined(__SDK_DOXYGEN__)
+
+#include <stdint.h>
+#include "nrf_crypto_types.h"
+#include "nrf_crypto_aead_shared.h"
+#include "nrf_crypto_aead_backend.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**@brief External variable declaration to the info structure for AES CCM mode with a 128-bit key.
+*
+* @note The variable is defined in the nrf_crypto backend that is enabled in the @c sdk_config file.
+*
+*/
+extern const nrf_crypto_aead_info_t g_nrf_crypto_aes_ccm_128_info;
+
+/**@brief External variable declaration to the info structure for AES CCM mode with a 192-bit key.
+*
+* @note The variable is defined in the nrf_crypto backend that is enabled in the @c sdk_config file.
+*
+*/
+extern const nrf_crypto_aead_info_t g_nrf_crypto_aes_ccm_192_info;
+
+/**@brief External variable declaration to the info structure for AES CCM mode with a 256-bit key.
+*
+* @note The variable is defined in the nrf_crypto backend that is enabled in the @c sdk_config file.
+*
+*/
+extern const nrf_crypto_aead_info_t g_nrf_crypto_aes_ccm_256_info;
+
+/**@brief External variable declaration to the info structure for AES CCM* mode with a 128-bit key.
+*
+* @note The variable is defined in the nrf_crypto backend that is enabled in the @c sdk_config file.
+*
+*/
+extern const nrf_crypto_aead_info_t g_nrf_crypto_aes_ccm_star_128_info;
+
+/**@brief External variable declaration to the info structure for AES EAX mode with a 128-bit key.
+*
+* @note The variable is defined in the nrf_crypto backend that is enabled in the @c sdk_config file.
+*
+*/
+extern const nrf_crypto_aead_info_t g_nrf_crypto_aes_eax_128_info;
+
+/**@brief External variable declaration to the info structure for AES EAX mode with a 192-bit key.
+*
+* @note The variable is defined in the nrf_crypto backend that is enabled in the @c sdk_config file.
+*
+*/
+extern const nrf_crypto_aead_info_t g_nrf_crypto_aes_eax_192_info;
+
+/**@brief External variable declaration to the info structure for AES EAX mode with a 256-bit key.
+*
+* @note The variable is defined in the nrf_crypto backend that is enabled in the @c sdk_config file.
+*
+*/
+extern const nrf_crypto_aead_info_t g_nrf_crypto_aes_eax_256_info;
+
+/**@brief External variable declaration to the info structure for AES GCM mode with a 128-bit key.
+*
+* @note The variable is defined in the nrf_crypto backend that is enabled in the @ref sdk_config.
+*
+*/
+extern const nrf_crypto_aead_info_t g_nrf_crypto_aes_gcm_128_info;
+
+/**@brief External variable declaration to the info structure for AES GCM mode with a 192-bit key.
+*
+* @note The variable is defined in the nrf_crypto backend that is enabled in the @ref sdk_config.
+*
+*/
+extern const nrf_crypto_aead_info_t g_nrf_crypto_aes_gcm_192_info;
+
+/**@brief External variable declaration to the info structure for AES GCM mode with a 256-bit key.
+*
+* @note The variable is defined in the nrf_crypto backend that is enabled in the @ref sdk_config.
+*
+*/
+extern const nrf_crypto_aead_info_t g_nrf_crypto_aes_gcm_256_info;
+
+/**@brief External variable declaration to the info structure for CHACHA-POLY mode with a 256-bit
+*         key.
+*
+* @note The variable is defined in the nrf_crypto backend that is enabled in the @ref sdk_config.
+*
+*/
+extern const nrf_crypto_aead_info_t g_nrf_crypto_chacha_poly_256_info;
+
+
+/**
+ * @brief Context type for AEAD.
+ *
+ * @note The size of this type is scaled for the largest AEAD backend context that is
+ *       enabled in @ref sdk_config.
+ */
+typedef nrf_crypto_backend_aead_context_t nrf_crypto_aead_context_t;
+
+
+/**@brief Function for initializing the AEAD calculation context.
+ *
+ * @param[in] p_context     Pointer to the context object. It must be a context type associated with
+ *                          the object provided in the p_info parameter or other memory that can
+ *                          hold that context type.
+ * @param[in] p_info        Pointer to structure holding information about: selected AES AEAD mode,
+ *                          and key size.
+ * @param[in] p_key         Pointer to AEAD mode key.
+ *
+ * @retval  NRF_SUCCESS  Context was successfully initialized.
+ */
+ret_code_t nrf_crypto_aead_init(nrf_crypto_aead_context_t * const    p_context,
+                                nrf_crypto_aead_info_t const * const p_info,
+                                uint8_t *                            p_key);
+
+/**@brief Function for uninitializing the AEAD calculation context.
+ *
+ * @param[in] p_context  Pointer to the context object. It must be initialized before function call.
+ *
+ * @retval  NRF_SUCCESS  Context was successfully uninitialized.
+ */
+ret_code_t nrf_crypto_aead_uninit(void * const p_context);
+
+/**@brief Integrated encryption / decryption function.
+ *
+ * @param[in]  p_context        Context object. Must be initialized before the call.
+ * @param[in]  operation        Parameter indicating whether an encrypt (NRF_CRYPTO_ENCRYPT) or
+ *                              a decrypt (NRF_CRYPTO_DECRYPT) operation shall be performed.
+ * @param[in]  p_nonce          Pointer to nonce. For nonce_size == 0 p_nonce can be NULL.
+ * @param[in]  nonce_size       Nonce byte size. Valid values for supported modes:
+ *                                - CCM         [7 ... 13]
+ *                                - CCM*        [13]
+ *                                - EAX         nonce size can be any length
+ *                                - GCM         nonce size can be any length
+ *                                - CHACHA-POLY [12]
+ * @param[in]  p_adata          Pointer to additional authenticated data (adata).
+ * @param[in]  adata_size       Length of additional authenticated data in bytes.
+ *                              For CHACHA-POLY mode must be > 0.
+ * @param[in]  p_data_in        Pointer to the input data buffer for encryption or decryption.
+ * @param[in]  data_in_size     Length of the data in p_data_in buffer in bytes. Size of the
+ *                              p_data_out buffer must not be smaller than this value.
+ *                              When selecting CC310 backend data_in_size value shall be limited
+ *                              to 65535 bytes. Data out buffer must be at least the same length.
+ * @param[out] p_data_out       Pointer to the output buffer where encrypted or decrypted data
+ *                              will be stored. Must be at least 'data_in_size' bytes wide.
+ *                                - GCM: On encryption, the p_data_out buffer can be the same as
+ *                                       the p_data_in buffer.
+ *                                       On decryption, the p_data_out buffer cannot be the same
+ *                                       as p_data_in buffer. If buffers overlap, the p_data_out
+ *                                       buffer must trail at least 8 bytes behind the p_data_in
+ *                                       buffer.
+ * @param[out] p_mac            Pointer to the MAC result buffer. Fo mac_size == 0 p_mac can be NULL.
+ * @param[in]  mac_size         MAC byte size. Valid values for supported modes:
+ *                                -CCM          [4, 6, 8, 10, 12, 14, 16]
+ *                                -CCM*         [0, 4, 8, 16]
+ *                                -EAX          [1 ... 16]
+ *                                -GCM          [4 ... 16]
+ *                                -CHACHA-POLY  [16]
+ *
+ * @retval  NRF_SUCCESS  Message was successfully encrypted.
+ */
+ret_code_t nrf_crypto_aead_crypt(nrf_crypto_aead_context_t * const p_context,
+                                 nrf_crypto_operation_t            operation,
+                                 uint8_t *                         p_nonce,
+                                 uint8_t                           nonce_size,
+                                 uint8_t *                         p_adata,
+                                 size_t                            adata_size,
+                                 uint8_t *                         p_data_in,
+                                 size_t                            data_in_size,
+                                 uint8_t *                         p_data_out,
+                                 uint8_t *                         p_mac,
+                                 uint8_t                           mac_size);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // #if NRF_MODULE_ENABLED(NRF_CRYPTO) || defined(__SDK_DOXYGEN__)
+
+/** @} */
+
+#endif // NRF_CRYPTO_AEAD_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_aead_backend.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_aead_backend.h
new file mode 100644
index 0000000..fd792dd
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_aead_backend.h
@@ -0,0 +1,100 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef NRF_CRYPTO_AEAD_BACKEND_H__
+#define NRF_CRYPTO_AEAD_BACKEND_H__
+
+#include "cc310_backend_aes_aead.h"
+#include "cc310_backend_chacha_poly_aead.h"
+#include "cifra_backend_aes_aead.h"
+#include "mbedtls_backend_aes_aead.h"
+#include "oberon_backend_chacha_poly_aead.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**@internal @brief Fallback type for AES CCM context (if no backend is enabled).
+ */
+#if !NRF_MODULE_ENABLED(NRF_CRYPTO_AES_CCM)
+typedef nrf_crypto_aead_internal_context_t nrf_crypto_backend_aes_ccm_context_t;
+#endif
+
+/**@internal @brief Fallback type for AES CCM* context (if no backend is enabled).
+ */
+#if !NRF_MODULE_ENABLED(NRF_CRYPTO_AES_CCM_STAR)
+typedef nrf_crypto_aead_internal_context_t nrf_crypto_backend_aes_ccm_star_context_t;
+#endif
+
+/**@internal @brief Fallback type for AES EAX context (if no backend is enabled).
+ */
+#if !NRF_MODULE_ENABLED(NRF_CRYPTO_AES_EAX)
+typedef nrf_crypto_aead_internal_context_t nrf_crypto_backend_aes_eax_context_t;
+#endif
+
+/**@internal @brief Fallback type for AES GCM context (if no backend is enabled).
+ */
+#if !NRF_MODULE_ENABLED(NRF_CRYPTO_AES_GCM)
+typedef nrf_crypto_aead_internal_context_t nrf_crypto_backend_aes_gcm_context_t;
+#endif
+
+/**@internal @brief Fallback type for CHACHA-POLY context (if no backend is enabled).
+ */
+#if !NRF_MODULE_ENABLED(NRF_CRYPTO_CHACHA_POLY)
+typedef nrf_crypto_aead_internal_context_t nrf_crypto_backend_chacha_poly_context_t;
+#endif
+
+/** @internal @brief Union holding a AEAD context. */
+typedef union
+{
+    nrf_crypto_backend_aes_ccm_context_t      ccm_context;          /**< @brief Holds context for AES CCM. */
+    nrf_crypto_backend_aes_ccm_star_context_t ccm_star_context;     /**< @brief Holds context for AES CCM*. */
+    nrf_crypto_backend_aes_eax_context_t      eax_context;          /**< @brief Holds context for AES EAX. */
+    nrf_crypto_backend_aes_gcm_context_t      gcm_context;          /**< @brief Holds context for AES GCM. */
+
+    nrf_crypto_backend_chacha_poly_context_t  chacha_poly_context;  /**< @brief Holds context for ChaCha-Poly. */
+} nrf_crypto_backend_aead_context_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // NRF_CRYPTO_AEAD_BACKEND_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_aead_shared.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_aead_shared.h
new file mode 100644
index 0000000..f847c1e
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_aead_shared.h
@@ -0,0 +1,147 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef NRF_CRYPTO_AEAD_SHARED_H__
+#define NRF_CRYPTO_AEAD_SHARED_H__
+
+/** @file
+ *
+ * @defgroup nrf_crypto_aead_shared AEAD related functions
+ * @{
+ * @ingroup nrf_crypto
+ *
+ * @brief Provides AEAD related functionality through nrf_crypto.
+ */
+
+#include <stdint.h>
+#include "nrf_crypto_types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**@internal @brief Magic value to signal that the nrf_crypto_hash context structure is initialized.
+ */
+#define NRF_CRYPTO_AEAD_INIT_MAGIC_VALUE    (0x44414541)    // ASCII "AEAD"
+
+#define NRF_CRYPTO_AES_CCM_STAR_MAC_BITMASK     (0x1C) /* [0, 4, 8, 16] allowed MAC size in CCM mode */
+#define NRF_CRYPTO_AES_CCM_MAC_MIN              (4u)   /* MAC min value in CCM mode */
+#define NRF_CRYPTO_AES_CCM_MAC_MAX              (16u)  /* MAC max value in CCM mode */
+#define NRF_CRYPTO_AES_GCM_MAC_MIN              (4u)   /* MAC min value in GCM mode */
+#define NRF_CRYPTO_AES_GCM_MAC_MAX              (16u)  /* MAC max value in GCM mode */
+#define NRF_CRYPTO_AES_CCM_NONCE_SIZE_MIN       (7u)   /* [7...13] allowed nonce size in CCM mode */
+#define NRF_CRYPTO_AES_CCM_NONCE_SIZE_MAX       (13u)  /* [7...13] allowed nonce size in CCM mode */
+#define NRF_CRYPTO_AES_CCM_STAR_NONCE_SIZE      (13u)  /* [13] allowed nonce size in CCM* mode */
+#define NRF_CRYPTO_CHACHA_POLY_NONCE_SIZE       (12u)  /* [12] allowed nonce size in chacha-poly mode */
+#define NRF_CRYPTO_CHACHA_POLY_MAC_SIZE         (16u)  /* [16] allowed MAC size in chacha-poly mode */
+
+/**@internal @brief Enumeration of supported modes of operation in nrf_crypto_aead.
+ */
+typedef enum
+{
+    NRF_CRYPTO_AEAD_MODE_AES_CCM,       // supported by: MBEDTLS & CC310
+    NRF_CRYPTO_AEAD_MODE_AES_CCM_STAR,  // supported by: CC310
+    NRF_CRYPTO_AEAD_MODE_AES_EAX,       // supported by: CIFRA
+    NRF_CRYPTO_AEAD_MODE_AES_GCM,       // supported by: MBEDTLS
+    NRF_CRYPTO_AEAD_MODE_CHACHA_POLY    // supported by: CC310 & OBERON
+} nrf_crypto_aead_mode_t;
+
+
+/**@internal @brief Type declaration to perform AEAD initialization in the nrf_crypto backend.
+ *
+ *  This is internal API. See @ref nrf_crypto_aead_init for documentation.
+ */
+typedef ret_code_t (*aead_init_fn_t)(void * const p_context, uint8_t * p_key);
+
+/**@internal @brief Type declaration to perform AEAD uninitialization in the nrf_crypto backend.
+ *
+ *  This is internal API. See @ref nrf_crypto_aead_uninit for documentation.
+ */
+typedef ret_code_t (*aead_uninit_fn_t)(void * const p_context);
+
+/**@internal @brief Type declaration to perform AEAD encryption in nrf_crypto backend.
+ *
+ *  This is internal API. See @ref nrf_crypto_aead_crypt for documentation.
+ */
+typedef ret_code_t (*aead_crypt_fn_t)(void * const           p_context,
+                                      nrf_crypto_operation_t operation,
+                                      uint8_t *              p_nonce,
+                                      uint8_t                nonce_size,
+                                      uint8_t *              p_adata,
+                                      size_t                 adata_size,
+                                      uint8_t *              p_data_in,
+                                      size_t                 data_in_size,
+                                      uint8_t *              p_data_out,
+                                      uint8_t *              p_mac,
+                                      uint8_t                mac_size);
+
+/**@internal @brief Type declaration for the nrf_crypto_aead info structure.
+ *
+ * @details     This structure contains the calling interface and any metadata required
+ *              to call the nrf_crypto_aead API functions.
+ */
+typedef struct
+{
+    nrf_crypto_aead_mode_t   const mode;
+    nrf_crypto_key_size_id_t const key_size;
+
+    aead_init_fn_t   const init_fn;
+    aead_uninit_fn_t const uninit_fn;
+    aead_crypt_fn_t  const crypt_fn;
+} nrf_crypto_aead_info_t;
+
+/**@internal @brief Type declaration of internal representation of an AEAD context structure.
+ *
+ * @details     This is an internal type that should not be used directly.
+ */
+typedef struct
+{
+    uint32_t init_value;
+    nrf_crypto_aead_info_t const * p_info;
+} nrf_crypto_aead_internal_context_t;
+
+/** @} */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // #ifndef NRF_CRYPTO_AEAD_SHARED_H__
+
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_aes.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_aes.c
new file mode 100644
index 0000000..f2ac8ae
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_aes.c
@@ -0,0 +1,319 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#include "sdk_common.h"
+#if NRF_MODULE_ENABLED(NRF_CRYPTO)
+
+#include "nrf_crypto_aes.h"
+#include "nrf_crypto_mem.h"
+#include "nrf_crypto_error.h"
+#include "nrf_crypto_shared.h"
+#include "nrf_crypto_aes_shared.h"
+#include "nrf_crypto_aes_backend.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_AES)
+
+static ret_code_t context_verify(nrf_crypto_aes_internal_context_t const * p_context)
+{
+    if (p_context == NULL)
+    {
+        return NRF_ERROR_CRYPTO_CONTEXT_NULL;
+    }
+
+    if (p_context->init_value != NRF_CRYPTO_AES_INIT_MAGIC_VALUE)
+    {
+        return NRF_ERROR_CRYPTO_CONTEXT_NOT_INITIALIZED;
+    }
+
+    return NRF_SUCCESS;
+}
+
+ret_code_t nrf_crypto_aes_init(nrf_crypto_aes_context_t * const    p_context,
+                               nrf_crypto_aes_info_t const * const p_info,
+                               nrf_crypto_operation_t              operation)
+{
+    ret_code_t ret_val;
+
+    nrf_crypto_aes_internal_context_t * p_int_context =
+        (nrf_crypto_aes_internal_context_t *)p_context;
+
+    ret_val = context_verify(p_int_context);
+    VERIFY_TRUE((ret_val == NRF_SUCCESS) || (ret_val == NRF_ERROR_CRYPTO_CONTEXT_NOT_INITIALIZED),
+                ret_val);
+
+    VERIFY_TRUE(p_info != NULL, NRF_ERROR_CRYPTO_INPUT_NULL);
+
+    p_int_context->p_info = p_info;
+
+    ret_val = p_info->init_fn(p_context, operation);
+
+    if (ret_val == NRF_SUCCESS)
+    {
+        p_int_context->init_value = NRF_CRYPTO_AES_INIT_MAGIC_VALUE;
+    }
+
+    return ret_val;
+}
+
+ret_code_t nrf_crypto_aes_uninit(nrf_crypto_aes_context_t * const p_context)
+{
+    ret_code_t ret_val;
+
+    nrf_crypto_aes_internal_context_t * p_int_context =
+        (nrf_crypto_aes_internal_context_t *)p_context;
+
+    ret_val = context_verify(p_int_context);
+
+    if (ret_val == NRF_ERROR_CRYPTO_CONTEXT_NOT_INITIALIZED)
+    {
+        /* If context was uninitialized with function nrf_crypto_aes_finalize it shall be still
+           possible to clear init_value */
+        if (p_int_context->init_value == NRF_CRYPTO_AES_UNINIT_MAGIC_VALUE)
+        {
+            ret_val = NRF_SUCCESS;
+        }
+    }
+    VERIFY_SUCCESS(ret_val);
+
+    ret_val = p_int_context->p_info->uninit_fn(p_context);
+
+    p_int_context->init_value = 0;
+
+    return ret_val;
+}
+
+ret_code_t nrf_crypto_aes_key_set(nrf_crypto_aes_context_t * const p_context, uint8_t * p_key)
+{
+    ret_code_t ret_val;
+
+    nrf_crypto_aes_internal_context_t * p_int_context =
+        (nrf_crypto_aes_internal_context_t *)p_context;
+
+    ret_val = context_verify(p_int_context);
+    VERIFY_SUCCESS(ret_val);
+
+    VERIFY_TRUE((p_key != NULL), NRF_ERROR_CRYPTO_INPUT_NULL);
+
+    ret_val = p_int_context->p_info->key_set_fn(p_context, p_key);
+
+    return ret_val;
+}
+
+ret_code_t nrf_crypto_aes_iv_set(nrf_crypto_aes_context_t * const p_context, uint8_t * p_iv)
+{
+    ret_code_t ret_val;
+
+    nrf_crypto_aes_internal_context_t * p_int_context =
+        (nrf_crypto_aes_internal_context_t *)p_context;
+
+    ret_val = context_verify(p_int_context);
+    VERIFY_SUCCESS(ret_val);
+
+    VERIFY_TRUE((p_int_context->p_info->iv_set_fn != NULL), NRF_ERROR_CRYPTO_FEATURE_UNAVAILABLE);
+
+    VERIFY_TRUE((p_iv != NULL), NRF_ERROR_CRYPTO_INPUT_NULL);
+
+    ret_val = p_int_context->p_info->iv_set_fn(p_context, p_iv);
+
+    return ret_val;
+}
+
+ret_code_t nrf_crypto_aes_iv_get(nrf_crypto_aes_context_t * const p_context, uint8_t * p_iv)
+{
+    ret_code_t ret_val;
+
+    nrf_crypto_aes_internal_context_t * p_int_context =
+        (nrf_crypto_aes_internal_context_t *)p_context;
+
+    ret_val = context_verify(p_int_context);
+    if (ret_val == NRF_ERROR_CRYPTO_CONTEXT_NOT_INITIALIZED)
+    {
+        /* If context was uninitialized with function nrf_crypto_aes_finalize it shall be still
+           possible to read IV value */
+        if (p_int_context->init_value == NRF_CRYPTO_AES_UNINIT_MAGIC_VALUE)
+        {
+            ret_val = NRF_SUCCESS;
+        }
+    }
+    VERIFY_SUCCESS(ret_val);
+
+    VERIFY_TRUE((p_iv != NULL), NRF_ERROR_CRYPTO_INPUT_NULL);
+
+    VERIFY_TRUE((p_int_context->p_info->iv_get_fn != NULL), NRF_ERROR_CRYPTO_FEATURE_UNAVAILABLE);
+
+    ret_val = p_int_context->p_info->iv_get_fn(p_context, p_iv);
+
+    return ret_val;
+}
+
+ret_code_t nrf_crypto_aes_update(nrf_crypto_aes_context_t * const p_context,
+                                 uint8_t *                        p_data_in,
+                                 size_t                           data_size,
+                                 uint8_t *                        p_data_out)
+{
+    ret_code_t ret_val;
+
+    nrf_crypto_aes_internal_context_t * p_int_context =
+        (nrf_crypto_aes_internal_context_t *)p_context;
+
+    ret_val = context_verify(p_int_context);
+    VERIFY_SUCCESS(ret_val);
+
+    VERIFY_TRUE((data_size != 0), NRF_ERROR_CRYPTO_INPUT_LENGTH);
+
+    VERIFY_TRUE((p_data_in != NULL), NRF_ERROR_CRYPTO_INPUT_NULL);
+
+    VERIFY_TRUE((p_data_out != NULL), NRF_ERROR_CRYPTO_OUTPUT_NULL);
+
+    if ((data_size & 0xF) != 0)
+    {
+        VERIFY_TRUE((p_int_context->p_info->mode == NRF_CRYPTO_AES_MODE_CFB),
+                    NRF_ERROR_CRYPTO_INPUT_LENGTH);
+    }
+
+    ret_val = p_int_context->p_info->update_fn(p_context,
+                                               p_data_in,
+                                               data_size,
+                                               p_data_out);
+
+    return ret_val;
+}
+
+ret_code_t nrf_crypto_aes_finalize(nrf_crypto_aes_context_t * const p_context,
+                                   uint8_t *                        p_data_in,
+                                   size_t                           data_size,
+                                   uint8_t *                        p_data_out,
+                                   size_t *                         p_data_out_size)
+{
+    ret_code_t ret_val;
+
+    nrf_crypto_aes_internal_context_t * p_int_context =
+        (nrf_crypto_aes_internal_context_t *)p_context;
+
+    ret_val = context_verify(p_int_context);
+    VERIFY_SUCCESS(ret_val);
+
+    VERIFY_TRUE((p_data_in != NULL), NRF_ERROR_CRYPTO_INPUT_NULL);
+
+    VERIFY_TRUE((p_data_out != NULL), NRF_ERROR_CRYPTO_OUTPUT_NULL);
+
+    VERIFY_TRUE((p_data_out_size != NULL), NRF_ERROR_CRYPTO_OUTPUT_NULL);
+
+    ret_val = p_int_context->p_info->finalize_fn(p_context,
+                                                 p_data_in,
+                                                 data_size,
+                                                 p_data_out,
+                                                 p_data_out_size);
+
+    VERIFY_TRUE((ret_val == NRF_SUCCESS), ret_val);
+
+    ret_val = nrf_crypto_aes_uninit(p_context);
+
+    if (ret_val == NRF_SUCCESS)
+    {
+        /* This line will allow to read IV for AES supporting IV get function. */
+        p_int_context->init_value = NRF_CRYPTO_AES_UNINIT_MAGIC_VALUE;
+    }
+
+    return ret_val;
+}
+
+ret_code_t nrf_crypto_aes_crypt(nrf_crypto_aes_context_t * const    p_context,
+                                nrf_crypto_aes_info_t const * const p_info,
+                                nrf_crypto_operation_t              operation,
+                                uint8_t *                           p_key,
+                                uint8_t *                           p_iv,
+                                uint8_t *                           p_data_in,
+                                size_t                              data_size,
+                                uint8_t *                           p_data_out,
+                                size_t *                            p_data_out_size)
+{
+    ret_code_t ret_val;
+    void *     p_allocated_context = NULL;
+
+    nrf_crypto_aes_context_t * p_ctx = p_context;
+
+    VERIFY_TRUE(p_info != NULL, NRF_ERROR_CRYPTO_INPUT_NULL);
+
+    if (p_ctx == NULL)
+    {
+        p_allocated_context = NRF_CRYPTO_ALLOC(p_info->context_size);
+        if (p_allocated_context == NULL)
+        {
+            return NRF_ERROR_CRYPTO_ALLOC_FAILED;
+        }
+        p_ctx = (nrf_crypto_aes_context_t *)p_allocated_context;
+    }
+
+    ret_val = nrf_crypto_aes_init(p_ctx, p_info, operation);
+    NRF_CRYPTO_VERIFY_SUCCESS_DEALLOCATE(ret_val, p_allocated_context);
+
+    ret_val = nrf_crypto_aes_key_set(p_ctx, p_key);
+    NRF_CRYPTO_VERIFY_SUCCESS_DEALLOCATE(ret_val, p_allocated_context);
+
+    ret_val = nrf_crypto_aes_iv_set(p_ctx, p_iv);
+    /* not all AES modes support IV */
+    if (ret_val != NRF_ERROR_CRYPTO_FEATURE_UNAVAILABLE)
+    {
+        NRF_CRYPTO_VERIFY_SUCCESS_DEALLOCATE(ret_val, p_allocated_context);
+    }
+
+    ret_val = nrf_crypto_aes_finalize(p_ctx,
+                                      p_data_in,
+                                      data_size,
+                                      p_data_out,
+                                      p_data_out_size);
+    if (ret_val != NRF_SUCCESS)
+    {
+        /* Context was not successfully deinitialized in nrf_crypto_aes_finalize */
+        UNUSED_RETURN_VALUE(nrf_crypto_aes_uninit(p_ctx));
+    }
+
+    if (p_allocated_context != NULL)
+    {
+        NRF_CRYPTO_FREE(p_allocated_context);
+    }
+
+    return ret_val;
+}
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_AES)
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO)
+
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_aes.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_aes.h
new file mode 100644
index 0000000..bb02700
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_aes.h
@@ -0,0 +1,481 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef NRF_CRYPTO_AES_H__
+#define NRF_CRYPTO_AES_H__
+
+/** @file
+ *
+ * @defgroup nrf_crypto_aes AES related functions
+ * @{
+ * @ingroup nrf_crypto
+ *
+ * @brief Provides AES related functionality through nrf_crypto.
+ */
+#include "sdk_common.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO) || defined(__SDK_DOXYGEN__)
+
+#include <stdint.h>
+#include "nrf_crypto_types.h"
+#include "nrf_crypto_aes_shared.h"
+#include "nrf_crypto_aes_backend.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**@brief External variable declaration to the info structure for AES CBC mode with a 128-bit key.
+*         No padding.
+*
+* @note The variable is defined in the nrf_crypto backend that is
+*       enabled in the @c sdk_config file.
+*
+*/
+extern const nrf_crypto_aes_info_t g_nrf_crypto_aes_cbc_128_info;
+
+/**@brief External variable declaration to the info structure for AES CBC mode with a 192-bit key.
+*         No padding.
+*
+* @note The variable is defined in the nrf_crypto backend that is
+*       enabled in the @c sdk_config file.
+*
+*/
+extern const nrf_crypto_aes_info_t g_nrf_crypto_aes_cbc_192_info;
+
+/**@brief External variable declaration to the info structure for AES CBC mode with a 256-bit key.
+*         No padding.
+*
+* @note The variable is defined in the nrf_crypto backend that is
+*       enabled in the @c sdk_config file.
+*
+*/
+extern const nrf_crypto_aes_info_t g_nrf_crypto_aes_cbc_256_info;
+
+/**@brief External variable declaration to the info structure for AES CBC mode with a 128-bit key.
+*         Padding pkcs7 enabled.
+*
+* @note The variable is defined in the nrf_crypto backend that is
+*       enabled in the @c sdk_config file.
+*
+*/
+extern const nrf_crypto_aes_info_t g_nrf_crypto_aes_cbc_128_pad_pkcs7_info;
+
+/**@brief External variable declaration to the info structure for AES CBC mode with a 192-bit key.
+*         Padding pkcs7 enabled.
+*
+* @note The variable is defined in the nrf_crypto backend that is
+*       enabled in the @c sdk_config file.
+*
+*/
+extern const nrf_crypto_aes_info_t g_nrf_crypto_aes_cbc_192_pad_pkcs7_info;
+
+/**@brief External variable declaration to the info structure for AES CBC mode with a 256-bit key.
+*         Padding pkcs7 enabled.
+*
+* @note The variable is defined in the nrf_crypto backend that is
+*       enabled in the @c sdk_config file.
+*
+*/
+extern const nrf_crypto_aes_info_t g_nrf_crypto_aes_cbc_256_pad_pkcs7_info;
+
+/**@brief External variable declaration to the info structure for AES CTR mode with a 128-bit key.
+*
+* @note The variable is defined in the nrf_crypto backend that is
+*       enabled in the @c sdk_config file.
+*
+*/
+extern const nrf_crypto_aes_info_t g_nrf_crypto_aes_ctr_128_info;
+
+/**@brief External variable declaration to the info structure for AES CTR mode with a 192-bit key.
+*
+* @note The variable is defined in the nrf_crypto backend that is
+*       enabled in the @c sdk_config file.
+*
+*/
+extern const nrf_crypto_aes_info_t g_nrf_crypto_aes_ctr_192_info;
+
+/**@brief External variable declaration to the info structure for AES CTR mode with a 256-bit key.
+*
+* @note The variable is defined in the nrf_crypto backend that is
+*       enabled in the @c sdk_config file.
+*
+*/
+extern const nrf_crypto_aes_info_t g_nrf_crypto_aes_ctr_256_info;
+
+/**@brief External variable declaration to the info structure for AES CFB mode with a 128-bit key.
+*
+* @note The variable is defined in the nrf_crypto backend that is
+*       enabled in the @c sdk_config file.
+*
+*/
+extern const nrf_crypto_aes_info_t g_nrf_crypto_aes_cfb_128_info;
+
+/**@brief External variable declaration to the info structure for AES CFB mode with a 192-bit key.
+*
+* @note The variable is defined in the nrf_crypto backend that is
+*       enabled in the @c sdk_config file.
+*
+*/
+extern const nrf_crypto_aes_info_t g_nrf_crypto_aes_cfb_192_info;
+
+/**@brief External variable declaration to the info structure for AES CFB mode with a 256-bit key.
+*
+* @note The variable is defined in the nrf_crypto backend that is
+*       enabled in the @c sdk_config file.
+*
+*/
+extern const nrf_crypto_aes_info_t g_nrf_crypto_aes_cfb_256_info;
+
+/**@brief External variable declaration to the info structure for AES ECB mode with a 128-bit key.
+*         No padding.
+*
+* @note The variable is defined in the nrf_crypto backend that is
+*       enabled in the @c sdk_config file.
+*
+*/
+extern const nrf_crypto_aes_info_t g_nrf_crypto_aes_ecb_128_info;
+
+/**@brief External variable declaration to the info structure for AES ECB mode with a 192-bit key.
+*         No padding.
+*
+* @note The variable is defined in the nrf_crypto backend that is
+*       enabled in the @c sdk_config file.
+*
+*/
+extern const nrf_crypto_aes_info_t g_nrf_crypto_aes_ecb_192_info;
+
+/**@brief External variable declaration to the info structure for AES ECB mode with a 256-bit key.
+*         No padding.
+*
+* @note The variable is defined in the nrf_crypto backend that is
+*       enabled in the @c sdk_config file.
+*
+*/
+extern const nrf_crypto_aes_info_t g_nrf_crypto_aes_ecb_256_info;
+
+/**@brief External variable declaration to the info structure for AES ECB mode with a 128-bit key.
+*         Padding pkcs7 enabled.
+*
+* @note The variable is defined in the nrf_crypto backend that is
+*       enabled in the @c sdk_config file.
+*
+*/
+extern const nrf_crypto_aes_info_t g_nrf_crypto_aes_ecb_128_pad_pkcs7_info;
+
+/**@brief External variable declaration to the info structure for AES ECB mode with a 192-bit key.
+*         Padding pkcs7 enabled.
+*
+* @note The variable is defined in the nrf_crypto backend that is
+*       enabled in the @c sdk_config file.
+*
+*/
+extern const nrf_crypto_aes_info_t g_nrf_crypto_aes_ecb_192_pad_pkcs7_info;
+
+/**@brief External variable declaration to the info structure for AES ECB mode with a 256-bit key.
+*         Padding pkcs7 enabled.
+*
+* @note The variable is defined in the nrf_crypto backend that is
+*       enabled in the @c sdk_config file.
+*
+*/
+extern const nrf_crypto_aes_info_t g_nrf_crypto_aes_ecb_256_pad_pkcs7_info;
+
+/**@brief External variable declaration to the info structure for AES CBC MAC mode with a 128-bit
+*         key.
+*
+* @note The variable is defined in the nrf_crypto backend that is
+*       enabled in the @c sdk_config file.
+*
+*/
+extern const nrf_crypto_aes_info_t g_nrf_crypto_aes_cbc_mac_128_info;
+
+/**@brief External variable declaration to the info structure for AES CBC MAC mode with a 192-bit
+*         key.
+*
+* @note The variable is defined in the nrf_crypto backend that is
+*       enabled in the @c sdk_config file.
+*
+*/
+extern const nrf_crypto_aes_info_t g_nrf_crypto_aes_cbc_mac_192_info;
+
+/**@brief External variable declaration to the info structure for AES CBC MAC mode with a 256-bit
+*         key.
+*
+* @note The variable is defined in the nrf_crypto backend that is
+*       enabled in the @c sdk_config file.
+*
+*/
+extern const nrf_crypto_aes_info_t g_nrf_crypto_aes_cbc_mac_256_info;
+
+/**@brief External variable declaration to the info structure for AES CBC MAC mode with a 128-bit
+*         key.
+*         Padding pkcs7 enabled.
+*
+* @note The variable is defined in the nrf_crypto backend that is
+*       enabled in the @c sdk_config file.
+*
+*/
+extern const nrf_crypto_aes_info_t g_nrf_crypto_aes_cbc_mac_128_pad_pkcs7_info;
+
+/**@brief External variable declaration to the info structure for AES CBC MAC mode with a 192-bit
+*         key.
+*         Padding pkcs7 enabled.
+*
+* @note The variable is defined in the nrf_crypto backend that is
+*       enabled in the @c sdk_config file.
+*
+*/
+extern const nrf_crypto_aes_info_t g_nrf_crypto_aes_cbc_mac_192_pad_pkcs7_info;
+
+/**@brief External variable declaration to the info structure for AES CBC MAC mode with a 256-bit
+*         key.
+*         Padding pkcs7 enabled.
+*
+* @note The variable is defined in the nrf_crypto backend that is
+*       enabled in the @c sdk_config file.
+*
+*/
+extern const nrf_crypto_aes_info_t g_nrf_crypto_aes_cbc_mac_256_pad_pkcs7_info;
+
+
+/**@brief External variable declaration to the info structure for AES CMAC mode with a 128-bit key.
+*
+* @note The variable is defined in the nrf_crypto backend that is
+*       enabled in the @c sdk_config file.
+*
+*/
+extern const nrf_crypto_aes_info_t g_nrf_crypto_aes_cmac_128_info;
+
+/**@brief External variable declaration to the info structure for AES CMAC mode with a 192-bit key.
+*
+* @note The variable is defined in the nrf_crypto backend that is
+*       enabled in the @c sdk_config file.
+*
+*/
+extern const nrf_crypto_aes_info_t g_nrf_crypto_aes_cmac_192_info;
+
+/**@brief External variable declaration to the info structure for AES CMAC mode with a 256-bit key.
+*
+* @note The variable is defined in the nrf_crypto backend that is
+*       enabled in the @c sdk_config file.
+*
+*/
+extern const nrf_crypto_aes_info_t g_nrf_crypto_aes_cmac_256_info;
+
+/**
+ * @brief Context type for AES.
+ *
+ * @note The size of this type is scaled for the largest AES backend context that is
+ *       enabled in @ref sdk_config.
+ */
+typedef nrf_crypto_backend_aes_context_t nrf_crypto_aes_context_t;
+
+/**@brief Function for initializing the AES context.
+ *
+ * @param[in]  p_context        Pointer to the context object. It must be a context type associated
+ *                              with the object provided in the p_info parameter or other memory
+ *                              that can hold that context type.
+ * @param[in]  p_info           Pointer to structure holding information about: selected AES mode,
+ *                              key size, and padding.
+ * @param[in]  operation        Parameter indicating whether an encrypt (NRF_CRYPTO_ENCRYPT),
+ *                              a decrypt (NRF_CRYPTO_DECRYPT) or MAC calculation
+ *                              (NRF_CRYPTO_MAC_CALCULATE) operation shall be performed.
+ *
+ * @return NRF_SUCCESS on success.
+ */
+ret_code_t nrf_crypto_aes_init(nrf_crypto_aes_context_t * const    p_context,
+                               nrf_crypto_aes_info_t const * const p_info,
+                               nrf_crypto_operation_t              operation);
+
+/**@brief Internal function for uninitializing the AES context.
+ *
+ * @param[in]  p_context    Context object. Must be initialized before the call.
+ *
+ * @return NRF_SUCCESS on success.
+ */
+ret_code_t nrf_crypto_aes_uninit(nrf_crypto_aes_context_t * const p_context);
+
+/**@brief Function for setting the AES key.
+ *
+ * @param[in]  p_context    Context object. Must be initialized before the call.
+ * @param[in]  p_key        Pointer to the AES key. This buffer will be copied and there is no need
+ *                          to keep it by the user.
+ *
+ * @return NRF_SUCCESS on success.
+ */
+ret_code_t nrf_crypto_aes_key_set(nrf_crypto_aes_context_t * const p_context, uint8_t * p_key);
+
+/**@brief Function for setting an AES IV or a counter for AES modes which are using it.
+ *
+ * @param[in]  p_context    Context object. Must be initialized before the call.
+ * @param[in]  p_iv         Pointer to a buffer of the IV or a counter. This buffer will be copied
+ *                          and there is no need to keep it by the user.
+ *
+ * @return NRF_SUCCESS on success.
+ */
+ret_code_t nrf_crypto_aes_iv_set(nrf_crypto_aes_context_t * const p_context, uint8_t * p_iv);
+
+/**@brief Function for getting an AES IV or a counter for mode which is supporting it.
+ *
+ * @param[in]  p_context    Context object. Must be initialized before the call.
+ * @param[out] p_iv         Pointer to a buffer of the IV or a counter.
+ *
+ * @return NRF_SUCCESS on success.
+ */
+ret_code_t nrf_crypto_aes_iv_get(nrf_crypto_aes_context_t * const p_context, uint8_t * p_iv);
+
+/**@brief AES update function for encryption, decryption and MAC calculation. It can be called once
+ *  on the whole data block, or as many times as needed, until all the input data is processed.
+ *  Functions: @ref nrf_crypto_aes_init, @ref nrf_crypto_aes_key_set, and, for some ciphers,
+ *  @ref nrf_crypto_aes_iv_set, must be called before call to this API with the same context.
+
+ *
+ * @param[in]  p_context    Context object. Must be initialized before the call.
+ * @param[in]  p_data_in    Pointer to the input buffer to the AES.
+ * @param[in]  data_size    Size of the data to be processed in bytes.
+ *                          For all modes except CFB it must be multiple of 16 bytes.
+ * @param[out] p_data_out   Pointer to the output buffer.
+ *
+ * @return NRF_SUCCESS on success.
+ */
+ret_code_t nrf_crypto_aes_update(nrf_crypto_aes_context_t * const p_context,
+                                 uint8_t *                        p_data_in,
+                                 size_t                           data_size,
+                                 uint8_t *                        p_data_out);
+
+
+/**@brief Function processes the last data block if needed and finalizes the AES operation (ie. adds
+ *  padding) and produces operation results (for MAC operations).
+ *  Functions: @ref nrf_crypto_aes_init, @ref nrf_crypto_aes_key_set, and, for some ciphers,
+ *  @ref nrf_crypto_aes_iv_set, must be called before call to this API with the same context.
+ *
+ *  Upon successful operation function will deinitialize the context but for some ciphers it will be
+ *  possible to read IV. In order to fully deinitialize context you must call
+ *  @ref nrf_crypto_aes_uninit.
+ *
+ * @param[in]     p_context         Context object. Must be initialized before the call.
+ * @param[in]     p_data_in         Pointer to the input buffer to the AES.
+ * @param[in]     data_size         Size of the data to be processed in bytes.
+ * @param[out]    p_data_out        Pointer to the output buffer.
+ *                                  When padding is set:
+ *                                    - The size of p_data_out buffer must have extra space for
+ *                                      padding. Otherwise, the function will return an error:
+ *                                      NRF_ERROR_CRYPTO_OUTPUT_LENGTH.
+ *                                    - When text_size is multiple of 16 bytes, p_text_out must be
+ *                                      allocated with size equal to text_size + an additional block
+ *                                      (i.e 16 bytes for padding).
+ *                                    - When text_size is not a multiple of 16 bytes, p_text_out
+ *                                      must be allocated with size aligned to the next full 16
+ *                                       bytes block (i.e. 1 - 15 bytes for padding).
+ * @param[in,out] p_data_out_size   IN:
+ *                                      Size of the p_data_out buffer.
+ *                                  OUT:
+ *                                      Upon successfull function execution value will be updated
+ *                                      with number of signifacnt bytes in p_data_out buffer.
+ *                                      On decryption with padding function will result in a value
+ *                                      without padded bytes.
+ *
+ * @return NRF_SUCCESS on success.
+ */
+ret_code_t nrf_crypto_aes_finalize(nrf_crypto_aes_context_t * const p_context,
+                                   uint8_t *                        p_data_in,
+                                   size_t                           data_size,
+                                   uint8_t *                        p_data_out,
+                                   size_t *                         p_data_out_size);
+
+
+
+
+/**@brief AES integrated function for encryption, decryption and MAC calculation.
+ *  It should be called once on the whole data block.
+ *
+ * @param[in]     p_context         Context object. If NULL, memory will be dynamically allocated.
+ * @param[in]     p_info            Pointer to structure holding information about: selected AES
+ *                                  mode, key size, and padding.
+ * @param[in]     operation         Parameter indicating whether an encrypt (NRF_CRYPTO_ENCRYPT),
+ *                                  a decrypt (NRF_CRYPTO_DECRYPT) or MAC calculation
+ *                                  (NRF_CRYPTO_MAC_CALCULATE) operation shall be performed.
+ * @param[in]     p_key             Pointer to the AES key. This buffer will be copied and there is
+ *                                  no need to keep it by the user.
+ * @param[in]     p_iv              Pointer to a buffer of the IV or a counter. This buffer will be
+ *                                  copied and there is no need to keep it by the user.
+ *                                  Can be NULL for ECB and CMAC.
+ * @param[in]     p_data_in         Pointer to the input buffer to the AES.
+ * @param[in]     data_size         Size of the data to be processed in bytes.
+ * @param[out]    p_data_out        Pointer to the output buffer.
+ *                                  When padding is set:
+ *                                    - The size of p_data_out buffer must have extra space for
+ *                                      padding. Otherwise, the function will return an error:
+ *                                      NRF_ERROR_CRYPTO_OUTPUT_LENGTH.
+ *                                    - When text_size is multiple of 16 bytes, p_text_out must be
+ *                                      allocated with size equal to text_size + an additional block
+ *                                      (i.e 16 bytes for padding).
+ *                                    - When text_size is not a multiple of 16 bytes, p_text_out
+ *                                      must be allocated with size aligned to the next full 16
+ *                                      bytes block (i.e. 1 - 15 bytes for padding).
+ * @param[in,out] p_data_out_size   IN:
+ *                                      Size of the p_data_out buffer.
+ *                                  OUT:
+ *                                      Upon successfull function execution value will be updated
+ *                                      with number of signifacnt bytes in p_data_out buffer.
+ *                                      On decryption function will result in a value without padded
+ *                                      bytes.
+ *
+ * @return NRF_SUCCESS on success.
+ */
+ret_code_t nrf_crypto_aes_crypt(nrf_crypto_aes_context_t * const    p_context,
+                                nrf_crypto_aes_info_t const * const p_info,
+                                nrf_crypto_operation_t              operation,
+                                uint8_t *                           p_key,
+                                uint8_t *                           p_iv,
+                                uint8_t *                           p_data_in,
+                                size_t                              data_size,
+                                uint8_t *                           p_data_out,
+                                size_t *                            p_data_out_size);
+#ifdef __cplusplus
+}
+#endif
+
+#endif // #if NRF_MODULE_ENABLED(NRF_CRYPTO) || defined(__SDK_DOXYGEN__)
+
+/** @} */
+
+#endif // #ifndef NRF_CRYPTO_AES_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_aes_backend.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_aes_backend.h
new file mode 100644
index 0000000..5c34476
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_aes_backend.h
@@ -0,0 +1,112 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef NRF_CRYPTO_AES_BACKEND_H__
+#define NRF_CRYPTO_AES_BACKEND_H__
+
+#include "cc310_backend_aes.h"
+#include "mbedtls_backend_aes.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**@internal @brief Fallback type for AES CBC context (if no backend is enabled).
+ */
+#if !NRF_MODULE_ENABLED(NRF_CRYPTO_AES_CBC)
+typedef nrf_crypto_aes_internal_context_t nrf_crypto_backend_aes_cbc_context_t;
+#endif
+
+/**@internal @brief Fallback type for AES CFB context (if no backend is enabled).
+ */
+#if !NRF_MODULE_ENABLED(NRF_CRYPTO_AES_CFB)
+typedef nrf_crypto_aes_internal_context_t nrf_crypto_backend_aes_cfb_context_t;
+#endif
+
+/**@internal @brief Fallback type for AES CTR context (if no backend is enabled).
+ */
+#if !NRF_MODULE_ENABLED(NRF_CRYPTO_AES_CTR)
+typedef nrf_crypto_aes_internal_context_t nrf_crypto_backend_aes_ctr_context_t;
+#endif
+
+/**@internal @brief Fallback type for AES ECB context (if no backend is enabled).
+ */
+#if !NRF_MODULE_ENABLED(NRF_CRYPTO_AES_ECB)
+typedef nrf_crypto_aes_internal_context_t nrf_crypto_backend_aes_ecb_context_t;
+#endif
+
+
+/**@internal @brief Fallback type for AES CBC_MAC context (if no backend is enabled).
+ */
+#if !NRF_MODULE_ENABLED(NRF_CRYPTO_AES_CBC_MAC)
+typedef nrf_crypto_aes_internal_context_t nrf_crypto_backend_aes_cbc_mac_context_t;
+#endif
+
+/**@internal @brief Fallback type for AES CMAC context (if no backend is enabled).
+ */
+#if !NRF_MODULE_ENABLED(NRF_CRYPTO_AES_CMAC)
+typedef nrf_crypto_aes_internal_context_t nrf_crypto_backend_aes_cmac_context_t;
+#endif
+
+/**@internal @brief Fallback type for AES CMAC_PRF128 context (if no backend is enabled).
+ */
+#if !NRF_MODULE_ENABLED(NRF_CRYPTO_AES_CMAC_PRF128)
+typedef nrf_crypto_aes_internal_context_t nrf_crypto_backend_aes_cmac_prf128_context_t;
+#endif
+
+
+/** @internal @brief Union holding a AES context. */
+typedef union
+{
+    nrf_crypto_backend_aes_cbc_context_t cbc_context;   /**< @brief Holds context for AES CBC. */
+    nrf_crypto_backend_aes_cfb_context_t cfb_context;   /**< @brief Holds context for AES CFB. */
+    nrf_crypto_backend_aes_ctr_context_t ctr_context;   /**< @brief Holds context for AES CFB. */
+    nrf_crypto_backend_aes_ecb_context_t ecb_context;   /**< @brief Holds context for AES ECB. */
+
+    nrf_crypto_backend_aes_cbc_mac_context_t     cbc_mac_context;       /**< @brief Holds context for CBC-MAC. */
+    nrf_crypto_backend_aes_cmac_context_t        cmac_context;          /**< @brief Holds context for CMAC. */
+    nrf_crypto_backend_aes_cmac_prf128_context_t cmac_prf128_context;   /**< @brief Holds context for CMAC_PRF128. */
+} nrf_crypto_backend_aes_context_t;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // NRF_CRYPTO_AES_BACKEND_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_aes_shared.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_aes_shared.c
new file mode 100644
index 0000000..615b236
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_aes_shared.c
@@ -0,0 +1,121 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#include "sdk_common.h"
+#if NRF_MODULE_ENABLED(NRF_CRYPTO)
+
+#include "nrf_crypto_error.h"
+#include "sdk_config.h"
+#include "nrf_crypto_types.h"
+
+
+ret_code_t padding_pkcs7_add(uint8_t * p_padding_buff,
+                             uint8_t * p_message_buff,
+                             uint8_t   msg_ending_len)
+{
+    uint8_t padding_count;
+
+    if ((p_padding_buff == NULL) || (p_message_buff == NULL))
+    {
+        return NRF_ERROR_CRYPTO_INPUT_NULL;
+    }
+
+    if (msg_ending_len >= NRF_CRYPTO_AES_BLOCK_SIZE)
+    {
+        return NRF_ERROR_CRYPTO_INVALID_PARAM;
+    }
+
+    /* Creating padding buffer in two steps */
+    /* step 1 add remaining message */
+    memcpy(p_padding_buff, p_message_buff, msg_ending_len);
+
+    /* step 2: add padding */
+    padding_count   = NRF_CRYPTO_AES_BLOCK_SIZE - msg_ending_len;
+    p_padding_buff += msg_ending_len;
+
+    for (size_t i = 0; i < padding_count; i++)
+    {
+        p_padding_buff[i] = padding_count;
+    }
+
+    return NRF_SUCCESS;
+}
+
+ret_code_t padding_pkcs7_remove(uint8_t * p_padded_message,
+                                size_t  * p_message_len)
+{
+    if (p_padded_message == NULL)
+    {
+        return NRF_ERROR_CRYPTO_INPUT_NULL;
+    }
+    if (p_message_len == NULL)
+    {
+        return NRF_ERROR_CRYPTO_OUTPUT_NULL;
+    }
+
+    /* padded_msg_len must be multiple of 16 */
+    if ((*p_message_len == 0) || ((*p_message_len & 0x0F) != 0))
+    {
+        return NRF_ERROR_CRYPTO_INVALID_PARAM;
+    }
+
+    size_t padded_bytes = p_padded_message[*p_message_len - 1];
+
+    if ((padded_bytes == 0) || (padded_bytes > NRF_CRYPTO_AES_BLOCK_SIZE))
+    {
+        return NRF_ERROR_CRYPTO_AES_INVALID_PADDING;
+    }
+
+    /* i = 2: 1 for valid string and 1 for already checked *p_message_len - 1 */
+    for (size_t i = 2; i < padded_bytes; i++)
+    {
+        if (p_padded_message[*p_message_len - i] != padded_bytes)
+        {
+            return NRF_ERROR_CRYPTO_AES_INVALID_PADDING;
+        }
+    }
+
+    *p_message_len -= padded_bytes;
+
+    return NRF_SUCCESS;
+}
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO)
+
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_aes_shared.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_aes_shared.h
new file mode 100644
index 0000000..9878bcb
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_aes_shared.h
@@ -0,0 +1,218 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef NRF_CRYPTO_AES_SHARED_H__
+#define NRF_CRYPTO_AES_SHARED_H__
+
+/** @file
+ *
+ * @defgroup nrf_crypto_aes AES related functions
+ * @{
+ * @ingroup nrf_crypto
+ *
+ * @brief Provides AES related functionality through nrf_crypto.
+ */
+
+#include <stdint.h>
+#include "nrf_crypto_types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/**@internal @brief Magic value to signal that the nrf_crypto_hash context structure is initialized.
+ */
+#define NRF_CRYPTO_AES_INIT_MAGIC_VALUE     (0x53454163)    // ASCII "cAES"
+#define NRF_CRYPTO_AES_UNINIT_MAGIC_VALUE   (0x63414553)    // ASCII "SEAc"
+
+#define NRF_CRYPTO_MBEDTLS_AES_IV_SIZE  (16)
+
+
+/** @internal @brief Enumeration of supported modes of operation in nrf_crypto_aes.
+ */
+typedef enum
+{
+    NRF_CRYPTO_AES_MODE_CBC,                // supported by: MBEDTLS & CC310
+    NRF_CRYPTO_AES_MODE_CBC_PAD_PCKS7,      // supported by: MBEDTLS & CC310
+    NRF_CRYPTO_AES_MODE_CFB,                // supported by: MBEDTLS
+    NRF_CRYPTO_AES_MODE_CTR,                // supported by: MBEDTLS & CC310
+    NRF_CRYPTO_AES_MODE_ECB,                // supported by: MBEDTLS & CC310
+    NRF_CRYPTO_AES_MODE_ECB_PAD_PCKS7,      // supported by: MBEDTLS & CC310
+
+    // Authentication modes
+    NRF_CRYPTO_AES_MODE_CBC_MAC,            // supported by: MBEDTLS & CC310
+    NRF_CRYPTO_AES_MODE_CBC_MAC_PAD_PCKS7,  // supported by: MBEDTLS & CC310
+    NRF_CRYPTO_AES_MODE_CMAC,               // supported by: MBEDTLS & CC310
+} nrf_crypto_aes_mode_t;
+
+/**@internal @brief Type declaration to perform AES initialization in the nrf_crypto backend.
+ *
+ *  This is internal API. See @ref nrf_crypto_aes_init for documentation.
+ */
+typedef ret_code_t (*aes_init_fn_t)(void * const p_context, nrf_crypto_operation_t operation);
+
+/**@internal @brief Type declaration to perform AES uninitialization in the nrf_crypto backend.
+ *
+ *  This is internal API. See @ref nrf_crypto_aes_uninit for documentation.
+ */
+typedef ret_code_t (*aes_uninit_fn_t)(void * const p_context);
+
+/**@internal @brief Type declaration to set an AES key in the nrf_crypto backend.
+ *
+ *  This is internal API. See @ref nrf_crypto_aes_key_set for documentation.
+ */
+typedef ret_code_t (*aes_key_set_fn_t)(void * const p_context, uint8_t * p_key);
+
+/**@internal @brief Type declaration to set an AES IV in the nrf_crypto backend.
+ *
+ *  This is internal API. See @ref nrf_crypto_aes_iv_set for documentation.
+ */
+typedef ret_code_t (*aes_iv_set_fn_t)(void * const p_context, uint8_t * p_iv);
+
+/**@internal @brief Type declaration to get an AES IV in the nrf_crypto backend.
+ *
+ *  This is internal API. See @ref nrf_crypto_aes_iv_get for documentation.
+ */
+typedef ret_code_t (*aes_iv_get_fn_t)(void * const p_context, uint8_t * p_iv);
+
+/**@internal @brief Type declaration to perform AES block operation in the nrf_crypto backend.
+ *
+ *  This is internal API. See @ref nrf_crypto_aes_update for documentation.
+ */
+typedef ret_code_t (*aes_update_fn_t)(void * const p_context,
+                                      uint8_t *    p_data_in,
+                                      size_t       data_size,
+                                      uint8_t *    p_data_out);
+
+/**@internal @brief Type declaration to finalize AES operation in the nrf_crypto backend.
+ *
+ *  This is internal API. See @ref nrf_crypto_aes_finalize for documentation.
+ */
+typedef ret_code_t (*aes_finalize_fn_t)(void * const p_context,
+                                        uint8_t *    p_data_in,
+                                        size_t       data_size,
+                                        uint8_t *    p_data_out,
+                                        size_t *     p_data_out_size);
+
+/**@internal @brief Type declaration for an nrf_crypto_aes info structure.
+ *
+ * @details     This structure contains the calling interface and any metadata required
+ *              to call the nrf_crypto_aes API functions.
+ */
+typedef struct
+{
+    nrf_crypto_aes_mode_t    const mode;
+    nrf_crypto_key_size_id_t const key_size;
+    size_t                   const context_size;
+
+    aes_init_fn_t            const init_fn;
+    aes_uninit_fn_t          const uninit_fn;
+    aes_key_set_fn_t         const key_set_fn;
+    aes_iv_set_fn_t          const iv_set_fn;
+    aes_iv_get_fn_t          const iv_get_fn;
+    aes_update_fn_t          const update_fn;
+    aes_finalize_fn_t        const finalize_fn;
+} nrf_crypto_aes_info_t;
+
+/**@internal @brief Type declaration of internal representation of an AES context structure.
+ *
+ * @details     This is an internal type that should not be used directly.
+ */
+typedef struct
+{
+    uint32_t init_value;
+    nrf_crypto_aes_info_t const * p_info;
+} nrf_crypto_aes_internal_context_t;
+
+
+/**@internal @brief Type declaration of internal representation of an AES backend context structure.
+ *                  with initialization vector.
+ *
+ * @details     This is an internal type that should not be used directly.
+ */
+typedef struct
+{
+    nrf_crypto_operation_t operation;
+
+    uint8_t  iv[NRF_CRYPTO_MBEDTLS_AES_IV_SIZE]; // space for 128-bit initialization vector
+} nrf_crypto_backend_aes_ctx_t;
+
+/**@internal @brief Type declaration of internal representation of an AES backend context structure
+ *                   without initialization vector.
+ *
+ * @details     This is an internal type that should not be used directly.
+ */
+typedef struct
+{
+    nrf_crypto_operation_t operation;
+} nrf_crypto_backend_no_iv_aes_ctx_t;
+
+
+/**@internal @brief Function copies remainders (msg_ending_len) from p_message_buff to the
+ *                  p_padding_buff. Next it adds pkcs7-padding to have a 16 bytes p_padding_buff.
+ *
+ * @param[in] p_padding_buff    Pointer the buffer with padded message.
+ * @param[in] p_message_buff    Pointer to the buffer with message that must be padded.
+ * @param[in] msg_ending_len    Message remainders length.
+ *
+ */
+ret_code_t padding_pkcs7_add(uint8_t * p_padding_buff,
+                             uint8_t * p_message_buff,
+                             uint8_t   msg_ending_len);
+
+
+/**@internal @brief Function calculate message length without padding.
+ *
+ * @param[in]     p_padded_message      Pointer the buffer with padded message.
+ * @param[in/out] p_message_len         IN:  padded message length
+ *                                      OUT: message length without padding
+ */
+ret_code_t padding_pkcs7_remove(uint8_t * p_padded_message,
+                                size_t  * p_message_len);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+/** @} */
+
+#endif // #ifndef NRF_CRYPTO_AES_SHARED_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_ecc.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_ecc.c
new file mode 100644
index 0000000..8bff9a7
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_ecc.c
@@ -0,0 +1,1314 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#include "nordic_common.h"
+#include "nrf_crypto_error.h"
+#include "nrf_crypto_mem.h"
+#include "nrf_crypto_ecc.h"
+#include "app_util.h"
+#include "sdk_macros.h"
+
+
+#if NRF_CRYPTO_ECC_ENABLED
+
+
+#if NRF_CRYPTO_ECC_IMPLEMENTED_CURVES_COUNT > 1
+
+
+static const nrf_crypto_backend_ecc_key_pair_generate_fn_t key_pair_generate_impl[] =
+{
+#if NRF_CRYPTO_ECC_SECP160R1_ENABLED
+    nrf_crypto_backend_secp160r1_key_pair_generate,
+#endif
+#if NRF_CRYPTO_ECC_SECP160R2_ENABLED
+    nrf_crypto_backend_secp160r2_key_pair_generate,
+#endif
+#if NRF_CRYPTO_ECC_SECP192R1_ENABLED
+    nrf_crypto_backend_secp192r1_key_pair_generate,
+#endif
+#if NRF_CRYPTO_ECC_SECP224R1_ENABLED
+    nrf_crypto_backend_secp224r1_key_pair_generate,
+#endif
+#if NRF_CRYPTO_ECC_SECP256R1_ENABLED
+    nrf_crypto_backend_secp256r1_key_pair_generate,
+#endif
+#if NRF_CRYPTO_ECC_SECP384R1_ENABLED
+    nrf_crypto_backend_secp384r1_key_pair_generate,
+#endif
+#if NRF_CRYPTO_ECC_SECP521R1_ENABLED
+    nrf_crypto_backend_secp521r1_key_pair_generate,
+#endif
+#if NRF_CRYPTO_ECC_SECP160K1_ENABLED
+    nrf_crypto_backend_secp160k1_key_pair_generate,
+#endif
+#if NRF_CRYPTO_ECC_SECP192K1_ENABLED
+    nrf_crypto_backend_secp192k1_key_pair_generate,
+#endif
+#if NRF_CRYPTO_ECC_SECP224K1_ENABLED
+    nrf_crypto_backend_secp224k1_key_pair_generate,
+#endif
+#if NRF_CRYPTO_ECC_SECP256K1_ENABLED
+    nrf_crypto_backend_secp256k1_key_pair_generate,
+#endif
+#if NRF_CRYPTO_ECC_BP256R1_ENABLED
+    nrf_crypto_backend_bp256r1_key_pair_generate,
+#endif
+#if NRF_CRYPTO_ECC_BP384R1_ENABLED
+    nrf_crypto_backend_bp384r1_key_pair_generate,
+#endif
+#if NRF_CRYPTO_ECC_BP512R1_ENABLED
+    nrf_crypto_backend_bp512r1_key_pair_generate,
+#endif
+#if NRF_CRYPTO_ECC_CURVE25519_ENABLED
+    nrf_crypto_backend_curve25519_key_pair_generate,
+#endif
+#if NRF_CRYPTO_ECC_ED25519_ENABLED
+    nrf_crypto_backend_ed25519_key_pair_generate,
+#endif
+};
+
+
+static const uint16_t key_pair_generate_context_size[] =
+{
+#if NRF_CRYPTO_ECC_SECP160R1_ENABLED
+    NRF_CRYPTO_BACKEND_SECP160R1_KEY_PAIR_GENERATE_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_SECP160R2_ENABLED
+    NRF_CRYPTO_BACKEND_SECP160R2_KEY_PAIR_GENERATE_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_SECP192R1_ENABLED
+    NRF_CRYPTO_BACKEND_SECP192R1_KEY_PAIR_GENERATE_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_SECP224R1_ENABLED
+    NRF_CRYPTO_BACKEND_SECP224R1_KEY_PAIR_GENERATE_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_SECP256R1_ENABLED
+    NRF_CRYPTO_BACKEND_SECP256R1_KEY_PAIR_GENERATE_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_SECP384R1_ENABLED
+    NRF_CRYPTO_BACKEND_SECP384R1_KEY_PAIR_GENERATE_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_SECP521R1_ENABLED
+    NRF_CRYPTO_BACKEND_SECP521R1_KEY_PAIR_GENERATE_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_SECP160K1_ENABLED
+    NRF_CRYPTO_BACKEND_SECP160K1_KEY_PAIR_GENERATE_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_SECP192K1_ENABLED
+    NRF_CRYPTO_BACKEND_SECP192K1_KEY_PAIR_GENERATE_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_SECP224K1_ENABLED
+    NRF_CRYPTO_BACKEND_SECP224K1_KEY_PAIR_GENERATE_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_SECP256K1_ENABLED
+    NRF_CRYPTO_BACKEND_SECP256K1_KEY_PAIR_GENERATE_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_BP256R1_ENABLED
+    NRF_CRYPTO_BACKEND_BP256R1_KEY_PAIR_GENERATE_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_BP384R1_ENABLED
+    NRF_CRYPTO_BACKEND_BP384R1_KEY_PAIR_GENERATE_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_BP512R1_ENABLED
+    NRF_CRYPTO_BACKEND_BP512R1_KEY_PAIR_GENERATE_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_CURVE25519_ENABLED
+    NRF_CRYPTO_BACKEND_CURVE25519_KEY_PAIR_GENERATE_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_ED25519_ENABLED
+    NRF_CRYPTO_BACKEND_ED25519_KEY_PAIR_GENERATE_CONTEXT_SIZE,
+#endif
+};
+
+
+static const nrf_crypto_backend_ecc_public_key_calculate_fn_t public_key_calculate_impl[] =
+{
+#if NRF_CRYPTO_ECC_SECP160R1_ENABLED
+    nrf_crypto_backend_secp160r1_public_key_calculate,
+#endif
+#if NRF_CRYPTO_ECC_SECP160R2_ENABLED
+    nrf_crypto_backend_secp160r2_public_key_calculate,
+#endif
+#if NRF_CRYPTO_ECC_SECP192R1_ENABLED
+    nrf_crypto_backend_secp192r1_public_key_calculate,
+#endif
+#if NRF_CRYPTO_ECC_SECP224R1_ENABLED
+    nrf_crypto_backend_secp224r1_public_key_calculate,
+#endif
+#if NRF_CRYPTO_ECC_SECP256R1_ENABLED
+    nrf_crypto_backend_secp256r1_public_key_calculate,
+#endif
+#if NRF_CRYPTO_ECC_SECP384R1_ENABLED
+    nrf_crypto_backend_secp384r1_public_key_calculate,
+#endif
+#if NRF_CRYPTO_ECC_SECP521R1_ENABLED
+    nrf_crypto_backend_secp521r1_public_key_calculate,
+#endif
+#if NRF_CRYPTO_ECC_SECP160K1_ENABLED
+    nrf_crypto_backend_secp160k1_public_key_calculate,
+#endif
+#if NRF_CRYPTO_ECC_SECP192K1_ENABLED
+    nrf_crypto_backend_secp192k1_public_key_calculate,
+#endif
+#if NRF_CRYPTO_ECC_SECP224K1_ENABLED
+    nrf_crypto_backend_secp224k1_public_key_calculate,
+#endif
+#if NRF_CRYPTO_ECC_SECP256K1_ENABLED
+    nrf_crypto_backend_secp256k1_public_key_calculate,
+#endif
+#if NRF_CRYPTO_ECC_BP256R1_ENABLED
+    nrf_crypto_backend_bp256r1_public_key_calculate,
+#endif
+#if NRF_CRYPTO_ECC_BP384R1_ENABLED
+    nrf_crypto_backend_bp384r1_public_key_calculate,
+#endif
+#if NRF_CRYPTO_ECC_BP512R1_ENABLED
+    nrf_crypto_backend_bp512r1_public_key_calculate,
+#endif
+#if NRF_CRYPTO_ECC_CURVE25519_ENABLED
+    nrf_crypto_backend_curve25519_public_key_calculate,
+#endif
+#if NRF_CRYPTO_ECC_ED25519_ENABLED
+    nrf_crypto_backend_ed25519_public_key_calculate,
+#endif
+};
+
+
+static const uint16_t public_key_calculate_context_size[] =
+{
+#if NRF_CRYPTO_ECC_SECP160R1_ENABLED
+    NRF_CRYPTO_BACKEND_SECP160R1_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_SECP160R2_ENABLED
+    NRF_CRYPTO_BACKEND_SECP160R2_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_SECP192R1_ENABLED
+    NRF_CRYPTO_BACKEND_SECP192R1_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_SECP224R1_ENABLED
+    NRF_CRYPTO_BACKEND_SECP224R1_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_SECP256R1_ENABLED
+    NRF_CRYPTO_BACKEND_SECP256R1_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_SECP384R1_ENABLED
+    NRF_CRYPTO_BACKEND_SECP384R1_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_SECP521R1_ENABLED
+    NRF_CRYPTO_BACKEND_SECP521R1_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_SECP160K1_ENABLED
+    NRF_CRYPTO_BACKEND_SECP160K1_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_SECP192K1_ENABLED
+    NRF_CRYPTO_BACKEND_SECP192K1_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_SECP224K1_ENABLED
+    NRF_CRYPTO_BACKEND_SECP224K1_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_SECP256K1_ENABLED
+    NRF_CRYPTO_BACKEND_SECP256K1_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_BP256R1_ENABLED
+    NRF_CRYPTO_BACKEND_BP256R1_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_BP384R1_ENABLED
+    NRF_CRYPTO_BACKEND_BP384R1_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_BP512R1_ENABLED
+    NRF_CRYPTO_BACKEND_BP512R1_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_CURVE25519_ENABLED
+    NRF_CRYPTO_BACKEND_CURVE25519_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_ED25519_ENABLED
+    NRF_CRYPTO_BACKEND_ED25519_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE,
+#endif
+};
+
+
+static const nrf_crypto_backend_ecc_private_key_from_raw_fn_t private_key_from_raw_impl[] =
+{
+#if NRF_CRYPTO_ECC_SECP160R1_ENABLED
+    nrf_crypto_backend_secp160r1_private_key_from_raw,
+#endif
+#if NRF_CRYPTO_ECC_SECP160R2_ENABLED
+    nrf_crypto_backend_secp160r2_private_key_from_raw,
+#endif
+#if NRF_CRYPTO_ECC_SECP192R1_ENABLED
+    nrf_crypto_backend_secp192r1_private_key_from_raw,
+#endif
+#if NRF_CRYPTO_ECC_SECP224R1_ENABLED
+    nrf_crypto_backend_secp224r1_private_key_from_raw,
+#endif
+#if NRF_CRYPTO_ECC_SECP256R1_ENABLED
+    nrf_crypto_backend_secp256r1_private_key_from_raw,
+#endif
+#if NRF_CRYPTO_ECC_SECP384R1_ENABLED
+    nrf_crypto_backend_secp384r1_private_key_from_raw,
+#endif
+#if NRF_CRYPTO_ECC_SECP521R1_ENABLED
+    nrf_crypto_backend_secp521r1_private_key_from_raw,
+#endif
+#if NRF_CRYPTO_ECC_SECP160K1_ENABLED
+    nrf_crypto_backend_secp160k1_private_key_from_raw,
+#endif
+#if NRF_CRYPTO_ECC_SECP192K1_ENABLED
+    nrf_crypto_backend_secp192k1_private_key_from_raw,
+#endif
+#if NRF_CRYPTO_ECC_SECP224K1_ENABLED
+    nrf_crypto_backend_secp224k1_private_key_from_raw,
+#endif
+#if NRF_CRYPTO_ECC_SECP256K1_ENABLED
+    nrf_crypto_backend_secp256k1_private_key_from_raw,
+#endif
+#if NRF_CRYPTO_ECC_BP256R1_ENABLED
+    nrf_crypto_backend_bp256r1_private_key_from_raw,
+#endif
+#if NRF_CRYPTO_ECC_BP384R1_ENABLED
+    nrf_crypto_backend_bp384r1_private_key_from_raw,
+#endif
+#if NRF_CRYPTO_ECC_BP512R1_ENABLED
+    nrf_crypto_backend_bp512r1_private_key_from_raw,
+#endif
+#if NRF_CRYPTO_ECC_CURVE25519_ENABLED
+    nrf_crypto_backend_curve25519_private_key_from_raw,
+#endif
+#if NRF_CRYPTO_ECC_ED25519_ENABLED
+    nrf_crypto_backend_ed25519_private_key_from_raw,
+#endif
+};
+
+
+static const nrf_crypto_backend_ecc_private_key_to_raw_fn_t private_key_to_raw_impl[] =
+{
+#if NRF_CRYPTO_ECC_SECP160R1_ENABLED
+    nrf_crypto_backend_secp160r1_private_key_to_raw,
+#endif
+#if NRF_CRYPTO_ECC_SECP160R2_ENABLED
+    nrf_crypto_backend_secp160r2_private_key_to_raw,
+#endif
+#if NRF_CRYPTO_ECC_SECP192R1_ENABLED
+    nrf_crypto_backend_secp192r1_private_key_to_raw,
+#endif
+#if NRF_CRYPTO_ECC_SECP224R1_ENABLED
+    nrf_crypto_backend_secp224r1_private_key_to_raw,
+#endif
+#if NRF_CRYPTO_ECC_SECP256R1_ENABLED
+    nrf_crypto_backend_secp256r1_private_key_to_raw,
+#endif
+#if NRF_CRYPTO_ECC_SECP384R1_ENABLED
+    nrf_crypto_backend_secp384r1_private_key_to_raw,
+#endif
+#if NRF_CRYPTO_ECC_SECP521R1_ENABLED
+    nrf_crypto_backend_secp521r1_private_key_to_raw,
+#endif
+#if NRF_CRYPTO_ECC_SECP160K1_ENABLED
+    nrf_crypto_backend_secp160k1_private_key_to_raw,
+#endif
+#if NRF_CRYPTO_ECC_SECP192K1_ENABLED
+    nrf_crypto_backend_secp192k1_private_key_to_raw,
+#endif
+#if NRF_CRYPTO_ECC_SECP224K1_ENABLED
+    nrf_crypto_backend_secp224k1_private_key_to_raw,
+#endif
+#if NRF_CRYPTO_ECC_SECP256K1_ENABLED
+    nrf_crypto_backend_secp256k1_private_key_to_raw,
+#endif
+#if NRF_CRYPTO_ECC_BP256R1_ENABLED
+    nrf_crypto_backend_bp256r1_private_key_to_raw,
+#endif
+#if NRF_CRYPTO_ECC_BP384R1_ENABLED
+    nrf_crypto_backend_bp384r1_private_key_to_raw,
+#endif
+#if NRF_CRYPTO_ECC_BP512R1_ENABLED
+    nrf_crypto_backend_bp512r1_private_key_to_raw,
+#endif
+#if NRF_CRYPTO_ECC_CURVE25519_ENABLED
+    nrf_crypto_backend_curve25519_private_key_to_raw,
+#endif
+#if NRF_CRYPTO_ECC_ED25519_ENABLED
+    nrf_crypto_backend_ed25519_private_key_to_raw,
+#endif
+};
+
+
+static const nrf_crypto_backend_ecc_public_key_from_raw_fn_t public_key_from_raw_impl[] =
+{
+#if NRF_CRYPTO_ECC_SECP160R1_ENABLED
+    nrf_crypto_backend_secp160r1_public_key_from_raw,
+#endif
+#if NRF_CRYPTO_ECC_SECP160R2_ENABLED
+    nrf_crypto_backend_secp160r2_public_key_from_raw,
+#endif
+#if NRF_CRYPTO_ECC_SECP192R1_ENABLED
+    nrf_crypto_backend_secp192r1_public_key_from_raw,
+#endif
+#if NRF_CRYPTO_ECC_SECP224R1_ENABLED
+    nrf_crypto_backend_secp224r1_public_key_from_raw,
+#endif
+#if NRF_CRYPTO_ECC_SECP256R1_ENABLED
+    nrf_crypto_backend_secp256r1_public_key_from_raw,
+#endif
+#if NRF_CRYPTO_ECC_SECP384R1_ENABLED
+    nrf_crypto_backend_secp384r1_public_key_from_raw,
+#endif
+#if NRF_CRYPTO_ECC_SECP521R1_ENABLED
+    nrf_crypto_backend_secp521r1_public_key_from_raw,
+#endif
+#if NRF_CRYPTO_ECC_SECP160K1_ENABLED
+    nrf_crypto_backend_secp160k1_public_key_from_raw,
+#endif
+#if NRF_CRYPTO_ECC_SECP192K1_ENABLED
+    nrf_crypto_backend_secp192k1_public_key_from_raw,
+#endif
+#if NRF_CRYPTO_ECC_SECP224K1_ENABLED
+    nrf_crypto_backend_secp224k1_public_key_from_raw,
+#endif
+#if NRF_CRYPTO_ECC_SECP256K1_ENABLED
+    nrf_crypto_backend_secp256k1_public_key_from_raw,
+#endif
+#if NRF_CRYPTO_ECC_BP256R1_ENABLED
+    nrf_crypto_backend_bp256r1_public_key_from_raw,
+#endif
+#if NRF_CRYPTO_ECC_BP384R1_ENABLED
+    nrf_crypto_backend_bp384r1_public_key_from_raw,
+#endif
+#if NRF_CRYPTO_ECC_BP512R1_ENABLED
+    nrf_crypto_backend_bp512r1_public_key_from_raw,
+#endif
+#if NRF_CRYPTO_ECC_CURVE25519_ENABLED
+    nrf_crypto_backend_curve25519_public_key_from_raw,
+#endif
+#if NRF_CRYPTO_ECC_ED25519_ENABLED
+    nrf_crypto_backend_ed25519_public_key_from_raw,
+#endif
+};
+
+
+static const nrf_crypto_backend_ecc_public_key_to_raw_fn_t public_key_to_raw_impl[] =
+{
+#if NRF_CRYPTO_ECC_SECP160R1_ENABLED
+    nrf_crypto_backend_secp160r1_public_key_to_raw,
+#endif
+#if NRF_CRYPTO_ECC_SECP160R2_ENABLED
+    nrf_crypto_backend_secp160r2_public_key_to_raw,
+#endif
+#if NRF_CRYPTO_ECC_SECP192R1_ENABLED
+    nrf_crypto_backend_secp192r1_public_key_to_raw,
+#endif
+#if NRF_CRYPTO_ECC_SECP224R1_ENABLED
+    nrf_crypto_backend_secp224r1_public_key_to_raw,
+#endif
+#if NRF_CRYPTO_ECC_SECP256R1_ENABLED
+    nrf_crypto_backend_secp256r1_public_key_to_raw,
+#endif
+#if NRF_CRYPTO_ECC_SECP384R1_ENABLED
+    nrf_crypto_backend_secp384r1_public_key_to_raw,
+#endif
+#if NRF_CRYPTO_ECC_SECP521R1_ENABLED
+    nrf_crypto_backend_secp521r1_public_key_to_raw,
+#endif
+#if NRF_CRYPTO_ECC_SECP160K1_ENABLED
+    nrf_crypto_backend_secp160k1_public_key_to_raw,
+#endif
+#if NRF_CRYPTO_ECC_SECP192K1_ENABLED
+    nrf_crypto_backend_secp192k1_public_key_to_raw,
+#endif
+#if NRF_CRYPTO_ECC_SECP224K1_ENABLED
+    nrf_crypto_backend_secp224k1_public_key_to_raw,
+#endif
+#if NRF_CRYPTO_ECC_SECP256K1_ENABLED
+    nrf_crypto_backend_secp256k1_public_key_to_raw,
+#endif
+#if NRF_CRYPTO_ECC_BP256R1_ENABLED
+    nrf_crypto_backend_bp256r1_public_key_to_raw,
+#endif
+#if NRF_CRYPTO_ECC_BP384R1_ENABLED
+    nrf_crypto_backend_bp384r1_public_key_to_raw,
+#endif
+#if NRF_CRYPTO_ECC_BP512R1_ENABLED
+    nrf_crypto_backend_bp512r1_public_key_to_raw,
+#endif
+#if NRF_CRYPTO_ECC_CURVE25519_ENABLED
+    nrf_crypto_backend_curve25519_public_key_to_raw,
+#endif
+#if NRF_CRYPTO_ECC_ED25519_ENABLED
+    nrf_crypto_backend_ed25519_public_key_to_raw,
+#endif
+};
+
+
+static const nrf_crypto_backend_ecc_key_free_fn_t private_key_free_impl[] =
+{
+#if NRF_CRYPTO_ECC_SECP160R1_ENABLED
+    nrf_crypto_backend_secp160r1_private_key_free,
+#endif
+#if NRF_CRYPTO_ECC_SECP160R2_ENABLED
+    nrf_crypto_backend_secp160r2_private_key_free,
+#endif
+#if NRF_CRYPTO_ECC_SECP192R1_ENABLED
+    nrf_crypto_backend_secp192r1_private_key_free,
+#endif
+#if NRF_CRYPTO_ECC_SECP224R1_ENABLED
+    nrf_crypto_backend_secp224r1_private_key_free,
+#endif
+#if NRF_CRYPTO_ECC_SECP256R1_ENABLED
+    nrf_crypto_backend_secp256r1_private_key_free,
+#endif
+#if NRF_CRYPTO_ECC_SECP384R1_ENABLED
+    nrf_crypto_backend_secp384r1_private_key_free,
+#endif
+#if NRF_CRYPTO_ECC_SECP521R1_ENABLED
+    nrf_crypto_backend_secp521r1_private_key_free,
+#endif
+#if NRF_CRYPTO_ECC_SECP160K1_ENABLED
+    nrf_crypto_backend_secp160k1_private_key_free,
+#endif
+#if NRF_CRYPTO_ECC_SECP192K1_ENABLED
+    nrf_crypto_backend_secp192k1_private_key_free,
+#endif
+#if NRF_CRYPTO_ECC_SECP224K1_ENABLED
+    nrf_crypto_backend_secp224k1_private_key_free,
+#endif
+#if NRF_CRYPTO_ECC_SECP256K1_ENABLED
+    nrf_crypto_backend_secp256k1_private_key_free,
+#endif
+#if NRF_CRYPTO_ECC_BP256R1_ENABLED
+    nrf_crypto_backend_bp256r1_private_key_free,
+#endif
+#if NRF_CRYPTO_ECC_BP384R1_ENABLED
+    nrf_crypto_backend_bp384r1_private_key_free,
+#endif
+#if NRF_CRYPTO_ECC_BP512R1_ENABLED
+    nrf_crypto_backend_bp512r1_private_key_free,
+#endif
+#if NRF_CRYPTO_ECC_CURVE25519_ENABLED
+    nrf_crypto_backend_curve25519_private_key_free,
+#endif
+#if NRF_CRYPTO_ECC_ED25519_ENABLED
+    nrf_crypto_backend_ed25519_private_key_free,
+#endif
+};
+
+
+static const nrf_crypto_backend_ecc_key_free_fn_t public_key_free_impl[] =
+{
+#if NRF_CRYPTO_ECC_SECP160R1_ENABLED
+    nrf_crypto_backend_secp160r1_public_key_free,
+#endif
+#if NRF_CRYPTO_ECC_SECP160R2_ENABLED
+    nrf_crypto_backend_secp160r2_public_key_free,
+#endif
+#if NRF_CRYPTO_ECC_SECP192R1_ENABLED
+    nrf_crypto_backend_secp192r1_public_key_free,
+#endif
+#if NRF_CRYPTO_ECC_SECP224R1_ENABLED
+    nrf_crypto_backend_secp224r1_public_key_free,
+#endif
+#if NRF_CRYPTO_ECC_SECP256R1_ENABLED
+    nrf_crypto_backend_secp256r1_public_key_free,
+#endif
+#if NRF_CRYPTO_ECC_SECP384R1_ENABLED
+    nrf_crypto_backend_secp384r1_public_key_free,
+#endif
+#if NRF_CRYPTO_ECC_SECP521R1_ENABLED
+    nrf_crypto_backend_secp521r1_public_key_free,
+#endif
+#if NRF_CRYPTO_ECC_SECP160K1_ENABLED
+    nrf_crypto_backend_secp160k1_public_key_free,
+#endif
+#if NRF_CRYPTO_ECC_SECP192K1_ENABLED
+    nrf_crypto_backend_secp192k1_public_key_free,
+#endif
+#if NRF_CRYPTO_ECC_SECP224K1_ENABLED
+    nrf_crypto_backend_secp224k1_public_key_free,
+#endif
+#if NRF_CRYPTO_ECC_SECP256K1_ENABLED
+    nrf_crypto_backend_secp256k1_public_key_free,
+#endif
+#if NRF_CRYPTO_ECC_BP256R1_ENABLED
+    nrf_crypto_backend_bp256r1_public_key_free,
+#endif
+#if NRF_CRYPTO_ECC_BP384R1_ENABLED
+    nrf_crypto_backend_bp384r1_public_key_free,
+#endif
+#if NRF_CRYPTO_ECC_BP512R1_ENABLED
+    nrf_crypto_backend_bp512r1_public_key_free,
+#endif
+#if NRF_CRYPTO_ECC_CURVE25519_ENABLED
+    nrf_crypto_backend_curve25519_public_key_free,
+#endif
+#if NRF_CRYPTO_ECC_ED25519_ENABLED
+    nrf_crypto_backend_ed25519_public_key_free,
+#endif
+};
+
+
+#define BACKEND_IMPL_GET(table, curve_type) (table)[(uint32_t)(curve_type)]
+
+
+#else
+
+
+#if NRF_CRYPTO_ECC_SECP160R1_ENABLED
+#define key_pair_generate_impl    nrf_crypto_backend_secp160r1_key_pair_generate
+#define public_key_calculate_impl nrf_crypto_backend_secp160r1_public_key_calculate
+#define private_key_from_raw_impl nrf_crypto_backend_secp160r1_private_key_from_raw
+#define private_key_to_raw_impl   nrf_crypto_backend_secp160r1_private_key_to_raw
+#define public_key_from_raw_impl  nrf_crypto_backend_secp160r1_public_key_from_raw
+#define public_key_to_raw_impl    nrf_crypto_backend_secp160r1_public_key_to_raw
+#define private_key_free_impl     nrf_crypto_backend_secp160r1_private_key_free
+#define public_key_free_impl      nrf_crypto_backend_secp160r1_public_key_free
+#define key_pair_generate_context_size \
+    NRF_CRYPTO_BACKEND_SECP160R1_KEY_PAIR_GENERATE_CONTEXT_SIZE
+#define public_key_calculate_context_size \
+    NRF_CRYPTO_BACKEND_SECP160R1_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE
+#elif NRF_CRYPTO_ECC_SECP160R2_ENABLED
+#define key_pair_generate_impl    nrf_crypto_backend_secp160r2_key_pair_generate
+#define public_key_calculate_impl nrf_crypto_backend_secp160r2_public_key_calculate
+#define private_key_from_raw_impl nrf_crypto_backend_secp160r2_private_key_from_raw
+#define private_key_to_raw_impl   nrf_crypto_backend_secp160r2_private_key_to_raw
+#define public_key_from_raw_impl  nrf_crypto_backend_secp160r2_public_key_from_raw
+#define public_key_to_raw_impl    nrf_crypto_backend_secp160r2_public_key_to_raw
+#define private_key_free_impl     nrf_crypto_backend_secp160r2_private_key_free
+#define public_key_free_impl      nrf_crypto_backend_secp160r2_public_key_free
+#define key_pair_generate_context_size \
+    NRF_CRYPTO_BACKEND_SECP160R2_KEY_PAIR_GENERATE_CONTEXT_SIZE
+#define public_key_calculate_context_size \
+    NRF_CRYPTO_BACKEND_SECP160R2_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE
+#elif NRF_CRYPTO_ECC_SECP192R1_ENABLED
+#define key_pair_generate_impl    nrf_crypto_backend_secp192r1_key_pair_generate
+#define public_key_calculate_impl nrf_crypto_backend_secp192r1_public_key_calculate
+#define private_key_from_raw_impl nrf_crypto_backend_secp192r1_private_key_from_raw
+#define private_key_to_raw_impl   nrf_crypto_backend_secp192r1_private_key_to_raw
+#define public_key_from_raw_impl  nrf_crypto_backend_secp192r1_public_key_from_raw
+#define public_key_to_raw_impl    nrf_crypto_backend_secp192r1_public_key_to_raw
+#define private_key_free_impl     nrf_crypto_backend_secp192r1_private_key_free
+#define public_key_free_impl      nrf_crypto_backend_secp192r1_public_key_free
+#define key_pair_generate_context_size \
+    NRF_CRYPTO_BACKEND_SECP192R1_KEY_PAIR_GENERATE_CONTEXT_SIZE
+#define public_key_calculate_context_size \
+    NRF_CRYPTO_BACKEND_SECP192R1_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE
+#elif NRF_CRYPTO_ECC_SECP224R1_ENABLED
+#define key_pair_generate_impl    nrf_crypto_backend_secp224r1_key_pair_generate
+#define public_key_calculate_impl nrf_crypto_backend_secp224r1_public_key_calculate
+#define private_key_from_raw_impl nrf_crypto_backend_secp224r1_private_key_from_raw
+#define private_key_to_raw_impl   nrf_crypto_backend_secp224r1_private_key_to_raw
+#define public_key_from_raw_impl  nrf_crypto_backend_secp224r1_public_key_from_raw
+#define public_key_to_raw_impl    nrf_crypto_backend_secp224r1_public_key_to_raw
+#define private_key_free_impl     nrf_crypto_backend_secp224r1_private_key_free
+#define public_key_free_impl      nrf_crypto_backend_secp224r1_public_key_free
+#define key_pair_generate_context_size \
+    NRF_CRYPTO_BACKEND_SECP224R1_KEY_PAIR_GENERATE_CONTEXT_SIZE
+#define public_key_calculate_context_size \
+    NRF_CRYPTO_BACKEND_SECP224R1_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE
+#elif NRF_CRYPTO_ECC_SECP256R1_ENABLED
+#define key_pair_generate_impl    nrf_crypto_backend_secp256r1_key_pair_generate
+#define public_key_calculate_impl nrf_crypto_backend_secp256r1_public_key_calculate
+#define private_key_from_raw_impl nrf_crypto_backend_secp256r1_private_key_from_raw
+#define private_key_to_raw_impl   nrf_crypto_backend_secp256r1_private_key_to_raw
+#define public_key_from_raw_impl  nrf_crypto_backend_secp256r1_public_key_from_raw
+#define public_key_to_raw_impl    nrf_crypto_backend_secp256r1_public_key_to_raw
+#define private_key_free_impl     nrf_crypto_backend_secp256r1_private_key_free
+#define public_key_free_impl      nrf_crypto_backend_secp256r1_public_key_free
+#define key_pair_generate_context_size \
+    NRF_CRYPTO_BACKEND_SECP256R1_KEY_PAIR_GENERATE_CONTEXT_SIZE
+#define public_key_calculate_context_size \
+    NRF_CRYPTO_BACKEND_SECP256R1_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE
+#elif NRF_CRYPTO_ECC_SECP384R1_ENABLED
+#define key_pair_generate_impl    nrf_crypto_backend_secp384r1_key_pair_generate
+#define public_key_calculate_impl nrf_crypto_backend_secp384r1_public_key_calculate
+#define private_key_from_raw_impl nrf_crypto_backend_secp384r1_private_key_from_raw
+#define private_key_to_raw_impl   nrf_crypto_backend_secp384r1_private_key_to_raw
+#define public_key_from_raw_impl  nrf_crypto_backend_secp384r1_public_key_from_raw
+#define public_key_to_raw_impl    nrf_crypto_backend_secp384r1_public_key_to_raw
+#define private_key_free_impl     nrf_crypto_backend_secp384r1_private_key_free
+#define public_key_free_impl      nrf_crypto_backend_secp384r1_public_key_free
+#define key_pair_generate_context_size \
+    NRF_CRYPTO_BACKEND_SECP384R1_KEY_PAIR_GENERATE_CONTEXT_SIZE
+#define public_key_calculate_context_size \
+    NRF_CRYPTO_BACKEND_SECP384R1_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE
+#elif NRF_CRYPTO_ECC_SECP521R1_ENABLED
+#define key_pair_generate_impl    nrf_crypto_backend_secp521r1_key_pair_generate
+#define public_key_calculate_impl nrf_crypto_backend_secp521r1_public_key_calculate
+#define private_key_from_raw_impl nrf_crypto_backend_secp521r1_private_key_from_raw
+#define private_key_to_raw_impl   nrf_crypto_backend_secp521r1_private_key_to_raw
+#define public_key_from_raw_impl  nrf_crypto_backend_secp521r1_public_key_from_raw
+#define public_key_to_raw_impl    nrf_crypto_backend_secp521r1_public_key_to_raw
+#define private_key_free_impl     nrf_crypto_backend_secp521r1_private_key_free
+#define public_key_free_impl      nrf_crypto_backend_secp521r1_public_key_free
+#define key_pair_generate_context_size \
+    NRF_CRYPTO_BACKEND_SECP521R1_KEY_PAIR_GENERATE_CONTEXT_SIZE
+#define public_key_calculate_context_size \
+    NRF_CRYPTO_BACKEND_SECP521R1_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE
+#elif NRF_CRYPTO_ECC_SECP160K1_ENABLED
+#define key_pair_generate_impl    nrf_crypto_backend_secp160k1_key_pair_generate
+#define public_key_calculate_impl nrf_crypto_backend_secp160k1_public_key_calculate
+#define private_key_from_raw_impl nrf_crypto_backend_secp160k1_private_key_from_raw
+#define private_key_to_raw_impl   nrf_crypto_backend_secp160k1_private_key_to_raw
+#define public_key_from_raw_impl  nrf_crypto_backend_secp160k1_public_key_from_raw
+#define public_key_to_raw_impl    nrf_crypto_backend_secp160k1_public_key_to_raw
+#define private_key_free_impl     nrf_crypto_backend_secp160k1_private_key_free
+#define public_key_free_impl      nrf_crypto_backend_secp160k1_public_key_free
+#define key_pair_generate_context_size \
+    NRF_CRYPTO_BACKEND_SECP160K1_KEY_PAIR_GENERATE_CONTEXT_SIZE
+#define public_key_calculate_context_size \
+    NRF_CRYPTO_BACKEND_SECP160K1_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE
+#elif NRF_CRYPTO_ECC_SECP192K1_ENABLED
+#define key_pair_generate_impl    nrf_crypto_backend_secp192k1_key_pair_generate
+#define public_key_calculate_impl nrf_crypto_backend_secp192k1_public_key_calculate
+#define private_key_from_raw_impl nrf_crypto_backend_secp192k1_private_key_from_raw
+#define private_key_to_raw_impl   nrf_crypto_backend_secp192k1_private_key_to_raw
+#define public_key_from_raw_impl  nrf_crypto_backend_secp192k1_public_key_from_raw
+#define public_key_to_raw_impl    nrf_crypto_backend_secp192k1_public_key_to_raw
+#define private_key_free_impl     nrf_crypto_backend_secp192k1_private_key_free
+#define public_key_free_impl      nrf_crypto_backend_secp192k1_public_key_free
+#define key_pair_generate_context_size \
+    NRF_CRYPTO_BACKEND_SECP192K1_KEY_PAIR_GENERATE_CONTEXT_SIZE
+#define public_key_calculate_context_size \
+    NRF_CRYPTO_BACKEND_SECP192K1_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE
+#elif NRF_CRYPTO_ECC_SECP224K1_ENABLED
+#define key_pair_generate_impl    nrf_crypto_backend_secp224k1_key_pair_generate
+#define public_key_calculate_impl nrf_crypto_backend_secp224k1_public_key_calculate
+#define private_key_from_raw_impl nrf_crypto_backend_secp224k1_private_key_from_raw
+#define private_key_to_raw_impl   nrf_crypto_backend_secp224k1_private_key_to_raw
+#define public_key_from_raw_impl  nrf_crypto_backend_secp224k1_public_key_from_raw
+#define public_key_to_raw_impl    nrf_crypto_backend_secp224k1_public_key_to_raw
+#define private_key_free_impl     nrf_crypto_backend_secp224k1_private_key_free
+#define public_key_free_impl      nrf_crypto_backend_secp224k1_public_key_free
+#define key_pair_generate_context_size \
+    NRF_CRYPTO_BACKEND_SECP224K1_KEY_PAIR_GENERATE_CONTEXT_SIZE
+#define public_key_calculate_context_size \
+    NRF_CRYPTO_BACKEND_SECP224K1_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE
+#elif NRF_CRYPTO_ECC_SECP256K1_ENABLED
+#define key_pair_generate_impl    nrf_crypto_backend_secp256k1_key_pair_generate
+#define public_key_calculate_impl nrf_crypto_backend_secp256k1_public_key_calculate
+#define private_key_from_raw_impl nrf_crypto_backend_secp256k1_private_key_from_raw
+#define private_key_to_raw_impl   nrf_crypto_backend_secp256k1_private_key_to_raw
+#define public_key_from_raw_impl  nrf_crypto_backend_secp256k1_public_key_from_raw
+#define public_key_to_raw_impl    nrf_crypto_backend_secp256k1_public_key_to_raw
+#define private_key_free_impl     nrf_crypto_backend_secp256k1_private_key_free
+#define public_key_free_impl      nrf_crypto_backend_secp256k1_public_key_free
+#define key_pair_generate_context_size \
+    NRF_CRYPTO_BACKEND_SECP256K1_KEY_PAIR_GENERATE_CONTEXT_SIZE
+#define public_key_calculate_context_size \
+    NRF_CRYPTO_BACKEND_SECP256K1_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE
+#elif NRF_CRYPTO_ECC_BP256R1_ENABLED
+#define key_pair_generate_impl    nrf_crypto_backend_bp256r1_key_pair_generate
+#define public_key_calculate_impl nrf_crypto_backend_bp256r1_public_key_calculate
+#define private_key_from_raw_impl nrf_crypto_backend_bp256r1_private_key_from_raw
+#define private_key_to_raw_impl   nrf_crypto_backend_bp256r1_private_key_to_raw
+#define public_key_from_raw_impl  nrf_crypto_backend_bp256r1_public_key_from_raw
+#define public_key_to_raw_impl    nrf_crypto_backend_bp256r1_public_key_to_raw
+#define private_key_free_impl     nrf_crypto_backend_bp256r1_private_key_free
+#define public_key_free_impl      nrf_crypto_backend_bp256r1_public_key_free
+#define key_pair_generate_context_size \
+    NRF_CRYPTO_BACKEND_BP256R1_KEY_PAIR_GENERATE_CONTEXT_SIZE
+#define public_key_calculate_context_size \
+    NRF_CRYPTO_BACKEND_BP256R1_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE
+#elif NRF_CRYPTO_ECC_BP384R1_ENABLED
+#define key_pair_generate_impl    nrf_crypto_backend_bp384r1_key_pair_generate
+#define public_key_calculate_impl nrf_crypto_backend_bp384r1_public_key_calculate
+#define private_key_from_raw_impl nrf_crypto_backend_bp384r1_private_key_from_raw
+#define private_key_to_raw_impl   nrf_crypto_backend_bp384r1_private_key_to_raw
+#define public_key_from_raw_impl  nrf_crypto_backend_bp384r1_public_key_from_raw
+#define public_key_to_raw_impl    nrf_crypto_backend_bp384r1_public_key_to_raw
+#define private_key_free_impl     nrf_crypto_backend_bp384r1_private_key_free
+#define public_key_free_impl      nrf_crypto_backend_bp384r1_public_key_free
+#define key_pair_generate_context_size \
+    NRF_CRYPTO_BACKEND_BP384R1_KEY_PAIR_GENERATE_CONTEXT_SIZE
+#define public_key_calculate_context_size \
+    NRF_CRYPTO_BACKEND_BP384R1_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE
+#elif NRF_CRYPTO_ECC_BP512R1_ENABLED
+#define key_pair_generate_impl    nrf_crypto_backend_bp512r1_key_pair_generate
+#define public_key_calculate_impl nrf_crypto_backend_bp512r1_public_key_calculate
+#define private_key_from_raw_impl nrf_crypto_backend_bp512r1_private_key_from_raw
+#define private_key_to_raw_impl   nrf_crypto_backend_bp512r1_private_key_to_raw
+#define public_key_from_raw_impl  nrf_crypto_backend_bp512r1_public_key_from_raw
+#define public_key_to_raw_impl    nrf_crypto_backend_bp512r1_public_key_to_raw
+#define private_key_free_impl     nrf_crypto_backend_bp512r1_private_key_free
+#define public_key_free_impl      nrf_crypto_backend_bp512r1_public_key_free
+#define key_pair_generate_context_size \
+    NRF_CRYPTO_BACKEND_BP512R1_KEY_PAIR_GENERATE_CONTEXT_SIZE
+#define public_key_calculate_context_size \
+    NRF_CRYPTO_BACKEND_BP512R1_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE
+#elif NRF_CRYPTO_ECC_CURVE25519_ENABLED
+#define key_pair_generate_impl    nrf_crypto_backend_curve25519_key_pair_generate
+#define public_key_calculate_impl nrf_crypto_backend_curve25519_public_key_calculate
+#define private_key_from_raw_impl nrf_crypto_backend_curve25519_private_key_from_raw
+#define private_key_to_raw_impl   nrf_crypto_backend_curve25519_private_key_to_raw
+#define public_key_from_raw_impl  nrf_crypto_backend_curve25519_public_key_from_raw
+#define public_key_to_raw_impl    nrf_crypto_backend_curve25519_public_key_to_raw
+#define private_key_free_impl     nrf_crypto_backend_curve25519_private_key_free
+#define public_key_free_impl      nrf_crypto_backend_curve25519_public_key_free
+#define key_pair_generate_context_size \
+    NRF_CRYPTO_BACKEND_CURVE25519_KEY_PAIR_GENERATE_CONTEXT_SIZE
+#define public_key_calculate_context_size \
+    NRF_CRYPTO_BACKEND_CURVE25519_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE
+#elif NRF_CRYPTO_ECC_ED25519_ENABLED
+#define key_pair_generate_impl    nrf_crypto_backend_ed25519_key_pair_generate
+#define public_key_calculate_impl nrf_crypto_backend_ed25519_public_key_calculate
+#define private_key_from_raw_impl nrf_crypto_backend_ed25519_private_key_from_raw
+#define private_key_to_raw_impl   nrf_crypto_backend_ed25519_private_key_to_raw
+#define public_key_from_raw_impl  nrf_crypto_backend_ed25519_public_key_from_raw
+#define public_key_to_raw_impl    nrf_crypto_backend_ed25519_public_key_to_raw
+#define private_key_free_impl     nrf_crypto_backend_ed25519_private_key_free
+#define public_key_free_impl      nrf_crypto_backend_ed25519_public_key_free
+#define key_pair_generate_context_size \
+    NRF_CRYPTO_BACKEND_ED25519_KEY_PAIR_GENERATE_CONTEXT_SIZE
+#define public_key_calculate_context_size \
+    NRF_CRYPTO_BACKEND_ED25519_PUBLIC_KEY_CALCULATE_CONTEXT_SIZE
+#else
+#define key_pair_generate_impl            NULL
+#define public_key_calculate_impl         NULL
+#define private_key_from_raw_impl         NULL
+#define private_key_to_raw_impl           NULL
+#define public_key_from_raw_impl          NULL
+#define public_key_to_raw_impl            NULL
+#define private_key_free_impl             NULL
+#define public_key_free_impl              NULL
+#define key_pair_generate_context_size    0
+#define public_key_calculate_context_size 0
+#endif
+
+
+#define BACKEND_IMPL_GET(function, curve_type) (function)
+
+
+#endif
+
+
+ret_code_t nrf_crypto_internal_ecc_key_output_prepare(
+    nrf_crypto_ecc_curve_info_t          const * p_curve_info,
+    nrf_crypto_internal_ecc_key_header_t       * p_key_header)
+{
+    // Check NULL pointers
+    VERIFY_TRUE(p_curve_info != NULL, NRF_ERROR_CRYPTO_INPUT_NULL);
+    VERIFY_TRUE(p_key_header != NULL, NRF_ERROR_CRYPTO_OUTPUT_NULL);
+
+    // Clear init value to indicate that this key is not valid yet.
+    p_key_header->init_value = 0;
+    // Save curve info inside the header
+    p_key_header->p_info = p_curve_info;
+
+    return NRF_SUCCESS;
+}
+
+
+ret_code_t nrf_crypto_internal_ecc_key_input_check(
+    nrf_crypto_internal_ecc_key_header_t const * p_key_header,
+    uint32_t                                     init_value)
+{
+    // Check NULL pointer
+    VERIFY_TRUE(p_key_header != NULL, NRF_ERROR_CRYPTO_INPUT_NULL);
+    // Check init value
+    VERIFY_TRUE(p_key_header->init_value == init_value, NRF_ERROR_CRYPTO_ECC_KEY_NOT_INITIALIZED);
+
+    return NRF_SUCCESS;
+}
+
+
+ret_code_t nrf_crypto_internal_ecc_raw_output_prepare(
+    uint8_t    * p_raw_data,
+    size_t     * p_raw_data_size,
+    size_t       expected_size)
+{
+    // Check NULL pointer
+    VERIFY_TRUE(p_raw_data != NULL, NRF_ERROR_CRYPTO_OUTPUT_NULL);
+
+    if (p_raw_data_size != NULL) // User can provide NULL as p_raw_data_size to skip size checking
+    {
+        // Check if data fits into buffer
+        VERIFY_TRUE(*p_raw_data_size >= expected_size, NRF_ERROR_CRYPTO_OUTPUT_LENGTH);
+        // Provide actual data size
+        *p_raw_data_size = expected_size;
+    }
+
+    return NRF_SUCCESS;
+}
+
+
+ret_code_t nrf_crypto_internal_ecc_raw_input_check(
+    uint8_t const * p_raw_data,
+    size_t          raw_data_size,
+    size_t          expected_size)
+{
+    VERIFY_TRUE(p_raw_data != NULL, NRF_ERROR_CRYPTO_INPUT_NULL);
+    VERIFY_TRUE(raw_data_size == expected_size, NRF_ERROR_CRYPTO_INPUT_LENGTH);
+
+    return NRF_SUCCESS;
+}
+
+
+ret_code_t nrf_crypto_ecc_key_pair_generate(
+    nrf_crypto_ecc_key_pair_generate_context_t       * p_context,
+    nrf_crypto_ecc_curve_info_t                const * p_curve_info,
+    nrf_crypto_ecc_private_key_t                     * p_private_key,
+    nrf_crypto_ecc_public_key_t                      * p_public_key)
+{
+    ret_code_t                                     result;
+    void                                         * p_allocated_context = NULL;
+    nrf_crypto_backend_ecc_key_pair_generate_fn_t  backend_implementation;
+    size_t                                         context_size;
+
+    // Get pointer to header for each key
+    nrf_crypto_internal_ecc_key_header_t * p_private_key_header =
+        (nrf_crypto_internal_ecc_key_header_t *)p_private_key;
+    nrf_crypto_internal_ecc_key_header_t * p_public_key_header =
+        (nrf_crypto_internal_ecc_key_header_t *)p_public_key;
+
+    // Check and prepare parameters
+    result = nrf_crypto_internal_ecc_key_output_prepare(p_curve_info, p_private_key_header);
+    VERIFY_SUCCESS(result);
+    result = nrf_crypto_internal_ecc_key_output_prepare(p_curve_info, p_public_key_header);
+    VERIFY_SUCCESS(result);
+
+    // Get backend specific information
+    backend_implementation = BACKEND_IMPL_GET(key_pair_generate_impl, p_curve_info->curve_type);
+    context_size = BACKEND_IMPL_GET(key_pair_generate_context_size, p_curve_info->curve_type);
+    VERIFY_TRUE(backend_implementation != NULL, NRF_ERROR_CRYPTO_FEATURE_UNAVAILABLE);
+
+    // Allocate context if not provided
+    if (p_context == NULL && context_size > 0)
+    {
+        p_allocated_context = NRF_CRYPTO_ALLOC(context_size);
+        VERIFY_TRUE(p_allocated_context != NULL, NRF_ERROR_CRYPTO_ALLOC_FAILED);
+        p_context = p_allocated_context;
+    }
+
+    // Execute backend implementation
+    result = backend_implementation(p_context, p_private_key, p_public_key);
+
+    // Set init values to indicate valid key
+    if (result == NRF_SUCCESS)
+    {
+        p_private_key_header->init_value = NRF_CRYPTO_INTERNAL_ECC_PRIVATE_KEY_INIT_VALUE;
+        p_public_key_header->init_value = NRF_CRYPTO_INTERNAL_ECC_PUBLIC_KEY_INIT_VALUE;
+    }
+
+    // Deallocate context if allocated
+    if (p_allocated_context != NULL)
+    {
+        NRF_CRYPTO_FREE(p_allocated_context);
+    }
+
+    return result;
+}
+
+
+ret_code_t nrf_crypto_ecc_public_key_calculate(
+    nrf_crypto_ecc_public_key_calculate_context_t       * p_context,
+    nrf_crypto_ecc_private_key_t                  const * p_private_key,
+    nrf_crypto_ecc_public_key_t                         * p_public_key)
+{
+    ret_code_t                                        result;
+    void                                            * p_allocated_context = NULL;
+    nrf_crypto_backend_ecc_public_key_calculate_fn_t  backend_implementation;
+    size_t                                            context_size;
+    nrf_crypto_ecc_curve_info_t               const * p_info;
+
+    // Get pointer to header for each key
+    nrf_crypto_internal_ecc_key_header_t const * p_private_key_header =
+        (nrf_crypto_internal_ecc_key_header_t const *)p_private_key;
+    nrf_crypto_internal_ecc_key_header_t       * p_public_key_header =
+        (nrf_crypto_internal_ecc_key_header_t *)p_public_key;
+
+    // Check and prepare parameters
+    result = nrf_crypto_internal_ecc_key_input_check(
+        p_private_key_header,
+        NRF_CRYPTO_INTERNAL_ECC_PRIVATE_KEY_INIT_VALUE);
+    VERIFY_SUCCESS(result);
+    p_info = p_private_key_header->p_info;
+    result  = nrf_crypto_internal_ecc_key_output_prepare(p_info, p_public_key_header);
+    VERIFY_SUCCESS(result);
+
+    // Get backend specific information
+    backend_implementation = BACKEND_IMPL_GET(public_key_calculate_impl, p_info->curve_type);
+    context_size = BACKEND_IMPL_GET(public_key_calculate_context_size, p_info->curve_type);
+    VERIFY_TRUE(backend_implementation != NULL, NRF_ERROR_CRYPTO_FEATURE_UNAVAILABLE);
+
+    // Allocate context if not provided
+    if (p_context == NULL && context_size > 0)
+    {
+        p_allocated_context = NRF_CRYPTO_ALLOC(context_size);
+        VERIFY_TRUE(p_allocated_context != NULL, NRF_ERROR_CRYPTO_ALLOC_FAILED);
+        p_context = p_allocated_context;
+    }
+
+    // Execute backend implementation
+    result = backend_implementation(p_context, p_private_key, p_public_key);
+
+    // Set init values to indicate valid key
+    if (result == NRF_SUCCESS)
+    {
+        p_public_key_header->init_value = NRF_CRYPTO_INTERNAL_ECC_PUBLIC_KEY_INIT_VALUE;
+    }
+
+    // Deallocate context if allocated
+    if (p_allocated_context != NULL)
+    {
+        NRF_CRYPTO_FREE(p_allocated_context);
+    }
+
+    return result;
+}
+
+
+ret_code_t nrf_crypto_ecc_private_key_from_raw(
+    nrf_crypto_ecc_curve_info_t  const * p_curve_info,
+    nrf_crypto_ecc_private_key_t       * p_private_key,
+    uint8_t                      const * p_raw_data,
+    size_t                               raw_data_size)
+{
+    ret_code_t                                       result;
+    nrf_crypto_backend_ecc_private_key_from_raw_fn_t backend_implementation;
+
+    // Get pointer to header
+    nrf_crypto_internal_ecc_key_header_t * p_private_key_header =
+        (nrf_crypto_internal_ecc_key_header_t *)p_private_key;
+
+    // Check and prepare parameters
+    result = nrf_crypto_internal_ecc_key_output_prepare(p_curve_info,
+                                                        p_private_key_header);
+    VERIFY_SUCCESS(result);
+    result = nrf_crypto_internal_ecc_raw_input_check(p_raw_data,
+                                                     raw_data_size,
+                                                     p_curve_info->raw_private_key_size);
+    VERIFY_SUCCESS(result);
+
+    // Get backend specific information
+    backend_implementation = BACKEND_IMPL_GET(private_key_from_raw_impl, p_curve_info->curve_type);
+    VERIFY_TRUE(backend_implementation != NULL, NRF_ERROR_CRYPTO_FEATURE_UNAVAILABLE);
+
+    // Execute backend implementation
+    result = backend_implementation(p_private_key, p_raw_data);
+
+    // Set init value to indicate valid key
+    if (result == NRF_SUCCESS)
+    {
+        p_private_key_header->init_value = NRF_CRYPTO_INTERNAL_ECC_PRIVATE_KEY_INIT_VALUE;
+    }
+
+    return result;
+}
+
+
+ret_code_t nrf_crypto_ecc_private_key_to_raw(
+    nrf_crypto_ecc_private_key_t const * p_private_key,
+    uint8_t                            * p_raw_data,
+    size_t                             * p_raw_data_size)
+{
+    ret_code_t                                             result;
+    nrf_crypto_ecc_curve_info_t                    const * p_info;
+    nrf_crypto_backend_ecc_private_key_to_raw_fn_t         backend_implementation;
+
+    // Get pointer to header
+    nrf_crypto_internal_ecc_key_header_t const * p_private_key_header =
+        (nrf_crypto_internal_ecc_key_header_t const *)p_private_key;
+
+    // Check and prepare parameters
+    result = nrf_crypto_internal_ecc_key_input_check(
+        p_private_key_header,
+        NRF_CRYPTO_INTERNAL_ECC_PRIVATE_KEY_INIT_VALUE);
+    VERIFY_SUCCESS(result);
+    p_info = p_private_key_header->p_info;
+    result = nrf_crypto_internal_ecc_raw_output_prepare(p_raw_data,
+                                                        p_raw_data_size,
+                                                        p_info->raw_private_key_size);
+    VERIFY_SUCCESS(result);
+
+    // Get backend specific information
+    backend_implementation = BACKEND_IMPL_GET(private_key_to_raw_impl, p_info->curve_type);
+    VERIFY_TRUE(backend_implementation != NULL, NRF_ERROR_CRYPTO_FEATURE_UNAVAILABLE);
+
+    // Execute backend implementation
+    result = backend_implementation(p_private_key, p_raw_data);
+
+    return result;
+}
+
+
+ret_code_t nrf_crypto_ecc_public_key_from_raw(
+    nrf_crypto_ecc_curve_info_t const * p_curve_info,
+    nrf_crypto_ecc_public_key_t       * p_public_key,
+    uint8_t                     const * p_raw_data,
+    size_t                              raw_data_size)
+{
+    ret_code_t                                       result;
+    nrf_crypto_backend_ecc_private_key_from_raw_fn_t backend_implementation;
+
+    // Get pointer to header
+    nrf_crypto_internal_ecc_key_header_t * p_public_key_header =
+        (nrf_crypto_internal_ecc_key_header_t *)p_public_key;
+
+    // Check and prepare parameters
+    result = nrf_crypto_internal_ecc_key_output_prepare(p_curve_info,
+                                                        p_public_key_header);
+    VERIFY_SUCCESS(result);
+    result = nrf_crypto_internal_ecc_raw_input_check(p_raw_data,
+                                                     raw_data_size,
+                                                     p_curve_info->raw_public_key_size);
+    VERIFY_SUCCESS(result);
+
+    // Get backend specific information
+    backend_implementation = BACKEND_IMPL_GET(public_key_from_raw_impl, p_curve_info->curve_type);
+    VERIFY_TRUE(backend_implementation != NULL, NRF_ERROR_CRYPTO_FEATURE_UNAVAILABLE);
+
+    // Execute backend implementation
+    result = backend_implementation(p_public_key, p_raw_data);
+
+    // Set init value to indicate valid key
+    if (result == NRF_SUCCESS)
+    {
+        p_public_key_header->init_value = NRF_CRYPTO_INTERNAL_ECC_PUBLIC_KEY_INIT_VALUE;
+    }
+
+    return result;
+}
+
+
+ret_code_t nrf_crypto_ecc_public_key_to_raw(
+    nrf_crypto_ecc_public_key_t const * p_public_key,
+    uint8_t                           * p_raw_data,
+    size_t                            * p_raw_data_size)
+{
+    ret_code_t                                            result;
+    nrf_crypto_ecc_curve_info_t                   const * p_info;
+    nrf_crypto_backend_ecc_public_key_to_raw_fn_t         backend_implementation;
+
+    // Get pointer to header
+    nrf_crypto_internal_ecc_key_header_t const * p_public_key_header =
+        (nrf_crypto_internal_ecc_key_header_t const *)p_public_key;
+
+    // Check and prepare parameters
+    result = nrf_crypto_internal_ecc_key_input_check(
+        p_public_key_header,
+        NRF_CRYPTO_INTERNAL_ECC_PUBLIC_KEY_INIT_VALUE);
+    VERIFY_SUCCESS(result);
+    p_info = p_public_key_header->p_info;
+    result = nrf_crypto_internal_ecc_raw_output_prepare(p_raw_data,
+                                                        p_raw_data_size,
+                                                        p_info->raw_public_key_size);
+    VERIFY_SUCCESS(result);
+
+    // Get backend specific information
+    backend_implementation = BACKEND_IMPL_GET(public_key_to_raw_impl, p_info->curve_type);
+    VERIFY_TRUE(backend_implementation != NULL, NRF_ERROR_CRYPTO_FEATURE_UNAVAILABLE);
+
+    // Execute backend implementation
+    result = backend_implementation(p_public_key, p_raw_data);
+
+    return result;
+}
+
+
+ret_code_t nrf_crypto_ecc_private_key_free(
+    nrf_crypto_ecc_private_key_t * p_private_key)
+{
+    ret_code_t                                   result;
+    nrf_crypto_ecc_curve_info_t          const * p_info;
+    nrf_crypto_backend_ecc_key_free_fn_t         backend_implementation;
+
+    // Get pointer to header
+    nrf_crypto_internal_ecc_key_header_t * p_private_key_header =
+        (nrf_crypto_internal_ecc_key_header_t *)p_private_key;
+
+    // Check and prepare parameters
+    result = nrf_crypto_internal_ecc_key_input_check(
+        p_private_key_header,
+        NRF_CRYPTO_INTERNAL_ECC_PRIVATE_KEY_INIT_VALUE);
+    VERIFY_SUCCESS(result);
+    p_info = p_private_key_header->p_info;
+
+    UNUSED_PARAMETER(p_info); // Is some situations BACKEND_IMPL_GET() macro may not use second parameter
+
+    // Get backend specific information
+    backend_implementation = BACKEND_IMPL_GET(private_key_free_impl, p_info->curve_type);
+
+    if (backend_implementation != NULL)
+    {
+        // Execute backend implementation
+        result = backend_implementation(p_private_key);
+    }
+    else
+    {
+        // Free is not implemented by the backend, so nothing have to deallocated.
+        result = NRF_SUCCESS;
+    }
+
+    // Clear init value to indicate invalid key
+    p_private_key_header->init_value = 0;
+
+    return result;
+}
+
+
+ret_code_t nrf_crypto_ecc_public_key_free(
+    nrf_crypto_ecc_public_key_t * p_public_key)
+{
+    ret_code_t                                   result;
+    nrf_crypto_ecc_curve_info_t          const * p_info;
+    nrf_crypto_backend_ecc_key_free_fn_t         backend_implementation;
+
+    // Get pointer to header
+    nrf_crypto_internal_ecc_key_header_t * p_public_key_header =
+        (nrf_crypto_internal_ecc_key_header_t *)p_public_key;
+
+    // Check and prepare parameters
+    result = nrf_crypto_internal_ecc_key_input_check(
+        p_public_key_header,
+        NRF_CRYPTO_INTERNAL_ECC_PUBLIC_KEY_INIT_VALUE);
+    VERIFY_SUCCESS(result);
+    p_info = p_public_key_header->p_info;
+
+    UNUSED_PARAMETER(p_info); // Is some situations BACKEND_IMPL_GET() macro may not use second parameter
+
+    // Get backend specific information
+    backend_implementation = BACKEND_IMPL_GET(public_key_free_impl, p_info->curve_type);
+
+    if (backend_implementation != NULL)
+    {
+        // Execute backend implementation
+        result = backend_implementation(p_public_key);
+    }
+    else
+    {
+        // Free is not implemented by the backend, so nothing have to deallocated.
+        result = NRF_SUCCESS;
+    }
+
+    // Clear init value to indicate invalid key
+    p_public_key_header->init_value = 0;
+
+    return result;
+}
+
+
+ret_code_t nrf_crypto_ecc_curve_info_get(
+    void                         const * p_key,
+    nrf_crypto_ecc_curve_info_t const ** pp_curve_info)
+{
+    ret_code_t result;
+
+    // Get pointer to header
+    nrf_crypto_internal_ecc_key_header_t const * p_key_header =
+        (nrf_crypto_internal_ecc_key_header_t const *)p_key;
+
+    // Check and prepare parameters
+    VERIFY_TRUE(pp_curve_info != NULL, NRF_ERROR_CRYPTO_INPUT_NULL);
+    result = nrf_crypto_internal_ecc_key_input_check(
+        p_key_header,
+        NRF_CRYPTO_INTERNAL_ECC_PRIVATE_KEY_INIT_VALUE);
+    if (result != NRF_SUCCESS)
+    {
+        // p_key can be private or public key, so check second case here
+        result = nrf_crypto_internal_ecc_key_input_check(
+            p_key_header,
+            NRF_CRYPTO_INTERNAL_ECC_PUBLIC_KEY_INIT_VALUE);
+    }
+    VERIFY_SUCCESS(result);
+
+    // Write output parameter
+    *pp_curve_info = p_key_header->p_info;
+
+    return NRF_SUCCESS;
+}
+
+
+ret_code_t nrf_crypto_ecc_byte_order_invert(
+    nrf_crypto_ecc_curve_info_t const * p_curve_info,
+    uint8_t                     const * p_raw_input,
+    uint8_t                           * p_raw_output,
+    size_t                              raw_data_size)
+{
+    uint8_t temp;
+    size_t  from_index;
+    size_t  to_index;
+    size_t  integer_size;
+
+    if (p_curve_info == NULL)
+    {
+        integer_size = raw_data_size;
+    }
+    else
+    {
+        integer_size = p_curve_info->raw_private_key_size;
+    }
+
+    VERIFY_TRUE(p_raw_input != NULL, NRF_ERROR_CRYPTO_INPUT_NULL);
+    VERIFY_TRUE(p_raw_output != NULL, NRF_ERROR_CRYPTO_OUTPUT_NULL);
+
+    // Loop over each big integer of the input
+    while (raw_data_size >= integer_size)
+    {
+        // Swap byte by byte in current integer
+        from_index = 0;
+        to_index = integer_size - 1;
+        while (from_index <= to_index)
+        {
+            // Swap bytes from source to destination, this may be the same buffer, so use temporary variable
+            temp = p_raw_input[from_index];
+            p_raw_output[from_index] = p_raw_input[to_index];
+            p_raw_output[to_index] = temp;
+            // Go to next pair of bytes
+            from_index++;
+            to_index--;
+        }
+        // Go to next integer
+        raw_data_size -= integer_size;
+        p_raw_input += integer_size;
+        p_raw_output += integer_size;
+    }
+
+    if (raw_data_size != 0)
+    {
+        // Input size is not a multiple of big integer size, so it is invalid
+        return NRF_ERROR_CRYPTO_INPUT_LENGTH;
+    }
+
+    return NRF_SUCCESS;
+}
+
+
+#endif // NRF_CRYPTO_ECC_ENABLED
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_ecc.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_ecc.h
new file mode 100644
index 0000000..8fa825b
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_ecc.h
@@ -0,0 +1,999 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef NRF_CRYPTO_ECC_H__
+#define NRF_CRYPTO_ECC_H__
+
+/** @addtogroup nrf_crypto
+ *  @{
+ *  @addtogroup nrf_crypto_ecc Elliptic Curve Cryptography Key Management
+ *  @{
+ *  @brief Provides elliptic curve cryptography API for public and private key management.
+ *
+ *  @addtogroup nrf_crypto_ecc_secp160r1   Definitions specific to secp160r1 (NIST 160-bit)
+ *  @addtogroup nrf_crypto_ecc_secp160r2   Definitions specific to secp160r2 (NIST 160-bit)
+ *  @addtogroup nrf_crypto_ecc_secp192r1   Definitions specific to secp192r1 (NIST 192-bit)
+ *  @addtogroup nrf_crypto_ecc_secp224r1   Definitions specific to secp224r1 (NIST 224-bit)
+ *  @addtogroup nrf_crypto_ecc_secp256r1   Definitions specific to secp256r1 (NIST 256-bit)
+ *  @addtogroup nrf_crypto_ecc_secp384r1   Definitions specific to secp384r1 (NIST 384-bit)
+ *  @addtogroup nrf_crypto_ecc_secp521r1   Definitions specific to secp521r1 (NIST 521-bit)
+ *  @addtogroup nrf_crypto_ecc_secp160k1   Definitions specific to secp160k1 (Koblitz 160-bit)
+ *  @addtogroup nrf_crypto_ecc_secp192k1   Definitions specific to secp192k1 (Koblitz 192-bit)
+ *  @addtogroup nrf_crypto_ecc_secp224k1   Definitions specific to secp224k1 (Koblitz 224-bit)
+ *  @addtogroup nrf_crypto_ecc_secp256k1   Definitions specific to secp256k1 (Koblitz 256-bit)
+ *  @addtogroup nrf_crypto_ecc_bp256r1     Definitions specific to bp256r1 (Brainpool 256-bit)
+ *  @addtogroup nrf_crypto_ecc_bp384r1     Definitions specific to bp384r1 (Brainpool 384-bit)
+ *  @addtogroup nrf_crypto_ecc_bp512r1     Definitions specific to bp512r1 (Brainpool 512-bit)
+ *  @addtogroup nrf_crypto_ecc_curve25519  Definitions specific to Curve25519
+ *  @addtogroup nrf_crypto_ecc_ed25519     Definitions specific to Ed25519
+ */
+
+#include <stdint.h>
+#include <stddef.h>
+
+#include "nrf_crypto_error.h"
+#include "nrf_crypto_ecc_shared.h"
+#include "nrf_crypto_ecc_backend.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#if defined(__SDK_DOXYGEN__)
+#define NRF_CRYPTO_ECC_SECP160R1_ENABLED  1  /**< @brief Defined as 1 if secp160r1 (NIST 160-bit) is enabled in any of the backends and it is usable in the API, 0 otherwise.    @ingroup nrf_crypto_ecc_secp160r1 */
+#define NRF_CRYPTO_ECC_SECP160R2_ENABLED  1  /**< @brief Defined as 1 if secp160r2 (NIST 160-bit) is enabled in any of the backends and it is usable in the API, 0 otherwise.    @ingroup nrf_crypto_ecc_secp160r2 */
+#define NRF_CRYPTO_ECC_SECP192R1_ENABLED  1  /**< @brief Defined as 1 if secp192r1 (NIST 192-bit) is enabled in any of the backends and it is usable in the API, 0 otherwise.    @ingroup nrf_crypto_ecc_secp192r1 */
+#define NRF_CRYPTO_ECC_SECP224R1_ENABLED  1  /**< @brief Defined as 1 if secp224r1 (NIST 224-bit) is enabled in any of the backends and it is usable in the API, 0 otherwise.    @ingroup nrf_crypto_ecc_secp224r1 */
+#define NRF_CRYPTO_ECC_SECP256R1_ENABLED  1  /**< @brief Defined as 1 if secp256r1 (NIST 256-bit) is enabled in any of the backends and it is usable in the API, 0 otherwise.    @ingroup nrf_crypto_ecc_secp256r1 */
+#define NRF_CRYPTO_ECC_SECP384R1_ENABLED  1  /**< @brief Defined as 1 if secp384r1 (NIST 384-bit) is enabled in any of the backends and it is usable in the API, 0 otherwise.    @ingroup nrf_crypto_ecc_secp384r1 */
+#define NRF_CRYPTO_ECC_SECP521R1_ENABLED  1  /**< @brief Defined as 1 if secp521r1 (NIST 521-bit) is enabled in any of the backends and it is usable in the API, 0 otherwise.    @ingroup nrf_crypto_ecc_secp521r1 */
+#define NRF_CRYPTO_ECC_SECP160K1_ENABLED  1  /**< @brief Defined as 1 if secp160k1 (Koblitz 160-bit) is enabled in any of the backends and it is usable in the API, 0 otherwise. @ingroup nrf_crypto_ecc_secp160k1 */
+#define NRF_CRYPTO_ECC_SECP192K1_ENABLED  1  /**< @brief Defined as 1 if secp192k1 (Koblitz 192-bit) is enabled in any of the backends and it is usable in the API, 0 otherwise. @ingroup nrf_crypto_ecc_secp192k1 */
+#define NRF_CRYPTO_ECC_SECP224K1_ENABLED  1  /**< @brief Defined as 1 if secp224k1 (Koblitz 224-bit) is enabled in any of the backends and it is usable in the API, 0 otherwise. @ingroup nrf_crypto_ecc_secp224k1 */
+#define NRF_CRYPTO_ECC_SECP256K1_ENABLED  1  /**< @brief Defined as 1 if secp256k1 (Koblitz 256-bit) is enabled in any of the backends and it is usable in the API, 0 otherwise. @ingroup nrf_crypto_ecc_secp256k1 */
+#define NRF_CRYPTO_ECC_BP256R1_ENABLED    1  /**< @brief Defined as 1 if bp256r1 (Brainpool 256-bit) is enabled in any of the backends and it is usable in the API, 0 otherwise. @ingroup nrf_crypto_ecc_bp256r1 */
+#define NRF_CRYPTO_ECC_BP384R1_ENABLED    1  /**< @brief Defined as 1 if bp384r1 (Brainpool 384-bit) is enabled in any of the backends and it is usable in the API, 0 otherwise. @ingroup nrf_crypto_ecc_bp384r1 */
+#define NRF_CRYPTO_ECC_BP512R1_ENABLED    1  /**< @brief Defined as 1 if bp512r1 (Brainpool 512-bit) is enabled in any of the backends and it is usable in the API, 0 otherwise. @ingroup nrf_crypto_ecc_bp512r1 */
+#define NRF_CRYPTO_ECC_CURVE25519_ENABLED 1  /**< @brief Defined as 1 if Curve25519 is enabled in any of the backends and it is usable in the API, 0 otherwise.                  @ingroup nrf_crypto_ecc_curve25519 */
+#define NRF_CRYPTO_ECC_ED25519_ENABLED    1  /**< @brief Defined as 1 if Ed25519 is enabled in any of the backends and it is usable in the API, 0 otherwise.                     @ingroup nrf_crypto_ecc_ed25519 */
+#endif
+
+
+#define NRF_CRYPTO_ECC_SECP160R1_RAW_PRIVATE_KEY_SIZE  (160 / 8)      /**< @brief Raw private key size for secp160r1 (NIST 160-bit).         @ingroup nrf_crypto_ecc_secp160r1 */
+#define NRF_CRYPTO_ECC_SECP160R2_RAW_PRIVATE_KEY_SIZE  (160 / 8)      /**< @brief Raw private key size for secp160r2 (NIST 160-bit).         @ingroup nrf_crypto_ecc_secp160r2 */
+#define NRF_CRYPTO_ECC_SECP192R1_RAW_PRIVATE_KEY_SIZE  (192 / 8)      /**< @brief Raw private key size for secp192r1 (NIST 192-bit).         @ingroup nrf_crypto_ecc_secp192r1 */
+#define NRF_CRYPTO_ECC_SECP224R1_RAW_PRIVATE_KEY_SIZE  (224 / 8)      /**< @brief Raw private key size for secp224r1 (NIST 224-bit).         @ingroup nrf_crypto_ecc_secp224r1 */
+#define NRF_CRYPTO_ECC_SECP256R1_RAW_PRIVATE_KEY_SIZE  (256 / 8)      /**< @brief Raw private key size for secp256r1 (NIST 256-bit).         @ingroup nrf_crypto_ecc_secp256r1 */
+#define NRF_CRYPTO_ECC_SECP384R1_RAW_PRIVATE_KEY_SIZE  (384 / 8)      /**< @brief Raw private key size for secp384r1 (NIST 384-bit).         @ingroup nrf_crypto_ecc_secp384r1 */
+#define NRF_CRYPTO_ECC_SECP521R1_RAW_PRIVATE_KEY_SIZE  (528 / 8)      /**< @brief Raw private key size for secp521r1 (NIST 521-bit).         @ingroup nrf_crypto_ecc_secp521r1 */
+#define NRF_CRYPTO_ECC_SECP160K1_RAW_PRIVATE_KEY_SIZE  (160 / 8)      /**< @brief Raw private key size for secp160k1 (Koblitz 160-bit).      @ingroup nrf_crypto_ecc_secp160k1 */
+#define NRF_CRYPTO_ECC_SECP192K1_RAW_PRIVATE_KEY_SIZE  (192 / 8)      /**< @brief Raw private key size for secp192k1 (Koblitz 192-bit).      @ingroup nrf_crypto_ecc_secp192k1 */
+#define NRF_CRYPTO_ECC_SECP224K1_RAW_PRIVATE_KEY_SIZE  (224 / 8)      /**< @brief Raw private key size for secp224k1 (Koblitz 224-bit).      @ingroup nrf_crypto_ecc_secp224k1 */
+#define NRF_CRYPTO_ECC_SECP256K1_RAW_PRIVATE_KEY_SIZE  (256 / 8)      /**< @brief Raw private key size for secp256k1 (Koblitz 256-bit).      @ingroup nrf_crypto_ecc_secp256k1 */
+#define NRF_CRYPTO_ECC_BP256R1_RAW_PRIVATE_KEY_SIZE    (256 / 8)      /**< @brief Raw private key size for bp256r1 (Brainpool 256-bit).      @ingroup nrf_crypto_ecc_bp256r1 */
+#define NRF_CRYPTO_ECC_BP384R1_RAW_PRIVATE_KEY_SIZE    (384 / 8)      /**< @brief Raw private key size for bp384r1 (Brainpool 384-bit).      @ingroup nrf_crypto_ecc_bp384r1 */
+#define NRF_CRYPTO_ECC_BP512R1_RAW_PRIVATE_KEY_SIZE    (512 / 8)      /**< @brief Raw private key size for bp512r1 (Brainpool 512-bit).      @ingroup nrf_crypto_ecc_bp512r1 */
+#define NRF_CRYPTO_ECC_CURVE25519_RAW_PRIVATE_KEY_SIZE (256 / 8)      /**< @brief Raw private key size for Curve25519.                       @ingroup nrf_crypto_ecc_curve25519 */
+#define NRF_CRYPTO_ECC_ED25519_RAW_PRIVATE_KEY_SIZE    (256 / 8)      /**< @brief Raw private key size for Ed25519.                          @ingroup nrf_crypto_ecc_ed25519 */
+
+
+#define NRF_CRYPTO_ECC_SECP160R1_RAW_PUBLIC_KEY_SIZE   (2 * 160 / 8)  /**< @brief Raw public key size for curve secp160r1 (NIST 160-bit).    @ingroup nrf_crypto_ecc_secp160r1 */
+#define NRF_CRYPTO_ECC_SECP160R2_RAW_PUBLIC_KEY_SIZE   (2 * 160 / 8)  /**< @brief Raw public key size for curve secp160r2 (NIST 160-bit).    @ingroup nrf_crypto_ecc_secp160r2 */
+#define NRF_CRYPTO_ECC_SECP192R1_RAW_PUBLIC_KEY_SIZE   (2 * 192 / 8)  /**< @brief Raw public key size for curve secp192r1 (NIST 192-bit).    @ingroup nrf_crypto_ecc_secp192r1 */
+#define NRF_CRYPTO_ECC_SECP224R1_RAW_PUBLIC_KEY_SIZE   (2 * 224 / 8)  /**< @brief Raw public key size for curve secp224r1 (NIST 224-bit).    @ingroup nrf_crypto_ecc_secp224r1 */
+#define NRF_CRYPTO_ECC_SECP256R1_RAW_PUBLIC_KEY_SIZE   (2 * 256 / 8)  /**< @brief Raw public key size for curve secp256r1 (NIST 256-bit).    @ingroup nrf_crypto_ecc_secp256r1 */
+#define NRF_CRYPTO_ECC_SECP384R1_RAW_PUBLIC_KEY_SIZE   (2 * 384 / 8)  /**< @brief Raw public key size for curve secp384r1 (NIST 384-bit).    @ingroup nrf_crypto_ecc_secp384r1 */
+#define NRF_CRYPTO_ECC_SECP521R1_RAW_PUBLIC_KEY_SIZE   (2 * 528 / 8)  /**< @brief Raw public key size for curve secp521r1 (NIST 521-bit).    @ingroup nrf_crypto_ecc_secp521r1 */
+#define NRF_CRYPTO_ECC_SECP160K1_RAW_PUBLIC_KEY_SIZE   (2 * 160 / 8)  /**< @brief Raw public key size for curve secp160k1 (Koblitz 160-bit). @ingroup nrf_crypto_ecc_secp160k1 */
+#define NRF_CRYPTO_ECC_SECP192K1_RAW_PUBLIC_KEY_SIZE   (2 * 192 / 8)  /**< @brief Raw public key size for curve secp192k1 (Koblitz 192-bit). @ingroup nrf_crypto_ecc_secp192k1 */
+#define NRF_CRYPTO_ECC_SECP224K1_RAW_PUBLIC_KEY_SIZE   (2 * 224 / 8)  /**< @brief Raw public key size for curve secp224k1 (Koblitz 224-bit). @ingroup nrf_crypto_ecc_secp224k1 */
+#define NRF_CRYPTO_ECC_SECP256K1_RAW_PUBLIC_KEY_SIZE   (2 * 256 / 8)  /**< @brief Raw public key size for curve secp256k1 (Koblitz 256-bit). @ingroup nrf_crypto_ecc_secp256k1 */
+#define NRF_CRYPTO_ECC_BP256R1_RAW_PUBLIC_KEY_SIZE     (2 * 256 / 8)  /**< @brief Raw public key size for curve bp256r1 (Brainpool 256-bit). @ingroup nrf_crypto_ecc_bp256r1 */
+#define NRF_CRYPTO_ECC_BP384R1_RAW_PUBLIC_KEY_SIZE     (2 * 384 / 8)  /**< @brief Raw public key size for curve bp384r1 (Brainpool 384-bit). @ingroup nrf_crypto_ecc_bp384r1 */
+#define NRF_CRYPTO_ECC_BP512R1_RAW_PUBLIC_KEY_SIZE     (2 * 512 / 8)  /**< @brief Raw public key size for curve bp512r1 (Brainpool 512-bit). @ingroup nrf_crypto_ecc_bp512r1 */
+#define NRF_CRYPTO_ECC_CURVE25519_RAW_PUBLIC_KEY_SIZE  (256 / 8)      /**< @brief Raw public key size for curve Curve25519.                  @ingroup nrf_crypto_ecc_curve25519 */
+#define NRF_CRYPTO_ECC_ED25519_RAW_PUBLIC_KEY_SIZE     (256 / 8)      /**< @brief Raw public key size for curve Ed25519.                     @ingroup nrf_crypto_ecc_ed25519 */
+
+
+#define NRF_CRYPTO_ECC_RAW_PRIVATE_KEY_MAX_SIZE NRF_CRYPTO_BACKEND_ECC_RAW_PRIVATE_KEY_MAX_SIZE  /**< @brief Maximum size of a raw private key for all enabled curves. */
+#define NRF_CRYPTO_ECC_RAW_PUBLIC_KEY_MAX_SIZE  NRF_CRYPTO_BACKEND_ECC_RAW_PUBLIC_KEY_MAX_SIZE   /**< @brief Maximum size of a raw public key for all enabled curves. */
+
+
+/** @brief Defines type of ECC curve.
+ */
+typedef enum
+{
+#if NRF_CRYPTO_ECC_SECP160R1_ENABLED
+    NRF_CRYPTO_ECC_SECP160R1_CURVE_TYPE,   /**< secp160r1 (NIST 160-bit) */
+#endif
+#if NRF_CRYPTO_ECC_SECP160R2_ENABLED
+    NRF_CRYPTO_ECC_SECP160R2_CURVE_TYPE,   /**< secp160r2 (NIST 160-bit) */
+#endif
+#if NRF_CRYPTO_ECC_SECP192R1_ENABLED
+    NRF_CRYPTO_ECC_SECP192R1_CURVE_TYPE,   /**< secp192r1 (NIST 192-bit) */
+#endif
+#if NRF_CRYPTO_ECC_SECP224R1_ENABLED
+    NRF_CRYPTO_ECC_SECP224R1_CURVE_TYPE,   /**< secp224r1 (NIST 224-bit) */
+#endif
+#if NRF_CRYPTO_ECC_SECP256R1_ENABLED
+    NRF_CRYPTO_ECC_SECP256R1_CURVE_TYPE,   /**< secp256r1 (NIST 256-bit) */
+#endif
+#if NRF_CRYPTO_ECC_SECP384R1_ENABLED
+    NRF_CRYPTO_ECC_SECP384R1_CURVE_TYPE,   /**< secp384r1 (NIST 384-bit) */
+#endif
+#if NRF_CRYPTO_ECC_SECP521R1_ENABLED
+    NRF_CRYPTO_ECC_SECP521R1_CURVE_TYPE,   /**< secp521r1 (NIST 521-bit) */
+#endif
+#if NRF_CRYPTO_ECC_SECP160K1_ENABLED
+    NRF_CRYPTO_ECC_SECP160K1_CURVE_TYPE,   /**< secp160k1 (Koblitz 160-bit) */
+#endif
+#if NRF_CRYPTO_ECC_SECP192K1_ENABLED
+    NRF_CRYPTO_ECC_SECP192K1_CURVE_TYPE,   /**< secp192k1 (Koblitz 192-bit) */
+#endif
+#if NRF_CRYPTO_ECC_SECP224K1_ENABLED
+    NRF_CRYPTO_ECC_SECP224K1_CURVE_TYPE,   /**< secp224k1 (Koblitz 224-bit) */
+#endif
+#if NRF_CRYPTO_ECC_SECP256K1_ENABLED
+    NRF_CRYPTO_ECC_SECP256K1_CURVE_TYPE,   /**< secp256k1 (Koblitz 256-bit) */
+#endif
+#if NRF_CRYPTO_ECC_BP256R1_ENABLED
+    NRF_CRYPTO_ECC_BP256R1_CURVE_TYPE,     /**< bp256r1 (Brainpool 256-bit) */
+#endif
+#if NRF_CRYPTO_ECC_BP384R1_ENABLED
+    NRF_CRYPTO_ECC_BP384R1_CURVE_TYPE,     /**< bp384r1 (Brainpool 384-bit) */
+#endif
+#if NRF_CRYPTO_ECC_BP512R1_ENABLED
+    NRF_CRYPTO_ECC_BP512R1_CURVE_TYPE,     /**< bp512r1 (Brainpool 512-bit) */
+#endif
+#if NRF_CRYPTO_ECC_CURVE25519_ENABLED
+    NRF_CRYPTO_ECC_CURVE25519_CURVE_TYPE,  /**< Curve25519 */
+#endif
+#if NRF_CRYPTO_ECC_ED25519_ENABLED
+    NRF_CRYPTO_ECC_ED25519_CURVE_TYPE,     /**< Ed25519 */
+#endif
+#if !NRF_CRYPTO_ECC_SECP160R1_ENABLED
+    NRF_CRYPTO_ECC_SECP160R1_CURVE_TYPE,   /**< secp160r1 (NIST 160-bit) */
+#endif
+#if !NRF_CRYPTO_ECC_SECP160R2_ENABLED
+    NRF_CRYPTO_ECC_SECP160R2_CURVE_TYPE,   /**< secp160r2 (NIST 160-bit) */
+#endif
+#if !NRF_CRYPTO_ECC_SECP192R1_ENABLED
+    NRF_CRYPTO_ECC_SECP192R1_CURVE_TYPE,   /**< secp192r1 (NIST 192-bit) */
+#endif
+#if !NRF_CRYPTO_ECC_SECP224R1_ENABLED
+    NRF_CRYPTO_ECC_SECP224R1_CURVE_TYPE,   /**< secp224r1 (NIST 224-bit) */
+#endif
+#if !NRF_CRYPTO_ECC_SECP256R1_ENABLED
+    NRF_CRYPTO_ECC_SECP256R1_CURVE_TYPE,   /**< secp256r1 (NIST 256-bit) */
+#endif
+#if !NRF_CRYPTO_ECC_SECP384R1_ENABLED
+    NRF_CRYPTO_ECC_SECP384R1_CURVE_TYPE,   /**< secp384r1 (NIST 384-bit) */
+#endif
+#if !NRF_CRYPTO_ECC_SECP521R1_ENABLED
+    NRF_CRYPTO_ECC_SECP521R1_CURVE_TYPE,   /**< secp521r1 (NIST 521-bit) */
+#endif
+#if !NRF_CRYPTO_ECC_SECP160K1_ENABLED
+    NRF_CRYPTO_ECC_SECP160K1_CURVE_TYPE,   /**< secp160k1 (Koblitz 160-bit) */
+#endif
+#if !NRF_CRYPTO_ECC_SECP192K1_ENABLED
+    NRF_CRYPTO_ECC_SECP192K1_CURVE_TYPE,   /**< secp192k1 (Koblitz 192-bit) */
+#endif
+#if !NRF_CRYPTO_ECC_SECP224K1_ENABLED
+    NRF_CRYPTO_ECC_SECP224K1_CURVE_TYPE,   /**< secp224k1 (Koblitz 224-bit) */
+#endif
+#if !NRF_CRYPTO_ECC_SECP256K1_ENABLED
+    NRF_CRYPTO_ECC_SECP256K1_CURVE_TYPE,   /**< secp256k1 (Koblitz 256-bit) */
+#endif
+#if !NRF_CRYPTO_ECC_BP256R1_ENABLED
+    NRF_CRYPTO_ECC_BP256R1_CURVE_TYPE,     /**< bp256r1 (Brainpool 256-bit) */
+#endif
+#if !NRF_CRYPTO_ECC_BP384R1_ENABLED
+    NRF_CRYPTO_ECC_BP384R1_CURVE_TYPE,     /**< bp384r1 (Brainpool 384-bit) */
+#endif
+#if !NRF_CRYPTO_ECC_BP512R1_ENABLED
+    NRF_CRYPTO_ECC_BP512R1_CURVE_TYPE,     /**< bp512r1 (Brainpool 512-bit) */
+#endif
+#if !NRF_CRYPTO_ECC_CURVE25519_ENABLED
+    NRF_CRYPTO_ECC_CURVE25519_CURVE_TYPE,  /**< Curve25519 */
+#endif
+#if !NRF_CRYPTO_ECC_ED25519_ENABLED
+    NRF_CRYPTO_ECC_ED25519_CURVE_TYPE,     /**< Ed25519 */
+#endif
+} nrf_crypto_ecc_curve_type_t;
+
+
+/** @brief Structure holding information on a specific curve.
+ *
+ *  @note This structure cannot be used to create a new variable. Only the variables defined by this
+ *  library can be used, e.g. @ref g_nrf_crypto_ecc_secp256r1_curve_info.
+ */
+typedef struct nrf_crypto_ecc_curve_info_s
+{
+    uint16_t                    public_key_size;       /**< @brief Size of a structure holding internal public key. */
+    uint16_t                    private_key_size;      /**< @brief Size of a structure holding internal private key. */
+    nrf_crypto_ecc_curve_type_t curve_type;            /**< @brief Type of the curve. */
+    uint8_t                     raw_private_key_size;  /**< @brief Size of a buffer containing raw private key. */
+    uint8_t                     raw_public_key_size;   /**< @brief Size of a buffer containing raw public key. */
+    void *                      p_backend_data;        /**< @brief Field to hold backend specific internal data. */
+} nrf_crypto_ecc_curve_info_t;
+
+
+/** @addtogroup nrf_crypto_ecc_secp160r1
+ *  @{ */
+
+typedef nrf_crypto_backend_secp160r1_key_pair_generate_context_t
+    nrf_crypto_ecc_secp160r1_key_pair_generate_context_t;            /**< @brief Context structure for key generation using secp160r1 (NIST 160-bit). */
+typedef nrf_crypto_backend_secp160r1_public_key_calculate_context_t
+    nrf_crypto_ecc_secp160r1_public_key_calculate_context_t;         /**< @brief Context structure for public key calculation using secp160r1 (NIST 160-bit). */
+typedef nrf_crypto_backend_secp160r1_private_key_t
+    nrf_crypto_ecc_secp160r1_private_key_t;                          /**< @brief Structure holding internal representation of a private key for secp160r1 (NIST 160-bit) */
+typedef nrf_crypto_backend_secp160r1_public_key_t
+    nrf_crypto_ecc_secp160r1_public_key_t;                           /**< @brief Structure holding internal representation of a public key for secp160r1 (NIST 160-bit) */
+typedef uint8_t nrf_crypto_ecc_secp160r1_raw_private_key_t
+    [NRF_CRYPTO_ECC_SECP160R1_RAW_PRIVATE_KEY_SIZE];                 /**< @brief Array holding raw private key for secp160r1 (NIST 160-bit) */
+typedef uint8_t nrf_crypto_ecc_secp160r1_raw_public_key_t
+    [NRF_CRYPTO_ECC_SECP160R1_RAW_PUBLIC_KEY_SIZE];                  /**< @brief Array holding raw public key for secp160r1 (NIST 160-bit) */
+
+
+#if NRF_CRYPTO_ECC_SECP160R1_ENABLED
+
+/** @brief Variable containing information on secp160r1 (NIST 160-bit).
+ *
+ *  It can be used as a parameter for the functions creating secp160r1 (NIST 160-bit) keys.
+ */
+extern const nrf_crypto_ecc_curve_info_t g_nrf_crypto_ecc_secp160r1_curve_info;
+
+#endif
+
+/** @} */
+
+
+/** @addtogroup nrf_crypto_ecc_secp160r2
+ *  @{ */
+
+typedef nrf_crypto_backend_secp160r2_key_pair_generate_context_t
+    nrf_crypto_ecc_secp160r2_key_pair_generate_context_t;            /**< @brief Context structure for key generation using secp160r2 (NIST 160-bit). */
+typedef nrf_crypto_backend_secp160r2_public_key_calculate_context_t
+    nrf_crypto_ecc_secp160r2_public_key_calculate_context_t;         /**< @brief Context structure for public key calculation using secp160r2 (NIST 160-bit). */
+typedef nrf_crypto_backend_secp160r2_private_key_t
+    nrf_crypto_ecc_secp160r2_private_key_t;                          /**< @brief Structure holding internal representation of a private key for secp160r2 (NIST 160-bit) */
+typedef nrf_crypto_backend_secp160r2_public_key_t
+    nrf_crypto_ecc_secp160r2_public_key_t;                           /**< @brief Structure holding internal representation of a public key for secp160r2 (NIST 160-bit) */
+typedef uint8_t nrf_crypto_ecc_secp160r2_raw_private_key_t
+    [NRF_CRYPTO_ECC_SECP160R2_RAW_PRIVATE_KEY_SIZE];                 /**< @brief Array holding raw private key for secp160r2 (NIST 160-bit) */
+typedef uint8_t nrf_crypto_ecc_secp160r2_raw_public_key_t
+    [NRF_CRYPTO_ECC_SECP160R2_RAW_PUBLIC_KEY_SIZE];                  /**< @brief Array holding raw public key for secp160r2 (NIST 160-bit) */
+
+
+#if NRF_CRYPTO_ECC_SECP160R2_ENABLED
+
+/** @brief Variable containing information on secp160r2 (NIST 160-bit).
+ *
+ *  It can be used as a parameter for the functions creating secp160r2 (NIST 160-bit) keys.
+ */
+extern const nrf_crypto_ecc_curve_info_t g_nrf_crypto_ecc_secp160r2_curve_info;
+
+#endif
+
+/** @} */
+
+
+/** @addtogroup nrf_crypto_ecc_secp192r1
+ *  @{ */
+
+typedef nrf_crypto_backend_secp192r1_key_pair_generate_context_t
+    nrf_crypto_ecc_secp192r1_key_pair_generate_context_t;            /**< @brief Context structure for key generation using secp192r1 (NIST 192-bit). */
+typedef nrf_crypto_backend_secp192r1_public_key_calculate_context_t
+    nrf_crypto_ecc_secp192r1_public_key_calculate_context_t;         /**< @brief Context structure for public key calculation using secp192r1 (NIST 192-bit). */
+typedef nrf_crypto_backend_secp192r1_private_key_t
+    nrf_crypto_ecc_secp192r1_private_key_t;                          /**< @brief Structure holding internal representation of a private key for secp192r1 (NIST 192-bit) */
+typedef nrf_crypto_backend_secp192r1_public_key_t
+    nrf_crypto_ecc_secp192r1_public_key_t;                           /**< @brief Structure holding internal representation of a public key for secp192r1 (NIST 192-bit) */
+typedef uint8_t nrf_crypto_ecc_secp192r1_raw_private_key_t
+    [NRF_CRYPTO_ECC_SECP192R1_RAW_PRIVATE_KEY_SIZE];                 /**< @brief Array holding raw private key for secp192r1 (NIST 192-bit) */
+typedef uint8_t nrf_crypto_ecc_secp192r1_raw_public_key_t
+    [NRF_CRYPTO_ECC_SECP192R1_RAW_PUBLIC_KEY_SIZE];                  /**< @brief Array holding raw public key for secp192r1 (NIST 192-bit) */
+
+
+#if NRF_CRYPTO_ECC_SECP192R1_ENABLED
+
+/** @brief Variable containing information on secp192r1 (NIST 192-bit).
+ *
+ *  It can be used as a parameter for the functions creating secp192r1 (NIST 192-bit) keys.
+ */
+extern const nrf_crypto_ecc_curve_info_t g_nrf_crypto_ecc_secp192r1_curve_info;
+
+#endif
+
+/** @} */
+
+
+/** @addtogroup nrf_crypto_ecc_secp224r1
+ *  @{ */
+
+typedef nrf_crypto_backend_secp224r1_key_pair_generate_context_t
+    nrf_crypto_ecc_secp224r1_key_pair_generate_context_t;            /**< @brief Context structure for key generation using secp224r1 (NIST 224-bit). */
+typedef nrf_crypto_backend_secp224r1_public_key_calculate_context_t
+    nrf_crypto_ecc_secp224r1_public_key_calculate_context_t;         /**< @brief Context structure for public key calculation using secp224r1 (NIST 224-bit). */
+typedef nrf_crypto_backend_secp224r1_private_key_t
+    nrf_crypto_ecc_secp224r1_private_key_t;                          /**< @brief Structure holding internal representation of a private key for secp224r1 (NIST 224-bit) */
+typedef nrf_crypto_backend_secp224r1_public_key_t
+    nrf_crypto_ecc_secp224r1_public_key_t;                           /**< @brief Structure holding internal representation of a public key for secp224r1 (NIST 224-bit) */
+typedef uint8_t nrf_crypto_ecc_secp224r1_raw_private_key_t
+    [NRF_CRYPTO_ECC_SECP224R1_RAW_PRIVATE_KEY_SIZE];                 /**< @brief Array holding raw private key for secp224r1 (NIST 224-bit) */
+typedef uint8_t nrf_crypto_ecc_secp224r1_raw_public_key_t
+    [NRF_CRYPTO_ECC_SECP224R1_RAW_PUBLIC_KEY_SIZE];                  /**< @brief Array holding raw public key for secp224r1 (NIST 224-bit) */
+
+
+#if NRF_CRYPTO_ECC_SECP224R1_ENABLED
+
+/** @brief Variable containing information on secp224r1 (NIST 224-bit).
+ *
+ *  It can be used as a parameter for the functions creating secp224r1 (NIST 224-bit) keys.
+ */
+extern const nrf_crypto_ecc_curve_info_t g_nrf_crypto_ecc_secp224r1_curve_info;
+
+#endif
+
+/** @} */
+
+
+/** @addtogroup nrf_crypto_ecc_secp256r1
+ *  @{ */
+
+typedef nrf_crypto_backend_secp256r1_key_pair_generate_context_t
+    nrf_crypto_ecc_secp256r1_key_pair_generate_context_t;            /**< @brief Context structure for key generation using secp256r1 (NIST 256-bit). */
+typedef nrf_crypto_backend_secp256r1_public_key_calculate_context_t
+    nrf_crypto_ecc_secp256r1_public_key_calculate_context_t;         /**< @brief Context structure for public key calculation using secp256r1 (NIST 256-bit). */
+typedef nrf_crypto_backend_secp256r1_private_key_t
+    nrf_crypto_ecc_secp256r1_private_key_t;                          /**< @brief Structure holding internal representation of a private key for secp256r1 (NIST 256-bit) */
+typedef nrf_crypto_backend_secp256r1_public_key_t
+    nrf_crypto_ecc_secp256r1_public_key_t;                           /**< @brief Structure holding internal representation of a public key for secp256r1 (NIST 256-bit) */
+typedef uint8_t nrf_crypto_ecc_secp256r1_raw_private_key_t
+    [NRF_CRYPTO_ECC_SECP256R1_RAW_PRIVATE_KEY_SIZE];                 /**< @brief Array holding raw private key for secp256r1 (NIST 256-bit) */
+typedef uint8_t nrf_crypto_ecc_secp256r1_raw_public_key_t
+    [NRF_CRYPTO_ECC_SECP256R1_RAW_PUBLIC_KEY_SIZE];                  /**< @brief Array holding raw public key for secp256r1 (NIST 256-bit) */
+
+
+#if NRF_CRYPTO_ECC_SECP256R1_ENABLED
+
+/** @brief Variable containing information on secp256r1 (NIST 256-bit).
+ *
+ *  It can be used as a parameter for the functions creating secp256r1 (NIST 256-bit) keys.
+ */
+extern const nrf_crypto_ecc_curve_info_t g_nrf_crypto_ecc_secp256r1_curve_info;
+
+#endif
+
+/** @} */
+
+
+/** @addtogroup nrf_crypto_ecc_secp384r1
+ *  @{ */
+
+typedef nrf_crypto_backend_secp384r1_key_pair_generate_context_t
+    nrf_crypto_ecc_secp384r1_key_pair_generate_context_t;            /**< @brief Context structure for key generation using secp384r1 (NIST 384-bit). */
+typedef nrf_crypto_backend_secp384r1_public_key_calculate_context_t
+    nrf_crypto_ecc_secp384r1_public_key_calculate_context_t;         /**< @brief Context structure for public key calculation using secp384r1 (NIST 384-bit). */
+typedef nrf_crypto_backend_secp384r1_private_key_t
+    nrf_crypto_ecc_secp384r1_private_key_t;                          /**< @brief Structure holding internal representation of a private key for secp384r1 (NIST 384-bit) */
+typedef nrf_crypto_backend_secp384r1_public_key_t
+    nrf_crypto_ecc_secp384r1_public_key_t;                           /**< @brief Structure holding internal representation of a public key for secp384r1 (NIST 384-bit) */
+typedef uint8_t nrf_crypto_ecc_secp384r1_raw_private_key_t
+    [NRF_CRYPTO_ECC_SECP384R1_RAW_PRIVATE_KEY_SIZE];                 /**< @brief Array holding raw private key for secp384r1 (NIST 384-bit) */
+typedef uint8_t nrf_crypto_ecc_secp384r1_raw_public_key_t
+    [NRF_CRYPTO_ECC_SECP384R1_RAW_PUBLIC_KEY_SIZE];                  /**< @brief Array holding raw public key for secp384r1 (NIST 384-bit) */
+
+
+#if NRF_CRYPTO_ECC_SECP384R1_ENABLED
+
+/** @brief Variable containing information on secp384r1 (NIST 384-bit).
+ *
+ *  It can be used as a parameter for the functions creating secp384r1 (NIST 384-bit) keys.
+ */
+extern const nrf_crypto_ecc_curve_info_t g_nrf_crypto_ecc_secp384r1_curve_info;
+
+#endif
+
+/** @} */
+
+
+/** @addtogroup nrf_crypto_ecc_secp521r1
+ *  @{ */
+
+typedef nrf_crypto_backend_secp521r1_key_pair_generate_context_t
+    nrf_crypto_ecc_secp521r1_key_pair_generate_context_t;            /**< @brief Context structure for key generation using secp521r1 (NIST 521-bit). */
+typedef nrf_crypto_backend_secp521r1_public_key_calculate_context_t
+    nrf_crypto_ecc_secp521r1_public_key_calculate_context_t;         /**< @brief Context structure for public key calculation using secp521r1 (NIST 521-bit). */
+typedef nrf_crypto_backend_secp521r1_private_key_t
+    nrf_crypto_ecc_secp521r1_private_key_t;                          /**< @brief Structure holding internal representation of a private key for secp521r1 (NIST 521-bit) */
+typedef nrf_crypto_backend_secp521r1_public_key_t
+    nrf_crypto_ecc_secp521r1_public_key_t;                           /**< @brief Structure holding internal representation of a public key for secp521r1 (NIST 521-bit) */
+typedef uint8_t nrf_crypto_ecc_secp521r1_raw_private_key_t
+    [NRF_CRYPTO_ECC_SECP521R1_RAW_PRIVATE_KEY_SIZE];                 /**< @brief Array holding raw private key for secp521r1 (NIST 521-bit) */
+typedef uint8_t nrf_crypto_ecc_secp521r1_raw_public_key_t
+    [NRF_CRYPTO_ECC_SECP521R1_RAW_PUBLIC_KEY_SIZE];                  /**< @brief Array holding raw public key for secp521r1 (NIST 521-bit) */
+
+
+#if NRF_CRYPTO_ECC_SECP521R1_ENABLED
+
+/** @brief Variable containing information on secp521r1 (NIST 521-bit).
+ *
+ *  It can be used as a parameter for the functions creating secp521r1 (NIST 521-bit) keys.
+ */
+extern const nrf_crypto_ecc_curve_info_t g_nrf_crypto_ecc_secp521r1_curve_info;
+
+#endif
+
+/** @} */
+
+
+/** @addtogroup nrf_crypto_ecc_secp160k1
+ *  @{ */
+
+typedef nrf_crypto_backend_secp160k1_key_pair_generate_context_t
+    nrf_crypto_ecc_secp160k1_key_pair_generate_context_t;            /**< @brief Context structure for key generation using secp160k1 (Koblitz 160-bit). */
+typedef nrf_crypto_backend_secp160k1_public_key_calculate_context_t
+    nrf_crypto_ecc_secp160k1_public_key_calculate_context_t;         /**< @brief Context structure for public key calculation using secp160k1 (Koblitz 160-bit). */
+typedef nrf_crypto_backend_secp160k1_private_key_t
+    nrf_crypto_ecc_secp160k1_private_key_t;                          /**< @brief Structure holding internal representation of a private key for secp160k1 (Koblitz 160-bit) */
+typedef nrf_crypto_backend_secp160k1_public_key_t
+    nrf_crypto_ecc_secp160k1_public_key_t;                           /**< @brief Structure holding internal representation of a public key for secp160k1 (Koblitz 160-bit) */
+typedef uint8_t nrf_crypto_ecc_secp160k1_raw_private_key_t
+    [NRF_CRYPTO_ECC_SECP160K1_RAW_PRIVATE_KEY_SIZE];                 /**< @brief Array holding raw private key for secp160k1 (Koblitz 160-bit) */
+typedef uint8_t nrf_crypto_ecc_secp160k1_raw_public_key_t
+    [NRF_CRYPTO_ECC_SECP160K1_RAW_PUBLIC_KEY_SIZE];                  /**< @brief Array holding raw public key for secp160k1 (Koblitz 160-bit) */
+
+
+#if NRF_CRYPTO_ECC_SECP160K1_ENABLED
+
+/** @brief Variable containing information on secp160k1 (Koblitz 160-bit).
+ *
+ *  It can be used as a parameter for the functions creating secp160k1 (Koblitz 160-bit) keys.
+ */
+extern const nrf_crypto_ecc_curve_info_t g_nrf_crypto_ecc_secp160k1_curve_info;
+
+#endif
+
+/** @} */
+
+
+/** @addtogroup nrf_crypto_ecc_secp192k1
+ *  @{ */
+
+typedef nrf_crypto_backend_secp192k1_key_pair_generate_context_t
+    nrf_crypto_ecc_secp192k1_key_pair_generate_context_t;            /**< @brief Context structure for key generation using secp192k1 (Koblitz 192-bit). */
+typedef nrf_crypto_backend_secp192k1_public_key_calculate_context_t
+    nrf_crypto_ecc_secp192k1_public_key_calculate_context_t;         /**< @brief Context structure for public key calculation using secp192k1 (Koblitz 192-bit). */
+typedef nrf_crypto_backend_secp192k1_private_key_t
+    nrf_crypto_ecc_secp192k1_private_key_t;                          /**< @brief Structure holding internal representation of a private key for secp192k1 (Koblitz 192-bit) */
+typedef nrf_crypto_backend_secp192k1_public_key_t
+    nrf_crypto_ecc_secp192k1_public_key_t;                           /**< @brief Structure holding internal representation of a public key for secp192k1 (Koblitz 192-bit) */
+typedef uint8_t nrf_crypto_ecc_secp192k1_raw_private_key_t
+    [NRF_CRYPTO_ECC_SECP192K1_RAW_PRIVATE_KEY_SIZE];                 /**< @brief Array holding raw private key for secp192k1 (Koblitz 192-bit) */
+typedef uint8_t nrf_crypto_ecc_secp192k1_raw_public_key_t
+    [NRF_CRYPTO_ECC_SECP192K1_RAW_PUBLIC_KEY_SIZE];                  /**< @brief Array holding raw public key for secp192k1 (Koblitz 192-bit) */
+
+
+#if NRF_CRYPTO_ECC_SECP192K1_ENABLED
+
+/** @brief Variable containing information on secp192k1 (Koblitz 192-bit).
+ *
+ *  It can be used as a parameter for the functions creating secp192k1 (Koblitz 192-bit) keys.
+ */
+extern const nrf_crypto_ecc_curve_info_t g_nrf_crypto_ecc_secp192k1_curve_info;
+
+#endif
+
+/** @} */
+
+
+/** @addtogroup nrf_crypto_ecc_secp224k1
+ *  @{ */
+
+typedef nrf_crypto_backend_secp224k1_key_pair_generate_context_t
+    nrf_crypto_ecc_secp224k1_key_pair_generate_context_t;            /**< @brief Context structure for key generation using secp224k1 (Koblitz 224-bit). */
+typedef nrf_crypto_backend_secp224k1_public_key_calculate_context_t
+    nrf_crypto_ecc_secp224k1_public_key_calculate_context_t;         /**< @brief Context structure for public key calculation using secp224k1 (Koblitz 224-bit). */
+typedef nrf_crypto_backend_secp224k1_private_key_t
+    nrf_crypto_ecc_secp224k1_private_key_t;                          /**< @brief Structure holding internal representation of a private key for secp224k1 (Koblitz 224-bit) */
+typedef nrf_crypto_backend_secp224k1_public_key_t
+    nrf_crypto_ecc_secp224k1_public_key_t;                           /**< @brief Structure holding internal representation of a public key for secp224k1 (Koblitz 224-bit) */
+typedef uint8_t nrf_crypto_ecc_secp224k1_raw_private_key_t
+    [NRF_CRYPTO_ECC_SECP224K1_RAW_PRIVATE_KEY_SIZE];                 /**< @brief Array holding raw private key for secp224k1 (Koblitz 224-bit) */
+typedef uint8_t nrf_crypto_ecc_secp224k1_raw_public_key_t
+    [NRF_CRYPTO_ECC_SECP224K1_RAW_PUBLIC_KEY_SIZE];                  /**< @brief Array holding raw public key for secp224k1 (Koblitz 224-bit) */
+
+
+#if NRF_CRYPTO_ECC_SECP224K1_ENABLED
+
+/** @brief Variable containing information on secp224k1 (Koblitz 224-bit).
+ *
+ *  It can be used as a parameter for the functions creating secp224k1 (Koblitz 224-bit) keys.
+ */
+extern const nrf_crypto_ecc_curve_info_t g_nrf_crypto_ecc_secp224k1_curve_info;
+
+#endif
+
+/** @} */
+
+
+/** @addtogroup nrf_crypto_ecc_secp256k1
+ *  @{ */
+
+typedef nrf_crypto_backend_secp256k1_key_pair_generate_context_t
+    nrf_crypto_ecc_secp256k1_key_pair_generate_context_t;            /**< @brief Context structure for key generation using secp256k1 (Koblitz 256-bit). */
+typedef nrf_crypto_backend_secp256k1_public_key_calculate_context_t
+    nrf_crypto_ecc_secp256k1_public_key_calculate_context_t;         /**< @brief Context structure for public key calculation using secp256k1 (Koblitz 256-bit). */
+typedef nrf_crypto_backend_secp256k1_private_key_t
+    nrf_crypto_ecc_secp256k1_private_key_t;                          /**< @brief Structure holding internal representation of a private key for secp256k1 (Koblitz 256-bit) */
+typedef nrf_crypto_backend_secp256k1_public_key_t
+    nrf_crypto_ecc_secp256k1_public_key_t;                           /**< @brief Structure holding internal representation of a public key for secp256k1 (Koblitz 256-bit) */
+typedef uint8_t nrf_crypto_ecc_secp256k1_raw_private_key_t
+    [NRF_CRYPTO_ECC_SECP256K1_RAW_PRIVATE_KEY_SIZE];                 /**< @brief Array holding raw private key for secp256k1 (Koblitz 256-bit) */
+typedef uint8_t nrf_crypto_ecc_secp256k1_raw_public_key_t
+    [NRF_CRYPTO_ECC_SECP256K1_RAW_PUBLIC_KEY_SIZE];                  /**< @brief Array holding raw public key for secp256k1 (Koblitz 256-bit) */
+
+
+#if NRF_CRYPTO_ECC_SECP256K1_ENABLED
+
+/** @brief Variable containing information on secp256k1 (Koblitz 256-bit).
+ *
+ *  It can be used as a parameter for the functions creating secp256k1 (Koblitz 256-bit) keys.
+ */
+extern const nrf_crypto_ecc_curve_info_t g_nrf_crypto_ecc_secp256k1_curve_info;
+
+#endif
+
+/** @} */
+
+
+/** @addtogroup nrf_crypto_ecc_bp256r1
+ *  @{ */
+
+typedef nrf_crypto_backend_bp256r1_key_pair_generate_context_t
+    nrf_crypto_ecc_bp256r1_key_pair_generate_context_t;              /**< @brief Context structure for key generation using bp256r1 (Brainpool 256-bit). */
+typedef nrf_crypto_backend_bp256r1_public_key_calculate_context_t
+    nrf_crypto_ecc_bp256r1_public_key_calculate_context_t;           /**< @brief Context structure for public key calculation using bp256r1 (Brainpool 256-bit). */
+typedef nrf_crypto_backend_bp256r1_private_key_t
+    nrf_crypto_ecc_bp256r1_private_key_t;                            /**< @brief Structure holding internal representation of a private key for bp256r1 (Brainpool 256-bit) */
+typedef nrf_crypto_backend_bp256r1_public_key_t
+    nrf_crypto_ecc_bp256r1_public_key_t;                             /**< @brief Structure holding internal representation of a public key for bp256r1 (Brainpool 256-bit) */
+typedef uint8_t nrf_crypto_ecc_bp256r1_raw_private_key_t
+    [NRF_CRYPTO_ECC_BP256R1_RAW_PRIVATE_KEY_SIZE];                   /**< @brief Array holding raw private key for bp256r1 (Brainpool 256-bit) */
+typedef uint8_t nrf_crypto_ecc_bp256r1_raw_public_key_t
+    [NRF_CRYPTO_ECC_BP256R1_RAW_PUBLIC_KEY_SIZE];                    /**< @brief Array holding raw public key for bp256r1 (Brainpool 256-bit) */
+
+
+#if NRF_CRYPTO_ECC_BP256R1_ENABLED
+
+/** @brief Variable containing information on bp256r1 (Brainpool 256-bit).
+ *
+ *  It can be used as a parameter for the functions creating bp256r1 (Brainpool 256-bit) keys.
+ */
+extern const nrf_crypto_ecc_curve_info_t g_nrf_crypto_ecc_bp256r1_curve_info;
+
+#endif
+
+/** @} */
+
+
+/** @addtogroup nrf_crypto_ecc_bp384r1
+ *  @{ */
+
+typedef nrf_crypto_backend_bp384r1_key_pair_generate_context_t
+    nrf_crypto_ecc_bp384r1_key_pair_generate_context_t;              /**< @brief Context structure for key generation using bp384r1 (Brainpool 384-bit). */
+typedef nrf_crypto_backend_bp384r1_public_key_calculate_context_t
+    nrf_crypto_ecc_bp384r1_public_key_calculate_context_t;           /**< @brief Context structure for public key calculation using bp384r1 (Brainpool 384-bit). */
+typedef nrf_crypto_backend_bp384r1_private_key_t
+    nrf_crypto_ecc_bp384r1_private_key_t;                            /**< @brief Structure holding internal representation of a private key for bp384r1 (Brainpool 384-bit) */
+typedef nrf_crypto_backend_bp384r1_public_key_t
+    nrf_crypto_ecc_bp384r1_public_key_t;                             /**< @brief Structure holding internal representation of a public key for bp384r1 (Brainpool 384-bit) */
+typedef uint8_t nrf_crypto_ecc_bp384r1_raw_private_key_t
+    [NRF_CRYPTO_ECC_BP384R1_RAW_PRIVATE_KEY_SIZE];                   /**< @brief Array holding raw private key for bp384r1 (Brainpool 384-bit) */
+typedef uint8_t nrf_crypto_ecc_bp384r1_raw_public_key_t
+    [NRF_CRYPTO_ECC_BP384R1_RAW_PUBLIC_KEY_SIZE];                    /**< @brief Array holding raw public key for bp384r1 (Brainpool 384-bit) */
+
+
+#if NRF_CRYPTO_ECC_BP384R1_ENABLED
+
+/** @brief Variable containing information on bp384r1 (Brainpool 384-bit).
+ *
+ *  It can be used as a parameter for the functions creating bp384r1 (Brainpool 384-bit) keys.
+ */
+extern const nrf_crypto_ecc_curve_info_t g_nrf_crypto_ecc_bp384r1_curve_info;
+
+#endif
+
+/** @} */
+
+
+/** @addtogroup nrf_crypto_ecc_bp512r1
+ *  @{ */
+
+typedef nrf_crypto_backend_bp512r1_key_pair_generate_context_t
+    nrf_crypto_ecc_bp512r1_key_pair_generate_context_t;              /**< @brief Context structure for key generation using bp512r1 (Brainpool 512-bit). */
+typedef nrf_crypto_backend_bp512r1_public_key_calculate_context_t
+    nrf_crypto_ecc_bp512r1_public_key_calculate_context_t;           /**< @brief Context structure for public key calculation using bp512r1 (Brainpool 512-bit). */
+typedef nrf_crypto_backend_bp512r1_private_key_t
+    nrf_crypto_ecc_bp512r1_private_key_t;                            /**< @brief Structure holding internal representation of a private key for bp512r1 (Brainpool 512-bit) */
+typedef nrf_crypto_backend_bp512r1_public_key_t
+    nrf_crypto_ecc_bp512r1_public_key_t;                             /**< @brief Structure holding internal representation of a public key for bp512r1 (Brainpool 512-bit) */
+typedef uint8_t nrf_crypto_ecc_bp512r1_raw_private_key_t
+    [NRF_CRYPTO_ECC_BP512R1_RAW_PRIVATE_KEY_SIZE];                   /**< @brief Array holding raw private key for bp512r1 (Brainpool 512-bit) */
+typedef uint8_t nrf_crypto_ecc_bp512r1_raw_public_key_t
+    [NRF_CRYPTO_ECC_BP512R1_RAW_PUBLIC_KEY_SIZE];                    /**< @brief Array holding raw public key for bp512r1 (Brainpool 512-bit) */
+
+
+#if NRF_CRYPTO_ECC_BP512R1_ENABLED
+
+/** @brief Variable containing information on bp512r1 (Brainpool 512-bit).
+ *
+ *  It can be used as a parameter for the functions creating bp512r1 (Brainpool 512-bit) keys.
+ */
+extern const nrf_crypto_ecc_curve_info_t g_nrf_crypto_ecc_bp512r1_curve_info;
+
+#endif
+
+/** @} */
+
+
+/** @addtogroup nrf_crypto_ecc_curve25519
+ *  @{ */
+
+typedef nrf_crypto_backend_curve25519_key_pair_generate_context_t
+    nrf_crypto_ecc_curve25519_key_pair_generate_context_t;           /**< @brief Context structure for key generation using Curve25519. */
+typedef nrf_crypto_backend_curve25519_public_key_calculate_context_t
+    nrf_crypto_ecc_curve25519_public_key_calculate_context_t;        /**< @brief Context structure for public key calculation using Curve25519. */
+typedef nrf_crypto_backend_curve25519_private_key_t
+    nrf_crypto_ecc_curve25519_private_key_t;                         /**< @brief Structure holding internal representation of a private key for Curve25519 */
+typedef nrf_crypto_backend_curve25519_public_key_t
+    nrf_crypto_ecc_curve25519_public_key_t;                          /**< @brief Structure holding internal representation of a public key for Curve25519 */
+typedef uint8_t nrf_crypto_ecc_curve25519_raw_private_key_t
+    [NRF_CRYPTO_ECC_CURVE25519_RAW_PRIVATE_KEY_SIZE];                /**< @brief Array holding raw private key for Curve25519 */
+typedef uint8_t nrf_crypto_ecc_curve25519_raw_public_key_t
+    [NRF_CRYPTO_ECC_CURVE25519_RAW_PUBLIC_KEY_SIZE];                 /**< @brief Array holding raw public key for Curve25519 */
+
+
+#if NRF_CRYPTO_ECC_CURVE25519_ENABLED
+
+/** @brief Variable containing information on Curve25519.
+ *
+ *  It can be used as a parameter for the functions creating Curve25519 keys.
+ */
+extern const nrf_crypto_ecc_curve_info_t g_nrf_crypto_ecc_curve25519_curve_info;
+
+#endif
+
+/** @} */
+
+
+/** @addtogroup nrf_crypto_ecc_ed25519
+ *  @{ */
+
+typedef nrf_crypto_backend_ed25519_key_pair_generate_context_t
+    nrf_crypto_ecc_ed25519_key_pair_generate_context_t;              /**< @brief Context structure for key generation using Ed25519. */
+typedef nrf_crypto_backend_ed25519_public_key_calculate_context_t
+    nrf_crypto_ecc_ed25519_public_key_calculate_context_t;           /**< @brief Context structure for public key calculation using Ed25519. */
+typedef nrf_crypto_backend_ed25519_private_key_t
+    nrf_crypto_ecc_ed25519_private_key_t;                            /**< @brief Structure holding internal representation of a private key for Ed25519 */
+typedef nrf_crypto_backend_ed25519_public_key_t
+    nrf_crypto_ecc_ed25519_public_key_t;                             /**< @brief Structure holding internal representation of a public key for Ed25519 */
+typedef uint8_t nrf_crypto_ecc_ed25519_raw_private_key_t
+    [NRF_CRYPTO_ECC_ED25519_RAW_PRIVATE_KEY_SIZE];                   /**< @brief Array holding raw private key for Ed25519 */
+typedef uint8_t nrf_crypto_ecc_ed25519_raw_public_key_t
+    [NRF_CRYPTO_ECC_ED25519_RAW_PUBLIC_KEY_SIZE];                    /**< @brief Array holding raw public key for Ed25519 */
+
+
+#if NRF_CRYPTO_ECC_ED25519_ENABLED
+
+/** @brief Variable containing information on Ed25519.
+ *
+ *  It can be used as a parameter for the functions creating Ed25519 keys.
+ */
+extern const nrf_crypto_ecc_curve_info_t g_nrf_crypto_ecc_ed25519_curve_info;
+
+#endif
+
+/** @} */
+
+
+typedef uint8_t nrf_crypto_ecc_raw_private_key_t[NRF_CRYPTO_ECC_RAW_PRIVATE_KEY_MAX_SIZE];  /**< @brief Type big enough to hold a raw private key for any the enabled curves. */
+typedef uint8_t nrf_crypto_ecc_raw_public_key_t [NRF_CRYPTO_ECC_RAW_PUBLIC_KEY_MAX_SIZE];   /**< @brief Type big enough to hold a raw public key for any the enabled curves. */
+
+
+/** @brief Union holding a context for a key pair generation.
+ */
+typedef union
+{
+    nrf_crypto_ecc_secp160r1_key_pair_generate_context_t  context_secp160r1;    /**< @brief Holds context for secp160r1 (NIST 160-bit). */
+    nrf_crypto_ecc_secp160r2_key_pair_generate_context_t  context_secp160r2;    /**< @brief Holds context for secp160r2 (NIST 160-bit). */
+    nrf_crypto_ecc_secp192r1_key_pair_generate_context_t  context_secp192r1;    /**< @brief Holds context for secp192r1 (NIST 192-bit). */
+    nrf_crypto_ecc_secp224r1_key_pair_generate_context_t  context_secp224r1;    /**< @brief Holds context for secp224r1 (NIST 224-bit). */
+    nrf_crypto_ecc_secp256r1_key_pair_generate_context_t  context_secp256r1;    /**< @brief Holds context for secp256r1 (NIST 256-bit). */
+    nrf_crypto_ecc_secp384r1_key_pair_generate_context_t  context_secp384r1;    /**< @brief Holds context for secp384r1 (NIST 384-bit). */
+    nrf_crypto_ecc_secp521r1_key_pair_generate_context_t  context_secp521r1;    /**< @brief Holds context for secp521r1 (NIST 521-bit). */
+    nrf_crypto_ecc_secp160k1_key_pair_generate_context_t  context_secp160k1;    /**< @brief Holds context for secp160k1 (Koblitz 160-bit). */
+    nrf_crypto_ecc_secp192k1_key_pair_generate_context_t  context_secp192k1;    /**< @brief Holds context for secp192k1 (Koblitz 192-bit). */
+    nrf_crypto_ecc_secp224k1_key_pair_generate_context_t  context_secp224k1;    /**< @brief Holds context for secp224k1 (Koblitz 224-bit). */
+    nrf_crypto_ecc_secp256k1_key_pair_generate_context_t  context_secp256k1;    /**< @brief Holds context for secp256k1 (Koblitz 256-bit). */
+    nrf_crypto_ecc_bp256r1_key_pair_generate_context_t    context_bp256r1;      /**< @brief Holds context for bp256r1 (Brainpool 256-bit). */
+    nrf_crypto_ecc_bp384r1_key_pair_generate_context_t    context_bp384r1;      /**< @brief Holds context for bp384r1 (Brainpool 384-bit). */
+    nrf_crypto_ecc_bp512r1_key_pair_generate_context_t    context_bp512r1;      /**< @brief Holds context for bp512r1 (Brainpool 512-bit). */
+    nrf_crypto_ecc_curve25519_key_pair_generate_context_t context_curve25519;   /**< @brief Holds context for Curve25519. */
+    nrf_crypto_ecc_ed25519_key_pair_generate_context_t    context_ed25519;      /**< @brief Holds context for Ed25519. */
+} nrf_crypto_ecc_key_pair_generate_context_t;
+
+
+/** @brief Union holding a context for a public key calculation.
+ */
+typedef union
+{
+    nrf_crypto_ecc_secp160r1_public_key_calculate_context_t  context_secp160r1;    /**< @brief Holds context for secp160r1 (NIST 160-bit). */
+    nrf_crypto_ecc_secp160r2_public_key_calculate_context_t  context_secp160r2;    /**< @brief Holds context for secp160r2 (NIST 160-bit). */
+    nrf_crypto_ecc_secp192r1_public_key_calculate_context_t  context_secp192r1;    /**< @brief Holds context for secp192r1 (NIST 192-bit). */
+    nrf_crypto_ecc_secp224r1_public_key_calculate_context_t  context_secp224r1;    /**< @brief Holds context for secp224r1 (NIST 224-bit). */
+    nrf_crypto_ecc_secp256r1_public_key_calculate_context_t  context_secp256r1;    /**< @brief Holds context for secp256r1 (NIST 256-bit). */
+    nrf_crypto_ecc_secp384r1_public_key_calculate_context_t  context_secp384r1;    /**< @brief Holds context for secp384r1 (NIST 384-bit). */
+    nrf_crypto_ecc_secp521r1_public_key_calculate_context_t  context_secp521r1;    /**< @brief Holds context for secp521r1 (NIST 521-bit). */
+    nrf_crypto_ecc_secp160k1_public_key_calculate_context_t  context_secp160k1;    /**< @brief Holds context for secp160k1 (Koblitz 160-bit). */
+    nrf_crypto_ecc_secp192k1_public_key_calculate_context_t  context_secp192k1;    /**< @brief Holds context for secp192k1 (Koblitz 192-bit). */
+    nrf_crypto_ecc_secp224k1_public_key_calculate_context_t  context_secp224k1;    /**< @brief Holds context for secp224k1 (Koblitz 224-bit). */
+    nrf_crypto_ecc_secp256k1_public_key_calculate_context_t  context_secp256k1;    /**< @brief Holds context for secp256k1 (Koblitz 256-bit). */
+    nrf_crypto_ecc_bp256r1_public_key_calculate_context_t    context_bp256r1;      /**< @brief Holds context for bp256r1 (Brainpool 256-bit). */
+    nrf_crypto_ecc_bp384r1_public_key_calculate_context_t    context_bp384r1;      /**< @brief Holds context for bp384r1 (Brainpool 384-bit). */
+    nrf_crypto_ecc_bp512r1_public_key_calculate_context_t    context_bp512r1;      /**< @brief Holds context for bp512r1 (Brainpool 512-bit). */
+    nrf_crypto_ecc_curve25519_public_key_calculate_context_t context_curve25519;   /**< @brief Holds context for Curve25519. */
+    nrf_crypto_ecc_ed25519_public_key_calculate_context_t    context_ed25519;      /**< @brief Holds context for Ed25519. */
+} nrf_crypto_ecc_public_key_calculate_context_t;
+
+
+/** @brief Union holding representation of a private key for any curve type.
+ */
+typedef union
+{
+    nrf_crypto_ecc_secp160r1_private_key_t  key_secp160r1;    /**< @brief Holds internal representation of a private key for secp160r1 (NIST 160-bit). */
+    nrf_crypto_ecc_secp160r2_private_key_t  key_secp160r2;    /**< @brief Holds internal representation of a private key for secp160r2 (NIST 160-bit). */
+    nrf_crypto_ecc_secp192r1_private_key_t  key_secp192r1;    /**< @brief Holds internal representation of a private key for secp192r1 (NIST 192-bit). */
+    nrf_crypto_ecc_secp224r1_private_key_t  key_secp224r1;    /**< @brief Holds internal representation of a private key for secp224r1 (NIST 224-bit). */
+    nrf_crypto_ecc_secp256r1_private_key_t  key_secp256r1;    /**< @brief Holds internal representation of a private key for secp256r1 (NIST 256-bit). */
+    nrf_crypto_ecc_secp384r1_private_key_t  key_secp384r1;    /**< @brief Holds internal representation of a private key for secp384r1 (NIST 384-bit). */
+    nrf_crypto_ecc_secp521r1_private_key_t  key_secp521r1;    /**< @brief Holds internal representation of a private key for secp521r1 (NIST 521-bit). */
+    nrf_crypto_ecc_secp160k1_private_key_t  key_secp160k1;    /**< @brief Holds internal representation of a private key for secp160k1 (Koblitz 160-bit). */
+    nrf_crypto_ecc_secp192k1_private_key_t  key_secp192k1;    /**< @brief Holds internal representation of a private key for secp192k1 (Koblitz 192-bit). */
+    nrf_crypto_ecc_secp224k1_private_key_t  key_secp224k1;    /**< @brief Holds internal representation of a private key for secp224k1 (Koblitz 224-bit). */
+    nrf_crypto_ecc_secp256k1_private_key_t  key_secp256k1;    /**< @brief Holds internal representation of a private key for secp256k1 (Koblitz 256-bit). */
+    nrf_crypto_ecc_bp256r1_private_key_t    key_bp256r1;      /**< @brief Holds internal representation of a private key for bp256r1 (Brainpool 256-bit). */
+    nrf_crypto_ecc_bp384r1_private_key_t    key_bp384r1;      /**< @brief Holds internal representation of a private key for bp384r1 (Brainpool 384-bit). */
+    nrf_crypto_ecc_bp512r1_private_key_t    key_bp512r1;      /**< @brief Holds internal representation of a private key for bp512r1 (Brainpool 512-bit). */
+    nrf_crypto_ecc_curve25519_private_key_t key_curve25519;   /**< @brief Holds internal representation of a private key for Curve25519. */
+    nrf_crypto_ecc_ed25519_private_key_t    key_ed25519;      /**< @brief Holds internal representation of a private key for Ed25519. */
+} nrf_crypto_ecc_private_key_t;
+
+
+/** @brief Union holding representation of a public key for any curve type.
+ */
+typedef union
+{
+    nrf_crypto_ecc_secp160r1_public_key_t  key_secp160r1;    /**< @brief Holds internal representation of a public key for secp160r1 (NIST 160-bit). */
+    nrf_crypto_ecc_secp160r2_public_key_t  key_secp160r2;    /**< @brief Holds internal representation of a public key for secp160r2 (NIST 160-bit). */
+    nrf_crypto_ecc_secp192r1_public_key_t  key_secp192r1;    /**< @brief Holds internal representation of a public key for secp192r1 (NIST 192-bit). */
+    nrf_crypto_ecc_secp224r1_public_key_t  key_secp224r1;    /**< @brief Holds internal representation of a public key for secp224r1 (NIST 224-bit). */
+    nrf_crypto_ecc_secp256r1_public_key_t  key_secp256r1;    /**< @brief Holds internal representation of a public key for secp256r1 (NIST 256-bit). */
+    nrf_crypto_ecc_secp384r1_public_key_t  key_secp384r1;    /**< @brief Holds internal representation of a public key for secp384r1 (NIST 384-bit). */
+    nrf_crypto_ecc_secp521r1_public_key_t  key_secp521r1;    /**< @brief Holds internal representation of a public key for secp521r1 (NIST 521-bit). */
+    nrf_crypto_ecc_secp160k1_public_key_t  key_secp160k1;    /**< @brief Holds internal representation of a public key for secp160k1 (Koblitz 160-bit). */
+    nrf_crypto_ecc_secp192k1_public_key_t  key_secp192k1;    /**< @brief Holds internal representation of a public key for secp192k1 (Koblitz 192-bit). */
+    nrf_crypto_ecc_secp224k1_public_key_t  key_secp224k1;    /**< @brief Holds internal representation of a public key for secp224k1 (Koblitz 224-bit). */
+    nrf_crypto_ecc_secp256k1_public_key_t  key_secp256k1;    /**< @brief Holds internal representation of a public key for secp256k1 (Koblitz 256-bit). */
+    nrf_crypto_ecc_bp256r1_public_key_t    key_bp256r1;      /**< @brief Holds internal representation of a public key for bp256r1 (Brainpool 256-bit). */
+    nrf_crypto_ecc_bp384r1_public_key_t    key_bp384r1;      /**< @brief Holds internal representation of a public key for bp384r1 (Brainpool 384-bit). */
+    nrf_crypto_ecc_bp512r1_public_key_t    key_bp512r1;      /**< @brief Holds internal representation of a public key for bp512r1 (Brainpool 512-bit). */
+    nrf_crypto_ecc_curve25519_public_key_t key_curve25519;   /**< @brief Holds internal representation of a public key for Curve25519. */
+    nrf_crypto_ecc_ed25519_public_key_t    key_ed25519;      /**< @brief Holds internal representation of a public key for Ed25519. */
+} nrf_crypto_ecc_public_key_t;
+
+
+/** @brief Generate a new pair of a public key and a private key.
+ *
+ *  Generated keys have to deallocated using @ref nrf_crypto_ecc_private_key_free and
+ *  @ref nrf_crypto_ecc_public_key_free.
+ *  @param[in]  p_context      Pointer to temporary structure holding context information.
+ *                             If it is NULL, necessary data will be allocated with
+ *                             @ref NRF_CRYPTO_ALLOC and freed at the end of the function.
+ *  @param[in]  p_curve_info   Pointer to information on selected curve. Use only global variables
+ *                             defined by nrf_crypto, e.g. @ref g_nrf_crypto_ecc_secp256r1_curve_info.
+ *  @param[out] p_private_key  Pointer to structure where newly generated private key will be put.
+ *  @param[out] p_public_key   Pointer to structure where newly generated public key will be put.
+ */
+ret_code_t nrf_crypto_ecc_key_pair_generate(
+    nrf_crypto_ecc_key_pair_generate_context_t       * p_context,
+    nrf_crypto_ecc_curve_info_t                const * p_curve_info,
+    nrf_crypto_ecc_private_key_t                     * p_private_key,
+    nrf_crypto_ecc_public_key_t                      * p_public_key);
+
+
+/** @brief Calculate public key associated with provided private key.
+ *
+ *  Calculated public key has to be deallocated using @ref nrf_crypto_ecc_public_key_free.
+ *  @param[in]  p_context      Pointer to temporary structure holding context information.
+ *                             If it is NULL, necessary data will be allocated with
+ *                             @ref NRF_CRYPTO_ALLOC and freed at the end of the function.
+ *  @param[in]  p_private_key  Pointer to structure holding a private key that will be used for computation.
+ *  @param[out] p_public_key   Pointer to structure where newly generated public key will be put.
+ */
+ret_code_t nrf_crypto_ecc_public_key_calculate(
+    nrf_crypto_ecc_public_key_calculate_context_t       * p_context,
+    nrf_crypto_ecc_private_key_t                  const * p_private_key,
+    nrf_crypto_ecc_public_key_t                         * p_public_key);
+
+
+/** @brief Create a private key from a raw data.
+ *
+ *  Generated private key has to be deallocated using @ref nrf_crypto_ecc_private_key_free.
+ *  @param[in]  p_curve_info   Pointer to information on selected curve. Use only global variables
+ *                             defined by nrf_crypto, e.g. @ref g_nrf_crypto_ecc_secp256r1_curve_info.
+ *  @param[out] p_private_key  Pointer to structure where newly converted private key will be put.
+ *  @param[in]  p_raw_data     Pointer to buffer containing a big endian raw data.
+ *  @param[in]  raw_data_size  Number of bytes of a raw data. Correct size for selected curve can be found in
+ *                             @p p_curve_info and it is also defined by the preprocessor definitions, e.g.
+ *                             @ref NRF_CRYPTO_ECC_SECP256R1_RAW_PRIVATE_KEY_SIZE.
+ */
+ret_code_t nrf_crypto_ecc_private_key_from_raw(
+    nrf_crypto_ecc_curve_info_t  const * p_curve_info,
+    nrf_crypto_ecc_private_key_t       * p_private_key,
+    uint8_t                      const * p_raw_data,
+    size_t                               raw_data_size);
+
+
+/** @brief Convert a private key to a raw data.
+ *
+ *  @param[in]     p_private_key    Pointer to structure holding private key that will be convert.
+ *  @param[out]    p_raw_data       Pointer to buffer containing a big endian raw data.
+ *  @param[in,out] p_raw_data_size  Maximum number of bytes that @p p_raw_data buffer can hold on input
+ *                                  and the actual number of bytes used by the raw data on output.
+ *                                  Actual size for selected curve can be found in
+ *                                  @ref nrf_crypto_ecc_curve_info_t and it is also defined by
+ *                                  the preprocessor definitions, e.g.
+ *                                  @ref NRF_CRYPTO_ECC_SECP256R1_RAW_PRIVATE_KEY_SIZE.
+ */
+ret_code_t nrf_crypto_ecc_private_key_to_raw(
+    nrf_crypto_ecc_private_key_t const * p_private_key,
+    uint8_t                            * p_raw_data,
+    size_t                             * p_raw_data_size);
+
+
+/** @brief Create a public key from a raw data.
+ *
+ *  Generated public key has to be deallocated using @ref nrf_crypto_ecc_public_key_free.
+ *  @param[in]  p_curve_info   Pointer to information on selected curve. Use only global variables
+ *                             defined by nrf_crypto, e.g. @ref g_nrf_crypto_ecc_secp256r1_curve_info.
+ *  @param[out] p_public_key   Pointer to structure where newly converted public key will be put.
+ *  @param[in]  p_raw_data     Pointer to buffer containing a big endian raw data.
+ *  @param[in]  raw_data_size  Number of bytes of a raw data. Correct size for selected curve can be found in
+ *                             @p p_curve_info and it is also defined by the preprocessor definitions, e.g.
+ *                             @ref NRF_CRYPTO_ECC_SECP256R1_RAW_PUBLIC_KEY_SIZE.
+ */
+ret_code_t nrf_crypto_ecc_public_key_from_raw(
+    nrf_crypto_ecc_curve_info_t const * p_curve_info,
+    nrf_crypto_ecc_public_key_t       * p_public_key,
+    uint8_t                     const * p_raw_data,
+    size_t                              raw_data_size);
+
+
+/** @brief Convert a public key to a raw data.
+ *
+ *  @param[in]     p_public_key     Pointer to structure holding public key that will be convert.
+ *  @param[out]    p_raw_data       Pointer to buffer containing a big endian raw data.
+ *  @param[in,out] p_raw_data_size  Maximum number of bytes that @p p_raw_data buffer can hold on input
+ *                                  and the actual number of bytes used by the raw data on output.
+ *                                  Actual size for selected curve can be found in
+ *                                  @ref nrf_crypto_ecc_curve_info_t and it is also defined by
+ *                                  the preprocessor definitions, e.g.
+ *                                  @ref NRF_CRYPTO_ECC_SECP256R1_RAW_PUBLIC_KEY_SIZE.
+ */
+ret_code_t nrf_crypto_ecc_public_key_to_raw(
+    nrf_crypto_ecc_public_key_t const * p_public_key,
+    uint8_t                           * p_raw_data,
+    size_t                            * p_raw_data_size);
+
+
+/** @brief Release resources taken by a private key.
+ *
+ *  @param[in] p_private_key   Pointer to structure holding private key to release.
+ */
+ret_code_t nrf_crypto_ecc_private_key_free(
+    nrf_crypto_ecc_private_key_t * p_private_key);
+
+
+/** @brief Release resources taken by a public key.
+ *
+ *  @param[in] p_public_key    Pointer to structure holding public key to release.
+ */
+ret_code_t nrf_crypto_ecc_public_key_free(
+    nrf_crypto_ecc_public_key_t * p_public_key);
+
+
+/** @brief Gets curve information structure from provided key (private or public).
+ *
+ *  @param[in]  p_key          Pointer to structure holding private or public key.
+ *  @param[out] pp_curve_info  Pointer to location where put retrieved pointer to curve information structure.
+ */
+ret_code_t nrf_crypto_ecc_curve_info_get(
+    void                         const * p_key,
+    nrf_crypto_ecc_curve_info_t const ** pp_curve_info);
+
+
+/** @brief Inverts byte order of a big integers contained in a raw data.
+ *
+ *  All the ECC API accepts only data with big endian integers, so this function have to be used
+ *  if little endian is required. If input is in little endian byte order it will be converted
+ *  to big endian. If input is in big endian byte order it will be converted to little endian.
+ *  It works for ECC raw private key, raw public key, signature and shared secret. If raw data
+ *  contains two big integers (e.g. R, S, or X, Y) each integer is inverted separately.
+ *  If @p p_curve_info is NULL then all bytes in buffer will be inverted regardless what is the
+ *  content of the buffer.
+ *
+ *  @param[in]  p_curve_info   Pointer to information on selected curve. Use only global variables
+ *                             defined by nrf_crypto, e.g. @ref g_nrf_crypto_ecc_secp256r1_curve_info.
+ *  @param[in]  p_raw_input    Pointer to buffer holding source data.
+ *  @param[out] p_raw_output   Pointer to buffer that will be filled with inverted byte order.
+ *                             This parameter can be the same as @p p_raw_input, otherwise the
+ *                             buffers cannot overlap.
+ *  @param[in]  raw_data_size  Size of input and output buffer.
+ */
+ret_code_t nrf_crypto_ecc_byte_order_invert(
+    nrf_crypto_ecc_curve_info_t const * p_curve_info,
+    uint8_t                     const * p_raw_input,
+    uint8_t                           * p_raw_output,
+    size_t                              raw_data_size);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+/** @}
+ *  @}
+ */
+
+#endif // NRF_CRYPTO_ECC_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_ecc_backend.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_ecc_backend.h
new file mode 100644
index 0000000..7ec1563
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_ecc_backend.h
@@ -0,0 +1,352 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef NRF_CRYPTO_ECC_BACKEND_H__
+#define NRF_CRYPTO_ECC_BACKEND_H__
+#if !defined(__SDK_DOXYGEN__)
+
+#include <stdint.h>
+#include <stddef.h>
+
+#include "sdk_config.h"
+#include "nordic_common.h"
+#include "nrf_crypto_error.h"
+#include "nrf_crypto_ecc_shared.h"
+
+// Include all backends
+#include "cc310_backend_ecc.h"
+#include "cc310_bl_backend_ecc.h"
+#include "mbedtls_backend_ecc.h"
+#include "oberon_backend_ecc.h"
+#include "micro_ecc_backend_ecc.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+// Make sure that all required defines are defined
+#if !defined(NRF_CRYPTO_ECC_SECP160R1_ENABLED)
+#define NRF_CRYPTO_ECC_SECP160R1_ENABLED 0
+#endif
+#if !defined(NRF_CRYPTO_ECC_SECP160R2_ENABLED)
+#define NRF_CRYPTO_ECC_SECP160R2_ENABLED 0
+#endif
+#if !defined(NRF_CRYPTO_ECC_SECP192R1_ENABLED)
+#define NRF_CRYPTO_ECC_SECP192R1_ENABLED 0
+#endif
+#if !defined(NRF_CRYPTO_ECC_SECP224R1_ENABLED)
+#define NRF_CRYPTO_ECC_SECP224R1_ENABLED 0
+#endif
+#if !defined(NRF_CRYPTO_ECC_SECP256R1_ENABLED)
+#define NRF_CRYPTO_ECC_SECP256R1_ENABLED 0
+#endif
+#if !defined(NRF_CRYPTO_ECC_SECP384R1_ENABLED)
+#define NRF_CRYPTO_ECC_SECP384R1_ENABLED 0
+#endif
+#if !defined(NRF_CRYPTO_ECC_SECP521R1_ENABLED)
+#define NRF_CRYPTO_ECC_SECP521R1_ENABLED 0
+#endif
+#if !defined(NRF_CRYPTO_ECC_SECP160K1_ENABLED)
+#define NRF_CRYPTO_ECC_SECP160K1_ENABLED 0
+#endif
+#if !defined(NRF_CRYPTO_ECC_SECP192K1_ENABLED)
+#define NRF_CRYPTO_ECC_SECP192K1_ENABLED 0
+#endif
+#if !defined(NRF_CRYPTO_ECC_SECP224K1_ENABLED)
+#define NRF_CRYPTO_ECC_SECP224K1_ENABLED 0
+#endif
+#if !defined(NRF_CRYPTO_ECC_SECP256K1_ENABLED)
+#define NRF_CRYPTO_ECC_SECP256K1_ENABLED 0
+#endif
+#if !defined(NRF_CRYPTO_ECC_BP256R1_ENABLED)
+#define NRF_CRYPTO_ECC_BP256R1_ENABLED 0
+#endif
+#if !defined(NRF_CRYPTO_ECC_BP384R1_ENABLED)
+#define NRF_CRYPTO_ECC_BP384R1_ENABLED 0
+#endif
+#if !defined(NRF_CRYPTO_ECC_BP512R1_ENABLED)
+#define NRF_CRYPTO_ECC_BP512R1_ENABLED 0
+#endif
+#if !defined(NRF_CRYPTO_ECC_CURVE25519_ENABLED)
+#define NRF_CRYPTO_ECC_CURVE25519_ENABLED 0
+#endif
+#if !defined(NRF_CRYPTO_ECC_ED25519_ENABLED)
+#define NRF_CRYPTO_ECC_ED25519_ENABLED 0
+#endif
+
+
+/** @internal @brief Definition to detect if ECC submodule is enabled. It will be enabled if any
+ *  curve of any of the backends is enabled.
+ */
+#define NRF_CRYPTO_ECC_ENABLED ( \
+    NRF_MODULE_ENABLED(NRF_CRYPTO) && ( \
+    NRF_CRYPTO_ECC_SECP160R1_ENABLED | \
+    NRF_CRYPTO_ECC_SECP160R2_ENABLED | \
+    NRF_CRYPTO_ECC_SECP192R1_ENABLED | \
+    NRF_CRYPTO_ECC_SECP224R1_ENABLED | \
+    NRF_CRYPTO_ECC_SECP256R1_ENABLED | \
+    NRF_CRYPTO_ECC_SECP384R1_ENABLED | \
+    NRF_CRYPTO_ECC_SECP521R1_ENABLED | \
+    NRF_CRYPTO_ECC_SECP160K1_ENABLED | \
+    NRF_CRYPTO_ECC_SECP192K1_ENABLED | \
+    NRF_CRYPTO_ECC_SECP224K1_ENABLED | \
+    NRF_CRYPTO_ECC_SECP256K1_ENABLED | \
+    NRF_CRYPTO_ECC_BP256R1_ENABLED | \
+    NRF_CRYPTO_ECC_BP384R1_ENABLED | \
+    NRF_CRYPTO_ECC_BP512R1_ENABLED | \
+    NRF_CRYPTO_ECC_CURVE25519_ENABLED | \
+    NRF_CRYPTO_ECC_ED25519_ENABLED))
+
+
+/** @internal @brief Definition containing number of enabled curves.
+ */
+#define NRF_CRYPTO_ECC_IMPLEMENTED_CURVES_COUNT ( \
+    NRF_CRYPTO_ECC_SECP160R1_ENABLED + \
+    NRF_CRYPTO_ECC_SECP160R2_ENABLED + \
+    NRF_CRYPTO_ECC_SECP192R1_ENABLED + \
+    NRF_CRYPTO_ECC_SECP224R1_ENABLED + \
+    NRF_CRYPTO_ECC_SECP256R1_ENABLED + \
+    NRF_CRYPTO_ECC_SECP384R1_ENABLED + \
+    NRF_CRYPTO_ECC_SECP521R1_ENABLED + \
+    NRF_CRYPTO_ECC_SECP160K1_ENABLED + \
+    NRF_CRYPTO_ECC_SECP192K1_ENABLED + \
+    NRF_CRYPTO_ECC_SECP224K1_ENABLED + \
+    NRF_CRYPTO_ECC_SECP256K1_ENABLED + \
+    NRF_CRYPTO_ECC_BP256R1_ENABLED + \
+    NRF_CRYPTO_ECC_BP384R1_ENABLED + \
+    NRF_CRYPTO_ECC_BP512R1_ENABLED + \
+    NRF_CRYPTO_ECC_CURVE25519_ENABLED + \
+    NRF_CRYPTO_ECC_ED25519_ENABLED)
+
+
+#if !NRF_CRYPTO_ECC_SECP160R1_ENABLED
+// Dummy typedefs for disabled contexts
+typedef uint32_t nrf_crypto_backend_secp160r1_key_pair_generate_context_t;
+typedef uint32_t nrf_crypto_backend_secp160r1_public_key_calculate_context_t;
+// Dummy typedefs for disabled keys
+typedef nrf_crypto_internal_ecc_key_header_t nrf_crypto_backend_secp160r1_private_key_t;
+typedef nrf_crypto_internal_ecc_key_header_t nrf_crypto_backend_secp160r1_public_key_t;
+#endif
+
+#if !NRF_CRYPTO_ECC_SECP160R2_ENABLED
+// Dummy typedefs for disabled contexts
+typedef uint32_t nrf_crypto_backend_secp160r2_key_pair_generate_context_t;
+typedef uint32_t nrf_crypto_backend_secp160r2_public_key_calculate_context_t;
+// Dummy typedefs for disabled keys
+typedef nrf_crypto_internal_ecc_key_header_t nrf_crypto_backend_secp160r2_private_key_t;
+typedef nrf_crypto_internal_ecc_key_header_t nrf_crypto_backend_secp160r2_public_key_t;
+#endif
+
+#if !NRF_CRYPTO_ECC_SECP192R1_ENABLED
+// Dummy typedefs for disabled contexts
+typedef uint32_t nrf_crypto_backend_secp192r1_key_pair_generate_context_t;
+typedef uint32_t nrf_crypto_backend_secp192r1_public_key_calculate_context_t;
+// Dummy typedefs for disabled keys
+typedef nrf_crypto_internal_ecc_key_header_t nrf_crypto_backend_secp192r1_private_key_t;
+typedef nrf_crypto_internal_ecc_key_header_t nrf_crypto_backend_secp192r1_public_key_t;
+#endif
+
+#if !NRF_CRYPTO_ECC_SECP224R1_ENABLED
+// Dummy typedefs for disabled contexts
+typedef uint32_t nrf_crypto_backend_secp224r1_key_pair_generate_context_t;
+typedef uint32_t nrf_crypto_backend_secp224r1_public_key_calculate_context_t;
+// Dummy typedefs for disabled keys
+typedef nrf_crypto_internal_ecc_key_header_t nrf_crypto_backend_secp224r1_private_key_t;
+typedef nrf_crypto_internal_ecc_key_header_t nrf_crypto_backend_secp224r1_public_key_t;
+#endif
+
+#if !NRF_CRYPTO_ECC_SECP256R1_ENABLED
+// Dummy typedefs for disabled contexts
+typedef uint32_t nrf_crypto_backend_secp256r1_key_pair_generate_context_t;
+typedef uint32_t nrf_crypto_backend_secp256r1_public_key_calculate_context_t;
+// Dummy typedefs for disabled keys
+typedef nrf_crypto_internal_ecc_key_header_t nrf_crypto_backend_secp256r1_private_key_t;
+typedef nrf_crypto_internal_ecc_key_header_t nrf_crypto_backend_secp256r1_public_key_t;
+#endif
+
+#if !NRF_CRYPTO_ECC_SECP384R1_ENABLED
+// Dummy typedefs for disabled contexts
+typedef uint32_t nrf_crypto_backend_secp384r1_key_pair_generate_context_t;
+typedef uint32_t nrf_crypto_backend_secp384r1_public_key_calculate_context_t;
+// Dummy typedefs for disabled keys
+typedef nrf_crypto_internal_ecc_key_header_t nrf_crypto_backend_secp384r1_private_key_t;
+typedef nrf_crypto_internal_ecc_key_header_t nrf_crypto_backend_secp384r1_public_key_t;
+#endif
+
+#if !NRF_CRYPTO_ECC_SECP521R1_ENABLED
+// Dummy typedefs for disabled contexts
+typedef uint32_t nrf_crypto_backend_secp521r1_key_pair_generate_context_t;
+typedef uint32_t nrf_crypto_backend_secp521r1_public_key_calculate_context_t;
+// Dummy typedefs for disabled keys
+typedef nrf_crypto_internal_ecc_key_header_t nrf_crypto_backend_secp521r1_private_key_t;
+typedef nrf_crypto_internal_ecc_key_header_t nrf_crypto_backend_secp521r1_public_key_t;
+#endif
+
+#if !NRF_CRYPTO_ECC_SECP160K1_ENABLED
+// Dummy typedefs for disabled contexts
+typedef uint32_t nrf_crypto_backend_secp160k1_key_pair_generate_context_t;
+typedef uint32_t nrf_crypto_backend_secp160k1_public_key_calculate_context_t;
+// Dummy typedefs for disabled keys
+typedef nrf_crypto_internal_ecc_key_header_t nrf_crypto_backend_secp160k1_private_key_t;
+typedef nrf_crypto_internal_ecc_key_header_t nrf_crypto_backend_secp160k1_public_key_t;
+#endif
+
+#if !NRF_CRYPTO_ECC_SECP192K1_ENABLED
+// Dummy typedefs for disabled contexts
+typedef uint32_t nrf_crypto_backend_secp192k1_key_pair_generate_context_t;
+typedef uint32_t nrf_crypto_backend_secp192k1_public_key_calculate_context_t;
+// Dummy typedefs for disabled keys
+typedef nrf_crypto_internal_ecc_key_header_t nrf_crypto_backend_secp192k1_private_key_t;
+typedef nrf_crypto_internal_ecc_key_header_t nrf_crypto_backend_secp192k1_public_key_t;
+#endif
+
+#if !NRF_CRYPTO_ECC_SECP224K1_ENABLED
+// Dummy typedefs for disabled contexts
+typedef uint32_t nrf_crypto_backend_secp224k1_key_pair_generate_context_t;
+typedef uint32_t nrf_crypto_backend_secp224k1_public_key_calculate_context_t;
+// Dummy typedefs for disabled keys
+typedef nrf_crypto_internal_ecc_key_header_t nrf_crypto_backend_secp224k1_private_key_t;
+typedef nrf_crypto_internal_ecc_key_header_t nrf_crypto_backend_secp224k1_public_key_t;
+#endif
+
+#if !NRF_CRYPTO_ECC_SECP256K1_ENABLED
+// Dummy typedefs for disabled contexts
+typedef uint32_t nrf_crypto_backend_secp256k1_key_pair_generate_context_t;
+typedef uint32_t nrf_crypto_backend_secp256k1_public_key_calculate_context_t;
+// Dummy typedefs for disabled keys
+typedef nrf_crypto_internal_ecc_key_header_t nrf_crypto_backend_secp256k1_private_key_t;
+typedef nrf_crypto_internal_ecc_key_header_t nrf_crypto_backend_secp256k1_public_key_t;
+#endif
+
+#if !NRF_CRYPTO_ECC_BP256R1_ENABLED
+// Dummy typedefs for disabled contexts
+typedef uint32_t nrf_crypto_backend_bp256r1_key_pair_generate_context_t;
+typedef uint32_t nrf_crypto_backend_bp256r1_public_key_calculate_context_t;
+// Dummy typedefs for disabled keys
+typedef nrf_crypto_internal_ecc_key_header_t nrf_crypto_backend_bp256r1_private_key_t;
+typedef nrf_crypto_internal_ecc_key_header_t nrf_crypto_backend_bp256r1_public_key_t;
+#endif
+
+#if !NRF_CRYPTO_ECC_BP384R1_ENABLED
+// Dummy typedefs for disabled contexts
+typedef uint32_t nrf_crypto_backend_bp384r1_key_pair_generate_context_t;
+typedef uint32_t nrf_crypto_backend_bp384r1_public_key_calculate_context_t;
+// Dummy typedefs for disabled keys
+typedef nrf_crypto_internal_ecc_key_header_t nrf_crypto_backend_bp384r1_private_key_t;
+typedef nrf_crypto_internal_ecc_key_header_t nrf_crypto_backend_bp384r1_public_key_t;
+#endif
+
+#if !NRF_CRYPTO_ECC_BP512R1_ENABLED
+// Dummy typedefs for disabled contexts
+typedef uint32_t nrf_crypto_backend_bp512r1_key_pair_generate_context_t;
+typedef uint32_t nrf_crypto_backend_bp512r1_public_key_calculate_context_t;
+// Dummy typedefs for disabled keys
+typedef nrf_crypto_internal_ecc_key_header_t nrf_crypto_backend_bp512r1_private_key_t;
+typedef nrf_crypto_internal_ecc_key_header_t nrf_crypto_backend_bp512r1_public_key_t;
+#endif
+
+#if !NRF_CRYPTO_ECC_CURVE25519_ENABLED
+// Dummy typedefs for disabled contexts
+typedef uint32_t nrf_crypto_backend_curve25519_key_pair_generate_context_t;
+typedef uint32_t nrf_crypto_backend_curve25519_public_key_calculate_context_t;
+// Dummy typedefs for disabled keys
+typedef nrf_crypto_internal_ecc_key_header_t nrf_crypto_backend_curve25519_private_key_t;
+typedef nrf_crypto_internal_ecc_key_header_t nrf_crypto_backend_curve25519_public_key_t;
+#endif
+
+#if !NRF_CRYPTO_ECC_ED25519_ENABLED
+// Dummy typedefs for disabled contexts
+typedef uint32_t nrf_crypto_backend_ed25519_key_pair_generate_context_t;
+typedef uint32_t nrf_crypto_backend_ed25519_public_key_calculate_context_t;
+// Dummy typedefs for disabled keys
+typedef nrf_crypto_internal_ecc_key_header_t nrf_crypto_backend_ed25519_private_key_t;
+typedef nrf_crypto_internal_ecc_key_header_t nrf_crypto_backend_ed25519_public_key_t;
+#endif
+
+
+// Find biggest raw private and public key size that is currently enabled
+#if NRF_CRYPTO_ECC_SECP521R1_ENABLED
+#   define NRF_CRYPTO_BACKEND_ECC_RAW_PRIVATE_KEY_MAX_SIZE (66)
+#elif NRF_CRYPTO_ECC_BP512R1_ENABLED
+#   define NRF_CRYPTO_BACKEND_ECC_RAW_PRIVATE_KEY_MAX_SIZE (64)
+#elif NRF_CRYPTO_ECC_BP384R1_ENABLED || NRF_CRYPTO_ECC_SECP384R1_ENABLED
+#   define NRF_CRYPTO_BACKEND_ECC_RAW_PRIVATE_KEY_MAX_SIZE (48)
+#elif NRF_CRYPTO_ECC_BP256R1_ENABLED || NRF_CRYPTO_ECC_SECP256K1_ENABLED || NRF_CRYPTO_ECC_CURVE25519_ENABLED || NRF_CRYPTO_ECC_ED25519_ENABLED || NRF_CRYPTO_ECC_SECP256R1_ENABLED
+#   define NRF_CRYPTO_BACKEND_ECC_RAW_PRIVATE_KEY_MAX_SIZE (32)
+#elif NRF_CRYPTO_ECC_SECP224K1_ENABLED || NRF_CRYPTO_ECC_SECP224R1_ENABLED
+#   define NRF_CRYPTO_BACKEND_ECC_RAW_PRIVATE_KEY_MAX_SIZE (28)
+#elif NRF_CRYPTO_ECC_SECP192K1_ENABLED || NRF_CRYPTO_ECC_SECP192R1_ENABLED
+#   define NRF_CRYPTO_BACKEND_ECC_RAW_PRIVATE_KEY_MAX_SIZE (24)
+#elif NRF_CRYPTO_ECC_SECP160K1_ENABLED || NRF_CRYPTO_ECC_SECP160R1_ENABLED || NRF_CRYPTO_ECC_SECP160R2_ENABLED
+#   define NRF_CRYPTO_BACKEND_ECC_RAW_PRIVATE_KEY_MAX_SIZE (20)
+#else
+#   define NRF_CRYPTO_BACKEND_ECC_RAW_PRIVATE_KEY_MAX_SIZE (1)
+#endif
+
+#if NRF_CRYPTO_ECC_SECP521R1_ENABLED
+#   define NRF_CRYPTO_BACKEND_ECC_RAW_PUBLIC_KEY_MAX_SIZE (2 * 66)
+#elif NRF_CRYPTO_ECC_BP512R1_ENABLED
+#   define NRF_CRYPTO_BACKEND_ECC_RAW_PUBLIC_KEY_MAX_SIZE (2 * 64)
+#elif NRF_CRYPTO_ECC_BP384R1_ENABLED || NRF_CRYPTO_ECC_SECP384R1_ENABLED
+#   define NRF_CRYPTO_BACKEND_ECC_RAW_PUBLIC_KEY_MAX_SIZE (2 * 48)
+#elif NRF_CRYPTO_ECC_BP256R1_ENABLED || NRF_CRYPTO_ECC_SECP256K1_ENABLED || NRF_CRYPTO_ECC_SECP256R1_ENABLED
+#   define NRF_CRYPTO_BACKEND_ECC_RAW_PUBLIC_KEY_MAX_SIZE (2 * 32)
+#elif NRF_CRYPTO_ECC_SECP224K1_ENABLED || NRF_CRYPTO_ECC_SECP224R1_ENABLED
+#   define NRF_CRYPTO_BACKEND_ECC_RAW_PUBLIC_KEY_MAX_SIZE (2 * 28)
+#elif NRF_CRYPTO_ECC_SECP192K1_ENABLED || NRF_CRYPTO_ECC_SECP192R1_ENABLED
+#   define NRF_CRYPTO_BACKEND_ECC_RAW_PUBLIC_KEY_MAX_SIZE (2 * 24)
+#elif NRF_CRYPTO_ECC_SECP160K1_ENABLED || NRF_CRYPTO_ECC_SECP160R1_ENABLED || NRF_CRYPTO_ECC_SECP160R2_ENABLED
+#   define NRF_CRYPTO_BACKEND_ECC_RAW_PUBLIC_KEY_MAX_SIZE (2 * 20)
+#elif NRF_CRYPTO_ECC_CURVE25519_ENABLED || NRF_CRYPTO_ECC_ED25519_ENABLED
+#   define NRF_CRYPTO_BACKEND_ECC_RAW_PUBLIC_KEY_MAX_SIZE (32)
+#else
+#   define NRF_CRYPTO_BACKEND_ECC_RAW_PUBLIC_KEY_MAX_SIZE (1)
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif // !defined(__SDK_DOXYGEN__)
+#endif // NRF_CRYPTO_ECC_BACKEND_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_ecc_shared.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_ecc_shared.h
new file mode 100644
index 0000000..33fd37f
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_ecc_shared.h
@@ -0,0 +1,229 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef NRF_CRYPTO_ECC_SHARED_H__
+#define NRF_CRYPTO_ECC_SHARED_H__
+#if !defined(__SDK_DOXYGEN__)
+
+#include <stdint.h>
+#include <stddef.h>
+#include <stdbool.h>
+
+#include "sdk_errors.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#define NRF_CRYPTO_INTERNAL_ECC_PRIVATE_KEY_INIT_VALUE (0x4D465276) /**< @internal @brief Init value for all ECC private keys. ASCII "nRFv". */
+#define NRF_CRYPTO_INTERNAL_ECC_PUBLIC_KEY_INIT_VALUE  (0x4D465270) /**< @internal @brief Init value for all ECC public keys. ASCII "nRFp". */
+
+
+// Forward declaration only
+struct nrf_crypto_ecc_curve_info_s;
+
+
+/** @brief Header structure at the beginning of each key structure.
+ */
+typedef struct
+{
+    uint32_t                                   init_value;    /**< @internal @brief Init value to check if key was correctly initialized. */
+    struct nrf_crypto_ecc_curve_info_s const * p_info;        /**< @internal @brief Points to information structure of an associated curve type. */
+} nrf_crypto_internal_ecc_key_header_t;
+
+
+/** @internal @brief Function pointer for backend implementation of a key pair garatarion.
+ *
+ * @note All parameters provided to the backend are vefified in frontend. Verification includes
+ * checking of NULL pointers, buffer size, initialization values. Front end also take full care of
+ * common ECC key hearder @ref nrf_crypto_internal_ecc_key_header_t.
+ *
+ * @param[in]  p_context      Pointer to context.
+ * @param[out] p_private_key  Pointer where to put new private key.
+ * @param[out] p_public_key   Pointer where to put new public key.
+ */
+typedef ret_code_t (*nrf_crypto_backend_ecc_key_pair_generate_fn_t)(
+    void * p_context,
+    void * p_private_key,
+    void * p_public_key);
+
+
+/** @internal @brief Function pointer for backend implementation of a public key calculation.
+ *
+ * @note All parameters provided to the backend are vefified in frontend. Verification includes
+ * checking of NULL pointers, buffer size, initialization values. Front end also take full care of
+ * common ECC key hearder @ref nrf_crypto_internal_ecc_key_header_t.
+ *
+ * @param[in]  p_context      Pointer to context.
+ * @param[in]  p_private_key  Pointer to private key.
+ * @param[out] p_public_key   Pointer where to put new public key.
+ */
+typedef ret_code_t (*nrf_crypto_backend_ecc_public_key_calculate_fn_t)(
+    void       * p_context,
+    void const * p_private_key,
+    void       * p_public_key);
+
+
+/** @internal @brief Function pointer for backend implementation of raw to private key conversion.
+ *
+ * @note All parameters provided to the backend are vefified in frontend. Verification includes
+ * checking of NULL pointers, buffer size, initialization values. Front end also take full care of
+ * common ECC key hearder @ref nrf_crypto_internal_ecc_key_header_t.
+ *
+ * @param[out] p_private_key  Pointer where to put new private key.
+ * @param[in]  p_raw_data     Pointer to raw data.
+ */
+typedef ret_code_t (*nrf_crypto_backend_ecc_private_key_from_raw_fn_t)(
+    void          * p_private_key,
+    uint8_t const * p_raw_data);
+
+
+/** @internal @brief Function pointer for backend implementation of private key to raw conversion.
+ *
+ * @note All parameters provided to the backend are vefified in frontend. Verification includes
+ * checking of NULL pointers, buffer size, initialization values. Front end also take full care of
+ * common ECC key hearder @ref nrf_crypto_internal_ecc_key_header_t.
+ *
+ * @param[in]  p_private_key  Pointer to private key.
+ * @param[out] p_raw_data     Pointer where to put raw data.
+ */
+typedef ret_code_t (*nrf_crypto_backend_ecc_private_key_to_raw_fn_t)(
+    void    const * p_private_key,
+    uint8_t       * p_raw_data);
+
+
+/** @internal @brief Function pointer for backend implementation of raw to public key conversion.
+ *
+ * @note All parameters provided to the backend are vefified in frontend. Verification includes
+ * checking of NULL pointers, buffer size, initialization values. Front end also take full care of
+ * common ECC key hearder @ref nrf_crypto_internal_ecc_key_header_t.
+ *
+ * @param[out] p_public_key  Pointer where to put new public key.
+ * @param[in]  p_raw_data    Pointer to raw data.
+ */
+typedef ret_code_t (*nrf_crypto_backend_ecc_public_key_from_raw_fn_t)(
+    void          * p_public_key,
+    uint8_t const * p_raw_data);
+
+
+/** @internal @brief Function pointer for backend implementation of public key to raw conversion.
+ *
+ * @note All parameters provided to the backend are vefified in frontend. Verification includes
+ * checking of NULL pointers, buffer size, initialization values. Front end also take full care of
+ * common ECC key hearder @ref nrf_crypto_internal_ecc_key_header_t.
+ *
+ * @param[in]  p_public_key  Pointer to public key.
+ * @param[out] p_raw_data    Pointer where to put raw data.
+ */
+typedef ret_code_t (*nrf_crypto_backend_ecc_public_key_to_raw_fn_t)(
+    void    const * p_public_key,
+    uint8_t       * p_raw_data);
+
+
+/** @internal @brief Function pointer for backend implementation of key (public or private) deallocation.
+ *
+ * @note All parameters provided to the backend are vefified in frontend. Verification includes
+ * checking of NULL pointers, buffer size, initialization values. Front end also take full care of
+ * common ECC key hearder @ref nrf_crypto_internal_ecc_key_header_t.
+ *
+ * @param[in]  p_key  Pointer to public or private key.
+ */
+typedef ret_code_t (*nrf_crypto_backend_ecc_key_free_fn_t)(
+    void * p_key);
+
+
+/** @internal @brief Function for checking and preparing ECC key output parameter.
+ *
+ * @param[in]  p_curve_info  Curve info provided by user that will be used to create a new key.
+ * @param[out] p_key_header  Key header that have to be prepared.
+ * @return                   NRF_SUCCESS if parameters are valid, error otherwise.
+ */
+ret_code_t nrf_crypto_internal_ecc_key_output_prepare(
+    struct nrf_crypto_ecc_curve_info_s   const * p_curve_info,
+    nrf_crypto_internal_ecc_key_header_t       * p_key_header);
+
+
+/** @internal @brief Function for checking ECC key input parameter.
+ *
+ * @param[in] p_key_header Key header that have to be checked.
+ * @param[in] init_value   Expected init value in this key.
+ * @return                 NRF_SUCCESS if parameter is valid, error otherwise.
+ */
+ret_code_t nrf_crypto_internal_ecc_key_input_check(
+    nrf_crypto_internal_ecc_key_header_t const * p_key_header,
+    uint32_t                                     init_value);
+
+
+/** @internal @brief Function for checking and preparing raw data output parameter.
+ *
+ * @param[out]    p_raw_data      Buffer where output will be written.
+ * @param[in,out] p_raw_data_size Pointer to size of the data. On input this is size of provided by
+ *                                the user buffer. On output is equal @p expected_size. This pointer
+ *                                can be NULL if used does not want to do size checking.
+ * @param[in]     expected_size   Size of output data that will be written to the buffer.
+ * @return                        NRF_SUCCESS if parameters are valid, error otherwise.
+ */
+ret_code_t nrf_crypto_internal_ecc_raw_output_prepare(
+    uint8_t    * p_raw_data,
+    size_t     * p_raw_data_size,
+    size_t       expected_size);
+
+
+/** @internal @brief Function for checking raw data input parameter.
+ *
+ * @param[in] p_raw_data     Buffer where data is located.
+ * @param[in] raw_data_size  Size of the data.Function will fail if it is different than @p expected_size.
+ * @param[in] expected_size  Expected size of the data.
+ * @return                   NRF_SUCCESS if parameters are valid, error otherwise.
+ */
+ret_code_t nrf_crypto_internal_ecc_raw_input_check(
+    uint8_t const * p_raw_data,
+    size_t          raw_data_size,
+    size_t          expected_size);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // !defined(__SDK_DOXYGEN__)
+#endif // NRF_CRYPTO_ECC_SHARED_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_ecdh.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_ecdh.c
new file mode 100644
index 0000000..3d7d798
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_ecdh.c
@@ -0,0 +1,286 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#include "nrf_crypto_error.h"
+#include "nrf_crypto_mem.h"
+#include "nrf_crypto_ecc.h"
+#include "nrf_crypto_ecdh.h"
+#include "app_util.h"
+#include "sdk_macros.h"
+
+
+#if NRF_CRYPTO_ECC_ENABLED
+
+
+#if NRF_CRYPTO_ECC_IMPLEMENTED_CURVES_COUNT > 1
+
+
+static const nrf_crypto_backend_ecdh_compute_fn_t compute_impl[] =
+{
+#if NRF_CRYPTO_ECC_SECP160R1_ENABLED
+    nrf_crypto_backend_secp160r1_ecdh_compute,
+#endif
+#if NRF_CRYPTO_ECC_SECP160R2_ENABLED
+    nrf_crypto_backend_secp160r2_ecdh_compute,
+#endif
+#if NRF_CRYPTO_ECC_SECP192R1_ENABLED
+    nrf_crypto_backend_secp192r1_ecdh_compute,
+#endif
+#if NRF_CRYPTO_ECC_SECP224R1_ENABLED
+    nrf_crypto_backend_secp224r1_ecdh_compute,
+#endif
+#if NRF_CRYPTO_ECC_SECP256R1_ENABLED
+    nrf_crypto_backend_secp256r1_ecdh_compute,
+#endif
+#if NRF_CRYPTO_ECC_SECP384R1_ENABLED
+    nrf_crypto_backend_secp384r1_ecdh_compute,
+#endif
+#if NRF_CRYPTO_ECC_SECP521R1_ENABLED
+    nrf_crypto_backend_secp521r1_ecdh_compute,
+#endif
+#if NRF_CRYPTO_ECC_SECP160K1_ENABLED
+    nrf_crypto_backend_secp160k1_ecdh_compute,
+#endif
+#if NRF_CRYPTO_ECC_SECP192K1_ENABLED
+    nrf_crypto_backend_secp192k1_ecdh_compute,
+#endif
+#if NRF_CRYPTO_ECC_SECP224K1_ENABLED
+    nrf_crypto_backend_secp224k1_ecdh_compute,
+#endif
+#if NRF_CRYPTO_ECC_SECP256K1_ENABLED
+    nrf_crypto_backend_secp256k1_ecdh_compute,
+#endif
+#if NRF_CRYPTO_ECC_BP256R1_ENABLED
+    nrf_crypto_backend_bp256r1_ecdh_compute,
+#endif
+#if NRF_CRYPTO_ECC_BP384R1_ENABLED
+    nrf_crypto_backend_bp384r1_ecdh_compute,
+#endif
+#if NRF_CRYPTO_ECC_BP512R1_ENABLED
+    nrf_crypto_backend_bp512r1_ecdh_compute,
+#endif
+#if NRF_CRYPTO_ECC_CURVE25519_ENABLED
+    nrf_crypto_backend_curve25519_ecdh_compute,
+#endif
+#if NRF_CRYPTO_ECC_ED25519_ENABLED
+    nrf_crypto_backend_ed25519_ecdh_compute,
+#endif
+};
+
+
+static const uint16_t compute_impl_context_size[] =
+{
+#if NRF_CRYPTO_ECC_SECP160R1_ENABLED
+    NRF_CRYPTO_BACKEND_SECP160R1_ECDH_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_SECP160R2_ENABLED
+    NRF_CRYPTO_BACKEND_SECP160R2_ECDH_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_SECP192R1_ENABLED
+    NRF_CRYPTO_BACKEND_SECP192R1_ECDH_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_SECP224R1_ENABLED
+    NRF_CRYPTO_BACKEND_SECP224R1_ECDH_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_SECP256R1_ENABLED
+    NRF_CRYPTO_BACKEND_SECP256R1_ECDH_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_SECP384R1_ENABLED
+    NRF_CRYPTO_BACKEND_SECP384R1_ECDH_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_SECP521R1_ENABLED
+    NRF_CRYPTO_BACKEND_SECP521R1_ECDH_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_SECP160K1_ENABLED
+    NRF_CRYPTO_BACKEND_SECP160K1_ECDH_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_SECP192K1_ENABLED
+    NRF_CRYPTO_BACKEND_SECP192K1_ECDH_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_SECP224K1_ENABLED
+    NRF_CRYPTO_BACKEND_SECP224K1_ECDH_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_SECP256K1_ENABLED
+    NRF_CRYPTO_BACKEND_SECP256K1_ECDH_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_BP256R1_ENABLED
+    NRF_CRYPTO_BACKEND_BP256R1_ECDH_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_BP384R1_ENABLED
+    NRF_CRYPTO_BACKEND_BP384R1_ECDH_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_BP512R1_ENABLED
+    NRF_CRYPTO_BACKEND_BP512R1_ECDH_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_CURVE25519_ENABLED
+    NRF_CRYPTO_BACKEND_CURVE25519_ECDH_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_ED25519_ENABLED
+    NRF_CRYPTO_BACKEND_ED25519_ECDH_CONTEXT_SIZE,
+#endif
+};
+
+#define BACKEND_IMPL_GET(table, curve_type) (table)[(uint32_t)(curve_type)]
+
+#else
+
+
+#if NRF_CRYPTO_ECC_SECP160R1_ENABLED
+#define compute_impl              nrf_crypto_backend_secp160r1_ecdh_compute
+#define compute_impl_context_size NRF_CRYPTO_BACKEND_SECP160R1_ECDH_CONTEXT_SIZE
+#elif NRF_CRYPTO_ECC_SECP160R2_ENABLED
+#define compute_impl              nrf_crypto_backend_secp160r2_ecdh_compute
+#define compute_impl_context_size NRF_CRYPTO_BACKEND_SECP160R2_ECDH_CONTEXT_SIZE
+#elif NRF_CRYPTO_ECC_SECP192R1_ENABLED
+#define compute_impl              nrf_crypto_backend_secp192r1_ecdh_compute
+#define compute_impl_context_size NRF_CRYPTO_BACKEND_SECP192R1_ECDH_CONTEXT_SIZE
+#elif NRF_CRYPTO_ECC_SECP224R1_ENABLED
+#define compute_impl              nrf_crypto_backend_secp224r1_ecdh_compute
+#define compute_impl_context_size NRF_CRYPTO_BACKEND_SECP224R1_ECDH_CONTEXT_SIZE
+#elif NRF_CRYPTO_ECC_SECP256R1_ENABLED
+#define compute_impl              nrf_crypto_backend_secp256r1_ecdh_compute
+#define compute_impl_context_size NRF_CRYPTO_BACKEND_SECP256R1_ECDH_CONTEXT_SIZE
+#elif NRF_CRYPTO_ECC_SECP384R1_ENABLED
+#define compute_impl              nrf_crypto_backend_secp384r1_ecdh_compute
+#define compute_impl_context_size NRF_CRYPTO_BACKEND_SECP384R1_ECDH_CONTEXT_SIZE
+#elif NRF_CRYPTO_ECC_SECP521R1_ENABLED
+#define compute_impl              nrf_crypto_backend_secp521r1_ecdh_compute
+#define compute_impl_context_size NRF_CRYPTO_BACKEND_SECP521R1_ECDH_CONTEXT_SIZE
+#elif NRF_CRYPTO_ECC_SECP160K1_ENABLED
+#define compute_impl              nrf_crypto_backend_secp160k1_ecdh_compute
+#define compute_impl_context_size NRF_CRYPTO_BACKEND_SECP160K1_ECDH_CONTEXT_SIZE
+#elif NRF_CRYPTO_ECC_SECP192K1_ENABLED
+#define compute_impl              nrf_crypto_backend_secp192k1_ecdh_compute
+#define compute_impl_context_size NRF_CRYPTO_BACKEND_SECP192K1_ECDH_CONTEXT_SIZE
+#elif NRF_CRYPTO_ECC_SECP224K1_ENABLED
+#define compute_impl              nrf_crypto_backend_secp224k1_ecdh_compute
+#define compute_impl_context_size NRF_CRYPTO_BACKEND_SECP224K1_ECDH_CONTEXT_SIZE
+#elif NRF_CRYPTO_ECC_SECP256K1_ENABLED
+#define compute_impl              nrf_crypto_backend_secp256k1_ecdh_compute
+#define compute_impl_context_size NRF_CRYPTO_BACKEND_SECP256K1_ECDH_CONTEXT_SIZE
+#elif NRF_CRYPTO_ECC_BP256R1_ENABLED
+#define compute_impl              nrf_crypto_backend_bp256r1_ecdh_compute
+#define compute_impl_context_size NRF_CRYPTO_BACKEND_BP256R1_ECDH_CONTEXT_SIZE
+#elif NRF_CRYPTO_ECC_BP384R1_ENABLED
+#define compute_impl              nrf_crypto_backend_bp384r1_ecdh_compute
+#define compute_impl_context_size NRF_CRYPTO_BACKEND_BP384R1_ECDH_CONTEXT_SIZE
+#elif NRF_CRYPTO_ECC_BP512R1_ENABLED
+#define compute_impl              nrf_crypto_backend_bp512r1_ecdh_compute
+#define compute_impl_context_size NRF_CRYPTO_BACKEND_BP512R1_ECDH_CONTEXT_SIZE
+#elif NRF_CRYPTO_ECC_CURVE25519_ENABLED
+#define compute_impl              nrf_crypto_backend_curve25519_ecdh_compute
+#define compute_impl_context_size NRF_CRYPTO_BACKEND_CURVE25519_ECDH_CONTEXT_SIZE
+#elif NRF_CRYPTO_ECC_ED25519_ENABLED
+#define compute_impl              nrf_crypto_backend_ed25519_ecdh_compute
+#define compute_impl_context_size NRF_CRYPTO_BACKEND_ED25519_ECDH_CONTEXT_SIZE
+#else
+#define compute_impl              NULL
+#define compute_impl_context_size 0
+#endif
+
+#define BACKEND_IMPL_GET(function, curve_type) (function)
+
+#endif
+
+
+ret_code_t nrf_crypto_ecdh_compute(
+    nrf_crypto_ecdh_context_t          * p_context,
+    nrf_crypto_ecc_private_key_t const * p_private_key,
+    nrf_crypto_ecc_public_key_t  const * p_public_key,
+    uint8_t                            * p_shared_secret,
+    size_t                             * p_shared_secret_size)
+{
+    ret_code_t                             result;
+    void                                 * p_allocated_context    = NULL;
+    nrf_crypto_backend_ecdh_compute_fn_t   backend_implementation;
+    size_t                                 context_size;
+    nrf_crypto_ecc_curve_info_t    const * p_info;
+
+    // Get pointer to header for each key
+    nrf_crypto_internal_ecc_key_header_t const * p_private_key_header =
+        (nrf_crypto_internal_ecc_key_header_t const *)p_private_key;
+    nrf_crypto_internal_ecc_key_header_t const * p_public_key_header =
+        (nrf_crypto_internal_ecc_key_header_t const *)p_public_key;
+
+    // Check and prepare parameters
+    result = nrf_crypto_internal_ecc_key_input_check(
+        p_private_key_header,
+        NRF_CRYPTO_INTERNAL_ECC_PRIVATE_KEY_INIT_VALUE);
+    VERIFY_SUCCESS(result);
+    result = nrf_crypto_internal_ecc_key_input_check(
+        p_public_key_header,
+        NRF_CRYPTO_INTERNAL_ECC_PUBLIC_KEY_INIT_VALUE);
+    VERIFY_SUCCESS(result);
+    VERIFY_TRUE(p_private_key_header->p_info == p_public_key_header->p_info,
+                NRF_ERROR_CRYPTO_ECDH_CURVE_MISMATCH);
+    p_info = p_private_key_header->p_info;
+    result = nrf_crypto_internal_ecc_raw_output_prepare(
+               p_shared_secret,
+               p_shared_secret_size,
+               p_info->raw_private_key_size);
+    VERIFY_SUCCESS(result);
+
+    // Get backend specific information
+    backend_implementation = BACKEND_IMPL_GET(compute_impl, p_info->curve_type);
+    context_size = BACKEND_IMPL_GET(compute_impl_context_size, p_info->curve_type);
+    VERIFY_TRUE(backend_implementation != NULL, NRF_ERROR_CRYPTO_FEATURE_UNAVAILABLE);
+
+    // Allocate context if not provided
+    if (p_context == NULL && context_size > 0)
+    {
+        p_allocated_context = NRF_CRYPTO_ALLOC(context_size);
+        VERIFY_TRUE(p_allocated_context != NULL, NRF_ERROR_CRYPTO_ALLOC_FAILED);
+        p_context = p_allocated_context;
+    }
+
+    // Execute backend implementation
+    result = backend_implementation(p_context, p_private_key, p_public_key, p_shared_secret);
+
+    // Deallocate context if allocated
+    if (p_allocated_context != NULL)
+    {
+        NRF_CRYPTO_FREE(p_allocated_context);
+    }
+
+    return result;
+}
+
+
+#endif // NRF_CRYPTO_ECC_ENABLED
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_ecdh.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_ecdh.h
new file mode 100644
index 0000000..7b177ef
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_ecdh.h
@@ -0,0 +1,207 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef NRF_CRYPTO_ECDH_H__
+#define NRF_CRYPTO_ECDH_H__
+
+/** @addtogroup nrf_crypto
+ *  @{
+ *  @addtogroup nrf_crypto_ecdh Elliptic Curve Diffie-Hellman (ECDH)
+ *  @{
+ *  @brief Provides elliptic curve cryptography functions for Diffie-Hellman shared secret exchange.
+ *
+ *  @addtogroup nrf_crypto_ecdh_secp160r1   Definitions specific to secp160r1 (NIST 160-bit)
+ *  @addtogroup nrf_crypto_ecdh_secp160r2   Definitions specific to secp160r2 (NIST 160-bit)
+ *  @addtogroup nrf_crypto_ecdh_secp192r1   Definitions specific to secp192r1 (NIST 192-bit)
+ *  @addtogroup nrf_crypto_ecdh_secp224r1   Definitions specific to secp224r1 (NIST 224-bit)
+ *  @addtogroup nrf_crypto_ecdh_secp256r1   Definitions specific to secp256r1 (NIST 256-bit)
+ *  @addtogroup nrf_crypto_ecdh_secp384r1   Definitions specific to secp384r1 (NIST 384-bit)
+ *  @addtogroup nrf_crypto_ecdh_secp521r1   Definitions specific to secp521r1 (NIST 521-bit)
+ *  @addtogroup nrf_crypto_ecdh_secp160k1   Definitions specific to secp160k1 (Koblitz 160-bit)
+ *  @addtogroup nrf_crypto_ecdh_secp192k1   Definitions specific to secp192k1 (Koblitz 192-bit)
+ *  @addtogroup nrf_crypto_ecdh_secp224k1   Definitions specific to secp224k1 (Koblitz 224-bit)
+ *  @addtogroup nrf_crypto_ecdh_secp256k1   Definitions specific to secp256k1 (Koblitz 256-bit)
+ *  @addtogroup nrf_crypto_ecdh_bp256r1     Definitions specific to bp256r1 (Brainpool 256-bit)
+ *  @addtogroup nrf_crypto_ecdh_bp384r1     Definitions specific to bp384r1 (Brainpool 384-bit)
+ *  @addtogroup nrf_crypto_ecdh_bp512r1     Definitions specific to bp512r1 (Brainpool 512-bit)
+ *  @addtogroup nrf_crypto_ecdh_curve25519  Definitions specific to Curve25519
+ *  @addtogroup nrf_crypto_ecdh_ed25519     Definitions specific to Ed25519
+ */
+
+#include <stdint.h>
+#include <stddef.h>
+
+#include "nrf_crypto_error.h"
+#include "nrf_crypto_ecc.h"
+#include "nrf_crypto_ecdh_shared.h"
+#include "nrf_crypto_ecdh_backend.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#define NRF_CRYPTO_ECDH_SECP160R1_SHARED_SECRET_SIZE  (160 / 8)   /**< @brief Number of bytes in a shared secret using secp160r1 (NIST 160-bit).     @ingroup nrf_crypto_ecdh_secp160r1 */
+#define NRF_CRYPTO_ECDH_SECP160R2_SHARED_SECRET_SIZE  (160 / 8)   /**< @brief Number of bytes in a shared secret using secp160r2 (NIST 160-bit).     @ingroup nrf_crypto_ecdh_secp160r2 */
+#define NRF_CRYPTO_ECDH_SECP192R1_SHARED_SECRET_SIZE  (192 / 8)   /**< @brief Number of bytes in a shared secret using secp192r1 (NIST 192-bit).     @ingroup nrf_crypto_ecdh_secp192r1 */
+#define NRF_CRYPTO_ECDH_SECP224R1_SHARED_SECRET_SIZE  (224 / 8)   /**< @brief Number of bytes in a shared secret using secp224r1 (NIST 224-bit).     @ingroup nrf_crypto_ecdh_secp224r1 */
+#define NRF_CRYPTO_ECDH_SECP256R1_SHARED_SECRET_SIZE  (256 / 8)   /**< @brief Number of bytes in a shared secret using secp256r1 (NIST 256-bit).     @ingroup nrf_crypto_ecdh_secp256r1 */
+#define NRF_CRYPTO_ECDH_SECP384R1_SHARED_SECRET_SIZE  (384 / 8)   /**< @brief Number of bytes in a shared secret using secp384r1 (NIST 384-bit).     @ingroup nrf_crypto_ecdh_secp384r1 */
+#define NRF_CRYPTO_ECDH_SECP521R1_SHARED_SECRET_SIZE  (528 / 8)   /**< @brief Number of bytes in a shared secret using secp521r1 (NIST 521-bit).     @ingroup nrf_crypto_ecdh_secp521r1 */
+#define NRF_CRYPTO_ECDH_SECP160K1_SHARED_SECRET_SIZE  (160 / 8)   /**< @brief Number of bytes in a shared secret using secp160k1 (Koblitz 160-bit).  @ingroup nrf_crypto_ecdh_secp160k1 */
+#define NRF_CRYPTO_ECDH_SECP192K1_SHARED_SECRET_SIZE  (192 / 8)   /**< @brief Number of bytes in a shared secret using secp192k1 (Koblitz 192-bit).  @ingroup nrf_crypto_ecdh_secp192k1 */
+#define NRF_CRYPTO_ECDH_SECP224K1_SHARED_SECRET_SIZE  (224 / 8)   /**< @brief Number of bytes in a shared secret using secp224k1 (Koblitz 224-bit).  @ingroup nrf_crypto_ecdh_secp224k1 */
+#define NRF_CRYPTO_ECDH_SECP256K1_SHARED_SECRET_SIZE  (256 / 8)   /**< @brief Number of bytes in a shared secret using secp256k1 (Koblitz 256-bit).  @ingroup nrf_crypto_ecdh_secp256k1 */
+#define NRF_CRYPTO_ECDH_BP256R1_SHARED_SECRET_SIZE    (256 / 8)   /**< @brief Number of bytes in a shared secret using bp256r1 (Brainpool 256-bit).  @ingroup nrf_crypto_ecdh_bp256r1 */
+#define NRF_CRYPTO_ECDH_BP384R1_SHARED_SECRET_SIZE    (384 / 8)   /**< @brief Number of bytes in a shared secret using bp384r1 (Brainpool 384-bit).  @ingroup nrf_crypto_ecdh_bp384r1 */
+#define NRF_CRYPTO_ECDH_BP512R1_SHARED_SECRET_SIZE    (512 / 8)   /**< @brief Number of bytes in a shared secret using bp512r1 (Brainpool 512-bit).  @ingroup nrf_crypto_ecdh_bp512r1 */
+#define NRF_CRYPTO_ECDH_CURVE25519_SHARED_SECRET_SIZE (256 / 8)   /**< @brief Number of bytes in a shared secret using Curve25519.                   @ingroup nrf_crypto_ecdh_curve25519 */
+#define NRF_CRYPTO_ECDH_ED25519_SHARED_SECRET_SIZE    (256 / 8)   /**< @brief Number of bytes in a shared secret using Ed25519.                      @ingroup nrf_crypto_ecdh_ed25519 */
+#define NRF_CRYPTO_ECDH_SHARED_SECRET_MAX_SIZE        NRF_CRYPTO_ECC_RAW_PRIVATE_KEY_MAX_SIZE  /**< @brief Maximum size of a shared secret in bytes for all enabled curves. */
+
+
+typedef nrf_crypto_backend_secp160r1_ecdh_context_t  nrf_crypto_ecdh_secp160r1_context_t;    /**< @brief Context used to store temporary data during computing ECDH for curve secp160r1 (NIST 160-bit).     @ingroup nrf_crypto_ecdh_secp160r1 */
+typedef nrf_crypto_backend_secp160r2_ecdh_context_t  nrf_crypto_ecdh_secp160r2_context_t;    /**< @brief Context used to store temporary data during computing ECDH for curve secp160r2 (NIST 160-bit).     @ingroup nrf_crypto_ecdh_secp160r2 */
+typedef nrf_crypto_backend_secp192r1_ecdh_context_t  nrf_crypto_ecdh_secp192r1_context_t;    /**< @brief Context used to store temporary data during computing ECDH for curve secp192r1 (NIST 192-bit).     @ingroup nrf_crypto_ecdh_secp192r1 */
+typedef nrf_crypto_backend_secp224r1_ecdh_context_t  nrf_crypto_ecdh_secp224r1_context_t;    /**< @brief Context used to store temporary data during computing ECDH for curve secp224r1 (NIST 224-bit).     @ingroup nrf_crypto_ecdh_secp224r1 */
+typedef nrf_crypto_backend_secp256r1_ecdh_context_t  nrf_crypto_ecdh_secp256r1_context_t;    /**< @brief Context used to store temporary data during computing ECDH for curve secp256r1 (NIST 256-bit).     @ingroup nrf_crypto_ecdh_secp256r1 */
+typedef nrf_crypto_backend_secp384r1_ecdh_context_t  nrf_crypto_ecdh_secp384r1_context_t;    /**< @brief Context used to store temporary data during computing ECDH for curve secp384r1 (NIST 384-bit).     @ingroup nrf_crypto_ecdh_secp384r1 */
+typedef nrf_crypto_backend_secp521r1_ecdh_context_t  nrf_crypto_ecdh_secp521r1_context_t;    /**< @brief Context used to store temporary data during computing ECDH for curve secp521r1 (NIST 521-bit).     @ingroup nrf_crypto_ecdh_secp521r1 */
+typedef nrf_crypto_backend_secp160k1_ecdh_context_t  nrf_crypto_ecdh_secp160k1_context_t;    /**< @brief Context used to store temporary data during computing ECDH for curve secp160k1 (Koblitz 160-bit).  @ingroup nrf_crypto_ecdh_secp160k1 */
+typedef nrf_crypto_backend_secp192k1_ecdh_context_t  nrf_crypto_ecdh_secp192k1_context_t;    /**< @brief Context used to store temporary data during computing ECDH for curve secp192k1 (Koblitz 192-bit).  @ingroup nrf_crypto_ecdh_secp192k1 */
+typedef nrf_crypto_backend_secp224k1_ecdh_context_t  nrf_crypto_ecdh_secp224k1_context_t;    /**< @brief Context used to store temporary data during computing ECDH for curve secp224k1 (Koblitz 224-bit).  @ingroup nrf_crypto_ecdh_secp224k1 */
+typedef nrf_crypto_backend_secp256k1_ecdh_context_t  nrf_crypto_ecdh_secp256k1_context_t;    /**< @brief Context used to store temporary data during computing ECDH for curve secp256k1 (Koblitz 256-bit).  @ingroup nrf_crypto_ecdh_secp256k1 */
+typedef nrf_crypto_backend_bp256r1_ecdh_context_t    nrf_crypto_ecdh_bp256r1_context_t;      /**< @brief Context used to store temporary data during computing ECDH for curve bp256r1 (Brainpool 256-bit).  @ingroup nrf_crypto_ecdh_bp256r1 */
+typedef nrf_crypto_backend_bp384r1_ecdh_context_t    nrf_crypto_ecdh_bp384r1_context_t;      /**< @brief Context used to store temporary data during computing ECDH for curve bp384r1 (Brainpool 384-bit).  @ingroup nrf_crypto_ecdh_bp384r1 */
+typedef nrf_crypto_backend_bp512r1_ecdh_context_t    nrf_crypto_ecdh_bp512r1_context_t;      /**< @brief Context used to store temporary data during computing ECDH for curve bp512r1 (Brainpool 512-bit).  @ingroup nrf_crypto_ecdh_bp512r1 */
+typedef nrf_crypto_backend_curve25519_ecdh_context_t nrf_crypto_ecdh_curve25519_context_t;   /**< @brief Context used to store temporary data during computing ECDH for curve Curve25519.                   @ingroup nrf_crypto_ecdh_curve25519 */
+typedef nrf_crypto_backend_ed25519_ecdh_context_t    nrf_crypto_ecdh_ed25519_context_t;      /**< @brief Context used to store temporary data during computing ECDH for curve Ed25519.                      @ingroup nrf_crypto_ecdh_ed25519 */
+
+
+typedef uint8_t nrf_crypto_ecdh_secp160r1_shared_secret_t
+    [NRF_CRYPTO_ECDH_SECP160R1_SHARED_SECRET_SIZE];        /**< @brief Array type of a shared secret for curve secp160r1 (NIST 160-bit).  @ingroup nrf_crypto_ecdh_secp160r1 */
+typedef uint8_t nrf_crypto_ecdh_secp160r2_shared_secret_t
+    [NRF_CRYPTO_ECDH_SECP160R2_SHARED_SECRET_SIZE];        /**< @brief Array type of a shared secret for curve secp160r2 (NIST 160-bit).  @ingroup nrf_crypto_ecdh_secp160r2 */
+typedef uint8_t nrf_crypto_ecdh_secp192r1_shared_secret_t
+    [NRF_CRYPTO_ECDH_SECP192R1_SHARED_SECRET_SIZE];        /**< @brief Array type of a shared secret for curve secp192r1 (NIST 192-bit).  @ingroup nrf_crypto_ecdh_secp192r1 */
+typedef uint8_t nrf_crypto_ecdh_secp224r1_shared_secret_t
+    [NRF_CRYPTO_ECDH_SECP224R1_SHARED_SECRET_SIZE];        /**< @brief Array type of a shared secret for curve secp224r1 (NIST 224-bit).  @ingroup nrf_crypto_ecdh_secp224r1 */
+typedef uint8_t nrf_crypto_ecdh_secp256r1_shared_secret_t
+    [NRF_CRYPTO_ECDH_SECP256R1_SHARED_SECRET_SIZE];        /**< @brief Array type of a shared secret for curve secp256r1 (NIST 256-bit).  @ingroup nrf_crypto_ecdh_secp256r1 */
+typedef uint8_t nrf_crypto_ecdh_secp384r1_shared_secret_t
+    [NRF_CRYPTO_ECDH_SECP384R1_SHARED_SECRET_SIZE];        /**< @brief Array type of a shared secret for curve secp384r1 (NIST 384-bit).  @ingroup nrf_crypto_ecdh_secp384r1 */
+typedef uint8_t nrf_crypto_ecdh_secp521r1_shared_secret_t
+    [NRF_CRYPTO_ECDH_SECP521R1_SHARED_SECRET_SIZE];        /**< @brief Array type of a shared secret for curve secp521r1 (NIST 521-bit).  @ingroup nrf_crypto_ecdh_secp521r1 */
+typedef uint8_t nrf_crypto_ecdh_secp160k1_shared_secret_t
+    [NRF_CRYPTO_ECDH_SECP160K1_SHARED_SECRET_SIZE];        /**< @brief Array type of a shared secret for curve secp160k1 (Koblitz 160-bit).  @ingroup nrf_crypto_ecdh_secp160k1 */
+typedef uint8_t nrf_crypto_ecdh_secp192k1_shared_secret_t
+    [NRF_CRYPTO_ECDH_SECP192K1_SHARED_SECRET_SIZE];        /**< @brief Array type of a shared secret for curve secp192k1 (Koblitz 192-bit).  @ingroup nrf_crypto_ecdh_secp192k1 */
+typedef uint8_t nrf_crypto_ecdh_secp224k1_shared_secret_t
+    [NRF_CRYPTO_ECDH_SECP224K1_SHARED_SECRET_SIZE];        /**< @brief Array type of a shared secret for curve secp224k1 (Koblitz 224-bit).  @ingroup nrf_crypto_ecdh_secp224k1 */
+typedef uint8_t nrf_crypto_ecdh_secp256k1_shared_secret_t
+    [NRF_CRYPTO_ECDH_SECP256K1_SHARED_SECRET_SIZE];        /**< @brief Array type of a shared secret for curve secp256k1 (Koblitz 256-bit).  @ingroup nrf_crypto_ecdh_secp256k1 */
+typedef uint8_t nrf_crypto_ecdh_bp256r1_shared_secret_t
+    [NRF_CRYPTO_ECDH_BP256R1_SHARED_SECRET_SIZE];          /**< @brief Array type of a shared secret for curve bp256r1 (Brainpool 256-bit).  @ingroup nrf_crypto_ecdh_bp256r1 */
+typedef uint8_t nrf_crypto_ecdh_bp384r1_shared_secret_t
+    [NRF_CRYPTO_ECDH_BP384R1_SHARED_SECRET_SIZE];          /**< @brief Array type of a shared secret for curve bp384r1 (Brainpool 384-bit).  @ingroup nrf_crypto_ecdh_bp384r1 */
+typedef uint8_t nrf_crypto_ecdh_bp512r1_shared_secret_t
+    [NRF_CRYPTO_ECDH_BP512R1_SHARED_SECRET_SIZE];          /**< @brief Array type of a shared secret for curve bp512r1 (Brainpool 512-bit).  @ingroup nrf_crypto_ecdh_bp512r1 */
+typedef uint8_t nrf_crypto_ecdh_curve25519_shared_secret_t
+    [NRF_CRYPTO_ECDH_CURVE25519_SHARED_SECRET_SIZE];       /**< @brief Array type of a shared secret for curve Curve25519.  @ingroup nrf_crypto_ecdh_curve25519 */
+typedef uint8_t nrf_crypto_ecdh_ed25519_shared_secret_t
+    [NRF_CRYPTO_ECDH_ED25519_SHARED_SECRET_SIZE];          /**< @brief Array type of a shared secret for curve Ed25519.  @ingroup nrf_crypto_ecdh_ed25519 */
+typedef uint8_t nrf_crypto_ecdh_shared_secret_t
+    [NRF_CRYPTO_ECDH_SHARED_SECRET_MAX_SIZE];              /**< @brief Array type of a shared secret for any of the enabled curves. */
+
+
+/** @brief Union holding a context for ECDH computation.
+ */
+typedef union
+{
+    nrf_crypto_ecdh_secp160r1_context_t  context_secp160r1;   /**< @brief Occupies space for secp160r1 (NIST 160-bit). */
+    nrf_crypto_ecdh_secp160r2_context_t  context_secp160r2;   /**< @brief Occupies space for secp160r2 (NIST 160-bit). */
+    nrf_crypto_ecdh_secp192r1_context_t  context_secp192r1;   /**< @brief Occupies space for secp192r1 (NIST 192-bit). */
+    nrf_crypto_ecdh_secp224r1_context_t  context_secp224r1;   /**< @brief Occupies space for secp224r1 (NIST 224-bit). */
+    nrf_crypto_ecdh_secp256r1_context_t  context_secp256r1;   /**< @brief Occupies space for secp256r1 (NIST 256-bit). */
+    nrf_crypto_ecdh_secp384r1_context_t  context_secp384r1;   /**< @brief Occupies space for secp384r1 (NIST 384-bit). */
+    nrf_crypto_ecdh_secp521r1_context_t  context_secp521r1;   /**< @brief Occupies space for secp521r1 (NIST 521-bit). */
+    nrf_crypto_ecdh_secp160k1_context_t  context_secp160k1;   /**< @brief Occupies space for secp160k1 (Koblitz 160-bit). */
+    nrf_crypto_ecdh_secp192k1_context_t  context_secp192k1;   /**< @brief Occupies space for secp192k1 (Koblitz 192-bit). */
+    nrf_crypto_ecdh_secp224k1_context_t  context_secp224k1;   /**< @brief Occupies space for secp224k1 (Koblitz 224-bit). */
+    nrf_crypto_ecdh_secp256k1_context_t  context_secp256k1;   /**< @brief Occupies space for secp256k1 (Koblitz 256-bit). */
+    nrf_crypto_ecdh_bp256r1_context_t    context_bp256r1;     /**< @brief Occupies space for bp256r1 (Brainpool 256-bit). */
+    nrf_crypto_ecdh_bp384r1_context_t    context_bp384r1;     /**< @brief Occupies space for bp384r1 (Brainpool 384-bit). */
+    nrf_crypto_ecdh_bp512r1_context_t    context_bp512r1;     /**< @brief Occupies space for bp512r1 (Brainpool 512-bit). */
+    nrf_crypto_ecdh_curve25519_context_t context_curve25519;  /**< @brief Occupies space for Curve25519. */
+    nrf_crypto_ecdh_ed25519_context_t    context_ed25519;     /**< @brief Occupies space for Ed25519. */
+} nrf_crypto_ecdh_context_t;
+
+
+/** @brief Computes shared secret using ECC Diffie-Hellman.
+ *
+ *  @param[in]     p_context             Pointer to temporary structure holding context information.
+ *                                       If it is NULL, necessary data will be allocated with
+ *                                       @ref NRF_CRYPTO_ALLOC and freed at the end of the function.
+ *  @param[in]     p_private_key         Pointer to structure holding a private key.
+ *  @param[in]     p_public_key          Pointer to structure holding a public key received from the other party.
+ *  @param[out]    p_shared_secret       Pointer to buffer where shared secret will be put.
+ *  @param[in,out] p_shared_secret_size  Maximum number of bytes that @p p_shared_secret buffer can hold on input
+ *                                       and the actual number of bytes used by the data on output.
+ *                                       Actual size for selected curve is defined by
+ *                                       the preprocessor definitions, e.g.
+ *                                       @ref NRF_CRYPTO_ECDH_SECP256R1_SHARED_SECRET_SIZE.
+ */
+ret_code_t nrf_crypto_ecdh_compute(
+    nrf_crypto_ecdh_context_t          * p_context,
+    nrf_crypto_ecc_private_key_t const * p_private_key,
+    nrf_crypto_ecc_public_key_t  const * p_public_key,
+    uint8_t                            * p_shared_secret,
+    size_t                             * p_shared_secret_size);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+/** @}
+ *  @}
+ */
+
+#endif // NRF_CRYPTO_ECDH_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_ecdh_backend.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_ecdh_backend.h
new file mode 100644
index 0000000..3b6f692
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_ecdh_backend.h
@@ -0,0 +1,184 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef NRF_CRYPTO_ECDH_BACKEND_H__
+#define NRF_CRYPTO_ECDH_BACKEND_H__
+#if !defined(__SDK_DOXYGEN__)
+
+#include <stdint.h>
+#include <stddef.h>
+
+#include "sdk_errors.h"
+#include "sdk_config.h"
+#include "nrf_crypto_ecc.h"
+#include "nrf_crypto_ecdh_shared.h"
+
+// Include all backends
+#include "cc310_backend_ecdh.h"
+#include "cc310_bl_backend_ecdh.h"
+#include "mbedtls_backend_ecdh.h"
+#include "oberon_backend_ecdh.h"
+#include "micro_ecc_backend_ecdh.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#if !NRF_CRYPTO_ECC_SECP160R1_ENABLED
+// Dummy typedef for disabled context
+typedef uint32_t nrf_crypto_backend_secp160r1_ecdh_context_t;
+// Backend implementation is NULL to indicate feature not supported
+#define nrf_crypto_backend_secp160r1_ecdh_compute NULL
+#endif
+
+#if !NRF_CRYPTO_ECC_SECP160R2_ENABLED
+// Dummy typedef for disabled context
+typedef uint32_t nrf_crypto_backend_secp160r2_ecdh_context_t;
+// Backend implementation is NULL to indicate feature not supported
+#define nrf_crypto_backend_secp160r2_ecdh_compute NULL
+#endif
+
+#if !NRF_CRYPTO_ECC_SECP192R1_ENABLED
+// Dummy typedef for disabled context
+typedef uint32_t nrf_crypto_backend_secp192r1_ecdh_context_t;
+// Backend implementation is NULL to indicate feature not supported
+#define nrf_crypto_backend_secp192r1_ecdh_compute NULL
+#endif
+
+#if !NRF_CRYPTO_ECC_SECP224R1_ENABLED
+// Dummy typedef for disabled context
+typedef uint32_t nrf_crypto_backend_secp224r1_ecdh_context_t;
+// Backend implementation is NULL to indicate feature not supported
+#define nrf_crypto_backend_secp224r1_ecdh_compute NULL
+#endif
+
+#if !NRF_CRYPTO_ECC_SECP256R1_ENABLED
+// Dummy typedef for disabled context
+typedef uint32_t nrf_crypto_backend_secp256r1_ecdh_context_t;
+// Backend implementation is NULL to indicate feature not supported
+#define nrf_crypto_backend_secp256r1_ecdh_compute NULL
+#endif
+
+#if !NRF_CRYPTO_ECC_SECP384R1_ENABLED
+// Dummy typedef for disabled context
+typedef uint32_t nrf_crypto_backend_secp384r1_ecdh_context_t;
+// Backend implementation is NULL to indicate feature not supported
+#define nrf_crypto_backend_secp384r1_ecdh_compute NULL
+#endif
+
+#if !NRF_CRYPTO_ECC_SECP521R1_ENABLED
+// Dummy typedef for disabled context
+typedef uint32_t nrf_crypto_backend_secp521r1_ecdh_context_t;
+// Backend implementation is NULL to indicate feature not supported
+#define nrf_crypto_backend_secp521r1_ecdh_compute NULL
+#endif
+
+#if !NRF_CRYPTO_ECC_SECP160K1_ENABLED
+// Dummy typedef for disabled context
+typedef uint32_t nrf_crypto_backend_secp160k1_ecdh_context_t;
+// Backend implementation is NULL to indicate feature not supported
+#define nrf_crypto_backend_secp160k1_ecdh_compute NULL
+#endif
+
+#if !NRF_CRYPTO_ECC_SECP192K1_ENABLED
+// Dummy typedef for disabled context
+typedef uint32_t nrf_crypto_backend_secp192k1_ecdh_context_t;
+// Backend implementation is NULL to indicate feature not supported
+#define nrf_crypto_backend_secp192k1_ecdh_compute NULL
+#endif
+
+#if !NRF_CRYPTO_ECC_SECP224K1_ENABLED
+// Dummy typedef for disabled context
+typedef uint32_t nrf_crypto_backend_secp224k1_ecdh_context_t;
+// Backend implementation is NULL to indicate feature not supported
+#define nrf_crypto_backend_secp224k1_ecdh_compute NULL
+#endif
+
+#if !NRF_CRYPTO_ECC_SECP256K1_ENABLED
+// Dummy typedef for disabled context
+typedef uint32_t nrf_crypto_backend_secp256k1_ecdh_context_t;
+// Backend implementation is NULL to indicate feature not supported
+#define nrf_crypto_backend_secp256k1_ecdh_compute NULL
+#endif
+
+#if !NRF_CRYPTO_ECC_BP256R1_ENABLED
+// Dummy typedef for disabled context
+typedef uint32_t nrf_crypto_backend_bp256r1_ecdh_context_t;
+// Backend implementation is NULL to indicate feature not supported
+#define nrf_crypto_backend_bp256r1_ecdh_compute NULL
+#endif
+
+#if !NRF_CRYPTO_ECC_BP384R1_ENABLED
+// Dummy typedef for disabled context
+typedef uint32_t nrf_crypto_backend_bp384r1_ecdh_context_t;
+// Backend implementation is NULL to indicate feature not supported
+#define nrf_crypto_backend_bp384r1_ecdh_compute NULL
+#endif
+
+#if !NRF_CRYPTO_ECC_BP512R1_ENABLED
+// Dummy typedef for disabled context
+typedef uint32_t nrf_crypto_backend_bp512r1_ecdh_context_t;
+// Backend implementation is NULL to indicate feature not supported
+#define nrf_crypto_backend_bp512r1_ecdh_compute NULL
+#endif
+
+#if !NRF_CRYPTO_ECC_CURVE25519_ENABLED
+// Dummy typedef for disabled context
+typedef uint32_t nrf_crypto_backend_curve25519_ecdh_context_t;
+// Backend implementation is NULL to indicate feature not supported
+#define nrf_crypto_backend_curve25519_ecdh_compute NULL
+#endif
+
+#if !NRF_CRYPTO_ECC_ED25519_ENABLED
+// Dummy typedef for disabled context
+typedef uint32_t nrf_crypto_backend_ed25519_ecdh_context_t;
+// Backend implementation is NULL to indicate feature not supported
+#define nrf_crypto_backend_ed25519_ecdh_compute NULL
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // !defined(__SDK_DOXYGEN__)
+#endif // NRF_CRYPTO_ECDH_BACKEND_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_ecdh_shared.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_ecdh_shared.h
new file mode 100644
index 0000000..7d25cb1
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_ecdh_shared.h
@@ -0,0 +1,79 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef NRF_CRYPTO_ECDH_SHARED_H__
+#define NRF_CRYPTO_ECDH_SHARED_H__
+#if !defined(__SDK_DOXYGEN__)
+
+#include <stdint.h>
+#include <stddef.h>
+
+#include "sdk_errors.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/** @internal @brief Function pointer for backend implementation of ECDH.
+ *
+ * @note All parameters provided to the backend are vefified in frontend. Verification includes
+ * checking of NULL pointers, buffer size, initialization values. Front end also take full care of
+ * common ECC key hearder @ref nrf_crypto_internal_ecc_key_header_t.
+ *
+ * @param[in]  p_context       Pointer to context.
+ * @param[in]  p_private_key   Pointer to private key.
+ * @param[in]  p_public_key    Pointer to public key.
+ * @param[out] p_shared_secret Pointer where to put generated shared secret.
+ */
+typedef ret_code_t (*nrf_crypto_backend_ecdh_compute_fn_t)(
+    void       * p_context,
+    void const * p_private_key,
+    void const * p_public_key,
+    uint8_t    * p_shared_secret);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // !defined(__SDK_DOXYGEN__)
+#endif // NRF_CRYPTO_ECDH_SHARED_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_ecdsa.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_ecdsa.c
new file mode 100644
index 0000000..6258cb2
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_ecdsa.c
@@ -0,0 +1,471 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#include "nrf_crypto_error.h"
+#include "nrf_crypto_ecc.h"
+#include "nrf_crypto_ecdsa.h"
+#include "nrf_crypto_mem.h"
+#include "app_util.h"
+#include "sdk_macros.h"
+
+
+#if NRF_CRYPTO_ECC_ENABLED
+
+
+#if NRF_CRYPTO_ECC_IMPLEMENTED_CURVES_COUNT > 1
+
+
+static const nrf_crypto_backend_ecdsa_sign_fn_t sign_impl[] =
+{
+#if NRF_CRYPTO_ECC_SECP160R1_ENABLED
+    nrf_crypto_backend_secp160r1_sign,
+#endif
+#if NRF_CRYPTO_ECC_SECP160R2_ENABLED
+    nrf_crypto_backend_secp160r2_sign,
+#endif
+#if NRF_CRYPTO_ECC_SECP192R1_ENABLED
+    nrf_crypto_backend_secp192r1_sign,
+#endif
+#if NRF_CRYPTO_ECC_SECP224R1_ENABLED
+    nrf_crypto_backend_secp224r1_sign,
+#endif
+#if NRF_CRYPTO_ECC_SECP256R1_ENABLED
+    nrf_crypto_backend_secp256r1_sign,
+#endif
+#if NRF_CRYPTO_ECC_SECP384R1_ENABLED
+    nrf_crypto_backend_secp384r1_sign,
+#endif
+#if NRF_CRYPTO_ECC_SECP521R1_ENABLED
+    nrf_crypto_backend_secp521r1_sign,
+#endif
+#if NRF_CRYPTO_ECC_SECP160K1_ENABLED
+    nrf_crypto_backend_secp160k1_sign,
+#endif
+#if NRF_CRYPTO_ECC_SECP192K1_ENABLED
+    nrf_crypto_backend_secp192k1_sign,
+#endif
+#if NRF_CRYPTO_ECC_SECP224K1_ENABLED
+    nrf_crypto_backend_secp224k1_sign,
+#endif
+#if NRF_CRYPTO_ECC_SECP256K1_ENABLED
+    nrf_crypto_backend_secp256k1_sign,
+#endif
+#if NRF_CRYPTO_ECC_BP256R1_ENABLED
+    nrf_crypto_backend_bp256r1_sign,
+#endif
+#if NRF_CRYPTO_ECC_BP384R1_ENABLED
+    nrf_crypto_backend_bp384r1_sign,
+#endif
+#if NRF_CRYPTO_ECC_BP512R1_ENABLED
+    nrf_crypto_backend_bp512r1_sign,
+#endif
+#if NRF_CRYPTO_ECC_CURVE25519_ENABLED
+    nrf_crypto_backend_curve25519_sign,
+#endif
+#if NRF_CRYPTO_ECC_ED25519_ENABLED
+    nrf_crypto_backend_ed25519_sign,
+#endif
+};
+
+static const uint16_t sign_impl_context_size[] =
+{
+#if NRF_CRYPTO_ECC_SECP160R1_ENABLED
+    NRF_CRYPTO_BACKEND_SECP160R1_SIGN_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_SECP160R2_ENABLED
+    NRF_CRYPTO_BACKEND_SECP160R2_SIGN_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_SECP192R1_ENABLED
+    NRF_CRYPTO_BACKEND_SECP192R1_SIGN_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_SECP224R1_ENABLED
+    NRF_CRYPTO_BACKEND_SECP224R1_SIGN_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_SECP256R1_ENABLED
+    NRF_CRYPTO_BACKEND_SECP256R1_SIGN_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_SECP384R1_ENABLED
+    NRF_CRYPTO_BACKEND_SECP384R1_SIGN_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_SECP521R1_ENABLED
+    NRF_CRYPTO_BACKEND_SECP521R1_SIGN_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_SECP160K1_ENABLED
+    NRF_CRYPTO_BACKEND_SECP160K1_SIGN_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_SECP192K1_ENABLED
+    NRF_CRYPTO_BACKEND_SECP192K1_SIGN_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_SECP224K1_ENABLED
+    NRF_CRYPTO_BACKEND_SECP224K1_SIGN_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_SECP256K1_ENABLED
+    NRF_CRYPTO_BACKEND_SECP256K1_SIGN_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_BP256R1_ENABLED
+    NRF_CRYPTO_BACKEND_BP256R1_SIGN_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_BP384R1_ENABLED
+    NRF_CRYPTO_BACKEND_BP384R1_SIGN_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_BP512R1_ENABLED
+    NRF_CRYPTO_BACKEND_BP512R1_SIGN_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_CURVE25519_ENABLED
+    NRF_CRYPTO_BACKEND_CURVE25519_SIGN_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_ED25519_ENABLED
+    NRF_CRYPTO_BACKEND_ED25519_SIGN_CONTEXT_SIZE,
+#endif
+};
+
+static const nrf_crypto_backend_ecdsa_verify_fn_t verify_impl[] =
+{
+#if NRF_CRYPTO_ECC_SECP160R1_ENABLED
+    nrf_crypto_backend_secp160r1_verify,
+#endif
+#if NRF_CRYPTO_ECC_SECP160R2_ENABLED
+    nrf_crypto_backend_secp160r2_verify,
+#endif
+#if NRF_CRYPTO_ECC_SECP192R1_ENABLED
+    nrf_crypto_backend_secp192r1_verify,
+#endif
+#if NRF_CRYPTO_ECC_SECP224R1_ENABLED
+    nrf_crypto_backend_secp224r1_verify,
+#endif
+#if NRF_CRYPTO_ECC_SECP256R1_ENABLED
+    nrf_crypto_backend_secp256r1_verify,
+#endif
+#if NRF_CRYPTO_ECC_SECP384R1_ENABLED
+    nrf_crypto_backend_secp384r1_verify,
+#endif
+#if NRF_CRYPTO_ECC_SECP521R1_ENABLED
+    nrf_crypto_backend_secp521r1_verify,
+#endif
+#if NRF_CRYPTO_ECC_SECP160K1_ENABLED
+    nrf_crypto_backend_secp160k1_verify,
+#endif
+#if NRF_CRYPTO_ECC_SECP192K1_ENABLED
+    nrf_crypto_backend_secp192k1_verify,
+#endif
+#if NRF_CRYPTO_ECC_SECP224K1_ENABLED
+    nrf_crypto_backend_secp224k1_verify,
+#endif
+#if NRF_CRYPTO_ECC_SECP256K1_ENABLED
+    nrf_crypto_backend_secp256k1_verify,
+#endif
+#if NRF_CRYPTO_ECC_BP256R1_ENABLED
+    nrf_crypto_backend_bp256r1_verify,
+#endif
+#if NRF_CRYPTO_ECC_BP384R1_ENABLED
+    nrf_crypto_backend_bp384r1_verify,
+#endif
+#if NRF_CRYPTO_ECC_BP512R1_ENABLED
+    nrf_crypto_backend_bp512r1_verify,
+#endif
+#if NRF_CRYPTO_ECC_CURVE25519_ENABLED
+    nrf_crypto_backend_curve25519_verify,
+#endif
+#if NRF_CRYPTO_ECC_ED25519_ENABLED
+    nrf_crypto_backend_ed25519_verify,
+#endif
+};
+
+static const uint16_t verify_impl_context_size[] =
+{
+#if NRF_CRYPTO_ECC_SECP160R1_ENABLED
+    NRF_CRYPTO_BACKEND_SECP160R1_VERIFY_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_SECP160R2_ENABLED
+    NRF_CRYPTO_BACKEND_SECP160R2_VERIFY_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_SECP192R1_ENABLED
+    NRF_CRYPTO_BACKEND_SECP192R1_VERIFY_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_SECP224R1_ENABLED
+    NRF_CRYPTO_BACKEND_SECP224R1_VERIFY_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_SECP256R1_ENABLED
+    NRF_CRYPTO_BACKEND_SECP256R1_VERIFY_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_SECP384R1_ENABLED
+    NRF_CRYPTO_BACKEND_SECP384R1_VERIFY_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_SECP521R1_ENABLED
+    NRF_CRYPTO_BACKEND_SECP521R1_VERIFY_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_SECP160K1_ENABLED
+    NRF_CRYPTO_BACKEND_SECP160K1_VERIFY_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_SECP192K1_ENABLED
+    NRF_CRYPTO_BACKEND_SECP192K1_VERIFY_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_SECP224K1_ENABLED
+    NRF_CRYPTO_BACKEND_SECP224K1_VERIFY_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_SECP256K1_ENABLED
+    NRF_CRYPTO_BACKEND_SECP256K1_VERIFY_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_BP256R1_ENABLED
+    NRF_CRYPTO_BACKEND_BP256R1_VERIFY_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_BP384R1_ENABLED
+    NRF_CRYPTO_BACKEND_BP384R1_VERIFY_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_BP512R1_ENABLED
+    NRF_CRYPTO_BACKEND_BP512R1_VERIFY_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_CURVE25519_ENABLED
+    NRF_CRYPTO_BACKEND_CURVE25519_VERIFY_CONTEXT_SIZE,
+#endif
+#if NRF_CRYPTO_ECC_ED25519_ENABLED
+    NRF_CRYPTO_BACKEND_ED25519_VERIFY_CONTEXT_SIZE,
+#endif
+};
+
+#define BACKEND_IMPL_GET(table, curve_type) (table)[(uint32_t)(curve_type)]
+
+#else
+
+#if NRF_CRYPTO_ECC_SECP160R1_ENABLED
+#define sign_impl                nrf_crypto_backend_secp160r1_sign
+#define sign_impl_context_size   NRF_CRYPTO_BACKEND_SECP160R1_SIGN_CONTEXT_SIZE
+#define verify_impl              nrf_crypto_backend_secp160r1_verify
+#define verify_impl_context_size NRF_CRYPTO_BACKEND_SECP160R1_VERIFY_CONTEXT_SIZE
+#elif NRF_CRYPTO_ECC_SECP160R2_ENABLED
+#define sign_impl                nrf_crypto_backend_secp160r2_sign
+#define sign_impl_context_size   NRF_CRYPTO_BACKEND_SECP160R2_SIGN_CONTEXT_SIZE
+#define verify_impl              nrf_crypto_backend_secp160r2_verify
+#define verify_impl_context_size NRF_CRYPTO_BACKEND_SECP160R2_VERIFY_CONTEXT_SIZE
+#elif NRF_CRYPTO_ECC_SECP192R1_ENABLED
+#define sign_impl                nrf_crypto_backend_secp192r1_sign
+#define sign_impl_context_size   NRF_CRYPTO_BACKEND_SECP192R1_SIGN_CONTEXT_SIZE
+#define verify_impl              nrf_crypto_backend_secp192r1_verify
+#define verify_impl_context_size NRF_CRYPTO_BACKEND_SECP192R1_VERIFY_CONTEXT_SIZE
+#elif NRF_CRYPTO_ECC_SECP224R1_ENABLED
+#define sign_impl                nrf_crypto_backend_secp224r1_sign
+#define sign_impl_context_size   NRF_CRYPTO_BACKEND_SECP224R1_SIGN_CONTEXT_SIZE
+#define verify_impl              nrf_crypto_backend_secp224r1_verify
+#define verify_impl_context_size NRF_CRYPTO_BACKEND_SECP224R1_VERIFY_CONTEXT_SIZE
+#elif NRF_CRYPTO_ECC_SECP256R1_ENABLED
+#define sign_impl                nrf_crypto_backend_secp256r1_sign
+#define sign_impl_context_size   NRF_CRYPTO_BACKEND_SECP256R1_SIGN_CONTEXT_SIZE
+#define verify_impl              nrf_crypto_backend_secp256r1_verify
+#define verify_impl_context_size NRF_CRYPTO_BACKEND_SECP256R1_VERIFY_CONTEXT_SIZE
+#elif NRF_CRYPTO_ECC_SECP384R1_ENABLED
+#define sign_impl                nrf_crypto_backend_secp384r1_sign
+#define sign_impl_context_size   NRF_CRYPTO_BACKEND_SECP384R1_SIGN_CONTEXT_SIZE
+#define verify_impl              nrf_crypto_backend_secp384r1_verify
+#define verify_impl_context_size NRF_CRYPTO_BACKEND_SECP384R1_VERIFY_CONTEXT_SIZE
+#elif NRF_CRYPTO_ECC_SECP521R1_ENABLED
+#define sign_impl                nrf_crypto_backend_secp521r1_sign
+#define sign_impl_context_size   NRF_CRYPTO_BACKEND_SECP521R1_SIGN_CONTEXT_SIZE
+#define verify_impl              nrf_crypto_backend_secp521r1_verify
+#define verify_impl_context_size NRF_CRYPTO_BACKEND_SECP521R1_VERIFY_CONTEXT_SIZE
+#elif NRF_CRYPTO_ECC_SECP160K1_ENABLED
+#define sign_impl                nrf_crypto_backend_secp160k1_sign
+#define sign_impl_context_size   NRF_CRYPTO_BACKEND_SECP160K1_SIGN_CONTEXT_SIZE
+#define verify_impl              nrf_crypto_backend_secp160k1_verify
+#define verify_impl_context_size NRF_CRYPTO_BACKEND_SECP160K1_VERIFY_CONTEXT_SIZE
+#elif NRF_CRYPTO_ECC_SECP192K1_ENABLED
+#define sign_impl                nrf_crypto_backend_secp192k1_sign
+#define sign_impl_context_size   NRF_CRYPTO_BACKEND_SECP192K1_SIGN_CONTEXT_SIZE
+#define verify_impl              nrf_crypto_backend_secp192k1_verify
+#define verify_impl_context_size NRF_CRYPTO_BACKEND_SECP192K1_VERIFY_CONTEXT_SIZE
+#elif NRF_CRYPTO_ECC_SECP224K1_ENABLED
+#define sign_impl                nrf_crypto_backend_secp224k1_sign
+#define sign_impl_context_size   NRF_CRYPTO_BACKEND_SECP224K1_SIGN_CONTEXT_SIZE
+#define verify_impl              nrf_crypto_backend_secp224k1_verify
+#define verify_impl_context_size NRF_CRYPTO_BACKEND_SECP224K1_VERIFY_CONTEXT_SIZE
+#elif NRF_CRYPTO_ECC_SECP256K1_ENABLED
+#define sign_impl                nrf_crypto_backend_secp256k1_sign
+#define sign_impl_context_size   NRF_CRYPTO_BACKEND_SECP256K1_SIGN_CONTEXT_SIZE
+#define verify_impl              nrf_crypto_backend_secp256k1_verify
+#define verify_impl_context_size NRF_CRYPTO_BACKEND_SECP256K1_VERIFY_CONTEXT_SIZE
+#elif NRF_CRYPTO_ECC_BP256R1_ENABLED
+#define sign_impl                nrf_crypto_backend_bp256r1_sign
+#define sign_impl_context_size   NRF_CRYPTO_BACKEND_BP256R1_SIGN_CONTEXT_SIZE
+#define verify_impl              nrf_crypto_backend_bp256r1_verify
+#define verify_impl_context_size NRF_CRYPTO_BACKEND_BP256R1_VERIFY_CONTEXT_SIZE
+#elif NRF_CRYPTO_ECC_BP384R1_ENABLED
+#define sign_impl                nrf_crypto_backend_bp384r1_sign
+#define sign_impl_context_size   NRF_CRYPTO_BACKEND_BP384R1_SIGN_CONTEXT_SIZE
+#define verify_impl              nrf_crypto_backend_bp384r1_verify
+#define verify_impl_context_size NRF_CRYPTO_BACKEND_BP384R1_VERIFY_CONTEXT_SIZE
+#elif NRF_CRYPTO_ECC_BP512R1_ENABLED
+#define sign_impl                nrf_crypto_backend_bp512r1_sign
+#define sign_impl_context_size   NRF_CRYPTO_BACKEND_BP512R1_SIGN_CONTEXT_SIZE
+#define verify_impl              nrf_crypto_backend_bp512r1_verify
+#define verify_impl_context_size NRF_CRYPTO_BACKEND_BP512R1_VERIFY_CONTEXT_SIZE
+#elif NRF_CRYPTO_ECC_CURVE25519_ENABLED
+#define sign_impl                nrf_crypto_backend_curve25519_sign
+#define sign_impl_context_size   NRF_CRYPTO_BACKEND_CURVE25519_SIGN_CONTEXT_SIZE
+#define verify_impl              nrf_crypto_backend_curve25519_verify
+#define verify_impl_context_size NRF_CRYPTO_BACKEND_CURVE25519_VERIFY_CONTEXT_SIZE
+#elif NRF_CRYPTO_ECC_ED25519_ENABLED
+#define sign_impl                nrf_crypto_backend_ed25519_sign
+#define sign_impl_context_size   NRF_CRYPTO_BACKEND_ED25519_SIGN_CONTEXT_SIZE
+#define verify_impl              nrf_crypto_backend_ed25519_verify
+#define verify_impl_context_size NRF_CRYPTO_BACKEND_ED25519_VERIFY_CONTEXT_SIZE
+#else
+#define sign_impl                NULL
+#define sign_impl_context_size   0
+#define verify_impl              NULL
+#define verify_impl_context_size 0
+#endif
+
+#define BACKEND_IMPL_GET(function, curve_type) (function)
+
+#endif
+
+
+ret_code_t nrf_crypto_ecdsa_sign(
+    nrf_crypto_ecdsa_sign_context_t       * p_context,
+    nrf_crypto_ecc_private_key_t    const * p_private_key,
+    uint8_t                         const * p_hash,
+    size_t                                  hash_size,
+    uint8_t                               * p_signature,
+    size_t                                * p_signature_size)
+{
+    ret_code_t                           result;
+    void                               * p_allocated_context = NULL;
+    nrf_crypto_backend_ecdsa_sign_fn_t   backend_implementation;
+    size_t                               context_size;
+    nrf_crypto_ecc_curve_info_t  const * p_info;
+
+    // Get pointer to header
+    nrf_crypto_internal_ecc_key_header_t const * p_private_key_header =
+        (nrf_crypto_internal_ecc_key_header_t const *)p_private_key;
+
+    // Check and prepare parameters
+    VERIFY_TRUE(p_hash != NULL, NRF_ERROR_CRYPTO_INPUT_NULL);
+    result = nrf_crypto_internal_ecc_key_input_check(
+        p_private_key_header,
+        NRF_CRYPTO_INTERNAL_ECC_PRIVATE_KEY_INIT_VALUE);
+    VERIFY_SUCCESS(result);
+    p_info = p_private_key_header->p_info;
+    result = nrf_crypto_internal_ecc_raw_output_prepare(p_signature,
+                                                        p_signature_size,
+                                                        2 * p_info->raw_private_key_size);
+    VERIFY_SUCCESS(result);
+
+    // Get backend specific information
+    backend_implementation = BACKEND_IMPL_GET(sign_impl, p_info->curve_type);
+    context_size = BACKEND_IMPL_GET(sign_impl_context_size, p_info->curve_type);
+    VERIFY_TRUE(backend_implementation != NULL, NRF_ERROR_CRYPTO_FEATURE_UNAVAILABLE);
+
+    // Allocate context if not provided
+    if (p_context == NULL && context_size > 0)
+    {
+        p_allocated_context = NRF_CRYPTO_ALLOC(context_size);
+        VERIFY_TRUE(p_allocated_context != NULL, NRF_ERROR_CRYPTO_ALLOC_FAILED);
+        p_context = p_allocated_context;
+    }
+
+    // Execute backend implementation
+    result = backend_implementation(p_context, p_private_key, p_hash, hash_size, p_signature);
+
+    // Deallocate context if allocated
+    if (p_allocated_context != NULL)
+    {
+        NRF_CRYPTO_FREE(p_allocated_context);
+    }
+
+    return result;
+}
+
+
+ret_code_t nrf_crypto_ecdsa_verify(
+    nrf_crypto_ecdsa_verify_context_t       * p_context,
+    nrf_crypto_ecc_public_key_t       const * p_public_key,
+    uint8_t                           const * p_hash,
+    size_t                                    hash_size,
+    uint8_t                           const * p_signature,
+    size_t                                    signature_size)
+{
+    ret_code_t                                   result;
+    void                                       * p_allocated_context = NULL;
+    nrf_crypto_backend_ecdsa_verify_fn_t         backend_implementation;
+    size_t                                       context_size;
+    nrf_crypto_ecc_curve_info_t          const * p_info;
+
+    // Get pointer to header
+    nrf_crypto_internal_ecc_key_header_t const * p_public_key_header =
+        (nrf_crypto_internal_ecc_key_header_t const *)p_public_key;
+
+    // Check and prepare parameters
+    result = nrf_crypto_internal_ecc_key_input_check(
+        p_public_key_header,
+        NRF_CRYPTO_INTERNAL_ECC_PUBLIC_KEY_INIT_VALUE);
+    VERIFY_SUCCESS(result);
+    p_info = p_public_key_header->p_info;
+    result = nrf_crypto_internal_ecc_raw_input_check(p_signature,
+                                                     signature_size,
+                                                     2 * p_info->raw_private_key_size);
+    VERIFY_SUCCESS(result);
+    VERIFY_TRUE(p_hash != NULL, NRF_ERROR_CRYPTO_INPUT_NULL);
+
+    // Get backend specific information
+    backend_implementation = BACKEND_IMPL_GET(verify_impl, p_info->curve_type);
+    context_size = BACKEND_IMPL_GET(verify_impl_context_size, p_info->curve_type);
+    VERIFY_TRUE(backend_implementation != NULL, NRF_ERROR_CRYPTO_FEATURE_UNAVAILABLE);
+
+    // Allocate context if not provided
+    if (p_context == NULL && context_size > 0)
+    {
+        p_allocated_context = NRF_CRYPTO_ALLOC(context_size);
+        VERIFY_TRUE(p_allocated_context != NULL, NRF_ERROR_CRYPTO_ALLOC_FAILED);
+        p_context = p_allocated_context;
+    }
+
+    // Execute backend implementation
+    result = backend_implementation(p_context, p_public_key, p_hash, hash_size, p_signature);
+
+    // Deallocate context if allocated
+    if (p_allocated_context != NULL)
+    {
+        NRF_CRYPTO_FREE(p_allocated_context);
+    }
+
+    return result;
+}
+
+
+#endif // NRF_CRYPTO_ECC_ENABLED
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_ecdsa.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_ecdsa.h
new file mode 100644
index 0000000..a7726a5
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_ecdsa.h
@@ -0,0 +1,252 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef NRF_CRYPTO_ECDSA_H__
+#define NRF_CRYPTO_ECDSA_H__
+
+/** @addtogroup nrf_crypto
+ *  @{
+ *  @addtogroup nrf_crypto_ecdsa Elliptic Curve Digital Signature (ECDSA)
+ *  @{
+ *  @brief Provides elliptic curve cryptography functions for digital signature.
+ *
+ *  @addtogroup nrf_crypto_ecdsa_secp160r1    Definitions specific to secp160r1 (NIST 160-bit)
+ *  @addtogroup nrf_crypto_ecdsa_secp160r2    Definitions specific to secp160r2 (NIST 160-bit)
+ *  @addtogroup nrf_crypto_ecdsa_secp192r1    Definitions specific to secp192r1 (NIST 192-bit)
+ *  @addtogroup nrf_crypto_ecdsa_secp224r1    Definitions specific to secp224r1 (NIST 224-bit)
+ *  @addtogroup nrf_crypto_ecdsa_secp256r1    Definitions specific to secp256r1 (NIST 256-bit)
+ *  @addtogroup nrf_crypto_ecdsa_secp384r1    Definitions specific to secp384r1 (NIST 384-bit)
+ *  @addtogroup nrf_crypto_ecdsa_secp521r1    Definitions specific to secp521r1 (NIST 521-bit)
+ *  @addtogroup nrf_crypto_ecdsa_secp160k1    Definitions specific to secp160k1 (Koblitz 160-bit)
+ *  @addtogroup nrf_crypto_ecdsa_secp192k1    Definitions specific to secp192k1 (Koblitz 192-bit)
+ *  @addtogroup nrf_crypto_ecdsa_secp224k1    Definitions specific to secp224k1 (Koblitz 224-bit)
+ *  @addtogroup nrf_crypto_ecdsa_secp256k1    Definitions specific to secp256k1 (Koblitz 256-bit)
+ *  @addtogroup nrf_crypto_ecdsa_bp256r1      Definitions specific to bp256r1 (Brainpool 256-bit)
+ *  @addtogroup nrf_crypto_ecdsa_bp384r1      Definitions specific to bp384r1 (Brainpool 384-bit)
+ *  @addtogroup nrf_crypto_ecdsa_bp512r1      Definitions specific to bp512r1 (Brainpool 512-bit)
+ *  @addtogroup nrf_crypto_ecdsa_curve25519   Definitions specific to Curve25519
+ *  @addtogroup nrf_crypto_ecdsa_ed25519      Definitions specific to Ed25519
+ */
+
+#include <stdint.h>
+#include <stddef.h>
+
+#include "nrf_crypto_error.h"
+#include "nrf_crypto_ecc.h"
+#include "nrf_crypto_ecdsa_shared.h"
+#include "nrf_crypto_ecdsa_backend.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define NRF_CRYPTO_ECDSA_SECP160R1_SIGNATURE_SIZE  (2 * 160 / 8)   /**< @brief Size of a signature for secp160r1 (NIST 160-bit) curve.     @ingroup nrf_crypto_ecdsa_secp160r1 */
+#define NRF_CRYPTO_ECDSA_SECP160R2_SIGNATURE_SIZE  (2 * 160 / 8)   /**< @brief Size of a signature for secp160r2 (NIST 160-bit) curve.     @ingroup nrf_crypto_ecdsa_secp160r2 */
+#define NRF_CRYPTO_ECDSA_SECP192R1_SIGNATURE_SIZE  (2 * 192 / 8)   /**< @brief Size of a signature for secp192r1 (NIST 192-bit) curve.     @ingroup nrf_crypto_ecdsa_secp192r1 */
+#define NRF_CRYPTO_ECDSA_SECP224R1_SIGNATURE_SIZE  (2 * 224 / 8)   /**< @brief Size of a signature for secp224r1 (NIST 224-bit) curve.     @ingroup nrf_crypto_ecdsa_secp224r1 */
+#define NRF_CRYPTO_ECDSA_SECP256R1_SIGNATURE_SIZE  (2 * 256 / 8)   /**< @brief Size of a signature for secp256r1 (NIST 256-bit) curve.     @ingroup nrf_crypto_ecdsa_secp256r1 */
+#define NRF_CRYPTO_ECDSA_SECP384R1_SIGNATURE_SIZE  (2 * 384 / 8)   /**< @brief Size of a signature for secp384r1 (NIST 384-bit) curve.     @ingroup nrf_crypto_ecdsa_secp384r1 */
+#define NRF_CRYPTO_ECDSA_SECP521R1_SIGNATURE_SIZE  (2 * 528 / 8)   /**< @brief Size of a signature for secp521r1 (NIST 521-bit) curve.     @ingroup nrf_crypto_ecdsa_secp521r1 */
+#define NRF_CRYPTO_ECDSA_SECP160K1_SIGNATURE_SIZE  (2 * 160 / 8)   /**< @brief Size of a signature for secp160k1 (Koblitz 160-bit) curve.  @ingroup nrf_crypto_ecdsa_secp160k1 */
+#define NRF_CRYPTO_ECDSA_SECP192K1_SIGNATURE_SIZE  (2 * 192 / 8)   /**< @brief Size of a signature for secp192k1 (Koblitz 192-bit) curve.  @ingroup nrf_crypto_ecdsa_secp192k1 */
+#define NRF_CRYPTO_ECDSA_SECP224K1_SIGNATURE_SIZE  (2 * 224 / 8)   /**< @brief Size of a signature for secp224k1 (Koblitz 224-bit) curve.  @ingroup nrf_crypto_ecdsa_secp224k1 */
+#define NRF_CRYPTO_ECDSA_SECP256K1_SIGNATURE_SIZE  (2 * 256 / 8)   /**< @brief Size of a signature for secp256k1 (Koblitz 256-bit) curve.  @ingroup nrf_crypto_ecdsa_secp256k1 */
+#define NRF_CRYPTO_ECDSA_BP256R1_SIGNATURE_SIZE    (2 * 256 / 8)   /**< @brief Size of a signature for bp256r1 (Brainpool 256-bit) curve.  @ingroup nrf_crypto_ecdsa_bp256r1 */
+#define NRF_CRYPTO_ECDSA_BP384R1_SIGNATURE_SIZE    (2 * 384 / 8)   /**< @brief Size of a signature for bp384r1 (Brainpool 384-bit) curve.  @ingroup nrf_crypto_ecdsa_bp384r1 */
+#define NRF_CRYPTO_ECDSA_BP512R1_SIGNATURE_SIZE    (2 * 512 / 8)   /**< @brief Size of a signature for bp512r1 (Brainpool 512-bit) curve.  @ingroup nrf_crypto_ecdsa_bp512r1 */
+#define NRF_CRYPTO_ECDSA_CURVE25519_SIGNATURE_SIZE (2 * 256 / 8)   /**< @brief Size of a signature for Curve25519 curve.                   @ingroup nrf_crypto_ecdsa_curve25519 */
+#define NRF_CRYPTO_ECDSA_ED25519_SIGNATURE_SIZE    (2 * 256 / 8)   /**< @brief Size of a signature for Ed25519 curve.                      @ingroup nrf_crypto_ecdsa_ed25519 */
+#define NRF_CRYPTO_ECDSA_SIGNATURE_MAX_SIZE        (2 * NRF_CRYPTO_ECC_RAW_PRIVATE_KEY_MAX_SIZE)  /**< @brief Maximum size of a signature for all enabled curves. */
+
+
+typedef uint8_t nrf_crypto_ecdsa_secp160r1_signature_t  [NRF_CRYPTO_ECDSA_SECP160R1_SIGNATURE_SIZE];    /**< @brief Type to hold signature output for secp160r1 (NIST 160-bit) curve.     @ingroup nrf_crypto_ecdsa_secp160r1 */
+typedef uint8_t nrf_crypto_ecdsa_secp160r2_signature_t  [NRF_CRYPTO_ECDSA_SECP160R2_SIGNATURE_SIZE];    /**< @brief Type to hold signature output for secp160r2 (NIST 160-bit) curve.     @ingroup nrf_crypto_ecdsa_secp160r2 */
+typedef uint8_t nrf_crypto_ecdsa_secp192r1_signature_t  [NRF_CRYPTO_ECDSA_SECP192R1_SIGNATURE_SIZE];    /**< @brief Type to hold signature output for secp192r1 (NIST 192-bit) curve.     @ingroup nrf_crypto_ecdsa_secp192r1 */
+typedef uint8_t nrf_crypto_ecdsa_secp224r1_signature_t  [NRF_CRYPTO_ECDSA_SECP224R1_SIGNATURE_SIZE];    /**< @brief Type to hold signature output for secp224r1 (NIST 224-bit) curve.     @ingroup nrf_crypto_ecdsa_secp224r1 */
+typedef uint8_t nrf_crypto_ecdsa_secp256r1_signature_t  [NRF_CRYPTO_ECDSA_SECP256R1_SIGNATURE_SIZE];    /**< @brief Type to hold signature output for secp256r1 (NIST 256-bit) curve.     @ingroup nrf_crypto_ecdsa_secp256r1 */
+typedef uint8_t nrf_crypto_ecdsa_secp384r1_signature_t  [NRF_CRYPTO_ECDSA_SECP384R1_SIGNATURE_SIZE];    /**< @brief Type to hold signature output for secp384r1 (NIST 384-bit) curve.     @ingroup nrf_crypto_ecdsa_secp384r1 */
+typedef uint8_t nrf_crypto_ecdsa_secp521r1_signature_t  [NRF_CRYPTO_ECDSA_SECP521R1_SIGNATURE_SIZE];    /**< @brief Type to hold signature output for secp521r1 (NIST 521-bit) curve.     @ingroup nrf_crypto_ecdsa_secp521r1 */
+typedef uint8_t nrf_crypto_ecdsa_secp160k1_signature_t  [NRF_CRYPTO_ECDSA_SECP160K1_SIGNATURE_SIZE];    /**< @brief Type to hold signature output for secp160k1 (Koblitz 160-bit) curve.  @ingroup nrf_crypto_ecdsa_secp160k1 */
+typedef uint8_t nrf_crypto_ecdsa_secp192k1_signature_t  [NRF_CRYPTO_ECDSA_SECP192K1_SIGNATURE_SIZE];    /**< @brief Type to hold signature output for secp192k1 (Koblitz 192-bit) curve.  @ingroup nrf_crypto_ecdsa_secp192k1 */
+typedef uint8_t nrf_crypto_ecdsa_secp224k1_signature_t  [NRF_CRYPTO_ECDSA_SECP224K1_SIGNATURE_SIZE];    /**< @brief Type to hold signature output for secp224k1 (Koblitz 224-bit) curve.  @ingroup nrf_crypto_ecdsa_secp224k1 */
+typedef uint8_t nrf_crypto_ecdsa_secp256k1_signature_t  [NRF_CRYPTO_ECDSA_SECP256K1_SIGNATURE_SIZE];    /**< @brief Type to hold signature output for secp256k1 (Koblitz 256-bit) curve.  @ingroup nrf_crypto_ecdsa_secp256k1 */
+typedef uint8_t nrf_crypto_ecdsa_bp256r1_signature_t    [NRF_CRYPTO_ECDSA_BP256R1_SIGNATURE_SIZE];      /**< @brief Type to hold signature output for bp256r1 (Brainpool 256-bit) curve.  @ingroup nrf_crypto_ecdsa_bp256r1 */
+typedef uint8_t nrf_crypto_ecdsa_bp384r1_signature_t    [NRF_CRYPTO_ECDSA_BP384R1_SIGNATURE_SIZE];      /**< @brief Type to hold signature output for bp384r1 (Brainpool 384-bit) curve.  @ingroup nrf_crypto_ecdsa_bp384r1 */
+typedef uint8_t nrf_crypto_ecdsa_bp512r1_signature_t    [NRF_CRYPTO_ECDSA_BP512R1_SIGNATURE_SIZE];      /**< @brief Type to hold signature output for bp512r1 (Brainpool 512-bit) curve.  @ingroup nrf_crypto_ecdsa_bp512r1 */
+typedef uint8_t nrf_crypto_ecdsa_curve25519_signature_t [NRF_CRYPTO_ECDSA_CURVE25519_SIGNATURE_SIZE];   /**< @brief Type to hold signature output for Curve25519 curve.                   @ingroup nrf_crypto_ecdsa_curve25519 */
+typedef uint8_t nrf_crypto_ecdsa_ed25519_signature_t    [NRF_CRYPTO_ECDSA_ED25519_SIGNATURE_SIZE];      /**< @brief Type to hold signature output for Ed25519 curve.                      @ingroup nrf_crypto_ecdsa_ed25519 */
+typedef uint8_t nrf_crypto_ecdsa_signature_t            [NRF_CRYPTO_ECDSA_SIGNATURE_MAX_SIZE];          /**< @brief Type big enough to hold signature output for any curve type. */
+
+
+typedef nrf_crypto_backend_secp160r1_sign_context_t  nrf_crypto_ecdsa_secp160r1_sign_context_t;     /**< @brief Context used to store temporary data during signing with curve secp160r1 (NIST 160-bit).     @ingroup nrf_crypto_ecdsa_secp160r1 */
+typedef nrf_crypto_backend_secp160r2_sign_context_t  nrf_crypto_ecdsa_secp160r2_sign_context_t;     /**< @brief Context used to store temporary data during signing with curve secp160r2 (NIST 160-bit).     @ingroup nrf_crypto_ecdsa_secp160r2 */
+typedef nrf_crypto_backend_secp192r1_sign_context_t  nrf_crypto_ecdsa_secp192r1_sign_context_t;     /**< @brief Context used to store temporary data during signing with curve secp192r1 (NIST 192-bit).     @ingroup nrf_crypto_ecdsa_secp192r1 */
+typedef nrf_crypto_backend_secp224r1_sign_context_t  nrf_crypto_ecdsa_secp224r1_sign_context_t;     /**< @brief Context used to store temporary data during signing with curve secp224r1 (NIST 224-bit).     @ingroup nrf_crypto_ecdsa_secp224r1 */
+typedef nrf_crypto_backend_secp256r1_sign_context_t  nrf_crypto_ecdsa_secp256r1_sign_context_t;     /**< @brief Context used to store temporary data during signing with curve secp256r1 (NIST 256-bit).     @ingroup nrf_crypto_ecdsa_secp256r1 */
+typedef nrf_crypto_backend_secp384r1_sign_context_t  nrf_crypto_ecdsa_secp384r1_sign_context_t;     /**< @brief Context used to store temporary data during signing with curve secp384r1 (NIST 384-bit).     @ingroup nrf_crypto_ecdsa_secp384r1 */
+typedef nrf_crypto_backend_secp521r1_sign_context_t  nrf_crypto_ecdsa_secp521r1_sign_context_t;     /**< @brief Context used to store temporary data during signing with curve secp521r1 (NIST 521-bit).     @ingroup nrf_crypto_ecdsa_secp521r1 */
+typedef nrf_crypto_backend_secp160k1_sign_context_t  nrf_crypto_ecdsa_secp160k1_sign_context_t;     /**< @brief Context used to store temporary data during signing with curve secp160k1 (Koblitz 160-bit).  @ingroup nrf_crypto_ecdsa_secp160k1 */
+typedef nrf_crypto_backend_secp192k1_sign_context_t  nrf_crypto_ecdsa_secp192k1_sign_context_t;     /**< @brief Context used to store temporary data during signing with curve secp192k1 (Koblitz 192-bit).  @ingroup nrf_crypto_ecdsa_secp192k1 */
+typedef nrf_crypto_backend_secp224k1_sign_context_t  nrf_crypto_ecdsa_secp224k1_sign_context_t;     /**< @brief Context used to store temporary data during signing with curve secp224k1 (Koblitz 224-bit).  @ingroup nrf_crypto_ecdsa_secp224k1 */
+typedef nrf_crypto_backend_secp256k1_sign_context_t  nrf_crypto_ecdsa_secp256k1_sign_context_t;     /**< @brief Context used to store temporary data during signing with curve secp256k1 (Koblitz 256-bit).  @ingroup nrf_crypto_ecdsa_secp256k1 */
+typedef nrf_crypto_backend_bp256r1_sign_context_t    nrf_crypto_ecdsa_bp256r1_sign_context_t;       /**< @brief Context used to store temporary data during signing with curve bp256r1 (Brainpool 256-bit).  @ingroup nrf_crypto_ecdsa_bp256r1 */
+typedef nrf_crypto_backend_bp384r1_sign_context_t    nrf_crypto_ecdsa_bp384r1_sign_context_t;       /**< @brief Context used to store temporary data during signing with curve bp384r1 (Brainpool 384-bit).  @ingroup nrf_crypto_ecdsa_bp384r1 */
+typedef nrf_crypto_backend_bp512r1_sign_context_t    nrf_crypto_ecdsa_bp512r1_sign_context_t;       /**< @brief Context used to store temporary data during signing with curve bp512r1 (Brainpool 512-bit).  @ingroup nrf_crypto_ecdsa_bp512r1 */
+typedef nrf_crypto_backend_curve25519_sign_context_t nrf_crypto_ecdsa_curve25519_sign_context_t;    /**< @brief Context used to store temporary data during signing with curve Curve25519.                   @ingroup nrf_crypto_ecdsa_curve25519 */
+typedef nrf_crypto_backend_ed25519_sign_context_t    nrf_crypto_ecdsa_ed25519_sign_context_t;       /**< @brief Context used to store temporary data during signing with curve Ed25519.                      @ingroup nrf_crypto_ecdsa_ed25519 */
+
+
+typedef nrf_crypto_backend_secp160r1_verify_context_t  nrf_crypto_ecdsa_secp160r1_verify_context_t;     /**< @brief Context used to store temporary data during verifying with curve secp160r1 (NIST 160-bit).     @ingroup nrf_crypto_ecdsa_secp160r1 */
+typedef nrf_crypto_backend_secp160r2_verify_context_t  nrf_crypto_ecdsa_secp160r2_verify_context_t;     /**< @brief Context used to store temporary data during verifying with curve secp160r2 (NIST 160-bit).     @ingroup nrf_crypto_ecdsa_secp160r2 */
+typedef nrf_crypto_backend_secp192r1_verify_context_t  nrf_crypto_ecdsa_secp192r1_verify_context_t;     /**< @brief Context used to store temporary data during verifying with curve secp192r1 (NIST 192-bit).     @ingroup nrf_crypto_ecdsa_secp192r1 */
+typedef nrf_crypto_backend_secp224r1_verify_context_t  nrf_crypto_ecdsa_secp224r1_verify_context_t;     /**< @brief Context used to store temporary data during verifying with curve secp224r1 (NIST 224-bit).     @ingroup nrf_crypto_ecdsa_secp224r1 */
+typedef nrf_crypto_backend_secp256r1_verify_context_t  nrf_crypto_ecdsa_secp256r1_verify_context_t;     /**< @brief Context used to store temporary data during verifying with curve secp256r1 (NIST 256-bit).     @ingroup nrf_crypto_ecdsa_secp256r1 */
+typedef nrf_crypto_backend_secp384r1_verify_context_t  nrf_crypto_ecdsa_secp384r1_verify_context_t;     /**< @brief Context used to store temporary data during verifying with curve secp384r1 (NIST 384-bit).     @ingroup nrf_crypto_ecdsa_secp384r1 */
+typedef nrf_crypto_backend_secp521r1_verify_context_t  nrf_crypto_ecdsa_secp521r1_verify_context_t;     /**< @brief Context used to store temporary data during verifying with curve secp521r1 (NIST 521-bit).     @ingroup nrf_crypto_ecdsa_secp521r1 */
+typedef nrf_crypto_backend_secp160k1_verify_context_t  nrf_crypto_ecdsa_secp160k1_verify_context_t;     /**< @brief Context used to store temporary data during verifying with curve secp160k1 (Koblitz 160-bit).  @ingroup nrf_crypto_ecdsa_secp160k1 */
+typedef nrf_crypto_backend_secp192k1_verify_context_t  nrf_crypto_ecdsa_secp192k1_verify_context_t;     /**< @brief Context used to store temporary data during verifying with curve secp192k1 (Koblitz 192-bit).  @ingroup nrf_crypto_ecdsa_secp192k1 */
+typedef nrf_crypto_backend_secp224k1_verify_context_t  nrf_crypto_ecdsa_secp224k1_verify_context_t;     /**< @brief Context used to store temporary data during verifying with curve secp224k1 (Koblitz 224-bit).  @ingroup nrf_crypto_ecdsa_secp224k1 */
+typedef nrf_crypto_backend_secp256k1_verify_context_t  nrf_crypto_ecdsa_secp256k1_verify_context_t;     /**< @brief Context used to store temporary data during verifying with curve secp256k1 (Koblitz 256-bit).  @ingroup nrf_crypto_ecdsa_secp256k1 */
+typedef nrf_crypto_backend_bp256r1_verify_context_t    nrf_crypto_ecdsa_bp256r1_verify_context_t;       /**< @brief Context used to store temporary data during verifying with curve bp256r1 (Brainpool 256-bit).  @ingroup nrf_crypto_ecdsa_bp256r1 */
+typedef nrf_crypto_backend_bp384r1_verify_context_t    nrf_crypto_ecdsa_bp384r1_verify_context_t;       /**< @brief Context used to store temporary data during verifying with curve bp384r1 (Brainpool 384-bit).  @ingroup nrf_crypto_ecdsa_bp384r1 */
+typedef nrf_crypto_backend_bp512r1_verify_context_t    nrf_crypto_ecdsa_bp512r1_verify_context_t;       /**< @brief Context used to store temporary data during verifying with curve bp512r1 (Brainpool 512-bit).  @ingroup nrf_crypto_ecdsa_bp512r1 */
+typedef nrf_crypto_backend_curve25519_verify_context_t nrf_crypto_ecdsa_curve25519_verify_context_t;    /**< @brief Context used to store temporary data during verifying with curve Curve25519.                   @ingroup nrf_crypto_ecdsa_curve25519 */
+typedef nrf_crypto_backend_ed25519_verify_context_t    nrf_crypto_ecdsa_ed25519_verify_context_t;       /**< @brief Context used to store temporary data during verifying with curve Ed25519.                      @ingroup nrf_crypto_ecdsa_ed25519 */
+
+
+/** @brief Union holding a context for ECDSA hash sign.
+ */
+typedef union
+{
+    nrf_crypto_ecdsa_secp160r1_sign_context_t  context_secp160r1;    /**< @brief Occupies space for secp160r1 (NIST 160-bit). */
+    nrf_crypto_ecdsa_secp160r2_sign_context_t  context_secp160r2;    /**< @brief Occupies space for secp160r2 (NIST 160-bit). */
+    nrf_crypto_ecdsa_secp192r1_sign_context_t  context_secp192r1;    /**< @brief Occupies space for secp192r1 (NIST 192-bit). */
+    nrf_crypto_ecdsa_secp224r1_sign_context_t  context_secp224r1;    /**< @brief Occupies space for secp224r1 (NIST 224-bit). */
+    nrf_crypto_ecdsa_secp256r1_sign_context_t  context_secp256r1;    /**< @brief Occupies space for secp256r1 (NIST 256-bit). */
+    nrf_crypto_ecdsa_secp384r1_sign_context_t  context_secp384r1;    /**< @brief Occupies space for secp384r1 (NIST 384-bit). */
+    nrf_crypto_ecdsa_secp521r1_sign_context_t  context_secp521r1;    /**< @brief Occupies space for secp521r1 (NIST 521-bit). */
+    nrf_crypto_ecdsa_secp160k1_sign_context_t  context_secp160k1;    /**< @brief Occupies space for secp160k1 (Koblitz 160-bit). */
+    nrf_crypto_ecdsa_secp192k1_sign_context_t  context_secp192k1;    /**< @brief Occupies space for secp192k1 (Koblitz 192-bit). */
+    nrf_crypto_ecdsa_secp224k1_sign_context_t  context_secp224k1;    /**< @brief Occupies space for secp224k1 (Koblitz 224-bit). */
+    nrf_crypto_ecdsa_secp256k1_sign_context_t  context_secp256k1;    /**< @brief Occupies space for secp256k1 (Koblitz 256-bit). */
+    nrf_crypto_ecdsa_bp256r1_sign_context_t    context_bp256r1;      /**< @brief Occupies space for bp256r1 (Brainpool 256-bit). */
+    nrf_crypto_ecdsa_bp384r1_sign_context_t    context_bp384r1;      /**< @brief Occupies space for bp384r1 (Brainpool 384-bit). */
+    nrf_crypto_ecdsa_bp512r1_sign_context_t    context_bp512r1;      /**< @brief Occupies space for bp512r1 (Brainpool 512-bit). */
+    nrf_crypto_ecdsa_curve25519_sign_context_t context_curve25519;   /**< @brief Occupies space for Curve25519. */
+    nrf_crypto_ecdsa_ed25519_sign_context_t    context_ed25519;      /**< @brief Occupies space for Ed25519. */
+} nrf_crypto_ecdsa_sign_context_t;
+
+
+/** @brief Union holding a context for ECDSA hash verify.
+ */
+typedef union
+{
+    nrf_crypto_ecdsa_secp160r1_verify_context_t  context_secp160r1;     /**< @brief Occupies spece for secp160r1 (NIST 160-bit). */
+    nrf_crypto_ecdsa_secp160r2_verify_context_t  context_secp160r2;     /**< @brief Occupies spece for secp160r2 (NIST 160-bit). */
+    nrf_crypto_ecdsa_secp192r1_verify_context_t  context_secp192r1;     /**< @brief Occupies spece for secp192r1 (NIST 192-bit). */
+    nrf_crypto_ecdsa_secp224r1_verify_context_t  context_secp224r1;     /**< @brief Occupies spece for secp224r1 (NIST 224-bit). */
+    nrf_crypto_ecdsa_secp256r1_verify_context_t  context_secp256r1;     /**< @brief Occupies spece for secp256r1 (NIST 256-bit). */
+    nrf_crypto_ecdsa_secp384r1_verify_context_t  context_secp384r1;     /**< @brief Occupies spece for secp384r1 (NIST 384-bit). */
+    nrf_crypto_ecdsa_secp521r1_verify_context_t  context_secp521r1;     /**< @brief Occupies spece for secp521r1 (NIST 521-bit). */
+    nrf_crypto_ecdsa_secp160k1_verify_context_t  context_secp160k1;     /**< @brief Occupies spece for secp160k1 (Koblitz 160-bit). */
+    nrf_crypto_ecdsa_secp192k1_verify_context_t  context_secp192k1;     /**< @brief Occupies spece for secp192k1 (Koblitz 192-bit). */
+    nrf_crypto_ecdsa_secp224k1_verify_context_t  context_secp224k1;     /**< @brief Occupies spece for secp224k1 (Koblitz 224-bit). */
+    nrf_crypto_ecdsa_secp256k1_verify_context_t  context_secp256k1;     /**< @brief Occupies spece for secp256k1 (Koblitz 256-bit). */
+    nrf_crypto_ecdsa_bp256r1_verify_context_t    context_bp256r1;       /**< @brief Occupies spece for bp256r1 (Brainpool 256-bit). */
+    nrf_crypto_ecdsa_bp384r1_verify_context_t    context_bp384r1;       /**< @brief Occupies spece for bp384r1 (Brainpool 384-bit). */
+    nrf_crypto_ecdsa_bp512r1_verify_context_t    context_bp512r1;       /**< @brief Occupies spece for bp512r1 (Brainpool 512-bit). */
+    nrf_crypto_ecdsa_curve25519_verify_context_t context_curve25519;    /**< @brief Occupies spece for Curve25519. */
+    nrf_crypto_ecdsa_ed25519_verify_context_t    context_ed25519;       /**< @brief Occupies spece for Ed25519. */
+} nrf_crypto_ecdsa_verify_context_t;
+
+
+/** @brief Sign a hash of a message.
+ *
+ *  @param[in]     p_context         Pointer to temporary structure holding context information.
+ *                                   If it is NULL, necessary data will be allocated with
+ *                                   @ref NRF_CRYPTO_ALLOC and freed at the end of the function.
+ *  @param[in]     p_private_key     Pointer to structure holding a private key.
+ *  @param[in]     p_hash            Pointer to hash to sign.
+ *  @param[in]     hash_size         Number of bytes in p_hash.
+ *  @param[out]    p_signature       Pointer to buffer where digital signature will be put.
+ *  @param[in,out] p_signature_size  Maximum number of bytes that @p p_signature buffer can hold on input
+ *                                   and the actual number of bytes used by the data on output.
+ *                                   Actual size for selected curve is defined by
+ *                                   the preprocessor definitions, e.g.
+ *                                   @ref NRF_CRYPTO_ECDSA_SECP256R1_SIGNATURE_SIZE.
+ */
+ret_code_t nrf_crypto_ecdsa_sign(
+    nrf_crypto_ecdsa_sign_context_t       * p_context,
+    nrf_crypto_ecc_private_key_t    const * p_private_key,
+    uint8_t                         const * p_hash,
+    size_t                                  hash_size,
+    uint8_t                               * p_signature,
+    size_t                                * p_signature_size);
+
+
+/** @brief Verify a signature using a hash of a message.
+ *
+ *  @param[in]     p_context       Pointer to temporary structure holding context information.
+ *                                 If it is NULL, necessary data will be allocated with
+ *                                 @ref NRF_CRYPTO_ALLOC and freed at the end of the function.
+ *  @param[in]     p_public_key    Pointer to structure holding a public key.
+ *  @param[in]     p_hash          Pointer to hash to verify.
+ *  @param[in]     hash_size       Number of bytes in p_hash.
+ *  @param[in]     p_signature     Pointer to buffer containing digital signature.
+ *  @param[in,out] signature_size  Number of bytes in p_signature.
+ */
+ret_code_t nrf_crypto_ecdsa_verify(
+    nrf_crypto_ecdsa_verify_context_t       * p_context,
+    nrf_crypto_ecc_public_key_t       const * p_public_key,
+    uint8_t                           const * p_hash,
+    size_t                                    hash_size,
+    uint8_t                           const * p_signature,
+    size_t                                    signature_size);
+
+#ifdef __cplusplus
+}
+#endif
+
+/** @}
+ *  @}
+ */
+
+#endif // NRF_CRYPTO_ECDSA_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_ecdsa_backend.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_ecdsa_backend.h
new file mode 100644
index 0000000..78bd2a0
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_ecdsa_backend.h
@@ -0,0 +1,262 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef NRF_CRYPTO_ECDSA_BACKEND_H__
+#define NRF_CRYPTO_ECDSA_BACKEND_H__
+#if !defined(__SDK_DOXYGEN__)
+
+#include <stdint.h>
+#include <stddef.h>
+
+#include "sdk_config.h"
+#include "nrf_crypto_ecdsa_shared.h"
+
+// Include all backends
+#include "cc310_backend_ecdsa.h"
+#include "cc310_bl_backend_ecdsa.h"
+#include "mbedtls_backend_ecdsa.h"
+#include "oberon_backend_ecdsa.h"
+#include "micro_ecc_backend_ecdsa.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#if !NRF_CRYPTO_ECC_SECP160R1_ENABLED
+// Context sizes are zero for disabled functionality
+#define NRF_CRYPTO_BACKEND_SECP160R1_SIGN_CONTEXT_SIZE 0
+#define NRF_CRYPTO_BACKEND_SECP160R1_VERIFY_CONTEXT_SIZE 0
+// Dummy typedefs for disabled contexts
+typedef uint8_t nrf_crypto_backend_secp160r1_sign_context_t;
+typedef uint8_t nrf_crypto_backend_secp160r1_verify_context_t;
+// Backend implementation is NULL to indicate feature not supported
+#define nrf_crypto_backend_secp160r1_sign NULL
+#define nrf_crypto_backend_secp160r1_verify NULL
+#endif
+
+#if !NRF_CRYPTO_ECC_SECP160R2_ENABLED
+// Context sizes are zero for disabled functionality
+#define NRF_CRYPTO_BACKEND_SECP160R2_SIGN_CONTEXT_SIZE 0
+#define NRF_CRYPTO_BACKEND_SECP160R2_VERIFY_CONTEXT_SIZE 0
+// Dummy typedefs for disabled contexts
+typedef uint8_t nrf_crypto_backend_secp160r2_sign_context_t;
+typedef uint8_t nrf_crypto_backend_secp160r2_verify_context_t;
+// Backend implementation is NULL to indicate feature not supported
+#define nrf_crypto_backend_secp160r2_sign NULL
+#define nrf_crypto_backend_secp160r2_verify NULL
+#endif
+
+#if !NRF_CRYPTO_ECC_SECP192R1_ENABLED
+// Context sizes are zero for disabled functionality
+#define NRF_CRYPTO_BACKEND_SECP192R1_SIGN_CONTEXT_SIZE 0
+#define NRF_CRYPTO_BACKEND_SECP192R1_VERIFY_CONTEXT_SIZE 0
+// Dummy typedefs for disabled contexts
+typedef uint8_t nrf_crypto_backend_secp192r1_sign_context_t;
+typedef uint8_t nrf_crypto_backend_secp192r1_verify_context_t;
+// Backend implementation is NULL to indicate feature not supported
+#define nrf_crypto_backend_secp192r1_sign NULL
+#define nrf_crypto_backend_secp192r1_verify NULL
+#endif
+
+#if !NRF_CRYPTO_ECC_SECP224R1_ENABLED
+// Context sizes are zero for disabled functionality
+#define NRF_CRYPTO_BACKEND_SECP224R1_SIGN_CONTEXT_SIZE 0
+#define NRF_CRYPTO_BACKEND_SECP224R1_VERIFY_CONTEXT_SIZE 0
+// Dummy typedefs for disabled contexts
+typedef uint8_t nrf_crypto_backend_secp224r1_sign_context_t;
+typedef uint8_t nrf_crypto_backend_secp224r1_verify_context_t;
+// Backend implementation is NULL to indicate feature not supported
+#define nrf_crypto_backend_secp224r1_sign NULL
+#define nrf_crypto_backend_secp224r1_verify NULL
+#endif
+
+#if !NRF_CRYPTO_ECC_SECP256R1_ENABLED
+// Context sizes are zero for disabled functionality
+#define NRF_CRYPTO_BACKEND_SECP256R1_SIGN_CONTEXT_SIZE 0
+#define NRF_CRYPTO_BACKEND_SECP256R1_VERIFY_CONTEXT_SIZE 0
+// Dummy typedefs for disabled contexts
+typedef uint8_t nrf_crypto_backend_secp256r1_sign_context_t;
+typedef uint8_t nrf_crypto_backend_secp256r1_verify_context_t;
+// Backend implementation is NULL to indicate feature not supported
+#define nrf_crypto_backend_secp256r1_sign NULL
+#define nrf_crypto_backend_secp256r1_verify NULL
+#endif
+
+#if !NRF_CRYPTO_ECC_SECP384R1_ENABLED
+// Context sizes are zero for disabled functionality
+#define NRF_CRYPTO_BACKEND_SECP384R1_SIGN_CONTEXT_SIZE 0
+#define NRF_CRYPTO_BACKEND_SECP384R1_VERIFY_CONTEXT_SIZE 0
+// Dummy typedefs for disabled contexts
+typedef uint8_t nrf_crypto_backend_secp384r1_sign_context_t;
+typedef uint8_t nrf_crypto_backend_secp384r1_verify_context_t;
+// Backend implementation is NULL to indicate feature not supported
+#define nrf_crypto_backend_secp384r1_sign NULL
+#define nrf_crypto_backend_secp384r1_verify NULL
+#endif
+
+#if !NRF_CRYPTO_ECC_SECP521R1_ENABLED
+// Context sizes are zero for disabled functionality
+#define NRF_CRYPTO_BACKEND_SECP521R1_SIGN_CONTEXT_SIZE 0
+#define NRF_CRYPTO_BACKEND_SECP521R1_VERIFY_CONTEXT_SIZE 0
+// Dummy typedefs for disabled contexts
+typedef uint8_t nrf_crypto_backend_secp521r1_sign_context_t;
+typedef uint8_t nrf_crypto_backend_secp521r1_verify_context_t;
+// Backend implementation is NULL to indicate feature not supported
+#define nrf_crypto_backend_secp521r1_sign NULL
+#define nrf_crypto_backend_secp521r1_verify NULL
+#endif
+
+#if !NRF_CRYPTO_ECC_SECP160K1_ENABLED
+// Context sizes are zero for disabled functionality
+#define NRF_CRYPTO_BACKEND_SECP160K1_SIGN_CONTEXT_SIZE 0
+#define NRF_CRYPTO_BACKEND_SECP160K1_VERIFY_CONTEXT_SIZE 0
+// Dummy typedefs for disabled contexts
+typedef uint8_t nrf_crypto_backend_secp160k1_sign_context_t;
+typedef uint8_t nrf_crypto_backend_secp160k1_verify_context_t;
+// Backend implementation is NULL to indicate feature not supported
+#define nrf_crypto_backend_secp160k1_sign NULL
+#define nrf_crypto_backend_secp160k1_verify NULL
+#endif
+
+#if !NRF_CRYPTO_ECC_SECP192K1_ENABLED
+// Context sizes are zero for disabled functionality
+#define NRF_CRYPTO_BACKEND_SECP192K1_SIGN_CONTEXT_SIZE 0
+#define NRF_CRYPTO_BACKEND_SECP192K1_VERIFY_CONTEXT_SIZE 0
+// Dummy typedefs for disabled contexts
+typedef uint8_t nrf_crypto_backend_secp192k1_sign_context_t;
+typedef uint8_t nrf_crypto_backend_secp192k1_verify_context_t;
+// Backend implementation is NULL to indicate feature not supported
+#define nrf_crypto_backend_secp192k1_sign NULL
+#define nrf_crypto_backend_secp192k1_verify NULL
+#endif
+
+#if !NRF_CRYPTO_ECC_SECP224K1_ENABLED
+// Context sizes are zero for disabled functionality
+#define NRF_CRYPTO_BACKEND_SECP224K1_SIGN_CONTEXT_SIZE 0
+#define NRF_CRYPTO_BACKEND_SECP224K1_VERIFY_CONTEXT_SIZE 0
+// Dummy typedefs for disabled contexts
+typedef uint8_t nrf_crypto_backend_secp224k1_sign_context_t;
+typedef uint8_t nrf_crypto_backend_secp224k1_verify_context_t;
+// Backend implementation is NULL to indicate feature not supported
+#define nrf_crypto_backend_secp224k1_sign NULL
+#define nrf_crypto_backend_secp224k1_verify NULL
+#endif
+
+#if !NRF_CRYPTO_ECC_SECP256K1_ENABLED
+// Context sizes are zero for disabled functionality
+#define NRF_CRYPTO_BACKEND_SECP256K1_SIGN_CONTEXT_SIZE 0
+#define NRF_CRYPTO_BACKEND_SECP256K1_VERIFY_CONTEXT_SIZE 0
+// Dummy typedefs for disabled contexts
+typedef uint8_t nrf_crypto_backend_secp256k1_sign_context_t;
+typedef uint8_t nrf_crypto_backend_secp256k1_verify_context_t;
+// Backend implementation is NULL to indicate feature not supported
+#define nrf_crypto_backend_secp256k1_sign NULL
+#define nrf_crypto_backend_secp256k1_verify NULL
+#endif
+
+#if !NRF_CRYPTO_ECC_BP256R1_ENABLED
+// Context sizes are zero for disabled functionality
+#define NRF_CRYPTO_BACKEND_BP256R1_SIGN_CONTEXT_SIZE 0
+#define NRF_CRYPTO_BACKEND_BP256R1_VERIFY_CONTEXT_SIZE 0
+// Dummy typedefs for disabled contexts
+typedef uint8_t nrf_crypto_backend_bp256r1_sign_context_t;
+typedef uint8_t nrf_crypto_backend_bp256r1_verify_context_t;
+// Backend implementation is NULL to indicate feature not supported
+#define nrf_crypto_backend_bp256r1_sign NULL
+#define nrf_crypto_backend_bp256r1_verify NULL
+#endif
+
+#if !NRF_CRYPTO_ECC_BP384R1_ENABLED
+// Context sizes are zero for disabled functionality
+#define NRF_CRYPTO_BACKEND_BP384R1_SIGN_CONTEXT_SIZE 0
+#define NRF_CRYPTO_BACKEND_BP384R1_VERIFY_CONTEXT_SIZE 0
+// Dummy typedefs for disabled contexts
+typedef uint8_t nrf_crypto_backend_bp384r1_sign_context_t;
+typedef uint8_t nrf_crypto_backend_bp384r1_verify_context_t;
+// Backend implementation is NULL to indicate feature not supported
+#define nrf_crypto_backend_bp384r1_sign NULL
+#define nrf_crypto_backend_bp384r1_verify NULL
+#endif
+
+#if !NRF_CRYPTO_ECC_BP512R1_ENABLED
+// Context sizes are zero for disabled functionality
+#define NRF_CRYPTO_BACKEND_BP512R1_SIGN_CONTEXT_SIZE 0
+#define NRF_CRYPTO_BACKEND_BP512R1_VERIFY_CONTEXT_SIZE 0
+// Dummy typedefs for disabled contexts
+typedef uint8_t nrf_crypto_backend_bp512r1_sign_context_t;
+typedef uint8_t nrf_crypto_backend_bp512r1_verify_context_t;
+// Backend implementation is NULL to indicate feature not supported
+#define nrf_crypto_backend_bp512r1_sign NULL
+#define nrf_crypto_backend_bp512r1_verify NULL
+#endif
+
+#if !NRF_CRYPTO_ECC_CURVE25519_ENABLED
+// Context sizes are zero for disabled functionality
+#define NRF_CRYPTO_BACKEND_CURVE25519_SIGN_CONTEXT_SIZE 0
+#define NRF_CRYPTO_BACKEND_CURVE25519_VERIFY_CONTEXT_SIZE 0
+// Dummy typedefs for disabled contexts
+typedef uint8_t nrf_crypto_backend_curve25519_sign_context_t;
+typedef uint8_t nrf_crypto_backend_curve25519_verify_context_t;
+// Backend implementation is NULL to indicate feature not supported
+#define nrf_crypto_backend_curve25519_sign NULL
+#define nrf_crypto_backend_curve25519_verify NULL
+#endif
+
+#if !NRF_CRYPTO_ECC_ED25519_ENABLED
+// Context sizes are zero for disabled functionality
+#define NRF_CRYPTO_BACKEND_ED25519_SIGN_CONTEXT_SIZE 0
+#define NRF_CRYPTO_BACKEND_ED25519_VERIFY_CONTEXT_SIZE 0
+// Dummy typedefs for disabled contexts
+typedef uint8_t nrf_crypto_backend_ed25519_sign_context_t;
+typedef uint8_t nrf_crypto_backend_ed25519_verify_context_t;
+// Backend implementation is NULL to indicate feature not supported
+#define nrf_crypto_backend_ed25519_sign NULL
+#define nrf_crypto_backend_ed25519_verify NULL
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // !defined(__SDK_DOXYGEN__)
+#endif // NRF_CRYPTO_ECDSA_BACKEND_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_ecdsa_shared.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_ecdsa_shared.h
new file mode 100644
index 0000000..70d81ac
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_ecdsa_shared.h
@@ -0,0 +1,103 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef NRF_CRYPTO_ECDSA_SHARED_H__
+#define NRF_CRYPTO_ECDSA_SHARED_H__
+
+#include <stdint.h>
+
+#include "nordic_common.h"
+#include "nrf_crypto_ecc.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/** @internal @brief Function pointer for backend implementation of ECDSA sign.
+ *
+ * @note All parameters provided to the backend are vefified in frontend. Verification includes
+ * checking of NULL pointers, buffer size, initialization values. Front end also take full care of
+ * common ECC key hearder @ref nrf_crypto_internal_ecc_key_header_t.
+ *
+ * @param[in]  p_context       Pointer to context.
+ * @param[in]  p_private_key   Pointer to private key.
+ * @param[in]  p_data          Pointer to data to sign. Data can be a message or a hash. It depends
+ *                             on which version of signing functions is pointed by this function
+ *                             pointer.
+ * @param[in]  data_size       Size of @p p_data.
+ * @param[out] p_signature     Pointer where to put generated signature.
+ */
+typedef ret_code_t (*nrf_crypto_backend_ecdsa_sign_fn_t)(
+    void          * p_context,
+    void    const * p_private_key,
+    uint8_t const * p_data,
+    size_t          data_size,
+    uint8_t       * p_signature);
+
+
+/** @internal @brief Function pointer for backend implementation of ECDSA verify.
+ *
+ * @note All parameters provided to the backend are vefified in frontend. Verification includes
+ * checking of NULL pointers, buffer size, initialization values. Front end also take full care of
+ * common ECC key hearder @ref nrf_crypto_internal_ecc_key_header_t.
+ *
+ * @param[in]  p_context       Pointer to context.
+ * @param[in]  p_public_key    Pointer to public key.
+ * @param[in]  p_data          Pointer to data to verify. Data can be a message or a hash. It depends
+ *                             on which version of signing functions is pointed by this function
+ *                             pointer.
+ * @param[in]  data_size       Size of @p p_data.
+ * @param[in]  p_signature     Pointer to signature to verify.
+ */
+typedef ret_code_t (*nrf_crypto_backend_ecdsa_verify_fn_t)(
+    void          * p_context,
+    void    const * p_public_key,
+    uint8_t const * p_data,
+    size_t          data_size,
+    uint8_t const * p_signature);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // NRF_CRYPTO_ECDSA_SHARED_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_error.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_error.c
new file mode 100644
index 0000000..9a37b01
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_error.c
@@ -0,0 +1,102 @@
+/**
+ * Copyright (c) 2017 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#include "sdk_common.h"
+#if NRF_MODULE_ENABLED(NRF_CRYPTO)
+
+#include "nordic_common.h"
+#include "nrf_crypto_error.h"
+
+typedef struct
+{
+    ret_code_t   error;
+    const char * p_text;
+} error_code_pair;
+
+static const error_code_pair m_crypto_error[] =
+{
+    { NRF_ERROR_CRYPTO_NOT_INITIALIZED,         "nrf_crypto_init was not called prior to this crypto function" },
+    { NRF_ERROR_CRYPTO_CONTEXT_NULL,            "A null pointer was provided for the context structure" },
+    { NRF_ERROR_CRYPTO_CONTEXT_NOT_INITIALIZED, "The context was not initialized prior to this call or it was corrupted. Please call the corresponding init function for the algorithm to initialize it" },
+    { NRF_ERROR_CRYPTO_FEATURE_UNAVAILABLE,     "The function was called with a feature that is unavailable" },
+    { NRF_ERROR_CRYPTO_BUSY,                    "The function could not be called because the crypto backend was busy. Please rerun the cryptographic routine at a later time" },
+    { NRF_ERROR_CRYPTO_INPUT_NULL,              "One or more of the input arguments for this function was NULL" },
+    { NRF_ERROR_CRYPTO_INPUT_LENGTH,            "The length of one or more of the input arguments was invalid" },
+    { NRF_ERROR_CRYPTO_INPUT_LOCATION,          "Input data not in RAM" },
+    { NRF_ERROR_CRYPTO_OUTPUT_NULL,             "One or more of the output arguments for this function was NULL" },
+    { NRF_ERROR_CRYPTO_OUTPUT_LENGTH,           "The length of the one or more output arguments was too small" },
+    { NRF_ERROR_CRYPTO_ALLOC_FAILED,            "A required memory allocation failed" },
+    { NRF_ERROR_CRYPTO_INTERNAL,                "An internal error occurred when calling this function" },
+    { NRF_ERROR_CRYPTO_INVALID_PARAM,           "Invalid combination of input parameters" },
+    { NRF_ERROR_CRYPTO_KEY_SIZE,                "Size of the key is not supported by choosen backend" },
+    { NRF_ERROR_CRYPTO_STACK_OVERFLOW,          "Stack overflow detected" },
+    { NRF_ERROR_CRYPTO_ECC_KEY_NOT_INITIALIZED, "ECC key was not initialized" },
+    { NRF_ERROR_CRYPTO_ECDH_CURVE_MISMATCH,     "Public and private key provided to ECDH have different types of curves" },
+    { NRF_ERROR_CRYPTO_ECDSA_INVALID_SIGNATURE, "Signature verification check reported invalid signature" },
+    { NRF_ERROR_CRYPTO_ECC_INVALID_KEY,         "Provided key is invalid" },
+    { NRF_ERROR_CRYPTO_AES_INVALID_PADDING,     "Message padding is corrupted." },
+    { NRF_ERROR_CRYPTO_AEAD_INVALID_MAC,        "MAC not matching encrypted text" },
+    { NRF_ERROR_CRYPTO_AEAD_NONCE_SIZE,         "Size of the nonce is not supported in this AEAD mode" },
+    { NRF_ERROR_CRYPTO_AEAD_MAC_SIZE,           "Size of the MAC (tag) is not supported in this AEAD mode" },
+    { NRF_ERROR_CRYPTO_RNG_INIT_FAILED,         "Initialization or startup of RNG failed" },
+    { NRF_ERROR_CRYPTO_RNG_RESEED_REQUIRED,     "Reseed required (reseed counter overflowed)" },
+};
+
+char const * nrf_crypto_error_string_get(ret_code_t error)
+{
+    if (error == NRF_SUCCESS)
+    {
+        return "No error";
+    }
+    else
+    {
+        uint32_t i;
+        for (i = 0; i < ARRAY_SIZE(m_crypto_error); i++)
+        {
+            if (m_crypto_error[i].error == error)
+            {
+                return m_crypto_error[i].p_text;
+            }
+        }
+    }
+    return "Error not related to nrf_crypto library";
+}
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO)
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_error.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_error.h
new file mode 100644
index 0000000..970f5fb
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_error.h
@@ -0,0 +1,113 @@
+/**
+ * Copyright (c) 2017 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef NRF_CRYPTO_ERROR_H__
+#define NRF_CRYPTO_ERROR_H__
+
+/**@file
+ *
+ * @defgroup nrf_crypto_error nrf_crypto error codes
+ * @{
+ * @ingroup nrf_crypto
+ *
+ * @details This is the standardized error codes provided when calling nrf_crypto APIs.
+ *          The error codes provided here are enumerated based on @ref NRF_ERROR_CRYPTO_ERR_BASE.
+ *
+ * @note Success code, NRF_SUCCESS, is used if the nrf_crypto operation was successful.
+ *
+ */
+
+#include "sdk_errors.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define NRF_ERROR_CRYPTO_NOT_INITIALIZED            (NRF_ERROR_CRYPTO_ERR_BASE + 0x00)      /**< @ref nrf_crypto_init was not called prior to this crypto function. */
+#define NRF_ERROR_CRYPTO_CONTEXT_NULL               (NRF_ERROR_CRYPTO_ERR_BASE + 0x01)      /**< A null pointer was provided for the context structure. */
+#define NRF_ERROR_CRYPTO_CONTEXT_NOT_INITIALIZED    (NRF_ERROR_CRYPTO_ERR_BASE + 0x02)      /**< The context was not initialized prior to this call or it was corrupted. Call the corresponding init function for the algorithm to initialize it. */
+#define NRF_ERROR_CRYPTO_FEATURE_UNAVAILABLE        (NRF_ERROR_CRYPTO_ERR_BASE + 0x03)      /**< The function was called with a feature that is unavailable. */
+#define NRF_ERROR_CRYPTO_BUSY                       (NRF_ERROR_CRYPTO_ERR_BASE + 0x04)      /**< The function could not be called because the crypto backend was busy. Rerun the cryptographic routine at a later time. */
+
+#define NRF_ERROR_CRYPTO_INPUT_NULL                 (NRF_ERROR_CRYPTO_ERR_BASE + 0x10)      /**< One or more of the input arguments for this function were NULL. */
+#define NRF_ERROR_CRYPTO_INPUT_LENGTH               (NRF_ERROR_CRYPTO_ERR_BASE + 0x11)      /**< The length of one or more of the input arguments was invalid. */
+#define NRF_ERROR_CRYPTO_INPUT_LOCATION             (NRF_ERROR_CRYPTO_ERR_BASE + 0x12)      /**< Input data not in RAM. */
+#define NRF_ERROR_CRYPTO_OUTPUT_NULL                (NRF_ERROR_CRYPTO_ERR_BASE + 0x13)      /**< One or more of the output arguments for this function were NULL. */
+#define NRF_ERROR_CRYPTO_OUTPUT_LENGTH              (NRF_ERROR_CRYPTO_ERR_BASE + 0x14)      /**< The length of one or more output arguments was too small. */
+#define NRF_ERROR_CRYPTO_ALLOC_FAILED               (NRF_ERROR_CRYPTO_ERR_BASE + 0x15)      /**< A required memory allocation failed. */
+#define NRF_ERROR_CRYPTO_INTERNAL                   (NRF_ERROR_CRYPTO_ERR_BASE + 0x16)      /**< An internal error occurred when calling this function. */
+#define NRF_ERROR_CRYPTO_INVALID_PARAM              (NRF_ERROR_CRYPTO_ERR_BASE + 0x17)      /**< Invalid combination of input parameters. */
+#define NRF_ERROR_CRYPTO_KEY_SIZE                   (NRF_ERROR_CRYPTO_ERR_BASE + 0x18)      /**< Size of the key is not supported by choosen backend. */
+#define NRF_ERROR_CRYPTO_STACK_OVERFLOW             (NRF_ERROR_CRYPTO_ERR_BASE + 0x19)      /**< Stack overflow detected. */
+
+#define NRF_ERROR_CRYPTO_ECC_ERR_BASE               (NRF_ERROR_CRYPTO_ERR_BASE + 0x40)      /**< Base error code for ECC. */
+#define NRF_ERROR_CRYPTO_ECC_KEY_NOT_INITIALIZED    (NRF_ERROR_CRYPTO_ECC_ERR_BASE + 0x00)  /**< The key was not initialized. */
+#define NRF_ERROR_CRYPTO_ECDH_CURVE_MISMATCH        (NRF_ERROR_CRYPTO_ECC_ERR_BASE + 0x01)  /**< Public and private key provided to ECDH have different types of curves. */
+#define NRF_ERROR_CRYPTO_ECDSA_INVALID_SIGNATURE    (NRF_ERROR_CRYPTO_ECC_ERR_BASE + 0x02)  /**< Signature verification check reported invalid signature. */
+#define NRF_ERROR_CRYPTO_ECC_INVALID_KEY            (NRF_ERROR_CRYPTO_ECC_ERR_BASE + 0x03)  /**< Provided key is invalid. */
+
+#define NRF_ERROR_CRYPTO_AES_ERR_BASE               (NRF_ERROR_CRYPTO_ERR_BASE + 0x50)      /**< Base error code for all AES modes. */
+#define NRF_ERROR_CRYPTO_AES_INVALID_PADDING        (NRF_ERROR_CRYPTO_AES_ERR_BASE + 0x00)  /**< Message padding is corrupted. */
+
+#define NRF_ERROR_CRYPTO_AEAD_ERR_BASE              (NRF_ERROR_CRYPTO_ERR_BASE + 0x60)      /**< Base error code for all AEAD modes. */
+#define NRF_ERROR_CRYPTO_AEAD_INVALID_MAC           (NRF_ERROR_CRYPTO_AEAD_ERR_BASE + 0x00) /**< MAC not matching encrypted text. */
+#define NRF_ERROR_CRYPTO_AEAD_NONCE_SIZE            (NRF_ERROR_CRYPTO_AEAD_ERR_BASE + 0x01) /**< Size of the nonce is not supported in this AEAD mode. */
+#define NRF_ERROR_CRYPTO_AEAD_MAC_SIZE              (NRF_ERROR_CRYPTO_AEAD_ERR_BASE + 0x02) /**< Size of the MAC (tag) is not supported in this AEAD mode. */
+
+#define NRF_ERROR_CRYPTO_RNG_ERR_BASE               (NRF_ERROR_CRYPTO_ERR_BASE + 0x70)      /**< Base error code for all RNG modes. */
+#define NRF_ERROR_CRYPTO_RNG_INIT_FAILED            (NRF_ERROR_CRYPTO_RNG_ERR_BASE + 0x00)  /**< Initialization or startup of RNG failed. */
+#define NRF_ERROR_CRYPTO_RNG_RESEED_REQUIRED        (NRF_ERROR_CRYPTO_RNG_ERR_BASE + 0x01)  /**< Reseed required (reseed counter overflowed). */
+
+/**
+ * @brief Function for converting an nrf_crypto error to a printable string pointer.
+ *
+ * @param[in] error     Error code.
+ *
+ * @return              Pointer to string explaining nrf_crypto error.
+ * */
+char const * nrf_crypto_error_string_get(ret_code_t error);
+
+#ifdef __cplusplus
+}
+#endif
+
+/** @} */
+
+#endif // NRF_CRYPTO_ERROR_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_hash.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_hash.c
new file mode 100644
index 0000000..a03a9ff
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_hash.c
@@ -0,0 +1,205 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#include "sdk_common.h"
+#if NRF_MODULE_ENABLED(NRF_CRYPTO)
+
+#include "nrf_crypto_error.h"
+#include "nrf_crypto_hash.h"
+#include "nrf_crypto_mem.h"
+#include "nrf_crypto_hash_backend.h"
+#include "nrf_crypto_hash_shared.h"
+#include "nrf_crypto_shared.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_HASH)
+
+static ret_code_t verify_context(nrf_crypto_hash_internal_context_t * const p_context)
+{
+    if (p_context == NULL)
+    {
+        return NRF_ERROR_CRYPTO_CONTEXT_NULL;
+    }
+
+    if (p_context->init_val != NRF_CRYPTO_HASH_INIT_VALUE)
+    {
+        return NRF_ERROR_CRYPTO_CONTEXT_NOT_INITIALIZED;
+    }
+
+    return NRF_SUCCESS;
+}
+
+
+ret_code_t nrf_crypto_hash_init(nrf_crypto_hash_context_t * const p_context,
+                                nrf_crypto_hash_info_t    const * p_info)
+{
+    ret_code_t                              ret_val;
+    nrf_crypto_hash_internal_context_t    * p_int_context;
+
+    VERIFY_TRUE(p_context != NULL, NRF_ERROR_CRYPTO_CONTEXT_NULL);
+    VERIFY_TRUE(p_info != NULL, NRF_ERROR_CRYPTO_INPUT_NULL);
+
+    p_int_context = (nrf_crypto_hash_internal_context_t *) p_context;
+    p_int_context->p_info = p_info;
+
+    ret_val = p_info->init_fn(p_context);
+    if (ret_val != NRF_SUCCESS)
+    {
+        return ret_val;
+    }
+
+    p_int_context->init_val = NRF_CRYPTO_HASH_INIT_VALUE;
+
+    return NRF_SUCCESS;
+}
+
+
+ret_code_t nrf_crypto_hash_update(nrf_crypto_hash_context_t   * const p_context,
+                                  uint8_t                     const * p_data,
+                                  size_t                              data_size)
+{
+    ret_code_t                              ret_val;
+    nrf_crypto_hash_internal_context_t    * p_int_context
+        = (nrf_crypto_hash_internal_context_t *) p_context;
+
+    ret_val = verify_context(p_int_context);
+    if (ret_val != NRF_SUCCESS)
+    {
+        return ret_val;
+    }
+
+    VERIFY_TRUE(p_data != NULL, NRF_ERROR_CRYPTO_INPUT_NULL);
+    
+    // Allow zero size input
+    if (data_size == 0)
+    {
+        return NRF_SUCCESS;
+    }
+
+    ret_val = p_int_context->p_info->update_fn(p_context, p_data, data_size);
+
+    return ret_val;
+}
+
+
+ret_code_t nrf_crypto_hash_finalize(nrf_crypto_hash_context_t * const p_context,
+                                    uint8_t                         * p_digest,
+                                    size_t                    * const p_digest_size)
+{
+    ret_code_t                              ret_val;
+    nrf_crypto_hash_internal_context_t    * p_int_context
+        = (nrf_crypto_hash_internal_context_t *) p_context;
+
+    ret_val = verify_context(p_int_context);
+    if (ret_val != NRF_SUCCESS)
+    {
+        return ret_val;
+    }
+
+    VERIFY_TRUE(p_digest != NULL, NRF_ERROR_CRYPTO_OUTPUT_NULL);
+    VERIFY_TRUE(*p_digest_size >= p_int_context->p_info->digest_size, NRF_ERROR_CRYPTO_OUTPUT_LENGTH);
+
+    ret_val = p_int_context->p_info->finalize_fn(p_context, p_digest, p_digest_size);
+
+    return ret_val;
+}
+
+
+ret_code_t nrf_crypto_hash_calculate(nrf_crypto_hash_context_t    * const p_context,
+                                     nrf_crypto_hash_info_t       const * p_info,
+                                     uint8_t                      const * p_data,
+                                     size_t                               data_size,
+                                     uint8_t                            * p_digest,
+                                     size_t                       * const p_digest_size)
+{
+    ret_code_t                      ret_val;
+    nrf_crypto_hash_context_t     * p_ctx  = (nrf_crypto_hash_context_t *)p_context;
+    void                          * p_allocated_context = NULL;
+
+// Internal allocation of context not available for CC310_BL in order to save code size.
+#if defined(NRF_CRYPTO_BACKEND_CC310_BL_HASH_SHA256_ENABLED) && (NRF_CRYPTO_BACKEND_CC310_BL_HASH_SHA256_ENABLED == 1)
+    
+    // Do nothing
+    
+#elif defined(NRF_CRYPTO_BACKEND_CC310_BL_HASH_SHA256_ENABLED) && (NRF_CRYPTO_BACKEND_CC310_BL_HASH_SHA256_ENABLED == 0)
+    
+    // Validate input. Only validate input parameters that are used locally, others are validated
+    // in the init, update and/or finalize functions.
+    VERIFY_TRUE(p_info != NULL, NRF_ERROR_CRYPTO_INPUT_NULL);
+
+    // Allocate context if needed (not provided by the user).
+    if (p_context == NULL)
+    {
+        p_allocated_context = NRF_CRYPTO_ALLOC(p_info->context_size);
+        if (p_allocated_context == NULL)
+        {
+            return NRF_ERROR_CRYPTO_ALLOC_FAILED;
+        }
+        p_ctx = (nrf_crypto_hash_context_t *)p_allocated_context;
+    }
+    
+#else
+
+    #warning NRF_CRYPTO_BACKEND_CC310_BL_HASH_SHA256_ENABLED define not found in sdk_config.h (Is the sdk_config.h valid?).
+    
+#endif // NRF_CRYPTO_BACKEND_CC310_BL_HASH_SHA256_ENABLED
+
+    ret_val = nrf_crypto_hash_init(p_ctx, p_info);
+    NRF_CRYPTO_VERIFY_SUCCESS_DEALLOCATE(ret_val, p_allocated_context);
+
+    ret_val = nrf_crypto_hash_update(p_ctx, p_data, data_size);
+    NRF_CRYPTO_VERIFY_SUCCESS_DEALLOCATE(ret_val, p_allocated_context);
+
+    ret_val = nrf_crypto_hash_finalize(p_ctx, p_digest, p_digest_size);
+    NRF_CRYPTO_VERIFY_SUCCESS_DEALLOCATE(ret_val, p_allocated_context);
+
+#if !NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_BL_HASH_SHA256)
+    // Free context if allocated internally
+    if (p_allocated_context != NULL)
+    {
+        NRF_CRYPTO_FREE(p_allocated_context);
+    }
+#endif // !NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_CC310_BL_HASH_SHA256)
+
+    return NRF_SUCCESS;
+}
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_HASH)
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO)
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_hash.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_hash.h
new file mode 100644
index 0000000..66159b4
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_hash.h
@@ -0,0 +1,268 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef NRF_CRYPTO_HASH_H__
+#define NRF_CRYPTO_HASH_H__
+
+/** @file
+ *
+ * @defgroup nrf_crypto_hash Cryptographic hash related functions
+ * @{
+ * @ingroup nrf_crypto
+ *
+ * @brief Provides cryptographic hash related functionality through nrf_crypto.
+ */
+
+#include <stdint.h>
+#include "nrf_crypto_types.h"
+#include "nrf_crypto_hash_shared.h"
+#include "nrf_crypto_hash_backend.h"
+#include "app_util.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**@brief External variable declaration to info structure for SHA-256
+ *
+ * @note The variable is defined in the nrf_crypto backend that is
+ *       enabled in the @ref sdk_config.
+ *
+ */
+extern const nrf_crypto_hash_info_t g_nrf_crypto_hash_sha256_info;
+
+
+ /**@brief External variable declaration to info structure for SHA-512
+ *
+ * @note The variable is defined in the nrf_crypto backend that is
+ *       enabled in the @ref sdk_config.
+ *
+ */
+extern const nrf_crypto_hash_info_t g_nrf_crypto_hash_sha512_info;
+
+
+/**
+ * @brief Context type for Hash.
+ *
+ * @note The size of this type is scaled for the largest Hash backend context that is
+ *       enabled in @ref sdk_config.
+ */
+typedef nrf_crypto_backend_hash_context_t nrf_crypto_hash_context_t;
+
+
+/** @brief Type definition for an array holding a SHA-256 hash digest. */
+typedef uint8_t nrf_crypto_hash_sha256_digest_t[NRF_CRYPTO_HASH_SIZE_SHA256];
+
+
+/** @brief Type definition for an array holding a SHA-512 hash digest. */
+typedef uint8_t nrf_crypto_hash_sha512_digest_t[NRF_CRYPTO_HASH_SIZE_SHA512];
+
+
+/**@brief Function for initializing the context structure required to compute a hash digest from
+ *        arbitrary input data.
+ *
+ * @note    The context structure is assumed to be an opaque type defined by the
+ *          nrf_crypto backend.
+ *
+ * @note    The return codes @ref NRF_ERROR_CRYPTO_FEATURE_UNAVAILABLE and
+ *          NRF_ERROR_CRYPTO_INTERNAL only happens in cc310 backend.
+ *
+ * @param[in,out]   p_context       Pointer to structure holding context information for
+ *                                  the hash calculation.
+ * @param[in]       p_info          Pointer to structure holding info about the hash algorithm
+ *                                  used to do the computed hash.
+ *
+ * @retval  NRF_SUCCESS                          The hash initialization was successful.
+ * @retval  NRF_ERROR_CRYPTO_NOT_INITIALIZED     @ref nrf_crypto_init was not called prior to
+ *                                               this crypto function.
+ * @retval  NRF_ERROR_CRYPTO_CONTEXT_NULL        A NULL pointer was provided for the context
+ *                                               structure.
+ * @retval  NRF_ERROR_CRYPTO_INPUT_NULL          The pointer to the info structure was NULL.
+ * @retval  NRF_ERROR_CRYPTO_FEATURE_UNAVAILABLE The function was called with a hash mode that
+ *                                               is unavailable.
+ * @retval  NRF_ERROR_CRYPTO_INTERNAL            An internal error occurred when initializing
+ *                                               the constext in the nrf_crypto backend.
+ */
+ret_code_t nrf_crypto_hash_init(nrf_crypto_hash_context_t * const p_context,
+                                nrf_crypto_hash_info_t    const * p_info);
+
+
+/**@brief Function for updating the hash calculation with partial arbitrary data.
+ *
+ * @details This function should be called one or more times until all arbituary input data
+ *          required for the hash calcuation is provided.
+ *
+ * @note    @ref nrf_crypto_hash_init must be called prior to this function to configure the
+ *          context structure used as input parameter to this function.
+ *
+ * @note    @ref nrf_crypto_hash_finalize must be called after all arbitruary input data
+ *          has been provided to get the calculated hash digest.
+ *
+ * @note    The context object is assumed to be an opaque type defined by the
+ *          nrf_crypto backend.
+ *
+ * @note    The return values @ref NRF_ERROR_CRYPTO_BUSY, @ref NRF_ERROR_CRYPTO_INPUT_LOCATION
+ *          and @ref NRF_ERROR_CRYPTO_INPUT_LOCATION can only occur in CC310 backend.
+ *
+ * @param[in,out]   p_context       Pointer to structure holding context information for
+ *                                  the hash calculation.
+ * @param[in]       p_data          Pointer to data to be hashed.
+ * @param[in]       data_size       Length of the data to be hashed.
+ *
+ * @retval  NRF_SUCCESS                               The hash digest was computed successfully.
+ * @retval  NRF_ERROR_CRYPTO_NOT_INITIALIZED          @ref nrf_crypto_init was not called prior to
+ *                                                    this crypto function.
+ * @retval  NRF_ERROR_CRYPTO_CONTEXT_NOT_INITIALIZED  The context was not initialized prior to
+ *                                                    this call or it was corrupted. Please call
+ *                                                    @ref nrf_crypto_hash_init to initialize it.
+ * @retval  NRF_ERROR_CRYPTO_CONTEXT_NULL             A NULL pointer was provided for the context
+ *                                                    structure.
+ * @retval  NRF_ERROR_CRYPTO_INPUT_NULL               p_data was NULL.
+ * @retval  NRF_ERROR_CRYPTO_INPUT_LOCATION           Input data not in RAM.
+ * @retval  NRF_ERROR_CRYPTO_BUSY                     The function could not be called because the
+ *                                                    nrf_crypto backend was busy. Please rerun the
+ *                                                    cryptographic routine at a later time.
+ * @retval  NRF_ERROR_CRYPTO_INTERNAL                 An internal error occurred in the nrf_crypto
+ *                                                    backend.
+ */
+ret_code_t nrf_crypto_hash_update(nrf_crypto_hash_context_t   * const p_context,
+                                  uint8_t                     const * p_data,
+                                  size_t                              data_size);
+
+/**@brief Function for finalizing computation of a hash digest from arbitrary data.
+ *
+ * @details This function is called to get the calculated
+ *
+ * @note    @ref nrf_crypto_hash_init must be called prior to this function to configure the
+ *          context structure used as input parameter to this function.
+ *
+ * @note    The input data for the calculated hash digest must be provided by calling
+ *          @ref nrf_crypto_hash_update one or more times.
+ *
+ * @note    The context object is assumed to be an opaque type defined by the
+ *          nrf_crypto backend.
+ *
+ * @note    The return values @ref NRF_ERROR_CRYPTO_BUSY and @ref NRF_ERROR_CRYPTO_INPUT_LOCATION
+ *          can only occur in CC310 backend.
+ *
+ *
+ * @param[in]       p_context       Pointer to structure holding context information for
+ *                                  the hash calculation.
+ * @param[out]      p_digest        Pointer to buffer holding the calculated hash digest.
+ * @param[in,out]   p_digest_size   Pointer to a variable holding the length of the calculated hash.
+ *                                  Set this to the length of buffer that p_digest is pointing to.
+ *
+ * @retval  NRF_SUCCESS                               The hash digest was computed successfully.
+ * @retval  NRF_ERROR_CRYPTO_NOT_INITIALIZED          @ref nrf_crypto_init was not called prior to
+ *                                                    this crypto function.
+ * @retval  NRF_ERROR_CRYPTO_CONTEXT_NOT_INITIALIZED  The context was not initialized prior to
+ *                                                    this call or it was corrupted. Please call
+ *                                                    @ref nrf_crypto_hash_init to initialize it.
+ * @retval  NRF_ERROR_CRYPTO_CONTEXT_NULL             A NULL pointer was provided for the context
+ *                                                    structure.
+ * @retval  NRF_ERROR_CRYPTO_OUTPUT_NULL              p_digest or p_digest_size was NULL.
+ * @retval  NRF_ERROR_CRYPTO_OUTPUT_LENGTH            The length of p_digest was too small for
+ *                                                    the hash digest result.
+ * @retval  NRF_ERROR_CRYPTO_BUSY                     The function could not be called because the
+ *                                                    nrf_crypto backend was busy. Please rerun the
+ *                                                    cryptographic routine at a later time.
+ * @retval  NRF_ERROR_CRYPTO_INTERNAL                 An internal error occurred in the nrf_crypto
+ *                                                    backend.
+ */
+ret_code_t nrf_crypto_hash_finalize(nrf_crypto_hash_context_t * const p_context,
+                                    uint8_t                         * p_digest,
+                                    size_t                    * const p_digest_size);
+
+
+/**@brief Function for computing a hash from arbitrary data in a single integrated step.
+ *
+ * @details This function calculates the hash digest from arbitruary data in a single integrated step.
+ *          This means calling init, update and finalize in one step.
+ *
+ * @note    The context object is assumed to be an opaque type defined by the
+ *          nrf_crypto backend.
+ *
+ * @note    The return values @ref NRF_ERROR_CRYPTO_BUSY, @ref NRF_ERROR_CRYPTO_INPUT_LOCATION
+ *          and @ref NRF_ERROR_CRYPTO_INPUT_LOCATION can only occur in CC310 backend.
+ *
+ * @param[in,out]   p_context       Pointer to structure holding context information for
+ *                                  the hash calculation. If this
+ *                                  is set to NULL, it will be allocated by the user configurable
+ *                                  allocate/free function @ref NRF_CRYPTO_ALLOC and
+ *                                  @ref NRF_CRYPTO_FREE.
+ * @param[in]       p_info          Pointer to structure holding info about hash algorithm
+ *                                  for the computed hash.
+ * @param[in]       p_data          Pointer to data to be hashed.
+ * @param[in]       data_size       Length of the data to be hashed.
+ * @param[out]      p_digest        Pointer to buffer holding the calculated hash digest.
+ * @param[in,out]   p_digest_size   Pointer to a variable holding the length of the calculated hash.
+ *                                  Set this to the length of buffer that p_digest is pointing to.
+ *
+ * @retval  NRF_SUCCESS                         The hash initialization was successful.
+ * @retval  NRF_ERROR_CRYPTO_NOT_INITIALIZED    @ref nrf_crypto_init was not called prior to
+ *                                              this crypto function.
+ * @retval  NRF_ERROR_CRYPTO_CONTEXT_NULL       A NULL pointer was provided for the context
+ *                                              structure.
+ * @retval  NRF_ERROR_CRYPTO_INPUT_NULL         p_info or p_data was NULL.
+ * @retval  NRF_ERROR_CRYPTO_INPUT_LOCATION     Input data not in RAM.
+ * @retval  NRF_ERROR_CRYPTO_OUTPUT_NULL        p_digest or p_digest_size was NULL.
+ * @retval  NRF_ERROR_CRYPTO_OUTPUT_LENGTH      The length of p_digest was too small for
+ *                                              the hash digest result.
+ * @retval  NRF_ERROR_CRYPTO_BUSY               The function could not be called because the
+ *                                              nrf_crypto backend was busy. Please rerun the
+ *                                              cryptographic routine at a later time.
+ * @retval  NRF_ERROR_CRYPTO_ALLOC_FAILED       Unable to allocate memory for the context.
+ * @retval  NRF_ERROR_CRYPTO_INTERNAL           An internal error occurred in the nrf_crypto
+ *                                              backend.
+ */
+ret_code_t nrf_crypto_hash_calculate(nrf_crypto_hash_context_t    * const p_context,
+                                     nrf_crypto_hash_info_t       const * p_info,
+                                     uint8_t                      const * p_data,
+                                     size_t                               data_size,
+                                     uint8_t                            * p_digest,
+                                     size_t                       * const p_digest_size);
+
+#ifdef __cplusplus
+}
+#endif
+
+/**@} */
+
+#endif // NRF_CRYPTO_HASH_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_hash_backend.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_hash_backend.h
new file mode 100644
index 0000000..2fbac07
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_hash_backend.h
@@ -0,0 +1,84 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef NRF_CRYPTO_HASH_BACKEND_H__
+#define NRF_CRYPTO_HASH_BACKEND_H__
+
+#include "sdk_common.h"
+#include "cc310_backend_hash.h"
+#include "mbedtls_backend_hash.h"
+#include "oberon_backend_hash.h"
+#include "cc310_bl_backend_hash.h"
+#include "nrf_sw_backend_hash.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if !NRF_MODULE_ENABLED(NRF_CRYPTO_HASH_SHA256)
+
+/**@internal @brief Fallback type for SHA-256 hash context (if no backend is enabled).
+ */
+typedef nrf_crypto_hash_internal_context_t  nrf_crypto_backend_hash_sha256_context_t;
+
+#endif
+
+#if !NRF_MODULE_ENABLED(NRF_CRYPTO_HASH_SHA512)
+
+/**@internal @brief Fallback type for SHA-512 hash context (if no backend is enabled).
+ */
+typedef nrf_crypto_hash_internal_context_t  nrf_crypto_backend_hash_sha512_context_t;
+
+#endif
+
+
+/** @internal @brief Union holding a hash context. */
+typedef union
+{
+    nrf_crypto_backend_hash_sha256_context_t hash_sha256_context;   /**< @brief Holds context for SHA-256. */
+    nrf_crypto_backend_hash_sha512_context_t hash_sha512_context;   /**< @brief Holds context for SHA-512. */
+} nrf_crypto_backend_hash_context_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // NRF_CRYPTO_HASH_BACKEND_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_hash_shared.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_hash_shared.h
new file mode 100644
index 0000000..14205d0
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_hash_shared.h
@@ -0,0 +1,120 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef NRF_CRYPTO_HASH_SHARED_H__
+#define NRF_CRYPTO_HASH_SHARED_H__
+
+#include "stdint.h"
+#include "stddef.h"
+#include "sdk_errors.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define NRF_CRYPTO_HASH_INIT_VALUE  (0x4846526E) //!< Magic value to signal that the nrf_crypto_hash context structure is initialized.
+
+/**@brief Enumeration of supported modes of operation in nrf_crypto_hash
+ */
+typedef enum
+{
+    NRF_CRYPTO_HASH_MODE_SHA256,
+    NRF_CRYPTO_HASH_MODE_SHA512
+} nrf_crypto_hash_mode_t;
+
+
+/**@internal @brief Type declaration to do hash initialization in nrf_crypto backend.
+ *
+ *  This is an internal API. See @ref nrf_crypto_hash_init for documentation.
+ */
+typedef ret_code_t (*nrf_crypto_hash_init_fn_t)(void * const p_context);
+
+
+/**@internal @brief Type declaration to do hash update in nrf_crypto backend.
+ *
+ *  This is an internal API. See @ref nrf_crypto_hash_init for documentation.
+ */
+typedef ret_code_t (*nrf_crypto_hash_update_fn_t)(void        * const p_context,
+                                                  uint8_t     const * p_data,
+                                                  size_t              size);
+
+
+/**@internal @brief Type declaration to do hash finalize in nrf_crypto backend.
+ *
+ *  This is an internal API. See @ref nrf_crypto_hash_finalize for documentation.
+ */
+typedef ret_code_t (*nrf_crypto_hash_finalize_fn_t)(void      * const p_context,
+                                                    uint8_t         * p_digest,
+                                                    size_t    * const p_digest_size);
+
+
+/**@internal @brief Type declaration to for a nrf_crypto_hash info strucure
+ *
+ * @details     This structure contains the calling interface and any meta data required
+ *              to call the nrf_crypto_hash API functions.
+ */
+typedef struct
+{
+    nrf_crypto_hash_init_fn_t      const init_fn;           /**< Function pointer to call to initialize nrf_crypto_hash context in backend. */
+    nrf_crypto_hash_update_fn_t    const update_fn;         /**< Function pointer to call to add data in the hash calculation. */
+    nrf_crypto_hash_finalize_fn_t  const finalize_fn;       /**< Function pointer to call to finalize the hash calculation and return the result. */
+    size_t                         const digest_size;       /**< Size of the digest. */
+    size_t                         const context_size;      /**< Size of the context type. */
+    nrf_crypto_hash_mode_t         const hash_mode;         /**< Mode of hash operation. */
+} nrf_crypto_hash_info_t;
+
+
+/**@internal @brief Type declaration of internal representation of a hash context structure.
+ *
+ * @details     This is an internal type that should not be used directly.
+ */
+typedef struct
+{
+    uint32_t                        init_val;   /**< Value that is set to NRF_CRYPTO_HASH_INIT_VALUE when context has been initialized. */
+    nrf_crypto_hash_info_t  const * p_info;     /**< Pointer to an nrf_crypto_hash info structure. */
+
+} nrf_crypto_hash_internal_context_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // NRF_CRYPTO_HASH_SHARED_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_hkdf.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_hkdf.c
new file mode 100644
index 0000000..00c6c7b
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_hkdf.c
@@ -0,0 +1,225 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#include "sdk_common.h"
+#if NRF_MODULE_ENABLED(NRF_CRYPTO)
+
+#include "stddef.h"
+#include "nrf_assert.h"
+#include "nrf_crypto_hmac.h"
+#include "nrf_crypto_hkdf.h"
+#include "nrf_crypto_error.h"
+#include "nrf_crypto_mem.h"
+#include "nrf_crypto_shared.h"
+#include "nrf_crypto_hmac_shared.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_HMAC)
+
+static ret_code_t hkdf_expand(nrf_crypto_hmac_context_t      * const p_context,
+                              nrf_crypto_hmac_info_t         const * p_info,
+                              uint8_t                        * const p_output_key,
+                              size_t                                 output_key_size,
+                              uint8_t                  const * const p_ainfo,
+                              size_t                                 ainfo_size,
+                              uint8_t                        * const p_temp,
+                              uint8_t                  const * const p_prk,
+                              size_t                                 prk_size)
+{
+    size_t const    hash_digest_size  = p_info->digest_size;
+    uint32_t const  n_iterations      = (output_key_size + hash_digest_size - 1) / hash_digest_size;
+    ret_code_t      err_code          = NRF_SUCCESS;
+    size_t          temp_size;
+    uint8_t         n_current;
+    int             write_offset;
+
+    VERIFY_TRUE(n_iterations <= 255, NRF_ERROR_CRYPTO_OUTPUT_LENGTH);
+
+    write_offset = 0;
+    for (uint32_t i = 0; i < n_iterations; i++)
+    {
+        n_current = i + 1;
+
+        err_code = nrf_crypto_hmac_init(p_context, p_info, p_prk, prk_size);
+        VERIFY_SUCCESS(err_code);
+
+        if (i != 0)
+        {
+            err_code = nrf_crypto_hmac_update(p_context, p_temp, hash_digest_size);
+            VERIFY_SUCCESS(err_code);
+        }
+
+        if (p_ainfo != NULL)
+        {
+            err_code = nrf_crypto_hmac_update(p_context, p_ainfo, ainfo_size);
+            VERIFY_SUCCESS(err_code);
+        }
+
+        err_code = nrf_crypto_hmac_update(p_context, &n_current, 1);
+        VERIFY_SUCCESS(err_code);
+
+        temp_size = hash_digest_size;
+        err_code = nrf_crypto_hmac_finalize(p_context, p_temp, &temp_size);
+        VERIFY_SUCCESS(err_code);
+
+        memcpy(p_output_key + write_offset,
+               p_temp,
+               (n_current != n_iterations) ? hash_digest_size : (output_key_size - write_offset));
+
+        write_offset += hash_digest_size;
+    }
+
+    return err_code;
+}
+
+
+ret_code_t nrf_crypto_hkdf_calculate(nrf_crypto_hmac_context_t      * const p_context,
+                                     nrf_crypto_hmac_info_t         const * p_info,
+                                     uint8_t                        * const p_output_key,
+                                     size_t                         * const p_output_key_size,
+                                     uint8_t                  const * const p_input_key,
+                                     size_t                                 input_key_size,
+                                     uint8_t                        const * p_salt,
+                                     size_t                                 salt_size,
+                                     uint8_t                  const * const p_ainfo,
+                                     size_t                                 ainfo_size,
+                                     nrf_crypto_hkdf_mode_t                 mode)
+{
+    uint8_t         prk[NRF_CRYPTO_HASH_SIZE_SHA512];                           // Scaled for the largest supported hash size.
+    uint8_t         temp[NRF_CRYPTO_HASH_SIZE_SHA512];                          // Scaled for the largest supported hash size.
+    void          * p_ctx                               = NULL;
+    void          * p_allocated_context                 = NULL;
+    size_t          prk_size                            = sizeof(prk);
+    size_t          output_key_size                     = *p_output_key_size;
+    ret_code_t      err_code;
+
+    VERIFY_TRUE(p_info != NULL, NRF_ERROR_CRYPTO_INPUT_NULL);
+    VERIFY_TRUE(p_output_key != NULL, NRF_ERROR_CRYPTO_OUTPUT_NULL);
+    VERIFY_TRUE(*p_output_key_size > 0, NRF_ERROR_CRYPTO_OUTPUT_LENGTH);
+    VERIFY_TRUE(p_input_key != NULL, NRF_ERROR_CRYPTO_INPUT_NULL);
+    VERIFY_TRUE(input_key_size > 0, NRF_ERROR_CRYPTO_INPUT_LENGTH);
+
+    if (p_salt != NULL)
+    {
+        VERIFY_TRUE(salt_size > 0, NRF_ERROR_CRYPTO_INPUT_LENGTH);
+    }
+
+    if (p_ainfo != NULL)
+    {
+        VERIFY_TRUE(ainfo_size > 0, NRF_ERROR_CRYPTO_INPUT_LENGTH);
+    }
+
+    *p_output_key_size = 0; // Set output length to 0 as default value (in case of error).
+
+    // Allocate context internally if p_context is NULL
+    if (p_context == NULL)
+    {
+        p_allocated_context = NRF_CRYPTO_ALLOC(p_info->context_size);
+        if (p_allocated_context == NULL)
+        {
+            return NRF_ERROR_CRYPTO_ALLOC_FAILED;
+        }
+        p_ctx = p_allocated_context;
+    }
+    else
+    {
+        p_ctx = p_context;
+    }
+
+    if (mode == NRF_CRYPTO_HKDF_EXTRACT_AND_EXPAND)
+    {
+        if (p_salt == NULL)
+        {
+            // Use default salt defined in RFC 5869: String of zeros of hash length.
+            salt_size = p_info->digest_size;
+            ASSERT(sizeof(temp) >= salt_size);
+            memset(temp, 0, salt_size);
+            p_salt = temp;
+        }
+
+        // Step 1: Extract
+        err_code = nrf_crypto_hmac_calculate(p_context,
+                                             p_info,
+                                             prk,
+                                             &prk_size,
+                                             p_salt,
+                                             salt_size,
+                                             p_input_key,
+                                             input_key_size);
+        NRF_CRYPTO_VERIFY_SUCCESS_DEALLOCATE(err_code, p_allocated_context);
+
+        // Step 2: Expand
+        err_code = hkdf_expand(p_ctx,
+                               p_info,
+                               p_output_key,
+                               output_key_size,
+                               p_ainfo,
+                               ainfo_size,
+                               temp,
+                               prk,
+                               prk_size);
+        NRF_CRYPTO_VERIFY_SUCCESS_DEALLOCATE(err_code, p_allocated_context);
+    }
+    else // NRF_CRYPTO_HKDF_EXPAND_ONLY
+    {
+        err_code = hkdf_expand(p_ctx,
+                               p_info,
+                               p_output_key,
+                               output_key_size,
+                               p_ainfo,
+                               ainfo_size,
+                               temp,
+                               p_input_key,
+                               input_key_size);
+        NRF_CRYPTO_VERIFY_SUCCESS_DEALLOCATE(err_code, p_allocated_context);
+    }
+
+    if (p_allocated_context != NULL)
+    {
+        NRF_CRYPTO_FREE(p_allocated_context);
+    }
+
+    *p_output_key_size = output_key_size;
+
+    return NRF_SUCCESS;
+}
+
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_HMAC)
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO)
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_hkdf.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_hkdf.h
new file mode 100644
index 0000000..7c84615
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_hkdf.h
@@ -0,0 +1,141 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef NRF_CRYPTO_HKDF_H__
+#define NRF_CRYPTO_HKDF_H__
+
+/** @file
+ *
+ * @defgroup nrf_crypto_hkdf HMAC based Key Derivation Function (HKDF) related functions
+ * @{
+ * @ingroup nrf_crypto
+ *
+ * @brief Provides functions to generate HMAC based Key Derivation Function (HKDF).
+ *
+ * @details Provides functions to generate HMAC based Key Derivation Function (HKDF) using
+ * one of the supported hash algorithms. This layer is independent of backend crypto library.
+ * The HKDF module does not have a backend configuration, as it uses the nrf_crypto_hmac API,
+ * including the backend configured for HMAC in @ref sdk_config.
+ */
+
+
+#include <stdint.h>
+#include "sdk_common.h"
+#include "nrf_crypto_hmac.h"
+#include "nrf_crypto_hkdf.h"
+#include "nrf_crypto_types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/**
+ * @brief Enumeration of HKDF modes.
+ */
+typedef enum
+{
+    NRF_CRYPTO_HKDF_EXTRACT_AND_EXPAND, //!< HKDF Extract and expand mode (normal).
+    NRF_CRYPTO_HKDF_EXPAND_ONLY         //!< HKDF Expand only mode.
+} nrf_crypto_hkdf_mode_t;
+
+
+/**
+ * @brief Integrated HKDF calculation function
+ *
+ * @details This HKDF calculation function uses the nrf_crypto HMAC frontend directly.
+ *          The backend is selected by configuring the HMAC backend in @ref sdk_config.
+ *
+ * @param[in,out]  p_context        Pointer to context structure. Context memory will be
+ *                                  allocated internally if the context pointer is NULL.
+ * @param[in]      p_info           Pointer to static info structure. This defines the algorithm.
+ *                                  This should be either @ref g_nrf_crypto_hmac_sha256_info or
+ *                                  @ref g_nrf_crypto_hmac_sha512_info.
+ * @param[out]     p_output_key     Pointer to buffer to hold the output key material.
+ * @param[in,out]  p_output_key_size Pointer to the length of the wanted output key material as input
+ *                                  and actual length of the output material as output. Can be any
+ *                                  number between 1 and the hash digest size multiplied by 255
+ *                                  (65280 for SHA-256 or 130560 for SHA-512). The p_output_key
+ *                                  buffer must be large enough to hold this value.
+ * @param[in]      p_input_key      Pointer to buffer holding the input key material.
+ * @param[in]      input_key_size   Length of the input key material.
+ * @param[in]      p_salt           Pointer to buffer of nonsecret random salt data. Set to NULL in
+ *                                  order to use the default salt defined by RFC 5869 (all zero
+ *                                  array of hash digest size) or if salt is not used (expand only).
+ * @param[in]      salt_size        Length of the salt. Must be > 0 unless default salt is used, or
+ *                                  in case mode is set to @ref NRF_CRYPTO_HKDF_EXPAND_ONLY.
+ * @param[in]      p_ainfo          Pointer to optional application specific information.
+ *                                  (set to NULL and set ainfo_size to 0 if unused).
+ * @param[in]      ainfo_size       Length of the additional information.
+ * @param[in]      mode             Set to @ref NRF_CRYPTO_HKDF_EXTRACT_AND_EXPAND for normal mode.
+ *                                  Alternatively, set to @ref NRF_CRYPTO_HKDF_EXPAND_ONLY to skip
+ *                                  the extraction step.
+ *
+ * @retval  NRF_SUCCESS                     Output key material hash was successfully calculated.
+ * @retval  NRF_ERROR_CRYPTO_INPUT_NULL     If p_input_key was NULL.
+ * @retval  NRF_ERROR_CRYPTO_INPUT_LENGTH   If input_key_size or salt_size was invalid.
+ * @retval  NRF_ERROR_CRYPTO_OUTPUT_NULL    If p_output_key_sizen was NULL.
+ * @retval  NRF_ERROR_CRYPTO_OUTPUT_LENGTH  If *p_output_key_size is 0.
+ * @retval  NRF_ERROR_CRYPTO_ALLOC_FAILED   Unable to allocate memory for the context.
+ * @retval  NRF_ERROR_CRYPTO_INTERNAL       An error occurred in the crypto backend.
+ * @retval  NRF_ERROR_CRYPTO_BUSY           The function could not be called because the
+ *                                          nrf_crypto backend was busy. Please rerun the
+ *                                          cryptographic routine at a later time. CC310 only.
+ */
+ret_code_t nrf_crypto_hkdf_calculate(nrf_crypto_hmac_context_t      * const p_context,
+                                     nrf_crypto_hmac_info_t         const * p_info,
+                                     uint8_t                        * const p_output_key,
+                                     size_t                         * const p_output_key_size,
+                                     uint8_t                  const * const p_input_key,
+                                     size_t                                 input_key_size,
+                                     uint8_t                        const * p_salt,
+                                     size_t                                 salt_size,
+                                     uint8_t                  const * const p_ainfo,
+                                     size_t                                 ainfo_size,
+                                     nrf_crypto_hkdf_mode_t                 mode);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+/**@} */
+
+#endif // #ifndef NRF_CRYPTO_HKDF_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_hmac.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_hmac.c
new file mode 100644
index 0000000..4bd1546
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_hmac.c
@@ -0,0 +1,203 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#include "sdk_common.h"
+#if NRF_MODULE_ENABLED(NRF_CRYPTO)
+
+#include "stddef.h"
+#include "nrf_log.h"
+#include "nrf_crypto_hmac.h"
+#include "nrf_crypto_hmac_shared.h"
+#include "nrf_crypto_error.h"
+#include "nrf_crypto_init.h"
+#include "nrf_crypto_mem.h"
+#include "nrf_crypto_shared.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_HMAC)
+
+// Magic word that is set when initializing the context and checked by functions that use it.
+#define NRF_CRYPTO_HMAC_INIT_MAGIC_VALUE     0xBADEBA11
+
+
+static ret_code_t verify_context_valid(nrf_crypto_hmac_internal_context_t * const p_context)
+{
+    if (p_context == NULL)
+    {
+        return NRF_ERROR_CRYPTO_CONTEXT_NULL;
+    }
+    else if (p_context->init_value != NRF_CRYPTO_HMAC_INIT_MAGIC_VALUE)
+    {
+        return NRF_ERROR_CRYPTO_CONTEXT_NOT_INITIALIZED;
+    }
+    else
+    {
+        return NRF_SUCCESS;
+    }
+}
+
+
+ret_code_t nrf_crypto_hmac_init(nrf_crypto_hmac_context_t   * const p_context,
+                                nrf_crypto_hmac_info_t      const * p_info,
+                                uint8_t                     const * p_key,
+                                size_t                              key_size)
+{
+    ret_code_t                           err_code;
+    nrf_crypto_hmac_internal_context_t * p_ctx = (nrf_crypto_hmac_internal_context_t *)p_context;
+
+    VERIFY_TRUE(nrf_crypto_is_initialized(), NRF_ERROR_CRYPTO_NOT_INITIALIZED);
+
+    // Validate input
+    VERIFY_TRUE(p_ctx != NULL, NRF_ERROR_CRYPTO_CONTEXT_NULL);
+    VERIFY_TRUE(p_info != NULL, NRF_ERROR_CRYPTO_INPUT_NULL);
+    VERIFY_TRUE(p_key != NULL, NRF_ERROR_CRYPTO_INPUT_NULL);
+    VERIFY_TRUE(key_size > 0, NRF_ERROR_CRYPTO_INPUT_LENGTH);
+
+    // Initialize generic part of the context
+    p_ctx->p_info = p_info;
+
+    // Do backend specific initialization by calling the backend init function pointed
+    // to in the configuration struct in the context (nrf_crypto_hmac_config_t)
+    err_code = p_ctx->p_info->init_fn(p_context, p_key, key_size);
+    if (err_code == NRF_SUCCESS)
+    {
+        p_ctx->init_value = NRF_CRYPTO_HMAC_INIT_MAGIC_VALUE;
+    }
+
+    return err_code;
+}
+
+
+ret_code_t nrf_crypto_hmac_update(nrf_crypto_hmac_context_t * const p_context,
+                                  uint8_t                   const * p_data,
+                                  size_t                            data_size)
+{
+    ret_code_t err_code;
+
+    // The context header by definition has to be the first element of the context struct.
+    nrf_crypto_hmac_internal_context_t * p_ctx = (nrf_crypto_hmac_internal_context_t *)p_context;
+
+    // Validate input
+    err_code = verify_context_valid(p_ctx);
+    VERIFY_SUCCESS(err_code);
+    VERIFY_TRUE(p_data != NULL, NRF_ERROR_CRYPTO_INPUT_NULL);
+    VERIFY_TRUE(data_size > 0, NRF_ERROR_CRYPTO_INPUT_LENGTH);
+
+    // Call backend specific update function (pointed to by config struct in context)
+    err_code = p_ctx->p_info->update_fn(p_context, p_data, data_size);
+
+    return err_code;
+}
+
+
+ret_code_t nrf_crypto_hmac_finalize(nrf_crypto_hmac_context_t   * const p_context,
+                                    uint8_t                           * p_digest,
+                                    size_t                      * const p_digest_size)
+{
+    ret_code_t err_code;
+
+    // The context header by definition has to be the first element of the context struct.
+    nrf_crypto_hmac_internal_context_t * p_ctx = (nrf_crypto_hmac_internal_context_t *)p_context;
+
+    // Validate input
+    err_code = verify_context_valid(p_ctx);
+    VERIFY_SUCCESS(err_code);
+    VERIFY_TRUE(p_digest != NULL, NRF_ERROR_CRYPTO_OUTPUT_NULL);
+    VERIFY_TRUE(*p_digest_size >= p_ctx->p_info->digest_size, NRF_ERROR_CRYPTO_OUTPUT_LENGTH);
+
+    // Call backend specific finish function (pointed to by config struct in context)
+    err_code = p_ctx->p_info->finalize_fn(p_context, p_digest, p_digest_size);
+
+    return err_code;
+}
+
+
+ret_code_t nrf_crypto_hmac_calculate(nrf_crypto_hmac_context_t  * const p_context,
+                                     nrf_crypto_hmac_info_t     const * p_info,
+                                     uint8_t                          * p_digest,
+                                     size_t                     * const p_digest_size,
+                                     uint8_t                    const * p_key,
+                                     size_t                             key_size,
+                                     uint8_t                    const * p_data,
+                                     size_t                             data_size)
+{
+    ret_code_t                      err_code;
+    nrf_crypto_hmac_context_t     * p_ctx;
+    void                          * p_allocated_context = NULL;
+
+    // Validate input. Only validate input parameters that are used locally, others are validated
+    // in the init, update and/or finalize functions.
+    VERIFY_TRUE(p_info != NULL, NRF_ERROR_CRYPTO_INPUT_NULL);
+
+    // Allocate context if needed (not provided by the user).
+    if (p_context == NULL)
+    {
+        p_allocated_context = NRF_CRYPTO_ALLOC(p_info->context_size);
+        if (p_allocated_context == NULL)
+        {
+            return NRF_ERROR_CRYPTO_ALLOC_FAILED;
+        }
+        p_ctx = (nrf_crypto_hmac_context_t *)p_allocated_context;
+    }
+    else
+    {
+        p_ctx = (nrf_crypto_hmac_context_t *)p_context;
+    }
+
+    // Perform integrated HMAC calculation by caling the frontend functions defined in this file
+    err_code = nrf_crypto_hmac_init(p_ctx, p_info, p_key, key_size);
+    NRF_CRYPTO_VERIFY_SUCCESS_DEALLOCATE(err_code, p_allocated_context);
+
+    err_code = nrf_crypto_hmac_update(p_ctx, p_data, data_size);
+    NRF_CRYPTO_VERIFY_SUCCESS_DEALLOCATE(err_code, p_allocated_context);
+
+    err_code = nrf_crypto_hmac_finalize(p_ctx, p_digest, p_digest_size);
+    NRF_CRYPTO_VERIFY_SUCCESS_DEALLOCATE(err_code, p_allocated_context);
+
+    // Free context if allocated internally
+    if (p_allocated_context != NULL)
+    {
+        NRF_CRYPTO_FREE(p_allocated_context);
+    }
+
+    return err_code;
+}
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_HMAC)
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO)
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_hmac.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_hmac.h
new file mode 100644
index 0000000..3a0340f
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_hmac.h
@@ -0,0 +1,226 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef NRF_CRYPTO_HMAC_H__
+#define NRF_CRYPTO_HMAC_H__
+
+/** @file
+ *
+ * @defgroup nrf_crypto_hmac Hash-based message authentication code (HMAC) related functions
+ * @{
+ * @ingroup nrf_crypto
+ *
+ * @brief Provides functions to generate Hash-based message authentication code (HMAC).
+ *
+ * @details Provides functions to generate Hash-based message authentication code (HMAC) using
+ * one of the supported hash algorithms. This layer is independent of backend crypto library.
+ */
+
+#include <stdint.h>
+#include "sdk_common.h"
+#include "nrf_crypto_types.h"
+#include "nrf_crypto_hmac_backend.h"
+#include "nrf_crypto_hmac_shared.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/**
+ * @brief Information structures used to select the specific algorithm (SHA-256)
+ *
+ * @details The information structure is used in a generic way but is populated by the backend,
+ * and contains backend specific data. */
+extern const nrf_crypto_hmac_info_t g_nrf_crypto_hmac_sha256_info;
+
+
+/**
+ * @brief Information structures used to select the specific algorithm (SHA-512)
+ *
+ * @details The information structure is used in a generic way but is populated by the backend,
+ * and contains backend specific data.
+ */
+extern const nrf_crypto_hmac_info_t g_nrf_crypto_hmac_sha512_info;
+
+
+/**
+ * @brief Context type for HMAC.
+ *
+ * @note The size of this type is scaled for the largest HMAC backend context that is
+ *       enabled in @ref sdk_config.
+ */
+typedef nrf_crypto_backend_hmac_context_t nrf_crypto_hmac_context_t;
+
+/**
+ * @brief Initialize context object for HMAC
+ *
+ * @details Use to initialize a context once it has been allocated.
+ *
+ * @note Must be called before @ref nrf_crypto_hmac_update. Can also be called after
+ *       @ref nrf_crypto_hmac_finalize order to start a new HMAC calculation re-using an
+ *       existing context object.
+ *
+ * @param[in,out]   p_context       Pointer to context structure.
+ * @param[in]       p_info          Pointer to static info structure. This defines the algorithm.
+ *                                  This should be either @ref g_nrf_crypto_hmac_sha256_info or
+ *                                  @ref g_nrf_crypto_hmac_sha512_info.
+ * @param[in]       p_key           HMAC key.
+ * @param[in]       key_size        Length of the HMAC key in bytes.
+ *
+ * @retval  NRF_SUCCESS                     Data successfully consumed.
+ * @retval  NRF_ERROR_CRYPTO_CONTEXT_NULL   If p_context has not been initialized.
+ * @retval  NRF_ERROR_CRYPTO_INPUT_NULL     If p_info or p_key was NULL.
+ * @retval  NRF_ERROR_CRYPTO_INPUT_LENGTH   If key_size was invalid.
+ * @retval  NRF_ERROR_CRYPTO_INPUT_LOCATION Input data not in RAM (CC310 only).
+ * @retval  NRF_ERROR_CRYPTO_INTERNAL       An error occurred in the crypto backend.
+ * @retval  NRF_ERROR_CRYPTO_BUSY           The function could not be called because the
+ *                                          nrf_crypto backend was busy. Please rerun
+ *                                          the cryptographic routine at a later time.
+ *                                          CC310 only.
+ */
+ret_code_t nrf_crypto_hmac_init(nrf_crypto_hmac_context_t   * const p_context,
+                                nrf_crypto_hmac_info_t      const * p_info,
+                                uint8_t                     const * p_key,
+                                size_t                              key_size);
+
+
+/**
+ * @brief Feed data to HMAC algorithm.
+ *
+ * @note Must be called after @ref nrf_crypto_hmac_init and before @ref nrf_crypto_hmac_finalize.
+ *       Can be called repeatedly to consume data as it arrives.
+ *
+ * @param[in,out]   p_context   Context pointer.
+ * @param[in]       p_data      Pointer to input data buffer.
+ * @param[in]       data_size   Length of input data.
+ *
+ * @retval  NRF_SUCCESS                                 Data successfully consumed.
+ * @retval  NRF_ERROR_CRYPTO_CONTEXT_NULL               If p_context has not been initialized.
+ * @retval  NRF_ERROR_CRYPTO_CONTEXT_NOT_INITIALIZED    If p_data was NULL.
+ * @retval  NRF_ERROR_CRYPTO_INPUT_NULL                 If p_data was NULL.
+ * @retval  NRF_ERROR_CRYPTO_INPUT_LENGTH               If size was invalid.
+ * @retval  NRF_ERROR_CRYPTO_INPUT_LOCATION             Input data not in RAM (CC310 only).
+ * @retval  NRF_ERROR_CRYPTO_INTERNAL                   An error occurred in the crypto backend.
+ * @retval  NRF_ERROR_CRYPTO_BUSY                       The function could not be called because the
+ *                                                      nrf_crypto backend was busy. Please rerun
+ *                                                      the cryptographic routine at a later time.
+ *                                                      CC310 only.
+ */
+ret_code_t nrf_crypto_hmac_update(nrf_crypto_hmac_context_t * const p_context,
+                                  uint8_t                   const * p_data,
+                                  size_t                            data_size);
+
+
+/**
+ * @brief Calculate HMAC
+ *
+ * @note @ref nrf_crypto_hmac_update must be called at least once before calling this.
+ *
+ * @param[in,out]  p_context     Context pointer.
+ * @param[out]     p_digest      Pointer to HMAC digest (result) buffer. Must be large enough to
+ *                               hold the digest (32 byte for SHA-256 and 64 byte for SHA-512).
+ * @param[in,out]  p_digest_size Length of buffer as input. Length of digest as output.
+ *
+ * @retval  NRF_SUCCESS                                 HMAC hash was successfully calculated.
+ * @retval  NRF_ERROR_CRYPTO_CONTEXT_NULL               If p_context was NULL.
+ * @retval  NRF_ERROR_CRYPTO_CONTEXT_NOT_INITIALIZED    If p_context has not been initialized.
+ * @retval  NRF_ERROR_CRYPTO_OUTPUT_NULL                If p_digest was NULL.
+ * @retval  NRF_ERROR_CRYPTO_OUTPUT_LENGTH              If p_size is not enough to hold the digest.
+ * @retval  NRF_ERROR_CRYPTO_INTERNAL                   An error occurred in the crypto backend.
+ * @retval  NRF_ERROR_CRYPTO_BUSY                       The function could not be called because the
+ *                                                      nrf_crypto backend was busy. Please rerun
+ *                                                      the cryptographic routine at a later time.
+ *                                                      CC310 only.
+ */
+ret_code_t nrf_crypto_hmac_finalize(nrf_crypto_hmac_context_t   * const p_context,
+                                    uint8_t                           * p_digest,
+                                    size_t                      * const p_digest_size);
+
+
+/**
+ * @brief Integrated HMAC wrapper function
+ *
+ * @note This is an integrated wrapper functions that can be used instead of calling other HMAC
+ *       functions individually.
+ *
+ * @param[in,out]  p_context     Optional pointer to context structure.
+ *                               Context memory will be allocated internally if the pointer is NULL.
+ * @param[in]      p_info        Pointer to static info structure. This defines the algorithm.
+ *                               This should be either @ref g_nrf_crypto_hmac_sha256_info or
+ *                               @ref g_nrf_crypto_hmac_sha512_info.
+ * @param[out]     p_digest      Pointer to HMAC digest.
+ *                               Buffer must be large enough to hold the digest.
+ * @param[in,out]  p_digest_size Length of digest (result) buffer as input.
+ *                               Length of digest as output.
+ * @param[in]      p_key         Pointer to HMAC key.
+ * @param[in]      key_size      Lenth of the HMAC key in bytes.
+ * @param[in]      p_data        Pointer to input data.
+ * @param[in]      data_size     Length of input data.
+ *
+ * @retval  NRF_SUCCESS                     HMAC hash was successfully calculated.
+ * @retval  NRF_ERROR_CRYPTO_INPUT_NULL     If p_key or p_data was NULL.
+ * @retval  NRF_ERROR_CRYPTO_INPUT_LOCATION Input data not in RAM (CC310 only).
+ * @retval  NRF_ERROR_CRYPTO_INPUT_LENGTH   If key_size or data_size was invalid.
+ * @retval  NRF_ERROR_CRYPTO_OUTPUT_NULL    If data_size was NULL.
+ * @retval  NRF_ERROR_CRYPTO_OUTPUT_LENGTH  If data_size is not enough to hold the digest.
+ * @retval  NRF_ERROR_CRYPTO_ALLOC_FAILED   Unable to allocate memory for the context.
+ * @retval  NRF_ERROR_CRYPTO_INTERNAL       An error occurred in the crypto backend.
+ * @retval  NRF_ERROR_CRYPTO_BUSY           The function could not be called because the
+ *                                          nrf_crypto backend was busy. Please rerun the
+ *                                          cryptographic routine at a later time. CC310 only.
+ */
+ret_code_t nrf_crypto_hmac_calculate(nrf_crypto_hmac_context_t  * const p_context,
+                                     nrf_crypto_hmac_info_t     const * p_info,
+                                     uint8_t                          * p_digest,
+                                     size_t                     * const p_digest_size,
+                                     uint8_t                    const * p_key,
+                                     size_t                             key_size,
+                                     uint8_t                    const * p_data,
+                                     size_t                             data_size);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+/**@} */
+
+#endif // #ifndef NRF_CRYPTO_HMAC_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_hmac_backend.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_hmac_backend.h
new file mode 100644
index 0000000..4547a8d
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_hmac_backend.h
@@ -0,0 +1,93 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef NRF_CRYPTO_HMAC_BACKEND_H__
+#define NRF_CRYPTO_HMAC_BACKEND_H__
+
+/** @file
+ *
+ * @defgroup nrf_crypto_hmac_backend Meta backend.
+ * @{
+ * @ingroup nrf_crypto_hmac
+ *
+ * @brief Includes all backends definitions.
+ *
+ * @details This file includes all backend definitions, and provide a dummy context in case no
+ * backend is enabled. This is needed so that any project including HMAC headers will still
+ * compile when HMAC is not used/enabled.
+ */
+
+#include "sdk_common.h"
+#include "nrf_crypto_hmac_shared.h"
+#include "mbedtls_backend_hmac.h"
+#include "cc310_backend_hmac.h"
+#include "oberon_backend_hmac.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#ifndef NRF_CRYPTO_HMAC_SHA256_ENABLED
+// /** @internal @brief Fallback context type for HMAC SHA256 in case no backend is selected. */
+typedef nrf_crypto_hmac_internal_context_t nrf_crypto_backend_hmac_sha256_context_t;
+#endif // #ifndef NRF_CRYPTO_HMAC_SHA256_ENABLED
+
+#ifndef NRF_CRYPTO_HMAC_SHA512_ENABLED
+/** @internal @brief Fallback context type for HMAC SHA512 in case no backend is selected. */
+typedef nrf_crypto_hmac_internal_context_t nrf_crypto_backend_hmac_sha512_context_t;
+#endif // #ifndef NRF_CRYPTO_HMAC_SHA512_ENABLED
+
+
+/** @internal @brief Union holding a HMAC context. */
+typedef union
+{
+    nrf_crypto_backend_hmac_sha256_context_t hmac_sha256_context;   /**< @brief Holds context for HMAC SHA-256. */
+    nrf_crypto_backend_hmac_sha512_context_t hmac_sha512_context;   /**< @brief Holds context for HMAC SHA-512. */
+} nrf_crypto_backend_hmac_context_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+/**@} */
+
+#endif // NRF_CRYPTO_HMAC_BACKEND_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_hmac_shared.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_hmac_shared.h
new file mode 100644
index 0000000..c8527f6
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_hmac_shared.h
@@ -0,0 +1,150 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef NRF_CRYPTO_HMAC_SHARED_H__
+#define NRF_CRYPTO_HMAC_SHARED_H__
+
+/** @file
+ *
+ * @defgroup nrf_crypto_hmac_shared Types shared between all @ref nrf_crypto_hmac backends.
+ * @{
+ * @ingroup nrf_crypto_hmac
+ *
+ * @brief Types shared between all @ref nrf_crypto_hmac backends.
+ *
+ * @details These types should not be used directly by the application.
+ */
+
+#include <stdint.h>
+#include "sdk_common.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @internal @brief HMAC algorithm type.
+ */
+typedef enum {
+    NRF_CRYPTO_HMAC_SHA256_TYPE,    //!< HMAC using hash algorithm SHA256
+    NRF_CRYPTO_HMAC_SHA512_TYPE,    //!< HMAC using hash algorithm SHA512
+} nrf_crypto_hmac_type_t;
+
+
+/**
+ * @internal @brief Function pointer type for HMAC backend init function.
+ *
+ * @note The backend function should never be called directly.
+ *       Use @ref nrf_crypto_hmac_init instead.
+ *
+ * @param[in,out]  p_context   Context pointer.
+ * @param[in]      p_key       HMAC key.
+ * @param[in]      key_size    Length of the HMAC key in bytes.
+*/
+typedef ret_code_t (*nrf_crypto_hmac_init_fn_t)(void    * const p_context,
+                                                uint8_t const * p_key,
+                                                size_t          key_size);
+
+
+/**
+ * @internal @brief Function pointer type for HMAC backend update function.
+ *
+ * @note The backend function should never be called directly.
+ *       Use @ref nrf_crypto_hmac_update instead.
+ *
+ * @param[in,out]  p_context   Context pointer.
+ * @param[in]      p_data      Pointer to input data buffer.
+ * @param[in]      size        Length of input data.
+*/
+typedef ret_code_t (*nrf_crypto_hmac_update_fn_t)(void      * const p_context,
+                                                  uint8_t   const * p_data,
+                                                  size_t            size);
+
+
+/**
+ * @internal @brief Function pointer type for HMAC backend finalize function.
+ *
+ * @note The backend function should never be called directly.
+ *       Use @ref nrf_crypto_hmac_finalize instead.
+ *
+ * @param[in,out]  p_context               Context pointer.
+ * @param[out]     p_digest                HMAC digest (result) buffer.
+ * @param[in,out]  p_size                  Length of buffer as input. Length of digest as output.
+*/
+typedef ret_code_t (*nrf_crypto_hmac_finalize_fn_t)(void    * const p_context,
+                                                    uint8_t * const p_digest,
+                                                    size_t        * p_size);
+
+
+/**
+ * @internal @brief structure holding the configuration of each particular algorithm.
+ *
+ * @details This is an internal type that should not be used directly.
+ */
+typedef struct
+{
+    nrf_crypto_hmac_init_fn_t         const init_fn;        //!< Pointer to update function for specific backend.
+    nrf_crypto_hmac_update_fn_t       const update_fn;      //!< Pointer to update function for specific backend.
+    nrf_crypto_hmac_finalize_fn_t     const finalize_fn;    //!< Pointer to finalize function for specific backend.
+    size_t                            const digest_size;    //!< Size of the digest of the HMAC operation.
+    size_t                            const context_size;   //!< Size of the context type.
+    nrf_crypto_hmac_type_t            const type;           //!< HMAC algorithm type.
+} nrf_crypto_hmac_info_t;
+
+
+/**
+ * @internal @brief Common header for each HMAC context structures
+ *
+ * @details This is an internal type that should not be used directly.
+ */
+typedef struct
+{
+    uint32_t                        init_value;     //!< Contains NRF_CRYPTO_HMAC_INIT_MAGIC_VALUE if it is correctly initialized.
+    nrf_crypto_hmac_info_t  const * p_info;         //!< Points to information object related to selected algorithm.
+} nrf_crypto_hmac_internal_context_t;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+/**@} */
+
+#endif // NRF_CRYPTO_HMAC_SHARED_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_init.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_init.c
new file mode 100644
index 0000000..f86d5e2
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_init.c
@@ -0,0 +1,122 @@
+/**
+ * Copyright (c) 2016 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#include "sdk_common.h"
+#if NRF_MODULE_ENABLED(NRF_CRYPTO)
+
+#include "nrf_crypto_init.h"
+#include "nrf_section.h"
+
+
+// Create a named section for crypto backend data
+NRF_SECTION_DEF(crypto_data, const nrf_crypto_backend_info_t);
+
+
+#define NRF_CRYPTO_BACKEND_SECTION_ITEM_GET(i)      NRF_SECTION_ITEM_GET(crypto_data, nrf_crypto_backend_info_t, (i))
+#define NRF_CRYPTO_BACKEND_SECTION_ITEM_COUNT       NRF_SECTION_ITEM_COUNT(crypto_data, nrf_crypto_backend_info_t)
+
+typedef enum
+{
+    UNINITIALIZED,
+    INITIALIZING,
+    INITIALIZED,
+} nrf_crypto_state_t;
+
+static volatile nrf_crypto_state_t m_state = UNINITIALIZED;
+
+
+ret_code_t nrf_crypto_init(void)
+{
+    ret_code_t      ret_val;
+    size_t const    num_backends = NRF_CRYPTO_BACKEND_SECTION_ITEM_COUNT;
+
+    m_state = INITIALIZING;
+
+    // Iterate through each backends to call the init function
+    for (size_t i = 0; i < num_backends; i++)
+    {
+        nrf_crypto_backend_info_t const * p_backend = NRF_CRYPTO_BACKEND_SECTION_ITEM_GET(i);
+        ret_val = p_backend->init_fn();
+        if (ret_val != NRF_SUCCESS)
+        {
+            return ret_val;
+        }
+    }
+
+    // Set nrf_crypto to initialized
+    m_state = INITIALIZED;
+    return NRF_SUCCESS;
+}
+
+
+ret_code_t nrf_crypto_uninit(void)
+{
+    ret_code_t      ret_val;
+    size_t const    num_backends = NRF_CRYPTO_BACKEND_SECTION_ITEM_COUNT;
+
+    // Iterate through each backends to call the uninit function
+    for (size_t i = 0; i < num_backends; i++)
+    {
+        nrf_crypto_backend_info_t const * p_backend = NRF_CRYPTO_BACKEND_SECTION_ITEM_GET(i);
+        ret_val = p_backend->uninit_fn();
+        if (ret_val != NRF_SUCCESS)
+        {
+            return ret_val;
+        }
+    }
+
+    // Set nrf_crypto to uninitialized
+    m_state = UNINITIALIZED;
+    return NRF_SUCCESS;
+}
+
+
+bool nrf_crypto_is_initialized(void)
+{
+    return (m_state == INITIALIZED);
+}
+
+
+bool nrf_crypto_is_initializing(void)
+{
+    return ((m_state == INITIALIZED) || m_state == INITIALIZING);
+}
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO)
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_init.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_init.h
new file mode 100644
index 0000000..a10fdde
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_init.h
@@ -0,0 +1,145 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef NRF_CRYPTO_INIT_H__
+#define NRF_CRYPTO_INIT_H__
+
+/** @file
+ *
+ * @defgroup nrf_crypto_initialization Initialization
+ * @{
+ * @ingroup nrf_crypto
+ *
+ * @brief Initialization related functions for nrf_crypto .
+ *
+ * @details @ref lib_crypto is responsible for global initialization of the nrf_crypto
+ *          frontend and backends that are enabled in @ref sdk_config.
+ */
+
+#include <stdint.h>
+#include <stdbool.h>
+#include "nrf_section.h"
+#include "sdk_errors.h"
+#include "nrf_crypto_types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/**@internal @brief  Macro for registering a nrf_crypto backend for initialization by using
+ *                   nrf_section.
+ *
+ * @details     This macro places a variable in a section named "crypto_data", which
+ *              is initialized by @ref nrf_crypto_init.
+ *
+ * @note    This macro is used internally based on sdk_config.h configurations for nrf_crypto
+ */
+#define CRYPTO_BACKEND_REGISTER(crypto_var) NRF_SECTION_ITEM_REGISTER(crypto_data, crypto_var)
+
+/**@internal @brief Type definition of function pointer to initialize the nrf_crypto backend.
+ *
+ * This function type is used internally. See @nrf_crypto_init for documentation.
+ */
+typedef ret_code_t (*nrf_crypto_backend_init_fn_t)(void);
+
+
+/**@internal @brief Type definition of function pointer to uninitialize the nrf_crypto backend.
+ *
+ * This function type is used internally. Please see @nrf_crypto_uninit for documentation.
+ */
+typedef ret_code_t (*nrf_crypto_backend_uninit_fn_t)(void);
+
+
+
+/**@internal @brief Type definition for structure holding the calling interface to
+ *                  init, uninit, enable, or disable an nrf_crypto_backend
+ *
+ * @note    Some backends require no expressive init, uninit, enable, or disable.
+ *          In this case, the backend will not use this structure type or only select
+ *          to implement
+ */
+typedef struct
+{
+    nrf_crypto_backend_init_fn_t      const init_fn;
+    nrf_crypto_backend_uninit_fn_t    const uninit_fn;
+} nrf_crypto_backend_info_t;
+
+
+/**@brief Function for initializing nrf_crypto and all registered backends.
+ *
+ * @details Must always be called before any other @ref nrf_crypto function.
+ *
+ * @retval  NRF_SUCCESS         The initialization was successful.
+ * @retval  NRF_ERROR_INTERNAL  An internal error occured in the nrf_crypt backend init.
+ */
+ret_code_t nrf_crypto_init(void);
+
+
+/**@brief Function for uninitializing nrf_crypto and all registered backends.
+ *
+ * @retval  NRF_SUCCESS         If unititialization was successful.
+ * @retval  NRF_ERROR_INTERNAL  If an internal error occured in the nrf_crypt backend init.
+ */
+ret_code_t nrf_crypto_uninit(void);
+
+
+/**@brief Function reporting if nrf_crypto has been initialized.
+ *
+ * @retval  True    If cryptographic library is initialized.
+ * @retval  False   If cryptographic library is not initialized.
+ */
+bool nrf_crypto_is_initialized(void);
+
+
+/**@brief Function reporting if nrf_crypto is initialized or is in the process of being initialized.
+ *
+ * @retval  True    If cryptographic library is initializing or already initialized.
+ * @retval  False   If cryptographic library is not initialized.
+ */
+bool nrf_crypto_is_initializing(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+/**@} */
+
+#endif // NRF_CRYPTO_INIT_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_mem.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_mem.h
new file mode 100644
index 0000000..0e2d163
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_mem.h
@@ -0,0 +1,185 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef NRF_CRYPTO_MEM_H__
+#define NRF_CRYPTO_MEM_H__
+
+/** @file
+ *
+ * @defgroup nrf_crypto_mem Dynamic memory management module
+ * @{
+ * @ingroup nrf_crypto
+ *
+ * @brief Module to manage dynamically allocated memory used by nrf_crypto APIs.
+ *
+ * @ref NRF_CRYPTO_ALLOCATOR definition is used to configure this module.
+ */
+
+#include <stdint.h>
+#include "sdk_common.h"
+#include "sdk_config.h"
+#include "nrf_crypto_types.h"
+#include "sdk_alloca.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#ifndef __SDK_DOXYGEN__
+
+
+#define NRF_CRYPTO_ALLOCATOR_DEFAULT    0  /**< @internal @brief Value for NRF_CRYPTO_ALLOCATOR to select default memory allocation. */
+#define NRF_CRYPTO_ALLOCATOR_USER       1  /**< @internal @brief Value for NRF_CRYPTO_ALLOCATOR to select user defined memory allocation. */
+#define NRF_CRYPTO_ALLOCATOR_ALLOCA     2  /**< @internal @brief Value for NRF_CRYPTO_ALLOCATOR to select stack based memory allocation. */
+#define NRF_CRYPTO_ALLOCATOR_MALLOC     3  /**< @internal @brief Value for NRF_CRYPTO_ALLOCATOR to select stdlib's dynamic memory allocation. */
+#define NRF_CRYPTO_ALLOCATOR_NRF_MALLOC 4  /**< @internal @brief Value for NRF_CRYPTO_ALLOCATOR to select mem_manager for memory allocation. */
+
+
+#ifndef NRF_CRYPTO_ALLOCATOR
+#define NRF_CRYPTO_ALLOCATOR NRF_CRYPTO_ALLOCATOR_DEFAULT
+#endif
+
+
+#if NRF_CRYPTO_ALLOCATOR == NRF_CRYPTO_ALLOCATOR_DEFAULT
+#undef NRF_CRYPTO_ALLOCATOR
+#if SDK_ALLOCA_DEFINED && !NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MBEDTLS)
+#define NRF_CRYPTO_ALLOCATOR NRF_CRYPTO_ALLOCATOR_ALLOCA
+#else
+#define NRF_CRYPTO_ALLOCATOR NRF_CRYPTO_ALLOCATOR_NRF_MALLOC
+#endif
+#endif
+
+
+#if NRF_CRYPTO_ALLOCATOR == NRF_CRYPTO_ALLOCATOR_USER
+
+#include "nrf_crypto_allocator.h"
+#ifndef NRF_CRYPTO_ALLOC
+#error "User defined allocator for nrf_crypto does not define NRF_CRYPTO_ALLOC"
+#endif
+#ifndef NRF_CRYPTO_FREE
+#error "User defined allocator for nrf_crypto does not define NRF_CRYPTO_FREE"
+#endif
+#ifndef NRF_CRYPTO_ALLOC_ON_STACK
+#error "User defined allocator for nrf_crypto does not define NRF_CRYPTO_ALLOC_ON_STACK"
+#endif
+
+#elif NRF_CRYPTO_ALLOCATOR == NRF_CRYPTO_ALLOCATOR_ALLOCA
+
+#if !SDK_ALLOCA_DEFINED
+#warning "Stack based allocation is selected, but alloca() is not supported on this platform"
+#endif
+#define NRF_CRYPTO_ALLOC(size)    (alloca((size_t)(size)))
+#define NRF_CRYPTO_FREE(p_buffer) // Empty
+#define NRF_CRYPTO_ALLOC_ON_STACK 1
+
+#elif NRF_CRYPTO_ALLOCATOR == NRF_CRYPTO_ALLOCATOR_MALLOC
+
+#include "stdlib.h"
+#define NRF_CRYPTO_ALLOC(size)    (malloc((size_t)(size)))
+#define NRF_CRYPTO_FREE(p_buffer) (free((void *)(p_buffer)))
+#define NRF_CRYPTO_ALLOC_ON_STACK 0
+
+#elif NRF_CRYPTO_ALLOCATOR == NRF_CRYPTO_ALLOCATOR_NRF_MALLOC
+
+#include "mem_manager.h"
+#define NRF_CRYPTO_ALLOC(size)    (nrf_malloc((uint32_t)(size)))
+#define NRF_CRYPTO_FREE(p_buffer) (nrf_free((void *)(p_buffer)))
+#define NRF_CRYPTO_ALLOC_ON_STACK 0
+
+#else
+
+#error "Invalid NRF_CRYPTO_ALLOCATOR configuration value"
+
+#endif
+
+
+#else // __SDK_DOXYGEN__
+
+
+/** @brief Defines memory allocation function for nrf_crypto.
+ *
+ *  This macro is used internally by nrf_crypto library to allocate temporary memory. It is not
+ *  intended to be used outside nrf_crypto library. How memory is actually allocated is configured
+ *  by @ref NRF_CRYPTO_ALLOCATOR definition.
+ *
+ *  If user macros are selected by @ref NRF_CRYPTO_ALLOCATOR then this macro have to be defined by
+ *  the user in "nrf_crypto_allocator.h" file. The file will be included into "nrf_crypto_mem.h".
+ *
+ *  If @ref NRF_CRYPTO_ALLOC_ON_STACK is 1 then this function will allocate data on stack,
+ *  so make sure that returned pointer is not used outside the caller function.
+ *
+ *  @param size      Number of bytes to allocate.
+ *  @returns         Pointer to newly allocated memory or NULL on error.
+ */
+#define NRF_CRYPTO_ALLOC(size)
+
+/** @brief Defines memory deallocation function for nrf_crypto.
+ *
+ *  This macro is used internally by nrf_crypto library to deallocate temporary memory. It is not
+ *  intended to be used outside nrf_crypto library.
+ *
+ *  If user macros are selected by @ref NRF_CRYPTO_ALLOCATOR then this macro have to be defined by
+ *  the user in "nrf_crypto_allocator.h" file. The file will be included into "nrf_crypto_mem.h".
+ *
+ *  @param p_buffer  Pointer to memory buffer for deallocation.
+ */
+#define NRF_CRYPTO_FREE(p_buffer)
+
+/** @brief Contains 1 if memory allocated by @ref NRF_CRYPTO_ALLOC is on stack or 0 otherwise.
+ *
+ *  This definition is used internally by nrf_crypto library. It is not intended to be used outside
+ *  nrf_crypto library.
+ *
+ *  If user macros are selected by @ref NRF_CRYPTO_ALLOCATOR then this macro have to be defined by
+ *  the user in "nrf_crypto_allocator.h" file. The file will be included into "nrf_crypto_mem.h".
+ */
+#define NRF_CRYPTO_ALLOC_ON_STACK
+
+
+#endif // __SDK_DOXYGEN__
+
+#ifdef __cplusplus
+}
+#endif
+
+/**@} */
+
+ #endif // NRF_CRYPTO_MEM_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_rng.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_rng.c
new file mode 100644
index 0000000..97532a5
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_rng.c
@@ -0,0 +1,430 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#include "sdk_common.h"
+#if NRF_MODULE_ENABLED(NRF_CRYPTO)
+
+#include "nrf_crypto_init.h"
+#include "nrf_log.h"
+#include "nrf_crypto_mem.h"
+#include "nrf_crypto_rng.h"
+#include "nrf_crypto_rng_shared.h"
+#include "nrf_crypto_rng_backend.h"
+#include "nrf_stack_info.h"
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_RNG)
+
+#define NRF_CRYPTO_RNG_MODULE_INIT_MAGIC_VALUE   (0x4be57265)
+
+static nrf_crypto_backend_rng_context_t   * mp_allocated_context    = NULL;
+static nrf_crypto_backend_rng_context_t   * mp_context              = NULL;
+static uint32_t                             m_initialized           = 0;
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_RNG_STATIC_MEMORY_BUFFERS)
+static nrf_crypto_backend_rng_context_t     m_context;
+static nrf_crypto_rng_temp_buffer_t         m_temp_buffer;
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_RNG_STATIC_MEMORY_BUFFERS)
+
+
+static bool is_vector_greater_or_equal(uint8_t    const * const p_vector,
+                                       uint8_t    const * const p_min,
+                                       size_t                   size)
+{
+    for (size_t i = 0; i < size; i++)
+    {
+        if (p_vector[i] != p_min[i])
+        {
+            if (p_vector[i] > p_min[i])
+            {
+                return true;
+            }
+            else
+            {
+                return false;
+            }
+        }
+    }
+
+    return true;
+}
+
+
+// Return true if value p_vector is between (including) p_min and p_max.
+static bool is_vector_in_range(uint8_t    const * const p_vector,
+                               uint8_t    const * const p_min,
+                               uint8_t    const * const p_max,
+                               size_t                   size)
+{
+    if (!is_vector_greater_or_equal(p_vector, p_min, size))
+    {
+        return false;
+    }
+
+    if (!is_vector_greater_or_equal(p_max, p_vector, size))
+    {
+        return false;
+    }
+
+    return true;
+}
+
+
+static uint32_t count_leading_zeros(uint8_t const * const p_vector, size_t size)
+{
+    uint32_t leading_zeros  = 0;
+    uint32_t nonzero_byte   = 0xFF;
+
+    // Find leading all-zero elements.
+    for (uint32_t i = 0; i < size; i++)
+    {
+        if (p_vector[i] == 0)
+        {
+            leading_zeros += 8;
+        }
+        else
+        {
+            nonzero_byte = p_vector[i];
+            break;
+        }
+    }
+
+    // Find leading zeros in non-zero element.
+    for (uint32_t i = 0; i < 8; i++)
+    {
+        nonzero_byte <<= 1;
+
+        if ((nonzero_byte & ~0xff) > 0)
+        {
+            break;
+        }
+
+        leading_zeros ++;
+    }
+
+    return leading_zeros;
+}
+
+
+static ret_code_t generate(uint8_t * const p_target, size_t size, bool use_mutex)
+{
+    ret_code_t ret_code;
+
+    VERIFY_TRUE(p_target != NULL, NRF_ERROR_CRYPTO_OUTPUT_NULL);
+    VERIFY_TRUE(size > 0, NRF_ERROR_CRYPTO_OUTPUT_LENGTH);
+
+    VERIFY_TRUE(m_initialized == NRF_CRYPTO_RNG_MODULE_INIT_MAGIC_VALUE,
+                NRF_ERROR_CRYPTO_CONTEXT_NOT_INITIALIZED);
+
+    ret_code = nrf_crypto_rng_backend_vector_generate(mp_context, p_target, size, use_mutex);
+
+    // Reseed internally and try again if reseed is required by the backend.
+    // (CC310 only as mbed TLS handles reseeding internally.)
+    if (ret_code == NRF_ERROR_CRYPTO_RNG_RESEED_REQUIRED)
+    {
+        ret_code = nrf_crypto_rng_reseed(NULL, NULL, 0);
+
+        if (ret_code != NRF_SUCCESS)
+        {
+            return ret_code;
+        }
+
+        ret_code = nrf_crypto_rng_backend_vector_generate(mp_context, p_target, size, use_mutex);
+    }
+
+    return ret_code;
+}
+
+
+static ret_code_t generate_in_range(uint8_t         * const p_target,
+                                    uint8_t   const * const p_min,
+                                    uint8_t   const * const p_max,
+                                    size_t                  size,
+                                    bool                    use_mutex)
+{
+    uint32_t const  max_leading_zeros = count_leading_zeros(p_max, size);
+    ret_code_t      ret_code;
+
+    VERIFY_TRUE(p_target != NULL, NRF_ERROR_CRYPTO_OUTPUT_NULL);
+    VERIFY_TRUE(size > 0, NRF_ERROR_CRYPTO_OUTPUT_LENGTH);
+    VERIFY_TRUE(p_min != NULL, NRF_ERROR_CRYPTO_INPUT_NULL);
+    VERIFY_TRUE(p_max != NULL, NRF_ERROR_CRYPTO_INPUT_NULL);
+    VERIFY_TRUE(is_vector_greater_or_equal(p_max, p_min, size), NRF_ERROR_CRYPTO_INVALID_PARAM);
+
+    do
+    {
+        ret_code = nrf_crypto_rng_backend_vector_generate(mp_context, p_target, size, use_mutex);
+
+        if (ret_code != NRF_SUCCESS)
+        {
+            return ret_code;
+        }
+
+        // Mask leading zeros in generated vector instead of always discarding a too large vectors.
+        memset(p_target, 0, max_leading_zeros / 8);
+        if ((max_leading_zeros & 0x07) > 0)
+        {
+            p_target[max_leading_zeros / 8] =
+                p_target[max_leading_zeros / 8] & (0xff >> (max_leading_zeros & 0x07));
+        }
+    } while (!is_vector_in_range(p_target, p_min, p_max, size));
+
+    return NRF_SUCCESS;
+}
+
+
+ret_code_t nrf_crypto_rng_vector_generate(uint8_t * const p_target, size_t size)
+{
+    ret_code_t ret_code;
+
+    ret_code = generate(p_target, size, true);
+
+    return ret_code;
+}
+
+
+ret_code_t nrf_crypto_rng_vector_generate_in_range(uint8_t          * const p_target,
+                                                   uint8_t    const * const p_min,
+                                                   uint8_t    const * const p_max,
+                                                   size_t                   size)
+{
+    ret_code_t ret_code;
+
+    ret_code = generate_in_range(p_target, p_min, p_max, size, true);
+
+    return ret_code;
+}
+
+
+ret_code_t nrf_crypto_rng_vector_generate_no_mutex(uint8_t * const p_target, size_t size)
+{
+    ret_code_t ret_code;
+
+    ret_code = generate(p_target, size, false);
+
+    return ret_code;
+}
+
+
+ret_code_t nrf_crypto_rng_vector_generate_in_range_no_mutex(uint8_t         * const p_target,
+                                                            uint8_t   const * const p_min,
+                                                            uint8_t   const * const p_max,
+                                                            size_t                  size)
+{
+    ret_code_t ret_code;
+
+    ret_code = generate_in_range(p_target, p_min, p_max, size, false);
+
+    return ret_code;
+}
+
+
+ret_code_t nrf_crypto_rng_init(nrf_crypto_rng_context_t       * p_context,
+                               nrf_crypto_rng_temp_buffer_t   * p_temp_buffer)
+{
+    ret_code_t                      ret_code;
+    nrf_crypto_rng_temp_buffer_t  * p_allocated_temp_buffer = NULL;
+
+    // Check if the stack has overflowed. This can typically happen if the application has put the
+    // ~6 kB large temp buffer for CC310 on the stack.
+    if (nrf_stack_info_overflowed())
+    {
+        NRF_LOG_ERROR("Stack overflow detected.");
+        return NRF_ERROR_CRYPTO_STACK_OVERFLOW;
+    }
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_RNG_AUTO_INIT)
+    VERIFY_TRUE(nrf_crypto_is_initializing(), NRF_ERROR_CRYPTO_NOT_INITIALIZED);
+#else
+    VERIFY_TRUE(nrf_crypto_is_initialized(), NRF_ERROR_CRYPTO_NOT_INITIALIZED);
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_RNG_AUTO_INIT)
+
+    // Do nothing if RNG module is already initialized.
+    if (mp_context != 0 && (m_initialized == NRF_CRYPTO_RNG_MODULE_INIT_MAGIC_VALUE))
+    {
+        return NRF_SUCCESS;
+    }
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_RNG_STATIC_MEMORY_BUFFERS)
+
+    VERIFY_TRUE(p_context == NULL, NRF_ERROR_CRYPTO_INVALID_PARAM);
+    VERIFY_TRUE(p_temp_buffer == NULL, NRF_ERROR_CRYPTO_INVALID_PARAM);
+
+    mp_context = &m_context;
+    p_temp_buffer = &m_temp_buffer;
+
+#else // !NRF_MODULE_ENABLED(NRF_CRYPTO_RNG_STATIC_MEMORY_BUFFERS)
+
+    if (p_context == NULL)
+    {
+        if (NRF_CRYPTO_ALLOC_ON_STACK)
+        {
+            NRF_LOG_ERROR("RNG context cannot be allocated on the stack.");
+            return NRF_ERROR_CRYPTO_ALLOC_FAILED;
+        }
+        else
+        {
+            mp_allocated_context = NRF_CRYPTO_ALLOC(sizeof(nrf_crypto_backend_rng_context_t));
+            if (mp_allocated_context == NULL)
+            {
+                return NRF_ERROR_CRYPTO_ALLOC_FAILED;
+            }
+            mp_context = mp_allocated_context;
+        }
+    }
+    else
+    {
+        mp_context = p_context;
+    }
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_RNG_STATIC_MEMORY_BUFFERS)
+
+    // Allocate temporary buffer internally if not statically allocated or provided by the user.
+    if (p_temp_buffer == NULL)
+    {
+        p_allocated_temp_buffer = NRF_CRYPTO_ALLOC(sizeof(nrf_crypto_rng_temp_buffer_t));
+
+        if (p_allocated_temp_buffer == NULL)
+        {
+            if (mp_allocated_context != NULL)
+            {
+                NRF_CRYPTO_FREE(mp_allocated_context);
+            }
+
+            return NRF_ERROR_CRYPTO_ALLOC_FAILED;
+        }
+
+        p_temp_buffer = p_allocated_temp_buffer;
+    }
+
+    ret_code = nrf_crypto_rng_backend_init(mp_context, p_temp_buffer);
+    if (ret_code == NRF_SUCCESS)
+    {
+        m_initialized = NRF_CRYPTO_RNG_MODULE_INIT_MAGIC_VALUE;
+        mp_context->header.init_value = NRF_CRYPTO_RNG_CONTEXT_INIT_MAGIC_VALUE;
+    }
+
+    if (p_allocated_temp_buffer != NULL)
+    {
+        NRF_CRYPTO_FREE(p_allocated_temp_buffer);
+    }
+
+    return ret_code;
+}
+
+
+ret_code_t nrf_crypto_rng_uninit(void)
+{
+    ret_code_t ret_code;
+
+    VERIFY_TRUE(m_initialized == NRF_CRYPTO_RNG_MODULE_INIT_MAGIC_VALUE,
+                NRF_ERROR_CRYPTO_CONTEXT_NOT_INITIALIZED);
+
+    VERIFY_TRUE(mp_context->header.init_value == NRF_CRYPTO_RNG_CONTEXT_INIT_MAGIC_VALUE,
+                NRF_ERROR_CRYPTO_CONTEXT_NOT_INITIALIZED);
+
+    mp_context->header.init_value = 0;
+    m_initialized = 0;
+
+    ret_code = nrf_crypto_rng_backend_uninit(mp_context);
+
+    if (mp_allocated_context != NULL)
+    {
+        NRF_CRYPTO_FREE(mp_allocated_context);
+    }
+
+    return ret_code;
+}
+
+
+ret_code_t nrf_crypto_rng_reseed(nrf_crypto_rng_temp_buffer_t * p_temp_buffer,
+                                 uint8_t                      * p_input_data,
+                                 size_t                         size)
+{
+    ret_code_t      ret_code;
+    void          * p_allocated_temp_buffer = NULL;
+
+    // Check if the stack has overflowed. This can typically happen if the application has put the
+    // ~6 kB large temp buffer for CC310 on the stack.
+    if (nrf_stack_info_overflowed())
+    {
+        NRF_LOG_ERROR("Stack overflow detected.");
+        return NRF_ERROR_CRYPTO_STACK_OVERFLOW;
+    }
+
+    if (size > 0)
+    {
+        VERIFY_TRUE(p_input_data != NULL, NRF_ERROR_CRYPTO_INPUT_NULL);
+    }
+
+    VERIFY_TRUE(m_initialized == NRF_CRYPTO_RNG_MODULE_INIT_MAGIC_VALUE,
+                NRF_ERROR_CRYPTO_CONTEXT_NOT_INITIALIZED);
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO_RNG_STATIC_MEMORY_BUFFERS)
+
+    VERIFY_TRUE(p_temp_buffer == NULL, NRF_ERROR_CRYPTO_INVALID_PARAM);
+    p_temp_buffer = &m_temp_buffer;
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_RNG_STATIC_MEMORY_BUFFERS)
+
+    // Allocate temporary buffer internally if not statically allocated or provided by the user.
+    if (p_temp_buffer == NULL)
+    {
+        p_allocated_temp_buffer = NRF_CRYPTO_ALLOC(sizeof(nrf_crypto_rng_temp_buffer_t));
+        if (p_allocated_temp_buffer == NULL)
+        {
+            return NRF_ERROR_CRYPTO_ALLOC_FAILED;
+        }
+        p_temp_buffer = (nrf_crypto_rng_temp_buffer_t *)p_allocated_temp_buffer;
+    }
+
+    ret_code = nrf_crypto_rng_backend_reseed(mp_context, p_temp_buffer, p_input_data, size);
+
+    if (p_allocated_temp_buffer != NULL)
+    {
+        NRF_CRYPTO_FREE(p_allocated_temp_buffer);
+    }
+
+    return ret_code;
+}
+
+
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO_RNG)
+#endif // NRF_MODULE_ENABLED(NRF_CRYPTO)
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_rng.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_rng.h
new file mode 100644
index 0000000..bb50218
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_rng.h
@@ -0,0 +1,285 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef NRF_CRYPTO_RNG_H__
+#define NRF_CRYPTO_RNG_H__
+
+/** @file
+ *
+ * @defgroup nrf_crypto_rng RNG related functions
+ * @{
+ * @ingroup nrf_crypto
+ *
+ * @brief RNG related functions
+ *
+ * @details There are two available RNG backends:
+ *              - ARM CryptoCell CC310 (default for devices with CC310).
+ *              - nRF HW RNG peripheral.
+ *                * CTR-DRBG mode - nRF HW RNG used for seeding mbed TLS CTR-DRBG (default for
+ *                  devices without CC310).
+ *                * Raw mode - all data is generated by the nRF HW RNG.
+ *
+ *          The CC310 backend meets the standards NIST 800-90B3 and AIS-31 (Class “P2 High”), and
+ *          should be preferred in most cases on devices that includes the CC310 core. Devices that
+ *          do not include CC310 should normally use the nRF HW RNG with mbed TLS CTR-DRBG. The
+ *          mbed TLS CTR-DRBG code is standardized by NIST (SP 800-90A Rev. 1).
+ */
+
+#include "sdk_common.h"
+#include "nrf_crypto_error.h"
+#include "nrf_crypto_rng_shared.h"
+#include "nrf_crypto_rng_backend.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/**
+ * @brief Context type for RNG.
+ *
+ * @note The actual type depend on the backend in use.
+ */
+typedef nrf_crypto_backend_rng_context_t nrf_crypto_rng_context_t;
+
+
+/**
+ * @brief Temporary work buffer type for RNG.
+ *
+ * @details Only needed during initializing. Can be freed when @ref nrf_crypto_rng_init has
+ *          returned. Not needed if @ref NRF_CRYPTO_RNG_STATIC_MEMORY_BUFFERS_ENABLED is enabled
+ *          in @ref sdk_config.
+ *
+ * @note The actual type depend on the backend in use.
+ */
+typedef nrf_crypto_backend_rng_temp_buffer_t nrf_crypto_rng_temp_buffer_t;
+
+
+/**@brief Initialize the random number generator.
+ *
+ * @details This function has no effect when @ref NRF_CRYPTO_RNG_AUTO_INIT_ENABLED is enabled.
+ *
+ * @warning The p_temp_buffer is 6112 bytes when using the CC310 backend. Ensure that stack size
+ *          is sufficient if allocated on stack. Applications that use nRF HW RNG as backend or are
+ *          not RAM constrained can use internal static allocation of context and temporary buffers
+ *          (@ref NRF_CRYPTO_RNG_STATIC_MEMORY_BUFFERS_ENABLED).
+ *
+ * @note  The context object can be reused without the need for a full reinitialization of the
+ *        backend in case of for example wakeup from system OFF, provided that the context is
+ *        located in a memory block that is retained. This only apply to the CC310 backend, and when
+ *        the context is allocated manually (NRF_CRYPTO_RNG_STATIC_MEMORY_BUFFERS_ENABLED disabled).
+ *
+ * @param[in]       p_context       Pointer to context memory. The context will be managed
+ *                                  internally, and the pointer is not used for subsequent calls to
+ *                                  the nrf_crypto_rng API. The context memory is needed until
+ *                                  @ref nrf_crypto_rng_uninit is called, so it should normally not
+ *                                  be on the stack. Use NULL if
+ *                                  @ref NRF_CRYPTO_RNG_STATIC_MEMORY_BUFFERS_ENABLED is enabled
+ *                                  in @ref sdk_config (recommended for most applications).
+ *
+ * @param[in,out]   p_temp_buffer   Temporary buffer needed during initialization of the backend. It
+ *                                  is not used after the return of this function, and can be freed
+ *                                  at that point. Buffer is allocated internally if the pointer is
+ *                                  NULL, using the allocated defined by @ref NRF_CRYPTO_ALLOCATOR
+ *                                  in @c sdk_config.h. Use NULL if
+ *                                  @ref NRF_CRYPTO_RNG_STATIC_MEMORY_BUFFERS_ENABLED is enabled
+ *                                  in @ref sdk_config (recommended for most applications).
+ *
+ * @retval  NRF_SUCCESS                         If random number generator was initialized
+ *                                              successfully.
+ * @retval  NRF_ERROR_CRYPTO_NOT_INITIALIZED    @ref nrf_crypto_init was not called prior to this
+ *                                              function.
+ * @retval  NRF_ERROR_CRYPTO_CONTEXT_NULL       p_context was NULL.
+ * @retval  NRF_ERROR_CRYPTO_INTERNAL           If an internal error occurred in the nrf_crypto
+ *                                              backend.
+ * @retval  NRF_ERROR_CRYPTO_ALLOC_FAILED       Unable to allocate memory for the context or work
+ *                                              buffer.
+ * @retval  NRF_ERROR_CRYPTO_STACK_OVERFLOW     Stack overflow detected. Typically caused by
+ *                                              allocating an instance of
+ *                                              @ref nrf_crypto_rng_temp_buffer_t
+ *                                              on the stack when using CC310 backend.
+ * @retval  NRF_ERROR_CRYPTO_BUSY               RNG is busy. Rerun at a later time.
+ */
+ret_code_t nrf_crypto_rng_init(nrf_crypto_rng_context_t       * p_context,
+                               nrf_crypto_rng_temp_buffer_t   * p_temp_buffer);
+
+
+/**@brief Uninitialize the random number generator.
+ *
+ * @retval  NRF_SUCCESS                                 If RNG was uninitialized successfully.
+ * @retval  NRF_ERROR_CRYPTO_CONTEXT_NOT_INITIALIZED    RNG has not been initialized.
+ * @retval  NRF_ERROR_CRYPTO_INTERNAL                   If an internal error occurred in the
+ *                                                      nrf_crypto backend.
+ * @retval  NRF_ERROR_CRYPTO_BUSY                       RNG is busy. Rerun at a later time.
+ */
+ret_code_t nrf_crypto_rng_uninit(void);
+
+
+/**@brief Generate random data of given size.
+ *
+ * @details @ref nrf_crypto_rng_init must be called prior to this function unless
+ *          @ref NRF_CRYPTO_RNG_AUTO_INIT_ENABLED is enabled in @ref sdk_config.
+ *
+ * @param[in,out]   p_target    Buffer to hold the random generated data.
+ *                              This buffer must be at least as large as the size parameter.
+ * @param[in]       size        Length (in bytes) to generate random data for.
+ *
+ * @retval  NRF_SUCCESS                                 Data was generated successfully.
+ * @retval  NRF_ERROR_CRYPTO_NOT_INITIALIZED            @ref nrf_crypto_init was not called prior to
+ *                                                      this function.
+ * @retval  NRF_ERROR_CRYPTO_CONTEXT_NOT_INITIALIZED    @ref nrf_crypto_rng_init was not called
+ *                                                      prior to this function and
+ *                                                      @ref NRF_CRYPTO_RNG_AUTO_INIT_ENABLED is
+ *                                                      disabled.
+ * @retval  NRF_ERROR_CRYPTO_OUTPUT_NULL                p_target was NULL.
+ * @retval  NRF_ERROR_CRYPTO_OUTPUT_LENGTH              Size was 0 or larger than the backend
+ *                                                      supports.
+ * @retval  NRF_ERROR_CRYPTO_INTERNAL                   If an internal error occurred in the
+ *                                                      backend.
+ * @retval  NRF_ERROR_CRYPTO_STACK_OVERFLOW             Stack overflow detected in
+ *                                                      @ref nrf_crypto_rng_init when using auto
+ *                                                      initialization. Typically caused by
+ *                                                      allocating an instance of
+ *                                                      @ref nrf_crypto_rng_temp_buffer_t
+ *                                                      on the stack when using CC310 backend.
+ * @retval  NRF_ERROR_CRYPTO_BUSY                       RNG is busy. Rerun at a later time.
+ */
+ret_code_t nrf_crypto_rng_vector_generate(uint8_t * const p_target, size_t size);
+
+
+/**@brief Generate a vector of constrained random data of given size, between the specified min
+ *        and max values.
+ *
+ * @details @ref nrf_crypto_rng_init must be called prior to this function unless
+ *          @ref NRF_CRYPTO_RNG_AUTO_INIT_ENABLED is enabled in @ref sdk_config.
+ *
+ *          All vectors are in big-endian format, with the most significant byte as the first
+ *          element / lowest address.
+ *
+ * @note This function may execute for a long time if the window between p_min and p_max is small.
+ *
+ * @param[in,out]   p_target    Buffer to hold the random generated data.
+ *                              This buffer must be at least as large as the size parameter.
+ * @param[in]       p_min       Byte array defining the lower limit of the random vector.
+ * @param[in]       p_max       Byte array defining the upper limit of the random vector.
+ * @param[in]       size        Length (in bytes) to generate random data for. Note that all three
+ *                              buffers (p_target, p_min and p_max) must be of this size.
+ *
+ * @retval  NRF_SUCCESS                                 Data was generated successfully.
+ * @retval  NRF_ERROR_CRYPTO_NOT_INITIALIZED            @ref nrf_crypto_init was not called prior to
+ *                                                      this function.
+ * @retval  NRF_ERROR_CRYPTO_CONTEXT_NOT_INITIALIZED    @ref nrf_crypto_rng_init was not called
+ *                                                      prior to this function and
+ *                                                      @ref NRF_CRYPTO_RNG_AUTO_INIT_ENABLED is
+ *                                                      disabled.
+ * @retval  NRF_ERROR_CRYPTO_OUTPUT_NULL                p_target was NULL.
+ * @retval  NRF_ERROR_CRYPTO_INPUT_NULL                 p_min or p_max was NULL.
+ * @retval  NRF_ERROR_CRYPTO_OUTPUT_LENGTH              Size was 0 or larger than the backend
+ *                                                      supports.
+ * @retval  NRF_ERROR_CRYPTO_INTERNAL                   If an internal error occurred in the
+ *                                                      backend.
+ * @retval  NRF_ERROR_CRYPTO_STACK_OVERFLOW             Stack overflow detected in
+ *                                                      @ref nrf_crypto_rng_init when using auto
+ *                                                      initialization. Typically caused by
+ *                                                      allocating an instance of
+ *                                                      @ref nrf_crypto_rng_temp_buffer_t
+ *                                                      on the stack when using CC310 backend.
+ * @retval  NRF_ERROR_CRYPTO_BUSY                       RNG is busy. Rerun at a later time.
+ */
+ret_code_t nrf_crypto_rng_vector_generate_in_range(uint8_t          * const p_target,
+                                                   uint8_t    const * const p_min,
+                                                   uint8_t    const * const p_max,
+                                                   size_t                   size);
+
+
+/**
+ * @brief This function is used for reseeding the RNG with additional entropy.
+ * 
+ * @details The backends will reseed automatically when required. This function can be used to
+ *          reseed at specific times and to provide additional data that is used to add personalized
+ *          randomness.
+ *
+ * @note Reseeding is not supported if using the nRF HW RNG backend without mbed TLS CTR-DRBG
+ *       (NRF_CRYPTO_BACKEND_NRF_HW_RNG_MBEDTLS_CTR_DRBG_ENABLED disabled in sdk_config.h).
+ *
+ * @warning The p_temp_buffer is 6112 bytes when the CC310 backend is used. Ensure that stack size
+ *          is sufficient if allocated on stack.
+ *
+ * @param[in,out]   p_temp_buffer   Temporary buffer needed during reseeding. It
+ *                                  is not used after the return of this function, and can be freed
+ *                                  at that point. Buffer is allocated internally if the pointer is
+ *                                  NULL, using the allocated defined by @ref NRF_CRYPTO_ALLOCATOR
+ *                                  in @c sdk_config.h. Use NULL if
+ *                                  @ref NRF_CRYPTO_RNG_STATIC_MEMORY_BUFFERS_ENABLED is enabled
+ *                                  in @ref sdk_config (recommended for most applications).
+ * @param[in]       p_input_data    Optional input data used to increase the entropy.
+ * @param[in]       size            Length of input data. Must be 0, 4, 8 or 12 for CC310.
+ *
+ * @retval  NRF_SUCCESS                                 Data was generated successfully.
+ * @retval  NRF_ERROR_CRYPTO_NOT_INITIALIZED            @ref nrf_crypto_init was not called prior to
+ *                                                      this function.
+ * @retval  NRF_ERROR_CRYPTO_CONTEXT_NOT_INITIALIZED    @ref nrf_crypto_rng_init was not called
+ *                                                      prior to this function and
+ *                                                      @ref NRF_CRYPTO_RNG_AUTO_INIT_ENABLED is
+ *                                                      disabled.
+ * @retval  NRF_ERROR_CRYPTO_INPUT_NULL                 p_temp_buffer was NULL or p_input_data was
+ *                                                      NULL and size > 0 .
+ * @retval  NRF_ERROR_CRYPTO_INPUT_LENGTH               Invalid input data size.
+ * @retval  NRF_ERROR_CRYPTO_FEATURE_UNAVAILABLE        Reseeding not supported by backend.
+ * @retval  NRF_ERROR_CRYPTO_INTERNAL                   If an internal error occurred in the
+ *                                                      backend.
+ * @retval  NRF_ERROR_CRYPTO_STACK_OVERFLOW             Stack overflow detected. Typically caused by
+ *                                                      allocating an instance of
+ *                                                      @ref nrf_crypto_rng_temp_buffer_t
+ *                                                      on the stack when using CC310 backend.
+ * @retval  NRF_ERROR_CRYPTO_BUSY                       RNG is busy. Rerun at a later time.
+ */
+ret_code_t nrf_crypto_rng_reseed(nrf_crypto_rng_temp_buffer_t * p_temp_buffer,
+                                 uint8_t                      * p_input_data,
+                                 size_t                         size);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+/**@} */
+
+#endif // NRF_CRYPTO_RNG_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_rng_backend.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_rng_backend.h
new file mode 100644
index 0000000..0fd900f
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_rng_backend.h
@@ -0,0 +1,82 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef NRF_CRYPTO_RNG_BACKEND_H__
+#define NRF_CRYPTO_RNG_BACKEND_H__
+
+/** @file
+ *
+ * @defgroup nrf_crypto_rng_backend Meta RNG backend.
+ * @{
+ * @ingroup nrf_crypto_rng
+ *
+ * @brief Includes all backends definitions.
+ *
+ * @details This file includes all backend definitions.
+ */
+
+#include "cc310_backend_rng.h"
+#include "nrf_hw_backend_rng.h"
+#include "nrf_hw_backend_rng_mbedtls.h"
+
+#if !NRF_MODULE_ENABLED(NRF_CRYPTO_RNG)
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** @internal @brief Fallback dummy context type in case no backend is selected */
+typedef nrf_crypto_rng_internal_context_t nrf_crypto_backend_rng_context_t;
+
+/** @internal @brief Fallback dummy temp buffer type in case no backend is selected . */
+typedef struct
+{
+    uint32_t reserved;
+} nrf_crypto_backend_rng_temp_buffer_t;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // !NRF_MODULE_ENABLED(NRF_CRYPTO_RNG)
+
+/**@} */
+
+#endif // NRF_CRYPTO_RNG_BACKEND_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_rng_shared.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_rng_shared.h
new file mode 100644
index 0000000..bbf7fd3
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_rng_shared.h
@@ -0,0 +1,142 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef NRF_CRYPTO_RNG_SHARED_H__
+#define NRF_CRYPTO_RNG_SHARED_H__
+
+/** @file
+ *
+ * @defgroup nrf_crypto_rng_shared Types shared between all @ref nrf_crypto_rng backends.
+ * @{
+ * @ingroup nrf_crypto_rng
+ *
+ * @brief Types shared between all @ref nrf_crypto_rng backends.
+ *
+ * @details These types should not be used directly by the application.
+ */
+
+#include "sdk_common.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#define NRF_CRYPTO_RNG_CONTEXT_INIT_MAGIC_VALUE (0x4d616961)
+
+
+/**
+ * @internal @brief Common header for each RNG backend context.
+ *
+ * @details This is an internal type that should not be used directly.
+ */
+typedef struct
+{
+    uint32_t    init_value; //!< Contains NRF_CRYPTO_RNG_CONTEXT_INIT_MAGIC_VALUE if initialized.
+} nrf_crypto_rng_internal_context_t;
+
+
+/**
+ * @internal @brief Function for initializing the RNG backend.
+ *
+ * @note The backend function should never be called directly.
+ *       Use @ref nrf_crypto_rng_init instead.
+ *
+ * @param[in,out]   p_context       Pointer to context structure.
+ * @param[in,out]   p_temp_buffer   Temporary buffer needed during initialization of the backend.
+ * @param[in]       use_mutex       Use mutex to prevent simultanious usage of backend resources.
+ */
+ret_code_t nrf_crypto_rng_backend_init(void * const p_context,
+                                       void * const p_temp_buffer);
+
+
+/**
+ * @internal @brief Function for uninitializing the RNG backend.
+ *
+ * @note The backend function should never be called directly.
+ *       Use @ref nrf_crypto_rng_uninit instead.
+ *
+ * @param[in,out]   p_context   Pointer to context structure.
+ * @param[in]       use_mutex   Use mutex to prevent simultanious usage of backend resources.
+ */
+ret_code_t nrf_crypto_rng_backend_uninit(void   * const p_context);
+
+
+/**
+ * @internal @brief Function for retrieving a random vector from the RNG backend.
+ *
+ * @note The backend function should never be called directly.
+ *       Use @ref nrf_crypto_rng_vector_generate instead.
+ *
+ * @param[in,out]   p_context   Pointer to context structure.
+ * @param[out]      p_target    Buffer to hold the random generated data.
+ * @param[in]       size        Length (in bytes) to generate random data for.
+ * @param[in]       use_mutex   Use mutex to prevent simultanious usage of backend resources.
+ */
+ret_code_t nrf_crypto_rng_backend_vector_generate(void      * const p_context,
+                                                  uint8_t   * const p_target,
+                                                  size_t            size,
+                                                  bool              use_mutex);
+
+
+/**
+ * @internal @brief This function is used for reseeding the RNG with additional entropy.
+ *
+ * @note The backend function should never be called directly.
+ *       Use @ref nrf_crypto_rng_reseed instead.
+ *
+ * @param[in,out]   p_context       Pointer to context structure.
+ * @param[in,out]   p_temp_buffer   Temporary buffer needed during initialization of the backend.
+ * @param[in]       p_input_data    Input data used to increase the entropy.
+ * @param[in]       size            Length of input data.
+ */
+ret_code_t nrf_crypto_rng_backend_reseed(void   * const p_context,
+                                         void         * p_temp_buffer,
+                                         uint8_t      * p_input_data,
+                                         size_t         size);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+/**@} */
+
+#endif // NRF_CRYPTO_RNG_SHARED_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_shared.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_shared.c
new file mode 100644
index 0000000..689ee48
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_shared.c
@@ -0,0 +1,97 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#include "sdk_config.h"
+#include "nordic_common.h"
+#include "nrf_crypto_shared.h"
+
+
+#if NRF_MODULE_ENABLED(NRF_CRYPTO)
+
+
+void nrf_crypto_internal_swap_endian_in_place(uint8_t * p_buffer, size_t size)
+{
+    ASSERT(p_buffer != NULL);
+
+    uint8_t temp;
+    uint8_t * p_first = p_buffer;
+    uint8_t * p_last = p_buffer + size - 1;
+    while (p_last >= p_first)
+    {
+        temp = *p_first;
+        *p_first = *p_last;
+        *p_last = temp;
+        p_first++;
+        p_last--;
+    }
+}
+
+
+void nrf_crypto_internal_swap_endian(uint8_t * p_out, uint8_t const * p_in, size_t size)
+{
+    ASSERT(p_out != NULL);
+    ASSERT(p_in != NULL);
+
+    uint8_t const * p_first = p_in;
+    uint8_t * p_last = p_out + size - 1;
+    while (p_last >= p_out)
+    {
+        *p_last = *p_first;
+        p_first++;
+        p_last--;
+    }
+}
+
+
+void nrf_crypto_internal_double_swap_endian(uint8_t * p_out, uint8_t const * p_in, size_t part_size)
+{
+    nrf_crypto_internal_swap_endian(p_out, p_in, part_size);
+    nrf_crypto_internal_swap_endian(&p_out[part_size], &p_in[part_size], part_size);
+}
+
+
+void nrf_crypto_internal_double_swap_endian_in_place(uint8_t * p_buffer, size_t part_size)
+{
+    nrf_crypto_internal_swap_endian_in_place(p_buffer, part_size);
+    nrf_crypto_internal_swap_endian_in_place(&p_buffer[part_size], part_size);
+}
+
+
+#endif
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_shared.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_shared.h
new file mode 100644
index 0000000..3e6dae3
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_shared.h
@@ -0,0 +1,189 @@
+/**
+ * Copyright (c) 2018 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef NRF_CRYPTO_SHARED_H__
+#define NRF_CRYPTO_SHARED_H__
+
+/** @internal @file
+ *
+ * @defgroup nrf_crypto_shared Shared macros for nrf_crypto
+ * @{
+ * @ingroup nrf_crypto
+ *
+ * @brief Module containing shared macros for nrf_crypto.
+ */
+
+#include "sdk_macros.h"
+#include "nrf_crypto_mem.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** @internal @brief Macro for verifying statement to be true. It will cause the exterior function
+ *                   to return err_code if the statement is not true, but only after freeing the
+ *                   memory pointed to by p_memory if p_memory is not NULL.
+ *
+ * @param[in]   statement   Statement to test.
+ * @param[in]   err_code    Error value to return if test was invalid.
+ * @param[in]   p_memory    The memory block to be freed in case of error.
+ *
+ * @retval      nothing, but will cause the exterior function to return @p err_code if @p statement
+ *              is false.
+ */
+#define NRF_CRYPTO_VERIFY_TRUE_DEALLOCATE(statement, err_code, p_memory)    \
+do                                                                          \
+{                                                                           \
+    if (!(statement))                                                       \
+    {                                                                       \
+        if (p_memory != NULL)                                               \
+        {                                                                   \
+            NRF_CRYPTO_FREE(p_memory);                                      \
+        }                                                                   \
+        return err_code;                                                    \
+    }                                                                       \
+} while (0)
+
+
+/**
+ * @internal @brief Macro for verifying that a function returned NRF_SUCCESS. It will cause the
+ *                  exterior function to return err_code if the err_code is not @ref NRF_SUCCESS,
+ *                  but only after freeing the memory pointed to by p_memory if p_memory is not
+ *                  NULL.
+ *
+ * @param[in] err_code The error code to check.
+ * @param[in] p_memory The memory block to be freed in case of error.
+ */
+#ifdef DISABLE_PARAM_CHECK
+#define NRF_CRYPTO_VERIFY_SUCCESS_DEALLOCATE()
+#else
+#define NRF_CRYPTO_VERIFY_SUCCESS_DEALLOCATE(err_code, p_memory)                       \
+    NRF_CRYPTO_VERIFY_TRUE_DEALLOCATE((err_code) == NRF_SUCCESS, (err_code), p_memory)
+#endif /* DISABLE_PARAM_CHECK */
+
+
+/**
+ * @internal @brief Generate a vector with random data of given size.
+ *
+ * @details This function does not check or lock the CC310 mutex, and should only be used
+ *
+ * @note Only for internal use in nrf_crypto.
+ *
+ * @param[in,out]   p_target    Buffer to hold the random generated data.
+ *                              This buffer must be at least as large as the size parameter.
+ * @param[in]       size        Length (in bytes) to generate random data for.
+ *
+ * @retval      See return values for @ref nrf_crypto_rng_vector_generate.
+ */
+ret_code_t nrf_crypto_rng_vector_generate_no_mutex(uint8_t * const p_target, size_t size);
+
+
+/**
+ * @internal @brief Generate a vector of constrained random data of given size, between the
+ *                  specified min and max values.
+ *
+ * @details This function does not check or lock the CC310 mutex, and should only be used
+ *
+ * @note Only for internal use in nrf_crypto.
+ *
+ * @param[in,out]   p_target    Buffer to hold the random generated data.
+ *                              This buffer must be at least as large as the size parameter.
+ * @param[in]       p_min       Byte array defining the lower limit of the random vector.
+ * @param[in]       p_max       Byte array defining the upper limit of the random vector.
+ * @param[in]       size        Length (in bytes) to generate random data for. Note that all three
+ *                              buffers (p_target, p_min and p_max) must be of this size.
+ *
+ * @retval      See return values for @ref nrf_crypto_rng_vector_generate_in_range.
+ */
+ret_code_t nrf_crypto_rng_vector_generate_in_range_no_mutex(uint8_t         * const p_target,
+                                                            uint8_t   const * const p_min,
+                                                            uint8_t   const * const p_max,
+                                                            size_t                  size);
+
+
+/** @internal @brief Swap bytes order inside provided buffer (in place).
+ *
+ * @note Only for internal use in nrf_crypto.
+ *
+ * @param[in,out]   p_buffer    Buffer with data to swap.
+ * @param[in]       size        Number of bytes in @p p_buffer.
+ */
+void nrf_crypto_internal_swap_endian_in_place(uint8_t * p_buffer, size_t size);
+
+
+/** @internal @brief Copy from one buffer to another and swap byte order.
+ *
+ * @note Only for internal use in nrf_crypto.
+ *
+ * @param[out]   p_out   Buffer with source data.
+ * @param[in]    p_in    Destination buffer with swapped bytes.
+ * @param[in]    size    Number of bytes in @p p_out and @p p_in.
+ */
+void nrf_crypto_internal_swap_endian(uint8_t * p_out, uint8_t const * p_in, size_t size);
+
+
+/** @internal @brief Swap bytes order inside buffer containing two integers (in place).
+ *
+ * @note Only for internal use in nrf_crypto.
+ *
+ * @param[in,out]   p_buffer    Buffer with data to swap.
+ * @param[in]       part_size   Number of bytes in single integer which is half of size of @p p_buffer.
+ */
+void nrf_crypto_internal_double_swap_endian_in_place(uint8_t * p_buffer, size_t part_size);
+
+
+/** @internal @brief Copy from one buffer containing two integers to another and swap byte order of each integer.
+ *
+ * @note Only for internal use in nrf_crypto.
+ *
+ * @param[out]   p_out      Buffer with source data.
+ * @param[in]    p_in       Destination buffer with swapped bytes.
+ * @param[in]    part_size  Number of bytes in single integer which is half of size of @p p_out and @p p_in.
+ */
+void nrf_crypto_internal_double_swap_endian(uint8_t * p_out, uint8_t const * p_in, size_t part_size);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+/**@} */
+
+#endif // NRF_CRYPTO_SHARED_H__
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_svc.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_svc.c
new file mode 100644
index 0000000..c80f141
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_svc.c
@@ -0,0 +1,93 @@
+/**
+ * Copyright (c) 2016 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#include "nrf_svc_function.h"
+#include "nrf_error.h"
+#include "sdk_common.h"
+
+/* use direct calls */
+#define SVC_INTERFACE_CALL_AS_NORMAL_FUNCTION
+#include "nrf_crypto.h"
+
+#ifndef NRF51
+
+SVC_REGISTER_FUNCTION(const nrf_svc_func_reg_t nrf_crypto_svci_init) =
+{
+    .svc_num = NRF_SVCI_SVC_NUM,
+    .svci_num = NRF_CRYPTO_SVCI_INIT,
+    .func_ptr = (nrf_svc_func_t)&nrf_crypto_init
+};
+
+SVC_REGISTER_FUNCTION(const nrf_svc_func_reg_t nrf_crypto_svci_public_key_compute) =
+{
+    .svc_num = NRF_SVCI_SVC_NUM,
+    .svci_num = NRF_CRYPTO_SVCI_PUBLIC_KEY_COMPUTE,
+    .func_ptr = (nrf_svc_func_t)&nrf_crypto_public_key_compute
+};
+
+SVC_REGISTER_FUNCTION(const nrf_svc_func_reg_t nrf_crypto_svci_shared_secret_compute) =
+{
+    .svc_num = NRF_SVCI_SVC_NUM,
+    .svci_num = NRF_CRYPTO_SVCI_SHARED_SECRET_COMPUTE,
+    .func_ptr = (nrf_svc_func_t)&nrf_crypto_shared_secret_compute
+};
+
+SVC_REGISTER_FUNCTION(const nrf_svc_func_reg_t nrf_crypto_svci_sign) =
+{
+    .svc_num = NRF_SVCI_SVC_NUM,
+    .svci_num = NRF_CRYPTO_SVCI_SIGN,
+    .func_ptr = (nrf_svc_func_t)&nrf_crypto_sign
+};
+
+#endif // #ifndef NRF51
+
+SVC_REGISTER_FUNCTION(const nrf_svc_func_reg_t nrf_crypto_svci_verify) =
+{
+    .svc_num = NRF_SVCI_SVC_NUM,
+    .svci_num = NRF_CRYPTO_SVCI_VERIFY,
+    .func_ptr = (nrf_svc_func_t)&nrf_crypto_verify
+};
+
+SVC_REGISTER_FUNCTION(const nrf_svc_func_reg_t nrf_crypto_svci_hash_compute) =
+{
+    .svc_num = NRF_SVCI_SVC_NUM,
+    .svci_num = NRF_CRYPTO_SVCI_HASH_COMPUTE,
+    .func_ptr = &nrf_crypto_hash_compute
+};
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_types.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_types.h
new file mode 100644
index 0000000..9d428b1
--- /dev/null
+++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/crypto/nrf_crypto_types.h
@@ -0,0 +1,113 @@
+/**
+ * Copyright (c) 2016 - 2018, Nordic Semiconductor ASA
+ * 
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form, except as embedded into a Nordic
+ *    Semiconductor ASA integrated circuit in a product or a software update for
+ *    such product, must reproduce the above copyright notice, this list of
+ *    conditions and the following disclaimer in the documentation and/or other
+ *    materials provided with the distribution.
+ * 
+ * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
+ *    contributors may be used to endorse or promote products derived from this
+ *    software without specific prior written permission.
+ * 
+ * 4. This software, with or without modification, must only be used with a
+ *    Nordic Semiconductor ASA integrated circuit.
+ * 
+ * 5. Any software provided in binary form under this license must not be reverse
+ *    engineered, decompiled, modified and/or disassembled.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#ifndef NRF_CRYPTO_TYPES_H__
+#define NRF_CRYPTO_TYPES_H__
+
+/** @file
+ *
+ * @defgroup nrf_crypto_types Commonly shared types
+ * @{
+ * @ingroup nrf_crypto
+ *
+ * @brief Provides definitions of commonly shared cryptographic types like hashes and curves used in the nrf_crypto APIs.
+ */
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** @brief Hashing algorithms that are available through nrf_crypto.
+ *
+ * @note    All cryptographic hash types may not be available through the nrf_crypto backend.
+ */
+typedef enum
+{
+    NRF_CRYPTO_HASH_TYPE_INVALID    = 0x00,        //!< Invalid hashing algorithm.
+    NRF_CRYPTO_HASH_TYPE_MD5        = 0x01,        //!< MD5.
+    NRF_CRYPTO_HASH_TYPE_SHA1       = 0x03,        //!< SHA-1.
+    NRF_CRYPTO_HASH_TYPE_SHA224     = 0x04,        //!< SHA-224 (SHA-2).
+    NRF_CRYPTO_HASH_TYPE_SHA256     = 0x05,        //!< SHA-256 (SHA-2).
+    NRF_CRYPTO_HASH_TYPE_SHA384     = 0x06,        //!< SHA-384 (SHA-2).
+    NRF_CRYPTO_HASH_TYPE_SHA512     = 0x07,        //!< SHA-512 (SHA-2).
+
+} nrf_hash_type_t;
+
+/**@defgroup NRF_CRYPTO_HASH_SIZES Cryptographic hash sizes
+ * @brief Sizes of different cryptographic hashes.
+ * @{ */
+#define NRF_CRYPTO_HASH_SIZE_MD5        (20)
+#define NRF_CRYPTO_HASH_SIZE_SHA1       (20)
+#define NRF_CRYPTO_HASH_SIZE_SHA224     (28)
+#define NRF_CRYPTO_HASH_SIZE_SHA256     (32)
+#define NRF_CRYPTO_HASH_SIZE_SHA384     (48)
+#define NRF_CRYPTO_HASH_SIZE_SHA512     (64)
+/** @}  */
+
+
+/**@brief Type definition for key size.
+ */
+typedef enum
+{
+    NRF_CRYPTO_KEY_SIZE_128 = 128,
+    NRF_CRYPTO_KEY_SIZE_192 = 192,
+    NRF_CRYPTO_KEY_SIZE_256 = 256
+} nrf_crypto_key_size_id_t;
+
+/**@brief Type specifying whether decrypt or encrypt operation shall be performed.
+ */
+typedef enum
+{
+    NRF_CRYPTO_DECRYPT       = 0,
+    NRF_CRYPTO_ENCRYPT       = 1,
+    NRF_CRYPTO_MAC_CALCULATE = 2
+} nrf_crypto_operation_t;
+
+#define NRF_CRYPTO_AES_BLOCK_SIZE   (16u) // 16 bytes
+
+#ifdef __cplusplus
+}
+#endif
+
+/**@} */
+
+#endif // #ifndef NRF_CRYPTO_TYPES_H__