public static UInt512 HmacSha512(this ReadOnlyByteSpan key, ReadOnlyByteSequence data) { var hash = new UInt512(); new HMACSHA512(key).TransformFinalBlock(data, hash.Span); return(hash); }
public static UInt256 Sha256(this ReadOnlyByteSpan data) { var hash = new UInt256(); Sha256(data, hash.Span); return(hash); }
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> /// Applies AES encryption to data with the specified key. /// iv can be specified (must be 16 bytes) or left null. /// The actual iv used is added to the first 16 bytes of the output result unless noIV = true. /// Padding is PKCS7. /// Mode is CBC. /// </summary> /// <param name="data">The data to encrypt.</param> /// <param name="key">The encryption key to use. The same key must be used to decrypt.</param> /// <param name="iv">null or 16 bytes of random initialization vector data</param> /// <param name="noInitVector">If true, the initialization vector used is not prepended to the encrypted result.</param> /// <returns>16 bytes of IV followed by encrypted data bytes.</returns> public static byte[] AesEncrypt(ReadOnlyByteSpan data, byte[] key, byte[] iv = null, bool noInitVector = false) { using var aes = new AesCryptoServiceProvider { Padding = PaddingMode.PKCS7, Mode = CipherMode.CBC, Key = key }; using var ms = new MemoryStream(); if (iv == null) { aes.GenerateIV(); iv = aes.IV; } else { aes.IV = iv; } if (!noInitVector) { ms.Write(iv); } using (var cs = new CryptoStream(ms, aes.CreateEncryptor(key, iv), CryptoStreamMode.Write)) { cs.Write(data); } return(ms.ToArray()); }
/// <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 ReadOnlyByteSpan data) { var hash = new UInt256(); data.Hash256(hash.Span); return(hash); }
public static UInt512 Sha512(this ReadOnlyByteSpan data) { var hash = new UInt512(); Sha512(data, hash.Span); return(hash); }
public static UInt160 Sha1(this ReadOnlyByteSpan data) { var hash = new UInt160(); Sha1(data, hash.Span); return(hash); }
public static UInt160 Ripemd160(this ReadOnlyByteSpan data) { var hash = new UInt160(); Ripemd160(data, hash.Span); return(hash); }
public static void TransformFinalBlock(this HashAlgorithm alg, ReadOnlyByteSpan data, ByteSpan hash) { var length = data.Length; var array = ArrayPool <byte> .Shared.Rent(Math.Min(MaxBufferSize, length)); try { var mOff = 0; do { var mLen = Math.Min(array.Length, data.Length - mOff); data.Slice(mOff, mLen).CopyTo(array); mOff += mLen; if (mOff < length) { alg.TransformBlock(array, 0, mLen, null, 0); } else { alg.TransformFinalBlock(array, 0, mLen); alg.Hash.CopyTo(hash); } }while (mOff < length); } finally { Array.Clear(array, 0, array.Length); ArrayPool <byte> .Shared.Return(array); } }
public static byte[] ComputeHash(this HashAlgorithm alg, ReadOnlyByteSpan buffer) { var hash = new byte[alg.HashSize]; alg.TransformFinalBlock(buffer, hash); return(hash); }
public static UInt256 HmacSha256(this ReadOnlyByteSpan key, ReadOnlyByteSpan data) { var hash = new UInt256(); new HMACSHA256(key).TransformFinalBlock(data, hash.Span); return(hash); }
/// <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> /// 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 ReadOnlyByteSpan data, ByteSpan hash) { var x = new UInt256(); using var sha = new SHA256Managed(); TransformFinalBlock(sha, data, x.Span); TransformFinalBlock(sha, x.Span, hash); }
/// <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); } }
public ScriptNum(ReadOnlyByteSpan bytes, bool fRequireMinimal = false, uint nMaximumSize = MaximumElementSize) : this() { if (bytes.Length > nMaximumSize) throw new OverflowError("script number overflow"); if (fRequireMinimal && !IsMinimallyEncoded(bytes, nMaximumSize)) throw new MinEncodeError("non-minimally encoded script number"); _value = set_vch(bytes); }
public void Decode(ReadOnlyByteSpan code) { Depth = code[0]; Fingerprint = BitConverter.ToInt32(code.Slice(1, 4)); Child = (uint)code[5] << 24 | (uint)code[6] << 16 | (uint)code[7] << 8 | code[8]; code.Slice(9, 32).CopyTo(ChainCode.Span); PublicKey = new PublicKey(); PublicKey.Set(code.Slice(41, 33)); }
public UInt160(ReadOnlyByteSpan span, bool reverse = false) : this() { if (span.Length < Length) { throw new ArgumentException($"{Length} bytes are required."); } span.Slice(0, Length).CopyTo(Span); if (reverse) { Span.Reverse(); } }
public override string Encode(ReadOnlyByteSpan bytes) { var s = new char[bytes.Length * 2]; var i = 0; foreach (var b in bytes) { var chs = ByteToChs[b]; s[i++] = chs[0]; s[i++] = chs[1]; } return(new string(s)); }
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> /// The complement function is PrivateKey CreateCompatSignature. /// </summary> /// <param name="hash"></param> /// <param name="sig"></param> /// <returns></returns> public bool RecoverCompact(UInt256 hash, ReadOnlyByteSpan sig) { var(ok, vch) = Secp256K1.PublicKeyRecoverCompact(hash.Span, sig); if (!ok) { Invalidate(); } else { _bytes = vch; } return(ok); }
/// <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); }
public Int64 set_vch(ReadOnlyByteSpan vch) { if (vch.Length == 0) return 0; Int64 result = 0; for (var i = 0; i < vch.Length; ++i) result |= ((Int64)vch[i]) << 8 * i; // If the input vector's most significant byte is 0x80, remove it from // the result's msb and return a negative. var last = vch.Length - 1; if ((vch[last] & 0x80) != 0) { return -((Int64)((UInt64)result & ~(0x80UL << (8 * last)))); } return result; }
public ExtPublicKey(ReadOnlyByteSpan code) { Decode(code); }
public void Decode(ReadOnlyByteSpan code) { Depth = code[0]; Fingerprint = BitConverter.ToInt32(code[1..5]);
public int BigEndianInt32(ReadOnlyByteSpan data) => BinaryPrimitives.ReadInt32BigEndian(data);
public int LittleEndianInt32(ReadOnlyByteSpan data) => BinaryPrimitives.ReadInt32LittleEndian(data);
public override string Encode(ReadOnlyByteSpan data) { return(BitConverter.IsLittleEndian ? System.Text.Encoding.Unicode.GetString(data) : System.Text.Encoding.BigEndianUnicode.GetString(data)); }