BitCrack - A tool for brute-forcing private keys

Quote from: NotATether on September 06, 2021, 10:55:01 AM

Quote from: a.a on September 05, 2021, 11:21:11 PM

Will we also see the sourcecode of those changes?

sp_ doesn't share the source code for his tools. Just see the last dozen or two pages before this one for another instance of that.

Well ...

He has been doing this for MANY years now, and manages to squeeze BTC out of almost everyone that messes with his 'private' binaries that are completely based on OpenSource Products.

If you go WAY back in his own thread, you will find multiple instances of him and Myself ripping into each other quite aggressively over such things. He NEVER plays fair, nor does he ever give a single shit about the people or uses of the software. Be VERY wary of him. Rune is known to be a ruthless purveyor tweaked software, not original coded software.

I learned this first hand in the very beginning when I helped with the testing when CWI had the largest GPU Farm in the Southern Hemisphere at the time.

Be VERY careful of his Malicious ways.

1% doesn't sound like much, but that was enough for him BACK THEN to make him a very rich man by tweaking other peoples Code (Namely Alexis78 - who was working with us at CWI at the time), compiling that OpenSource product after a tweak (usually a Hard Coded Intensity Setting) and distributing it as a 'Private Miner' based on Windows which he claimed was his.

As for BitCrack - this work will continue ... and it is good work so far!

#crysx

// https://github.com/ZenulAbidin/BitCrack-3000/blob/master/CudaKeySearchDevice/CudaKeySearchDevice.cpp line 112
   // Generate key pairs for k, k+1, k+2 ... k + <total points in parallel - 1>
   secp256k1::uint256 privKey = _startExponent;

   if(!_randomMode) {
   exponents.push_back(privKey);
   }
// ...
// Line 272
   if(!_randomMode) {
   offset = (secp256k1::uint256((uint64_t)_blocks * _threads * _pointsPerThread * _iterations) + privateKeyOffset) * _stride;
   privateKey = secp256k1::addModN(_startExponent, offset);
   } else {
   offset = secp256k1::uint256(_iterations) * _stride;
   privateKey = exponents[privateKeyOffset];
   privateKey = secp256k1::addModN(privateKey, offset);
   }

void CudaKeySearchDevice::generateStartingPoints()
{
...
if(!_randomMode) {
exponents.push_back(privKey);
}

for(uint64_t i = !_randomMode ? 1 : 0; i < totalPoints; i++) {

if(_randomMode) {
privKey = secp256k1::getRandomRange(_startExponent, _end);
} else {
privKey = privKey.add(_stride);
}
...
}
...
}

uint256 secp256k1::getRandomRange(uint256 min, uint256 max)
{
uint256 result;
uint256 range = max.sub(min);

unsigned char targetByteSize = (range.getBitRange() + 31) / 32;

for(int i = 0; i < 8; i++) {
if(targetByteSize > i) {
result.v[i] = rnd.getChunk();
if(targetByteSize > i && targetByteSize <= i + 1 && range.v[i] != 0 && result.v[i] > range.v[i]) {
result.v[i] %= range.v[i];
}
}
}
return result.add(min);
}