ec.hpp

Go to the documentation of this file.

#ifndef NDNPH_KEYCHAIN_EC_HPP
#define NDNPH_KEYCHAIN_EC_HPP
 
#include "../port/ec/port.hpp"
#include "certificate.hpp"
#include "keychain.hpp"
 
namespace ndnph {
namespace ec {
namespace detail {
 
using namespace ndnph::detail;
 
using PvtLen = port::Ec::Curve::PvtLen;
using PubLen = port::Ec::Curve::PubLen;
 
inline tlv::Value
getSpkiHeader() {
  static const uint8_t bytes[] = {
    0x30, 0x59,                                                 // SEQUENCE
    0x30, 0x13,                                                 // . SEQUENCE
    0x06, 0x07, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x02, 0x01,       // .. OID ecPublicKey
    0x06, 0x08, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x03, 0x01, 0x07, // .. OID prime256v1
    0x03, 0x42, 0x00                                            // . BIT STRING
  };
  static const tlv::Value value(bytes, sizeof(bytes));
  return value;
}
 
inline tlv::Value
getOid() {
  static const tlv::Value value(getSpkiHeader().begin() + 4, 9);
  return value;
}
 
inline const uint8_t*
findPublicKeyInCertificate(const Data& data) {
  if (!certificate::isCertificate(data)) {
    return nullptr;
  }
 
  auto content = data.getContent();
  if (content.size() < PubLen::value) {
    return nullptr;
  }
 
  auto oid = getOid();
  auto found = std::search(content.begin(), content.end(), oid.begin(), oid.end());
  if (found == content.end()) {
    return nullptr;
  }
 
  return content.end() - PubLen::value;
}
 
} // namespace detail
 
class EcPublicKey : public detail::NamedPublicKey<SigType::Sha256WithEcdsa> {
public:
  using KeyLen = detail::PubLen;
 
  explicit operator bool() const {
    return m_key != nullptr;
  }
 
  bool import(const Name& name, const uint8_t raw[KeyLen::value]) {
    if (!certificate::isKeyName(name)) {
      return false;
    }
 
    m_key.reset(new port::Ec::PublicKey());
    if (!m_key->import(raw)) {
      m_key.reset();
      return false;
    }
 
    setName(name);
    std::copy_n(raw, sizeof(m_raw), m_raw);
    return true;
  }
 
  bool import(Region& region, const Data& data) {
    const uint8_t* raw = detail::findPublicKeyInCertificate(data);
    if (raw == nullptr) {
      return false;
    }
 
    Name name = certificate::toKeyName(region, data.getName());
    if (!name) {
      return false;
    }
 
    return import(name, raw);
  }
 
  template<typename Signer>
  Data::Signed buildCertificate(Region& region, const Name& name, const ValidityPeriod& validity,
                                const Signer& signer) const {
    return detail::buildCertificate(region, name, validity, signer, [&](Data& data) {
      auto spkiHdr = detail::getSpkiHeader();
      size_t spkiLen = spkiHdr.size() + KeyLen::value;
      uint8_t* spki = region.alloc(spkiLen);
      if (spki == nullptr) {
        return false;
      }
 
      auto pos = std::copy_n(spkiHdr.begin(), spkiHdr.size(), spki);
      std::copy_n(m_raw, KeyLen::value, pos);
      data.setContent(tlv::Value(spki, spkiLen));
      return true;
    });
  }
 
  template<typename Signer>
  Data::Signed selfSign(Region& region, const ValidityPeriod& validity,
                        const Signer& signer) const {
    Name certName = certificate::makeCertName(region, getName(), certificate::getIssuerSelf());
    return buildCertificate(region, certName, validity, signer);
  }
 
  bool verify(std::initializer_list<tlv::Value> chunks, const uint8_t* sig,
              size_t sigLen) const final {
    if (m_key == nullptr) {
      return false;
    }
    uint8_t digest[NDNPH_SHA256_LEN];
    return detail::computeDigest(chunks, digest) && m_key->verify(digest, sig, sigLen);
  }
 
private:
  std::unique_ptr<port::Ec::PublicKey> m_key;
  uint8_t m_raw[KeyLen::value];
};
 
class EcPrivateKey : public detail::NamedPrivateKey<SigType::Sha256WithEcdsa> {
public:
  using KeyLen = detail::PvtLen;
  using MaxSigLen = port::Ec::Curve::MaxSigLen;
 
  explicit operator bool() const {
    return m_key != nullptr;
  }
 
  bool import(const Name& name, const uint8_t raw[KeyLen::value]) {
    if (!certificate::isKeyName(name)) {
      return false;
    }
 
    m_key.reset(new port::Ec::PrivateKey());
    if (!m_key->import(raw)) {
      m_key.reset();
      return false;
    }
 
    setName(name);
    return true;
  }
 
  size_t getMaxSigLen() const final {
    return MaxSigLen::value;
  }
 
  ssize_t sign(std::initializer_list<tlv::Value> chunks, uint8_t* sig) const final {
    if (m_key == nullptr) {
      return -1;
    }
    uint8_t digest[NDNPH_SHA256_LEN];
    if (!detail::computeDigest(chunks, digest)) {
      return -1;
    }
    return m_key->sign(digest, sig);
  }
 
private:
  std::unique_ptr<port::Ec::PrivateKey> m_key;
};
 
inline bool
generateRaw(uint8_t pvt[EcPrivateKey::KeyLen::value], uint8_t pub[EcPublicKey::KeyLen::value]) {
  return port::Ec::generateKey(pvt, pub);
}
 
namespace detail {
 
struct StoredKeyPair {
  uint8_t pvt[PvtLen::value];
  uint8_t pub[PubLen::value];
};
 
inline bool
generate(Region& region, const Name& name, EcPrivateKey& pvt, EcPublicKey& pub, KeyChain* keyChain,
         const char* id) {
  Name keyName = certificate::toKeyName(region, name, true);
  if (!keyName) {
    return false;
  }
 
  ScopedEncoder encoder(region);
  encoder.prepend(keyName);
  auto stored = reinterpret_cast<StoredKeyPair*>(encoder.prependRoom(sizeof(StoredKeyPair)));
  bool ok = stored != nullptr && generateRaw(stored->pvt, stored->pub) &&
            pvt.import(keyName, stored->pvt) && pub.import(keyName, stored->pub);
 
  if (keyChain != nullptr) {
    ok = ok && keyChain->keys.set(id, tlv::Value(encoder));
  }
  return ok;
}
 
} // namespace detail
 
inline bool
generate(Region& region, const Name& name, EcPrivateKey& pvt, EcPublicKey& pub) {
  return detail::generate(region, name, pvt, pub, nullptr, nullptr);
}
 
inline bool
generate(Region& region, const Name& name, EcPrivateKey& pvt, EcPublicKey& pub, KeyChain& keyChain,
         const char* id) {
  return detail::generate(region, name, pvt, pub, &keyChain, id);
}
 
inline bool
load(KeyChain& keyChain, const char* id, Region& region, EcPrivateKey& pvt, EcPublicKey& pub) {
  tlv::Value storedObject = keyChain.keys.get(id, region);
  if (storedObject.size() < sizeof(detail::StoredKeyPair)) {
    return false;
  }
  auto stored = reinterpret_cast<const detail::StoredKeyPair*>(storedObject.begin());
  Name name;
  Decoder decoder(storedObject.begin() + sizeof(detail::StoredKeyPair),
                  storedObject.size() - sizeof(detail::StoredKeyPair));
  return decoder.decode(name) && pvt.import(name, stored->pvt) && pub.import(name, stored->pub);
}
 
inline bool
isCertificate(const Data& data) {
  return detail::findPublicKeyInCertificate(data) != nullptr;
}
 
} // namespace ec
 
using EcPublicKey = ec::EcPublicKey;
using EcPrivateKey = ec::EcPrivateKey;
 
} // namespace ndnph
 
#endif // NDNPH_KEYCHAIN_EC_HPP