SslStream Clase
Definición
Importante
Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.
Proporciona una transmisión que se utiliza para la comunicación cliente/servidor que utiliza el protocolo de seguridad Capa de sockets seguros (SSL) para autenticar el servidor y, opcionalmente, el cliente.
public ref class SslStream : System::Net::Security::AuthenticatedStreampublic class SslStream : System.Net.Security.AuthenticatedStreamtype SslStream = class
inherit AuthenticatedStreamtype SslStream = class
inherit AuthenticatedStream
interface IDisposablePublic Class SslStream
Inherits AuthenticatedStream- Herencia
- Herencia
- Implementaciones
Ejemplos
En el ejemplo de código siguiente se muestra cómo crear un TcpListener objeto que usa la SslStream clase para comunicarse con los clientes.
#using <System.dll>
using namespace System;
using namespace System::Collections;
using namespace System::Net;
using namespace System::Net::Sockets;
using namespace System::Net::Security;
using namespace System::Security::Authentication;
using namespace System::Text;
using namespace System::Security::Cryptography::X509Certificates;
using namespace System::IO;
public ref class SslTcpServer sealed
{
private:
static X509Certificate^ serverCertificate = nullptr;
public:
// The certificate parameter specifies the name of the file
// containing the machine certificate.
static void RunServer( String^ certificate )
{
serverCertificate = X509Certificate::CreateFromCertFile( certificate );
// Create a TCP/IP (IPv4) socket and listen for incoming connections.
TcpListener^ listener = gcnew TcpListener( IPAddress::Any,8080 );
listener->Start();
while (true)
{
Console::WriteLine( L"Waiting for a client to connect..." );
// Application blocks while waiting for an incoming connection.
// Type CNTL-C to terminate the server.
TcpClient^ client = listener->AcceptTcpClient();
ProcessClient( client );
}
}
static void ProcessClient( TcpClient^ client )
{
// A client has connected. Create the
// SslStream using the client's network stream.
SslStream^ sslStream = gcnew SslStream( client->GetStream(),false );
// Authenticate the server but don't require the client to authenticate.
try
{
sslStream->AuthenticateAsServer( serverCertificate, false, true );
// false == no client cert required; true == check cert revocation.
// Display the properties and settings for the authenticated stream.
DisplaySecurityLevel( sslStream );
DisplaySecurityServices( sslStream );
DisplayCertificateInformation( sslStream );
DisplayStreamProperties( sslStream );
// Set timeouts for the read and write to 5 seconds.
sslStream->ReadTimeout = 5000;
sslStream->WriteTimeout = 5000;
// Read a message from the client.
Console::WriteLine( L"Waiting for client message..." );
String^ messageData = ReadMessage( sslStream );
Console::WriteLine( L"Received: {0}", messageData );
// Write a message to the client.
array<Byte>^message = Encoding::UTF8->GetBytes( L"Hello from the server.<EOF>" );
Console::WriteLine( L"Sending hello message." );
sslStream->Write( message );
}
catch ( AuthenticationException^ e )
{
Console::WriteLine( L"Exception: {0}", e->Message );
if ( e->InnerException != nullptr )
{
Console::WriteLine( L"Inner exception: {0}", e->InnerException->Message );
}
Console::WriteLine( L"Authentication failed - closing the connection." );
sslStream->Close();
client->Close();
return;
}
finally
{
// The client stream will be closed with the sslStream
// because we specified this behavior when creating
// the sslStream.
sslStream->Close();
client->Close();
}
}
static String^ ReadMessage( SslStream^ sslStream )
{
// Read the message sent by the client.
// The client signals the end of the message using the
// "<EOF>" marker.
array<Byte>^buffer = gcnew array<Byte>(2048);
StringBuilder^ messageData = gcnew StringBuilder;
int bytes = -1;
do
{
// Read the client's test message.
bytes = sslStream->Read( buffer, 0, buffer->Length );
// Use Decoder class to convert from bytes to UTF8
// in case a character spans two buffers.
Decoder^ decoder = Encoding::UTF8->GetDecoder();
array<Char>^chars = gcnew array<Char>(decoder->GetCharCount( buffer, 0, bytes ));
decoder->GetChars( buffer, 0, bytes, chars, 0 );
messageData->Append( chars );
// Check for EOF or an empty message.
if ( messageData->ToString()->IndexOf( L"<EOF>" ) != -1 )
{
break;
}
}
while ( bytes != 0 );
return messageData->ToString();
}
static void DisplaySecurityLevel( SslStream^ stream )
{
Console::WriteLine( L"Cipher: {0} strength {1}", stream->CipherAlgorithm, stream->CipherStrength );
Console::WriteLine( L"Hash: {0} strength {1}", stream->HashAlgorithm, stream->HashStrength );
Console::WriteLine( L"Key exchange: {0} strength {1}", stream->KeyExchangeAlgorithm, stream->KeyExchangeStrength );
Console::WriteLine( L"Protocol: {0}", stream->SslProtocol );
}
static void DisplaySecurityServices( SslStream^ stream )
{
Console::WriteLine( L"Is authenticated: {0} as server? {1}", stream->IsAuthenticated, stream->IsServer );
Console::WriteLine( L"IsSigned: {0}", stream->IsSigned );
Console::WriteLine( L"Is Encrypted: {0}", stream->IsEncrypted );
}
static void DisplayStreamProperties( SslStream^ stream )
{
Console::WriteLine( L"Can read: {0}, write {1}", stream->CanRead, stream->CanWrite );
Console::WriteLine( L"Can timeout: {0}", stream->CanTimeout );
}
static void DisplayCertificateInformation( SslStream^ stream )
{
Console::WriteLine( L"Certificate revocation list checked: {0}", stream->CheckCertRevocationStatus );
X509Certificate^ localCertificate = stream->LocalCertificate;
if ( stream->LocalCertificate != nullptr )
{
Console::WriteLine( L"Local cert was issued to {0} and is valid from {1} until {2}.",
localCertificate->Subject,
localCertificate->GetEffectiveDateString(),
localCertificate->GetExpirationDateString() );
}
else
{
Console::WriteLine( L"Local certificate is null." );
}
X509Certificate^ remoteCertificate = stream->RemoteCertificate;
if ( stream->RemoteCertificate != nullptr )
{
Console::WriteLine( L"Remote cert was issued to {0} and is valid from {1} until {2}.",
remoteCertificate->Subject,
remoteCertificate->GetEffectiveDateString(),
remoteCertificate->GetExpirationDateString() );
}
else
{
Console::WriteLine( L"Remote certificate is null." );
}
}
private:
static void DisplayUsage()
{
Console::WriteLine( L"To start the server specify:" );
Console::WriteLine( L"serverSync certificateFile.cer" );
Environment::Exit( 1 );
}
public:
int RunServerASync()
{
array<String^>^args = Environment::GetCommandLineArgs();
String^ certificate = nullptr;
if ( args == nullptr || args->Length < 2 )
{
DisplayUsage();
}
certificate = args[ 1 ];
SslTcpServer::RunServer( certificate );
return 0;
}
};
int main(){
SslTcpServer^ sts = gcnew SslTcpServer();
sts->RunServerASync();
}
using System;
using System.Collections;
using System.Net;
using System.Net.Sockets;
using System.Net.Security;
using System.Security.Authentication;
using System.Text;
using System.Security.Cryptography.X509Certificates;
using System.IO;
namespace Examples.System.Net
{
public sealed class SslTcpServer
{
static X509Certificate serverCertificate = null;
// The certificate parameter specifies the name of the file
// containing the machine certificate.
public static void RunServer(string certificate)
{
serverCertificate = X509Certificate.CreateFromCertFile(certificate);
// Create a TCP/IP (IPv4) socket and listen for incoming connections.
TcpListener listener = new TcpListener(IPAddress.Any, 8080);
listener.Start();
while (true)
{
Console.WriteLine("Waiting for a client to connect...");
// Application blocks while waiting for an incoming connection.
// Type CNTL-C to terminate the server.
TcpClient client = listener.AcceptTcpClient();
ProcessClient(client);
}
}
static void ProcessClient (TcpClient client)
{
// A client has connected. Create the
// SslStream using the client's network stream.
SslStream sslStream = new SslStream(
client.GetStream(), false);
// Authenticate the server but don't require the client to authenticate.
try
{
sslStream.AuthenticateAsServer(serverCertificate, clientCertificateRequired: false, checkCertificateRevocation: true);
// Display the properties and settings for the authenticated stream.
DisplaySecurityLevel(sslStream);
DisplaySecurityServices(sslStream);
DisplayCertificateInformation(sslStream);
DisplayStreamProperties(sslStream);
// Set timeouts for the read and write to 5 seconds.
sslStream.ReadTimeout = 5000;
sslStream.WriteTimeout = 5000;
// Read a message from the client.
Console.WriteLine("Waiting for client message...");
string messageData = ReadMessage(sslStream);
Console.WriteLine("Received: {0}", messageData);
// Write a message to the client.
byte[] message = Encoding.UTF8.GetBytes("Hello from the server.<EOF>");
Console.WriteLine("Sending hello message.");
sslStream.Write(message);
}
catch (AuthenticationException e)
{
Console.WriteLine("Exception: {0}", e.Message);
if (e.InnerException != null)
{
Console.WriteLine("Inner exception: {0}", e.InnerException.Message);
}
Console.WriteLine ("Authentication failed - closing the connection.");
sslStream.Close();
client.Close();
return;
}
finally
{
// The client stream will be closed with the sslStream
// because we specified this behavior when creating
// the sslStream.
sslStream.Close();
client.Close();
}
}
static string ReadMessage(SslStream sslStream)
{
// Read the message sent by the client.
// The client signals the end of the message using the
// "<EOF>" marker.
byte [] buffer = new byte[2048];
StringBuilder messageData = new StringBuilder();
int bytes = -1;
do
{
// Read the client's test message.
bytes = sslStream.Read(buffer, 0, buffer.Length);
// Use Decoder class to convert from bytes to UTF8
// in case a character spans two buffers.
Decoder decoder = Encoding.UTF8.GetDecoder();
char[] chars = new char[decoder.GetCharCount(buffer,0,bytes)];
decoder.GetChars(buffer, 0, bytes, chars,0);
messageData.Append (chars);
// Check for EOF or an empty message.
if (messageData.ToString().IndexOf("<EOF>") != -1)
{
break;
}
} while (bytes !=0);
return messageData.ToString();
}
static void DisplaySecurityLevel(SslStream stream)
{
Console.WriteLine("Cipher: {0} strength {1}", stream.CipherAlgorithm, stream.CipherStrength);
Console.WriteLine("Hash: {0} strength {1}", stream.HashAlgorithm, stream.HashStrength);
Console.WriteLine("Key exchange: {0} strength {1}", stream.KeyExchangeAlgorithm, stream.KeyExchangeStrength);
Console.WriteLine("Protocol: {0}", stream.SslProtocol);
}
static void DisplaySecurityServices(SslStream stream)
{
Console.WriteLine("Is authenticated: {0} as server? {1}", stream.IsAuthenticated, stream.IsServer);
Console.WriteLine("IsSigned: {0}", stream.IsSigned);
Console.WriteLine("Is Encrypted: {0}", stream.IsEncrypted);
}
static void DisplayStreamProperties(SslStream stream)
{
Console.WriteLine("Can read: {0}, write {1}", stream.CanRead, stream.CanWrite);
Console.WriteLine("Can timeout: {0}", stream.CanTimeout);
}
static void DisplayCertificateInformation(SslStream stream)
{
Console.WriteLine("Certificate revocation list checked: {0}", stream.CheckCertRevocationStatus);
X509Certificate localCertificate = stream.LocalCertificate;
if (stream.LocalCertificate != null)
{
Console.WriteLine("Local cert was issued to {0} and is valid from {1} until {2}.",
localCertificate.Subject,
localCertificate.GetEffectiveDateString(),
localCertificate.GetExpirationDateString());
} else
{
Console.WriteLine("Local certificate is null.");
}
// Display the properties of the client's certificate.
X509Certificate remoteCertificate = stream.RemoteCertificate;
if (stream.RemoteCertificate != null)
{
Console.WriteLine("Remote cert was issued to {0} and is valid from {1} until {2}.",
remoteCertificate.Subject,
remoteCertificate.GetEffectiveDateString(),
remoteCertificate.GetExpirationDateString());
} else
{
Console.WriteLine("Remote certificate is null.");
}
}
private static void DisplayUsage()
{
Console.WriteLine("To start the server specify:");
Console.WriteLine("serverSync certificateFile.cer");
Environment.Exit(1);
}
public static int Main(string[] args)
{
string certificate = null;
if (args == null ||args.Length < 1 )
{
DisplayUsage();
}
certificate = args[0];
SslTcpServer.RunServer (certificate);
return 0;
}
}
}
Imports System.Collections
Imports System.Net
Imports System.Net.Sockets
Imports System.Net.Security
Imports System.Security.Authentication
Imports System.Text
Imports System.Security.Cryptography.X509Certificates
Imports System.IO
Namespace Examples.System.Net
Public NotInheritable Class SslTcpServer
Shared serverCertificate As X509Certificate = Nothing
' The certificate parameter specifies the name of the file
' containing the machine certificate.
Public Shared Sub RunServer(certificate As String)
serverCertificate = X509Certificate.CreateFromCertFile(certificate)
' Create a TCP/IP (IPv4) socket And listen for incoming connections.
Dim listener = New TcpListener(IPAddress.Any, 8080)
listener.Start()
While True
Console.WriteLine("Waiting for a client to connect...")
' Application blocks while waiting for an incoming connection.
' Type CNTL-C to terminate the server.
Dim client As TcpClient = listener.AcceptTcpClient()
ProcessClient(client)
End While
End Sub
Private Shared Sub ProcessClient(client As TcpClient)
' A client has connected. Create the
' SslStream using the client's network stream.
Dim sslStream = New SslStream(client.GetStream(), False)
Try
sslStream.AuthenticateAsServer(serverCertificate, clientCertificateRequired:=False, checkCertificateRevocation:=True)
' Display the properties And settings for the authenticated stream.
DisplaySecurityLevel(sslStream)
DisplaySecurityServices(sslStream)
DisplayCertificateInformation(sslStream)
DisplayStreamProperties(sslStream)
' Set timeouts for the read and write to 5 seconds.
sslStream.ReadTimeout = 5000
sslStream.WriteTimeout = 5000
' Read a message from the client.
Console.WriteLine("Waiting for client message...")
Dim messageData As String = ReadMessage(sslStream)
Console.WriteLine("Received: {0}", messageData)
' Write a message to the client.
Dim message As Byte() = Encoding.UTF8.GetBytes("Hello from the server.<EOF>")
Console.WriteLine("Sending hello message.")
sslStream.Write(message)
Catch e As AuthenticationException
Console.WriteLine("Exception: {0}", e.Message)
If e.InnerException IsNot Nothing Then
Console.WriteLine("Inner exception: {0}", e.InnerException.Message)
End If
Console.WriteLine("Authentication failed - closing the connection.")
sslStream.Close()
client.Close()
Return
Finally
' The client stream will be closed with the sslStream
' because we specified this behavior when creating
' the sslStream.
sslStream.Close()
client.Close()
End Try
End Sub
Private Shared Function ReadMessage(sslStream As SslStream) As String
' Read the message sent by the client.
' The client signals the end of the message using the
' "<EOF>" marker.
Dim buffer As Byte() = New Byte(2048) {}
Dim messageData As StringBuilder = New StringBuilder()
Dim bytes As Integer = -1
Do
' Read the client's test message.
bytes = sslStream.Read(buffer, 0, buffer.Length)
' Use decoder class to convert from bytes to UTF8
' in case a character spans two buffers.
Dim decoder As Decoder = Encoding.UTF8.GetDecoder()
Dim chars As Char() = New Char(decoder.GetCharCount(buffer, 0, bytes) - 1) {}
decoder.GetChars(buffer, 0, bytes, chars, 0)
messageData.Append(chars)
' Check for EOF or an empty message.
If messageData.ToString().IndexOf("<EOF>") <> -1 Then
Exit Do
End If
Loop While bytes <> 0
Return messageData.ToString()
End Function
Private Shared Sub DisplaySecurityLevel(stream As SslStream)
Console.WriteLine("Cipher: {0} strength {1}", stream.CipherAlgorithm, stream.CipherStrength)
Console.WriteLine("Hash: {0} strength {1}", stream.HashAlgorithm, stream.HashStrength)
Console.WriteLine("Key exchange: {0} strength {1}", stream.KeyExchangeAlgorithm, stream.KeyExchangeStrength)
Console.WriteLine("Protocol: {0}", stream.SslProtocol)
End Sub
Private Shared Sub DisplaySecurityServices(stream As SslStream)
Console.WriteLine("Is authenticated: {0} as server? {1}", stream.IsAuthenticated, stream.IsServer)
Console.WriteLine("IsSigned: {0}", stream.IsSigned)
Console.WriteLine("Is Encrypted: {0}", stream.IsEncrypted)
End Sub
Private Shared Sub DisplayStreamProperties(stream As SslStream)
Console.WriteLine("Can read: {0}, write {1}", stream.CanRead, stream.CanWrite)
Console.WriteLine("Can timeout: {0}", stream.CanTimeout)
End Sub
Private Shared Sub DisplayCertificateInformation(stream As SslStream)
Console.WriteLine("Certificate revocation list checked: {0}", stream.CheckCertRevocationStatus)
Dim localCertificate As X509Certificate = stream.LocalCertificate
If stream.LocalCertificate IsNot Nothing Then
Console.WriteLine("Local cert was issued to {0} and is valid from {1} until {2}.", localCertificate.Subject, localCertificate.GetEffectiveDateString(), localCertificate.GetExpirationDateString())
Else
Console.WriteLine("Local certificate is null.")
End If
' Display the properties of the client's certificate.
Dim remoteCertificate As X509Certificate = stream.RemoteCertificate
If stream.RemoteCertificate IsNot Nothing Then
Console.WriteLine("Remote cert was issued to {0} and is valid from {1} until {2}.", remoteCertificate.Subject, remoteCertificate.GetEffectiveDateString(), remoteCertificate.GetExpirationDateString())
Else
Console.WriteLine("Remote certificate is null.")
End If
End Sub
Private Shared Sub DisplayUsage()
Console.WriteLine("To start the server specify:")
Console.WriteLine("serverSync certificateFile.cer")
Environment.[Exit](1)
End Sub
Public Shared Function Main(ByVal args As String()) As Integer
Dim certificate As String
If args Is Nothing OrElse args.Length < 1 Then
DisplayUsage()
End If
certificate = args(0)
RunServer(certificate)
Return 0
End Function
End Class
End Namespace
En el ejemplo de código siguiente se muestra cómo crear un TcpClient objeto que usa la SslStream clase para comunicarse con un servidor.
#using <System.dll>
#using <System.Security.dll>
using namespace System;
using namespace System::Collections;
using namespace System::Globalization;
using namespace System::Net;
using namespace System::Net::Security;
using namespace System::Net::Sockets;
using namespace System::Security::Authentication;
using namespace System::Text;
using namespace System::Security::Cryptography::X509Certificates;
using namespace System::IO;
namespace NlsClientSync
{
public ref class SslTcpClient
{
private:
static Hashtable^ certificateErrors = gcnew Hashtable;
// Load a table of errors that might cause
// the certificate authentication to fail.
static void InitializeCertificateErrors()
{
certificateErrors->Add(0x800B0101,
"The certification has expired.");
certificateErrors->Add(0x800B0104,
"A path length constraint "
"in the certification chain has been violated.");
certificateErrors->Add(0x800B0105,
"A certificate contains an unknown extension "
"that is marked critical.");
certificateErrors->Add(0x800B0107,
"A parent of a given certificate in fact "
"did not issue that child certificate.");
certificateErrors->Add(0x800B0108,
"A certificate is missing or has an empty value "
"for a necessary field.");
certificateErrors->Add(0x800B0109,
"The certificate root is not trusted.");
certificateErrors->Add(0x800B010C,
"The certificate has been revoked.");
certificateErrors->Add(0x800B010F,
"The name in the certificate does not not match "
"the host name requested by the client.");
certificateErrors->Add(0x800B0111,
"The certificate was explicitly marked "
"as untrusted by the user.");
certificateErrors->Add(0x800B0112,
"A certification chain processed correctly, "
"but one of the CA certificates is not trusted.");
certificateErrors->Add(0x800B0113,
"The certificate has an invalid policy.");
certificateErrors->Add(0x800B0114,
"The certificate name is either not "
"in the permitted list or is explicitly excluded.");
certificateErrors->Add(0x80092012,
"The revocation function was unable to check "
"revocation for the certificate.");
certificateErrors->Add(0x80090327,
"An unknown error occurred while "
"processing the certificate.");
certificateErrors->Add(0x80096001,
"A system-level error occurred "
"while verifying trust.");
certificateErrors->Add(0x80096002,
"The certificate for the signer of the message "
"is invalid or not found.");
certificateErrors->Add(0x80096003,
"One of the counter signatures was invalid.");
certificateErrors->Add(0x80096004,
"The signature of the certificate "
"cannot be verified.");
certificateErrors->Add(0x80096005,
"The time stamp signature or certificate "
"could not be verified or is malformed.");
certificateErrors->Add(0x80096010,
"The digital signature of the object "
"was not verified.");
certificateErrors->Add(0x80096019,
"The basic constraint extension of a certificate "
"has not been observed.");
}
static String^ CertificateErrorDescription(UInt32 problem)
{
// Initialize the error message dictionary
// if it is not yet available.
if (certificateErrors->Count == 0)
{
InitializeCertificateErrors();
}
String^ description = safe_cast<String^>(
certificateErrors[problem]);
if (description == nullptr)
{
description = String::Format(
CultureInfo::CurrentCulture,
"Unknown certificate error - 0x{0:x8}",
problem);
}
return description;
}
public:
// The following method is invoked
// by the CertificateValidationDelegate.
static bool ValidateServerCertificate(
Object^ sender,
X509Certificate^ certificate,
X509Chain^ chain,
SslPolicyErrors sslPolicyErrors)
{
Console::WriteLine("Validating the server certificate.");
if (sslPolicyErrors == SslPolicyErrors::None)
return true;
Console::WriteLine("Certificate error: {0}", sslPolicyErrors);
// Do not allow this client to communicate with unauthenticated servers.
return false;
}
static void RunClient(String^ machineName, String^ serverName)
{
// Create a TCP/IP client socket.
// machineName is the host running the server application.
TcpClient^ client = gcnew TcpClient(machineName, 8080);
Console::WriteLine("Client connected.");
// Create an SSL stream that will close
// the client's stream.
SslStream^ sslStream = gcnew SslStream(
client->GetStream(), false,
gcnew RemoteCertificateValidationCallback(ValidateServerCertificate),
nullptr);
// The server name must match the name
// on the server certificate.
try
{
sslStream->AuthenticateAsClient(serverName);
}
catch (AuthenticationException^ ex)
{
Console::WriteLine("Exception: {0}", ex->Message);
if (ex->InnerException != nullptr)
{
Console::WriteLine("Inner exception: {0}",
ex->InnerException->Message);
}
Console::WriteLine("Authentication failed - "
"closing the connection.");
sslStream->Close();
client->Close();
return;
}
// Encode a test message into a byte array.
// Signal the end of the message using the "<EOF>".
array<Byte>^ messsage = Encoding::UTF8->GetBytes(
"Hello from the client.<EOF>");
// Send hello message to the server.
sslStream->Write(messsage);
sslStream->Flush();
// Read message from the server.
String^ serverMessage = ReadMessage(sslStream);
Console::WriteLine("Server says: {0}", serverMessage);
// Close the client connection.
sslStream->Close();
client->Close();
Console::WriteLine("Client closed.");
}
private:
static String^ ReadMessage(SslStream^ sslStream)
{
// Read the message sent by the server.
// The end of the message is signaled using the
// "<EOF>" marker.
array<Byte>^ buffer = gcnew array<Byte>(2048);
StringBuilder^ messageData = gcnew StringBuilder;
// Use Decoder class to convert from bytes to UTF8
// in case a character spans two buffers.
Encoding^ u8 = Encoding::UTF8;
Decoder^ decoder = u8->GetDecoder();
int bytes = -1;
do
{
bytes = sslStream->Read(buffer, 0, buffer->Length);
array<__wchar_t>^ chars = gcnew array<__wchar_t>(
decoder->GetCharCount(buffer, 0, bytes));
decoder->GetChars(buffer, 0, bytes, chars, 0);
messageData->Append(chars);
// Check for EOF.
if (messageData->ToString()->IndexOf("<EOF>") != -1)
{
break;
}
}
while (bytes != 0);
return messageData->ToString();
}
};
}
int main()
{
array<String^>^ args = Environment::GetCommandLineArgs();
String^ serverCertificateName = nullptr;
String^ machineName = nullptr;
if (args == nullptr || args->Length < 2)
{
Console::WriteLine("To start the client specify:");
Console::WriteLine("clientSync machineName [serverName]");
return 1;
}
// User can specify the machine name and server name.
// Server name must match the name on
// the server's certificate.
machineName = args[1];
if (args->Length < 3)
{
serverCertificateName = machineName;
}
else
{
serverCertificateName = args[2];
};
NlsClientSync::SslTcpClient::RunClient(machineName,
serverCertificateName);
return 0;
}
using System;
using System.Collections;
using System.Net;
using System.Net.Security;
using System.Net.Sockets;
using System.Security.Authentication;
using System.Text;
using System.Security.Cryptography.X509Certificates;
using System.IO;
namespace Examples.System.Net
{
public class SslTcpClient
{
private static Hashtable certificateErrors = new Hashtable();
// The following method is invoked by the RemoteCertificateValidationDelegate.
public static bool ValidateServerCertificate(
object sender,
X509Certificate certificate,
X509Chain chain,
SslPolicyErrors sslPolicyErrors)
{
if (sslPolicyErrors == SslPolicyErrors.None)
return true;
Console.WriteLine("Certificate error: {0}", sslPolicyErrors);
// Do not allow this client to communicate with unauthenticated servers.
return false;
}
public static void RunClient(string machineName, string serverName)
{
// Create a TCP/IP client socket.
// machineName is the host running the server application.
TcpClient client = new TcpClient(machineName,443);
Console.WriteLine("Client connected.");
// Create an SSL stream that will close the client's stream.
SslStream sslStream = new SslStream(
client.GetStream(),
false,
new RemoteCertificateValidationCallback (ValidateServerCertificate),
null
);
// The server name must match the name on the server certificate.
try
{
sslStream.AuthenticateAsClient(serverName);
}
catch (AuthenticationException e)
{
Console.WriteLine("Exception: {0}", e.Message);
if (e.InnerException != null)
{
Console.WriteLine("Inner exception: {0}", e.InnerException.Message);
}
Console.WriteLine ("Authentication failed - closing the connection.");
client.Close();
return;
}
// Encode a test message into a byte array.
// Signal the end of the message using the "<EOF>".
byte[] messsage = Encoding.UTF8.GetBytes("Hello from the client.<EOF>");
// Send hello message to the server.
sslStream.Write(messsage);
sslStream.Flush();
// Read message from the server.
string serverMessage = ReadMessage(sslStream);
Console.WriteLine("Server says: {0}", serverMessage);
// Close the client connection.
client.Close();
Console.WriteLine("Client closed.");
}
static string ReadMessage(SslStream sslStream)
{
// Read the message sent by the server.
// The end of the message is signaled using the
// "<EOF>" marker.
byte [] buffer = new byte[2048];
StringBuilder messageData = new StringBuilder();
int bytes = -1;
do
{
bytes = sslStream.Read(buffer, 0, buffer.Length);
// Use Decoder class to convert from bytes to UTF8
// in case a character spans two buffers.
Decoder decoder = Encoding.UTF8.GetDecoder();
char[] chars = new char[decoder.GetCharCount(buffer,0,bytes)];
decoder.GetChars(buffer, 0, bytes, chars,0);
messageData.Append (chars);
// Check for EOF.
if (messageData.ToString().IndexOf("<EOF>") != -1)
{
break;
}
} while (bytes != 0);
return messageData.ToString();
}
private static void DisplayUsage()
{
Console.WriteLine("To start the client specify:");
Console.WriteLine("clientSync machineName [serverName]");
Environment.Exit(1);
}
public static int Main(string[] args)
{
string serverCertificateName = null;
string machineName = null;
if (args == null ||args.Length <1 )
{
DisplayUsage();
}
// User can specify the machine name and server name.
// Server name must match the name on the server's certificate.
machineName = args[0];
if (args.Length <2 )
{
serverCertificateName = machineName;
}
else
{
serverCertificateName = args[1];
}
SslTcpClient.RunClient (machineName, serverCertificateName);
return 0;
}
}
}
Imports System.Collections
Imports System.Net
Imports System.Net.Security
Imports System.Net.Sockets
Imports System.Security.Authentication
Imports System.Text
Imports System.Security.Cryptography.X509Certificates
Imports System.IO
Namespace Examples.System.Net
Public Class SslTcpClient
' The following method is invoked by the RemoteCertificateValidationDelegate.
Public Shared Function ValidateServerCertificate(
sender As Object,
certificate As X509Certificate,
chain As X509Chain,
sslPolicyErrors As SslPolicyErrors) As Boolean
If sslPolicyErrors = SslPolicyErrors.None Then Return True
Console.WriteLine("Certificate error: {0}", sslPolicyErrors)
' Do not allow this client to communicate with unauthenticated servers.
Return False
End Function
Public Shared Sub RunClient(machineName As String, serverName As String)
' Create a TCP/IP client socket.
' machineName is the host running the server application.
Dim client = New TcpClient(machineName, 443)
Console.WriteLine("Client connected.")
' Create an SSL stream that will close the client's stream.
Dim sslStream = New SslStream(
client.GetStream(), False,
New RemoteCertificateValidationCallback(AddressOf ValidateServerCertificate), Nothing)
' The server name must match the name on the server certificate.
Try
sslStream.AuthenticateAsClient(serverName)
Catch e As AuthenticationException
Console.WriteLine("Exception: {0}", e.Message)
If e.InnerException IsNot Nothing Then
Console.WriteLine("Inner exception: {0}", e.InnerException.Message)
End If
Console.WriteLine("Authentication failed - closing the connection.")
client.Close()
Return
End Try
' Encode a test message into a byte array.
' Signal the end of the message using the "<EOF>".
Dim messsage As Byte() = Encoding.UTF8.GetBytes("Hello from the client.<EOF>")
' Send hello message to the server.
sslStream.Write(messsage)
sslStream.Flush()
' Read message from the server.
Dim serverMessage = ReadMessage(sslStream)
Console.WriteLine("Server says: {0}", serverMessage)
' Close the client connection
client.Close()
Console.WriteLine("Client closed.")
End Sub
Private Shared Function ReadMessage(sslStream As SslStream) As String
' Read the message sent by the server.
' The end of the message is signaled using the "<EOF>" marker.
Dim buffer = New Byte(2048) {}
Dim messageData = New StringBuilder()
Dim bytes As Integer
Do
bytes = sslStream.Read(buffer, 0, buffer.Length)
' Use Decoder class to convert from bytes to UTF8
' in case a character spans two buffers.
Dim decoder As Decoder = Encoding.UTF8.GetDecoder()
Dim chars = New Char(decoder.GetCharCount(buffer, 0, bytes) - 1) {}
decoder.GetChars(buffer, 0, bytes, chars, 0)
messageData.Append(chars)
' Check for EOF.
If messageData.ToString().IndexOf("<EOF>") <> -1 Then Exit Do
Loop While bytes <> 0
Return messageData.ToString()
End Function
Private Shared Sub DisplayUsage()
Console.WriteLine("To start the client specify:")
Console.WriteLine("clientSync machineName [serverName]")
Environment.[Exit](1)
End Sub
Public Shared Function Main(args As String()) As Integer
Dim serverCertificateName As String
Dim machineName As String
If args Is Nothing OrElse args.Length < 1 Then
DisplayUsage()
End If
' User can specify the machine name and server name.
' Server name must match the name on the server's certificate.
machineName = args(0)
If args.Length < 2 Then
serverCertificateName = machineName
Else
serverCertificateName = args(1)
End If
SslTcpClient.RunClient(machineName, serverCertificateName)
Return 0
End Function
End Class
End Namespace
Comentarios
Los protocolos SSL ayudan a proporcionar confidencialidad e integridad para comprobar los mensajes transmitidos mediante .SslStream Se debe usar una conexión SSL, como la proporcionada por SslStream, al comunicar información confidencial entre un cliente y un servidor. El uso de un SslStream elemento ayuda a evitar que cualquier persona lea y manipule la información mientras está en tránsito en la red.
Una SslStream instancia transmite datos mediante una secuencia que se proporciona al crear .SslStream Al proporcionar esta secuencia subyacente, tiene la opción de especificar si el cierre SslStream también cierra la secuencia subyacente. Normalmente, la SslStream clase se usa con las TcpClient clases y TcpListener . El GetStream método proporciona un NetworkStream adecuado para su uso con la SslStream clase .
Después de crear un SslStream, el servidor y, opcionalmente, el cliente debe autenticarse. El servidor debe proporcionar un certificado X509 que establezca la prueba de su identidad y pueda solicitar que el cliente también lo haga. La autenticación debe realizarse antes de transmitir información mediante .SslStream Los clientes inician la autenticación mediante los métodos sincrónicos AuthenticateAsClient , que bloquean hasta que se completa la autenticación o los métodos asincrónicos BeginAuthenticateAsClient , que no bloquean la espera de que se complete la autenticación. Los servidores inician la autenticación mediante los métodos sincrónicos AuthenticateAsServer o asincrónicos BeginAuthenticateAsServer . Tanto el cliente como el servidor deben iniciar la autenticación.
El proveedor de canales del proveedor de soporte técnico de seguridad (SSPI) controla la autenticación. El cliente tiene la oportunidad de controlar la validación del certificado del servidor especificando un RemoteCertificateValidationCallback delegado al crear un SslStream. El servidor también puede controlar la validación proporcionando un RemoteCertificateValidationCallback delegado. El método al que hace referencia el delegado incluye el certificado de la entidad remota y cualquier error que se encuentre SSPI al validar el certificado. Tenga en cuenta que si el servidor especifica un delegado, se invoca el método del delegado independientemente de si el servidor solicitó autenticación de cliente. Si el servidor no solicitó la autenticación de cliente, el método delegado del servidor recibe un certificado NULL y una matriz vacía de errores de certificado.
Si el servidor requiere autenticación de cliente, el cliente debe especificar uno o varios certificados para la autenticación. Si el cliente tiene más de un certificado, el cliente puede proporcionar un LocalCertificateSelectionCallback delegado para seleccionar el certificado correcto para el servidor. Los certificados del cliente deben encontrarse en el almacén de certificados "My" del usuario actual. No se admite la autenticación de cliente a través de certificados para el Ssl2 protocolo (versión 2) de SSL.
Si se produce un error en la autenticación, recibirá un AuthenticationExceptiony SslStream ya no se puede usar. Debe cerrar este objeto y quitar todas las referencias a él para que el recolector de elementos no utilizados pueda recopilarla.
Cuando el proceso de autenticación, también conocido como protocolo de enlace SSL, se realiza correctamente, se establece la identidad del servidor (y, opcionalmente, el cliente) y el cliente y SslStream el servidor los puede usar para intercambiar mensajes. Antes de enviar o recibir información, el cliente y el servidor deben comprobar los servicios y niveles de seguridad proporcionados por para SslStream determinar si el protocolo, los algoritmos y las fortalezas seleccionados cumplen sus requisitos de integridad y confidencialidad. Si la configuración actual no es suficiente, se debe cerrar la secuencia. Puede comprobar los servicios de seguridad proporcionados por mediante SslStream las IsEncrypted propiedades y IsSigned . En la tabla siguiente se muestran los elementos que notifican la configuración criptográfica usada para la autenticación, el cifrado y la firma de datos.
| Elemento | Miembros |
|---|---|
| Protocolo de seguridad que se usa para autenticar el servidor y, opcionalmente, el cliente. | La SslProtocol propiedad y la enumeración asociada SslProtocols . |
| Algoritmo de intercambio de claves. | La KeyExchangeAlgorithm propiedad y la enumeración asociada ExchangeAlgorithmType . |
| Algoritmo de integridad del mensaje. | La HashAlgorithm propiedad y la enumeración asociada HashAlgorithmType . |
| Algoritmo de confidencialidad del mensaje. | La CipherAlgorithm propiedad y la enumeración asociada CipherAlgorithmType . |
| Puntos fuertes de los algoritmos seleccionados. | Las KeyExchangeStrengthpropiedades , HashStrengthy CipherStrength . |
Después de una autenticación correcta, puede enviar datos mediante los métodos sincrónicos Write o asincrónicos BeginWrite . Puede recibir datos mediante los métodos sincrónicos Read o asincrónicos BeginRead .
Si especificó que SslStream la secuencia subyacente debe dejarse abierta, es responsable de cerrar esa secuencia cuando haya terminado de usarla.
Nota
Si la aplicación que crea el SslStream objeto se ejecuta con las credenciales de un usuario Normal, la aplicación no podrá acceder a los certificados instalados en el almacén de máquinas locales a menos que se haya concedido explícitamente permiso al usuario para hacerlo.
SslStream supone que un tiempo de espera junto con cualquier otro IOException cuando se inicia una desde la secuencia interna se tratará como fatal por su autor de la llamada. La reutilización de una SslStream instancia después de un tiempo de espera devolverá elementos no utilizados. Una aplicación debe Close producir SslStream y producir una excepción en estos casos.
El .NET Framework 4.6 incluye una nueva característica de seguridad que bloquea algoritmos de cifrado y hash no seguros para las conexiones. Las aplicaciones que usan TLS/SSL a través de API como HttpClient, HttpWebRequest, FTPClient, SmtpClient, SslStream, etc. y el destino .NET Framework 4.6 obtienen el comportamiento más seguro de forma predeterminada.
Es posible que los desarrolladores quieran dejar de participar en este comportamiento para mantener la interoperabilidad con sus servicios SSL3 existentes O servicios TLS w/ RC4. En este artículo se explica cómo modificar el código para que el nuevo comportamiento esté deshabilitado.
El .NET Framework 4.7 agrega nuevas sobrecargas para los métodos que autentican SslStreams que no especifican una versión de TLS, sino que usan la versión tls definida como valor predeterminado del sistema en SCHANNEL. Use estos métodos en la aplicación como una manera de poder modificar posteriormente los valores predeterminados a medida que cambia el procedimiento recomendado de la versión de TLS a lo largo del tiempo, sin necesidad de volver a generar e implementar la aplicación.
Consulte también Procedimientos recomendados de seguridad de la capa de transporte (TLS) con el .NET Framework.
Constructores
| SslStream(Stream) |
Inicializa una nueva instancia de la clase SslStream utilizando la clase Stream especificada. |
| SslStream(Stream, Boolean) |
Inicializa una nueva instancia de la clase SslStream utilizando el objeto Stream especificado y el comportamiento de cierre de secuencias. |
| SslStream(Stream, Boolean, RemoteCertificateValidationCallback) |
Inicializa una nueva instancia de la clase SslStream utilizando el objeto Stream, el comportamiento de cierre de secuencias y el delegado de validación de certificados especificados. |
| SslStream(Stream, Boolean, RemoteCertificateValidationCallback, LocalCertificateSelectionCallback) |
Inicializa una nueva instancia de la clase SslStream utilizando el objeto Stream, el delegado de validación de certificados y el delegado de selección de certificados especificados. |
| SslStream(Stream, Boolean, RemoteCertificateValidationCallback, LocalCertificateSelectionCallback, EncryptionPolicy) |
Inicializa una nueva instancia de la clase SslStream utilizando la clase Stream especificada. |
Propiedades
| CanRead |
Obtiene un valor Boolean que indica si se puede leer la secuencia subyacente. |
| CanSeek |
Obtiene un valor Boolean que indica si se puede buscar en la secuencia subyacente. |
| CanTimeout |
Obtiene un valor Boolean que indica si la secuencia subyacente admite tiempos de espera. |
| CanWrite |
Obtiene un valor Boolean que indica si se puede escribir en la secuencia subyacente. |
| CheckCertRevocationStatus |
Obtiene un valor Boolean que indica si la lista de revocación de certificados se coteja durante el proceso de validación de certificados. |
| CipherAlgorithm |
Obtiene un valor que identifica el algoritmo de cifrado masivo utilizado por esta secuencia SslStream. |
| CipherStrength |
Obtiene un valor que identifica la intensidad del algoritmo de cifrado utilizado por esta secuencia SslStream. |
| HashAlgorithm |
Obtiene el algoritmo utilizado para generar códigos de autenticación de mensajes (MAC). |
| HashStrength |
Obtiene un valor que identifica la intensidad del algoritmo de hash utilizado por esta instancia. |
| InnerStream |
Obtiene la secuencia utilizado por esta AuthenticatedStream para enviar y recibir datos. (Heredado de AuthenticatedStream) |
| IsAuthenticated |
Obtiene un valor Boolean que indica si la autenticación se realizó correctamente. |
| IsEncrypted |
Obtiene un valor Boolean que indica si esta clase SslStream utiliza el cifrado de datos. |
| IsMutuallyAuthenticated |
Obtiene un valor de Boolean que indica si se autenticaron tanto el cliente como el servidor. |
| IsServer |
Obtiene un valor Boolean que indica si el lado local de la conexión utilizada por SslStream se autenticó como el servidor. |
| IsSigned |
Obtiene un valor Boolean que indica si los datos enviados utilizando esta secuencia tienen signo. |
| KeyExchangeAlgorithm |
Obtiene el algoritmo de intercambio de claves utilizado por esta SslStream. |
| KeyExchangeStrength |
Obtiene un valor que identifica la intensidad del algoritmo de intercambio de claves utilizado por esta instancia. |
| LeaveInnerStreamOpen |
Obtiene si la secuencia utilizada por esta AuthenticatedStream para enviar y recibir datos se ha dejado abierta. (Heredado de AuthenticatedStream) |
| Length |
Obtiene la longitud de la secuencia subyacente. |
| LocalCertificate |
Obtiene el certificado utilizado para autenticar el extremo local. |
| NegotiatedApplicationProtocol |
Protocolo de aplicación negociado en el protocolo de enlace TLS. |
| NegotiatedCipherSuite |
Obtiene el conjunto cifrado que se negoció para esta conexión. |
| Position |
Obtiene o establece la posición actual en la secuencia subyacente. |
| ReadTimeout |
Obtiene o establece el período de tiempo en milisegundo en el que una operación de lectura se bloquea en espera de los datos. |
| RemoteCertificate |
Obtiene el certificado utilizado para autenticar el extremo remoto. |
| SslProtocol |
Obtiene un valor que indica el protocolo de seguridad utilizado para autenticar esta conexión. |
| TargetHostName |
Obtiene el nombre del servidor al que el cliente intenta conectarse. Ese nombre se usa para la validación de certificados de servidor. Puede ser un nombre DNS o una dirección IP. |
| TransportContext |
Obtiene el objeto TransportContext utilizado para la autenticación utilizando la protección extendida. |
| WriteTimeout |
Obtiene o establece el período de tiempo que se bloquea una operación de escritura mientras espera datos. |
Métodos
| AuthenticateAsClient(SslClientAuthenticationOptions) |
Lo llaman los clientes para autenticar el servidor y, de forma opcional, el cliente en una conexión cliente-servidor. |
| AuthenticateAsClient(String) |
Lo llaman los clientes para autenticar el servidor y, de forma opcional, el cliente en una conexión cliente-servidor. |
| AuthenticateAsClient(String, X509CertificateCollection, Boolean) |
Lo llaman los clientes para autenticar el servidor y, de forma opcional, el cliente en una conexión cliente-servidor. El proceso de autenticación usa la colección de certificados especificada y el protocolo SSL predeterminado del sistema. |
| AuthenticateAsClient(String, X509CertificateCollection, SslProtocols, Boolean) |
Lo llaman los clientes para autenticar el servidor y, de forma opcional, el cliente en una conexión cliente-servidor. El proceso de autenticación utiliza la colección de certificados especificada y el protocolo SSL. |
| AuthenticateAsClientAsync(SslClientAuthenticationOptions, CancellationToken) |
Lo llaman los clientes para autenticar el servidor y, de forma opcional, el cliente en una conexión cliente-servidor como operación asincrónica. El proceso de autenticación usa información especificada en el contenedor de propiedades |
| AuthenticateAsClientAsync(String) |
Lo llaman los clientes para autenticar el servidor y, de forma opcional, el cliente en una conexión cliente-servidor como operación asincrónica. |
| AuthenticateAsClientAsync(String, X509CertificateCollection, Boolean) |
Lo llaman los clientes para autenticar el servidor y, de forma opcional, el cliente en una conexión cliente-servidor como operación asincrónica. El proceso de autenticación usa la colección de certificados especificada y el protocolo SSL predeterminado del sistema. |
| AuthenticateAsClientAsync(String, X509CertificateCollection, SslProtocols, Boolean) |
Lo llaman los clientes para autenticar el servidor y, de forma opcional, el cliente en una conexión cliente-servidor como operación asincrónica. El proceso de autenticación utiliza la colección de certificados especificada y el protocolo SSL. |
| AuthenticateAsServer(SslServerAuthenticationOptions) |
Lo llaman los servidores para autenticar el servidor, y opcionalmente el cliente, en una conexión cliente-servidor utilizando el certificado especificado. |
| AuthenticateAsServer(X509Certificate) |
Lo llaman los servidores para autenticar el servidor, y opcionalmente el cliente, en una conexión cliente-servidor utilizando el certificado especificado. |
| AuthenticateAsServer(X509Certificate, Boolean, Boolean) |
Los llaman los servidores para autenticar el servidor y, opcionalmente, el cliente en una conexión cliente/servidor mediante los certificados y requisitos especificados, además del protocolo de seguridad predeterminado del sistema. |
| AuthenticateAsServer(X509Certificate, Boolean, SslProtocols, Boolean) |
Los llaman los servidores para autenticar el servidor y, opcionalmente, el cliente en una conexión cliente/servidor mediante los certificados, los requisitos y el protocolo de seguridad. |
| AuthenticateAsServerAsync(ServerOptionsSelectionCallback, Object, CancellationToken) |
Lo llaman los servidores con el fin de autenticar el servidor, y opcionalmente el cliente, en una conexión cliente-servidor como una operación asincrónica. El proceso de autenticación usa la información devuelta por |
| AuthenticateAsServerAsync(SslServerAuthenticationOptions, CancellationToken) |
Lo llaman los servidores con el fin de autenticar el servidor, y opcionalmente el cliente, en una conexión cliente-servidor como una operación asincrónica. El proceso de autenticación usa información especificada en el contenedor de propiedades |
| AuthenticateAsServerAsync(X509Certificate) |
Lo llaman los servidores para autenticar el servidor, y opcionalmente el cliente, en una conexión cliente-servidor utilizando el certificado especificado como una operación asincrónica. |
| AuthenticateAsServerAsync(X509Certificate, Boolean, Boolean) |
Los llaman los servidores para autenticar el servidor y, opcionalmente, el cliente en una conexión cliente/servidor mediante los certificados, los requisitos y el protocolo de seguridad especificados como una operación asincrónica. |
| AuthenticateAsServerAsync(X509Certificate, Boolean, SslProtocols, Boolean) |
Los llaman los servidores para autenticar el servidor y, opcionalmente, el cliente en una conexión cliente/servidor mediante los certificados, los requisitos y el protocolo de seguridad especificados como una operación asincrónica. |
| BeginAuthenticateAsClient(String, AsyncCallback, Object) |
Lo llaman clientes para empezar una operación asincrónica con el fin de autenticar el servidor y opcionalmente el cliente. |
| BeginAuthenticateAsClient(String, X509CertificateCollection, Boolean, AsyncCallback, Object) |
Los llaman los servidores para comenzar una operación asincrónica con el fin de autenticar el servidor y, opcionalmente, el cliente mediante los certificados especificados y el protocolo de seguridad predeterminado del sistema. |
| BeginAuthenticateAsClient(String, X509CertificateCollection, SslProtocols, Boolean, AsyncCallback, Object) |
Lo llaman los clientes para empezar una operación asincrónica con el fin de autenticar el servidor y, opcionalmente el cliente, mediante los certificados, los requisitos y el protocolo de seguridad especificados. |
| BeginAuthenticateAsServer(X509Certificate, AsyncCallback, Object) |
Lo llaman los servidores para comenzar una operación asincrónica con el fin de autenticar el cliente, y opcionalmente el servidor, en una conexión cliente-servidor. |
| BeginAuthenticateAsServer(X509Certificate, Boolean, Boolean, AsyncCallback, Object) |
Los llaman los servidores para comenzar una operación asincrónica con el fin de autenticar el servidor y, opcionalmente, el cliente mediante los certificados y requisitos especificados, además del protocolo de seguridad predeterminado del sistema. |
| BeginAuthenticateAsServer(X509Certificate, Boolean, SslProtocols, Boolean, AsyncCallback, Object) |
Los llaman los servidores para comenzar una operación asincrónica con el fin de autenticar el servidor y, opcionalmente, el cliente mediante los certificados, requisitos y protocolo de seguridad especificados. |
| BeginRead(Byte[], Int32, Int32, AsyncCallback, Object) |
Inicia una operación de lectura asincrónica que lee los datos de la secuencia y los almacena en la matriz especificada. |
| BeginRead(Byte[], Int32, Int32, AsyncCallback, Object) |
Comienza una operación de lectura asincrónica. (Considere usar ReadAsync(Byte[], Int32, Int32) en su lugar). (Heredado de Stream) |
| BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object) |
Inicia una operación de escritura asincrónica que escribe Bytes desde el búfer especificado en la secuencia. |
| BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object) |
Comienza una operación de escritura asincrónica. (Considere usar WriteAsync(Byte[], Int32, Int32) en su lugar). (Heredado de Stream) |
| Close() |
Cierra la secuencia actual y libera todos los recursos (como sockets e identificadores de archivo) asociados a esta. En lugar de llamar a este método, asegúrese de que la secuencia se desecha correctamente. (Heredado de Stream) |
| CopyTo(Stream) |
Lee los bytes de la secuencia actual y los escribe en otra secuencia de destino. Ambas posiciones de secuencias están avanzadas por el número de bytes copiados. (Heredado de Stream) |
| CopyTo(Stream, Int32) |
Lee todos los bytes de la secuencia actual y los escribe en otra secuencia, usando el tamaño de búfer especificado. Ambas posiciones de secuencias están avanzadas por el número de bytes copiados. (Heredado de Stream) |
| CopyToAsync(Stream) |
Lee asincrónicamente los bytes de la secuencia actual y los escribe en otra secuencia. Ambas posiciones de secuencias están avanzadas por el número de bytes copiados. (Heredado de Stream) |
| CopyToAsync(Stream, CancellationToken) |
Lee de forma asincrónica los bytes de la secuencia actual y los escribe en otra secuencia mediante un token de cancelación especificado. Ambas posiciones de secuencias están avanzadas por el número de bytes copiados. (Heredado de Stream) |
| CopyToAsync(Stream, Int32) |
Lee asincrónicamente los bytes de la secuencia actual y los escribe en otra secuencia, usando el tamaño de búfer especificado. Ambas posiciones de secuencias están avanzadas por el número de bytes copiados. (Heredado de Stream) |
| CopyToAsync(Stream, Int32, CancellationToken) |
Lee asincrónicamente los bytes de la secuencia actual y los escribe en otra secuencia, utilizando el tamaño de búfer y el token de cancelación especificados. Ambas posiciones de secuencias están avanzadas por el número de bytes copiados. (Heredado de Stream) |
| CreateObjRef(Type) |
Crea un objeto que contiene toda la información relevante necesaria para generar un proxy utilizado para comunicarse con un objeto remoto. (Heredado de MarshalByRefObject) |
| CreateWaitHandle() |
Obsoleto.
Obsoleto.
Obsoleto.
Asigna un objeto WaitHandle. (Heredado de Stream) |
| Dispose() |
Libera todos los recursos que usa Stream. (Heredado de Stream) |
| Dispose(Boolean) |
Libera los recursos no administrados que usa SslStream y, de forma opcional, libera los recursos administrados. |
| Dispose(Boolean) |
Libera los recursos no administrados que usa AuthenticatedStream y, de forma opcional, libera los recursos administrados. (Heredado de AuthenticatedStream) |
| DisposeAsync() |
Libera de forma asincrónica los recursos administrados y no administrados que usa SslStream. |
| DisposeAsync() |
Libera de forma asincrónica los recursos administrados y no administrados que usa AuthenticatedStream. (Heredado de AuthenticatedStream) |
| EndAuthenticateAsClient(IAsyncResult) |
Finaliza una operación de autenticación de servidor asincrónica iniciada con una llamada previa a BeginAuthenticateAsClient. |
| EndAuthenticateAsServer(IAsyncResult) |
Finaliza una operación de autenticación de cliente asincrónica iniciada con una llamada previa a BeginAuthenticateAsClient. |
| EndRead(IAsyncResult) |
Finaliza una operación de lectura asincrónica iniciada con una llamada previa a BeginRead(Byte[], Int32, Int32, AsyncCallback, Object). |
| EndRead(IAsyncResult) |
Espera a que se complete la lectura asincrónica que se encuentra pendiente. (Considere usar ReadAsync(Byte[], Int32, Int32) en su lugar). (Heredado de Stream) |
| EndWrite(IAsyncResult) |
Finaliza una operación de escritura asincrónica iniciada con una llamada previa a BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object). |
| EndWrite(IAsyncResult) |
Finaliza una operación de escritura asincrónica. (Considere usar WriteAsync(Byte[], Int32, Int32) en su lugar). (Heredado de Stream) |
| Equals(Object) |
Determina si el objeto especificado es igual que el objeto actual. (Heredado de Object) |
| Finalize() |
Libera todos los recursos que usa SslStream. |
| Flush() |
Provoca la escritura de los datos almacenados en el búfer del dispositivo subyacente. |
| FlushAsync() |
Borra asincrónicamente todos los búferes de esta secuencia y hace que los datos almacenados en búfer se escriban en el dispositivo subyacente. (Heredado de Stream) |
| FlushAsync(CancellationToken) |
Escribe de manera asincrónica cualquier dato almacenado en búfer en el dispositivo subyacente. |
| FlushAsync(CancellationToken) |
Borra asincrónicamente todos los búferes de esta secuencia, y hace que todos los datos almacenados en búfer se escriban en el dispositivo subyacente y supervisa las solicitudes de cancelación. (Heredado de Stream) |
| GetHashCode() |
Sirve como la función hash predeterminada. (Heredado de Object) |
| GetLifetimeService() |
Obsoleto.
Recupera el objeto de servicio de duración actual que controla la directiva de duración de esta instancia. (Heredado de MarshalByRefObject) |
| GetType() |
Obtiene el Type de la instancia actual. (Heredado de Object) |
| InitializeLifetimeService() |
Obsoleto.
Obtiene un objeto de servicio de duración para controlar la directiva de duración de esta instancia. (Heredado de MarshalByRefObject) |
| MemberwiseClone() |
Crea una copia superficial del Object actual. (Heredado de Object) |
| MemberwiseClone(Boolean) |
Crea una copia superficial del objeto MarshalByRefObject actual. (Heredado de MarshalByRefObject) |
| NegotiateClientCertificateAsync(CancellationToken) |
Negocia el certificado de cliente en la conexión autenticada. |
| ObjectInvariant() |
Obsoleto.
Proporciona compatibilidad con una clase Contract. (Heredado de Stream) |
| Read(Byte[], Int32, Int32) |
Lee datos de esta secuencia y los almacena en la matriz especificada. |
| Read(Span<Byte>) |
Cuando se reemplaza en una clase derivada, se lee una secuencia de bytes en la secuencia actual y se hace avanzar la posición dentro de la secuencia el número de bytes leídos. (Heredado de Stream) |
| ReadAsync(Byte[], Int32, Int32) |
Lee asincrónicamente una secuencia de bytes de la secuencia actual y avanza la posición en esta secuencia según el número de bytes leídos. (Heredado de Stream) |
| ReadAsync(Byte[], Int32, Int32, CancellationToken) |
Lee de forma asincrónica los datos de esta secuencia y los almacena en el rango especificado de una matriz de bytes. |
| ReadAsync(Byte[], Int32, Int32, CancellationToken) |
Lee de forma asincrónica una secuencia de bytes en la secuencia actual, se hace avanzar la posición dentro de la secuencia el número de bytes leídos y controla las solicitudes de cancelación. (Heredado de Stream) |
| ReadAsync(Memory<Byte>, CancellationToken) |
Lee de forma asincrónica los datos de esta secuencia y los almacena en el rango de memoria especificado. |
| ReadAsync(Memory<Byte>, CancellationToken) |
Lee de forma asincrónica una secuencia de bytes en la secuencia actual, se hace avanzar la posición dentro de la secuencia el número de bytes leídos y controla las solicitudes de cancelación. (Heredado de Stream) |
| ReadAtLeast(Span<Byte>, Int32, Boolean) |
Lee al menos un número mínimo de bytes de la secuencia actual y avanza la posición dentro de la secuencia por el número de bytes leídos. (Heredado de Stream) |
| ReadAtLeastAsync(Memory<Byte>, Int32, Boolean, CancellationToken) |
Lee de forma asincrónica al menos un número mínimo de bytes de la secuencia actual, avanza la posición dentro de la secuencia por el número de bytes leídos y supervisa las solicitudes de cancelación. (Heredado de Stream) |
| ReadByte() |
Lee un byte de SslStream y hace avanzar la posición de la secuencia en un byte, o devuelve -1 si está al final de la secuencia. |
| ReadByte() |
Lee un byte de la secuencia y hace avanzar la posición de la secuencia en un byte, o devuelve -1 si está al final de la secuencia. (Heredado de Stream) |
| ReadExactly(Byte[], Int32, Int32) |
|
| ReadExactly(Span<Byte>) |
Lee bytes de la secuencia actual y avanza la posición dentro de la secuencia hasta |
| ReadExactlyAsync(Byte[], Int32, Int32, CancellationToken) |
Lee |
| ReadExactlyAsync(Memory<Byte>, CancellationToken) |
Lee de forma asincrónica los bytes de la secuencia actual, avanza la posición dentro de la secuencia hasta |
| Seek(Int64, SeekOrigin) |
Produce una excepción NotSupportedException. |
| SetLength(Int64) |
Establece la longitud de la secuencia subyacente. |
| ShutdownAsync() |
Cierra esta clase SslStream. |
| ToString() |
Devuelve una cadena que representa el objeto actual. (Heredado de Object) |
| Write(Byte[]) |
Escribe los datos especificados en esta secuencia. |
| Write(Byte[], Int32, Int32) |
Escriba el número especificado de Bytes en la secuencia subyacente mediante el búfer y el desplazamiento especificados. |
| Write(ReadOnlySpan<Byte>) |
Cuando se reemplaza en una clase derivada, se escribe una secuencia de bytes en la secuencia actual y se hace avanzar la posición actual dentro de la secuencia el número de bytes escritos. (Heredado de Stream) |
| WriteAsync(Byte[], Int32, Int32) |
Escribe asincrónicamente una secuencia de bytes en la secuencia actual y avanza la posición actual en esta secuencia según el número de bytes escritos. (Heredado de Stream) |
| WriteAsync(Byte[], Int32, Int32, CancellationToken) |
Escribe de forma asincrónica datos en la secuencia subyacente desde el rango especificado de una matriz de bytes. |
| WriteAsync(Byte[], Int32, Int32, CancellationToken) |
Escribe de forma asincrónica una secuencia de bytes en la secuencia actual, se hace avanzar la posición actual dentro de la secuencia el número de bytes escritos y controla las solicitudes de cancelación. (Heredado de Stream) |
| WriteAsync(ReadOnlyMemory<Byte>, CancellationToken) |
Escribe de forma asincrónica datos en la secuencia subyacente desde un rango de memoria de bytes de solo lectura. |
| WriteAsync(ReadOnlyMemory<Byte>, CancellationToken) |
Escribe de forma asincrónica una secuencia de bytes en la secuencia actual, se hace avanzar la posición actual dentro de la secuencia el número de bytes escritos y controla las solicitudes de cancelación. (Heredado de Stream) |
| WriteByte(Byte) |
Escribe un byte a la posición actual en la secuencia y avanza la posición de la secuencia en un byte. (Heredado de Stream) |
Métodos de extensión
| ConfigureAwait(IAsyncDisposable, Boolean) |
Configura la forma en la que se realizan las expresiones await en las tareas devueltas desde un elemento asincrónico descartable. |