public void TestMethod1()
{
byte[] encryptByteArray = encryptor.Encrypt(Encoding.ASCII.GetBytes("=zasxi10021824 ajfd 22s"));
string encryptStr = Base32Object.GetEncodeStrResult(encryptByteArray);
byte[] decryptByteArray = decryptor.Decrypt(encryptStr);
string decryptStr = Base32Object.GetDecodeStrResult(decryptByteArray);
Assert.AreEqual("=zasxi10021824 ajfd 22s", decryptStr);
}
public void DecryptedOutputStringMatchesInputString()
{
const string inputString = "Test String";
const string password = "******";
var encryptedString = encryptor.Encrypt(inputString, password);
var decryptedString = decryptor.Decrypt(encryptedString, password);
Assert.AreEqual(decryptedString, inputString);
}
public void binary_to_string()
{
string expected = "z";
string diffs = "01111010";
List <int> diff = new List <int>();
diffs.ToList().ForEach(x => diff.Add(int.Parse(x.ToString())));
string result = _decryptor.Decrypt(diff);
Assert.Equal(expected, result);
}
public TextModel Decrypt(TextModel input)
{
return(new TextModel()
{
Text = _decryptor.Decrypt(input.Text)
});
}
public void DecryptData(StateObject new_state, StateObject state, string sender, int count)
{
IntPtr output = IntPtr.Zero;
int output_size = 0;
try
{
int sender_flag = CLIENT;
if (sender.Equals("server"))
{
sender_flag = SERVER;
}
int ret = Decrypt.Decrypt(sender_flag, new_state.buffer, state.recvSize, count, ref output, ref output_size);
byte[] decrypted = new byte[output_size];
Marshal.Copy(output, decrypted, 0, output_size);
// if we allow modification, take the response data from our decryption dll.
if (modify.Equals(true))
{
Console.WriteLine("Modified data!");
Console.WriteLine("x: {0}", Encoding.ASCII.GetString(decrypted));
new_state.buffer = decrypted;
new_state.recvSize = output_size;
}
}
finally
{
if (output != IntPtr.Zero)
{
Marshal.FreeCoTaskMem(output);
}
}
}
private void Authenticate(byte[] packet)
{
var roomid = NumberConversionExtensions.MakeWord(packet[4], packet[5]);
var requestedRoom = this.manager.GetChatRoom(roomid);
if (requestedRoom == null)
{
Log.Error($"Requested room {roomid} has not been registered before.");
this.LogOff();
return;
}
TokenDecryptor.Decrypt(ref packet);
var tokenAsString = packet.ExtractString(TokenOffset, 10, Encoding.UTF8);
if (!uint.TryParse(tokenAsString, out uint _))
{
Log.Error($"Token '{tokenAsString}' is not a parseable integer.");
this.LogOff();
return;
}
this.AuthenticationToken = tokenAsString;
if (requestedRoom.TryJoin(this))
{
this.room = requestedRoom;
}
else
{
this.LogOff();
}
}
private byte[] ReadRawData(Stream stream, Entity entity)
{
stream.Seek(entity.OffsetRawBlock, SeekOrigin.Begin);
var buffer = stream.ReadBytes(entity.Size);
_decryptor.Decrypt(buffer, entity.DecryptIndexBlock);
return(buffer);
}
internal static T Decrypt <T>(Encrypted encrypted, IDecryptor decryptor)
{
var plaintext = decryptor.Decrypt(encrypted).ToUtf8();
try
{
return(JsonConvert.DeserializeObject <T>(plaintext));
}
catch (JsonException e)
{
throw new InternalErrorException("Failed to parse JSON", e);
}
}
public static AssetBundleArchive LoadAssetBundle(this ArchiveContainer container, string path, IDecryptor decryptor)
{
using (var fileStream = new FileStream(path, FileMode.Open, FileAccess.Read))
{
using (var stream = decryptor.Decrypt(fileStream))
{
AssetBundleArchive bundle = AssetBundleArchive.Load(stream);
bundle.Path = path;
container.AddBundleArchive(bundle);
return(bundle);
}
}
}
public int ProcessData()
{
int ret = SetDecryptor(decrypto.dll);
if (ret != 0)
{
return(ret);
}
if (decrypto.format.Equals("json"))
{
var output = new IntPtr();
var output_size = 0;
string sender = "";
reader = new JSONLogWriter();
reader.Open(decrypto.input, "r");
Transmissions trans = reader.ReadTransmission();
foreach (LogEvent e in trans.LogEventList)
{
try
{
if (e.sender == CLIENT)
{
sender = "client";
}
else
{
sender = "server";
}
Console.WriteLine("sender: {0} packet: {1} length: {2}", sender, e.count, e.data.Length);
Decrypt.Decrypt(e.sender, e.data, e.data.Length, e.count, ref output, ref output_size);
byte[] decrypted = new byte[output_size];
Marshal.Copy(output, decrypted, 0, output_size);
Console.WriteLine("\nAfter decrypt: {0}", Encoding.ASCII.GetString(decrypted));
Console.WriteLine("--------------------------------------");
if (writer != null)
{
writer.LogTransmission(decrypted, sender, e.count);
}
}
finally
{
if (output != IntPtr.Zero)
{
Marshal.FreeCoTaskMem(output);
}
}
}
}
return(0);
}
private void PacketReceived(byte[] packet)
{
if (packet.Length < 3 || packet[0] != 0xC1)
{
return;
}
this.LastActivity = DateTime.Now;
switch (packet[2])
{
case 0:
this.Authenticate(packet);
break;
case 1:
case 2:
case 3:
// We did never capture such packets, but they don't seem to be wrong (next is 4), so do nothing.
break;
case 4:
if (this.room != null && this.CheckMessage(packet))
{
MessageDecryptor.Decrypt(ref packet);
var message = packet.ExtractString(5, int.MaxValue, Encoding.UTF8);
if (Log.IsDebugEnabled)
{
Log.Debug($"Message reveived from {this.Index}: \"{message}\"");
}
this.room.SendMessage(this.Index, message);
}
break;
case 5:
// This is something like a keep-connection-alive packet.
// Last activity is always set, so we have to do nothing here.
Log.Debug("Keep-alive received");
break;
default:
Log.Error($"Received unknown packet of type {packet[2]}: {packet.AsString()}");
this.LogOff();
break;
}
}
public static Response <T> Read <T>(IDecryptor decryptor, NetMQMessage message)
{
// Frame 0: Message type
// Frame 1: Payload
Debug.Assert(message.FrameCount == 2);
var type = (MessageType)message.Pop().ConvertToInt32();
var payload = default(T);
if (!message.First.IsEmpty)
{
payload = JsonConvert.DeserializeObject <T>(decryptor.Decrypt(message.Pop().ToByteArray()));
}
return(new Response <T>(type, payload));
}
public static Int32 ReadInt32(
this IDecryptor decryptor,
Stream stream,
ulong cryptBlockIndex,
ref ulong nextCryptBlockIndex,
Endian endian
)
{
var buffer = stream.FillBuffer(4);
decryptor.Decrypt(buffer, cryptBlockIndex, ref nextCryptBlockIndex);
if (endian == Endian.Big)
{
Array.Reverse(buffer);
}
return(BitConverter.ToInt32(buffer, 0));
}
public static Request <T> Read <T>(IDecryptor decryptor, NetMQMessage message)
{
// Frame 0: RequesterID
// Frame 1: Empty
// Frame 2: Message type
// Frame 3: Payload
Debug.Assert(message.FrameCount == 4);
var requester = message.Pop().ToByteArray();
message.Pop(); // Empty frame
var type = (MessageType)message.Pop().ConvertToInt32();
var payload = default(T);
if (!message.First.IsEmpty)
{
payload = JsonConvert.DeserializeObject <T>(decryptor.Decrypt(message.Pop().ToByteArray()));
}
return(new Request <T>(requester, type, payload));
}
/// <summary>
/// Decrypts incoming data.
/// </summary>
public byte[] Decrypt(byte[] input)
{
return(decryptor.Decrypt(input));
}
public static INotifyModelDecrypted Decrypt(this INotifyModel notifyModel, IDecryptor <INotifyModel, IDecryptorOption, INotifyModelDecrypted> decryptor)
{
return(decryptor.Decrypt(notifyModel));
}
