ssl_stream.h

 
#pragma once
 
#include <cstdint>
#include <security/cryptography/x509_certificates/x509_certificate.h>
#include <security/cryptography/x509_certificates/x509_certificate_collection.h>
#include <security/cryptography/x509_certificates/x509_chain.h>
#include <system/array.h>
#include <system/async_callback.h>
#include <system/enum_helpers.h>
#include <system/iasyncresult.h>
#include <system/io/seekorigin.h>
#include <system/multicast_delegate.h>
#include <system/object.h>
#include <system/shared_ptr.h>
#include <system/string.h>
 
#include <net/secure_protocols/authentificated_stream.h>
#include <net/secure_protocols/ssl_enum_types.h>
#include <net/secure_protocols/ssl_policy_errors.h>
 
namespace System { namespace Net { namespace Details {
class TlsStreamImplStream;
class TlsStreamImplSocket;
}}} // namespace System::Net::Details
 
namespace System { namespace Net { namespace Security {
 
enum class EncryptionPolicy
{
    RequireEncryption = 0,
    AllowNoEncryption,
    NoEncryption
};
 
using RemoteCertificateValidationCallback = System::MulticastDelegate<bool(
    System::SharedPtr<Object>, System::SharedPtr<System::Security::Cryptography::X509Certificates::X509Certificate>,
    System::SharedPtr<System::Security::Cryptography::X509Certificates::X509Chain>, SslPolicyErrors)>;
 
using LocalCertificateSelectionCallback =
    System::MulticastDelegate<System::SharedPtr<System::Security::Cryptography::X509Certificates::X509Certificate>(
        System::SharedPtr<Object>, String,
        System::SharedPtr<System::Security::Cryptography::X509Certificates::X509CertificateCollection>,
        System::SharedPtr<System::Security::Cryptography::X509Certificates::X509Certificate>,
        System::ArrayPtr<String>)>;
 
class TlsStreamAsyncResult;
 
class ASPOSECPP_SHARED_CLASS SslStream : public System::Net::Security::AuthenticatedStream
{
    friend class TlsStreamAsyncResult;
 
    typedef SslStream ThisType;
    typedef System::Net::Security::AuthenticatedStream BaseType;
 
    typedef ::System::BaseTypesInfo<BaseType> ThisTypeBaseTypesInfo;
    ASPOSECPP_SHARED_RTTI_INFO_DECL();
public:
    typedef TlsStreamAsyncResult AsyncResultType;
    typedef std::shared_ptr<System::Net::Details::TlsStreamImplSocket> StreamImplementationPtr;
 
 
    ASPOSECPP_SHARED_API bool get_IsAuthenticated() const override;
    ASPOSECPP_SHARED_API bool get_IsMutuallyAuthenticated() const override;
    ASPOSECPP_SHARED_API bool get_IsEncrypted() const override;
    ASPOSECPP_SHARED_API bool get_IsSigned() const override;
    ASPOSECPP_SHARED_API bool get_IsServer() const override;
    virtual ASPOSECPP_SHARED_API System::Security::Authentication::SslProtocols get_SslProtocol();
    // process.
    virtual ASPOSECPP_SHARED_API bool get_CheckCertRevocationStatus();
    virtual ASPOSECPP_SHARED_API System::SharedPtr<System::Security::Cryptography::X509Certificates::X509Certificate>
        get_LocalCertificate();
    virtual ASPOSECPP_SHARED_API System::SharedPtr<System::Security::Cryptography::X509Certificates::X509Certificate>
        get_RemoteCertificate();
    virtual ASPOSECPP_SHARED_API System::Security::Authentication::CipherAlgorithmType get_CipherAlgorithm();
    virtual ASPOSECPP_SHARED_API int32_t get_CipherStrength();
    virtual ASPOSECPP_SHARED_API System::Security::Authentication::HashAlgorithmType get_HashAlgorithm();
    virtual ASPOSECPP_SHARED_API int32_t get_HashStrength();
    virtual ASPOSECPP_SHARED_API int32_t get_KeyExchangeStrength();
    ASPOSECPP_SHARED_API bool get_CanSeek() const override;
    ASPOSECPP_SHARED_API bool get_CanRead() const override;
    ASPOSECPP_SHARED_API bool get_CanTimeout() const override;
    ASPOSECPP_SHARED_API bool get_CanWrite() const override;
    ASPOSECPP_SHARED_API int32_t get_ReadTimeout() const override;
    ASPOSECPP_SHARED_API void set_ReadTimeout(int32_t value) override;
    ASPOSECPP_SHARED_API int32_t get_WriteTimeout() const override;
    ASPOSECPP_SHARED_API void set_WriteTimeout(int32_t value) override;
    ASPOSECPP_SHARED_API int64_t get_Length() const override;
    ASPOSECPP_SHARED_API int64_t get_Position() const override;
    ASPOSECPP_SHARED_API void set_Position(int64_t value) override;
 
    ASPOSECPP_SHARED_API SslStream(System::SharedPtr<IO::Stream> innerStream);
    ASPOSECPP_SHARED_API SslStream(System::SharedPtr<IO::Stream> innerStream, bool leaveInnerStreamOpen);
    ASPOSECPP_SHARED_API SslStream(System::SharedPtr<IO::Stream> innerStream, bool leaveInnerStreamOpen,
                                   RemoteCertificateValidationCallback userCertificateValidationCallback);
    ASPOSECPP_SHARED_API SslStream(System::SharedPtr<IO::Stream> innerStream, bool leaveInnerStreamOpen,
                                   RemoteCertificateValidationCallback userCertificateValidationCallback,
                                   LocalCertificateSelectionCallback userCertificateSelectionCallback);
    ASPOSECPP_SHARED_API SslStream(System::SharedPtr<IO::Stream> innerStream, bool leaveInnerStreamOpen,
                                   RemoteCertificateValidationCallback userCertificateValidationCallback,
                                   LocalCertificateSelectionCallback userCertificateSelectionCallback,
                                   EncryptionPolicy encryptionPolicy);
 
    virtual ASPOSECPP_SHARED_API void AuthenticateAsClient(String targetHost);
    virtual ASPOSECPP_SHARED_API void AuthenticateAsClient(
        String targetHost,
        System::SharedPtr<System::Security::Cryptography::X509Certificates::X509CertificateCollection>
            clientCertificates,
        System::Security::Authentication::SslProtocols enabledSslProtocols, bool checkCertificateRevocation);
 
    ASPOSECPP_SHARED_API void SetLength(int64_t value) override;
    ASPOSECPP_SHARED_API int64_t Seek(int64_t offset, IO::SeekOrigin origin) override;
    ASPOSECPP_SHARED_API void Flush() override;
    ASPOSECPP_SHARED_API int32_t Read(const ArrayPtr<uint8_t>& buffer, int32_t offset, int32_t count) override;
    ASPOSECPP_SHARED_API void Write(const ArrayPtr<uint8_t>& buffer);
    ASPOSECPP_SHARED_API void Write(const ArrayPtr<uint8_t>& buffer, int32_t offset, int32_t count) override;
    ASPOSECPP_SHARED_API int32_t Read(const System::Details::ArrayView<uint8_t>& buffer, int32_t offset, int32_t count) override;
    ASPOSECPP_SHARED_API void Write(const System::Details::ArrayView<uint8_t>& buffer);
    ASPOSECPP_SHARED_API void Write(const System::Details::ArrayView<uint8_t>& buffer, int32_t offset, int32_t count) override;
    ASPOSECPP_SHARED_API System::SharedPtr<IAsyncResult> BeginRead(System::ArrayPtr<uint8_t> buffer, int32_t offset,
                                                                   int32_t count, AsyncCallback asyncCallback,
                                                                   System::SharedPtr<Object> asyncState) override;
    ASPOSECPP_SHARED_API int32_t EndRead(System::SharedPtr<IAsyncResult> asyncResult) override;
    ASPOSECPP_SHARED_API System::SharedPtr<IAsyncResult> BeginWrite(System::ArrayPtr<uint8_t> buffer, int32_t offset,
                                                                    int32_t count, AsyncCallback asyncCallback,
                                                                    System::SharedPtr<Object> asyncState) override;
    ASPOSECPP_SHARED_API void EndWrite(System::SharedPtr<IAsyncResult> asyncResult) override;
 
    ASPOSECPP_SHARED_API void Dispose(bool disposing) override;
    ASPOSECPP_SHARED_API void Close() override;
 
private:
    size_t read(uint8_t buffer[], size_t size);
    void write(const uint8_t buffer[], size_t size);
 
    StreamImplementationPtr stream_impl;
};
}}} // namespace System::Net::Security
 
DECLARE_USING_ENUM_OPERATORS(System::Net::Security);