/// <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(); }
public void Connect(IPEndPoint remoteEP) { _socket.Connect(remoteEP); var udpTransport = new UdpTransport(_socket); var random = new SecureRandom(); var protocol = new DtlsClientProtocol(random); var client = new TlsClientImpl(); _dtlsTransport = protocol.Connect(client, udpTransport); }
public void Accept(DtlsServerProtocol serverProtocol, TlsServer server) { _dtlsTransport = serverProtocol.Accept(server, _udpTransport); if (server is IDtlsServerWithConnectionInfo serverWithInfo) { var serverInfo = serverWithInfo.GetConnectionInfo(); ConnectionInfo = serverInfo; } }
public Task ConnectAsync(CoapTransportLayerConnectOptions connectOptions, CancellationToken cancellationToken) { _udpTransport = new UdpTransport(connectOptions); var clientProtocol = new DtlsClientProtocol(new SecureRandom()); var client = new DtlsClient(ConvertProtocolVersion(DtlsVersion), (PreSharedKey)Credentials); _dtlsTransport = clientProtocol.Connect(client, _udpTransport); return(Task.FromResult(0)); }
public DtlsTransport Accept() { try { DtlsTransport dtlsTransport = dtlsServerProtocol.Accept(tlsServer, DatagramTransport); HandshakeComplete?.Invoke(this, new HandshakeCompleteEventArgs(tlsServer.ChosenSrtpProtectionProfile, TlsRole.Server, tlsServer.SrtpKeyingMaterial)); return(dtlsTransport); } catch (System.Exception e) { throw e; } }
/// <summary> /// Stop the current session /// </summary> public void Stop() { if (_dtlsSession != null) { _dtlsSession.Close(); EventHandler<SessionEventArgs> h = SessionEvent; if (h != null) { SessionEventArgs thisEvent = new SessionEventArgs(SessionEventArgs.SessionEvent.Closed, this); h(this, thisEvent); } _dtlsSession = null; } _client = null; }
DtlsTransport Connect() { try { DtlsTransport dtlsTransport = dtlsClientProtocol.Connect(tlsClient, datagramTransport); HandshakeComplete?.Invoke(this, new HandshakeCompleteEventArgs(tlsClient.ChosenSrtpProtectionProfile, TlsRole.Client, tlsClient.SrtpKeyingMaterial)); return(dtlsTransport); } catch (Exception e) { throw e; } }
private void EnsureConnected() { lock (_ensureConnectedLock) { if (_isConnected) { return; } var udpClient = new UdpClient(Server, Port); var dtlsClientProtocol = new DtlsClientProtocol(new SecureRandom()); _datagramTransport = dtlsClientProtocol.Connect(_tlsClient, new UdpDatagramTransport(udpClient, NetworkMtu)); _isConnected = true; } }
/// <summary> /// Create the DTLS connection over a specific UDP channel. /// We already know what address we are going to use /// </summary> /// <param name="udpChannel">UDP channel to use</param> public void Connect(UDPChannel udpChannel) { #if SUPPORT_TLS_CWT if (CwtTrustKeySet != null) { _client = new DtlsClient(null, _userKey, CwtTrustKeySet); } else { #endif if (_userKey.PrivateKey.HasKeyType((int)GeneralValuesInt.KeyType_Octet)) { CBORObject kid = _userKey.PrivateKey[CoseKeyKeys.KeyIdentifier]; BasicTlsPskIdentity pskIdentity; pskIdentity = new BasicTlsPskIdentity(kid != null ? kid.GetByteString() : new byte[0], _userKey.PrivateKey[CoseKeyParameterKeys.Octet_k].GetByteString()); _client = new DtlsClient(null, pskIdentity); } else if (_userKey.PrivateKey.HasKeyType((int)GeneralValuesInt.KeyType_EC2)) { _client = new DtlsClient(null, _userKey); } #if SUPPORT_TLS_CWT } #endif _client.TlsEventHandler += OnTlsEvent; DtlsClientProtocol clientProtocol = new DtlsClientProtocol(new SecureRandom()); _transport.UDPChannel = udpChannel; AuthenticationKey = _userKey.PrivateKey; _listening = 1; DtlsTransport dtlsClient = clientProtocol.Connect(_client, _transport); _listening = 0; _dtlsSession = dtlsClient; // We are now in the world of a connected system - // We need to do the receive calls new Thread(StartListen).Start(); }
public async Task ConnectAsync(CoapTransportLayerConnectOptions connectOptions, CancellationToken cancellationToken) { if (connectOptions == null) { throw new ArgumentNullException(nameof(connectOptions)); } cancellationToken.ThrowIfCancellationRequested(); try { _udpTransport = new UdpTransport(connectOptions); var clientProtocol = new DtlsClientProtocol(_secureRandom); _dtlsClient = new DtlsClient(ConvertProtocolVersion(DtlsVersion), (PreSharedKey)Credentials); using (cancellationToken.Register(() => { _udpTransport.Close(); })) { _dtlsTransport = await Task.Run(() => clientProtocol.Connect(_dtlsClient, _udpTransport), cancellationToken).ConfigureAwait(false); } } catch { _udpTransport?.Dispose(); if (cancellationToken.IsCancellationRequested) { throw new OperationCanceledException(); } if (_dtlsClient.ReceivedAlert != 0) { throw new DtlsException($"Received alert {AlertDescription.GetText(_dtlsClient.ReceivedAlert)}.", null) { ReceivedAlert = _dtlsClient.ReceivedAlert }; } throw; } }
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); }
/// <summary> /// Connect to a group to start streaming /// </summary> /// <param name="groupId"></param> /// <param name="simulator"></param> /// <returns></returns> public async Task Connect(string groupId, bool simulator = false) { _simulator = simulator; var enableResult = await _localHueClient.SetStreamingAsync(groupId).ConfigureAwait(false); byte[] psk = FromHex(_clientKey); BasicTlsPskIdentity pskIdentity = new BasicTlsPskIdentity(_appKey, psk); var dtlsClient = new DtlsClient(null !, pskIdentity); DtlsClientProtocol clientProtocol = new DtlsClientProtocol(new SecureRandom()); await _socket.ConnectAsync(IPAddress.Parse(_ip), 2100).ConfigureAwait(false); _udp = new UdpTransport(_socket); if (!simulator) { _dtlsTransport = clientProtocol.Connect(dtlsClient, _udp); } }
public void Run() { try { DtlsTransport dtlsServer = mServerProtocol.Accept(mServerImpl, mServerTransport); byte[] buf = new byte[dtlsServer.GetReceiveLimit()]; while (!isShutdown) { int length = dtlsServer.Receive(buf, 0, buf.Length, 100); if (length >= 0) { dtlsServer.Send(buf, 0, length); } } dtlsServer.Close(); } catch (Exception e) { mCaught = e; mOuter.LogException(mCaught); } }
public void Run() { try { MockDtlsServer server = new MockDtlsServer(); DtlsTransport dtlsServer = mServerProtocol.Accept(server, mServerTransport); byte[] buf = new byte[dtlsServer.GetReceiveLimit()]; while (!isShutdown) { int length = dtlsServer.Receive(buf, 0, buf.Length, 1000); if (length >= 0) { dtlsServer.Send(buf, 0, length); } } dtlsServer.Close(); } catch (Exception e) { Console.Error.WriteLine(e.StackTrace); } }
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 DtlsClient(Socket socket, DtlsTransport transport) { _socket = socket; _dtlsTransport = transport; }