v1/sec-public-info.hpp

Go to the documentation of this file.

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

#include "../../name.hpp"
#include "../security-common.hpp"
#include "public-key.hpp"
#include "identity-certificate.hpp"

namespace ndn {
namespace security {
namespace v1 {

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

  explicit
  SecPublicInfo(const std::string& location);

  virtual
  ~SecPublicInfo();

  virtual void
  setTpmLocator(const std::string& tpmLocator) = 0;

  virtual std::string
  getTpmLocator() = 0;

  std::string
  getPibLocator();

  virtual bool
  doesIdentityExist(const Name& identityName) = 0;

  virtual void
  addIdentity(const Name& identityName) = 0;

  virtual bool
  revokeIdentity() = 0;

  virtual bool
  doesPublicKeyExist(const Name& keyName) = 0;

  DEPRECATED(
  void
  addPublicKey(const Name& keyName, KeyType keyType, const PublicKey& publicKey));

  virtual void
  addKey(const Name& keyName, const PublicKey& publicKey) = 0;

  virtual shared_ptr<PublicKey>
  getPublicKey(const Name& keyName) = 0;

  virtual KeyType
  getPublicKeyType(const Name& keyName) = 0;

  virtual bool
  doesCertificateExist(const Name& certificateName) = 0;

  virtual void
  addCertificate(const IdentityCertificate& certificate) = 0;

  virtual shared_ptr<IdentityCertificate>
  getCertificate(const Name& certificateName) = 0;


  /*****************************************
   *            Default Getter             *
   *****************************************/

  virtual Name
  getDefaultIdentity() = 0;

  virtual Name
  getDefaultKeyNameForIdentity(const Name& identityName) = 0;

  virtual Name
  getDefaultCertificateNameForKey(const Name& keyName) = 0;

  virtual void
  getAllIdentities(std::vector<Name>& nameList, bool isDefault) = 0;

  virtual void
  getAllKeyNames(std::vector<Name>& nameList, bool isDefault) = 0;

  virtual void
  getAllKeyNamesOfIdentity(const Name& identity, std::vector<Name>& nameList, bool isDefault) = 0;

  virtual void
  getAllCertificateNames(std::vector<Name>& nameList, bool isDefault) = 0;

  virtual void
  getAllCertificateNamesOfKey(const Name& keyName, std::vector<Name>& nameList, bool isDefault) = 0;

  /*****************************************
   *            Delete Methods             *
   *****************************************/

  virtual void
  deleteCertificateInfo(const Name& certificateName) = 0;

  virtual void
  deletePublicKeyInfo(const Name& keyName) = 0;

  virtual void
  deleteIdentityInfo(const Name& identity) = 0;

protected:

  /*****************************************
   *            Default Setter             *
   *****************************************/

  virtual void
  setDefaultIdentityInternal(const Name& identityName) = 0;

  virtual void
  setDefaultKeyNameForIdentityInternal(const Name& keyName) = 0;

  virtual void
  setDefaultCertificateNameForKeyInternal(const Name& certificateName) = 0;

  virtual std::string
  getScheme() = 0;

public:

  /*****************************************
   *            Helper Methods             *
   *****************************************/

  void
  setDefaultIdentity(const Name& identityName);

  void
  setDefaultKeyNameForIdentity(const Name& keyName);

  void
  setDefaultCertificateNameForKey(const Name& certificateName);

  Name
  getNewKeyName(const Name& identityName, bool useKsk);

  Name
  getDefaultCertificateNameForIdentity(const Name& identityName);

  Name
  getDefaultCertificateName();

  void
  addCertificateAsKeyDefault(const IdentityCertificate& certificate);

  void
  addCertificateAsIdentityDefault(const IdentityCertificate& certificate);

  void
  addCertificateAsSystemDefault(const IdentityCertificate& certificate);

  DEPRECATED(
  shared_ptr<IdentityCertificate>
  defaultCertificate());

  shared_ptr<IdentityCertificate>
  getDefaultCertificate();

  void
  refreshDefaultCertificate();

protected:
  shared_ptr<IdentityCertificate> m_defaultCertificate;
  std::string m_location;
};

} // namespace v1

#ifdef NDN_CXX_KEEP_SECURITY_V1_ALIASES
using v1::SecPublicInfo;
#endif // NDN_CXX_KEEP_SECURITY_V1_ALIASES

} // namespace security

#ifdef NDN_CXX_KEEP_SECURITY_V1_ALIASES
using security::v1::SecPublicInfo;
#endif // NDN_CXX_KEEP_SECURITY_V1_ALIASES

} // namespace ndn

#endif // NDN_SECURITY_V1_SEC_PUBLIC_INFO_HPP