key-chain.hpp

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

#include "../data.hpp"
#include "../interest.hpp"
#include "../face.hpp"
#include "identity/identity-manager.hpp"
#include "policy/validation-request.hpp"
#include "key-params.hpp"

namespace ndn {

class PolicyManager;

class KeyChain {
public:
  KeyChain
    (const ptr_lib::shared_ptr<IdentityManager>& identityManager,
     const ptr_lib::shared_ptr<PolicyManager>& policyManager);

  KeyChain(const ptr_lib::shared_ptr<IdentityManager>& identityManager);

  KeyChain();

  /*****************************************
   *          Identity Management          *
   *****************************************/

  Name
  createIdentityAndCertificate
    (const Name& identityName, const KeyParams& params = DEFAULT_KEY_PARAMS)
  {
    return identityManager_->createIdentityAndCertificate(identityName, params);
  }

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

  void
  deleteIdentity(const Name& identityName)
  {
    identityManager_->deleteIdentity(identityName);
  }

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

  Name
  getDefaultCertificateName()
  {
    return identityManager_->getDefaultCertificateName();
  }

  Name
  generateRSAKeyPair(const Name& identityName, bool isKsk = false, int keySize = 2048)
  {
    return identityManager_->generateRSAKeyPair(identityName, isKsk, keySize);
  }

  Name
  generateEcdsaKeyPair(const Name& identityName, bool isKsk = false, int keySize = 256)
  {
    return identityManager_->generateEcdsaKeyPair(identityName, isKsk, keySize);
  }

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

  Name
  generateRSAKeyPairAsDefault(const Name& identityName, bool isKsk = false, int keySize = 2048)
  {
    return identityManager_->generateRSAKeyPairAsDefault(identityName, isKsk, keySize);
  }

  Name
  generateEcdsaKeyPairAsDefault(const Name& identityName, bool isKsk = false, int keySize = 256)
  {
    return identityManager_->generateEcdsaKeyPairAsDefault(identityName, isKsk, keySize);
  }

  Blob
  createSigningRequest(const Name& keyName)
  {
    return identityManager_->getPublicKey(keyName)->getKeyDer();
  }

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

  void
  setDefaultCertificateForKey(const IdentityCertificate& certificate)
  {
    identityManager_->setDefaultCertificateForKey(certificate);
  }

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

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

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

  ptr_lib::shared_ptr<IdentityCertificate>
  getAnyIdentityCertificate(const Name& certificateName)
  {
    return identityManager_->getAnyCertificate(certificateName);
  }

  void
  revokeKey(const Name & keyName)
  {
    //TODO: Implement
  }

  void
  revokeCertificate(const Name & certificateName)
  {
    //TODO: Implement
  }

  const ptr_lib::shared_ptr<IdentityManager>&
  getIdentityManager() { return identityManager_; }

  /*****************************************
   *           Policy Management           *
   *****************************************/

  const ptr_lib::shared_ptr<PolicyManager>&
  getPolicyManager() { return policyManager_; }

  /*****************************************
   *              Sign/Verify              *
   *****************************************/

  void
  sign(Data& data, const Name& certificateName,
       WireFormat& wireFormat = *WireFormat::getDefaultWireFormat())
  {
    identityManager_->signByCertificate(data, certificateName, wireFormat);
  }

  void
  sign(Data& data, WireFormat& wireFormat = *WireFormat::getDefaultWireFormat())
  {
    identityManager_->signByCertificate
      (data, prepareDefaultCertificateName(), wireFormat);
  }

  void
  sign
    (Interest& interest, const Name& certificateName,
     WireFormat& wireFormat = *WireFormat::getDefaultWireFormat())
  {
    identityManager_->signInterestByCertificate
      (interest, certificateName, wireFormat);
  }

  void
  sign
    (Interest& interest,
     WireFormat& wireFormat = *WireFormat::getDefaultWireFormat())
  {
    identityManager_->signInterestByCertificate
      (interest, prepareDefaultCertificateName(), wireFormat);
  }

  ptr_lib::shared_ptr<Signature>
  sign(const uint8_t* buffer, size_t bufferLength, const Name& certificateName)
  {
    return identityManager_->signByCertificate
      (buffer, bufferLength, certificateName);
  }

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

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

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

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

  void
  signWithSha256
    (Data& data, WireFormat& wireFormat = *WireFormat::getDefaultWireFormat())
  {
    identityManager_->signWithSha256(data, wireFormat);
  }

  void
  signWithSha256
    (Interest& interest, WireFormat& wireFormat = *WireFormat::getDefaultWireFormat())
  {
    identityManager_->signInterestWithSha256(interest, wireFormat);
  }

  void
  verifyData
    (const ptr_lib::shared_ptr<Data>& data, const OnVerified& onVerified, const OnVerifyFailed& onVerifyFailed, int stepCount = 0);

  void
  verifyInterest
    (const ptr_lib::shared_ptr<Interest>& interest,
     const OnVerifiedInterest& onVerified,
     const OnVerifyInterestFailed& onVerifyFailed, int stepCount = 0,
     WireFormat& wireFormat = *WireFormat::getDefaultWireFormat());

  void
  setFace(Face* face) { face_ = face; }

  static const RsaKeyParams DEFAULT_KEY_PARAMS;

private:
  void
  onCertificateData
    (const ptr_lib::shared_ptr<const Interest> &interest, const ptr_lib::shared_ptr<Data> &data, ptr_lib::shared_ptr<ValidationRequest> nextStep);

  void
  onCertificateInterestTimeout
    (const ptr_lib::shared_ptr<const Interest> &interest, int retry, const OnVerifyFailed& onVerifyFailed,
     const ptr_lib::shared_ptr<Data> &data, ptr_lib::shared_ptr<ValidationRequest> nextStep);

  void
  onCertificateInterestTimeoutForVerifyInterest
    (const ptr_lib::shared_ptr<const Interest> &interest, int retry,
     const OnVerifyInterestFailed& onVerifyFailed,
     const ptr_lib::shared_ptr<Interest>& originalInterest,
     ptr_lib::shared_ptr<ValidationRequest> nextStep);

  Name
  prepareDefaultCertificateName();

  void
  setDefaultCertificate();

  ptr_lib::shared_ptr<IdentityManager> identityManager_;
  ptr_lib::shared_ptr<PolicyManager> policyManager_;
  Face* face_;
};

}

#endif