This possible scam wallet.dat  That file, is works but struck with a password, right?

Why owner file did not try to crack the password themself?

What collision did you mean?

How can we can fine half like this?


2**120
1329227995784915872903807060280344576

private key = 1329227995784915872903807060280344576

1329227995784915872903807060280344576 hex = 1000000000000000000000000000000

binary = 1000000000000000000000000000000000000000000000000000000000000000000000000000000 000000000000000000000000000000000000000000

Half binary first (60) = 100000000000000000000000000000000000000000000000000000000000

(hex) 800000000000000  = (dec) 576460752303423488

half of 1329227995784915872903807060280344576 is 576460752303423488

What is OP mean?

Did I understand correctly?

private key 2**256  (256 bit) will behave  2**96 address duplicate address
 order = 115792089237316195423570985008687907852837564279074904382605163141518161494337

but address = can have 2**160 = 1461501637330902918203684832716283019655932542976
some private key will get the same address?

What meaning is Half of any bitcoin?
Do you mean half of the public key right?
or
Did you mean half of the scalar to the private key right? or what?

Thank you albert0bsd
I will try to read and make understand

Did BSGS have code in python so I can read the code and run a test it to make understand?

Why do all programs/tools about bitcoin all-time download chrome browser warning to download and recommend deleting a file?
What algorithms or some code makes the browser check it and think can be harm the computer.
it happens with tools download from Github and open source code, bitcrack, kangaroo all get warning all-time download it.

Hi, albert0bsd

I would like to understand BSGS, Can you help to explain some methods? (I can study in detail more)
I understand kangaroos (a little some part) and understand some entropy or scalar for the Elliptic curve convert private key to public key
a lot of bitcoin and cryptography I do not yet understand clear

OK, I just think simple maybe calculate SHA-256 and RIPEMD160 it is maybe fast that Elliptic curve point calculate
I think with 1 step(value*G). it is calculated 256 times (loop) for each bit  maybe make full key brute-force slow

I think modmath.c it is not a division number by simple math
but modmath.c it is division by use function Elliptic curve  point division




try to use Elliptic curve  point division function on python
I am not sure I am correct, wait programmer/expert coder to help confirm

thank iceland2k14
I will try keyhunt

thank you sssergy2705

right, it is very hard to find with 256-bit number

I think all tools should be open-source code for transparent
it is dangerous to use tools not show code may use GPU for calculating some hidden when using it

for user
use all tools should block internet access on that tools before using or unplug wifi and use it offline

Yes, please
maybe puzzle 64-100 without pubkey can be useful to solve

free stye to code as you want or easy to code (with GPU)

problem with full calculate like bitcrack it is calculated puzzle#64 from first bit to bit 64  (or any bit 356) it uses to may loop over 200 to calculate double and add multiply, made it slow to brute-forcing

maybe someone can use this too found it (dot point trillion one percent possible)

my idea try to calculate sort can possible
1. random X
2. calculate Y from X
3. hash SHA-256
4. hash RIPEMD-160
5. check the match search

I am not sure I write step correct or not

With GPU calculate How many pubkey scans can do per minute?

option may be up to you code begins with easy first for open testing and then modify to option later
option
1. absolute random
2. random in the range
3. run number X (+1 next like bitcrack)

for check match RIPEMD-160 search
1. full match with "3EE4133D991F52FDF6A25C9834E0745AC74248A4"
2. vanity math like  "3EE4133D991F5"   (from 3EE4133D991F52FDF6A25C9834E0745AC74248A4)

Can any body help to create tools brute-forcing by using GPU NVidia from random Public ECDSA Key to RIPEMD-160 Hash and vanity search
RIPEMD-160 Hash
just test random idea to brute-forcing puzzle 64 and use kangaroo solve it ( I know it is not work, but would be test to know it sure to not work)

What is sach scrypt ?

Did you mean search script or  scrypt hash algorithms ?

Thank you I try 4 bit already, I use by command
python gen_data.py -f data1.json -m "HelloYou" -c SECP256R1 -b 4 -t MSB -n 50
python gen_data.py -f data1.json -m "HelloYou" -c SECP256R1 -b 4 -t LSB -n 50

I found some key lattice-attack can not be found the key. lattice-attack can not be found 100%

I think lattice-attack is not worked for solve puzzle

We are just users of lattice, just users use it
if lattice-attack it works I think many mathematics use it for

however, if using lattice-attack should be doing like use Kangaroo solve ECDSA need developer code and apply it a new one

I believe all methods on the internet that publish still can not use for solve puzzle #120
A better method is used generate a key to sample and create new one algorithm that can find key

I try to test with private key 120-bit script can fine 120-bit key (just modify the script random number from curve 256bit to random 120 bit)

if like to test with puzzle 120 how to implement to hash (z)

in the sample, file generate data.json have only R and S  and 8bit leak nonce
What is the data message at the end file on data.json

it is just for testing (possible not works)

this script it is the same of lattice-attack or not
https://asecuritysite.com/signatures/ecd
I see it is using LLL and reduction same
from sample how can expand the matrix to very large enough can search number
sorry I do not yet understand clear in math of lattice algorithms

I try to learn and understand math
Did I understand correctly?
this script method use leak nonce that generates to recover private key right?
script it not use way collect data from all data from signature with?
this lattice-attack use only one signature with leak 8-bit leak nonce to calculate correctly?
just loop search from 1000 signature until found one can calculate