private void ServerGreetingReceived(AsynchronousSocket socket)
{
if (socket.ReceiveBufferLength != 80)
{
OnDebug("Server did not send a proper greeting");
socket.Disconnect();
return;
}
string salt = SRP6.BytesToHex(SRP6.SubArray(socket.ReceiveBuffer, 0, 32));
string pubKey = SRP6.BytesToHex(SRP6.SubArray(socket.ReceiveBuffer, 32, 32));
string scrambler = SRP6.BytesToHex(SRP6.SubArray(socket.ReceiveBuffer, 64, 16));
// Setup the SessionKey
srpClient = new SRP6(IdentityHash, Modulus, 0x07, salt);
srpClient.SetSessionKey(pubKey, scrambler);
OnDebug("Salt = " + salt);
OnDebug("Server's PublicKey = " + pubKey);
OnDebug("Scrambler = " + scrambler);
step++;
// Send my public key to the server
OnDebug("Client->PublicKey");
OnDebug("PublicKey = " + srpClient.GetPublicKey());
byte[] reply = srpClient.PublicKey.ToUnsignedByteArray();
socket.Send(reply, 0, reply.Length);
OnDebug("SessionKey = " + srpClient.GetSessionKey());
}
protected bool OnAuthenticationRequest(AsynchronousSocket socket, byte[] identityHash)
{
bool allow = false;
AuthenticationRequestEventHandler handler = AuthenticationRequest;
if (handler != null)
{
AuthenticationRequestEventArgs args =
new AuthenticationRequestEventArgs(identityHash);
foreach (AuthenticationRequestEventHandler tmp in
handler.GetInvocationList())
{
tmp(this, args);
if (args.Allow)
{
allow = true;
break;
}
}
}
if (!allow)
{
socket.Disconnect();
return(false);
}
return(true);
}
private void ProcessFileReceive(AsynchronousSocket socket, byte[] encryptedMessage)
{
socket.WriteFileReceive(encryptedMessage);
BytesReceived += Socket.ReceiveBufferSize;
if (ReceivedFileBlock != null)
{
ReceivedFileBlock.Invoke(this, new EventArgs());
}
if (socket.FileBytesReceived >= encryptedFileSize)
{
isReceivingUpdate = false;
byte[] encryptedData = receiveStream.ToArray();
byte[] decryptedData = srpClient.Decrypt(encryptedData);
FileStream fileStream;
if (!File.Exists(UpdateFileLocation))
{
fileStream = new FileStream(UpdateFileLocation, FileMode.CreateNew, FileAccess.Write);
}
else
{
fileStream = new FileStream(UpdateFileLocation, FileMode.Truncate, FileAccess.Write);
}
fileStream.Write(decryptedData, 0, decryptedData.Length);
fileStream.Flush();
fileStream.Close();
socket.EndFileReceive();
FileInfo fileInfo = new FileInfo(UpdateFileLocation);
if (fileInfo.Length == UpdateFileSize)
{
wasUpdateCompleted = true;
}
socket.Disconnect();
}
}
private void ProcessDecryptedClientMessages(AsynchronousSocket socket, byte[] message)
{
string command = ASCIIEncoding.ASCII.GetString(message, 0, (message.Length > 128 ? 128 : message.Length));
OnDebug("Client Message \"" + SRP6.ArrayToString(message, 0, message.Length) + "\"");
if (command.StartsWith("SUBMIT_CRASH")) // Client wants to send us a crash report
{
OnDebug("Beginning submitting Crash Report");
string strMessage = SRP6.ArrayToString(message, 13, message.Length - 13);
string[] strTokens = strMessage.Split(' ');
try
{
crashReportSize = Convert.ToInt32(strTokens[0]);
}
catch { }
try
{
crashReportEncryptedSize = Convert.ToInt32(strTokens[1]);
}
catch { }
if ((crashReportSize > 0) && (crashReportEncryptedSize >= crashReportSize))
{
isReceivingCrashReport = true;
// We know what to expect now, send "PROCEED" message.
srpServer.EncryptAndSend(socket, "PROCEED");
}
else
{
OnDebug(
"Failed to get valid transfer information from the client");
}
}
else if (command.StartsWith("VERSION"))
{
srpServer.EncryptAndSend(socket, TemposVersionString);
}
else if (command.StartsWith("SEND"))
{
socket.SendStream = new FileStream(UpdateFileLocation, FileMode.Open, FileAccess.Read);
socket.EncryptedSendStream = srpServer.Encrypt(socket.SendStream);
srpServer.EncryptAndSend(socket, socket.SendStream.Length.ToString() + " " +
socket.EncryptedSendStream.Length.ToString());
}
else if (command.StartsWith("CONTINUE"))
{
if (socket.EncryptedSendStream != null)
{
socket.SendFile(socket.EncryptedSendStream);
}
}
else
{
socket.Disconnect();
OnDebug("Unhandled: " + command);
}
}
private void ServerReadyReceived(AsynchronousSocket socket)
{
byte[] message = SRP6.SubArray(
socket.ReceiveBuffer, 0,
socket.ReceiveBufferLength);
string strMessage = SRP6.ArrayToString(message, 0, message.Length);
// Server and client are now both ready for encrypted communications
if (strMessage.Equals("READY"))
{
OnDebug("Received \"READY\" from server");
step++;
if (Authenticated != null)
{
Authenticated.Invoke(this, new EventArgs());
}
if (crashReportOnly)
{
// Request to send a crash report to the server
OnDebug("Telling server we want to upload a crash report");
try
{
byte[] serializedObject = CrashException.SerializeObject();
socket.SendStream = new MemoryStream(serializedObject);
socket.EncryptedSendStream = srpClient.Encrypt(socket.SendStream);
srpClient.EncryptAndSend(socket, "SUBMIT_CRASH " +
socket.SendStream.Length + " " +
socket.EncryptedSendStream.Length);
}
catch (Exception ex)
{
OnDebug("Exception: " + ex.Message);
}
}
else
{
// Request the current version
OnDebug("Sending version-check request to server");
isCheckingVersion = true;
srpClient.EncryptAndSend(socket, "VERSION");
}
}
else
{
OnDebug("Authentication Failed");
socket.Disconnect();
}
}
private void DisconnectTimeoutStart(object obj)
{
AsynchronousSocket socket = obj as AsynchronousSocket;
DateTime startTime = DateTime.Now;
DateTime endTime = startTime + new TimeSpan(0, 0, 15);
while (DateTime.Now < endTime)
{
Thread.Sleep(1000);
}
if (socket.Step < 2) // Not authenticated
{
socket.Disconnect();
socket.Close();
}
}
void listenerSocket_ClientConnected(object sender, EventArgs e)
{
AsynchronousSocket socket = sender as AsynchronousSocket;
IPEndPoint endPoint = socket.TcpSocket.RemoteEndPoint as IPEndPoint;
OnDebug("Client Connected: (" + endPoint.Address + ")");
if (!IsClientPermitted(socket))
{
socket.Disconnect();
socket.Close();
return;
}
StartAuthenicationTimeOut(socket);
clients.Add(socket);
socket.Disconnected += new EventHandler(clientSocket_Disconnected);
socket.ReceiveCompleted += new EventHandler(clientSocket_ReceiveCompleted);
}
public void Stop()
{
// Give 30 seconds for clients to finish downloading
int retriesRemaining = 60;
while ((clients.Count > 0) && (retriesRemaining > 0))
{
Thread.Sleep(500);
retriesRemaining--;
}
foreach (object sock in clients)
{
AsynchronousSocket socket = sock as AsynchronousSocket;
socket.Disconnect();
}
clients.Clear();
listenerSocket.StopListening();
}
private void ProcessFileReceive(AsynchronousSocket socket, byte[] encryptedMessage)
{
socket.WriteFileReceive(encryptedMessage);
bytesReceived += socket.ReceiveBufferSize;
//if (ReceivedFileBlock != null)
// ReceivedFileBlock.Invoke(this, new EventArgs());
if (socket.FileBytesReceived >= crashReportEncryptedSize)
{
isReceivingCrashReport = false;
byte[] encryptedData = receiveStream.ToArray();
byte[] decryptedData = srpServer.Decrypt(encryptedData);
Exception ex = (Exception)decryptedData.DeserializeObject();
if (ReceivedCrashException != null)
{
ReceivedCrashException.Invoke(this, new ExceptionEventArgs(ex));
}
socket.EndFileReceive();
socket.Disconnect();
}
}
private void ProcessDecryptedServerMessages(AsynchronousSocket socket, byte[] message)
{
// Server is going to tell us the size of the update
if (isRequestingSend)
{
isRequestingSend = false;
string strMessage = SRP6.ArrayToString(message, 0, message.Length);
string[] strTokens = strMessage.Split(' ');
try
{
UpdateFileSize = Convert.ToInt32(strTokens[0]);
}
catch { }
try
{
encryptedFileSize = Convert.ToInt32(strTokens[1]);
}
catch { }
if ((UpdateFileSize > 0) && (encryptedFileSize >= UpdateFileSize))
{
isReceivingUpdate = true;
srpClient.EncryptAndSend(socket, "CONTINUE");
}
else
{
OnDebug("Bad transfer information sent from the server");
}
return;
}
{
string strMessage = SRP6.ArrayToString(message, 0, message.Length);
OnDebug("Server Message \"" + strMessage + "\"");
if (strMessage.Equals("PROCEED")) // CrashException != null
{
// Send the CrashException to the server (serialized)
OnDebug("Sending crash report to server");
srpClient.EncryptAndSend(socket, CrashException.SerializeObject());
}
}
if (isCheckingVersion)
{
isCheckingVersion = false;
string text = SRP6.ArrayToString(message, 0, message.Length);
OnDebug("Server reports that version is \"" + text + "\"");
Srp6ClientSocket.NewestUpdateVersion = text;
if (ReceivedVersion != null)
{
ReceivedVersion.Invoke(this, new EventArgs());
}
if (checkVersionOnly)
{
isCheckingVersion = false;
socket.Disconnect();
}
else
{
isRequestingSend = true;
srpClient.EncryptAndSend(socket, "SEND");
}
}
}
