memory-private-key-storage.hpp

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

#include <map>
#include "../../lite/security/ec-private-key-lite.hpp"
#include "../../lite/security/rsa-private-key-lite.hpp"
#include "private-key-storage.hpp"

namespace ndn {

class MemoryPrivateKeyStorage : public PrivateKeyStorage {
public:
  virtual
  ~MemoryPrivateKeyStorage();

  void
  setPublicKeyForKeyName
    (const Name& keyName, KeyType keyType, const uint8_t* publicKeyDer,
     size_t publicKeyDerLength);

  void
  DEPRECATED_IN_NDN_CPP setPublicKeyForKeyName
    (const Name& keyName, const uint8_t* publicKeyDer, size_t publicKeyDerLength)
  {
    setPublicKeyForKeyName(keyName, KEY_TYPE_RSA, publicKeyDer, publicKeyDerLength);
  }

  void
 setPrivateKeyForKeyName
    (const Name& keyName, KeyType keyType, const uint8_t* privateKeyDer,
     size_t privateKeyDerLength);

  void
   DEPRECATED_IN_NDN_CPP setPrivateKeyForKeyName
    (const Name& keyName, const uint8_t* privateKeyDer, size_t privateKeyDerLength)
  {
    setPrivateKeyForKeyName(keyName, KEY_TYPE_RSA, privateKeyDer, privateKeyDerLength);
  }

  void
  setKeyPairForKeyName
    (const Name& keyName, KeyType keyType, const uint8_t* publicKeyDer,
     size_t publicKeyDerLength, const uint8_t* privateKeyDer,
     size_t privateKeyDerLength)
  {
    setPublicKeyForKeyName(keyName, keyType, publicKeyDer, publicKeyDerLength);
    setPrivateKeyForKeyName(keyName, keyType, privateKeyDer, privateKeyDerLength);
  }

  void
  DEPRECATED_IN_NDN_CPP setKeyPairForKeyName
    (const Name& keyName, const uint8_t* publicKeyDer, size_t publicKeyDerLength,
     const uint8_t* privateKeyDer, size_t privateKeyDerLength)
  {
    setKeyPairForKeyName
      (keyName, KEY_TYPE_RSA, publicKeyDer, publicKeyDerLength, privateKeyDer,
       privateKeyDerLength);
  }

  virtual void
  generateKeyPair(const Name& keyName, const KeyParams& params);

  virtual void
  deleteKeyPair(const Name& keyName);

  virtual ptr_lib::shared_ptr<PublicKey>
  getPublicKey(const Name& keyName);

  virtual Blob
  sign(const uint8_t *data, size_t dataLength, const Name& keyName, DigestAlgorithm digestAlgorithm);

  virtual Blob
  decrypt(const Name& keyName, const uint8_t* data, size_t dataLength, bool isSymmetric);

  virtual Blob
  encrypt(const Name& keyName, const uint8_t* data, size_t dataLength, bool isSymmetric);

  virtual void
  generateKey(const Name& keyName, const KeyParams& params);

  virtual bool
  doesKeyExist(const Name& keyName, KeyClass keyClass);

private:
  class PrivateKey {
  public:
    PrivateKey(KeyType keyType, const uint8_t* keyDer, size_t keyDerLength);

    KeyType getKeyType() const { return keyType_; }

    const RsaPrivateKeyLite& getRsaPrivateKey() const { return rsaPrivateKey_; }

    const EcPrivateKeyLite& getEcPrivateKey() const { return ecPrivateKey_; }

  private:
    KeyType keyType_;
    RsaPrivateKeyLite rsaPrivateKey_;
    EcPrivateKeyLite ecPrivateKey_;
  };

  std::map<std::string, ptr_lib::shared_ptr<PublicKey> > publicKeyStore_;   
  std::map<std::string, ptr_lib::shared_ptr<PrivateKey> > privateKeyStore_; 
};

}

#endif