rsa-public-key-lite.hpp

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

#include "../util/blob-lite.hpp"
#include "../../c/errors.h"
#include "../../c/encrypt/algo/encrypt-params-types.h"
#include "../../c/security/rsa-public-key-types.h"

namespace ndn {

class RsaPublicKeyLite : private ndn_RsaPublicKey {
public:
  RsaPublicKeyLite();

  ~RsaPublicKeyLite();

  ndn_Error
  decode(const uint8_t* publicKeyDer, size_t publicKeyDerLength);

  ndn_Error
  decode(const BlobLite& publicKeyDer)
  {
    return decode(publicKeyDer.buf(), publicKeyDer.size());
  }

  ndn_Error
  encode(uint8_t* encoding, size_t& encodingLength) const;

  bool
  verifyWithSha256
    (const uint8_t* signature, size_t signatureLength, const uint8_t* data,
     size_t dataLength) const;

  bool
  verifyWithSha256(const BlobLite& signature, const BlobLite& data) const
  {
    return verifyWithSha256
      (signature.buf(), signature.size(), data.buf(), data.size());
  }

  static ndn_Error
  verifySha256WithRsaSignature
    (const uint8_t *signature, size_t signatureLength, const uint8_t *data,
     size_t dataLength, const uint8_t *publicKeyDer, size_t publicKeyDerLength,
     bool &verified);

  static ndn_Error
  verifySha256WithRsaSignature
    (const BlobLite& signature, const BlobLite& data,
     const BlobLite& publicKeyDer, bool &verified)
  {
    return verifySha256WithRsaSignature
      (signature.buf(), signature.size(), data.buf(), data.size(),
       publicKeyDer.buf(), publicKeyDer.size(), verified);
  }

  ndn_Error
  encrypt
    (const uint8_t* plainData, size_t plainDataLength,
     ndn_EncryptAlgorithmType algorithmType, uint8_t* encryptedData,
     size_t& encryptedDataLength) const;

  ndn_Error
  encrypt
    (const BlobLite& plainData, ndn_EncryptAlgorithmType algorithmType,
     uint8_t* encryptedData, size_t& encryptedDataLength) const
  {
    return encrypt
      (plainData.buf(), plainData.size(), algorithmType, encryptedData,
       encryptedDataLength);
  }

  static RsaPublicKeyLite&
  downCast(ndn_RsaPublicKey& blob) { return *(RsaPublicKeyLite*)&blob; }

  static const RsaPublicKeyLite&
  downCast(const ndn_RsaPublicKey& blob) { return *(RsaPublicKeyLite*)&blob; }

private:
  // Don't allow copying since we don't reference count the allocated value.
  RsaPublicKeyLite(const RsaPublicKeyLite& other);
  RsaPublicKeyLite& operator=(const RsaPublicKeyLite& other);
};

}

#endif