rsa.h

 
#pragma once
 
#include <system/io/stream.h>
#include <security/cryptography/asymmetric_algorithm.h>
#include <security/cryptography/rsa_encryption_padding.h>
#include <security/cryptography/rsa_signature_padding.h>
#include <security/cryptography/rsa_parameters.h>
 
namespace System { namespace Security { namespace Cryptography {
 
class ASPOSECPP_SHARED_CLASS ABSTRACT RSA : public AsymmetricAlgorithm
{
    typedef RSA ThisType;
    typedef AsymmetricAlgorithm BaseType;
    ASPOSECPP_SHARED_RTTI_INFO_DECL();
 
public:
    ASPOSECPP_SHARED_API String get_KeyExchangeAlgorithm() override;
 
    ASPOSECPP_SHARED_API String get_SignatureAlgorithm() override;
 
    virtual ASPOSECPP_SHARED_API ByteArrayPtr Decrypt(ByteArrayPtr data, SharedPtr<RSAEncryptionPadding> padding);
 
    virtual ASPOSECPP_SHARED_API ByteArrayPtr DecryptValue(ByteArrayPtr rgb);
 
    virtual ASPOSECPP_SHARED_API ByteArrayPtr Encrypt(ByteArrayPtr data, SharedPtr<RSAEncryptionPadding> padding);
 
    virtual ASPOSECPP_SHARED_API ByteArrayPtr EncryptValue(ByteArrayPtr rgb);
 
    virtual ASPOSECPP_SHARED_API RSAParameters ExportParameters(bool include_private_parameters) = 0;
 
    virtual ASPOSECPP_SHARED_API void ImportParameters(RSAParameters parameters) = 0;
 
    ASPOSECPP_SHARED_API void FromXmlString(String xml_string) override;
 
    ASPOSECPP_SHARED_API String ToXmlString(bool include_private_parameters) override;
 
    ASPOSECPP_SHARED_API ByteArrayPtr SignData(const ByteArrayPtr& data, const HashAlgorithmName& hash_algorithm,
        const SharedPtr<RSASignaturePadding>& padding);
 
    ASPOSECPP_SHARED_API ByteArrayPtr SignData(const ByteArrayPtr& data, int32_t offset, int32_t count,
        const HashAlgorithmName& hash_algorithm,
        const SharedPtr<RSASignaturePadding>& padding);
 
    ASPOSECPP_SHARED_API ByteArrayPtr SignData(const StreamPtr& stream, const HashAlgorithmName& hash_algorithm,
        const SharedPtr<RSASignaturePadding>& padding);
 
    virtual ASPOSECPP_SHARED_API ByteArrayPtr SignHash(ByteArrayPtr hash, HashAlgorithmName hash_algorithm,
        SharedPtr<RSASignaturePadding> padding);
 
    ASPOSECPP_SHARED_API bool VerifyData(const ByteArrayPtr& data, const ByteArrayPtr& signature, const HashAlgorithmName& hash_algorithm,
        const SharedPtr<RSASignaturePadding>& padding);
 
    ASPOSECPP_SHARED_API bool VerifyData(const ByteArrayPtr& data, int32_t offset, int32_t count,
        const ByteArrayPtr& signature, const HashAlgorithmName& hash_algorithm,
        const SharedPtr<RSASignaturePadding>& padding);
 
    ASPOSECPP_SHARED_API bool VerifyData(const StreamPtr& stream, const ByteArrayPtr& signature, const HashAlgorithmName& hash_algorithm,
        const SharedPtr<RSASignaturePadding>& padding);
 
    virtual ASPOSECPP_SHARED_API bool VerifyHash(ByteArrayPtr hash, ByteArrayPtr signature, const HashAlgorithmName& hash_algorithm,
        SharedPtr<RSASignaturePadding> padding);
 
    static ASPOSECPP_SHARED_API SharedPtr<RSA> Create();
 
    static ASPOSECPP_SHARED_API SharedPtr<RSA> Create(const String& alg_name);
 
    static ASPOSECPP_SHARED_API SharedPtr<RSA> Create(int32_t key_size_in_bits);
 
    static ASPOSECPP_SHARED_API SharedPtr<RSA> Create(const RSAParameters& parameters);
 
    static ASPOSECPP_SHARED_API SharedPtr<RSA> CreateFromXmlString(const String& xml_string);
 
protected:
    ASPOSECPP_SHARED_API RSA();
 
    virtual ASPOSECPP_SHARED_API ByteArrayPtr HashData(ByteArrayPtr data, int32_t offset, int32_t count, HashAlgorithmName hash_algorithm);
 
    virtual ASPOSECPP_SHARED_API ByteArrayPtr HashData(StreamPtr stream, HashAlgorithmName hash_algorithm);
};
 
}}} // namespace System::Security::Cryptography