Creando una base de datos superligrera.Cuando trabajamos en los puzzles de BTC, pensamos de inmediato en la logica de que teniendo muchas keys en una base de datos aumenta nuestra probabilidad de exito, y esto es cierto.
pero luego nos topamos con que abarcan mucho espacio en disco.
les traigo esta posible solucion.
existe pubkeys pares o impares, y no existe un patron secuencial entre ellas por lo tanto se me ocurrio guardar en secuencia restando al target secuencias "x" cantidades de llaves.
solo que almacendo de manera binaria:
0=pubkey par,
1=pubkey impar.
eso nos permite reducir el espacio en disco de la base de datos a un bit por pubkey, para hacernos una idea 32 millones de pubkeys serian 3.81MB en disco(impresionante).
para esta base de datos necesitamos usar este script de python.
para una sola llave publica#@mcdouglasx
import secp256k1 as ice
from bitstring import BitArray
import bitcoin
print("Making Binary Data-Base")
target_public_key = "030d282cf2ff536d2c42f105d0b8588821a915dc3f9a05bd98bb23af67a2e92a5b"
target = ice.pub2upub(target_public_key)
num = 10000 # number of keys.
sustract= 1 #amount to subtract each time, If you modify this, use the same amount to scan.
Low_m= 10
lm= num // Low_m
print(lm)
sustract_pub= ice.scalar_multiplication(sustract)
res= ice.point_loop_subtraction(lm, target, sustract_pub)
binary = ''
for t in range (lm):
h= (res[t*65:t*65+65]).hex()
hc= int(h[2:], 16)
if str(hc).endswith(('0','2','4','6','8')):
A="0"
binary+= ''.join(str(A))
if str(hc).endswith(('1','3','5','7','9')):
A="1"
binary+= ''.join(str(A))
my_str = bytes(BitArray(bin=binary))
binary_file = open('data-base.bin', 'ab')
binary_file.write(my_str)
binary_file.close()
for i in range (1,Low_m):
lm_upub= sustract_pub= ice.scalar_multiplication((lm*i)*sustract)
A1= ice.point_subtraction(target, lm_upub)
sustract_pub= ice.scalar_multiplication(sustract)
res= ice.point_loop_subtraction(lm, A1, sustract_pub)
binary = ''
for t in range (lm):
h= (res[t*65:t*65+65]).hex()
hc= int(h[2:], 16)
if str(hc).endswith(('0','2','4','6','8')):
A="0"
binary+= ''.join(str(A))
if str(hc).endswith(('1','3','5','7','9')):
A="1"
binary+= ''.join(str(A))
my_str = bytes(BitArray(bin=binary))
binary_file = open('data-base.bin', 'ab')
binary_file.write(my_str)
binary_file.close()
Si desea crear una base de datos más larga de lo que admite tu memoria ram.
Por ejemplo, 1000 millones de claves y su límite de memoria es 100 millones, divida entre 10 cambiando esta variable:
debes usar numeros asi, sin residuos.
num = 10000000000000
Low_m= 10000
num = 20000000000000
Low_m= 2000
Evite hacer esto o encontrará claves privadas con los últimos números modificados.
num = 14678976447
Low_m= 23
lo hicimos!
Disponemos de una base de datos enorme, con poco espacio en disco.
Debido a que no existe una secuencia entre claves públicas pares e impares, podemos establecer un margen de colisión de 64, 128, 256...
Con esto quiero decir que a medida que aumenta el margen de colisión, la probabilidad de encontrar una secuencia binaria idéntica disminuye.
¿De qué sirve esto?Solo necesitamos generar secuencias binarias aleatoriamente y verificar si existen en la
base de datos.
buscando una sola clave pública#@mcdouglasx
import secp256k1 as ice
import random
from bitstring import BitArray
print("Scanning Binary Sequence")
#Pk: 1033162084
#cPub: 030d282cf2ff536d2c42f105d0b8588821a915dc3f9a05bd98bb23af67a2e92a5b
#range
start= 1033100000
end= 1033200000
while True:
pk= random.randint(start, end)
target = ice.scalar_multiplication(pk)
num = 64 # collision margin.
sustract= 1 # #amount to subtract each time.
sustract_pub= ice.scalar_multiplication(sustract)
res= ice.point_loop_subtraction(num, target, sustract_pub)
binary = ''
for t in range (num):
h= (res[t*65:t*65+65]).hex()
hc= int(h[2:], 16)
if str(hc).endswith(('0','2','4','6','8')):
A="0"
binary+= ''.join(str(A))
if str(hc).endswith(('1','3','5','7','9')):
A="1"
binary+= ''.join(str(A))
my_str = binary
b = bytes(BitArray(bin=my_str))
file = open("data-base.bin", "rb")
dat = bytes(file.read())
if b in dat:
s = b
f = dat
inx = f.find(s)*sustract
inx_0=inx
Pk = (int(pk) + int(inx_0))+int(inx_0)*7
data = open("win.txt","a")
data.write("Pk:"+" "+str(Pk)+"\n")
data.close()
break
tambien es posible, aunque la base de datos debe ser secuencial esto no implica que no se puedan guardar multiples pk.
ejemplo:si tenemos 10 targets y queremos una base de datos de 1.000.000.000 de pubkeys dividimos
base de datos/targets y cada target individualmente abarcara 100 millones de keys.
script en progreso, estoy corrigiendo unos detalles, pronto lo subire.
Este código es sólo una demostración que puede no estar optimizado correctamente, preferiblemente cree su propia versión en C.
No olvide decir gracias, para motivarme a contribuir con otras ideas.
