osx-private-key-storage.hpp

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

// Only compile if ndn-cpp-config.h defines NDN_CPP_HAVE_OSX_SECURITY 1.
#include <ndn-cpp/ndn-cpp-config.h>
#if NDN_CPP_HAVE_OSX_SECURITY

#include "../../common.hpp"
#include "private-key-storage.hpp"

#include <CoreFoundation/CoreFoundation.h>
#include <Security/Security.h>
#include <CoreServices/CoreServices.h>

namespace ndn
{


template<class T>
class CFReleaser
{
public:
  // Construction/destruction //

  CFReleaser()
    : m_typeRef(0)
  {
  }

  CFReleaser(const T& typeRef)
    : m_typeRef(typeRef)
  {
  }

  CFReleaser(const CFReleaser& inReleaser)
    : m_typeRef(0)
  {
    retain(inReleaser.m_typeRef);
  }

  CFReleaser&
  operator=(const T& typeRef)
  {
    if (typeRef != m_typeRef) {
      release();
      m_typeRef = typeRef;
    }
    return *this;
  }

  CFReleaser&
  operator=(const CFReleaser& inReleaser)
  {
    retain(inReleaser.m_typeRef);
    return *this;
  }

  ~CFReleaser()
  {
    release();
  }

  // Access //

  // operator const T&() const
  // {
  //   return m_typeRef;
  // }

  // operator T&()
  // {
  //   return m_typeRef;
  // }

  const T&
  get() const
  {
    return m_typeRef;
  }

  T&
  get()
  {
    return m_typeRef;
  }

  // Miscellaneous //

  void
  retain(const T& typeRef)
  {
    if (typeRef != 0) {
      CFRetain(typeRef);
    }
    release();
    m_typeRef = typeRef;
  }

  void release()
  {
    if (m_typeRef != 0) {
      CFRelease(m_typeRef);
      m_typeRef = 0;
    }
  };

private:
  T m_typeRef;
};

class OSXPrivateKeyStorage : public PrivateKeyStorage {
public:
  OSXPrivateKeyStorage() {}

  virtual
  ~OSXPrivateKeyStorage();

  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 = DIGEST_ALGORITHM_SHA256);

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

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

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

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

  bool
  setACL(const Name & keyName, KeyClass keyClass, int acl, const std::string & appPath);

 private:
  std::string
  toInternalKeyName(const Name & keyName, KeyClass keyClass);

  CFReleaser<SecKeychainItemRef>
  getKey(const Name & keyName, KeyClass keyClass);

  const CFTypeRef
  getSymmetricKeyType(KeyType keyType);

  const CFTypeRef
  getAsymmetricKeyType(KeyType keyType);

  const CFTypeRef
  getKeyClass(KeyClass keyClass);

  const CFStringRef
  getDigestAlgorithm(DigestAlgorithm digestAlgorithm);

  long
  getDigestSize(DigestAlgorithm digestAlgo);
};

}

#endif // NDN_CPP_HAVE_OSX_SECURITY

#endif