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