xiaozhengsheng/HL-PDJ-1
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

初始版本

Browse Source
This commit is contained in:
xiaozhengsheng
2025-08-19 09:49:41 +08:00
parent 10f1ddf1c1
commit 6df0f7d96e
2974 changed files with 1712873 additions and 54 deletions
Download Patch File Download Diff File Expand all files Collapse all files

341
components/libraries/crypto/backend/micro_ecc/micro_ecc_backend_ecc.c Normal file
View File

@@ -0,0 +1,341 @@
/**
* Copyright (c) 2018 - 2020, 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;
#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
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_public_key_t),
.private_key_size = sizeof(nrf_crypto_backend_secp192r1_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,
//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_public_key_t),
.private_key_size = sizeof(nrf_crypto_backend_secp224r1_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,
//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_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 *)&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_public_key_t),
.private_key_size = sizeof(nrf_crypto_backend_secp256k1_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,
//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)

303
components/libraries/crypto/backend/micro_ecc/micro_ecc_backend_ecc.h Normal file
View File

@@ -0,0 +1,303 @@
/**
* Copyright (c) 2018 - 2020, 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__

103
components/libraries/crypto/backend/micro_ecc/micro_ecc_backend_ecdh.c Normal file
View File

@@ -0,0 +1,103 @@
/**
* Copyright (c) 2018 - 2020, 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);
// Check that the public key is valid
if (!uECC_valid_public_key((uint8_t *)(&p_pub->key[0]), p_micro_ecc_curve))
{
return NRF_ERROR_CRYPTO_INTERNAL;
}
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)

105
components/libraries/crypto/backend/micro_ecc/micro_ecc_backend_ecdh.h Normal file
View File

@@ -0,0 +1,105 @@
/**
* Copyright (c) 2018 - 2020, 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__

166
components/libraries/crypto/backend/micro_ecc/micro_ecc_backend_ecdsa.c Normal file
View File

@@ -0,0 +1,166 @@
/**
* Copyright (c) 2018 - 2020, 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)

124
components/libraries/crypto/backend/micro_ecc/micro_ecc_backend_ecdsa.h Normal file
View File

@@ -0,0 +1,124 @@
/**
* Copyright (c) 2018 - 2020, 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__

69
components/libraries/crypto/backend/micro_ecc/micro_ecc_backend_shared.h Normal file
View File

@@ -0,0 +1,69 @@
/**
* Copyright (c) 2018 - 2020, 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 defined(NRF_CRYPTO_BACKEND_MICRO_ECC_LITTLE_ENDIAN_ENABLED)
#error The configuration NRF_CRYPTO_BACKEND_MICRO_ECC_LITTLE_ENDIAN_ENABLED was removed in SDK 15.1.0. Please see release notes for details on removing this error message.
#endif
#define ECC_BACKEND_SWAP_BYTES uECC_VLI_NATIVE_LITTLE_ENDIAN
#ifdef __cplusplus
}
#endif
#endif // NRF_MODULE_ENABLED(NRF_CRYPTO) && NRF_MODULE_ENABLED(NRF_CRYPTO_BACKEND_MICRO_ECC)
#endif // MICRO_ECC_BACKEND_ECDSA_H__