protected void SetData(ReadOnlyByteSpan version, ReadOnlyByteSpan data, bool flag = false) { _versionData = new byte[version.Length + data.Length + 1]; _versionLength = version.Length; version.CopyTo(Version); data.CopyTo(KeyData); KeyData.Data[^ 1] = (byte)(flag ? 1 : 0);
/// <summary> /// Duplicates Python hash library pbkdf2_hmac for hash_name = 'sha512' and dklen = None /// /// Performance can be improved by pre-computing _trans_36 and _trans_5c. /// Unlike Python's hash functions, .NET doesn't currently support copying state between blocks. /// This results in having to recompute hash of innerSeed and outerSeed on each iteration. /// </summary> /// <param name="password"></param> /// <param name="salt"></param> /// <param name="iterations"></param> /// <returns></returns> public static UInt512 PbKdf2HmacSha512(ReadOnlyByteSpan password, ReadOnlyByteSpan salt, int iterations) { if (iterations < 1) { throw new ArgumentException(); } byte[] passwordBytes = password; using var inner = new SHA512Managed(); using var outer = new SHA512Managed(); const int blocksize = 128; // match python hash library sha512 block size. if (passwordBytes.Length > blocksize) { inner.TransformFinalBlock(passwordBytes, 0, passwordBytes.Length); passwordBytes = inner.Hash; //inner.Initialize(); } if (passwordBytes.Length < blocksize) { Array.Resize(ref passwordBytes, blocksize); } var trans36 = new byte[256]; var trans5C = new byte[256]; for (var i = 0; i < 256; i++) { trans36[i] = (byte)(i ^ 0x36); trans5C[i] = (byte)(i ^ 0x5c); } var innerSeed = passwordBytes.Select(pb => trans36[pb]).ToArray(); var outerSeed = passwordBytes.Select(pb => trans5C[pb]).ToArray(); var hash = new UInt512(); var xhash = new UInt512(); var data = new byte[salt.Length + 4]; salt.CopyTo(data); 1.AsReadOnlySpan(bigEndian: true).CopyTo(data.AsSpan(salt.Length)); var dataSpan = data.AsSpan(); for (var i = 0; i < iterations; i++) { inner.TransformBlock(innerSeed); outer.TransformBlock(outerSeed); inner.TransformFinalBlock(dataSpan, hash.Span); outer.TransformFinalBlock(hash.Span, hash.Span); dataSpan = hash.Span; xhash = i == 0 ? hash : xhash ^ hash; } return(xhash); }
public string Encode(ReadOnlyByteSpan data1, ReadOnlyByteSpan data2) { var bytes = new byte[data1.Length + data2.Length].AsSpan(); data1.CopyTo(bytes); data2.CopyTo(bytes.Slice(data1.Length)); return(Encode(bytes)); }
/// <summary> /// Appends first 4 bytes of double SHA256 hash to bytes before standard Base58 encoding. /// </summary> /// <param name="bytes"></param> /// <returns></returns> public override string Encode(ReadOnlyByteSpan bytes) { var checksum = bytes.Hash256(); var buf = new byte[bytes.Length + 4]; bytes.CopyTo(buf); checksum.Span.Slice(0, 4).CopyTo(buf.AsSpan().Slice(bytes.Length)); return(Encoders.Base58.Encode(buf)); }
public PublicKey(ReadOnlyByteSpan bytes) : this() { if (bytes.Length > 0 && bytes.Length == PredictLength(bytes[0])) { _bytes = new byte[bytes.Length]; bytes.CopyTo(_bytes); } }
internal void Set(ReadOnlyByteSpan data, bool compressed = true) { if (data.Length != UInt256.Length || !Check(data)) { IsValid = false; } else { data.CopyTo(_keyData.Span); IsCompressed = compressed; IsValid = true; } }
public void Set(ReadOnlyByteSpan data) { var len = data.Length == 0 ? 0 : PredictLength(data[0]); if (len > 0 && len == data.Length) { _bytes = new byte[data.Length]; data.CopyTo(_bytes.AsSpan()); } else { Invalidate(); } }
/// <summary> /// Hash used to implement BIP 32 key derivations. /// </summary> /// <param name="chainCode"></param> /// <param name="nChild"></param> /// <param name="header"></param> /// <param name="data"></param> /// <param name="output">512 bit, 64 byte hash.</param> public static void Bip32Hash(UInt256 chainCode, uint nChild, byte header, ReadOnlyByteSpan data, ByteSpan output) { var len = data.Length; var buf = new byte[1 + len + 4]; // header, data, nChild var s = buf.AsSpan(); s[0] = header; data.CopyTo(s.Slice(1, len)); var num = s.Slice(1 + len, 4); num[0] = (byte)((nChild >> 24) & 0xFF); num[1] = (byte)((nChild >> 16) & 0xFF); num[2] = (byte)((nChild >> 8) & 0xFF); // ReSharper disable once ShiftExpressionRealShiftCountIsZero num[3] = (byte)((nChild >> 0) & 0xFF); HmacSha512(chainCode.Span, s, output); }