ndn-lite-ecc.h

Go to the documentation of this file.

/*
 * Copyright (C) 2018-2019 Zhiyi Zhang
 *
 * This file is subject to the terms and conditions of the GNU Lesser
 * General Public License v3.0. See the file LICENSE in the top level
 * directory for more details.
 */

#ifndef NDN_SECURITY_ECC_H_
#define NDN_SECURITY_ECC_H_

#include "../ndn-error-code.h"
#include "ndn-lite-sec-config.h"
#include "ndn-lite-rng.h"

#ifdef __cplusplus
extern "C" {
#endif

typedef struct abstract_ecc_pub_key abstract_ecc_pub_key_t;
typedef struct abstract_ecc_prv_key abstract_ecc_prv_key_t;

typedef uint32_t (*ndn_ecc_get_pub_key_size_impl)(const abstract_ecc_pub_key_t* pub_key);
typedef uint32_t (*ndn_ecc_get_prv_key_size_impl)(const abstract_ecc_prv_key_t* prv_key);
typedef const uint8_t* (*ndn_ecc_get_pub_key_value_impl)(const abstract_ecc_pub_key_t* pub_key);
typedef int (*ndn_ecc_load_pub_key_impl)(abstract_ecc_pub_key_t* pub_key,
                                         const uint8_t* key_value, uint32_t key_size);
typedef int (*ndn_ecc_load_prv_key_impl)(abstract_ecc_prv_key_t* prv_key,
                                         const uint8_t* key_value, uint32_t key_size);
typedef int (*ndn_ecc_set_rng_impl)(ndn_rng_impl rng);
typedef int (*ndn_ecdsa_sign_impl)(const uint8_t* payload_value, uint32_t payload_size,
                                   uint8_t* output_value, uint32_t output_max_size,
                                   const abstract_ecc_prv_key_t* prv_key,
                                   uint8_t ecdsa_type, uint32_t* output_used_size);
typedef int (*ndn_ecdsa_verify_impl)(const uint8_t* payload_value, uint32_t payload_size,
                                     const uint8_t* sig_value, uint32_t sig_size,
                                     const abstract_ecc_pub_key_t* pub_key, uint8_t ecdsa_type);
typedef int (*ndn_ecc_make_key_impl)(abstract_ecc_pub_key_t* pub_key,
                                     abstract_ecc_prv_key_t* prv_key,
                                     uint8_t curve_type);
typedef int (*ndn_ecc_dh_shared_secret_impl)(const abstract_ecc_pub_key_t* ecc_pub,
                                             const abstract_ecc_prv_key_t* ecc_prv,
                                             uint8_t curve_type, uint8_t* output,
                                             uint32_t output_size);

typedef struct ndn_ecc_backend {
  ndn_ecc_get_pub_key_size_impl get_pub_key_size;
  ndn_ecc_get_prv_key_size_impl get_prv_key_size;
  ndn_ecc_get_pub_key_value_impl get_pub_key_value;
  ndn_ecc_load_pub_key_impl load_pub_key;
  ndn_ecc_load_prv_key_impl load_prv_key;
  ndn_ecc_set_rng_impl set_rng;
  ndn_ecc_make_key_impl make_key;
  ndn_ecc_dh_shared_secret_impl dh_shared_secret;
  ndn_ecdsa_sign_impl ecdsa_sign;
  ndn_ecdsa_verify_impl ecdsa_verify;
} ndn_ecc_backend_t;

typedef struct ndn_ecc_pub {
  abstract_ecc_pub_key_t abs_key;
  uint32_t key_id;
  uint8_t curve_type;
} ndn_ecc_pub_t;

typedef struct ndn_ecc_prv {
  abstract_ecc_prv_key_t abs_key;
  uint32_t key_id;
  uint8_t curve_type;
} ndn_ecc_prv_t;

ndn_ecc_backend_t*
ndn_ecc_get_backend(void);

uint32_t
ndn_ecc_get_pub_key_size(const ndn_ecc_pub_t* pub_key);

uint32_t
ndn_ecc_get_prv_key_size(const ndn_ecc_prv_t* prv_key);

const uint8_t*
ndn_ecc_get_pub_key_value(const ndn_ecc_pub_t* pub_key);

int
ndn_ecc_load_pub_key(ndn_ecc_pub_t* pub_key,
                     const uint8_t* key_value, uint32_t key_size);

static inline int
ndn_ecc_pub_init(ndn_ecc_pub_t* ecc_pub, const uint8_t* key_value,
                 uint32_t key_size, uint8_t curve_type, uint32_t key_id)
{
  ndn_ecc_load_pub_key(ecc_pub, key_value, key_size);
  ecc_pub->curve_type = curve_type;
  ecc_pub->key_id = key_id;
  return 0;
}

int
ndn_ecc_load_prv_key(ndn_ecc_prv_t* prv_key,
                     const uint8_t* key_value, uint32_t key_size);

static inline int
ndn_ecc_prv_init(ndn_ecc_prv_t* ecc_prv, const uint8_t* key_value,
                 uint32_t key_size, uint8_t curve_type, uint32_t key_id)
{
  ndn_ecc_load_prv_key(ecc_prv, key_value, key_size);
  ecc_prv->curve_type = curve_type;
  ecc_prv->key_id = key_id;
  return 0;
}

int
ndn_ecc_set_rng(ndn_rng_impl rng);

int
ndn_ecc_make_key(ndn_ecc_pub_t* ecc_pub, ndn_ecc_prv_t* ecc_prv,
                 uint8_t curve_type, uint32_t key_id);

int
ndn_ecc_dh_shared_secret(const ndn_ecc_pub_t* ecc_pub, const ndn_ecc_prv_t* ecc_prv,
                         uint8_t curve_type, uint8_t* output, uint32_t output_size);

int
ndn_ecdsa_sign(const uint8_t* input_value, uint32_t input_size,
               uint8_t* output_value, uint32_t output_max_size,
               const ndn_ecc_prv_t* ecc_prv_key,
               uint8_t ecdsa_type, uint32_t* output_used_size);

int
ndn_ecdsa_verify(const uint8_t* input_value, uint32_t input_size,
                 const uint8_t* sig_value, uint32_t sig_size,
                 const ndn_ecc_pub_t* ecc_pub_key,
                 uint8_t ecdsa_type);


#ifdef __cplusplus
}
#endif

#endif // NDN_SECURITY_ECC_H_