Topic: Binary Baby Step Giant Step with lightweight database - Brute force (BSGS) (Read 522 times)

import secp256k1 as ice
from bitstring import BitArray

print("creating Baby Step")

# create baby step
num = 92233720368  # Keys number in Binary Babystep. same m in the search script
Low_m = 20
lm = num // Low_m
Add = 18446744073709551615
Add_pub = ice.scalar_multiplication(Add)

# Function to process a chunk and write to binary file
def process_and_write_chunk(start, end):
    res = ice.point_sequential_increment(end - start, Add_pub)

    # Ensure the length of res is a multiple of 65
    res_length = len(res)
    if res_length % 65 != 0:
        res = res[:-(res_length % 65)]

    binary = ''
    for t in range(start, end):
        h = res[t * 65 : (t + 1) * 65].hex()
        hc = int(h[2:], 16) if h else 0  # Handle the case when h is an empty string

        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 = BitArray(bin=binary)

    binary_file = open('baby_steps_binary.bin', 'ab')
    my_str.tofile(binary_file)
    binary_file.close()

# Process the remaining chunks with a smaller chunk size
chunk_size = 100000
for i in range(0, lm, chunk_size):
    print("stage: " + str(i // chunk_size + 1) + "/" + str((lm + chunk_size - 1) // chunk_size))
    end = min(i + chunk_size, lm)
    process_and_write_chunk(i, end)

#by mcdouglasx
import secp256k1 as ice
from bitstring import BitArray

print("creating Baby Step")


#create baby step

num = 2000000 # Keys number in Binary Babystep. same m in search script

Low_m= 20

lm= num // Low_m

Add = 1
Add_pub= ice.scalar_multiplication(Add)

res= ice.point_sequential_increment(lm, Add_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 = (BitArray(bin=binary))#bin=binary

binary_file = open('baby_steps__binary.bin', 'ab')
my_str.tofile(binary_file)
binary_file.close()

for i in range (1,Low_m):
    print("stage: "+ str(i+1)+"/"+str(20))
    
    lm_upub= ice.scalar_multiplication((lm*i))

    res= ice.point_sequential_increment(lm, lm_upub)

    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 = (BitArray(bin=binary))#bin=binary

    binary_file = open('baby_steps__binary.bin', 'ab')
    my_str.tofile(binary_file)
    binary_file.close()

#@author: iceland, modified by @mcdouglasx

import time
import random
import bit
import os
import math
import sys
import secp256k1 as ice
import numpy as np
from bitstring import BitArray


##Pk: 33185509 puzzle #30
Target = '03057fbea3a2623382628dde556b2a0698e32428d3cd225f3bd034dca82dd7455a'

bs_file = 'baby_steps__binary.bin'


start = 0
end =   33554431                                       


m = 2000000 # Keys number in Binary Babystep
Cm= 64


public_key = ice.pub2upub(Target).hex()
   

# =============================================================================

def pub2upub(pub_hex):
x = int(pub_hex[2:66],16)
if len(pub_hex) < 70:
y = bit.format.x_to_y(x, int(pub_hex[:2],16)%2)
else:
y = int(pub_hex[66:],16)
return bytes.fromhex('04'+ hex(x)[2:].zfill(64) + hex(y)[2:].zfill(64))

#find baby step file

valid = os.path.isfile(bs_file)
if valid == True:
    print('\nFound the Baby Steps Table file: '+bs_file+'. Will be used directly')
   
    file = bytes(np.fromfile(bs_file))

    baby_steps= BitArray(file)
       
if valid == False:
    print('\nNot Found '+bs_file+'. you must Create This File Now.' )


###############################################################################

st = time.time()
print('\n[+] Starting Program : Binary BSGS mode')

Q = pub2upub(public_key)


# We have to solve P = k.G, we know that k lies in the range ]k1,k2]
k1 = random.randint(start, end) # start from
k2 = k1 + m*m
print('Checking {0} keys from {1}'.format(m*m, k1))

k1G = ice.scalar_multiplication(k1)
mG = ice.scalar_multiplication(m)



st = time.time()

###############################################################################

def findkey(onePoint):
    S = ice.point_subtraction(Q, k1G)
   
    found = False
    step = 0
   
    while found is False and step<(1+k2-k1):
        Sx_1= ice.point_sequential_increment(Cm, S)
        binary = ''
       
        for t in range (Cm):

            h= (Sx_1[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))

               
       
        b = BitArray(bin=binary)           
        c = bytes(b)
        Sw =c
       
        if b in baby_steps:
            #
            s = c
            f = BitArray(baby_steps)
            inx = f.find(s)
            inx_1=str(inx).replace(",", "")
            inx_0=str(inx_1).replace("(", "")
            inx_2=str(inx_0).replace(")", "")
            b = int(inx_2)
            found = True
            break
        else:
            # Giant step
            S = ice.point_subtraction(S, mG)
            step = step + m
    if found == True:
        #print("k1:",k1)
        #print("step:",step)
        #print("b:",b)
       
        final_key = (k1 + step + b + 1)-1
       
    else:
        final_key = -1
    return final_key


final_key = findkey(Q)

if final_key >0:
    print("BSGS FOUND PrivateKey  :",str(final_key))
    data= open("win.txt", "a")
    data.write("private key = "+str(final_key)+"\n")
    data.write(str("Time Spent : {0:.2f} seconds".format(time.time()-st))+ "\n")
    data.close()
else:
    print('PrivateKey Not Found')


print(str("Time Spent : {0:.2f} seconds".format(time.time()-st)))