public static KzUInt512 SHA512(this ReadOnlySpan <byte> data) { var hash = new KzUInt512(); SHA512(data, hash.Span); return(hash); }
public static KzUInt512 HMACSHA512(this ReadOnlySpan <byte> key, ReadOnlySpan <byte> data) { var h = new KzUInt512(); new HMACSHA512(key.ToArray()).TransformFinalBlock(data, h.Span); return(h); }
public static KzUInt512 operator ^(KzUInt512 x, KzUInt512 y) { var r = new KzUInt512(); r.n0 = x.n0 ^ y.n0; r.n1 = x.n1 ^ y.n1; r.n2 = x.n2 ^ y.n2; r.n3 = x.n3 ^ y.n3; r.n4 = x.n4 ^ y.n4; r.n5 = x.n5 ^ y.n5; r.n6 = x.n6 ^ y.n6; r.n7 = x.n7 ^ y.n7; return(r); }
public IKzWriter Add(KzUInt512 v) { v.Span.CopyTo(Memory.Span.Slice(Length)); Length += 64; return(this); }
public IKzWriter Add(KzUInt512 v) { Length += 64; return(this); }
public IKzWriter Add(KzUInt512 v) { _alg.TransformBlock(v.ReadOnlySpan); return(this); }
public bool Equals(KzUInt512 o) => n0 == o.n0 && n1 == o.n1 && n2 == o.n2 && n3 == o.n3 && n4 == o.n4 && n5 == o.n5 && n6 == o.n6 && n7 == o.n7;
/// <summary> /// Sets this extended private key to be a master (depth 0) with the private key and chaincode set from the single 512 bit vout parameter. /// Master private key will be set to the first 256 bits. /// Chaincode will be set from the last 256 bits. /// </summary> /// <param name="vout">Master private key will be set to the first 256 bits. Chaincode will be set from the last 256 bits.</param> /// <param name="required">if not null, each key path will be verified as valid on the specified key or returns null.</param> /// <returns>Returns this key unless required key paths aren't valid for specified key.</returns> public KzExtPrivKey SetMaster(KzUInt512 vout, IEnumerable <KzKeyPath> required = null) { return(SetMaster(vout.ReadOnlySpan.Slice(0, 32).ToKzUInt256(), vout.ReadOnlySpan.Slice(32, 32).ToKzUInt256(), required)); }
/// <summary> /// Returns a new extended private key to be a master (depth 0) with the private key and chaincode set from the single 512 bit vout parameter. /// Master private key will be set to the first 256 bits. /// Chaincode will be set from the last 256 bits. /// </summary> /// <param name="vout">Master private key will be set to the first 256 bits. Chaincode will be set from the last 256 bits.</param> /// <param name="required">if not null, each key path will be verified as valid on the specified key or returns null.</param> /// <returns>Returns new key unless required key paths aren't valid for specified key in which case null is returned.</returns> public static KzExtPrivKey Master(KzUInt512 vout, IEnumerable <KzKeyPath> required = null) => new KzExtPrivKey().SetMaster(vout, required);
/// <summary> /// Duplicates Python hashlib's pbkdf2_hmac for hash_name = 'sha512' and dklen = None /// /// Performance can be improved by precomputing _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 KzUInt512 pbkdf2_hmac_sha512(ReadOnlySpan <byte> password, ReadOnlySpan <byte> salt, int iterations) { if (iterations < 1) { throw new ArgumentException(); } var _password = password.ToArray(); using var inner = new SHA512Managed(); using var outer = new SHA512Managed(); var blocksize = 128; // match python hashlib's sha512 blocksize. if (_password.Length > blocksize) { inner.TransformFinalBlock(_password, 0, _password.Length); _password = inner.Hash; //inner.Initialize(); } if (_password.Length < blocksize) { Array.Resize(ref _password, blocksize); } var _trans_36 = new byte[256]; var _trans_5c = new byte[256]; for (var i = 0; i < 256; i++) { _trans_36[i] = (byte)(i ^ 0x36); _trans_5c[i] = (byte)(i ^ 0x5c); } var innerSeed = _password.Select(pb => _trans_36[pb]).ToArray(); var outerSeed = _password.Select(pb => _trans_5c[pb]).ToArray(); var hash = new KzUInt512(); var xhash = new KzUInt512(); var data = new byte[salt.Length + 4]; salt.CopyTo(data); var loop = 1; loop.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); }