public DtlsServer(DatagramTransport datagramTransport, CertificateInfo certificateInfo, DtlsServerProtocol dtlsServerProtocol = null)
{
DatagramTransport = datagramTransport;
this.dtlsServerProtocol = dtlsServerProtocol ?? new DtlsServerProtocol(new Org.BouncyCastle.Security.SecureRandom());
tlsServer = new TlsServerImpl(certificateInfo);
tlsServer.ClientCertificateReceived += TlsServer_ClientCertificateReceived;
}
/// <summary>
/// Start up a session on the server side
/// </summary>
/// <param name="udpChannel">What channel are we on</param>
/// <param name="message">What was the last message we got?</param>
public void Accept(UDPChannel udpChannel, byte[] message)
{
DtlsServerProtocol serverProtocol = new DtlsServerProtocol(new SecureRandom());
DtlsServer server = new DtlsServer(_serverKeys, _userKeys);
server.TlsEventHandler += OnTlsEvent;
#if SUPPORT_TLS_CWT
server.CwtTrustKeySet = CwtTrustKeySet;
#endif
_transport.UDPChannel = udpChannel;
_transport.Receive(message);
// Make sure we do not startup a listing thread as the correct call is always made
// byt the DTLS accept protocol.
_listening = 1;
DtlsTransport dtlsServer = serverProtocol.Accept(server, _transport);
_listening = 0;
_dtlsSession = dtlsServer;
AuthenticationKey = server.AuthenticationKey;
AuthenticationCertificate = server.AuthenticationCertificate;
new Thread(StartListen).Start();
}
internal Server(DtlsTestCase outer, DtlsServerProtocol serverProtocol, DatagramTransport serverTransport, TlsTestServerImpl serverImpl)
{
this.mOuter = outer;
this.mServerProtocol = serverProtocol;
this.mServerTransport = serverTransport;
this.mServerImpl = serverImpl;
}
public void Accept(DtlsServerProtocol serverProtocol, TlsServer server)
{
_dtlsTransport = serverProtocol.Accept(server, _udpTransport);
if (server is IDtlsServerWithConnectionInfo serverWithInfo)
{
var serverInfo = serverWithInfo.GetConnectionInfo();
ConnectionInfo = serverInfo;
}
}
public CoapDtlsServerTransport(CoapDtlsServerEndPoint endPoint, ICoapHandler coapHandler, IDtlsServerFactory tlsServerFactory, ILogger <CoapDtlsServerTransport> logger)
{
_endPoint = endPoint ?? throw new ArgumentNullException(nameof(endPoint));
_coapHandler = coapHandler ?? throw new ArgumentNullException(nameof(coapHandler));
_tlsServerFactory = tlsServerFactory ?? throw new ArgumentNullException(nameof(tlsServerFactory));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
SecureRandom random = new SecureRandom();
_serverProtocol = new DtlsServerProtocol(random);
_sessions = new ConcurrentDictionary <IPEndPoint, CoapDtlsServerClientEndPoint>();
}
public bool DoHandshakeAsServer()
{
logger.LogDebug("DTLS commencing handshake as server.");
if (!handshaking && !handshakeComplete)
{
this.startTime = DateTime.Now;
this.handshaking = true;
SecureRandom secureRandom = new SecureRandom();
DtlsServerProtocol serverProtocol = new DtlsServerProtocol(secureRandom);
try
{
var server = (DtlsSrtpServer)connection;
// Perform the handshake in a non-blocking fashion
Transport = serverProtocol.Accept(server, this);
// Prepare the shared key to be used in RTP streaming
//server.PrepareSrtpSharedSecret();
// Generate encoders for DTLS traffic
if (server.GetSrtpPolicy() != null)
{
srtpDecoder = GenerateRtpDecoder();
srtpEncoder = GenerateRtpEncoder();
srtcpDecoder = GenerateRtcpDecoder();
srtcpEncoder = GenerateRtcpEncoder();
}
// Declare handshake as complete
handshakeComplete = true;
handshakeFailed = false;
handshaking = false;
// Warn listeners handshake completed
//UnityEngine.Debug.Log("DTLS Handshake Completed");
return(true);
}
catch (Exception excp)
{
logger.LogWarning($"DTLS handshake as server failed. {excp.Message}");
// Declare handshake as failed
handshakeComplete = false;
handshakeFailed = true;
handshaking = false;
// Warn listeners handshake completed
//UnityEngine.Debug.Log("DTLS Handshake failed\n"+ e);
}
}
return(false);
}
public DtlsClient Accept()
{
while (true)
{
if (_acceptQueue.TryDequeue(out var udpTransport))
{
var random = new SecureRandom();
var protocol = new DtlsServerProtocol(random);
var server = new TlsServerImpl(ProtocolVersion.DTLSv12);
var dtlsTransport = protocol.Accept(server, udpTransport);
var client = new DtlsClient(_socket, dtlsTransport);
return(client);
}
}
}
public void TestClientServer()
{
SecureRandom secureRandom = new SecureRandom();
DtlsClientProtocol clientProtocol = new DtlsClientProtocol(secureRandom);
DtlsServerProtocol serverProtocol = new DtlsServerProtocol(secureRandom);
MockDatagramAssociation network = new MockDatagramAssociation(1500);
Server server = new Server(serverProtocol, network.Server);
Thread serverThread = new Thread(new ThreadStart(server.Run));
serverThread.Start();
DatagramTransport clientTransport = network.Client;
clientTransport = new UnreliableDatagramTransport(clientTransport, secureRandom, 0, 0);
clientTransport = new LoggingDatagramTransport(clientTransport, Console.Out);
MockDtlsClient client = new MockDtlsClient(null);
DtlsTransport dtlsClient = clientProtocol.Connect(client, clientTransport);
for (int i = 1; i <= 10; ++i)
{
byte[] data = new byte[i];
Arrays.Fill(data, (byte)i);
dtlsClient.Send(data, 0, data.Length);
}
byte[] buf = new byte[dtlsClient.GetReceiveLimit()];
while (dtlsClient.Receive(buf, 0, buf.Length, 100) >= 0)
{
}
dtlsClient.Close();
server.Shutdown(serverThread);
}
public void TestClientServer()
{
SecureRandom secureRandom = new SecureRandom();
DtlsClientProtocol clientProtocol = new DtlsClientProtocol(secureRandom);
DtlsServerProtocol serverProtocol = new DtlsServerProtocol(secureRandom);
MockDatagramAssociation network = new MockDatagramAssociation(1500);
Server server = new Server(serverProtocol, network.Server);
Thread serverThread = new Thread(new ThreadStart(server.Run));
serverThread.Start();
DatagramTransport clientTransport = network.Client;
clientTransport = new UnreliableDatagramTransport(clientTransport, secureRandom, 0, 0);
clientTransport = new LoggingDatagramTransport(clientTransport, Console.Out);
MockDtlsClient client = new MockDtlsClient(null);
DtlsTransport dtlsClient = clientProtocol.Connect(client, clientTransport);
for (int i = 1; i <= 10; ++i)
{
byte[] data = new byte[i];
Arrays.Fill(data, (byte)i);
dtlsClient.Send(data, 0, data.Length);
}
byte[] buf = new byte[dtlsClient.GetReceiveLimit()];
while (dtlsClient.Receive(buf, 0, buf.Length, 100) >= 0)
{
}
dtlsClient.Close();
server.Shutdown(serverThread);
}
public void RunTest(TlsTestConfig config)
{
CheckDtlsVersion(config.clientMinimumVersion);
CheckDtlsVersion(config.clientOfferVersion);
CheckDtlsVersion(config.serverMaximumVersion);
CheckDtlsVersion(config.serverMinimumVersion);
SecureRandom secureRandom = new SecureRandom();
DtlsClientProtocol clientProtocol = new DtlsClientProtocol(secureRandom);
DtlsServerProtocol serverProtocol = new DtlsServerProtocol(secureRandom);
MockDatagramAssociation network = new MockDatagramAssociation(1500);
TlsTestClientImpl clientImpl = new TlsTestClientImpl(config);
TlsTestServerImpl serverImpl = new TlsTestServerImpl(config);
Server server = new Server(this, serverProtocol, network.Server, serverImpl);
Thread serverThread = new Thread(new ThreadStart(server.Run));
serverThread.Start();
Exception caught = null;
try
{
DatagramTransport clientTransport = network.Client;
if (TlsTestConfig.DEBUG)
{
clientTransport = new LoggingDatagramTransport(clientTransport, Console.Out);
}
DtlsTransport dtlsClient = clientProtocol.Connect(clientImpl, clientTransport);
for (int i = 1; i <= 10; ++i)
{
byte[] data = new byte[i];
Arrays.Fill(data, (byte)i);
dtlsClient.Send(data, 0, data.Length);
}
byte[] buf = new byte[dtlsClient.GetReceiveLimit()];
while (dtlsClient.Receive(buf, 0, buf.Length, 100) >= 0)
{
}
dtlsClient.Close();
}
catch (Exception e)
{
caught = e;
LogException(caught);
}
server.Shutdown(serverThread);
// TODO Add checks that the various streams were closed
Assert.AreEqual(config.expectFatalAlertConnectionEnd, clientImpl.FirstFatalAlertConnectionEnd, "Client fatal alert connection end");
Assert.AreEqual(config.expectFatalAlertConnectionEnd, serverImpl.FirstFatalAlertConnectionEnd, "Server fatal alert connection end");
Assert.AreEqual(config.expectFatalAlertDescription, clientImpl.FirstFatalAlertDescription, "Client fatal alert description");
Assert.AreEqual(config.expectFatalAlertDescription, serverImpl.FirstFatalAlertDescription, "Server fatal alert description");
if (config.expectFatalAlertConnectionEnd == -1)
{
Assert.IsNull(caught, "Unexpected client exception");
Assert.IsNull(server.mCaught, "Unexpected server exception");
}
}
private bool DoHandshakeAsServer(out string handshakeError)
{
handshakeError = null;
logger.LogDebug("DTLS commencing handshake as server.");
if (!_handshaking && !_handshakeComplete)
{
this._waitMillis = RetransmissionMilliseconds;
this._startTime = System.DateTime.Now;
this._handshaking = true;
SecureRandom secureRandom = new SecureRandom();
DtlsServerProtocol serverProtocol = new DtlsServerProtocol(secureRandom);
try
{
var server = (DtlsSrtpServer)connection;
// Perform the handshake in a non-blocking fashion
Transport = serverProtocol.Accept(server, this);
// Prepare the shared key to be used in RTP streaming
//server.PrepareSrtpSharedSecret();
// Generate encoders for DTLS traffic
if (server.GetSrtpPolicy() != null)
{
srtpDecoder = GenerateRtpDecoder();
srtpEncoder = GenerateRtpEncoder();
srtcpDecoder = GenerateRtcpDecoder();
srtcpEncoder = GenerateRtcpEncoder();
}
// Declare handshake as complete
_handshakeComplete = true;
_handshakeFailed = false;
_handshaking = false;
// Warn listeners handshake completed
//UnityEngine.Debug.Log("DTLS Handshake Completed");
return(true);
}
catch (System.Exception excp)
{
if (excp.InnerException is TimeoutException)
{
logger.LogWarning(excp, $"DTLS handshake as server timed out waiting for handshake to complete.");
handshakeError = "timeout";
}
else
{
handshakeError = "unknown";
if (excp is Org.BouncyCastle.Crypto.Tls.TlsFatalAlert)
{
handshakeError = (excp as Org.BouncyCastle.Crypto.Tls.TlsFatalAlert).Message;
}
logger.LogWarning(excp, $"DTLS handshake as server failed. {excp.Message}");
}
// Declare handshake as failed
_handshakeComplete = false;
_handshakeFailed = true;
_handshaking = false;
// Warn listeners handshake completed
//UnityEngine.Debug.Log("DTLS Handshake failed\n"+ e);
}
}
return(false);
}
public void RunTest(TlsTestConfig config)
{
CheckDtlsVersion(config.clientMinimumVersion);
CheckDtlsVersion(config.clientOfferVersion);
CheckDtlsVersion(config.serverMaximumVersion);
CheckDtlsVersion(config.serverMinimumVersion);
SecureRandom secureRandom = new SecureRandom();
DtlsClientProtocol clientProtocol = new DtlsClientProtocol(secureRandom);
DtlsServerProtocol serverProtocol = new DtlsServerProtocol(secureRandom);
MockDatagramAssociation network = new MockDatagramAssociation(1500);
TlsTestClientImpl clientImpl = new TlsTestClientImpl(config);
TlsTestServerImpl serverImpl = new TlsTestServerImpl(config);
Server server = new Server(this, serverProtocol, network.Server, serverImpl);
Thread serverThread = new Thread(new ThreadStart(server.Run));
serverThread.Start();
Exception caught = null;
try
{
DatagramTransport clientTransport = network.Client;
if (TlsTestConfig.DEBUG)
{
clientTransport = new LoggingDatagramTransport(clientTransport, Console.Out);
}
DtlsTransport dtlsClient = clientProtocol.Connect(clientImpl, clientTransport);
for (int i = 1; i <= 10; ++i)
{
byte[] data = new byte[i];
Arrays.Fill(data, (byte)i);
dtlsClient.Send(data, 0, data.Length);
}
byte[] buf = new byte[dtlsClient.GetReceiveLimit()];
while (dtlsClient.Receive(buf, 0, buf.Length, 100) >= 0)
{
}
dtlsClient.Close();
}
catch (Exception e)
{
caught = e;
LogException(caught);
}
server.Shutdown(serverThread);
// TODO Add checks that the various streams were closed
Assert.AreEqual(config.expectFatalAlertConnectionEnd, clientImpl.FirstFatalAlertConnectionEnd, "Client fatal alert connection end");
Assert.AreEqual(config.expectFatalAlertConnectionEnd, serverImpl.FirstFatalAlertConnectionEnd, "Server fatal alert connection end");
Assert.AreEqual(config.expectFatalAlertDescription, clientImpl.FirstFatalAlertDescription, "Client fatal alert description");
Assert.AreEqual(config.expectFatalAlertDescription, serverImpl.FirstFatalAlertDescription, "Server fatal alert description");
if (config.expectFatalAlertConnectionEnd == -1)
{
Assert.IsNull(caught, "Unexpected client exception");
Assert.IsNull(server.mCaught, "Unexpected server exception");
}
}
internal Server(DtlsTestCase outer, DtlsServerProtocol serverProtocol, DatagramTransport serverTransport, TlsTestServerImpl serverImpl)
{
this.mOuter = outer;
this.mServerProtocol = serverProtocol;
this.mServerTransport = serverTransport;
this.mServerImpl = serverImpl;
}
internal Server(DtlsServerProtocol serverProtocol, DatagramTransport serverTransport)
{
this.mServerProtocol = serverProtocol;
this.mServerTransport = serverTransport;
}
internal Server(DtlsServerProtocol serverProtocol, DatagramTransport serverTransport)
{
this.mServerProtocol = serverProtocol;
this.mServerTransport = serverTransport;
}
