identity-manager.hpp

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

#include "../certificate/identity-certificate.hpp"
#include "../../interest.hpp"
#include "identity-storage.hpp"
#include "../certificate/public-key.hpp"
#include "private-key-storage.hpp"

namespace ndn {

class IdentityManager {
public:
  IdentityManager
    (const ptr_lib::shared_ptr<IdentityStorage>& identityStorage,
     const ptr_lib::shared_ptr<PrivateKeyStorage>& privateKeyStorage);

  IdentityManager(const ptr_lib::shared_ptr<IdentityStorage>& identityStorage);

  IdentityManager();

  Name
  createIdentityAndCertificate(const Name& identityName, const KeyParams& params);

  Name
  DEPRECATED_IN_NDN_CPP createIdentity
    (const Name& identityName, const KeyParams& params)
  {
    return IdentityCertificate::certificateNameToPublicKeyName
      (createIdentityAndCertificate(identityName, params));
  }

  ptr_lib::shared_ptr<IdentityCertificate>
  prepareUnsignedIdentityCertificate
    (const Name& keyName, const Name& signingIdentity,
     MillisecondsSince1970 notBefore, MillisecondsSince1970 notAfter,
     std::vector<CertificateSubjectDescription>& subjectDescription,
     const Name* certPrefix = 0);

  ptr_lib::shared_ptr<IdentityCertificate>
  prepareUnsignedIdentityCertificate
    (const Name& keyName, const PublicKey& publicKey,
     const Name& signingIdentity, MillisecondsSince1970 notBefore,
     MillisecondsSince1970 notAfter,
     std::vector<CertificateSubjectDescription>& subjectDescription,
     const Name* certPrefix = 0);

  void
  deleteIdentity(const Name& identityName);

  void
  setDefaultIdentity(const Name& identityName)
  {
    identityStorage_->setDefaultIdentity(identityName);
  }

  Name
  getDefaultIdentity()
  {
    return identityStorage_->getDefaultIdentity();
  }

  ptr_lib::shared_ptr<IdentityCertificate>
  getDefaultCertificate()
  {
    return identityStorage_->getDefaultCertificate();
  }

  Name
  generateRSAKeyPair(const Name& identityName, bool isKsk = false, int keySize = 2048);

  Name
  generateEcdsaKeyPair(const Name& identityName, bool isKsk = false, int keySize = 256);

  void
  setDefaultKeyForIdentity(const Name& keyName, const Name& identityNameCheck = Name())
  {
    identityStorage_->setDefaultKeyNameForIdentity(keyName, identityNameCheck);
  }

  Name
  getDefaultKeyNameForIdentity(const Name& identityName)
  {
    return identityStorage_->getDefaultKeyNameForIdentity(identityName);
  }

  Name
  generateRSAKeyPairAsDefault(const Name& identityName, bool isKsk = false, int keySize = 2048);

  Name
  generateEcdsaKeyPairAsDefault(const Name& identityName, bool isKsk = false, int keySize = 256);

  ptr_lib::shared_ptr<PublicKey>
  getPublicKey(const Name& keyName)
  {
    return ptr_lib::shared_ptr<PublicKey>(new PublicKey
      (identityStorage_->getKey(keyName)));
  }

  Name
  createIdentityCertificate
    (const Name& certificatePrefix, const Name& signerCertificateName, const MillisecondsSince1970& notBefore,
     const MillisecondsSince1970& notAfter);

  ptr_lib::shared_ptr<IdentityCertificate>
  createIdentityCertificate
    (const Name& certificatePrefix, const PublicKey& publickey, const Name& signerCertificateName,
     const MillisecondsSince1970& notBefore, const MillisecondsSince1970& notAfter);

  void
  addCertificate(const IdentityCertificate& certificate)
  {
    identityStorage_->addCertificate(certificate);
  }

  void
  setDefaultCertificateForKey(const IdentityCertificate& certificate);

  void
  addCertificateAsIdentityDefault(const IdentityCertificate& certificate);

  void
  addCertificateAsDefault(const IdentityCertificate& certificate);

  ptr_lib::shared_ptr<IdentityCertificate>
  getCertificate(const Name& certificateName)
  {
    return identityStorage_->getCertificate(certificateName);
  }

  Name
  getDefaultCertificateNameForIdentity(const Name& identityName)
  {
    return identityStorage_->getDefaultCertificateNameForIdentity(identityName);
  }

  Name
  getDefaultCertificateName()
  {
    return identityStorage_->getDefaultCertificateNameForIdentity(getDefaultIdentity());
  }

  void
  getAllIdentities(std::vector<Name>& nameList, bool isDefault)
  {
    identityStorage_->getAllIdentities(nameList, isDefault);
  }

  void
  getAllKeyNamesOfIdentity
    (const Name& identityName, std::vector<Name>& nameList, bool isDefault)
  {
    identityStorage_->getAllKeyNamesOfIdentity(identityName, nameList, isDefault);
  }

  void
  getAllCertificateNamesOfKey
    (const Name& keyName, std::vector<Name>& nameList, bool isDefault)
  {
    identityStorage_->getAllCertificateNamesOfKey(keyName, nameList, isDefault);
  }

  ptr_lib::shared_ptr<Signature>
  signByCertificate(const uint8_t* buffer, size_t bufferLength, const Name& certificateName);

  ptr_lib::shared_ptr<Signature>
  signByCertificate(const std::vector<uint8_t>& buffer, const Name& certificateName)
  {
    return signByCertificate(&buffer[0], buffer.size(), certificateName);
  }

  void
  signByCertificate(Data& data, const Name& certificateName, WireFormat& wireFormat = *WireFormat::getDefaultWireFormat());

  void
  signInterestByCertificate
    (Interest& interest, const Name& certificateName,
     WireFormat& wireFormat = *WireFormat::getDefaultWireFormat());

  void
  signWithSha256
    (Data& data, WireFormat& wireFormat = *WireFormat::getDefaultWireFormat());

  void
  signInterestWithSha256
    (Interest& interest, WireFormat& wireFormat = *WireFormat::getDefaultWireFormat());

  ptr_lib::shared_ptr<IdentityCertificate>
  selfSign(const Name& keyName);

private:
  Name
  generateKeyPair(const Name& identityName, bool isKsk, const KeyParams& params);

  static Name
  getKeyNameFromCertificatePrefix(const Name& certificatePrefix);

  ptr_lib::shared_ptr<Signature>
  makeSignatureByCertificate
    (const Name& certificateName, DigestAlgorithm& digestAlgorithm);

  ptr_lib::shared_ptr<IdentityStorage> identityStorage_;
  ptr_lib::shared_ptr<PrivateKeyStorage> privateKeyStorage_;
};

}

#endif