public async Task Handle_InitializeMessage_Rejected_With_Extensions()
{
// arrange
var connectionStatus = ConnectionStatus.Reject(
"Foo",
new Dictionary <string, object> {
{ "bar", "baz" }
});
var interceptor = new SocketSessionInterceptorMock(connectionStatus);
var connection = new SocketConnectionMock();
var handler = new InitializeConnectionMessageHandler(interceptor);
var message = new InitializeConnectionMessage();
// act
await handler.HandleAsync(
connection,
message,
CancellationToken.None);
// assert
Assert.Collection(connection.SentMessages,
t =>
{
Assert.True(t.SequenceEqual(
new RejectConnectionMessage(
connectionStatus.Message,
connectionStatus.Extensions)
.Serialize()));
});
Assert.True(connection.Closed);
}
public override ValueTask <ConnectionStatus> OnConnectAsync(
ISocketConnection connection,
InitializeConnectionMessage message,
CancellationToken cancellationToken)
{
return(new ValueTask <ConnectionStatus>(_connectionStatus));
}
public async Task Handle_InitializeMessage_Accepted()
{
// arrange
var connection = new SocketConnectionMock();
var handler = new InitializeConnectionMessageHandler(
new SocketSessionInterceptorMock());
var message = new InitializeConnectionMessage();
// act
await handler.HandleAsync(
connection,
message,
CancellationToken.None);
// assert
Assert.Collection(connection.SentMessages,
t =>
{
Assert.True(t.SequenceEqual(
AcceptConnectionMessage.Default.Serialize()));
},
t =>
{
Assert.True(t.SequenceEqual(
KeepConnectionAliveMessage.Default.Serialize()));
});
}
// private readonly IAuthenticationSchemeProvider _schemes;
// public AuthenticationSocketInterceptor(IAuthenticationSchemeProvider schemes)
// {
// _schemes = schemes;
// }
// public async Task<ConnectionStatus> OnOpenAsync(
// HttpContext context,
// IReadOnlyDictionary<string, object> properties,
// CancellationToken cancellationToken)
// {
// if (properties.TryGetValue(WEBOCKET_PAYLOAD_AUTH_KEY, out object token) &&
// token is string stringToken)
// {
// context.Items[HTTP_CONTEXT_WEBSOCKET_AUTH_KEY] = stringToken;
// context.Features.Set<IAuthenticationFeature>(new AuthenticationFeature
// {
// OriginalPath = context.Request.Path,
// OriginalPathBase = context.Request.PathBase
// });
// // Give any IAuthenticationRequestHandler schemes a chance to handle the request
// var handlers = context.RequestServices.GetRequiredService<IAuthenticationHandlerProvider>();
// foreach (var scheme in await _schemes.GetRequestHandlerSchemesAsync())
// {
// var handler = handlers.GetHandlerAsync(context, scheme.Name) as IAuthenticationRequestHandler;
// if (handler != null && await handler.HandleRequestAsync())
// {
// return ConnectionStatus.Reject();
// }
// }
// var defaultAuthenticate = await _schemes.GetDefaultAuthenticateSchemeAsync();
// if (defaultAuthenticate != null)
// {
// var result = await context.AuthenticateAsync(defaultAuthenticate.Name);
// if (result?.Principal != null)
// {
// context.User = result.Principal;
// return ConnectionStatus.Accept();
// }
// }
// }
// return ConnectionStatus.Reject();
// }
public async ValueTask <ConnectionStatus> OnConnectAsync(ISocketConnection connection,
InitializeConnectionMessage message,
CancellationToken cancellationToken)
{
var schemes = connection.RequestServices.GetService <IAuthenticationSchemeProvider>();
if (schemes is null)
{
Console.WriteLine("Failed to get authentication scheme provider");
return(ConnectionStatus.Reject());
}
if (message.Payload?[WEBOCKET_PAYLOAD_AUTH_KEY] is not string stringToken)
{
Console.WriteLine("authToken was missing from request");
return(ConnectionStatus.Reject());
}
connection.HttpContext.Items[HTTP_CONTEXT_WEBSOCKET_AUTH_KEY] = stringToken;
connection.HttpContext.Features.Set <IAuthenticationFeature>(new AuthenticationFeature
{
OriginalPath = connection.HttpContext.Request.Path,
OriginalPathBase = connection.HttpContext.Request.PathBase
});
// Give any IAuthenticationRequestHandler schemes a chance to handle the request
var handlers = connection.HttpContext.RequestServices.GetRequiredService <IAuthenticationHandlerProvider>();
foreach (var scheme in await schemes.GetRequestHandlerSchemesAsync())
{
var handler =
handlers.GetHandlerAsync(connection.HttpContext, scheme.Name) as IAuthenticationRequestHandler;
if (handler != null && await handler.HandleRequestAsync())
{
return(ConnectionStatus.Reject());
}
}
var defaultAuthenticate = await schemes.GetDefaultAuthenticateSchemeAsync();
if (defaultAuthenticate != null)
{
var result = await connection.HttpContext.AuthenticateAsync(defaultAuthenticate.Name);
if (result?.Principal != null)
{
connection.HttpContext.User = result.Principal;
return(ConnectionStatus.Accept());
}
}
Console.WriteLine($"Failed to authenticate token {stringToken}");
return(ConnectionStatus.Reject());
}
public void CanHandle_InitializeMessage_True()
{
// arrange
var handler = new InitializeConnectionMessageHandler(
new SocketSessionInterceptorMock());
var message = new InitializeConnectionMessage();
// act
var result = handler.CanHandle(message);
// assert
Assert.True(result);
}
public Task <ConnectionStatus> OnReceiveAsync(
ISocketConnection connection,
InitializeConnectionMessage message,
CancellationToken cancellationToken)
{
if (_interceptor != null &&
connection is WebSocketConnection con)
{
return(_interceptor.OnOpenAsync(
con.HttpContext,
message.Payload,
cancellationToken));
}
return(Task.FromResult(ConnectionStatus.Accept()));
}
public async ValueTask <ConnectionStatus> OnConnectAsync(
ISocketConnection connection,
InitializeConnectionMessage message,
CancellationToken cancellationToken)
{
// Auth
object?token = null;
var payload = message.Payload ?? throw new Exception("Payload is missing. Can not authenticate user.");
payload?.TryGetValue(WEBOCKET_PAYLOAD_AUTH_KEY, out token);
if (token != null && token is string stringToken)
{
// Do auth
var context = connection.HttpContext;
context.Items.TryAdd(HTTP_CONTEXT_WEBSOCKET_AUTH_KEY, stringToken);
context.Features.Set <IAuthenticationFeature>(new AuthenticationFeature
{
OriginalPath = context.Request.Path,
OriginalPathBase = context.Request.PathBase
});
var authResult = await context.AuthenticateAsync(IdentityServerAuthenticationDefaults.AuthenticationScheme);
if (authResult?.Principal != null)
{
context.User = authResult.Principal;
// add connection to manager
_webSocketManager.AddSocketConnection(connection);
return(ConnectionStatus.Accept());
}
else
{
// reject websocket because user is not authenticated
return(ConnectionStatus.Reject());
}
}
else
{
return(ConnectionStatus.Reject());
}
}
public async Task Handle_InitializeMessage_Rejected()
{
// arrange
var interceptor = new SocketSessionInterceptorMock(ConnectionStatus.Reject());
var connection = new SocketConnectionMock();
var handler = new InitializeConnectionMessageHandler(interceptor);
var message = new InitializeConnectionMessage();
// act
await handler.HandleAsync(
connection,
message,
CancellationToken.None);
// assert
Assert.Collection(connection.SentMessages,
t =>
{
Assert.True(t.SequenceEqual(
new RejectConnectionMessage(
ConnectionStatus.Reject().Message)
.Serialize()));
});
}
public virtual ValueTask <ConnectionStatus> OnConnectAsync(
ISocketConnection connection,
InitializeConnectionMessage message,
CancellationToken cancellationToken) =>
new ValueTask <ConnectionStatus>(ConnectionStatus.Accept());
