So any update on the progress of finding this key?
First offset = 03982a5a42895a5cfe4b9b98e49f9389ebf9b3bf91c2289f1c5db3d944f46ec710
Half of above =
0291001b0dc6e5a2628cb4698eb00a6fb7dbd276dc2b214795f2fe52e61243aa9b
Half of 130?
0337374e00a32eaf009e9946035c0e69085627b60a844637d2b958dd83bcfa4383
The following is the subtracted key from #130
Second offset =
03d99bb89e8db75d20b882f13f8086fb39221858fa211de0346c926a93ae259b3a
Half of above?
03a3dc00bf5f7e7eec691569c7f67a15d3cdbb3a9994c9a5ec1430cffdb622cf9f
Now subtract half of first offset from half of #130 to get half of second offset.
Second offset is known, we need to work on first offset's half, use -1 divide by 2 script to reduce 18 bits from it, you'll have millions of new offsets and one of them is the target, now divide the #130 range by 2, subtract 18 bits from it and use the new range as your search range, input those millions offset keys and search the range.
Don't just try blind searching.
Hi! Can you show me how you do it?, to remove on video. I can't understand how you make the -1 divide by 2 scenario, and how you get the millionth offsets.
Hi there, I can't make a video but here is the script you can use to reduce bits.
from sympy import mod_inverse
import secp256k1 as ice
pub=ice.pub2upub('Here Compressed Public Key')
N=0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
k=mod_inverse(2,N)
neg1=ice.point_negation(ice.scalar_multiplication(1))
def ters(Qx,Scalar):
ScalarBin = str(bin(Scalar))[2:]
le=len(ScalarBin)
for i in range (1,le+1):
if ScalarBin[le-i] == "0":
Qx=ice.point_multiplication(k,Qx)
else:
Qx=ice.point_addition(Qx,neg1)
Qx=ice.point_multiplication(k,Qx)
return ice.point_to_cpub(Qx)
for x in range(1,65536):
f= (ters(pub,x))
data= open(“halfpub.txt”,”a”)
data.write(f+”\n”)
data.close()
Note this is where you decide how many bits should be reduced
for x in range(1,65536):
For example reducing 26 bits requires 67108864 to be generated, 1 of them is the correct 26 bit reduced key.
My new software is for public keys, inspired by BSGS but a little different, using division and subtraction. Currently, I'm solving 35 bits in 3 seconds; this time is due to the delay in dividing a point. However, I believe that with the correct configuration, I will soon be able to break larger keys. I have some theories that have worked out very well in my tests, and I will be trying out more things to confirm.
For example, for a 35-bit key, I reduce the challenge #35 to 3 bits using my code. You input the public key and the 3-bit key '111,' and it returns 0x4aed21170, which is the equivalent private key of the public key.
key: 111
found: 00000000000000000000000000000000000000000000000000000004aed21170
Total time: 0 h, 0 m, 2 s
"111101" would be the key for #38.
key: 111101
found: 00000000000000000000000000000000000000000000000000000022382facd0
Total time: 0 h, 0 m, 13 s
Will you release for public to use?