public static UInt160 Sha1(this ReadOnlyByteSequence data) { var hash = new UInt160(); Sha1(data, hash.Span); return(hash); }
public static void TransformBlock(this HashAlgorithm alg, ReadOnlyByteSequence data) { var length = data.Length; var array = ArrayPool <byte> .Shared.Rent((int)Math.Min(MaxBufferSize, length)); try { foreach (var m in data) { var mOff = 0; do { var mLen = Math.Min(array.Length, m.Length - mOff); m.Data.Span.Slice(mOff, mLen).CopyTo(array); mOff += mLen; alg.TransformBlock(array, 0, mLen, null, 0); } while (mOff < m.Length); } } finally { Array.Clear(array, 0, array.Length); ArrayPool <byte> .Shared.Return(array); } }
public static UInt160 Ripemd160(this ReadOnlyByteSequence data) { var h = new UInt160(); Ripemd160(data, h.Span); return(h); }
public static byte[] ComputeHash(this HashAlgorithm alg, ReadOnlyByteSequence buffer) { var hash = new byte[alg.HashSize]; alg.TransformFinalBlock(buffer, hash); return(hash); }
/// <summary> /// Computes double SHA256 of data: SHA256(SHA256(data)) /// </summary> /// <param name="data">Input: bytes to be hashed.</param> /// <returns>SHA256 of SHA256 of data.</returns> public static UInt256 Hash256(this ReadOnlyByteSequence data) { var h2 = new UInt256(); data.Hash256(h2.Span); return(h2); }
public static UInt256 Sha256(this ReadOnlyByteSequence data) { var hash = new UInt256(); Sha256(data, hash.Span); return(hash); }
public static UInt512 HmacSha512(this ReadOnlyByteSpan key, ReadOnlyByteSequence data) { var hash = new UInt512(); new HMACSHA512(key).TransformFinalBlock(data, hash.Span); return(hash); }
/// <summary> /// Computes double SHA256 of data: SHA256(SHA256(data)) /// </summary> /// <param name="data">Input: bytes to be hashed.</param> /// <param name="hash">Output: SHA256 of SHA256 of data.</param> public static void Hash256(this ReadOnlyByteSequence data, ByteSpan hash) { var h1 = new UInt256(); using var sha = new SHA256Managed(); TransformFinalBlock(sha, data, h1.Span); TransformFinalBlock(sha, h1.Span, hash); }
public static (bool ok, Script script) ParseHex(string rawScriptHex, bool withoutLength = false) { var bytes = rawScriptHex.HexToBytes(); var s = new Script(); var ros = new ReadOnlyByteSequence(bytes); var sr = new ByteSequenceReader(ros); return(s.TryReadScript(ref sr, withoutLength), s); }
public bool TryParseBlock(ref ReadOnlyByteSequence ros, int height, IBlockParser bp) { var r = new ByteSequenceReader(ros); if (!TryParseBlock(ref r, height, bp)) { return(false); } ros = ros.Data.Slice(r.Data.Consumed); return(true); }
public bool TryReadBlock(ref ReadOnlyByteSequence ros) { var r = new ByteSequenceReader(ros); if (!TryReadBlock(ref r)) { return(false); } ros = ros.Data.Slice(r.Data.Consumed); return(true); }
/// <summary> /// Check whether a signature is normalized (lower-S). /// </summary> /// <param name="vchSig"></param> /// <returns></returns> public static bool CheckLowS(ReadOnlyByteSequence vchSig) { var sig = new byte[64]; var input = (ReadOnlyByteSpan)vchSig; using var library = new Secp256k1(); if (!library.SignatureParseDerLax(sig, input)) { return(false); } return(!library.SignatureNormalize(Span <byte> .Empty, input)); }
public void TestRemoveSlice() { var a = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 }; var ros = new ReadOnlyByteSequence(a); Assert.Equal(new byte[] { 1, 2 }, ros.RemoveSlice(2, 12).ToArray()); Assert.Equal(new byte[] { 11, 12 }, ros.RemoveSlice(0, 10).ToArray()); Assert.Equal(new byte[] { 1, 12 }, ros.RemoveSlice(1, 11).ToArray()); var r1 = ros.RemoveSlice(1, 5); var r2 = r1.RemoveSlice(3, 7); Assert.Equal(new byte[] { 1, 6, 7, 12 }, r2.ToArray()); }
private static Block GetBlock(int height) { var bytes = GetBlockBytes(height); var kzb = new Block { Height = height }; var ros = new ReadOnlyByteSequence(bytes); var ok = kzb.TryReadBlock(ref ros); Assert.True(ros.Length == 0); Assert.True(ok); return(kzb); }
public bool TryReadTransaction(ref ReadOnlyByteSequence ros) { var r = new ByteSequenceReader(ros); if (!TryReadTransaction(ref r)) { goto fail; } ros = ros.Data.Slice(r.Data.Consumed); return(true); fail: return(false); }
public override string Encode(ReadOnlyByteSequence bytes) { var s = new char[bytes.Length * 2]; var i = 0; foreach (var m in bytes) { foreach (var b in m.Data.Span) { var chs = ByteToChs[b]; s[i++] = chs[0]; s[i++] = chs[1]; } } return(new string(s)); }
/// <summary> /// Return the Template String representation of script bytes. /// If the returned string does not include all the script opcodes, either because the scriptLen or limitLen /// arguments are greater than zero, or if the script sequence ends with an incomplete multi-byte opcode, /// then "..." is appended following the last complete opcode. /// /// scriptLen argument should be used when the actual script is longer than the script sequence provided, /// which must then be a subsequence from the start of the script. /// If greater than zero it may be longer than the sequence provided in which case "..." will be appended /// after the last opcode. /// /// limitLen argument stops converting opcodes to their template string format after processing this many bytes. /// </summary> /// <param name="script"></param> /// <param name="scriptLen">How long the entire script is, or zero.</param> /// <param name="limitLen">How many bytes to process, or zero.</param> /// <returns></returns> public static string ToTemplateString(ReadOnlyByteSequence script, long scriptLen = 0, long limitLen = 0) { var ros = script; if (limitLen == 0) { limitLen = long.MaxValue; } var ok = true; var count = 0L; var sb = new StringBuilder(); while (ros.Length > 0 && ok && limitLen > count) { var op = new Operand(); ok = op.TryReadOperand(ref ros, out var consumed); count += consumed; if (ok && limitLen >= count) { var len = op.Data.Length; sb.Append(len == 0 ? $"{op.CodeName} " : $"[{op.Data.Length}] "); } } if (sb.Length > 0) { sb.Length--; } if (scriptLen == 0) { scriptLen = count; } if (!ok || limitLen < count || count < scriptLen) { sb.Append("..."); } return(sb.ToString()); }
/// <summary> /// The checksum is a substring of the binary representation of the SHA256 hash of entropy. /// For every four bytes of entropy, one additional bit of the hash is used. /// </summary> /// <param name="entropy"></param> /// <returns></returns> private static string GetChecksum(ReadOnlyByteSequence entropy) { var hash = entropy.Sha256(); var bits = (int)entropy.Length * 8; var cs = bits / 32; var sb = new StringBuilder(); foreach (var b in hash.Span) { sb.Append(Convert.ToString(b, 2).PadLeft(8, '0')); cs -= 8; if (cs <= 0) { break; } } if (cs < 0) { sb.Length += cs; } return(sb.ToString()); }
private VarType() { _sequence = new ReadOnlyByteSequence(Array.Empty <byte>()); }
/// <summary> /// Encodes a sequence of bytes as a string./// /// </summary> /// <param name="data">Byte sequence to be encoded.</param> /// <returns></returns> public virtual string Encode(ReadOnlyByteSequence data) => Encode((ReadOnlyByteSpan)data);
public IBitcoinWriter Add(ReadOnlyByteSequence data) { _alg.TransformBlock(data.ToArray()); return(this); }
/// <summary> /// Computes RIPEMD160 of SHA256 of data: RIPEMD160(SHA256(data)) /// </summary> /// <param name="data">Input: bytes to be hashed.</param> /// <returns>KzHash160 RIPEMD160 of SHA256 of data.</returns> public static UInt160 Hash160(this ReadOnlyByteSequence data) { return(Ripemd160(Sha256(data).Span)); }
public override string Encode(ReadOnlyByteSequence data) => System.Text.Encoding.UTF8.GetString(data);
public static void HmacSha512(this ReadOnlyByteSpan key, ReadOnlyByteSequence data, ByteSpan hash) { new HMACSHA512(key).TransformFinalBlock(data, hash); }
/// <summary> /// Computes RIPEMD160 of SHA256 of data: RIPEMD160(SHA256(data)) /// </summary> /// <param name="data">Input: bytes to be hashed.</param> /// <param name="hash">Output: RIPEMD160 of SHA256 of data.</param> public static void Hash160(this ReadOnlyByteSequence data, ByteSpan hash) { var h = data.Sha256(); Ripemd160(h.Span, hash); }
public static void Ripemd160(this ReadOnlyByteSequence data, ByteSpan hash) { Ripemd.Ripemd160(data, hash); }
public VarType(ReadOnlyByteSequence data) { _sequence = data; }
public static string ToHexReverse(this ReadOnlyByteSequence data) => Encoders.Hex.Encode(data);
public static void Sha512(this ReadOnlyByteSequence data, ByteSpan hash) { using var sha = new SHA512Managed(); sha.TransformFinalBlock(data, hash); }
public IBitcoinWriter Add(ReadOnlyByteSequence data) { Length += data.Length; return(this); }