Do you think you can try to look for a way to reduce keyspace search for kangaroo too?
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 |
|
|
|
I feel bitcrack work by scan all range very slow https://github.com/brichard19/BitCrackI am not follow from beginning brichard19 is original bitcrack right bitcrack this version have random mode right, I will try compare https://github.com/djarumlights/BitCrackcompare bitcrack with kangaroo with same keyspace, kangaroo work very fast and kangaroo found key fast and bitcrack can not found key I test with address that have pubkey and bitcrack by bitcrack use address and kangaroo use pubkey both same bitcoin kangaroo can found key on 2 hour but bit crack 24 hour still not found (clbitcrack OpenCL version) |
|
|
|
Hi guys ,
Can this tool or any modification of this be modified to write all private keys and respective uncompressed private keys and addresses) in range 1 to 56BC75E2D630FFFFF as a csv file . Since it generates 700 to xxxx million keys /s in some of its versions , so it will take many years on a single machine. But still looking for solutions. Writing regular outputs will consume too much time
So better it will save several millions or billions in some sort of memory operation and then write them once , till then next batch will find its space in memory to be written again.
If I understand you correctly, you are saying that Bitcrack should write the address of each private key it finds to a file? How would that speed up key searching? Bitcrack doesn't even encode addresses anyway (it only decodes them to RIPEMD160 hash at the beginning of a search) so modifying it to make an address out of every address it finds will slow it down. I agree with write to file make bitcrack slowly both technic open file and write file each key or collector on memory and write one same work slow (write to file use low memory and write one use large memory too) if you need write to file on this case it no need to use bitcrack just use any python script write to file it fast same your want both random and running number I try already like python write file private key 1 million per 4 minute (up to harddisk or SSD storage) if you want to collect private key is use a log of storage to keep it too. plan text file is very small but when have billions trillion line use some space 64 billion private key data use 4TB disk, how many you need to keep most decide to scan and let it go |
|
|
|
Hello, I'm a total newbie for the bitcoin puzzle and bitcoin in general, but I have some experience in Python. I wrote the following codes depending on my knowledge in Python. first of all, I'm running these codes on 2 laptops [core i3 & core i5], but it runs extremely slow on both of them ~333keys/s I tried to use Bitcrack but I couldn't manage to get it run on Kali Linux "I have just installed it couple of days ago so I'm not experienced with it"I tried https://privatekeys.pw/scanner "which by the way shows that I'm generating ~15,000 Keys/s on both laptops!"I tried to find a faster bitcoin library for Python but I couldn't manage to make it work like bitcoin standard libraryanyway, here are my codes: CODE #1import random
from bitcoin import *
while True:
x = random.randint(2**63, 2**64)
y = privtoaddr(x)
if y == '16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN':
print(hex(i))
break
from bitcoin import privtoaddr
i = 18446744073709551616
while i >= 9223372036854775808:
i -= 1
y = privtoaddr(i)
if y == '16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN':
print(hex(i))
break I try to play around a lot with CODE #2, but still getting the same results. Any suggestions to make it run faster or recommending faster tools are appreciated. Thanks in advance. With your laptops speed, use BSGS by WanderingPhilospher https://bitcointalk.org/index.php?topic=5304368.0 or Plutus https://github.com/Isaacdelly/Plutus a slightly adapted one can check at least 20 million addr in 1 second (in infinity)... try BSGS or other way use method calculate position address before scan code #2 scan all is 9 Quintillion (9 billion of billion) if you laptop can scan 1 billion per day and then need 9 billion days to scan on you laptop so pure scan (raw brute force all) may be not work, it need to calculate something before scan example 15446744073709551615 16446744073709551615 17446744073709551615 18446744073709551615 if you guess key on between 17446744073709551615 to 18446744073709551615 still = 1000000000000000000 = 1000000000* 1000000000 64bit pool now still scan to 1 Quintillion from 9 Quintillion try to join pool to scan all 8 Quintillion leave |
|
|
|
This is just not true. The RAM consumed/used is not dependent on the bits being search...it comes down to your DP setting and how often you save the work file. I don't see your settings/flags when starting the program but you are using a very low -d setting or that plus using a long save to file time.
Sorry I forget tell use with old python version test on 256bit with set max 256bit that eat a lot of memory, that mean For JeanLucPons Kangaroo it use low memory it work better other Kangaroo recommend to use with GPU is better (CPU will full 100% resource ) if can have option for Kangaroo version OpenCL will be great |
|
|
|
puzzle #120 in.txt 800000000000000000000000000000
FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
02CEB6CBBCDBDF5EF7150682150F4CE2C6F4807B349827DCDBDD1F2EFA885A2630 where in c++ code read and use value 800000000000000000000000000000 and FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF to use as range search I would like to compare c++ work and use modify old python code to use range like c++ now I use JeanLucPons Kangaroo by split keyspace to small part and search when use full rank, my CPU very high and use Full memory, I think 16GB laptop not enough for 120bit search may be need 64Gb to 128GB high end memory board |
|
|
|
|
Did you guy modify kangaroo to can use high bit or 256bit
I try to modify python version to high bit and 256bits
problem kangaroo need to calculate prepare table and value before start compare a lot make CPU high and RAM Memory high (full memory) when use 256bits
I think may be have problem both with version JeanLucPons Kangaroo or any C++ same problem may be the keyspace are too high more than kangaroo work fast
|
|
|
|
So what did original 2009 - 2012 bitcoin wallets generate? 64bit keys?
I am not aware of any wallet software (Bitcoin Core or otherwise) that used anything other than 256-bit keys. At one point in time, people made private keys out of so called "brain wallets" which are just random strings SHA256'ed into a hash that generated public and private keys. [Some people even used public base58 addresses as input to SHA256.] Right and I try already bitcoin original from alpha version bitcoin-nov08.tgz bitcoin-0.1.0.rar bitcoin-0.1.3.rar all are 256 bits from 2009 (2008 develop) everything 256 bits very good for over thinking bitcoin address if develop fit use, may be bitcoin are hack done already all real money bitcoin use 256 bit have only Brainwallet have problem for human crack |
|
|
|
Ok thanks, so lets say i wanted to attempt to solve/crack a private key for a 128bit key, or 256bit key, is there a setting, or how do i program it to crack that, or is it just automatic?
By using
0
FFFFFFFFFFFFFFFFFFFFFFFFF
will that check the entire keyspace of a standard 128bit key?
Can you code? for very high 128bit key, or 256bit key you need to upgrade or find the way works better and smart than current kangaroo for reduce time use find key now puzzle 120 bits keys still un solve |
|
|
|
recommend use sample file puzzle32.txt https://github.com/JeanLucPons/Kangaroo/blob/master/puzzle32.txtmore testing file for longer test puzzle #65 = 3-10 minute up to you CPU or GPU command puzzle65.bat Kangaroo.exe -ws -o result65.txt -w puzzle65.work -wi 300 puzzle65.txt
GPU Kangaroo.exe -ws -gpu -o result65.txt -w puzzle65.work -wi 300 puzzle65.txt
puzzle65.txt 10000000000000000
1ffffffffffffffff
0230210c23b1a047bc9bdbb13448e67deddc108946de6de639bcc75d47c0216b1b
capital same 10000000000000000
1FFFFFFFFFFFFFFFF
0230210C23B1A047BC9BDBB13448E67DEDDC108946DE6DE639BCC75D47C0216B1B
|
|
|
|
Question, i have say 1000 keys in my config, does it crack them all simultaneously?
Also if i wanted to check the entire keyspace for 128bit keys (yes i know this makes it astronomically harder and likely impossible) what would the first two lines of config file look like?
Its currently
0
FFFFFFFFFFFFFFFFFFFFFFFFF
Sorry for the newbie questions, this is for a school project, so help would be appreciated.
try this example puzzle #40 puzzle40.txt 8000000000
FFFFFFFFFF
03A2EFA402FD5268400C77C20E574BA86409EDEDEE7C4020E4B9F0EDBEE53DE0D4 command puzzle40.bat Kangaroo.exe -ws -o result40.txt -w puzzle40.work -wi 300 puzzle40.txt then check fiel result40.txt |
|
|
|
|
one thing about all script python and any script
if it display show message detail like show key or show generate, show random, show runing number
try test until make sure it work 100%
then modify change to hide all message it make to working fast than show massage
just turn off show display it make to faster
show display it make script works slowly it not necessary
try it you can see it work better.
let script calculate work without display and make it save result to file make show only when success
|
|
|
|
I use it on python 2.7 (windows) and it works like a charm. Are you using 2.7 or 3.x?
ok now it work fine on 2.7 how can I change ripetofind = '3ee4133d991f52fdf6a25c9834e0745ac74248a4' I try use this web is correct http://gobittest.appspot.com/Addressput address below and submit get address upper RIPEMD-160 Hash puzzle #64 3EE4133D991F52FDF6A25C9834E0745AC74248A4 puzzle #120 AE6804B35C82F47F8B0A42D8C5E514FE5EF0A883 |
|
|
|
I use it on python 2.7 (windows) and it works like a charm. Are you using 2.7 or 3.x?
ok, I use 3.9 will try on 2.7 I have both 2.7 and 3.x use on miniconda two version |
|
|
|
@fxsniper Here is the code I told you I would upload. It's not the exact one I was looking for but it is based on the same principle. Easy to change the range you want to search through. I modified my code to search for the RIPEMD of the address I was looking for. Shaves a few milliseconds off versus processing all the way to the address. I created this probably 6 months ago and I am sure it is not the most efficient coding. Hopefully it gives you some ideas on how to tweak and make exactly what you are wanting. #Amateur, very amateur coding by the Wandering Philosopher
#Tested with Python 2.7
import binascii, hashlib, base58, sys, ecdsa, codecs, os, random
import time
import timeit
#Enter the RIPEMD160 of the address you want to search for; make sure it is in LOWERCASE
ripetofind = '3ee4133d991f52fdf6a25c9834e0745ac74248a4'
def compressed_RIPEMD(privkey):
start_time = timeit.default_timer()
pvk_to_bytes = codecs.decode (privkey, 'hex')
#Generates the public key
key = ecdsa.SigningKey.from_string (pvk_to_bytes, curve=ecdsa.SECP256k1).verifying_key
key_bytes = key.to_string()
key_hex = codecs.encode(key_bytes, 'hex')
if(ord(bytearray.fromhex(key_hex[-2:])) % 2 == 0):
#If the last byte of Y is Even, add '02'
public_key_compressed = '02' + key_hex[0:64]
#Making SHA-256 of compressed pubkey and then RIPEMD-160
public_key_in_bytes = codecs.decode(public_key_compressed, 'hex')
sha256_public_key_compressed = hashlib.sha256(public_key_in_bytes)
sha256_public_key_compressed_digest = sha256_public_key_compressed.digest()
ripemd160 = hashlib.new('ripemd160')
ripemd160.update(sha256_public_key_compressed_digest)
ripemd160_digest = ripemd160.digest()
ripemd160_hex = codecs.encode(ripemd160_digest, 'hex')
else:
#If the last byte of Y is Odd, add '03'
public_key_compressed = '03' + key_hex[0:64]
#Making SHA-256 of compressed pubkey and then RIPEMD-160
public_key_in_bytes = codecs.decode(public_key_compressed, 'hex')
sha256_public_key_compressed = hashlib.sha256(public_key_in_bytes)
sha256_public_key_compressed_digest = sha256_public_key_compressed.digest()
ripemd160 = hashlib.new('ripemd160')
ripemd160.update(sha256_public_key_compressed_digest)
ripemd160_digest = ripemd160.digest()
ripemd160_hex = codecs.encode(ripemd160_digest, 'hex')
elapsed = timeit.default_timer() - start_time
#Prints status and numbers on screen. Comment out both sys.stdout lines below if not wanted and the countall +=1 ; I liked to know it was working/running.
sys.stdout.write("\r" + " Key every: " + str(elapsed)[:7] + " seconds " + " Random RIPEMD160s: " + ripemd160_hex + " # of Keys: " + str(countall))
sys.stdout.flush()
fwrite = open('KEYSFOUND.txt', 'a')
if ripemd160_hex == ripetofind:
fwrite.write('Key: ' + randomprivkey + ' ' + ripemd160_hex + '\n' )
#Always leave countall = 0 below. If you want the program to run unlimited, comment out the countall +=1 down below
countall = 0
while (countall < 100000000000000):
if __name__== "__main__":
#Enter the range you want to search through below
low = 0x8000000000000000
high = 0xFFFFFFFFFFFFFFFF
#high = 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140
randomprivkey = hex( random.randrange( low, high ) ).lstrip("0x").rstrip("L").zfill(64)
countall +=1
compressed_RIPEMD(randomprivkey)
Thanks this code find RIPEMD-160 hash before convert to address right if(ord(bytearray.fromhex(key_hex[-2:])) % 2 == 0): TypeError: fromhex() argument must be str, not bytes |
|
|
|
it is normal. I think it is too fast. 1086000828893888512 keys in 30 seconds - Added 0 points from file
- Setting N up to 17592186044416.
- Init bloom filter for 4194304 elements : 11.00 MB
- Allocating 128.00 MB for aMP Points
- Precalculating 4194304 aMP points
- Allocating 64.00 MB for bP Points
- precalculating 4194304 bP points
- Sorting 4194304 elements
Total 1086000828893888512 keys in 30 seconds: 36200027629796283 keys/s Total 2176681179275591680 keys in 60 seconds: 36278019654593194 keys/s Total 3263473656541478912 keys in 90 seconds: 36260818406016432 keys/s Total 4346941210644971520 keys in 120 seconds: 36224510088708096 keys/s |
|
|
|
|
Thanks now ok quiet option already
turn off display make program work fast that show it display
other program is same turn off is make it work faster
and What mean keys, it is mean 1 private key or 1 key character
Total 2163563847226549600256 keys in 69000 seconds: 31355997785892023 keys/s
Total 2164516112257133838336 keys in 69030 seconds: 31356165612880397 keys/s
Total 2165465615314509103104 keys in 69060 seconds: 31356293300239054 keys/s
Total 2166412549912721883136 keys in 69090 seconds: 31356383701153884 keys/s
Total 2167356300325260623872 keys in 69120 seconds: 31356427956094627 keys/s
Total 2168303551582822203392 keys in 69150 seconds: 31356522799462360 keys/s
Total 2169249254728011874304 keys in 69180 seconds: 31356595182538477 keys/s
Total 2170192670889015771136 keys in 69210 seconds: 31356634458734514 keys/s
|
|
|
|
Where in the warping cyberspace is "PRIx64" defined?  Kangaroo.cpp, line 169, function SetDP(int size) [I think that's the name of it off the top of my head] ::printf("DP size: %d [0x%" PRIx64 "]\n",dpSize,dMask);This is ostensibly supposed to be the Unix format code for a 64-bit hex number, but it's not defined anywhere in the program. Could it be in a standard header file? I have to change it to 256-bit (4 64-bit format codes strung together) because I wound up having to increase the DP size to 256 bits as well because I didn't feel like having ANOTHER field just for a truncated lowest-64 bits of the kangaroo position, especially when said field is shoved inside Int.bits64[3] of a 128-bit kangaroo and all the code references that. There are 2 more occurrences of this which you can see with https://github.com/JeanLucPons/Kangaroo/search?q=PRIx64&type=Could you help to fork update to version 256bit (for use up to #160 puzzle)? may be work better than limited to fit 120 bits JeanLucPons still on forum, Can possible to update? or may be limited because of have some problem technic when use work with high bits or not? |
|
|
|
|
Show Posts
