public TestClient(bool synchronousCallbacks = false) { var options = new ChannelOptimizations { AllowSynchronousContinuations = synchronousCallbacks }; var transportToApplication = Channel.CreateUnbounded <byte[]>(options); var applicationToTransport = Channel.CreateUnbounded <byte[]>(options); Application = ChannelConnection.Create <byte[]>(input: applicationToTransport, output: transportToApplication); _transport = ChannelConnection.Create <byte[]>(input: transportToApplication, output: applicationToTransport); Connection = new DefaultConnectionContext(Guid.NewGuid().ToString(), _transport, Application); Connection.User = new ClaimsPrincipal(new ClaimsIdentity(new[] { new Claim(ClaimTypes.Name, Interlocked.Increment(ref _id).ToString()) })); Connection.Metadata["ConnectedTask"] = new TaskCompletionSource <bool>(); var protocol = new JsonHubProtocol(new JsonSerializer()); _protocolReaderWriter = new HubProtocolReaderWriter(protocol, new PassThroughEncoder()); _cts = new CancellationTokenSource(); using (var memoryStream = new MemoryStream()) { NegotiationProtocol.WriteMessage(new NegotiationMessage(protocol.Name), memoryStream); Application.Out.TryWrite(memoryStream.ToArray()); } }
public TestClient(bool synchronousCallbacks = false, IHubProtocol protocol = null, IInvocationBinder invocationBinder = null, bool addClaimId = false) { var options = new PipeOptions(readerScheduler: synchronousCallbacks ? PipeScheduler.Inline : null); var pair = DuplexPipe.CreateConnectionPair(options, options); Connection = new DefaultConnectionContext(Guid.NewGuid().ToString(), pair.Transport, pair.Application); var claimValue = Interlocked.Increment(ref _id).ToString(); var claims = new List <Claim> { new Claim(ClaimTypes.Name, claimValue) }; if (addClaimId) { claims.Add(new Claim(ClaimTypes.NameIdentifier, claimValue)); } Connection.User = new ClaimsPrincipal(new ClaimsIdentity(claims)); Connection.Items["ConnectedTask"] = new TaskCompletionSource <bool>(); _protocol = protocol ?? new JsonHubProtocol(); _invocationBinder = invocationBinder ?? new DefaultInvocationBinder(); _cts = new CancellationTokenSource(); using (var memoryStream = new MemoryStream()) { NegotiationProtocol.WriteMessage(new NegotiationMessage(_protocol.Name), memoryStream); Connection.Application.Output.WriteAsync(memoryStream.ToArray()); } }
private async Task StartAsyncCore() { var transferModeFeature = _connection.Features.Get <ITransferModeFeature>(); if (transferModeFeature == null) { transferModeFeature = new TransferModeFeature(); _connection.Features.Set(transferModeFeature); } var requestedTransferMode = _protocol.Type == ProtocolType.Binary ? TransferMode.Binary : TransferMode.Text; transferModeFeature.TransferMode = requestedTransferMode; await _connection.StartAsync(); var actualTransferMode = transferModeFeature.TransferMode; _protocolReaderWriter = new HubProtocolReaderWriter(_protocol, GetDataEncoder(requestedTransferMode, actualTransferMode)); _logger.HubProtocol(_protocol.Name); using (var memoryStream = new MemoryStream()) { NegotiationProtocol.WriteMessage(new NegotiationMessage(_protocol.Name), memoryStream); await _connection.SendAsync(memoryStream.ToArray(), _connectionActive.Token); } }
private async Task NegotiateProtocol() { _logger.LogDebug($"Negotiate to use hub protocol: {_protocol.Name}"); using (var memoryStream = new MemoryStream()) { NegotiationProtocol.WriteMessage(new NegotiationMessage(_protocol.Name), memoryStream); await _connection.SendAsync(memoryStream.ToArray(), CancellationToken.None); } }
public void ParsingNegotiationMessageThrowsForInvalidMessages(string payload, string expectedMessage) { var message = Encoding.UTF8.GetBytes(payload); var exception = Assert.Throws <InvalidDataException>(() => Assert.True(NegotiationProtocol.TryParseMessage(message, out var deserializedMessage))); Assert.Equal(expectedMessage, exception.Message); }
public void CanRoundtripNegotiation() { var negotiationMessage = new NegotiationMessage(protocol: "dummy"); using (var ms = new MemoryStream()) { NegotiationProtocol.WriteMessage(negotiationMessage, ms); Assert.True(NegotiationProtocol.TryParseMessage(ms.ToArray(), out var deserializedMessage)); Assert.NotNull(deserializedMessage); Assert.Equal(negotiationMessage.Protocol, deserializedMessage.Protocol); } }
internal async Task <bool> NegotiateAsync(TimeSpan timeout, IHubProtocolResolver protocolResolver, IUserIdProvider userIdProvider) { try { using (var cts = new CancellationTokenSource()) { cts.CancelAfter(timeout); while (await _connectionContext.Transport.Reader.WaitToReadAsync(cts.Token)) { while (_connectionContext.Transport.Reader.TryRead(out var buffer)) { if (NegotiationProtocol.TryParseMessage(buffer, out var negotiationMessage)) { var protocol = protocolResolver.GetProtocol(negotiationMessage.Protocol, this); var transportCapabilities = Features.Get <IConnectionTransportFeature>()?.TransportCapabilities ?? throw new InvalidOperationException("Unable to read transport capabilities."); var dataEncoder = (protocol.Type == ProtocolType.Binary && (transportCapabilities & TransferMode.Binary) == 0) ? (IDataEncoder)Base64Encoder : PassThroughEncoder; var transferModeFeature = Features.Get <ITransferModeFeature>() ?? throw new InvalidOperationException("Unable to read transfer mode."); transferModeFeature.TransferMode = (protocol.Type == ProtocolType.Binary && (transportCapabilities & TransferMode.Binary) != 0) ? TransferMode.Binary : TransferMode.Text; ProtocolReaderWriter = new HubProtocolReaderWriter(protocol, dataEncoder); _logger.UsingHubProtocol(protocol.Name); UserIdentifier = userIdProvider.GetUserId(this); return(true); } } } } } catch (OperationCanceledException) { _logger.NegotiateCanceled(); } return(false); }
private async Task <bool> ProcessNegotiate(HubConnectionContext connection) { try { using (var cts = new CancellationTokenSource()) { cts.CancelAfter(_hubOptions.NegotiateTimeout); while (await connection.Input.WaitToReadAsync(cts.Token)) { while (connection.Input.TryRead(out var buffer)) { if (NegotiationProtocol.TryParseMessage(buffer, out var negotiationMessage)) { var protocol = _protocolResolver.GetProtocol(negotiationMessage.Protocol, connection); var transportCapabilities = connection.Features.Get <IConnectionTransportFeature>()?.TransportCapabilities ?? throw new InvalidOperationException("Unable to read transport capabilities."); var dataEncoder = (protocol.Type == ProtocolType.Binary && (transportCapabilities & TransferMode.Binary) == 0) ? (IDataEncoder)Base64Encoder : PassThroughEncoder; var transferModeFeature = connection.Features.Get <ITransferModeFeature>() ?? throw new InvalidOperationException("Unable to read transfer mode."); transferModeFeature.TransferMode = (protocol.Type == ProtocolType.Binary && (transportCapabilities & TransferMode.Binary) != 0) ? TransferMode.Binary : TransferMode.Text; connection.ProtocolReaderWriter = new HubProtocolReaderWriter(protocol, dataEncoder); _logger.UsingHubProtocol(protocol.Name); return(true); } } } } } catch (OperationCanceledException) { _logger.NegotiateCanceled(); } return(false); }
/// <summary> /// Client X.224 Connection Request PDU /// </summary> private static void sendConnectNegotiation(NegotiationProtocol NegotiationFlags, byte[] loadBalanceToken) { string domainAndUsername = Options.DomainAndUsername; if (domainAndUsername.Length > 9) { domainAndUsername = domainAndUsername.Substring(0, 9); } RdpPacket packet = new RdpPacket(); packet.WriteByte(3); packet.WriteByte(0); long position = packet.Position; packet.WriteBigEndian16((short)0); packet.WriteByte(0); packet.WriteByte(0xe0); packet.WriteBigEndian16((short)0); packet.WriteBigEndian16((short)0); packet.WriteByte(0); if (loadBalanceToken != null) { packet.Write(loadBalanceToken, 0, loadBalanceToken.Length); packet.WriteString("\r\n", false); } else { packet.WriteString("Cookie: mstshash=" + domainAndUsername + "\r\n", true); } // RDP Negotiation Request packet.WriteByte(0x01); packet.WriteByte(0); packet.WriteLittleEndian16((short)8); packet.WriteLittleEndian32((int)NegotiationFlags); // Standard RDP Security, TLS 1.0, CredSSP long num2 = packet.Position; packet.Position = position; packet.WriteBigEndian16((short)num2); packet.WriteByte((byte)(num2 - 5L)); IsoLayer.Write(packet); }
private async Task StartAsyncCore() { await _connection.StartAsync(_protocol.TransferFormat); _needKeepAlive = _connection.Features.Get <IConnectionInherentKeepAliveFeature>() == null; Log.HubProtocol(_logger, _protocol.Name); _connectionActive = new CancellationTokenSource(); using (var memoryStream = new MemoryStream()) { Log.SendingHubNegotiate(_logger); NegotiationProtocol.WriteMessage(new NegotiationMessage(_protocol.Name), memoryStream); await _connection.SendAsync(memoryStream.ToArray(), _connectionActive.Token); } ResetTimeoutTimer(); }
public TestClient(bool synchronousCallbacks = false, IHubProtocol protocol = null, IInvocationBinder invocationBinder = null, bool addClaimId = false) { var options = new UnboundedChannelOptions { AllowSynchronousContinuations = synchronousCallbacks }; var transportToApplication = Channel.CreateUnbounded <byte[]>(options); var applicationToTransport = Channel.CreateUnbounded <byte[]>(options); Application = ChannelConnection.Create <byte[]>(input: applicationToTransport, output: transportToApplication); _transport = ChannelConnection.Create <byte[]>(input: transportToApplication, output: applicationToTransport); Connection = new DefaultConnectionContext(Guid.NewGuid().ToString(), _transport, Application); var claimValue = Interlocked.Increment(ref _id).ToString(); var claims = new List <Claim> { new Claim(ClaimTypes.Name, claimValue) }; if (addClaimId) { claims.Add(new Claim(ClaimTypes.NameIdentifier, claimValue)); } Connection.User = new ClaimsPrincipal(new ClaimsIdentity(claims)); Connection.Metadata["ConnectedTask"] = new TaskCompletionSource <bool>(); protocol = protocol ?? new JsonHubProtocol(); _protocolReaderWriter = new HubProtocolReaderWriter(protocol, new PassThroughEncoder()); _invocationBinder = invocationBinder ?? new DefaultInvocationBinder(); _cts = new CancellationTokenSource(); using (var memoryStream = new MemoryStream()) { NegotiationProtocol.WriteMessage(new NegotiationMessage(protocol.Name), memoryStream); Application.Writer.TryWrite(memoryStream.ToArray()); } }
private async Task StartAsyncCore() { var transferModeFeature = _connection.Features.Get <ITransferModeFeature>(); if (transferModeFeature == null) { transferModeFeature = new TransferModeFeature(); _connection.Features.Set(transferModeFeature); } var requestedTransferMode = _protocol.Type == ProtocolType.Binary ? TransferMode.Binary : TransferMode.Text; transferModeFeature.TransferMode = requestedTransferMode; await _connection.StartAsync(); _needKeepAlive = _connection.Features.Get <IConnectionInherentKeepAliveFeature>() == null; var actualTransferMode = transferModeFeature.TransferMode; _protocolReaderWriter = new HubProtocolReaderWriter(_protocol, GetDataEncoder(requestedTransferMode, actualTransferMode)); Log.HubProtocol(_logger, _protocol.Name); _connectionActive = new CancellationTokenSource(); using (var memoryStream = new MemoryStream()) { Log.SendingHubNegotiate(_logger); NegotiationProtocol.WriteMessage(new NegotiationMessage(_protocol.Name), memoryStream); await _connection.SendAsync(memoryStream.ToArray(), _connectionActive.Token); } ResetTimeoutTimer(); }
internal async Task <bool> NegotiateAsync(TimeSpan timeout, IList <string> supportedProtocols, IHubProtocolResolver protocolResolver, IUserIdProvider userIdProvider) { try { using (var cts = new CancellationTokenSource()) { cts.CancelAfter(timeout); while (true) { var result = await _connectionContext.Transport.Input.ReadAsync(cts.Token); var buffer = result.Buffer; var consumed = buffer.End; var examined = buffer.End; try { if (!buffer.IsEmpty) { if (NegotiationProtocol.TryParseMessage(buffer, out var negotiationMessage, out consumed, out examined)) { Protocol = protocolResolver.GetProtocol(negotiationMessage.Protocol, supportedProtocols, this); // If there's a transfer format feature, we need to check if we're compatible and set the active format. // If there isn't a feature, it means that the transport supports binary data and doesn't need us to tell them // what format we're writing. var transferFormatFeature = Features.Get <ITransferFormatFeature>(); if (transferFormatFeature != null) { if ((transferFormatFeature.SupportedFormats & Protocol.TransferFormat) == 0) { throw new InvalidOperationException($"Cannot use the '{Protocol.Name}' protocol on the current transport. The transport does not support the '{Protocol.TransferFormat}' transfer mode."); } transferFormatFeature.ActiveFormat = Protocol.TransferFormat; } _cachedPingMessage = Protocol.WriteToArray(PingMessage.Instance); Log.UsingHubProtocol(_logger, Protocol.Name); UserIdentifier = userIdProvider.GetUserId(this); if (Features.Get <IConnectionInherentKeepAliveFeature>() == null) { // Only register KeepAlive after protocol negotiated otherwise KeepAliveTick could try to write without having a ProtocolReaderWriter Features.Get <IConnectionHeartbeatFeature>()?.OnHeartbeat(state => ((HubConnectionContext)state).KeepAliveTick(), this); } return(true); } } else if (result.IsCompleted) { break; } } finally { _connectionContext.Transport.Input.AdvanceTo(consumed, examined); } } } } catch (OperationCanceledException) { Log.NegotiateCanceled(_logger); } return(false); }
internal async Task <bool> NegotiateAsync(TimeSpan timeout, IList <string> supportedProtocols, IHubProtocolResolver protocolResolver, IUserIdProvider userIdProvider) { try { using (var cts = new CancellationTokenSource()) { cts.CancelAfter(timeout); while (true) { var result = await _connectionContext.Transport.Input.ReadAsync(cts.Token); var buffer = result.Buffer; var consumed = buffer.End; var examined = buffer.End; try { if (!buffer.IsEmpty) { if (NegotiationProtocol.TryParseMessage(buffer, out var negotiationMessage, out consumed, out examined)) { var protocol = protocolResolver.GetProtocol(negotiationMessage.Protocol, supportedProtocols, this); var transportCapabilities = Features.Get <IConnectionTransportFeature>()?.TransportCapabilities ?? throw new InvalidOperationException("Unable to read transport capabilities."); var dataEncoder = (protocol.Type == ProtocolType.Binary && (transportCapabilities & TransferMode.Binary) == 0) ? (IDataEncoder)Base64Encoder : PassThroughEncoder; var transferModeFeature = Features.Get <ITransferModeFeature>() ?? throw new InvalidOperationException("Unable to read transfer mode."); transferModeFeature.TransferMode = (protocol.Type == ProtocolType.Binary && (transportCapabilities & TransferMode.Binary) != 0) ? TransferMode.Binary : TransferMode.Text; ProtocolReaderWriter = new HubProtocolReaderWriter(protocol, dataEncoder); _cachedPingMessage = ProtocolReaderWriter.WriteMessage(PingMessage.Instance); Log.UsingHubProtocol(_logger, protocol.Name); UserIdentifier = userIdProvider.GetUserId(this); if (Features.Get <IConnectionInherentKeepAliveFeature>() == null) { // Only register KeepAlive after protocol negotiated otherwise KeepAliveTick could try to write without having a ProtocolReaderWriter Features.Get <IConnectionHeartbeatFeature>()?.OnHeartbeat(state => ((HubConnectionContext)state).KeepAliveTick(), this); } return(true); } } else if (result.IsCompleted) { break; } } finally { _connectionContext.Transport.Input.AdvanceTo(consumed, examined); } } } } catch (OperationCanceledException) { Log.NegotiateCanceled(_logger); } return(false); }