public byte[] Encode(params dynamic[] values) { var stream = new MemoryStream(); if (values.Length == _definition.Inputs.Length) { try { var parameters = new AbiInputParameter[values.Length]; for (var index = 0; index < values.Length; index++) { parameters[index] = new AbiInputParameter(_definition.Inputs[index], values[index]); } stream.Append(_definition.Sha3Signature); stream.Append(AbiParameterCoder.EncodeParameter(parameters)); } catch { throw new ArgumentException("input values invalid"); } } else { throw new ArgumentException("values number not match"); } return(stream.ToArray()); }
/// <summary> /// Get parsed messages from FileZilla admin interface /// </summary> /// <returns></returns> public FileZillaMessage[] ReceiveMessages() { var data = Receive(); var list = new List <FileZillaMessage>(); using (var memoryStream = new MemoryStream()) { memoryStream.Append(data); using (var reader = new BinaryReader(memoryStream)) { while (reader.BaseStream.Position < reader.BaseStream.Length) { var b = reader.ReadByte(); var count = reader.ReadInt32(); while ((reader.BaseStream.Length - reader.BaseStream.Position) < count) { var buffer = Receive(); memoryStream.Append(buffer); } byte[] payload = reader.ReadBytes(count); var message = new FileZillaMessage((MessageOrigin)(b & 0x3), (MessageType)(b >> 2), payload, ProtocolVersion); list.Add(message); } } } return(list.ToArray()); }
public Stream Transform(Stream strm, Core.DataStore.IDataStore dataStore, object param) { var resultStream = new MemoryStream(); resultStream.Append(strm); resultStream.Append(dataStore.GetReadStream((string)param)); resultStream.Seek(0, SeekOrigin.Begin); return(resultStream); }
private static void EncodeList(MemoryStream buffer, List <object> input) { buffer.Append(ListStart); foreach (var item in input) { EncodeNextObject(buffer, item); } buffer.Append(ListEnd); }
public string CalculateIDWithUnsigned(string origin) { if (!SimpleWallet.IsValidAddress(origin)) { throw new ArgumentException("origin expected address"); } byte[] signingHash = this.SigningHash(); MemoryStream stream = new MemoryStream(); stream.Append(signingHash); stream.Append(origin.ToBytes()); return(Blake2b.CalculateHash(stream.ToArray()).ToHexString()); }
private static void EncodeDictionary(MemoryStream buffer, Dictionary <string, object> input) { buffer.Append(DictionaryStart); // we need to sort the keys by their raw bytes, not the string var sortedKeys = input.Keys.ToList().OrderBy(x => BitConverter.ToString(Encoding.UTF8.GetBytes(x))); foreach (var key in sortedKeys) { EncodeString(buffer, key); EncodeNextObject(buffer, input[key]); } buffer.Append(DictionaryEnd); }
public void WithValidIEnumerableArray_AppendBytes() { using (var stream = new MemoryStream(10)) { Assert.Throws <ArgumentNullException>(() => stream.Append(NullByteArray)); } }
public void WithNullBuffer_ThrowsArgumentNullException() { using (var stream = new MemoryStream(10)) { Assert.Throws <ArgumentNullException>(() => stream.Append(NullByteArray)); } }
/// <summary> /// Creates a test stream with a single way. /// </summary> /// <returns></returns> public static Stream GetWayTestStream() { var stream = new MemoryStream(); var way1 = new Way() { Id = 1, ChangeSetId = 1, TimeStamp = DateTime.Now, Tags = new TagsCollection(new Tag("name", "hu?")), Nodes = new long[] { 1, 2, 3 }, UserId = 1, UserName = "******", Version = 1, Visible = true }; stream.Append(way1); stream.Seek(0, SeekOrigin.Begin); return(stream); }
StringToBuf(string s, MemoryStream ms) { if (s == "") { return(LenSerial.Encode(0, ms)); } if (s == null) { return(LenSerial.EncodeNull(ms)); } byte[] b = Encoding.UTF8.GetBytes(s); if (b.LongLength > Int32.MaxValue) { throw new BufSeriaLenException("String to be encoded is too long."); } int lenBytes = LenSerial.Encode(b.Length, ms); ms.Append(b); return(lenBytes + b.Length); }
public void WithValidBytes_AppendBytes() { using (var stream = new MemoryStream(10)) { stream.Append(Bytes); Assert.AreEqual(Bytes.Length, stream.Length, "Get Append value"); } }
/// <summary> /// Adds a byte to the stream. /// </summary> /// /// <param name="stream"> MemoryStream where the byte is added. </param> /// <param name="b"> Byte to be added. </param> /// public static void Append(this MemoryStream stream, byte b) { Span <byte> span = stackalloc byte[1]; span[0] = b; stream.Append(span); }
public void AppendTest() { using (var stream = new MemoryStream(10)) { stream.Append(_bytes); Assert.AreEqual(_bytes.Length, stream.Length, "Get Append value"); } }
/// <summary> /// TP_Link TCP commands are pseudo-encrypted (obfuscated) /// </summary> /// <param name="s"></param> /// <returns></returns> static byte[] Encrypt(byte[] s) { MemoryStream stream = new MemoryStream(); stream.Append(0); stream.Append(0); stream.Append(0); stream.Append((byte)s.Length); var key = 171; foreach (var c1 in s) { var c2 = c1 ^ key; key = c2; stream.Append((byte)c2); } return(stream.ToArray()); }
public void AddVIP191Signature(byte[] senderSignature, byte[] gasPayerSignature) { if (senderSignature == null || senderSignature.Length != 65) { throw new ArgumentException("SenderSignature invalid"); } if (gasPayerSignature == null || gasPayerSignature.Length != 65) { throw new ArgumentException("GasPayerSignature invalid"); } MemoryStream stream = new MemoryStream(); stream.Append(senderSignature); stream.Append(gasPayerSignature); this.Signature = stream.ToArray(); }
UInt16ToBuf(ushort u, MemoryStream ms) { Span <byte> b = stackalloc byte[2]; b[0] = (byte)(u >> 0); b[1] = (byte)(u >> 8); ms.Append(b); return(b.Length); }
BytesToBuf(byte[] buf, MemoryStream ms) { if (buf == null) { LenSerial.EncodeNull(ms); return; } LenSerial.Encode(buf.Length, ms); ms.Append(buf); }
public void WithValidIEnumerable_AppendBytes() { IEnumerable <byte> enumerableByte = BitConverter.GetBytes(Value); using (var stream = new MemoryStream(10)) { stream.Append(enumerableByte); Assert.AreEqual(4, stream.Length, "Get Append value"); } }
public byte[] SigningHash(string delegateFor = "") { byte[] encode = RlpCode.Encode(Transaction.UnsignedRlpDefinition(), this.Body); byte[] hash = Blake2b.CalculateHash(encode); if (delegateFor.Length != 0) { if (SimpleWallet.IsValidAddress(delegateFor)) { MemoryStream stream = new MemoryStream(); stream.Append(hash); stream.Append(delegateFor.ToBytes()); return(Blake2b.CalculateHash(stream.ToArray())); } else { throw new ArgumentException("delegateFor expected address"); } } return(hash); }
Int32ToBuf(int i, MemoryStream ms) { Span <byte> b = stackalloc byte[4]; b[0] = (byte)(i >> 0); b[1] = (byte)(i >> 8); b[2] = (byte)(i >> 16); b[3] = (byte)(i >> 24); ms.Append(b); return(b.Length); }
Encode(int len, MemoryStream ms) { if (len < (int)EncodedLen.L16) { ms.Append((byte)len); return(1); } if (len <= ushort.MaxValue) { ms.Append((byte)EncodedLen.L16); Serial.UInt16ToBuf((ushort)len, ms); return(3); } ms.Append((byte)EncodedLen.L32); Serial.Int32ToBuf(len, ms); return(5); }
/// <summary> /// Message reader is almost equal as bytereader, but it does not return until a whole message is set /// </summary> /// <param name="packetReceived"></param> protected void StartMessageReaderAsync(Action <byte[]> packetReceived) { int BufferSize = sizeof(int); var commandBuilder = new MemoryStream(); var commandBuffer = new byte[BufferSize]; pipeStream.ReadAsync( commandBuffer, 0, commandBuffer.Length) .ContinueWith(rt => { if (rt.Result == 0) { Disconnect?.Invoke(this, EventArgs.Empty); return; } commandBuilder.Append(commandBuffer); while (!pipeStream.IsMessageComplete) { var length = pipeStream.Read( commandBuffer, 0, commandBuffer.Length); if (rt.Result == 0) { Disconnect?.Invoke(this, EventArgs.Empty); return; } commandBuilder.Append(commandBuffer, length); } //Return the message we received packetReceived(commandBuilder.ToArray()); StartMessageReaderAsync(packetReceived); }); }
/// <summary> /// TP_Link TCP responses are pseudo-encrypted (obfuscated) /// </summary> /// <param name="s"></param> /// <returns></returns> static byte[] Decrypt(byte[] s) { MemoryStream stream = new MemoryStream(); var key = 171; foreach (var c1 in s.Skip(4)) { var c2 = c1 ^ key; key = c1; stream.Append((byte)c2); } return(stream.ToArray()); }
private byte[] PrepareReaderSeRequest(byte[] package) { var requestStream = new MemoryStream(); requestStream.Append(_frameStart); var command = Helpers.StringToByteArray(CommandCode.RfPackage); requestStream.Append(command); var sLength = BitConverter.GetBytes((short)package.Length); //SLEN - Length of package requestStream.Append(sLength[1]); requestStream.Append(sLength[0]); var rLength = BitConverter.GetBytes((short)32); //RLEN - Estimated response length requestStream.Append(rLength[1]); requestStream.Append(rLength[0]); requestStream.Append(new byte[] { 10 }); // Timeout requestStream.Append(package); requestStream.Append(_frameStop); requestStream.Append(CalculateChecksum(requestStream.ToArray())); return(requestStream.ToArray()); }
private byte[] PrepareRequest(string command, string param = null) { var requestStream = new MemoryStream(); requestStream.Append(_frameStart); if (command != null) { var payload = Helpers.StringToByteArray(command); requestStream.Append(payload); } if (param != null) { var payload = Helpers.StringToByteArray(param); requestStream.Append(payload); } requestStream.Append(_frameStop); requestStream.Append(CalculateChecksum(requestStream.ToArray())); return(requestStream.ToArray()); }
Int64ToBuf(long l, MemoryStream ms) { Span <byte> b = stackalloc byte[8]; b[0] = (byte)(l >> 0); b[1] = (byte)(l >> 8); b[2] = (byte)(l >> 16); b[3] = (byte)(l >> 24); b[4] = (byte)(l >> 32); b[5] = (byte)(l >> 40); b[6] = (byte)(l >> 48); b[7] = (byte)(l >> 56); ms.Append(b); return(b.Length); }
CollectionToBuf <T>(ICollection <T> c, MemoryStream ms) where T : IBufSeriable { if (c == null) { Serial.Int32ToBuf(-1, ms); return; } int n = c.Count; Serial.Int32ToBuf(n, ms); foreach (var i in c) { ms.Append(i.Serialize()); } }
private string ReadUniqueIdentify() { MemoryStream ByteBuilder = new MemoryStream(); byte[] content = new byte[UNIQUELENGTH]; using (FileStream fs = File.Open(UNIQUE_PATH, FileMode.Open)) { int readed = 0; while ((readed = fs.Read(content, 0, UNIQUELENGTH)) > 0) { ByteBuilder.Append(content, readed); } } UTF8Encoding utf8 = new UTF8Encoding(true); string Unique = utf8.GetString(ByteBuilder.ToArray()); //md5 hash Unique = MessageDigest_Algorithm.getMd5Hash(Unique); return(Unique); }
/// <summary> /// Creates a test stream with a single relation. /// </summary> /// <returns></returns> public static Stream GetRelationTestStream() { var stream = new MemoryStream(); var relation1 = new Relation() { Id = 1, ChangeSetId = 1, TimeStamp = DateTime.Now, Tags = new TagsCollection(new Tag("name", "hu?")), Members = new RelationMember[] { new RelationMember() { Id = 1, Role = "node", Type = OsmGeoType.Node }, new RelationMember() { Id = 2, Role = "way", Type = OsmGeoType.Way }, new RelationMember() { Id = 3, Role = "relation", Type = OsmGeoType.Relation } }, UserId = 1, UserName = "******", Version = 1, Visible = true }; stream.Append(relation1); stream.Seek(0, SeekOrigin.Begin); return(stream); }
private byte[] PrepareReaderRequest(string command, string param = null) { var requestStream = new MemoryStream(); requestStream.Append(_frameStart); var payload = Helpers.StringToByteArray(command + param); var sLength = BitConverter.GetBytes((short)payload.Length); requestStream.Append(sLength[1]); requestStream.Append(sLength[0]); requestStream.Append(payload); requestStream.Append(_frameStop); requestStream.Append(CalculateChecksum(requestStream.ToArray())); return(requestStream.ToArray()); }
private void HandleRecv(byte[] data) { switch (state) { case SocketState.HANDSHAKING: // garbage collector will get rid of this, no need for Close() MemoryStream request = new MemoryStream(); // check response if (data[0] != GetVersion() && data[1] != 0) { // bad Close(); } request.Append(GetVersion()); // connect request.Append(1); // reserved request.Append(0); // dns or ipv4? switch (Uri.CheckHostName(hs.host)) { case UriHostNameType.Dns: request.Append(3); request.Append((byte)hs.host.Length); break; case UriHostNameType.IPv4: request.Append(1); break; default: // not supported Console.WriteLine("Neither DNS nor IPv4"); return; } request.Append(Encoding.ASCII.GetBytes(hs.host)); byte[] bPort = BitConverter.GetBytes((UInt16)hs.port); if (BitConverter.IsLittleEndian) { // network byte order is big endian Array.Reverse(bPort); } request.Append(bPort); byte[] buffer = request.ToArray(); state = SocketState.CONNECTING; Send(buffer); Receive(); break; case SocketState.CONNECTING: if (data[0] == 5 && data[1] == 0) { isConnected = true; state = SocketState.CONNECTED; // connect callback if (onConnectCallback != null) { onConnectCallback(this); } } else if(data[0] == 4 && data[1] == 0x5A) { isConnected = true; state = SocketState.CONNECTED; // connect callback if (onConnectCallback != null) { onConnectCallback(this); } } else { Close(); Console.WriteLine("Bad socks response while connecting"); } break; case SocketState.CONNECTED: // packets are from proxied host if (onReceiveCallback != null) { onReceiveCallback(this, data); } break; } }