Search content
Sort by
Showing 20 of 69 results by iceland2k14
⭐ Merited by pbies (1)
I am getting:
Tried the same way you have posted here.
Code:
AttributeError: module 'secp256k1' has no attribute 'create_burn_address'
Tried the same way you have posted here.
Steps:
1. Git clone or download this to any Folder in your pc. https://github.com/iceland2k14/secp256k1
2. cd to same folder and then run python commands or scripts you desire. That will work.
The reason for failure is that you might have another library with the same name secp256k1 from some other repo.
Seems like yes, is there any python code to do that?
This library does not provide this function...
This library does not provide this function...
Why you said it. The library has already the wrapper defined for this purpose. You just need 2 lines of code in python3 for your purpose, nothing else.
Code:
>>> import secp256k1 as ice
>>> ice.create_burn_address('pbies', 'x')
'1pbiesxxxxxxxxxxxxxxxxxxxxxyWyYH7'
>>> ice.create_burn_address('pbies', 'x')
'1pbiesxxxxxxxxxxxxxxxxxxxxxyWyYH7'
If you want to know the inside implementation of how it is done, then here is the defined function from the file secp256k1.py which is responsible.
Code:
def create_burn_address(vanity = 'iceLand', filler = 'x'):
# create_burn_address('ADayWiLLcomeWheniceLandisGoingToSoLvebitCoinPuzzLe', 'X')
out = []
bs58 = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
for i in vanity:
if i not in bs58:
return "invalid char found in vanity --> : " + i
vanity = [vanity[i:i+25] for i in range(0,len(vanity),25)] # For longer text make many address
for t in vanity:
s = t.ljust(30, filler) if t[0] == '1' else ('1'+t).ljust(30, filler) + '111'
h = address_to_h160(s)
out.append(hash_to_address(0, True, bytes.fromhex(h)))
if len(out) == 1: return out[0]
else: return out
# create_burn_address('ADayWiLLcomeWheniceLandisGoingToSoLvebitCoinPuzzLe', 'X')
out = []
bs58 = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
for i in vanity:
if i not in bs58:
return "invalid char found in vanity --> : " + i
vanity = [vanity[i:i+25] for i in range(0,len(vanity),25)] # For longer text make many address
for t in vanity:
s = t.ljust(30, filler) if t[0] == '1' else ('1'+t).ljust(30, filler) + '111'
h = address_to_h160(s)
out.append(hash_to_address(0, True, bytes.fromhex(h)))
if len(out) == 1: return out[0]
else: return out
can I create a valid address (without private key and public key) with a specific string?
I mean python 3 here and maybe some brute-force method?
I mean python 3 here and maybe some brute-force method?
I think you are simply looking for something like this.
Code:
import secp256k1 as ice
ice.create_burn_address('ADayWiLLcomeWheniceLandisGoingToSoLvebitCoinPuzzLe', 'X')
ice.create_burn_address('ADayWiLLcomeWheniceLandisGoingToSoLvebitCoinPuzzLe', 'X')
Result :
Code:
['1ADayWiLLcomeWheniceLandisXXVF7Q3', '1GoingToSoLvebitCoinPuzzLeXXxuijG']
If the String is bigger you will get a list of address output. Otherwise it will be just 1 address. Example
Code:
ice.create_burn_address('iceLandxxxxxxBTC', 'Z')
'1iceLandxxxxxxBTCZZZZZZZZZZae8Au3'
'1iceLandxxxxxxBTCZZZZZZZZZZae8Au3'
Is that what you want ?
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
My question is whether, using the method and specifications that I'll describe, it's possible to write Python code to apply the given filters and perform the search?
400000000000000000 to 7FFFFFFFFFFFFFFFFF
........
Filtering Criteria:
We filter out all keys whose first four hexadecimal characters (prefixes) follow the pattern:
The first character is one of 4, 5, 6, or 7,
Followed by three identical hexadecimal digits (0-9, A-F).
Conclusion:
Applying this filtering criterion removes approximately 97.7% of all private keys within the specified range.
400000000000000000 to 7FFFFFFFFFFFFFFFFF
........
Filtering Criteria:
We filter out all keys whose first four hexadecimal characters (prefixes) follow the pattern:
The first character is one of 4, 5, 6, or 7,
Followed by three identical hexadecimal digits (0-9, A-F).
Conclusion:
Applying this filtering criterion removes approximately 97.7% of all private keys within the specified range.
Yes you have done a big Mistake.
For each 3 hex character after first digit (4,5,6,7) there are total 4096 possibilities. Out of which you are removing the identical chars (total 16). That leaves 4080 still valid keys after each starting digit. 4xxx, 5xxx, 6xxx, 7xxx
That means you have to still solve 99.61 % of the remaining keyspace. Congratulations to Reality.
Apart from pumping and dumping in altcoins there are just very few of them who could reach some significant price. Otherwise none seems to be reaching any closer to BTC.
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
As the search space is getting bigger and bigger each time we are moving up in the puzzle, there are more people inclined towards every kind of skip search, they can think of. Unless someone hit one of the puzzle using those skipping technique there will be always both crtisizm and appreciation. Deal with it.
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
Quite the opposite is true. saatoshi_rising himself explains that he did not hand-pick 256 separate keys, but used a deterministic wallet generator:
No matter how hard it is but this was a very tempting approach which i tried also a year ago https://github.com/iceland2k14/btc_words/blob/main/seed_puzzle.py. Off course as expected no success. Good for only playing and Dreaming of hitting all the Puzzles together in 1 shot.
Re: Ultra-Lightweight Database with Public Keys (for puzzle btc)
I would like to think about this Light Weight Database approach to see if that helps... (Later)
Currently without this and just using the BSGS script (15 MB Table) solves Puzzles #40 in 0.49 sec.
Result for Puzzle #45 is
For bigger puzzles lightweight strategy could help with iteration in primary collision and then secondary check for confirmation using the table.
Currently without this and just using the BSGS script (15 MB Table) solves Puzzles #40 in 0.49 sec.
Code:
import math
import time
import os
import secp256k1 as ice
# Main Script
if __name__ == "__main__":
# Puzzle Parameters
puzzle = 45
start_range = 2**(puzzle-1)
end_range = (2**puzzle) - 1
puzzle_pubkey = '026ecabd2d22fdb737be21975ce9a694e108eb94f3649c586cc7461c8abf5da71a'
P = ice.pub2upub(puzzle_pubkey)
# Precompute m and mP for BSGS
m = int(math.floor(math.sqrt(end_range - start_range)))
m = m * 20 # for use in bsgs_2nd
m_P = ice.scalar_multiplication(m)
m_Pn = ice.point_negation(m_P)
m2 = math.ceil((end_range - start_range)/m)
print(f'[+] m={m} m2={m2} Puzzle={puzzle}')
if os.path.isfile('baby_table.2nd') == False:
print(f'[+] Preparing for BSGS Table with {m} elements in RAM')
ice.bsgs_2nd_check_prepare(m)
ice.dump_bsgs_2nd('baby_table.2nd', True)
else:
ice.load_bsgs_2nd('baby_table.2nd', True)
# BSGS Search
print('[+] BSGS Search in progress')
st = time.time()
S = ice.point_subtraction(P, ice.scalar_multiplication(start_range))
found, pvk = ice.bsgs_2nd_check(S, 1)
if found == True:
k = start_range + int.from_bytes(pvk, 'big')
print(f'FOUND PrivateKey: {k:064x}')
print(f"[+] Time Spent : {time.time() - st:.2f} seconds")
exit()
ice.init_P2_Group(m_Pn) # Negative for P2_mcpu
SL = ice.point_sequential_increment_P2_mcpu(m2, S) # succesive decrement
found, pvk = ice.bsgs_2nd_check_mcpu(SL, 1)
if int.from_bytes(found, 'big') > 0:
elapsed = time.time() - st
for i in range(m2):
if found[i] == 1:
print(f'start=[0x{start_range:0x}] [i={i}] idx=0x{int.from_bytes(pvk[i*32:(i+1)*32], "big"):0x} ')
k = start_range + (i+1) * m + int.from_bytes(pvk[i*32:(i+1)*32], 'big')
print(f'FOUND PrivateKey: {k:064x}')
print(f"[+] Time Spent : {elapsed:.2f} seconds")
exit()
print('[+] Key not found')
print(f"[+] Time Spent : {time.time() - st:.2f} seconds")
import time
import os
import secp256k1 as ice
# Main Script
if __name__ == "__main__":
# Puzzle Parameters
puzzle = 45
start_range = 2**(puzzle-1)
end_range = (2**puzzle) - 1
puzzle_pubkey = '026ecabd2d22fdb737be21975ce9a694e108eb94f3649c586cc7461c8abf5da71a'
P = ice.pub2upub(puzzle_pubkey)
# Precompute m and mP for BSGS
m = int(math.floor(math.sqrt(end_range - start_range)))
m = m * 20 # for use in bsgs_2nd
m_P = ice.scalar_multiplication(m)
m_Pn = ice.point_negation(m_P)
m2 = math.ceil((end_range - start_range)/m)
print(f'[+] m={m} m2={m2} Puzzle={puzzle}')
if os.path.isfile('baby_table.2nd') == False:
print(f'[+] Preparing for BSGS Table with {m} elements in RAM')
ice.bsgs_2nd_check_prepare(m)
ice.dump_bsgs_2nd('baby_table.2nd', True)
else:
ice.load_bsgs_2nd('baby_table.2nd', True)
# BSGS Search
print('[+] BSGS Search in progress')
st = time.time()
S = ice.point_subtraction(P, ice.scalar_multiplication(start_range))
found, pvk = ice.bsgs_2nd_check(S, 1)
if found == True:
k = start_range + int.from_bytes(pvk, 'big')
print(f'FOUND PrivateKey: {k:064x}')
print(f"[+] Time Spent : {time.time() - st:.2f} seconds")
exit()
ice.init_P2_Group(m_Pn) # Negative for P2_mcpu
SL = ice.point_sequential_increment_P2_mcpu(m2, S) # succesive decrement
found, pvk = ice.bsgs_2nd_check_mcpu(SL, 1)
if int.from_bytes(found, 'big') > 0:
elapsed = time.time() - st
for i in range(m2):
if found[i] == 1:
print(f'start=[0x{start_range:0x}] [i={i}] idx=0x{int.from_bytes(pvk[i*32:(i+1)*32], "big"):0x} ')
k = start_range + (i+1) * m + int.from_bytes(pvk[i*32:(i+1)*32], 'big')
print(f'FOUND PrivateKey: {k:064x}')
print(f"[+] Time Spent : {elapsed:.2f} seconds")
exit()
print('[+] Key not found')
print(f"[+] Time Spent : {time.time() - st:.2f} seconds")
Result for Puzzle #45 is
Code:
python ULWD_bsgs.py
[+] m=83886060 m2=209716 Puzzle=45
[+] Preparing for BSGS Table with 83886060 elements in RAM
Calculating : 100 %
[+] [N2:4194500, N3:209725, N4:10486] Vec4th Size : 10486
[+] [bloom2nd (14 MB)] [bloom3rd (0 MB)] [bloom4th (0 MB)]
[+] BSGS Search in progress
start=[0x100000000000] [i=28660] idx=0x11cfb29
FOUND PrivateKey: 0000000000000000000000000000000000000000000000000000122fca143c05
[+] Time Spent : 2.80 seconds
[+] m=83886060 m2=209716 Puzzle=45
[+] Preparing for BSGS Table with 83886060 elements in RAM
Calculating : 100 %
[+] [N2:4194500, N3:209725, N4:10486] Vec4th Size : 10486
[+] [bloom2nd (14 MB)] [bloom3rd (0 MB)] [bloom4th (0 MB)]
[+] BSGS Search in progress
start=[0x100000000000] [i=28660] idx=0x11cfb29
FOUND PrivateKey: 0000000000000000000000000000000000000000000000000000122fca143c05
[+] Time Spent : 2.80 seconds
For bigger puzzles lightweight strategy could help with iteration in primary collision and then secondary check for confirmation using the table.
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
⭐ Merited by kTimesG (1)
This thread used to have so much of proper discussion, and now it's a pity to even look at this page.
Re: I found a method to reverse public keys to private keys
How is it different than Lattice Reduction method. Where for 200 bit Nonce we can solve using 7 or 8 Signatures.
Code:
Leakage: 5 bit. Sigs Needed:71
Leakage:10 bit. Sigs Needed:36
Leakage:15 bit. Sigs Needed:24
Leakage:20 bit. Sigs Needed:18
Leakage:25 bit. Sigs Needed:15
Leakage:30 bit. Sigs Needed:12
Leakage:56 bit. Sigs Needed:7
Leakage:10 bit. Sigs Needed:36
Leakage:15 bit. Sigs Needed:24
Leakage:20 bit. Sigs Needed:18
Leakage:25 bit. Sigs Needed:15
Leakage:30 bit. Sigs Needed:12
Leakage:56 bit. Sigs Needed:7
secp256k1 curve is
With the help of cuberoot of Unity, we can say that each value of Y there will be 3 values of X. (Endomorphism Points)
In a similar way For each X there will be 2 values of Y. (symmetry Points)
The relationships between them are well known and already used in various tools for faster scanning (example VanitySearch from JLP).
In a very simple way if you have a Pubkey points (x, y) you can get in total 6 pubkeys easily through
These points are related with the Generator through Privatekeys like this
Here the secp256k1 constants are
Code:
y² = x³ + 7
With the help of cuberoot of Unity, we can say that each value of Y there will be 3 values of X. (Endomorphism Points)
In a similar way For each X there will be 2 values of Y. (symmetry Points)
The relationships between them are well known and already used in various tools for faster scanning (example VanitySearch from JLP).
In a very simple way if you have a Pubkey points (x, y) you can get in total 6 pubkeys easily through
Code:
6 Pubkeys = [x,y] [x*beta%p, y] [x*beta2%p, y] [x,p-y] [x*beta%p, p-y] [x*beta2%p, p-y]
These points are related with the Generator through Privatekeys like this
Code:
6 Pvkeys = pvk, pvk*lmda%N, pvk*lmda2%N, N-pvk, N-pvk*lmda%N, N-pvk*lmda2%N
Here the secp256k1 constants are
Code:
p = 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f
N = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
# Constants Based on Cube root of 1
beta = 0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee
beta2 = 0x851695d49a83f8ef919bb86153cbcb16630fb68aed0a766a3ec693d68e6afa40 # beta*beta
lmda = 0x5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72
lmda2 = 0xac9c52b33fa3cf1f5ad9e3fd77ed9ba4a880b9fc8ec739c2e0cfc810b51283ce # lmda*lmda
N = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
# Constants Based on Cube root of 1
beta = 0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee
beta2 = 0x851695d49a83f8ef919bb86153cbcb16630fb68aed0a766a3ec693d68e6afa40 # beta*beta
lmda = 0x5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72
lmda2 = 0xac9c52b33fa3cf1f5ad9e3fd77ed9ba4a880b9fc8ec739c2e0cfc810b51283ce # lmda*lmda
Assume it's a placeholder for POC purpose.
https://github.com/iceland2k14/btc_words/blob/main/p2sh_brute.py
https://github.com/iceland2k14/btc_words/blob/main/p2sh_brute.py
Re: Determining the positivity or negativity of a Bitcoin public key
⭐ Merited by ABCbits (2)
This type of approach are often seen as an attempt to relate between the public key and (even/odd) privatekey in last few years.
You can make an experiment. Generate from 1 to 1billion all privatekeys, their corresponding publickey. Isolate them into 2 groups based on 02 or 03. Now try to relate this +/- pubkey observation to the PrivateKey. You will get nothing.
Otherwise anyone could have broken any 256 bit pubkey in just 256 loops of conditional division by 2 untill reach to 1.
You can make an experiment. Generate from 1 to 1billion all privatekeys, their corresponding publickey. Isolate them into 2 groups based on 02 or 03. Now try to relate this +/- pubkey observation to the PrivateKey. You will get nothing.
Otherwise anyone could have broken any 256 bit pubkey in just 256 loops of conditional division by 2 untill reach to 1.
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
I tried to recover the public key using the following python script, but it seems to have generated incorrect public key. I think I didn't understand how the 65-byte signature operates. Perhaps albert can explain in detail how to recover the public key from the signature? Thanks a lot.
Code:
>>> import secp256k1 as ice
>>> ice.verify_message('1BY8GQbBPGYEC58s9ckHmqf9doEX9mCKPR', 'H0J+wKAwGGMiVWHLuwEaZpLePkQAYx0HoTVvEZJu/wx3N6QYbUJMuajlj//yyjD7WLh42Ydlg+/vTJm50Td1LS0=', '15/01/2025 hotmoney')
>>> ice.verify_message('1BY8GQbBPGYEC58s9ckHmqf9doEX9mCKPR', 'H0J+wKAwGGMiVWHLuwEaZpLePkQAYx0HoTVvEZJu/wx3N6QYbUJMuajlj//yyjD7WLh42Ydlg+/vTJm50Td1LS0=', '15/01/2025 hotmoney')
Code:
Rpoint: 04427ec0a0301863225561cbbb011a6692de3e4400631d07a1356f11926eff0c77e31f0022894d9b6fdea00a252d803ef06bf9238b74e1eb7537e87a60c7684558
r : 427ec0a0301863225561cbbb011a6692de3e4400631d07a1356f11926eff0c77
s : 37a4186d424cb9a8e58ffff2ca30fb58b878d9876583efef4c99b9d137752d2d
z : 66c9d17af97088340e7894865731ad6e37642ab797ce58ecc650f351f5349f6
PubKey : 032145f843d3c91c3795a75da5ea46796070d18de51a7d0c0b68eb2f30162b169f
Address : 1BY8GQbBPGYEC58s9ckHmqf9doEX9mCKPR
signature is Valid and Address is Verified.
r : 427ec0a0301863225561cbbb011a6692de3e4400631d07a1356f11926eff0c77
s : 37a4186d424cb9a8e58ffff2ca30fb58b878d9876583efef4c99b9d137752d2d
z : 66c9d17af97088340e7894865731ad6e37642ab797ce58ecc650f351f5349f6
PubKey : 032145f843d3c91c3795a75da5ea46796070d18de51a7d0c0b68eb2f30162b169f
Address : 1BY8GQbBPGYEC58s9ckHmqf9doEX9mCKPR
signature is Valid and Address is Verified.
⭐ Merited by RetiredCoder (5)
Code:
import secp256k1 as ice
pub = '03C8F139DAD58B4786D3649992849733C2A7626F011089E87508CCDF8B0758C493'
lmda = 0x5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72
N = ice.N
G = ice.scalar_multiplication(1)
Q = ice.pub2upub(pub) # pvk
QE = ice.pub_endo1(Q) # pvk * lmda % N
QG = ice.point_subtraction( Q, G ) # pvk -1
if QG == QE: # pvk -1 = (pvk * lmda % N)
# pvk -1 = (pvk * lmda % N)
# pvk - pvk * lmda = 1 %N
# pvk (1 - lmda) = 1 %N
# pvk = 1 / (1 - lmda) %N
print(f'[+] PrivateKey: {hex(pow((1-lmda), N-2, N))}')
pub = '03C8F139DAD58B4786D3649992849733C2A7626F011089E87508CCDF8B0758C493'
lmda = 0x5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72
N = ice.N
G = ice.scalar_multiplication(1)
Q = ice.pub2upub(pub) # pvk
QE = ice.pub_endo1(Q) # pvk * lmda % N
QG = ice.point_subtraction( Q, G ) # pvk -1
if QG == QE: # pvk -1 = (pvk * lmda % N)
# pvk -1 = (pvk * lmda % N)
# pvk - pvk * lmda = 1 %N
# pvk (1 - lmda) = 1 %N
# pvk = 1 / (1 - lmda) %N
print(f'[+] PrivateKey: {hex(pow((1-lmda), N-2, N))}')
Code:
[+] PrivateKey: 0xc6768f199574104ae1b75eab82b0cc1d2d2e9ee7d50637a574e27131e9301552
I missed it indeed.
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
I still don't understand why people are searching for the Prefix 1BY8GQbnue . It does not give any advantage towards the full solution, no matter what anyone believes.