protected override void Execute(Stream stream)
{
this.Log("Sending StoreObject request to {0} for object ID {1}", TargetNode.EndPoint, objectId);
var clientHandshake = new ClientHandshake();
clientHandshake.NodeId = App.Node.Id;
clientHandshake.Port = App.Node.Port;
clientHandshake.StoreObjectRequest = new StoreObjectRequest();
clientHandshake.StoreObjectRequest.Hash = Crypto.Hash(bytes);
clientHandshake.StoreObjectRequest.Length = (uint) bytes.Length;
clientHandshake.StoreObjectRequest.ObjectId = objectId;
Serializer.SerializeWithLengthPrefix(stream, clientHandshake, PrefixStyle.Base128);
var storeObjectResponse = Serializer.DeserializeWithLengthPrefix<StoreObjectResponse>(stream, PrefixStyle.Base128);
if (storeObjectResponse.Error != Error.Success)
{
this.Log("Got StoreObject response {0} from {1} for object ID {2}", storeObjectResponse.Error, TargetNode.EndPoint, objectId);
done(storeObjectResponse.Error);
return;
}
// TODO: update local metadata
stream.Write(bytes, 0, bytes.Length);
done(Error.Success);
}
protected override void Execute(Stream stream)
{
this.Log("Sending GetObject request to {0} for object ID {1}", TargetNode.EndPoint, objectId);
var clientHandshake = new ClientHandshake();
clientHandshake.NodeId = App.Node.Id;
clientHandshake.Port = App.Node.Port;
clientHandshake.GetObjectRequest = new GetObjectRequest();
clientHandshake.GetObjectRequest.ObjectId = objectId;
Serializer.SerializeWithLengthPrefix(stream, clientHandshake, PrefixStyle.Base128);
var getObjectResponse = Serializer.DeserializeWithLengthPrefix<GetObjectResponse>(stream, PrefixStyle.Base128);
if (getObjectResponse.Error != Error.Success)
{
this.Log("Got GetObject response {0} from {1} for object ID {2}", getObjectResponse.Error, TargetNode.EndPoint, objectId);
done(getObjectResponse.Error, null);
return;
}
var buffer = new byte[getObjectResponse.Length];
var offset = 0;
var remaining = (int) getObjectResponse.Length;
while (remaining != 0)
{
int read = stream.Read(buffer, offset, remaining);
offset += read;
remaining -= read;
}
this.Log("Got object {0} from {1}.", objectId, TargetNode.EndPoint);
done(Error.Success, buffer);
}
public static void HandleHandshake(Session session, ClientHandshake handshake)
{
Log.Print(LogType.Debug, $"Protocol Version: {handshake.ProtocolVersion}");
Log.Print(LogType.Debug, $"Server Address: {handshake.ServerAddress}");
Log.Print(LogType.Debug, $"Server Port: {handshake.ServerPort}");
Log.Print(LogType.Debug, $"Next State: {handshake.NextState}");
}
public static ServerHandshake Handshake(ClientHandshake clientData, NetworkStream stream)
{
var output = GetServerData(stream);
SendClientData(clientData, stream);
return(output);
}
private async Task ConnectToAgent(CancellationToken token)
{
var agentAddress = $"{Agent.TcpHost}:{Agent.TcpPort}";
Log.Debug($"Connecting to TCP Agent '{agentAddress}'...");
try {
await MessageClient.ConnectAsync(Agent.TcpHost, Agent.TcpPort, Token);
Log.Info($"Connected to TCP Agent '{agentAddress}'.");
Log.Debug($"Performing TCP handshake... [{agentAddress}]");
await ClientHandshake.Verify(MessageClient, token);
Log.Info($"Handshake successful. [{agentAddress}].");
}
catch (Exception error) {
Log.Error($"Failed to connect to TCP Agent '{agentAddress}'!", error);
MessageClient.Dispose();
throw;
}
await OnBeginSession(token);
Tasks.Start();
}
// This method is called when the socket connects
public override void Connected(ClientHandshake handshake)
{
Console.WriteLine("");
Console.WriteLine(" * Client Connected");
Console.WriteLine("");
Console.WriteLine("What would you like to say to the client?");
Console.WriteLine("");
}
private void Authenticate()
{
_handshake = new ClientHandshake {
Version = "8", Origin = Origin, Host = _host, Key = GenerateKey(), ResourcePath = _path, SubProtocols = SubProtocols
};
_client.Client.Send(Encoding.UTF8.GetBytes(_handshake.ToString()));
}
public void CorruptHostShouldNotValidate()
{
var clientHandshake = new ClientHandshake();
clientHandshake.Key1 = "aaa";
clientHandshake.Key2 = "bbb";
clientHandshake.Origin = "AAA";
clientHandshake.ResourcePath = "BBB";
clientHandshake.Host = "$%%$%NoT^^^A)()(()VALID--==!!URI&&&@@#$#~~~";
Assert.IsFalse(clientHandshake.Validate(null, "ws://localhost:8181/"));
}
public void HostnameShouldMatchOnUri()
{
var clientHandshake = new ClientHandshake();
clientHandshake.Key1 = "aaa";
clientHandshake.Key2 = "bbb";
clientHandshake.Origin = "AAA";
clientHandshake.ResourcePath = "BBB";
clientHandshake.Host = "localhost:8181";
Assert.IsTrue(clientHandshake.Validate(null, "ws://localhost:8181/"));
}
public void NullHostShouldNotValidate()
{
var clientHandshake = new ClientHandshake();
clientHandshake.Key1 = "aaa";
clientHandshake.Key2 = "bbb";
clientHandshake.Origin = "AAA";
clientHandshake.ResourcePath = "BBB";
clientHandshake.Host = null;
Assert.IsFalse(clientHandshake.Validate(null, "ws://localhost:8181/"));
}
//public List<IWebSocket> this[string metadata]
//{
// get
// {
// if (clientsByMetadata.ContainsKey(metadata))
// {
// return clientsByMetadata[metadata];
// }
// return new List<IWebSocket>();
// }
//}
private void OnHandShaken(IWebSocket webSocket, ClientHandshake clientHandshake)
{
var handler = handlerFactory.Create(clientHandshake.ResourceName);
if (handler != null)
{
webSocket.Received = handler.Received;
webSocket.Disconnected = sender =>
{
var found = clientsByMetadata.FirstOrDefault(kv => kv.Value.Exists(ws => ws == sender));
if (found.Value != null)
{
found.Value.Remove((WebSocket)sender);
if (!found.Value.Any())
{
clientsByMetadata.Remove(found.Key);
}
// A web socket with the metaData has been disconnected from the server
handler.Disconnected(found.Key);
}
};
webSocket.Error = handler.Error;
var metadata = GetMetadata(clientHandshake, webSocket);
// A web socket with the metaData has been connected to the server
handler.Connected(metadata);
if (!clientsByMetadata.ContainsKey(metadata))
{
clientsByMetadata.Add(metadata, new List <IWebSocket> {
webSocket
});
}
else
{
//clientsByMetaData[metaData].Dispose();
clientsByMetadata[metadata].Add(webSocket);
}
// Begin receiving data from the client
webSocket.ReceiveAsync();
}
else
{
if (Log.IsDebugEnabled)
{
Log.Debug("There was no handler found for the resource name");
}
// If nothing is handling client connections
// the client connection should be closed
webSocket.Dispose();
}
}
private async Task AgentAction(ServerAgent agent)
{
using (var messageClient = new MessageClient(PhotonServer.Instance.MessageRegistry)) {
Output.WriteBlock(block => block
.Write("Connecting to agent ", ConsoleColor.DarkCyan)
.Write(agent.Name, ConsoleColor.Cyan)
.WriteLine("...", ConsoleColor.DarkCyan));
try {
await messageClient.ConnectAsync(agent.TcpHost, agent.TcpPort, TokenSource.Token);
await ClientHandshake.Verify(messageClient, TokenSource.Token);
}
catch (Exception error) {
Output.WriteBlock(block => block
.Write("Failed to connect to agent ", ConsoleColor.DarkRed)
.Write(agent.Name, ConsoleColor.Red)
.WriteLine("!", ConsoleColor.DarkRed)
.WriteLine(error.UnfoldMessages(), ConsoleColor.DarkYellow));
return;
}
Output.WriteLine("Agent connected.", ConsoleColor.DarkGreen);
Output.WriteBlock(block => block
.Write("Updating Agent ", ConsoleColor.DarkCyan)
.Write(agent.Name, ConsoleColor.Cyan)
.WriteLine("...", ConsoleColor.DarkCyan));
try {
await UpdateAgent(agent, messageClient, TokenSource.Token);
Output.WriteBlock(block => block
.Write("Agent ", ConsoleColor.DarkGreen)
.Write(agent.Name, ConsoleColor.Green)
.WriteLine(" updated successfully.", ConsoleColor.DarkGreen));
}
catch (Exception error) {
Output.WriteBlock(block => block
.Write("Failed to update agent ", ConsoleColor.DarkRed)
.Write(agent.Name, ConsoleColor.Red)
.WriteLine("!", ConsoleColor.DarkRed)
.WriteLine(error.UnfoldMessages(), ConsoleColor.DarkYellow));
}
}
}
private async Task <MessageClient> Reconnect(ServerAgent agent, TimeSpan timeout, CancellationToken token)
{
using (var timeoutTokenSource = new CancellationTokenSource(timeout))
using (var mergedTokenSource = CancellationTokenSource.CreateLinkedTokenSource(timeoutTokenSource.Token, token)) {
while (true)
{
mergedTokenSource.Token.ThrowIfCancellationRequested();
var client = new MessageClient(PhotonServer.Instance.MessageRegistry);
try {
using (var connectionTimeoutTokenSource = new CancellationTokenSource(20_000))
using (var connectTokenSource = CancellationTokenSource.CreateLinkedTokenSource(mergedTokenSource.Token, connectionTimeoutTokenSource.Token)) {
await client.ConnectAsync(agent.TcpHost, agent.TcpPort, connectTokenSource.Token);
await ClientHandshake.Verify(client, connectTokenSource.Token);
var versionRequest = new AgentGetVersionRequest();
var versionResponse = await client.Send(versionRequest)
.GetResponseAsync <AgentGetVersionResponse>(connectTokenSource.Token);
if (string.IsNullOrEmpty(versionResponse.Version))
{
Log.Warn("An empty version response was received!");
continue;
}
if (!VersionTools.HasUpdates(versionResponse.Version, UpdateVersion))
{
return(client);
}
}
}
catch (SocketException) {}
catch (OperationCanceledException) {}
catch (Exception error) {
Log.Warn("An unhandled exception occurred while attempting to reconnect to an updating agent.", error);
}
client.Dispose();
await Task.Delay(3_000, mergedTokenSource.Token);
}
}
}
private async Task AgentAction(ServerAgent agent)
{
using (var messageClient = new MessageClient(PhotonServer.Instance.MessageRegistry)) {
try {
Output.WriteLine($"[{agent.Name}] Connecting...'", ConsoleColor.White);
await messageClient.ConnectAsync(agent.TcpHost, agent.TcpPort, TokenSource.Token);
await ClientHandshake.Verify(messageClient, TokenSource.Token);
Output.WriteLine($"[{agent.Name}] Connected.", ConsoleColor.DarkCyan);
}
catch (Exception error) {
using (var block = Output.WriteBlock()) {
block.WriteLine($"[{agent.Name}] Connection Failed!", ConsoleColor.DarkRed);
block.WriteLine(error.UnfoldMessages(), ConsoleColor.DarkYellow);
}
return;
}
var userMgr = PhotonServer.Instance.UserMgr;
var securityConfig = PhotonServer.Instance.ServerConfiguration.Value.Security;
var message = new SecurityPublishRequest {
Users = userMgr.AllUsers.ToArray(),
UserGroups = userMgr.AllGroups.ToArray(),
SecurityEnabled = securityConfig.Enabled,
SecurityDomainEnabled = securityConfig.DomainEnabled,
};
Output.WriteLine($"[{agent.Name}] Publishing security configuration...", ConsoleColor.White);
await messageClient.Send(message)
.GetResponseAsync();
Output.WriteLine($"[{agent.Name}] security configuration published.", ConsoleColor.DarkGreen);
try {
Output.WriteLine($"[{agent.Name}] Disconnecting...", ConsoleColor.White);
messageClient.Disconnect();
}
catch {}
}
}
private string GetMetadata(ClientHandshake clientHandshake, IWebSocket webSocket)
{
if (!string.IsNullOrEmpty(fromFieldName) &&
clientHandshake.ExtraFields != null &&
clientHandshake.ExtraFields.ContainsKey(fromFieldName))
{
return(clientHandshake.ExtraFields[fromFieldName]);
}
else if (!string.IsNullOrEmpty(clientHandshake.Origin) &&
!clientHandshake.Origin.Equals("null"))
{
return(clientHandshake.Origin);
}
else
{
return(webSocket.LocalEndPoint.ToString());
}
}
public static HandshakeReturnCapsula Login(Logger logger, Stream stream, X509Certificate2 cert, string password, string userName = null, int?clientId = null)
{
ClientHandshake clientHandshake = new ClientHandshake()
{
PemCertificate = X509Certificate2Utils.ExportToPem(cert),
UserName = userName,
ClientId = clientId,
ServerPassword = password
};
if (userName != null && userName.Length > DataConstants.USER_NAME_MAX_LENGHT)
{
throw new Exception("Username is too long.");
}
TextEncoder.SendJson(stream, clientHandshake);
byte[] encrypted = BinaryEncoder.ReceiveBytes(stream);
byte[] decrypted = RSAEncoder.Decrypt(encrypted, cert);
BinaryEncoder.SendBytes(stream, decrypted);
ServerHandshake serverHandshake = TextEncoder.ReadJson <ServerHandshake>(stream);
logger.Log("Handshake", "Handshake", serverHandshake.Errors, false);
if (!serverHandshake.Succeeded)
{
throw new Exception($"Handshake failed\n{serverHandshake.Errors}");
}
return(new HandshakeReturnCapsula()
{
UserId = serverHandshake.UserId,
UserName = serverHandshake.UserName,
ClientId = serverHandshake.ClientId,
SelfAesPassword = serverHandshake.SelfAesKey == null ? null : new AESPassword(RSAEncoder.DecryptAndVerify(serverHandshake.SelfAesKey, cert, cert))
});
}
private void Start()
{
DontDestroyOnLoad(gameObject);
info = FindObjectOfType <PlayerInformation>();
ws = new WebSocket("ws://" + serverIp);
Debug.Log("Connecting to server - " + serverIp);
ws.Connect();
ws.OnMessage += (sender, e) => Receive(sender, e);
ws.OnClose += (sender, e) => OnDisconnect(sender, e);
ClientHandshake handshake = new ClientHandshake();
handshake.packetType = (int)GameClientPackets.Handshake;
handshake.username = info.username;
string json = JsonUtility.ToJson(handshake);
ws.Send(json);
StartCoroutine(StayAlive());
}
private static async Task <string> GetAgentVersion(ServerAgent agent, CancellationToken token)
{
MessageClient messageClient = null;
try {
messageClient = new MessageClient(PhotonServer.Instance.MessageRegistry);
await messageClient.ConnectAsync(agent.TcpHost, agent.TcpPort, token);
await ClientHandshake.Verify(messageClient, token);
var agentVersionRequest = new AgentGetVersionRequest();
var agentVersionResponse = await messageClient.Send(agentVersionRequest)
.GetResponseAsync <AgentGetVersionResponse>(token);
return(agentVersionResponse.Version);
}
catch (Exception error) {
throw new ApplicationException($"Failed to retrieve version of agent '{agent.Name}'!", error);
}
finally {
messageClient?.Dispose();
}
}
public static ConnectionInfo Run(Stream stream, Action <string> log, ServerConfig config)
{
ClientHandshake clientHandshake = TextEncoder.ReadJson <ClientHandshake>(stream);
X509Certificate2 clientCertificate = X509Certificate2Utils.ImportFromPem(clientHandshake.PemCertificate);
log($"Logging user sent username {clientHandshake.UserName}\n Certificate:\n {clientHandshake.PemCertificate}");
ServerHandshake errorHandshake = new ServerHandshake()
{
Errors = "",
NewUser = false,
Succeeded = false,
UserId = -1,
UserName = ""
};
if (config.Password != null && !config.Password.Equals(clientHandshake.ServerPassword))
{
errorHandshake.Errors = "Server password is wrong.";
TextEncoder.SendJson(stream, errorHandshake);
throw new Exception(errorHandshake.Errors);
}
log("Generating random bytes");
byte[] randomBytes = LUtils.GenerateRandomBytes(TcpConstants.HANDSHAKE_LENGHT);
log("Sending encrypted bytes");
BinaryEncoder.SendBytes(stream, RSAEncoder.Encrypt(randomBytes, clientCertificate));
byte[] received = BinaryEncoder.ReceiveBytes(stream);
if (!randomBytes.SequenceEqual(received))
{
log("Client's certificate verification failed.");
errorHandshake.Errors = "Client's certificate verification failed.";
TextEncoder.SendJson(stream, errorHandshake);
throw new Exception(errorHandshake.Errors);
}
log("Certificate verification succeeded.");
Users user;
String message;
Clients client;
byte[] aesKey = null;
bool newUser = false;
using (Context context = new Context(config))
{
byte[] hash = SHA256Utils.ComputeByteSha256Hash(clientCertificate);
user = context.Users.SingleOrDefault(u => u.PublicCertificateSha256.SequenceEqual(hash));
if (user == null)
{
log("User doesn't exist yet. I'll try to create him.");
newUser = true;
log("Checking the uniquity of username.");
String userName = clientHandshake.UserName;
if (context.Users.SingleOrDefault(u => u.UserName.Equals(userName)) != null)
{
errorHandshake.Errors = "Username isn't unique.";
TextEncoder.SendJson(stream, errorHandshake);
throw new Exception(errorHandshake.Errors);
}
else if (userName.Length > 45)
{
errorHandshake.Errors = "Username is too long (max. 45 chars)";
TextEncoder.SendJson(stream, errorHandshake);
throw new Exception(errorHandshake.Errors);
}
else if (userName.Length < 4)
{
errorHandshake.Errors = "Username is too short (min. 4 chars)";
TextEncoder.SendJson(stream, errorHandshake);
throw new Exception(errorHandshake.Errors);
}
else if (!Validators.ValidateRegexUserName(userName))
{
errorHandshake.Errors = "Username must match this regex ^[a-zA-Z][-a-zA-Z0-9_]+$ (Vaguely can't contain special chars and spaces)";
TextEncoder.SendJson(stream, errorHandshake);
throw new Exception(errorHandshake.Errors);
}
log("Creating user.");
user = new Users()
{
PublicCertificate = clientHandshake.PemCertificate,
PublicCertificateSha256 = hash,
UserName = clientHandshake.UserName
};
context.Users.Add(user);
context.SaveChanges();
message = "User successfully created.";
log("User successfully created.");
}
else
{
message = "User exists.";
log("User exists.");
}
client = new Clients()
{
UserId = user.Id
};
if (clientHandshake.ClientId == null)
{
log($"Loading self-aes key.");
aesKey = context.UsersKeys
.Where(u => u.RecepientId == user.Id)
.Where(u => u.SenderId == user.Id)
.Select(u => u.AesKey)
.SingleOrDefault();
context.Add(client);
context.SaveChanges();
log($"Added client with Id {client.Id}.");
}
else
{
client.Id = (int)clientHandshake.ClientId;
if (context.Clients.Where(u => u.Id == client.Id).Single().UserId != user.Id)
{
errorHandshake.Errors = "This client id isn't owned by this user.";
TextEncoder.SendJson(stream, errorHandshake);
throw new Exception(errorHandshake.Errors);
}
log($"Client with Id {client.Id} has logged in.");
}
}
ServerHandshake toSend = new ServerHandshake()
{
Errors = message,
NewUser = newUser,
Succeeded = true,
UserId = user.Id,
UserName = user.UserName,
ClientId = client.Id,
SelfAesKey = aesKey
};
TextEncoder.SendJson(stream, toSend);
ConnectionInfo ret = new ConnectionInfo(user, clientCertificate, client.Id);
log($"Handshake successeded. User {ret.UserName} with id {ret.UserId} has logged in. Client has id {client.Id}.");
return(ret);
}
public static void SendClientData(ClientHandshake data, NetworkStream stream)
{
NetworkInterop.WriteInt(stream, data.receivingPortNumber);
}
public void Connected(ClientHandshake handshake)
{
((IWebSocket)webSocket).Connected(handshake);
}
public abstract void Connected(ClientHandshake handshake);
public override void Connected(ClientHandshake handshake)
{
}
public override void Connected(ClientHandshake handshake)
{
var ys = new String('y', Count);
Send(ys);
}
public override void Connected(ClientHandshake handshake)
{
ConnectedCalled = true;
}
public void Connected(ClientHandshake handshake)
{
Console.WriteLine("--- connected ---");
}
public static UserCapsula Run(Stream stream, Action <string> log, ServerConfig config)
{
ClientHandshake clientHandshake = TextEncoder.ReadClientHandshake(stream);
X509Certificate2 clientCertificate = X509Certificate2Utils.ImportFromPem(clientHandshake.PemCertificate);
log($"Logging user sent username {clientHandshake.UserName}\n Certificate:\n {clientHandshake.PemCertificate}");
log("Generating random bytes");
byte[] randomBytes = LUtils.GenerateRandomBytes(TcpConstants.HANDSHAKE_LENGHT);
log("Sending encrypted bytes");
BinaryEncoder.SendBytes(stream, RSAEncoder.Encrypt(randomBytes, clientCertificate));
ServerHandshake errorHandshake = new ServerHandshake()
{
Errors = "",
NewUser = false,
Succeeded = false,
UserId = -1,
UserName = ""
};
byte[] received = BinaryEncoder.ReceiveBytes(stream);
if (!randomBytes.SequenceEqual(received))
{
log("Sending error to client.");
errorHandshake.Errors = "Client's certificate verification failed.";
TextEncoder.SendJson(stream, errorHandshake);
throw new Exception(errorHandshake.Errors);
}
log("Certificate verification succeeded.");
Users user;
String message;
Clients client;
bool newUser = false;
using (Context context = new Context(config))
{
SHA1 sha = new SHA1CryptoServiceProvider();
byte[] hash = sha.ComputeHash(clientCertificate.RawData);
user = context.Users.SingleOrDefault(u => u.PublicCertificateSha1.SequenceEqual(hash));
if (user == null)
{
log("User doesn't exist yet. I'll try to create him.");
newUser = true;
log("Checking the uniquity of username.");
String userName = clientHandshake.UserName;
if (context.Users.SingleOrDefault(u => u.UserName.Equals(userName)) != null)
{
log("Username isn't unique.");
errorHandshake.Errors = "Username isn't unique.";
TextEncoder.SendJson(stream, errorHandshake);
throw new Exception(errorHandshake.Errors);
}
log("Creating user.");
user = new Users()
{
PublicCertificate = clientHandshake.PemCertificate,
PublicCertificateSha1 = hash,
UserName = clientHandshake.UserName
};
context.Users.Add(user);
context.SaveChanges();
message = "User successfully created.";
log("User successfully created.");
}
else
{
message = "User exists.";
log("User exists.");
}
client = new Clients()
{
UserId = user.Id
};
if (clientHandshake.ClientId == null)
{
context.Add(client);
context.SaveChanges();
log($"Added client with Id {client.Id}.");
}
else
{
log($"Client with Id {client.Id} has logged in.");
}
}
ServerHandshake toSend = new ServerHandshake()
{
Errors = message,
NewUser = newUser,
Succeeded = true,
UserId = user.Id,
UserName = user.UserName,
ClientId = client.Id
};
TextEncoder.SendJson(stream, toSend);
UserCapsula ret = new UserCapsula(user, clientCertificate);
log($"Handshake successeded. User {ret.UserName} with id {ret.UserId} has logged in");
return(ret);
}
// This method is called when the socket connects
public override void Connected(ClientHandshake handshake)
{
//this.Send("You are now connected");
}
public override void Connected(ClientHandshake handshake)
{
ConnectedCalled = true;
}
public override void Connected(ClientHandshake handshake)
{
Console.WriteLine("new double echo connection");
}
// This method is called when the socket connects
public override void Connected(ClientHandshake handshake)
{
Console.WriteLine(" - Client Connected");
}
public override void Connected(ClientHandshake handshake)
{
}
public override void Connected(ClientHandshake handshake)
{
var ys = new String('y', Count);
Send(ys);
}
