public PublicKey[] GetPublicKeys(BIP0032Path path, uint count, uint startIndex = 0, uint step = 1) { if (isDisposed) { throw new ObjectDisposedException(nameof(BIP0032)); } if (path is null) { throw new ArgumentNullException(nameof(path), "Path can not be null!"); } if (ExtendedKeyDepth == byte.MaxValue || ExtendedKeyDepth + path.Indexes.Length + 1 > byte.MaxValue) { throw new ArgumentOutOfRangeException(nameof(ExtendedKeyDepth), "Can not get children since " + "depth will be bigger than 1 byte"); } PublicKey[] result = new PublicKey[count]; if (!(PrvKey is null)) { PrivateKey[] tempPK = GetPrivateKeys(path, count, startIndex, step); for (int j = 0; j < tempPK.Length; j++) { result[j] = tempPK[j].ToPublicKey(); tempPK[j].Dispose(); } return(result); } // If we are here it means PrivateKey was null bool anyHardened = path.Indexes.Any(x => IsHardendedIndex(x)); if (anyHardened || IsHardendedIndex(startIndex)) { throw new ArgumentException(); } // Two quick fixes: if (count == 0) { return(null); } if (step < 1) { step = 1; } // First start deriving the extended keys for each index BigInteger prevPrvInt = PrvKey.ToBigInt(); byte[] prevPubBa = PubKey.ToByteArray(true); EllipticCurvePoint prevPubPoint = PubKey.ToPoint(); byte[] tempCC = ChainCode; byte[] tempLeft; EllipticCurveCalculator calc = new EllipticCurveCalculator(); foreach (var index in path.Indexes) { // There is no hardened indexes thanks to first check FastStream stream = new FastStream(33 + 4); stream.Write(prevPubBa); stream.WriteBigEndian(index); HmacAndSplitData(stream.ToByteArray(), tempCC, out tempLeft, out tempCC); BigInteger kTemp = tempLeft.ToBigInt(true, true); // Note that we throw an exception here if the values were invalid (highly unlikely) // because it is the extended keys, we can't skip anything here. if (kTemp == 0 || kTemp >= N) { throw new ArgumentException(); } EllipticCurvePoint pt = calc.AddChecked(calc.MultiplyByG(kTemp), prevPubPoint); PublicKey tempPub = new PublicKey(pt); prevPubPoint = tempPub.ToPoint(); prevPubBa = tempPub.ToByteArray(true); } // Then derive the actual keys int i = 0; uint childIndex = startIndex; while (i < count) { // There is no hardened indexes thanks to first check FastStream stream = new FastStream(33 + 4); stream.Write(prevPubBa); stream.WriteBigEndian(childIndex); HmacAndSplitData(stream.ToByteArray(), tempCC, out tempLeft, out _); BigInteger kTemp = tempLeft.ToBigInt(true, true); // Note: we don't throw any exceptions here. We simply ignore invalid values (highly unlikely) // and move on to the next index. The returned value will always be filled with expected number of items. if (kTemp == 0 || kTemp >= N) { continue; } EllipticCurvePoint pt = calc.AddChecked(calc.MultiplyByG(kTemp), prevPubPoint); PublicKey temp = new PublicKey(pt); result[i++] = temp; childIndex += step; } return(result); }
private unsafe bool LoopComp(string key, int missingCount, char missingChar, byte[] expectedHash) { int[] missingIndexes = new int[missingCount]; byte[] ba = new byte[32]; for (int i = 0, j = 0; i < ba.Length; i++) { int hi, lo; if (key[i * 2] == missingChar) { hi = 0; missingIndexes[j++] = i * 2; } else { hi = key[i * 2] - 65; hi = hi + 10 + ((hi >> 31) & 7); } if (key[i * 2 + 1] == '*') { lo = 0; missingIndexes[j++] = i * 2 + 1; } else { lo = key[i * 2 + 1] - 65; lo = lo + 10 + ((lo >> 31) & 7) & 0x0f; } ba[i] = (byte)(lo | hi << 4); } var cartesian = CartesianProduct.Create(Enumerable.Repeat(Enumerable.Range(0, 16), missingCount)); EllipticCurveCalculator calc = new EllipticCurveCalculator(); BigInteger smallVal = new BigInteger(ba, true, true); EllipticCurvePoint smallPub = calc.MultiplyByG(smallVal); Ripemd160Sha256 hash = new Ripemd160Sha256(); Parallel.ForEach(cartesian, (item, loopState) => { Span <byte> temp = new byte[32]; int mis = 0; foreach (int keyItem in item) { int misIndex = missingIndexes[mis]; if (misIndex % 2 == 0) { temp[misIndex / 2] |= (byte)(keyItem << 4); } else { temp[misIndex / 2] |= (byte)keyItem; } mis++; } BigInteger tempVal = new BigInteger(temp, true, true); EllipticCurvePoint tempPub = calc.MultiplyByG(tempVal); EllipticCurvePoint pub = calc.AddChecked(tempPub, smallPub); byte[] toHash = new byte[33]; toHash[0] = pub.Y.IsEven ? (byte)2 : (byte)3; byte[] xBytes = pub.X.ToByteArray(true, true); Buffer.BlockCopy(xBytes, 0, toHash, 33 - xBytes.Length, xBytes.Length); ReadOnlySpan <byte> actual = hash.ComputeHash(toHash); if (actual.SequenceEqual(expectedHash)) { char[] origHex = key.ToCharArray(); int index = 0; foreach (var keyItem in item) { origHex[missingIndexes[index++]] = GetHex(keyItem); } AddQueue($"Found a key: {new string(origHex)}"); loopState.Break(); } }); AddQueue("Failed to find any key."); return(false); }