Topic: Baby Step Giant Step Combined Efforts to Find 1.2 Bitcoin (Read 1930 times)

The program does not know, but there are MANY ranges to check. That's why a pool would need to be formed. The odds of same range being checked early in the search would be rare and even if, those numbers would be small.

Which version are you using?

Depends on which version I put out you are using. One version only searches for #120 subtracted range, the other version you could use for any wallet/range.
For #64 or #66, it cannot be used because we do not know the public key for those addresses.

Ok so I managed to run the program on multiple PCs, I have a couple of questions, I am not a pro programmer but trying to learn so please bear with me...

1) How does the program know NOT to search for ranges that someone else has already searched for? is it automated in the code to get previous searches from other users online? If so, does that mean that it would be a bad idea to run it on an air gapped PC?

2) I am currently running bat files: 10,17,18... would running them again after scan completion search for different ranges within 10 & 17 & 18 automatically?

3) Can I try my luck and use BSGS to search for other wallets' private keys (example: wallet #64 or #66)? If so can someone please Eli5 how to do it? (where to input other wallet's public key and how to set range?

I am learning python these days, dunno if that will help 

Start here, and read forward up til the last posts. It's all explained there with some examples.
But a quick answer to your questions, yes any range can be compressed. As many bits as you can print pubkeys and check for.
https://bitcointalk.org/index.php?topic=5244940.1900

Can you explain in more detail how to do this?
Any range can be compressed ?
How many bits can you compress?

Has anyone tried this program?
https://github.com/albertobsd/keyhunt
It also has an implementation of BSGS

problem BSGS it is using a lot of Memory RAM
my PC can not rung BSGS  (program not respond)

I got idea from Chia coin (mine hard disk)

it can possible make BSGS to write to harddisk replace using full memory?
ok may be make it slow than using all memory

How much RAM is needed to solve key #120, #125, and #130 with BSGS?

This is a super waste of time. The best-of-the-best of anything on GITHUB is jean-luc 'Kangaroo', but even that you must be within the search range of 2^40, but then on that range of a real-space of 2^256, your not even in right galaxy 1/2^216

You get one-at-a-time search hashes in python, what are you doing 100 keys/sec??

You have to program in C/C++, you have to know how to program GPU's;

BTC key-space is 2^256, that is 10^77, that is the number of electrons in the known universe; One at a time you could not even be looking in the right galaxy for your lost electron.

The way its done is to parallel search of all keys at once, all 300M bitcoin addresses, that way on every search cycle your looking all at once in one nano-second is this priv-key, is this hash in the bloom-filter abstracting 300M keys, yes or no. If it is, then you print out that key, and you have found a private-key to a real bitcoin address.

Running on RTX-3070 cards, I'm seeing 2500M keys/sec, but because I'm comparing 300M on each cycle, its really 100B keys/sec, even then with the birthday problem 2^128, I figure the odd's of hitting a high-value address is 1,000 days, I run a mining rack of 4 RTX-3070's, and I'm doing over 10,000M cycles/sec ( times 300M ). WHen I say 1,000 days. Which is once every 3 years.

Just a few years ago with GTX-1070 cards I was doing 200M keys/sec, with 4gb bloom-filters( 100M) bitcoin addresses.

There are only about 10k high-value addresses on bitcoin

There were at one time 1,000's of public-keys with high-value, but post 2013-ish they hashed the public-key, so their no longer available, note "Kangaroo' only works if you have a public-key. Note that the only priv-keys ever found were toy problems where they gave you an priv-key that was close to the 2^40 range

...

There are two ways you can hack, crack, or bust Bitcoin.

1.) Is by math, that means you know the public-key, you search for it; The fastest technique on earth to date is pollard-rho/lambda, aka now called kangaroo, but it only works on toy problems, the current is around 2^110

There are other ways to hack a public-key, such as endomorphisms, and pairing;  You can google these subjects; "ECDLP discrete log problem pariring/endomorphisms" read the papers.

I know this stuff is working, because two years ago here were 1,000's of BTC public-keys still with high-value ( pristine ), today there are less than 900, they get hacked about 10 / month; I spend about 1/2 my time on this activity so I'm up on what's being done

2.) The other way is hack is brute force, or just search the entire 2^256 space randomly; Which is what I'm talking about above with GPU test 10,000M priv-keys/sec, and look to see if the hashed address is in the 300M ( 64gb bloom ), if you get a hit, you still need to do a binary-search using 'xxd & sort -u', and binchk ( see original brainflayer for binchk ), that is 100% instant verification, the bloom-filter will always have some false positive, even 300M addresses in a 64gb bloom will find false postivies, the final binary-search lets you know that you a good key for sure.

...

If you say I don't know C/C++, or I can't program a GPU, then you really shouldn't even be playing this game.

If you don't have $10's of 1,000's of dollars for AMD 64thread-ripper cpus, and dozens of 4TB ram-drives, you shouldn't be in this game, your cpus must have 128GB of ram, and of course these days the RTX graphics cards are unavailable for any price

My feeling is the next generation graphics, will find keys in 100 days, as I'm seeing this stuff get faster 10x every 1-2 years, but you need to stay on top of the latest gen

...

Baby-step-giant-step is for toy problems, so people can learn about point-counting and simple elliptic-curve arithmetic

If you don't have the equivalent of a masters in math, then you will have a hard time exploring the type #1 hacking above, if you don't have lots of money, and cpu-gpu you'll have a hard time doing #2, and of course you must be able to do C/C++, and program gpus; the off the shelf stuff on GITHUB is 99% worthless; Like they say, if it worked they wouldn't be giving it away for free.

...

Some say "how often do you find keys", I would say once in a while 0.001 here, 0.05 there, I just put the private key into an CSV file, and then run checks to see if the money is still there in all cases, 1-2 years its gone, I have no long term keys that still have money

On checking adresses you must host a Bitcoin-NODE, and electrum-wallet server, so you can do your own checking, you can't be contacting the internet; So that's more computers.

I have GPU cards for years, been doing ML for years so I just redeployed stuff to bitcoin hacking, and of course you can mine, which is very profitable these days on ETH

Even little GTX-1060 cards, now 3gb is worthless on ETH, but I can use on algo #2 above and each card does 200M keys/sec ( * 300M); Just giving this so you can see difference,

...

I have no doubt that the last of the last public-keys will be hacked, I think most promising is pairing, finding a 'smart attack' prime close to the BTC prime, but of order N==P, then you convert that Elliptic-Curve maps directly to the finite-field; Very difficult to find these magic primes ( but it can be done ), but even here with the last of the last 900 public-keys of high value, we're able to search 900 at once, as well on each cycle, toss in a full 300M bloom-compare, so you can do a twofer 1&2 above.

WRT to targeting specific BTC address, so the ant-pool addresses that hold 10's of 1,000's of BTC, I think this would be impossible; Quantum Computers don't exist they're fictional at this point in time.

Can the NSA crack BTC? Yes I think so, this is where endomorphisms come in there are 1,000's; There is a backdoor to SECP256k1, otherwise NSA wouldn't have made it public.

The problem is how much time can person spend on this stuff, each area is like its own research; If it were easy to hack then you would be solving the ECDLP problem, which is worthy of a fields medal in math, lots of brilliant people work on this stuff, its like the Fermats Last Theorem

...

For you guys that want to do this stuff, I suggest if you don't the resources, just team up, and each do what they can do, don't try to go it alone, and I have attempted here to explain the state of art, and how difficult it right now,

This said, finding good keys every 1,000 days, if you have a mining farm, you could be finding good keys everyday, which is why I think 'inflection' has already passed, that hacking is more profitable than mining.

Lastly, for those that say Hacking BTC is bad, Nietzche said "That which kills bitcoin, makes it stronger", had BITCOIN-org made btc stronger and private years ago none of this would be possible

BITCOIN is designed become worthless in time, just like CBDC in China. Solution, hack the BITCOIN source pull out SHA256, and SECp256k1, an use SHA512, and a 1024 bit elliptic-curve that is un-breakable for the next 20+ years.

What about this article?

https://sefiks.com/2018/02/27/counting-points-on-elliptic-curves-over-finite-field/

What function for Baby Step Giant Step works on article?

I want to know How Baby Step Giant Step work and How Baby Step Giant Step calculate

https://github.com/JeanLucPons/BSGS

Did BSGS calculate private key by jump with Baby Step Giant Step algorithm?
I mean number 2**119 to 2**120
or
Did BSGS with point x (ECC) like kangaroo?

 

The input file contains, in line order:
the amount of memory to be used to fill baby steps
start range
end range
pubkey1
pubkey2
etc
etc

I was reading the python.  I'm an old programmer but not a python programmer.   What is the input.txt file? 

https://bitcointalksearch.org/topic/m.56500576

Hi,  yes I am using windows

If you are using Windows I can post a python and bat script here to help you get started.

I need some help with this. I would like to participate but when I go to github all I see is the exe ,  a readme and the ranges searched txt.   Is there supposed to some bat files?   how do I go about running the program to search for the keys?

In trying to find some old source code for a project I ran across some #120 ranges searched.

How to use this?  The ranges listed have been searched through for the #120 key and the key was not in the range.  I am only adding the ones starting with 8 because the list would be 8 times as big. So any range listed below has also been ran in the 9, A, B ,C, D, E, F ranges as well.

The list has been sorted so you can determine the ranges by looking at the top range (that is the start range) and the next range (that is the end range).

I have more ranges that I have searched and will upload/update the above list once found.

Link (list was to big to post here):

https://github.com/WanderingPhilosopher/BSGS/blob/main/Ranges_Searched1a.txt

BSGS gets through a smaller range faster and with 100% certainty that a key is or is not in the range.  Kangaroo can get through same range fast, but may keep going and going if key not found; BSGS stops and you know if key is there or not.

Bitcrack is designed to do something totally different. It is a mere brute force attack. So yes, if you do not know the public key, then you have to use a program like Bitcrack. But if you know the public key, Kangaroo and BSGS are 1 million times faster/better x Pi, than Bitcrack.

You can't really rank Kanga and BSGS with Bitcrack, they are different animals.
Pub key known and range above 64 bits, use kangaroo...64 and below, use BSGS.
Pub key not known, use Bitcrack or some other type of brute force program.

The only way to reduce keyspace is if pubkey is known, then you can do some basic ECDLP math to shrink the search range.

Unfortunately I am not programmer I can not code on C++

All tools is develop very good but still can work with low range low keyspace  and very large key space are still use time a lot

Do you think want to waiting a long time or scan all keyspace

I don't want to waiting more, I think should find the way predict or pick small key space and use tools for scan  may be better do scan all every thing

Baby Step Giant Step can found key on

at high range , wide keyspace BSGS still not work good, waiting a long time  (personal kangaroo feel work better)
compare ranking
1. Kangaroo
2. BitCrack
3. Baby Step Giant Step

Do you think you can try to look for a way to reduce keyspace search for kangaroo too?

Reference script BSGS
https://github.com/iceland2k14/bsgs
https://github.com/iceland2k14/bsgs/blob/main/bsgs_v4_gmp.py


I modify to hide message PVK not found.
and print S value is show X,Y and hex_line

What is hex_line value?

script generate large file baby_steps table for calculate
found key when meet hex_line on baby_steps table

I read baby step from
https://asecuritysite.com/encryption/baby

scripts make 1073741824 list babystep for multiply right
and when calculate use run with babystep

I think both script and BSGS.exe do the same right
https://github.com/JeanLucPons/BSGS
create large table hash table (25bit hash) to store the baby steps. 2^30 baby steps is about 9GB

still learning
not yet clear understand

now I try to looking way to reduce keyspace for search because high bits it is too much large area to search
if can fine right keyspace  may be helpful to working search

It took 12 seconds to run your test.

The settings I gave in older BSGS and the ones I gave in the new python script have been tried and tested and work best for the 56 bit random ranges. Yes, if you use a high baby step then it will take a long time to actually build the baby steps in RAM; if it is too low then it will either miss keys or it will take a long time for your giant steps to work through the range.

As stated, the BSGS is great at working through smaller ranges very quick and efficiently. Kangaroo is better at bigger ranges. But when one is working through random ranges, such as this thread was started upon, it's better to use BSGS because it tells you with 100% certainty if the key is in the range you are searching whereas kangaroo you will have to run over the expected group operations and even then it's still not 100% certain that key wasn't in the range searched.

some problem
BSGS.exe use a lot of RAM (memory) and harddisk (SSD still high writing)

I think should have table for calculate for user
like 8GB, 16GB, 32GB should be use limited how much each

I setup too high my memory 32GB still full and SSD hdd work 100% with writing something (may be swap memory)

good if have
table for babystep and wide range
and table for memory (ram) for fast work on memory without write to disk

I don't know how BSGS.exe works
but for fast work setting for limited and fit to can work only in memory is better.

I think I found problem

1. Setting baby step to low and too high
2. range too high

if baby step too low BSGS.exe  work slow  (I set 100 and try 1000 very slow)
if baby step too high BSGS.exe  work slow  (I set 1000000000 very slow)

range low BSGS.exe will work fast
range very high BSGS.exe will work slow

rand 1 to FFFFFFFFFFF  (low work fast)
rand 1 to FFFFFFFFFFFFFFFF  (too high work slow)
rand 8000000000000000 to  ffffffffffffffff (too high work slow)
rand 800000000000000000000000000000...ffffffffffffffffffffffffffffff (too high work slow)

I now sure may be need to calculate  range/babystep
to not high will work fast

I am not sure
request WanderingPhilospher help to calculate table of setting
or give file setting sample many file for ready to use testing


recommend using python scripts help to split rang and run  BSGS.exe
may be help better


Here if you try to use

Try using this test setting

How fast you pc/laptop run BSGS.exe 


Setting baba step = 1000000
Set rank = 1 to  fffffffffff


Command
BSGS.exe   test.txt
file = test.txt

Thank

I have problem with use BSGS JeanLucPons version
open program very long time to can find key

but you BSGS version (on bath file set version) work faster and can find key success
I try with in.txt new one file you version still work fine
but JeanLucPons not work fast , I try set baby step to both small side and large size still run problem , some time program fond key but before work open it very long time
test both small range and large rang

Here is the python script to automate the process (save it as Starter.py to run the automated process):


And here is the batch file I use to start the automation:

I have it set up to randomly generate a 56 bit range and then the BSGS checks it. Using 4 threads, it takes me under 2 minutes to run the range. If you plan on sharing/contributing the ranges you've scanned, please leave it at 56 bits (leave the y and Y1 alone in the python script). Also, if you want this to run with zero chances of missing the key, do not tinker with -t 0 or the baby step size of "4000000" . If you just want to use it for your own personal use, tweak any and everything. Enjoy![/code]

Everyone, I updated the github page. I published a new release.

https://github.com/WanderingPhilosopher/BSGS/releases/tag/V2.0

The only difference in this version and Jean Luc's original version is that my version will save a text file containing the public and private keys.  So it's back to searching the 120 bit range since the pub key shift seemed to cause confusion and now you can search your own range and pubkeys with this version. I plan on uploading a python script and batch file that will auto generate a random range and the batch file to search that random range.  The python script will also create a ranges checked file so that we can still share which ranges we have checked; so still can be a combined effort.

I also deleted all of the old exe files and batch files off the main page.  Python and batch starting script will be released soon...

There is no issue with Baby Step Giant Step. If you are searching smaller ranges or different ranges than what mine is programmed to do, use Jean Luc's version.

BSGS is great at finding keys in smaller ranges, extremely fast and with 100% guarantee if the key is in specified range or not. If you run a smaller range and don't find a key that you know is in that range, then your setting may be off.

If you get a warning, like this one (Warning, range is not a multiple of nbThread) when running BSGS, you may or may not find the key. Your settings have to be right. I can get that warning if I run a range of 1 to FFFFFFFFFF, but running range 0 to FFFFFFFFFF, I do not get that warning. I always make sure my ranges are of FFFFFFFFFF, FFFFFFFFFFF, or FFFFFFFFFFFF in size.

The baby step size also correlates to how much RAM you will use, so don't exceed what your PC has.

Also, if you run a big range, above 64 bits, BSGS will take time. If you look at Jean Luc's test, it was taking him 15 to 30 minutes to find keys in a 64 bit range, if you go above 64 bit, that time will increase, especially if using a small baby step setting.

I designed my program to be automated, meaning it automatically calculates correct settings, creates the input file, and generates a random range (one where the #120 can be found); and prints out key information if found. Mine is no better or faster than Jean Luc's, it's the same minus the items just mentioned.

test file for
https://github.com/WanderingPhilosopher/BSGS

file  83.txt  you can change start rank from 1 to any rank you want to test

83.txt use public key from puzzle all 83 key

found to 44 bit easy other start to take time


command


 83.txt

Thank you for update, I will try

For Baby Step Giant Step

I recommend to use BSGS  from WanderingPhilosopher mod
https://github.com/WanderingPhilosopher/BSGS

I test no problem

test with public key puzzle 83 key and found puzzle  1-44 easy and fast like both Kangaroo and bitcrack

result found on file
FOUNDKEYSFOUNDKEYSFOUNDKEYSFOUNDKEYSFOUNDKEYSFOUNDKEYSFOUNDKEYSFOUNDKEYSFOUNDKE YS.txt

Some problem with Baby Step Giant Step

Problem I do wrong setting (it make can not found any key) Waste of time a lot
seting Babystep size too large

I think all user use any tools should be study that tools and learn how to use
and creator should be give more detail how to use tools with example

I try use BSGS 1.1
https://github.com/JeanLucPons/BSGS

some detail BSGS not found key when using with small rank
I just testing BSGS , program it work or not

I using puzzle already solve with low keyspace (keyspace  begin not so far from private key) for can found very fast.

BSGS not found key
Kangaroo found key fast
bitcrack found key fast

may be BSGS skip rank until not found key
BSGS finish work when over rank setting

example test
find key #65
30568377312064202855
start key space 30568377312175202855
1A838B1350C502227

find key #115
31464123230573852164273674364426950
start key space 31464123230573852164273689364426950
60F4D11574F5DEEE49965577270C6

using Babystep size from sameple  = 40000000
result = not found key

I try reduce size Babystep size to 40000, 400
but still can not found key

other test
I try o test first 64 puzzle that found already
Babystep size = 4000

and start keyspace from 1 to 60F4D11574F5DEFE49961D9609AC6
and public key using from pluzzle 1 to 160 on file in.txt
result = not found key

test compare both Kangaroo found key and bitcrack found key


any advice and suggestion

Update...I will be releasing a newer version with different pubkeys/ranges.  It's meant for the combined effort of us, one of us, finding the key to #120. Like I said, not everyone has a GPU so this is a way to have a shot at #120 and split 1.2 bitcoins.

The new release will require around 10 minutes to run through 1 range (with CPU cores), but the overall range has been reduced from 120 bits to 107. I am running it on 3 machines to test overnight and will release in the next few days.

You can't add any flags to original BSGS to get an output file; it has to be hard coded. If I have time, I will code a version with an -o output flag. If you are using the original version, make sure you have "pause" as the last line in your batch file so you can capture key and pubkey. My version automatically prints it out.
The program that I released/this thread is about, has shifted pubkeys from the original #120 pubkey, meaning they are lower than the 120 bit range but if we find one, we can solve puzzle #120.

That is why I started this thread/put out the program. So that we all work on different ranges, at the same time

Hi, WanderingPhilospher

I think BSGS version WanderingPhilosopher is good one becuase when found private key BSGS1A.exe write output
https://github.com/WanderingPhilosopher/BSGS

FOUNDKEYSFOUNDKEYSFOUNDKEYSFOUNDKEYSFOUNDKEYSFOUNDKEYSFOUNDKEYSFOUNDKEYSFOUNDKE YS.txt


but BSGS.exe original
https[Suspicious link removed] original not have option write output to file

problem on test learn to use, I write batch file command and double click run batch
when complete console of batch file run gone with private key result
lucky this is test, if using on real and use time over 24 hour and found key, user will be start over new one again.

may be I don't know
How can use  BSGS.exe original write output?


and more
WanderingPhilospher, What is this pubkey looking for what?

you BSGS1A.exe is auto generate   Thread1AInput.txt  and contain what is this pubkey

1A67438673BE6097FF4C458F4184A7
04aa2de8d96f74cbd3c094f9070463f59d8ba306e6de72ff9c2d51c8c74f142628626168083ce7d 562a788ce8cb093c6a574a156e8099f7bacba4278de6b299a07
044aed9313f7441330905b2a9f444f8b1d425f704727e426c0c629a04594a5d67014a3827b9c030 44b5ea6b04d135a840007187d2450a4ba21d92e27020c1855f5
04040e4ed21a78299b9ba99b04b4b2d5b219b8aa196932c6041d27decd020f702b94eaf5fe70e57 0f0bc6d6a980af45cfa190683c47ec2a29b7c47ee125b22bfdd
048a90e42a0c7e50dcae58dfb52adf50f4e3658662ebbbbf82a169e3b4dcc7519f8e0b1a61ac774 225a1a9287e9b0cf0c71f290fb42352bdc198632e8a5b382324
043053e415c43f89b48f0e2760e199bcaaf902d37ff341b58a5be40f0d5c2739ea86a5992b670ca 7614b963b8eb1fcbb5f16d56e5bc84c8d73ada6c264fb8ae231
04bca13c6d47e7c936c9c7f2c0bae22a7d6dc0e252300f3c16581533708f26dcee405542db6d705 4b7a9cf6bf78b11647d8e3046dd5e2aefc3cd6f19827cff40a3
04423b85c770e23ad12507279c6e649a44185315c471162ca10c96efe5357719d0e7cfc5dcb4ea4 eca2affa451ec1a879cfa4222ab6eecb6af60ce4ecd59767a9b
041c4a77404fd16254286b0bc384f915a31a8d9e48892d4d2739147ab643ca9a38d51b1074dd432 5f757b8aeb67bdce08a7a78bce8c6052ccb9fe3d2c1c31b73a8

My small laptop have NVIDIA GeForce GT720M , it can not using GPU for calculate. laptop have CUDA but not high enough with support Nvidia CUDA Driver to can work GPU calculate

if you buy new one laptop recommend to buy gamming laptop and check GPU Nvidia that support to use CUDA, looking GTX 1050 up or higher, brand new generation Nvidia GPU may be fine

may be MSI cheap or ASUS try look meet with your budget

other way is external GPU try looking at eBay

I just know many people using GPU at cloud service, is great way to use GPU or CPU on demand.

actually I'm interested too, especially the prize 

but looking at the specs of my laptop an intel core i3, it looks like it will be tough doing the task.

thank you bigvito19

now it work fine

problem may be take time too long can't waiting for result LOL.

test with very low bit, all is ok
test with high bit, not have anything happen. (CPU run high)

if download from internet MS will be block with virus (harm you computer) it happen with many file on internet

I use method download to PC my VM not have antivirus  and copy to my PC.

try download to mobile phone and copy to you PC  (or transfer by Bluetooth)

(other try use wget command download)

may be other web browser like firefox opera can download it easy more than, just try

Microsoft found viruses in those files when I tried to download the BSGS11.exe

Yes, your setup is correct and you can use both compressed and uncompressed public keys.

Hi, WanderingPhilospher or anyone

reference with puzzle thread (update)
https://bitcointalksearch.org/topic/bitcoin-challenge-transaction-1000-btc-total-bounty-to-solvers-updated-5218972

should be setup in.txt like this right?

Done I do correct?

publickey can be use both compressed and uncompressed right?


in.txt
40000000
7FFFFFFFFFFFFFFFFFFFFFFFFFFFFF
FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE00
02CEB6CBBCDBDF5EF7150682150F4CE2C6F4807B349827DCDBDD1F2EFA885A2630
0233709EB11E0D4439A729F21C2C443DEDB727528229713F0065721BA8FA46F00E
03633CBE3EC02B9401C5EFFA144C5B4D22F87940259634858FC7E59B1C09937852
02145D2611C823A396EF6712CE0F712F09B9B4F3135E3E0AA3230FB9B6D08D1E16
031F6A332D3C5C4F2DE2378C012F429CD109BA07D69690C6C701B6BB87860D6640
03AFDDA497369E219A2C1C369954A930E4D3740968E5E4352475BCFFCE3140DAE5
03137807790EA7DC6E97901C2BC87411F45ED74A5629315C4E4B03A0A102250C49
035CD1854CAE45391CA4EC428CC7E6C7D9984424B954209A8EEA197B9E364C05F6
02E0A8B039282FAF6FE0FD769CFBC4B6B4CF8758BA68220EAC420E32B91DDFA673

Hi, i am new

Just try BSGS
https://github.com/JeanLucPons/BSGS

Done Baby Step Giant Step has any version python script work like BSGS?

May be 46

connecting to tests.
interesting idea
2 prots with 24 cores. see what happens.
how best to run? 48 processes?

yes identical if you have 4 you can use 3 bat files if you are not on that pc working, or 15 if you have 16cores.

if you think it is in one of the other ranges the bat files wich start with different starting points you want you choose.
good luck

Hello!  Dextronomous. Thanks for the answer. BSGS has multiple bat files. Run each one sequentially.? Or parallel to the core?

Hi there Elvis13,

you don't need screenshots just download the stuff from github, put it somewhere. after you select the bat files you want to run,
it will run by itself and show you information, let us know.

WanderingPhilospher! Please post screenshots of how to use your program. I'm ready to try.

hi wandering,

any would do good, 120th only down to or up to 160 no limits.

What pubkey and bits (better if exact range) are you looking to search for/

so new version is nice and not able to choose the pub key i want.

;could that be implemented, in the console asked for pubkey and bits,
something like that,

thanks again for your time,
happy new year 2021

Well, I mean that is your opinion. However, I do not believe Zielar has been running his machines for #120.

It's all about processing power...regardless of the method. More people have CPUs than GPUs. The more who run the program, the better the odds. Like I stated, BSGS allows us to give different ranges to workers without losing in complexity which is not possible with Kangaroo.

Also, the BSGS is faster in solving these subranges, and it provides 100 percent guarantee that a key doesn't lie in the range, whereas Kangaroo can run forever and still not be 100% sure a key is in a range.

I am also running a Kangaroo program with GPUs for #120. But this program gives another option for people. No one is forcing you PrivatePerson. Either run it or don't. Only guarantee I can give you is that if you don't run it (or another program) you have zero chances of finding #120.

If more than 500x Tesla V100 cannot solve 120 bits at the moment, then there is no point in trying to do it on processors.

A lot...jump in and help with the effort

I updated the programs, now there are 16, and added additional batch files for each program. They are located here:

https://github.com/WanderingPhilosopher/BSGS

Now, each program is designed to check a specific range.

Example, the BSGS1A program will only check ranges in the 1Axxxxxxxxxxxxxxxxxxxxxxxxxxxx range.

I also updated the random range generator so the duplicate ranges checked is small, as it now calls on specific computer functions to set the random generator. This is tested on Windows only, may not work on Linux.

How many ranges are there?

Estimated search time for each range, under 10 seconds, with 1 CPU thread. Search time for entire range, depends on how many people join the effort.

It's just another way to combine efforts to search for the #120 puzzle as mentioned above. I would like to have it hosted on server, with server client connect, like a mining pool, but I do not have that ability...yet.

The software is built off of JLP's BSGS program. The things I tweaked are stated above, the random and input file automation.

Estimated search time?
Closed-source software?
Only the author of the software can decrypt the result?

Sorry I have difficulties with translation, so I didn't understand everything.

Hey there. Those pubkeys all tie back to the #120 pubkey. If we find any one of them, we solve the private key for #120.

hi there wandering,

could we use another pub-key instead of the baked in ones.?

the first public is 0 btc and compressed 0 btc. and the rest of the list of public keys  has 0 btc to.
has it got anything to do with the puzzel and how we find the right private key for the wrong pub-key?

thanks a lot great app, getting 5MK/s  1 thread with an i5, very fast all ranges 2^25 2^22 is what i keep seeing,

To run all four, I start with one, double click on it, then go to the next, double click on it, etc. until you have all 4 running.

Total ranges, if it takes to the last range to find the key, is 2^73. But, each range is checked within 10 seconds. So, the more CPUs running, the better!

How to run all the batch files at the same time?

And what's the total ranges to be checked for #120?

Reserved for OP.....

Total Ranges Searched Update:

250,611
(4,408,795,336,777,138,176 individual keys checked; that I know of)

Reserved for OP...

UPDATE: I have removed all the BSGS files from version one, for the combined effort, on this page. The BSGS exe file located on main page is the same as Jean Luc's; I just added the function where it will print and save a text document with the public and private keys. The combined effort seemed to cause confusion because of the pub key shift so now it's back to just searching in the actual 120 bit range. Users can still share ranges searched. I will upload a simple python and batch file to randomly choose ranges to search and keep track of those ranges via a text file.

I have tweaked the code of Jean Luc Pons' Baby Step Giant Step program ( https://github.com/JeanLucPons/BSGS ) to help find the #120 puzzle in the Bitcoin Challenge Transaction ( https://bitcointalksearch.org/topic/bitcoin-challenge-transaction-1000-btc-total-bounty-to-solvers-updated-5218972 ).

Not everyone has a GPU or a high powered GPU to use programs such as Bitcrack or Kangaroo methods. But mostly everyone has a CPU, and that is what powers the Baby Step Giant Step (BSGS) program...the CPU located in your computer. Now, everyone has a chance to help crack the puzzle. One major advantage over Kangaroo methods, the BSGS is easy to give different ranges to workers without losing in complexity which is not possible with Kangaroo.

Download the exe files and batch files here:
https://github.com/WanderingPhilosopher/BSGS

The tweaks I made to the original code include:
a random range generator
the program now automatically creates the input file:
Baby Step Size
Start Range
End Range
and applicable Public Keys (to search for)

All you have to do is download the tweaked program and the already made batch file. Once you download the files, place them in the same folder and double-click on the batch file. The program will automatically start searching for the public key. That's it. It's that easy.

What you will notice in the folder you placed your files in:
an input file will automatically pre-fill
and there will be a file called ranges_searched.txt

After we run the program for awhile, people can send me their ranges_searched.txt file and I can keep track of ranges searched and maybe this will help us narrow down to a smaller range in the future. Or, people can post how many ranges they've already searched and we can keep a running tally.

I took the #120 public key (120 bits) and compressed it down to 117 bits to make our search range 8 times smaller.

What happens when you find the public key?
If your CPU finds a key, a text document called, FOUNDKEYSFOUNDKEYSFOUNDKEYSFOUNDKEYSFOUNDKEYSFOUNDKEYSFOUNDKEYSFOUNDKEYSFOUNDKE YS.txt will be created in the folder and it will contain the private key and the public key. Send that information to me, along with your bitcoin wallet address, and I will recreate the original #120 public key, and we will split the 1.2 bitcoin 50/50. It's that easy.

How I am running the program on my computer:
I have downloaded the 16 BSGS exe files and the 16 batch files. In each batch file, it calls to use one CPU thread (-t 1). So I run as many of the batch files/programs as my CPU can handle. On an i5-4690, with four instances running (4 threads total), each thread completes a range in about 9 seconds. So that's 4 ranges checked every 9 seconds, which on the safe side, this one computer checks about 34,560 ranges a day. Let me know how fast your computer completes a range.