dsa_crypto_service_provider.h

 
#pragma once
 
#include <security/cryptography/dsa.h>
#include <security/cryptography/i_csp_asymmetric_algorithm.h>
#include <memory>
 
namespace System { namespace Security { namespace Cryptography {
 
namespace Details { struct DSACryptoServiceProviderPimpl; }
 
class ASPOSECPP_SHARED_CLASS DSACryptoServiceProvider final : public DSA, public ICspAsymmetricAlgorithm
{
    typedef DSACryptoServiceProvider ThisType;
    typedef DSA BaseType;
    typedef ICspAsymmetricAlgorithm BaseType1;
    typedef System::BaseTypesInfo<BaseType, BaseType1> ThisBaseTypesInfo;
    ASPOSECPP_SHARED_RTTI_INFO_DECL();
 
public:
    using DSA::SignData;
    using DSA::VerifyData;
 
    ASPOSECPP_SHARED_API DSACryptoServiceProvider();
 
    ASPOSECPP_SHARED_API DSACryptoServiceProvider(const DSAParameters& parameters);
 
    ASPOSECPP_SHARED_API DSACryptoServiceProvider(const SharedPtr<CspParameters>& parameters);
 
    ASPOSECPP_SHARED_API DSACryptoServiceProvider(int32_t key_size);
 
    ASPOSECPP_SHARED_API DSACryptoServiceProvider(int32_t key_size, const SharedPtr<CspParameters>& parameters);
 
    ASPOSECPP_SHARED_API SharedPtr<CspKeyContainerInfo> get_CspKeyContainerInfo() override;
 
    ASPOSECPP_SHARED_API bool get_PersistKeyInCsp() const;
 
    ASPOSECPP_SHARED_API void set_PersistKeyInCsp(bool value);
 
    ASPOSECPP_SHARED_API bool get_PublicOnly() const;
 
    static ASPOSECPP_SHARED_API bool get_UseMachineKeyStore();
 
    static ASPOSECPP_SHARED_API void set_UseMachineKeyStore(bool value);
 
    ASPOSECPP_SHARED_API String get_KeyExchangeAlgorithm() override;
 
    ASPOSECPP_SHARED_API int32_t get_KeySize() override;
 
    ASPOSECPP_SHARED_API String get_SignatureAlgorithm() override;
 
    ASPOSECPP_SHARED_API ByteArrayPtr CreateSignature(ByteArrayPtr rgb_hash) override;
 
    ASPOSECPP_SHARED_API bool VerifySignature(ByteArrayPtr rgb_hash, ByteArrayPtr rgb_signature) override;
 
    ASPOSECPP_SHARED_API ByteArrayPtr ExportCspBlob(bool include_private_parameters) override;
 
    ASPOSECPP_SHARED_API DSAParameters ExportParameters(bool include_private_parameters) override;
 
    ASPOSECPP_SHARED_API void ImportCspBlob(ByteArrayPtr key_blob) override;
 
    ASPOSECPP_SHARED_API void ImportParameters(DSAParameters parameters) override;
 
    ASPOSECPP_SHARED_API ByteArrayPtr SignData(const ByteArrayPtr& buffer);
 
    ASPOSECPP_SHARED_API ByteArrayPtr SignData(const SharedPtr<IO::Stream>& input_stream);
 
    ASPOSECPP_SHARED_API ByteArrayPtr SignData(const ByteArrayPtr& buffer, int32_t offset, int32_t count);
 
    ASPOSECPP_SHARED_API ByteArrayPtr SignHash(const ByteArrayPtr& rgb_hash, const String& str);
 
    ASPOSECPP_SHARED_API bool VerifyData(const ByteArrayPtr& buffer, const ByteArrayPtr& signature);
 
    ASPOSECPP_SHARED_API bool VerifyHash(const ByteArrayPtr& rgb_hash, const String& str, const ByteArrayPtr& rgb_signature);
 
    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:
    bool m_persist_key_in_csp = false;
    static bool s_use_machine_key_store;
 
    std::unique_ptr<Details::DSACryptoServiceProviderPimpl> m_pimpl;
 
    ASPOSECPP_SHARED_API ~DSACryptoServiceProvider();
 
    void VerifyNotDisposed() const;
    void VerifyPrivateKeyExists() const;
    void SetupLegalKeySizesValue();
};
 
}}} // namespace System::Security::Cryptography