v2/key-chain.hpp

Go to the documentation of this file.

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
#ifndef NDN_SECURITY_V2_KEY_CHAIN_HPP
#define NDN_SECURITY_V2_KEY_CHAIN_HPP

#include "../security-common.hpp"
#include "certificate.hpp"
#include "../key-params.hpp"
#include "../pib/pib.hpp"
#include "../safe-bag.hpp"
#include "../signing-info.hpp"
#include "../tpm/tpm.hpp"
#include "../../interest.hpp"

namespace ndn {
namespace security {
namespace v2 {

class KeyChain : noncopyable
{
public:
  class Error : public std::runtime_error
  {
  public:
    explicit
    Error(const std::string& what)
      : std::runtime_error(what)
    {
    }
  };

  class LocatorMismatchError : public Error
  {
  public:
    explicit
    LocatorMismatchError(const std::string& what)
      : Error(what)
    {
    }
  };

  class InvalidSigningInfoError : public Error
  {
  public:
    explicit
    InvalidSigningInfoError(const std::string& what)
      : Error(what)
    {
    }
  };

  KeyChain();

  KeyChain(const std::string& pibLocator, const std::string& tpmLocator, bool allowReset = false);

  ~KeyChain();

  const Pib&
  getPib() const
  {
    return *m_pib;
  }

  const Tpm&
  getTpm() const
  {
    return *m_tpm;
  }

public: // Identity management
  Identity
  createIdentity(const Name& identityName, const KeyParams& params = getDefaultKeyParams());

  void
  deleteIdentity(const Identity& identity);

  void
  setDefaultIdentity(const Identity& identity);

public: // Key management
  Key
  createKey(const Identity& identity, const KeyParams& params = getDefaultKeyParams());

  void
  deleteKey(const Identity& identity, const Key& key);

  void
  setDefaultKey(const Identity& identity, const Key& key);

public: // Certificate management
  void
  addCertificate(const Key& key, const Certificate& certificate);

  void
  deleteCertificate(const Key& key, const Name& certificateName);

  void
  setDefaultCertificate(const Key& key, const Certificate& cert);

public: // signing
  void
  sign(Data& data, const SigningInfo& params = getDefaultSigningInfo());

  void
  sign(Interest& interest, const SigningInfo& params = getDefaultSigningInfo());

  Block
  sign(const uint8_t* buffer, size_t bufferLength, const SigningInfo& params = getDefaultSigningInfo());

public: // export & import
  shared_ptr<SafeBag>
  exportSafeBag(const Certificate& certificate, const char* pw, size_t pwLen);

  void
  importSafeBag(const SafeBag& safeBag, const char* pw, size_t pwLen);

NDN_CXX_PUBLIC_WITH_TESTS_ELSE_PRIVATE:
  static tlv::SignatureTypeValue
  getSignatureType(KeyType keyType, DigestAlgorithm digestAlgorithm);

public: // PIB & TPM backend registry
  template<class PibBackendType>
  static void
  registerPibBackend(const std::string& scheme);

  template<class TpmBackendType>
  static void
  registerTpmBackend(const std::string& scheme);

private:
  typedef std::map<std::string, function<unique_ptr<pib::PibImpl>(const std::string& location)>> PibFactories;
  typedef std::map<std::string, function<unique_ptr<tpm::BackEnd>(const std::string& location)>> TpmFactories;

  static PibFactories&
  getPibFactories();

  static TpmFactories&
  getTpmFactories();

  static std::tuple<std::string/*type*/, std::string/*location*/>
  parseAndCheckPibLocator(const std::string& pibLocator);

  static std::tuple<std::string/*type*/, std::string/*location*/>
  parseAndCheckTpmLocator(const std::string& tpmLocator);

  static const std::string&
  getDefaultPibScheme();

  static const std::string&
  getDefaultTpmScheme();

  static unique_ptr<Pib>
  createPib(const std::string& pibLocator);

  static unique_ptr<Tpm>
  createTpm(const std::string& tpmLocator);

NDN_CXX_PUBLIC_WITH_TESTS_ELSE_PRIVATE:
  static const std::string&
  getDefaultPibLocator();

  static const std::string&
  getDefaultTpmLocator();

private: // signing
  Certificate
  selfSign(Key& key);

  std::tuple<Name, SignatureInfo>
  prepareSignatureInfo(const SigningInfo& params);

  Block
  sign(const uint8_t* buf, size_t size, const Name& keyName, DigestAlgorithm digestAlgorithm) const;

public:
  static const SigningInfo&
  getDefaultSigningInfo();

  static const KeyParams&
  getDefaultKeyParams();

private:
  std::unique_ptr<Pib> m_pib;
  std::unique_ptr<Tpm> m_tpm;

  static std::string s_defaultPibLocator;
  static std::string s_defaultTpmLocator;
};

template<class PibType>
inline void
KeyChain::registerPibBackend(const std::string& scheme)
{
  getPibFactories().emplace(scheme, [] (const std::string& locator) {
      return unique_ptr<pib::PibImpl>(new PibType(locator));
    });
}

template<class TpmType>
inline void
KeyChain::registerTpmBackend(const std::string& scheme)
{
  getTpmFactories().emplace(scheme, [] (const std::string& locator) {
      return unique_ptr<tpm::BackEnd>(new TpmType(locator));
    });
}

#define NDN_CXX_V2_KEYCHAIN_REGISTER_PIB_BACKEND(PibType)     \
static class NdnCxxAuto ## PibType ## PibRegistrationClass    \
{                                                             \
public:                                                       \
  NdnCxxAuto ## PibType ## PibRegistrationClass()             \
  {                                                           \
    ::ndn::security::v2::KeyChain::registerPibBackend<PibType>(PibType::getScheme()); \
  }                                                           \
} ndnCxxAuto ## PibType ## PibRegistrationVariable

#define NDN_CXX_V2_KEYCHAIN_REGISTER_TPM_BACKEND(TpmType)     \
static class NdnCxxAuto ## TpmType ## TpmRegistrationClass    \
{                                                             \
public:                                                       \
  NdnCxxAuto ## TpmType ## TpmRegistrationClass()             \
  {                                                           \
    ::ndn::security::v2::KeyChain::registerTpmBackend<TpmType>(TpmType::getScheme()); \
  }                                                           \
} ndnCxxAuto ## TpmType ## TpmRegistrationVariable

} // namespace v2
} // namespace security
} // namespace ndn

#endif // NDN_SECURITY_V2_KEY_CHAIN_HPP