private IPacketIn ReadPacket(IPacketIn packet)
{
try
{
byte[] buffer = ReadBuffer(packet.Length - _bufferSize);
if (_needToDecrypt)
{
if (_idBuffer == null)
{
//throw new Exception("InitialBuffer not provided for packet id " + packet.Id);
_idBuffer = ReadBuffer(8);
}
buffer = XTEA.Decrypt(buffer, Config.Pong);
byte[] newBuffer = new byte[_idBuffer.Length + buffer.Length];
_idBuffer.CopyTo(newBuffer, 0);
buffer.CopyTo(newBuffer, _idBuffer.Length);
buffer = newBuffer;
}
packet.ParseBuffer(buffer); //Length - buffer because of alread read data
_log.Packet("Read PacketID: " + packet.Id.ToString("X2"));
return(packet);
}
catch (Exception e)
{
_log.Error("Error with client: " + _ip + " Exception: " + e);
Drop("IOException: " + e.Message);
}
return(null);
}
internal bool IsGameAuthPacket(byte[] data)
{
if (data.Length != 56)
{
return(false);
}
data = XTEA.Decrypt(data, _pong);
return(data[0] == 0x6D);
}
/// <summary>
/// Processes received packet
/// </summary>
/// <param name="id"> Packet id or Packet initial buffer </param>
private void ProcessPacket(byte[] id)
{
if (_needToDecrypt)
{
id = XTEA.Decrypt(id, Config.Pong);
}
_idBuffer = id;
switch (id[0])
{
case (byte)InPackets.HandshakePacket:
_log.Packet("Received HandshakePacket");
ContinueHandshake();
break;
case (byte)InPackets.GameAuthorizationPacket:
_log.Packet("Received GameAuthorizationPacket");
VerifyAuth();
break;
case (byte)InPackets.CharacterCreatePacket:
_log.Packet("Received CharacterCreatePacket");
CreateCharacter();
break;
case (byte)InPackets.CharacterChoosePacket:
// TODO Code for map enter
_log.Packet("Received CharacterChoosePacket");
GameEnter();
break;
case (byte)InPackets.LauncherNamePacket:
_log.Packet("Received LauncherNamePacket.\nSooooo useful...");
break;
case (byte)InPackets.UnknownPacket1:
_log.Packet("Received UnknownPacket1.");
break;
default:
_log.PacketConsole("Unknown Packet ID: " + id[0]);
Drop("Unknown Packet ID " + id[0]);
break;
}
}
public string Download(string filename, string key, int alg, Download form)
{
try
{
StoredFile sf = svc.Download(Username, filename, Token);
byte[] f;
switch (alg)
{
case 0: f = DoubleTransposition.Decrypt(sf.data, key, sf.hash); break;
case 1: f = XTEA.Decrypt(sf.data, key, sf.hash); break;
default: throw new Exception("You have not chosen an algorithm.");
}
form.Save(filename, f);
return("File successfuly downloaded.");
}
catch (Exception e)
{
return(e.Message);
}
}
private void ProcessPacket(byte[] id)
{
if (_needToDecrypt)
{
id = XTEA.Decrypt(id, Config.Pong);
}
switch (id[0])
{
case (byte)InPackets.HandshakePacket:
ContinueHandshake();
break;
case (byte)InPackets.LoginPacket:
VerifyLogin(id);
break;
default:
Drop("Unknown Packet");
break;
}
}
internal void DecryptPacket()
{
if (Length % 8 == 0 || Length == MaxBuffer)
{
Crypted = true;
byte[] _key = new byte[16];
if (DestinationPort == _authPort || SourcePort == _authPort)
{
_key = _pong;
}
else if (DestinationPort == _gamePort)
{
if (IsGameAuthPacket(Data))
{
DecryptedData = XTEA.Decrypt(Data, _pong);
return;
}
if (XTEAKey1 == null)
{
UpdateKeys();
}
_key = XTEAKey1;
}
else if (SourcePort == _gamePort)
{
if (XTEAKey2 == null)
{
UpdateKeys();
}
_key = XTEAKey2;
}
else
{
return;
}
DecryptedData = XTEA.Decrypt(Data, _key);
Id = DecryptedData[0];
}
}
/// <summary>
/// If the user's credentials are stored in PlayerPrefs, this method will retrieve them.
/// </summary>
/// <param name="username">Contains the username if retrieval was successfull, empty string otherwise.</param>
/// <param name="token">Contains the token if retrieval was successfull, empty string otherwise.</param>
/// <returns>Whether retrieval was successfull or not.</returns>
public bool GetStoredUserCredentials(out string username, out string token)
{
username = token = "";
if (string.IsNullOrEmpty(UserCredentialsPreferences) || string.IsNullOrEmpty(Settings.EncryptionKey) ||
!PlayerPrefs.HasKey(UserCredentialsPreferences))
{
return(false);
}
var credentials = PlayerPrefs.GetString(UserCredentialsPreferences).Split('#');
if (credentials.Length != 2)
{
return(false);
}
try {
username = XTEA.Decrypt(credentials[0], Settings.EncryptionKey);
token = XTEA.Decrypt(credentials[1], Settings.EncryptionKey);
return(true);
} catch {
LogHelper.Warning("Failed to retrieve user credentials.");
return(false);
}
}
private void Download(System.ComponentModel.DoWorkEventArgs e)
{
// Initializing service proxy
var cloudProxy = new CloudServiceClient();
try
{
// Initializing client-side decryption
var clientCypher = new XTEA();
// Getting decryption key
clientCypher.SetKey(Encoding.ASCII.GetBytes(cloudProxy.GetKey()));
// Initializing stream from service
var length = cloudProxy.DownloadFile(ref _cloudFileName, out var inputStream);
// Write stream to disk
using (var writeStream = new FileStream(_localFilePath, FileMode.CreateNew, FileAccess.Write))
{
// Initializing buffer
var buffer = new byte[ChunkSize];
// Initializing boolean determining whether it's the last chunk
var lastChunk = false;
do
{
// Read bytes from input stream
var bytesRead = inputStream.Read(buffer, 0, ChunkSize);
if (bytesRead == 0)
{
break;
}
// Check if it is the last chunk
if (bytesRead < ChunkSize)
{
var temp = new byte[bytesRead];
Array.Copy(buffer, temp, bytesRead);
buffer = temp;
lastChunk = true;
}
// Decrypt data from the buffer
var decryptedBuffer = clientCypher.Decrypt(buffer);
// Write bytes to output stream
writeStream.Write(decryptedBuffer, 0, decryptedBuffer.Length);
// Update progress bar
if (lastChunk)
{
backgroundWorker.ReportProgress(100);
}
else
{
backgroundWorker.ReportProgress((int)(writeStream.Position * 100 / length));
}
// Check for cancellation
if (!backgroundWorker.CancellationPending)
{
continue;
}
e.Cancel = true;
inputStream.Dispose();
return;
} while (!lastChunk);
writeStream.Close();
}
// Deallocate stream
inputStream.Dispose();
}
catch (Exception exception)
{
throw new ArgumentException(exception.Message);
}
finally
{
// Close service proxy
cloudProxy.Close();
}
}
public void XTEABMPDecryption(FileInfo file, FormModel model)
{
bool threadSuccesfull = false;
var timeStarted = DateTime.Now;
try
{
if (!file.Extension.Contains("bmp"))
{
throw new Exception("File is not bmp!");
}
//OutputFileName
string outputFileName = "";
//Log
loggerController.Add(" ! File dec: " + file.Name + ", Alg: " + model.AlgorithmName);
//OutputFileName
outputFileName = FileNameCreator.CreateFileDecryptedName(
model.Folders.OutputFolder,
file.Name,
".bmp");
using (FileStream fsw = new FileStream(outputFileName, FileMode.Create))
{
using (BinaryWriter bw = new BinaryWriter(fsw, new ASCIIEncoding()))
{
//Reading and encrypting files
var readedValue = File.ReadAllBytes(file.FullName);
long pos = readedValue[10] + 256 * (readedValue[11] + 256 * (readedValue[12] + 256 * readedValue[13]));
byte[] header = new byte[pos];
for (int i = 0; i < header.Length; i++)
{
header[i] = readedValue[i];
}
byte[] data = readedValue.Skip(header.Length).ToArray();
var decryptedValue = XTEA.Decrypt(data);
decryptedValue = header.Concat(decryptedValue).ToArray();
bw.Write(decryptedValue);
if (LoadedFilesController._END_OF_ENC_DEC_THREADS)
{
bw.Dispose();
fsw.Dispose();
File.Delete(outputFileName);
Thread.CurrentThread.Abort();
}
}
}
threadSuccesfull = true;
Thread.Sleep(250);
}
catch (Exception ex)
{
loggerController.Add(" ? Dec exception: " + ex.Message);
threadSuccesfull = false;
}
finally
{
this.ThreadEnds(file, threadSuccesfull, timeStarted);
}
}
public void XTEADecryption(FileInfo file, FormModel model)
{
bool threadSuccesfull = false;
var timeStarted = DateTime.Now;
try
{
//OutputFileName
string outputFileName = "";
//Log
loggerController.Add(" ! File dec: " + file.Name + ", Alg: " + model.AlgorithmName);
//Reading the extension
var readedValues = File.ReadAllBytes(file.FullName);
int lenght = 0;
var extensionLength = (int)readedValues[0];
lenght++;
char[] extension = new char[extensionLength];
int j = 0;
for (var i = 1; i <= extensionLength; i++)
{
extension[j] = (char)readedValues[i];
j++;
lenght++;
}
var finalExtesnion = "." + new string(extension);
//OutputFileName
outputFileName = FileNameCreator.CreateFileDecryptedName(
model.Folders.OutputFolder,
file.Name,
finalExtesnion);
using (FileStream fsw = new FileStream(outputFileName, FileMode.Create))
{
using (BinaryWriter bw = new BinaryWriter(fsw, new ASCIIEncoding()))
{
//DEC
byte[] newValue = new byte[readedValues.Length - lenght];
int k = 0;
for (int i = lenght; i < readedValues.Length; i++)
{
newValue[k] = readedValues[i];
k++;
}
var decryptedValue = XTEA.Decrypt(newValue);
bw.Write(decryptedValue);
if (LoadedFilesController._END_OF_ENC_DEC_THREADS)
{
bw.Dispose();
fsw.Dispose();
File.Delete(outputFileName);
Thread.CurrentThread.Abort();
}
}
}
threadSuccesfull = true;
Thread.Sleep(250);
}
catch (Exception ex)
{
loggerController.Add(" ? Dec exception: " + ex.Message);
threadSuccesfull = false;
}
finally
{
this.ThreadEnds(file, threadSuccesfull, timeStarted);
}
}
