rsa_crypto_service_provider.h

 
#pragma once
 
#include <system/io/stream.h>
 
#include <security/cryptography/rsa.h>
#include <security/cryptography/i_csp_asymmetric_algorithm.h>
#include <security/cryptography/hash_algorithm.h>
 
namespace System { namespace Security { namespace Cryptography {
 
namespace Details {
    struct RSACryptoServiceProviderPimpl;
    struct RSAPKCS1SignatureFormatterPimpl;
    struct RSAPKCS1SignatureDeformatterPimpl;
}
 
class ASPOSECPP_SHARED_CLASS RSACryptoServiceProvider final : public RSA, public ICspAsymmetricAlgorithm
{
    friend struct Details::RSAPKCS1SignatureFormatterPimpl;
    friend struct Details::RSAPKCS1SignatureDeformatterPimpl;
 
    typedef RSACryptoServiceProvider ThisType;
    typedef RSA BaseType;
    typedef ICspAsymmetricAlgorithm BaseType1;
    typedef System::BaseTypesInfo<BaseType, BaseType1> ThisBaseTypesInfo;
    ASPOSECPP_SHARED_RTTI_INFO_DECL();
 
public:
    ASPOSECPP_SHARED_API RSACryptoServiceProvider();
 
    ASPOSECPP_SHARED_API RSACryptoServiceProvider(const SharedPtr<CspParameters>& parameters);
 
    ASPOSECPP_SHARED_API RSACryptoServiceProvider(const RSAParameters& parameters);
 
    ASPOSECPP_SHARED_API RSACryptoServiceProvider(int32_t key_size);
 
    ASPOSECPP_SHARED_API RSACryptoServiceProvider(int32_t key_size, const SharedPtr<CspParameters>& parameters);
 
    ASPOSECPP_SHARED_API SharedPtr<CspKeyContainerInfo> get_CspKeyContainerInfo() override;
 
    ASPOSECPP_SHARED_API String get_KeyExchangeAlgorithm() override;
 
    ASPOSECPP_SHARED_API int32_t get_KeySize() override;
 
    ASPOSECPP_SHARED_API bool get_PersistKeyInCsp() const;
 
    ASPOSECPP_SHARED_API void set_PersistKeyInCsp(bool value);
 
    ASPOSECPP_SHARED_API bool get_PublicOnly() const;
 
    ASPOSECPP_SHARED_API String get_SignatureAlgorithm() override;
 
    static ASPOSECPP_SHARED_API bool get_UseMachineKeyStore();
 
    static ASPOSECPP_SHARED_API void set_UseMachineKeyStore(bool value);
 
    ASPOSECPP_SHARED_API ByteArrayPtr Decrypt(const ByteArrayPtr& rgb, bool use_oaep);
 
    ASPOSECPP_SHARED_API ByteArrayPtr Decrypt(ByteArrayPtr data, SharedPtr<RSAEncryptionPadding> padding) override;
 
    ASPOSECPP_SHARED_API ByteArrayPtr Encrypt(const ByteArrayPtr& rgb, bool use_oaep);
 
    ASPOSECPP_SHARED_API ByteArrayPtr Encrypt(ByteArrayPtr data, SharedPtr<RSAEncryptionPadding> padding) override;
 
    ASPOSECPP_SHARED_API ByteArrayPtr ExportCspBlob(bool include_private_parameters) override;
 
    ASPOSECPP_SHARED_API RSAParameters ExportParameters(bool include_private_parameters) override;
 
    ASPOSECPP_SHARED_API void ImportCspBlob(ByteArrayPtr key_blob) override;
 
    ASPOSECPP_SHARED_API void ImportParameters(RSAParameters parameters) override;
 
    ASPOSECPP_SHARED_API ByteArrayPtr SignData(const ByteArrayPtr& buffer, const SharedPtr<Object>& halg);
 
    ASPOSECPP_SHARED_API ByteArrayPtr SignData(const SharedPtr<IO::Stream>& input_stream, const SharedPtr<Object>& halg);
 
    ASPOSECPP_SHARED_API ByteArrayPtr SignData(const ByteArrayPtr& buffer, int32_t offset, int32_t count, const SharedPtr<Object>& halg);
 
    ASPOSECPP_SHARED_API ByteArrayPtr SignHash(ByteArrayPtr hash, HashAlgorithmName hash_algorithm,
        SharedPtr<RSASignaturePadding> padding) override;
 
    ASPOSECPP_SHARED_API ByteArrayPtr SignHash(const ByteArrayPtr& rgb_hash, const String& str);
 
    ASPOSECPP_SHARED_API bool VerifyData(const ByteArrayPtr& buffer, const SharedPtr<Object>& halg, const ByteArrayPtr& signature);
 
    ASPOSECPP_SHARED_API bool VerifyHash(const ByteArrayPtr& rgb_hash, const String& str, const ByteArrayPtr& rgb_signature);
 
    ASPOSECPP_SHARED_API bool VerifyHash(ByteArrayPtr hash, ByteArrayPtr signature, const HashAlgorithmName& hash_algorithm,
        SharedPtr<RSASignaturePadding> padding) override;
 
    ASPOSECPP_SHARED_API void Dispose() override;
 
protected:
    ASPOSECPP_SHARED_API ByteArrayPtr HashData(ByteArrayPtr data, int32_t offset, int32_t count, HashAlgorithmName hash_algorithm) override;
 
    ASPOSECPP_SHARED_API ByteArrayPtr HashData(StreamPtr stream, HashAlgorithmName hash_algorithm) override;
 
private:
    int32_t m_key_size;
    bool m_persist_key_in_csp;
    static bool s_use_machine_key_store;
    std::unique_ptr<Details::RSACryptoServiceProviderPimpl> m_pimpl;
 
    void VerifyNotDisposed() const;
    void VerifyPrivateKeyExists() const;
    void SetupLegalKeySizesValue();
 
    ByteArrayPtr SignHash(const ByteArrayPtr& hash_value, const SharedPtr<HashAlgorithm>& hash_algorithm);
    bool VerifyHash(const ByteArrayPtr& rgb_hash, const SharedPtr<HashAlgorithm>& hash_algorithm, const ByteArrayPtr& rgb_signature);
};
 
}}} // namespace System::Security::Cryptography