signature.h

Go to the documentation of this file.

/*
 * Copyright (C) 2018-2019 Zhiyi Zhang, Tianyuan Yu
 *
 * 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_ENCODING_SIGNATURE_H
#define NDN_ENCODING_SIGNATURE_H

#include "name.h"
#include "../ndn-constants.h"

#ifdef __cplusplus
extern "C" {
#endif

typedef struct ndn_validity_period {
  uint8_t not_before[15];
  uint8_t not_after[15];
} ndn_validity_period_t;

typedef struct ndn_signature {
  uint8_t sig_type;
  uint8_t sig_value[NDN_SIGNATURE_BUFFER_SIZE];
  uint32_t sig_size;
  uint8_t enable_KeyLocator;
  ndn_name_t key_locator_name;
  uint8_t enable_SignatureNonce;
  uint32_t signature_nonce;
  uint8_t enable_Timestamp;
  uint64_t timestamp;
  uint8_t enable_Seqnum;
  uint64_t seqnum;
  ndn_validity_period_t validity_period;
  uint8_t enable_ValidityPeriod;
} ndn_signature_t;

static inline int
ndn_signature_init(ndn_signature_t* signature)
{
  signature->enable_KeyLocator = 0;
  signature->enable_ValidityPeriod = 0;
  signature->enable_SignatureNonce = 0;
  signature->signature_nonce = 0;
  signature->enable_Timestamp = 0;
  signature->timestamp = 0;
  signature->enable_Seqnum = 0;
  signature->seqnum = 0;
  return 0;
}

static inline int
ndn_signature_set_signature_type(ndn_signature_t* signature, uint8_t type)
{
  switch (type) {
  case NDN_SIG_TYPE_DIGEST_SHA256:
    signature->sig_size = NDN_SEC_SHA256_HASH_SIZE;
    break;
  case NDN_SIG_TYPE_ECDSA_SHA256:
    signature->sig_size = NDN_ASN1_ECDSA_MAX_ENCODED_SIG_SIZE;
    break;
  case NDN_SIG_TYPE_HMAC_SHA256:
    signature->sig_size = NDN_SEC_SHA256_HASH_SIZE;
    break;
  default:
    return NDN_SEC_UNSUPPORT_SIGN_TYPE;
  }
  signature->sig_type = type;
  return 0;
}

static inline int
ndn_signature_set_signature(ndn_signature_t* signature, const uint8_t* sig_value, size_t sig_size)
{
  if (sig_size > NDN_SIGNATURE_BUFFER_SIZE)
    return NDN_OVERSIZE;

  if (signature->sig_type == NDN_SIG_TYPE_ECDSA_SHA256 && sig_size != 64)
    return NDN_SEC_WRONG_SIG_SIZE;

  if (signature->sig_type == NDN_SIG_TYPE_HMAC_SHA256 && sig_size != 32)
    return NDN_SEC_WRONG_SIG_SIZE;

  if (signature->sig_type == NDN_SIG_TYPE_DIGEST_SHA256 && sig_size != 32)
    return NDN_SEC_WRONG_SIG_SIZE;

  signature->sig_size = sig_size;
  memcpy(signature->sig_value, sig_value, sig_size);
  return 0;
}

static inline void
ndn_signature_set_key_locator(ndn_signature_t* signature, const ndn_name_t* key_name)
{
  signature->enable_KeyLocator = 1;
  memcpy(&signature->key_locator_name, key_name, sizeof(ndn_name_t));
}

static inline void
ndn_signature_set_timestamp(ndn_signature_t* signature, uint64_t timestamp)
{
  signature->enable_Timestamp = 1;
  signature->timestamp = timestamp;
}

static inline void
ndn_signature_set_signature_nonce(ndn_signature_t* signature, uint32_t nonce)
{
  signature->enable_SignatureNonce = 1;
  signature->signature_nonce = nonce;
}

static inline void
ndn_signature_set_seqnum(ndn_signature_t* signature, uint32_t seqnum)
{
  signature->enable_Seqnum = 1;
  signature->seqnum = seqnum;
}

static inline void
ndn_signature_set_validity_period(ndn_signature_t* signature,
                                  const uint8_t* not_before, const uint8_t* not_after)
{
  signature->enable_ValidityPeriod = 1;
  memcpy(signature->validity_period.not_before, not_before, 15);
  memcpy(signature->validity_period.not_after, not_after, 15);
}

static inline uint32_t
ndn_signature_info_probe_block_size(const ndn_signature_t* signature)
{
  // signature type
  uint32_t info_buffer_size = encoder_probe_block_size(TLV_SignatureType, 1);

  if (signature->enable_KeyLocator > 0) {
    uint32_t key_name_block_size = ndn_name_probe_block_size(&signature->key_locator_name);
    info_buffer_size += encoder_probe_block_size(TLV_KeyLocator, key_name_block_size);
  }
  if (signature->enable_ValidityPeriod > 0) {
    uint32_t validity_period_buffer_size = encoder_probe_block_size(TLV_NotBefore, 15);
    validity_period_buffer_size += encoder_probe_block_size(TLV_NotAfter, 15);
    info_buffer_size += encoder_probe_block_size(TLV_ValidityPeriod, validity_period_buffer_size);
  }
  if (signature->enable_SignatureNonce > 0) {
    info_buffer_size += encoder_probe_block_size(TLV_SignatureNonce, 4);
  }
  if (signature->enable_Timestamp > 0) {
    info_buffer_size += encoder_probe_block_size(TLV_Timestamp,
                                                 encoder_probe_uint_length(signature->timestamp));
  }
  if (signature->enable_Seqnum > 0) {
    info_buffer_size += encoder_probe_block_size(TLV_SeqNum,
                                                 encoder_probe_uint_length(signature->seqnum));
  }
  return encoder_probe_block_size(TLV_SignatureInfo, info_buffer_size);
}

static inline uint32_t
ndn_signature_value_probe_block_size(const ndn_signature_t* signature)
{
  return encoder_probe_block_size(TLV_SignatureValue, signature->sig_size);
}

int
ndn_signature_info_tlv_encode(ndn_encoder_t* encoder, const ndn_signature_t* signature);

int
ndn_signature_value_tlv_encode(ndn_encoder_t* encoder, const ndn_signature_t* signature);

int
ndn_signature_info_tlv_decode(ndn_decoder_t* decoder, ndn_signature_t* signature);

int
ndn_signature_value_tlv_decode(ndn_decoder_t* decoder, ndn_signature_t* signature);

#ifdef __cplusplus
}
#endif

#endif // NDN_ENCODING_SIGNATURE_H