ecc加密算法的使用(c语言实现)_ecc加密算法c语言实现

参考nodic官方代码：

/*ecc.c文件*/
 
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include "nordic_common.h"
#include "app_timer.h"
#include "app_util.h"
#include "nrf_log.h"
#include "nrf_drv_rng.h"
#include "ecc.h"
 
#include "uECC.h"
 
 
static int ecc_rng(uint8_t *dest, unsigned size)//生成随机数
{
    nrf_drv_rng_block_rand(dest, (uint32_t) size);
    return 1;
}
 
void ecc_init(bool rng)
{
    if (rng)
    {
        uECC_set_rng(ecc_rng);
    }
}
 
ret_code_t ecc_p256_keypair_gen(uint8_t *p_le_sk, uint8_t *p_le_pk)//生成私钥和公钥
{
    const struct uECC_Curve_t * p_curve;
 
    if (!p_le_sk || !p_le_pk)
    {
        return NRF_ERROR_NULL;
    }
 
    if (!is_word_aligned(p_le_sk) || !is_word_aligned(p_le_pk))
    {
        return NRF_ERROR_INVALID_ADDR;
    }
 
    p_curve = uECC_secp256r1();
 
    int ret = uECC_make_key((uint8_t *) p_le_pk, (uint8_t *) p_le_sk, p_curve);
    if (!ret)
    {
        return NRF_ERROR_INTERNAL;
    }
 
    return NRF_SUCCESS;
}
 
 
/*公钥计算*/
ret_code_t ecc_p256_public_key_compute(uint8_t const *p_le_sk, uint8_t *p_le_pk)
{
    const struct uECC_Curve_t * p_curve;
 
    if (!p_le_sk || !p_le_pk)
    {
        return NRF_ERROR_NULL;
    }
 
    if (!is_word_aligned(p_le_sk) || !is_word_aligned(p_le_pk))
    {
        return NRF_ERROR_INVALID_ADDR;
    }
 
    p_curve = uECC_secp256r1();
 
    //NRF_LOG_INFO("uECC_compute_public_key");
    int ret = uECC_compute_public_key((uint8_t *) p_le_sk, (uint8_t *) p_le_pk, p_curve);
    if (!ret)
    {
        return NRF_ERROR_INTERNAL;
    }
 
    //NRF_LOG_INFO("uECC_compute_public_key complete: %d", ret);
    return NRF_SUCCESS;
}
 
 
/*私钥计算*/
ret_code_t ecc_p256_shared_secret_compute(uint8_t const *p_le_sk, uint8_t const *p_le_pk, uint8_t *p_le_ss)
{
    int ret;
    const struct uECC_Curve_t * p_curve;
 
    if (!p_le_sk || !p_le_pk || !p_le_ss)
    {
        return NRF_ERROR_NULL;
    }
 
    if (!is_word_aligned(p_le_sk) || !is_word_aligned(p_le_pk) || !is_word_aligned(p_le_ss))
    {
        return NRF_ERROR_INVALID_ADDR;
    }
 
    p_curve = uECC_secp256r1();
    
    
    // Validate the remote public key
    ret = uECC_valid_public_key((uint8_t*) p_le_pk, p_curve);
    if (!ret)
    {
        return NRF_ERROR_INTERNAL;
    }
    
    //NRF_LOG_INFO("uECC_shared_secret");
    ret = uECC_shared_secret((uint8_t *) p_le_pk, (uint8_t *) p_le_sk, p_le_ss, p_curve);
    if (!ret)
    {
        return NRF_ERROR_INTERNAL;
    }
 
    //NRF_LOG_INFO("uECC_shared_secret complete: %d", ret);
    return NRF_SUCCESS;
}
 
 
/*签名*/
ret_code_t ecc_p256_sign(uint8_t const *p_le_sk, uint8_t const * p_le_hash, uint32_t hlen, uint8_t *p_le_sig)
{
    const struct uECC_Curve_t * p_curve;
 
    if (!p_le_sk || !p_le_hash || !p_le_sig)
    {
        return NRF_ERROR_NULL;
    }
 
    if (!is_word_aligned(p_le_sk) || !is_word_aligned(p_le_hash) || !is_word_aligned(p_le_sig))
    {
        return NRF_ERROR_INVALID_ADDR;
    }
 
    p_curve = uECC_secp256r1();
 
    //NRF_LOG_INFO("uECC_sign");
    int ret = uECC_sign((const uint8_t *) p_le_sk, (const uint8_t *) p_le_hash, (unsigned) hlen, (uint8_t *) p_le_sig, p_curve);
    if (!ret)
    {
        return NRF_ERROR_INTERNAL;
    }
 
    //NRF_LOG_INFO("uECC_sign complete: %d", ret);
    return NRF_SUCCESS;
}
 
/*验证*/
ret_code_t ecc_p256_verify(uint8_t const *p_le_pk, uint8_t const * p_le_hash, uint32_t hlen, uint8_t const *p_le_sig)
{
    const struct uECC_Curve_t * p_curve;
 
    if (!p_le_pk || !p_le_hash || !p_le_sig)
    {
        return NRF_ERROR_NULL;
    }
 
    if (!is_word_aligned(p_le_pk) || !is_word_aligned(p_le_hash) || !is_word_aligned(p_le_sig))
    {
        return NRF_ERROR_INVALID_ADDR;
    }
 
    p_curve = uECC_secp256r1();
 
    //NRF_LOG_INFO("uECC_verify");
    int ret = uECC_verify((const uint8_t *) p_le_pk, (const uint8_t *) p_le_hash, (unsigned) hlen, (uint8_t *) p_le_sig, p_curve);
    if (!ret)
    {
        return NRF_ERROR_INVALID_DATA;
    }
 
    //NRF_LOG_INFO("uECC_verify complete: %d", ret);
    return NRF_SUCCESS;
 
}
 
 

/*ecc.h头文件*/
 
#ifndef ECC_H__
#define ECC_H__
 
#include <stdint.h>
#include <stdbool.h>
#include "nordic_common.h"
#include "nrf_error.h"
#include "sdk_errors.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define ECC_P256_SK_LEN 32
#define ECC_P256_PK_LEN 64
 
 
void ecc_init(bool rng);
 
 
ret_code_t ecc_p256_keypair_gen(uint8_t *p_le_sk, uint8_t* p_le_pk);
 
 
ret_code_t ecc_p256_public_key_compute(uint8_t const *p_le_sk, uint8_t* p_le_pk);
 
 
ret_code_t ecc_p256_shared_secret_compute(uint8_t const *p_le_sk, uint8_t const * p_le_pk, uint8_t *p_le_ss);
 
 
ret_code_t ecc_p256_sign(uint8_t const *p_le_sk, uint8_t const * p_le_hash, uint32_t hlen, uint8_t *p_le_sig);
 
 
ret_code_t ecc_p256_verify(uint8_t const *p_le_pk, uint8_t const * p_le_hash, uint32_t hlen, uint8_t const *p_le_sig);
 
 
#ifdef __cplusplus
}
#endif
 
#endif // ECC_H__

/*main.c文件*/
 
int main(){
	uint8_t sk[32];
	uint8_t pk[64];
	ecc_init (true);
	NRF_LOG_INFO("----------ECC Begins-------------\r\n");
	NRF_LOG_FLUSH();
	uint32_t err_code = ecc_p256_keypair_gen(sk,pk);//秘钥和公钥生成
	APP_ERROR_CHECK(err_code);
	NRF_LOG_INFO("Private Key:\r\n");
	NRF_LOG_FLUSH();
	NRF_LOG_HEXDUMP_INFO(sk,32);
	NRF_LOG_FLUSH();
	NRF_LOG_INFO("Public Key:\r\n");
	NRF_LOG_HEXDUMP_INFO(pk,64);
	NRF_LOG_FLUSH();
 
    return 0;
}