ec_dsa_botan.h

 
#pragma once
 
#include <security/cryptography/ec_dsa.h>
#include <security/cryptography/ec_key_xml_format.h>
#include <security/cryptography/hash_algorithm_name.h>
#include <memory>
 
namespace Botan {
 
class ECDSA_PublicKey;
class ECDSA_PrivateKey;
 
} // namespace Botan
 
namespace System { namespace Security { namespace Cryptography {
 
class ASPOSECPP_SHARED_CLASS ECDsaBotan final : public ECDsa
{
    typedef ECDsaBotan ThisType;
    typedef ECDsa BaseType;
    ASPOSECPP_SHARED_RTTI_INFO_DECL();
 
public:
    using ECDsa::SignData;
    using ECDsa::VerifyData;
 
    ASPOSECPP_SHARED_API ECDsaBotan();
 
    ASPOSECPP_SHARED_API ECDsaBotan(const ECParameters& parameters);
 
    ASPOSECPP_SHARED_API ECDsaBotan(const ECCurve& curve);
 
    ASPOSECPP_SHARED_API ECDsaBotan(int32_t key_size);
 
    ASPOSECPP_SHARED_API ECDsaBotan(const Botan::ECDSA_PublicKey& key);
 
    ASPOSECPP_SHARED_API ECDsaBotan(const Botan::ECDSA_PrivateKey& key);
 
    ASPOSECPP_SHARED_API void set_KeySize(int32_t value) override;
 
    ASPOSECPP_SHARED_API HashAlgorithmName get_HashAlgorithm() const;
 
    ASPOSECPP_SHARED_API void set_HashAlgorithm(const HashAlgorithmName& value);
 
    ASPOSECPP_SHARED_API ECParameters ExportExplicitParameters(bool include_private_parameters) override;
 
    ASPOSECPP_SHARED_API ECParameters ExportParameters(bool include_private_parameters) override;
 
    ASPOSECPP_SHARED_API void FromXmlString(String xml_string) override;
 
    ASPOSECPP_SHARED_API void FromXmlString(const String& xml_string, ECKeyXmlFormat format);
 
    ASPOSECPP_SHARED_API void GenerateKey(const ECCurve& curve) override;
 
    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;
 
    ASPOSECPP_SHARED_API void ImportParameters(const ECParameters& parameters) override;
 
    ASPOSECPP_SHARED_API ByteArrayPtr SignData(const ByteArrayPtr& data);
 
    ASPOSECPP_SHARED_API ByteArrayPtr SignData(const ByteArrayPtr& data, int32_t offset, int32_t count);
 
    ASPOSECPP_SHARED_API ByteArrayPtr SignData(const StreamPtr& stream);
 
    ASPOSECPP_SHARED_API ByteArrayPtr SignHash(const ByteArrayPtr& hash) override;
 
    ASPOSECPP_SHARED_API String ToXmlString(bool include_private_parameters) override;
 
    ASPOSECPP_SHARED_API String ToXmlString(ECKeyXmlFormat format);
 
    ASPOSECPP_SHARED_API bool VerifyData(const ByteArrayPtr& data, const ByteArrayPtr& signature);
 
    ASPOSECPP_SHARED_API bool VerifyData(const ByteArrayPtr& data, int32_t offset, int32_t count,
        const ByteArrayPtr& signature);
 
    ASPOSECPP_SHARED_API bool VerifyData(const StreamPtr& stream, const ByteArrayPtr& signature);
 
    ASPOSECPP_SHARED_API bool VerifyHash(ByteArrayPtr hash, ByteArrayPtr signature) override;
 
protected:
    virtual ASPOSECPP_SHARED_API void Dispose(bool disposing);
 
private:
    struct Implementation;
    std::unique_ptr<Implementation> m_pimpl;
 
    HashAlgorithmName m_hash_algorithm;
 
    void VerifyNotDisposed() const;
    void SetupLegalKeySizesValue();
    void GenerateKey(int32_t key_size);
};
 
}}} // namespace System::Security::Cryptography