public static Dictionary <int, byte[]> SearchFixup(ILogFileRecord record, byte[] data) { var offset_dict = new Dictionary <int, byte[]>(); var offset = record.SectorSize - 2; var fixup_value = record.Header.FixupValue; var count = 0; //start at 510, read 2 bytes, repeat every 512. for (int x = offset; x < data.Length; x += record.SectorSize) { if (ByteExtensions.CompareTo(data, record.Header.FixupValue, x)) { count += 1; var start = (x / offset - 1) << 1; var stop = (x / offset) << 1; offset_dict[x] = record.Header.FixupArray.SubBytes(x, 2); } else { LoggerService.WriteCallerLine($"'Data: {data.SubBytes(x,2).BytesToHexString()} at offset {x} is not fixup_value: {fixup_value}"); } } return(count == record.SectorAmount?offset_dict:null); }
/// <summary> /// Compares the peeked state and the previous state and fires events if the state has changed. /// This method calls method <see cref="PeekState"/> automatically if the state is not peeked. /// </summary> public void FetchState() { lock (_syncRoot) { if (_peekedState == null) { PeekState(); } byte[] newState = _peekedState; _peekedState = null; if (newState.SequenceEqual(_committedState)) { return; } byte[] oldState = GetState(); Array.Copy(newState, _state, _state.Length); Array.Copy(newState, _committedState, _committedState.Length); Log.Verbose("'" + Id + "' fetched different state (" + ByteExtensions.ToString(oldState) + "->" + ByteExtensions.ToString(newState) + ")."); StateChanged?.Invoke(this, new IOBoardStateChangedEventArgs(oldState, newState)); } }
public static byte[] Encode(List <NetworkAddress> addresses) { List <byte[]> addressData = new List <byte[]>(); foreach (var address in addresses) { switch (address.Type) { case AddressType.IpV4: addressData.Add(EncodeIpV4(address)); break; case AddressType.IpV6: addressData.Add(EncodeIpV6(address)); break; // TODO: support TOR // case AddressType.TorV2: // byte[] torv2 = new byte[12]; // torv2[0] = 2; // break; // case AddressType.TorV3: // byte[] torv3 = new byte[37]; // torv3[0] = 3; // addressData.Add(torv3); // break; } } return(ByteExtensions.Combine(addressData.ToArray())); }
internal static IDelegateCommand CreateCopyToCopyHexToCBoardCommand(IHexDataContext hexDataContext) { var copyHexToCBoardCommand = CommandFactory.CreateDelegateCommand( () => { if (hexDataContext.SelectionStart == -1 || hexDataContext.SelectionStart == -1) //若需剪切数据大于4GB { return; } if (hexDataContext.SelectionLength - hexDataContext.SelectionStart > MaxCopyToClipBoardSize) { MsgBoxService.Current?.Show(LanguageService.Current?.FindResourceString(Constants.MsgText_TooLargeCopySize)); return; } try { var buffer = hexDataContext.GetSelectionData(); ClipBoardService.SetText(ByteExtensions.BytesToHexString(buffer)); } catch (Exception ex) { LoggerService.WriteCallerLine(ex.Message); MsgBoxService.Current?.Show($"{ex.Message}"); } }); return(copyHexToCBoardCommand); }
private void FromMessage(byte[] msg) { int i = 4; byte first = msg[i]; if (first == (byte)PacketType.A2S_PLAYER) // Skip first byte if you haven't already. { first = msg[++i]; } this.NumPlayers = first; this.players = new List <IPlayer> (this.NumPlayers); for (int p = 0; p < this.NumPlayers; ++p) { var player = new SourcePlayer(); player.Index = msg[++i]; player.Name = ByteExtensions.GetString(msg, ++i, ref i); player.Score = ByteExtensions.GetInt32(msg, i, ref i); player.TimeConnected = ByteExtensions.GetSingle(msg, i, ref i); this.players.Add(player); } }
public byte[] GetBytes() { var properties = GetProperties(); var propertyData = new List <byte[]>(); int index = 0; ValidateProperties(properties); propertyData.Add(_messageDefinition.TypeId.GetBytesBigEndian()); foreach (var property in properties) { var definition = _messageDefinition.Properties[index]; if (definition.Type.VariableLength) { ushort length = (ushort)((ushort)property.Length / definition.Type.LengthPerProperty); propertyData.Add(ByteExtensions.Combine(length.GetBytesBigEndian(), property)); } else { if (property.Length != definition.Type.Length) { throw new ArgumentException("wrong property size"); } propertyData.Add(property); } index++; } return(ByteExtensions.Combine(propertyData.ToArray())); }
/// <summary> /// Extract the address family from the saddr /// </summary> /// <param name="saddrHexString">Saddr hex dump</param> /// <returns>LinuxAddressFamily type</returns> public static LinuxAddressFamily ExtractFamilyFromSaddr(string saddrHexString) { var bytes = ByteExtensions.GetBytesFromFromHexString(saddrHexString); int family = bytes[0]; return((LinuxAddressFamily)family); }
//private static int ConnectPacketSize = 8; //public static readonly int PacketSize = BasePacketSize + ConnectPacketSize; public ConnectPacket(byte[] data) : base(data) { RemoteIP = BitConverter.ToUInt32(ByteExtensions.SubBytes(data, 13, sizeof(uint))); RemotePort = BitConverter.ToUInt16(ByteExtensions.SubBytes(data, 17, sizeof(ushort))); GotYourData = data[19]; Finished = data[20]; }
/// <summary> /// NOTE: Code-generation-invoked method, method name and parameter order matters /// </summary> /// <param name="objectMayArray">value</param> /// <param name="granularity">granularity</param> /// <param name="serializers">serializers</param> /// <returns>hash</returns> public static int SerializeAndCRC32Hash( object objectMayArray, int granularity, Serializer[] serializers) { byte[] bytes; try { if (objectMayArray is object[]) { bytes = SerializerFactory.Serialize(serializers, (object[]) objectMayArray); } else { bytes = SerializerFactory.Serialize(serializers[0], objectMayArray); } } catch (IOException e) { Log.Error("Exception serializing parameters for computing consistent hash: " + e.Message, e); bytes = new byte[0]; } long value = ByteExtensions.GetCrc32(bytes); int result = (int) value % granularity; if (result >= 0) { return result; } return -result; }
public byte[] GetDataWithRealmAndHmac(byte[] nextHmac) { if (ShortChannelId.Length != 8) { throw new ArgumentException("invalid property size.", nameof(ShortChannelId)); } if (Padding.Length != 12) { throw new ArgumentException("invalid property size.", nameof(Padding)); } if (nextHmac.Length != 32) { throw new ArgumentException("invalid property size.", nameof(nextHmac)); } return(ByteExtensions.Combine( new[] { Realm }, ShortChannelId, AmountToForward.GetBytesBigEndian(), OutgoingCltvValue.GetBytesBigEndian(), Padding, nextHmac)); }
public void ModifyKeyAfterCompute() { // Rfc2202_7 var key = ByteExtensions.Repeat(0xaa, 80); var data = ByteExtensions.HexToByteArray("54657374205573696e67204c6172676572205468616e20426c6f636b2d53697a65204b657920616e64204c6172676572205468616e204f6e6520426c6f636b2d53697a652044617461"); // "Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data" var expectedHash = ByteExtensions.HexToByteArray("6f630fad67cda0ee1fb1f562db3aa53e"); var hmac = CreateHMACMD5(key); var actualHash = hmac.ComputeHash(data); Assert.Equal(expectedHash, actualHash); // Rfc2202_2: assign key smaller than block size key = ByteExtensions.HexToByteArray("4a656665"); // "Jefe"; data = ByteExtensions.HexToByteArray("7768617420646f2079612077616e7420666f72206e6f7468696e673f"); // "what do ya want for nothing?" expectedHash = ByteExtensions.HexToByteArray("750c783e6ab0b503eaa86e310a5db738"); hmac.Key = key; actualHash = hmac.ComputeHash(data); Assert.Equal(expectedHash, actualHash); // Rfc2202_7: assign key larger than block size key = ByteExtensions.Repeat(0xaa, 80); data = ByteExtensions.HexToByteArray("54657374205573696e67204c6172676572205468616e20426c6f636b2d53697a65204b657920616e64204c6172676572205468616e204f6e6520426c6f636b2d53697a652044617461"); // "Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data" expectedHash = ByteExtensions.HexToByteArray("6f630fad67cda0ee1fb1f562db3aa53e"); hmac.Key = key; actualHash = hmac.ComputeHash(data); Assert.Equal(expectedHash, actualHash); }
public override void Transform() { for (var i = 0; i < Length; i += ByteCount) { ByteExtensions.Swap(ref RgbBytes[i], ref RgbBytes[i + RedIndex]); } }
private void RemoteTimestamp(BlockchainProof proof) { var uri = _configuration.RemoteServer(); uri = uri.Append($"/api/timestamp/{proof.MerkleRoot.ConvertToBase64()}"); using (var client = new WebClient()) { var json = client.DownloadString(uri); if (!string.IsNullOrEmpty(json)) { var timestamp = JsonConvert.DeserializeObject <Timestamp>(json); if (timestamp.Proof != null) { if (timestamp.Proof.Confirmations > 0) { proof.Receipt = ByteExtensions.Combine(timestamp.Path, timestamp.Proof.Receipt); proof.Address = timestamp.Proof.Address; proof.Confirmations = timestamp.Proof.Confirmations; proof.Blockchain = timestamp.Proof.Blockchain; } } } } }
protected override void DealWithStringBuilder(StringBuilder sb, byte[] buffer) { sb.Append($"String sData =\"{ByteExtensions.BytesToString(buffer)}\";"); sb.AppendLine(); sb.Append($"String sDataHex =\"{ByteExtensions.BytesToHexString(buffer)}\";"); sb.AppendLine(); sb.AppendLine(); sb.Append("byte rawData[] = {"); sb.AppendLine(); sb.Append("\t"); var i = 0; foreach (byte b in buffer) { i++; sb.Append("(byte)"); if (i == 6) { i = 0; sb.AppendLine(); sb.Append("\t"); } } sb.AppendLine(); sb.Append("};"); }
/// <summary> /// 不通过对齐的方式搜索; /// </summary> /// <param name="stream"></param> /// <param name="setting"></param> /// <param name="reporter"></param> /// <returns></returns> private IEnumerable <(long index, long size)> SearchWithoutAlignment(Stream stream, ICustomSignSearchSetting setting, IProgressReporter reporter) { stream.Position = setting.SecStartLBA * setting.SectorSize; var pinLen = setting.KeyWord.Length; //获得标识长度; var readLen = 0; var keyWord = setting.KeyWord; var bufferLen = 1024 * 1024 * 4 + pinLen - 1; //缓冲区大小为预缓冲区大小+(pinLen - 1); var buffer = new byte[bufferLen]; long lastPosition = -1; long curOffset = 0; //将前pinLen - 1位 置为与Ke不等的数字,确保第一次循环时前几位不会影响结果; for (var i = 0; i < pinLen - 1; i++) { //对于pin[i],遍历所有字节,找到不满足的; for (byte j = 0; j < 0xff; j++) { //是否找到相等的结果; if (!keyWord.Any(p => p == j)) { buffer[i] = j; break; } } } while ((readLen = stream.Read(buffer, pinLen - 1, bufferLen - pinLen + 1)) != 0) { //轮询缓冲区pin剩余长度以后的内容; for (var i = 0; i < readLen; i++) { if (buffer[i] != keyWord[0]) { continue; } if (ByteExtensions.IsHeadSame(buffer, keyWord, pinLen - 1, i + 1, 1)) { if (lastPosition != -1) { yield return(lastPosition, curOffset + i - pinLen + 1 - lastPosition); } lastPosition = curOffset + i - pinLen + 1; i += pinLen; } } //后面未检索的几位向前推移至缓冲区首; Buffer.BlockCopy(buffer, readLen, buffer, 0, pinLen - 1); curOffset += readLen; reporter?.ReportProgress((int)(curOffset * 100 / stream.Length)); if (reporter?.CancelPending ?? false) { break; } } }
public InitPacket(byte[] data) : base(data) { PortType = data[13]; //02 ClientIndex = data[14]; //00 UseGamePort = data[15]; //00 LocalIp = BitConverter.ToUInt32(ByteExtensions.SubBytes(data, 16, sizeof(uint))); //00 - 00 - 00 - 00 LocalPort = BitConverter.ToUInt16(ByteExtensions.SubBytes(data, 20, sizeof(ushort))); //00 - 00 }
public void Rfc1321_3() { var data = ByteExtensions.HexToByteArray("616263"); // "abc" var expectedHash = ByteExtensions.HexToByteArray("900150983cd24fb0d6963f7d28e17f72"); var actualHash = _hashAlgorithm.ComputeHash(data); Assert.Equal(expectedHash, actualHash); }
public void Rfc1321_6() { var data = ByteExtensions.HexToByteArray("4142434445464748494a4b4c4d4e4f505152535455565758595a6162636465666768696a6b6c6d6e6f707172737475767778797a30313233343536373839"); // "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789" var expectedHash = ByteExtensions.HexToByteArray("d174ab98d277d9f5a5611c2c9f419d9f"); var actualHash = _hashAlgorithm.ComputeHash(data); Assert.Equal(expectedHash, actualHash); }
public void Rfc1321_5() { var data = ByteExtensions.HexToByteArray("6162636465666768696a6b6c6d6e6f707172737475767778797a"); // "abcdefghijklmnopqrstuvwxyz" var expectedHash = ByteExtensions.HexToByteArray("c3fcd3d76192e4007dfb496cca67e13b"); var actualHash = _hashAlgorithm.ComputeHash(data); Assert.Equal(expectedHash, actualHash); }
public void Rfc1321_7() { var data = ByteExtensions.HexToByteArray(StringExtensions.Repeat("31323334353637383930", 8)); // "1234567890" * 8 var expectedHash = ByteExtensions.HexToByteArray("57edf4a22be3c955ac49da2e2107b67a"); var actualHash = _hashAlgorithm.ComputeHash(data); Assert.Equal(expectedHash, actualHash); }
/// <summary> /// 加密指定的数据(文本,UTF8编码)。 /// </summary> /// <param name="text">需要加密的文本。</param> /// <param name="key">key。</param> /// <param name="vector">vector。</param> /// <returns>返回加密后的数据。</returns> public static string Encrypt(string text, string key, string vector) { if (string.IsNullOrEmpty(text)) { return(text); } byte[] array = Encrypt(System.Text.Encoding.UTF8.GetBytes(text), key, vector); return(ByteExtensions.ToHex(array));// System.BitConverter.ToString(array).Replace("-", ""); }
public void Rfc3174_1() { var data = ByteExtensions.HexToByteArray("616263"); // "abc" var expectedHash = ByteExtensions.HexToByteArray("A9993E364706816ABA3E25717850C26C9CD0D89D"); var actualHash = _hashAlgorithm.ComputeHash(data); Assert.Equal(expectedHash, actualHash); }
public override List <byte[]> GetProperties() { return(new List <byte[]> { ChannelId, Signature, ByteExtensions.Combine(HtlcSignatures.ToArray()) }); }
public void Rfc3174_3() { var data = ByteExtensions.HexToByteArray(StringExtensions.Repeat("61", 1000000)); // "a" * 1000000 var expectedHash = ByteExtensions.HexToByteArray("34AA973CD4C4DAA4F61EEB2BDBAD27316534016F"); var actualHash = _hashAlgorithm.ComputeHash(data); Assert.Equal(expectedHash, actualHash); }
public void Rfc3174_2() { var data = ByteExtensions.HexToByteArray("6162636462636465636465666465666765666768666768696768696a68696a6b696a6b6c6a6b6c6d6b6c6d6e6c6d6e6f6d6e6f706e6f7071"); // "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq" var expectedHash = ByteExtensions.HexToByteArray("84983E441C3BD26EBAAE4AA1F95129E5E54670F1"); var actualHash = _hashAlgorithm.ComputeHash(data); Assert.Equal(expectedHash, actualHash); }
public void Fips180_3() { var data = ByteExtensions.HexToByteArray(StringExtensions.Repeat("61", 1000000)); // "a" * 1000000 var expectedHash = ByteExtensions.HexToByteArray("cdc76e5c9914fb9281a1c7e284d73e67f1809a48a497200e046d39ccc7112cd0"); var actualHash = _hashAlgorithm.ComputeHash(data); Assert.Equal(expectedHash, actualHash); }
public void Fips180_2() { var data = ByteExtensions.HexToByteArray("6162636462636465636465666465666765666768666768696768696a68696a6b696a6b6c6a6b6c6d6b6c6d6e6c6d6e6f6d6e6f706e6f7071"); // "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq" var expectedHash = ByteExtensions.HexToByteArray("248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1"); var actualHash = _hashAlgorithm.ComputeHash(data); Assert.Equal(expectedHash, actualHash); }
public void Fips180_1() { var data = ByteExtensions.HexToByteArray("616263"); // "abc" var expectedHash = ByteExtensions.HexToByteArray("ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"); var actualHash = _hashAlgorithm.ComputeHash(data); Assert.Equal(expectedHash, actualHash); }
public void Rfc3174_4() { var data = ByteExtensions.HexToByteArray(StringExtensions.Repeat("3031323334353637", 8 * 10)); // "01234567" * (8*10) var expectedHash = ByteExtensions.HexToByteArray("DEA356A2CDDD90C7A7ECEDC5EBB563934F460452"); var actualHash = _hashAlgorithm.ComputeHash(data); Assert.Equal(expectedHash, actualHash); }
public void Rfc1321_4() { var data = ByteExtensions.HexToByteArray("6d65737361676520646967657374"); // "message digest" var expectedHash = ByteExtensions.HexToByteArray("f96b697d7cb7938d525a2f31aaf161d0"); var actualHash = _hashAlgorithm.ComputeHash(data); Assert.Equal(expectedHash, actualHash); }