racminer
Member
 Offline
Activity: 242
Merit: 17
|
 |
December 03, 2018, 06:57:32 AM |
|
#58 1Dn8NF8qDyyfHMktmuoQLGyjWmZXgvosXf has been spent an hour ago
tx: 17d31de2bd300bc1bad430ec0db77ca27466bbb97bf03df6a3ff386d60e58996
|
|
|
|
|
|
|
|
|
|
|
|
In order to achieve higher forum ranks, you need both activity points and merit points.
|
|
|
Advertised sites are not endorsed by the Bitcoin Forum. They may be unsafe, untrustworthy, or illegal in your jurisdiction.
|
|
|
|
|
|
|
stalker00075
Newbie
Offline
Activity: 54
Merit: 0
|
|
December 03, 2018, 09:14:52 AM
Last edit: December 03, 2018, 09:40:23 AM by stalker00075 |
|
arulbero Help!
what key can there be 1Dn8NF8qDyyfHMktmuoQLGyjWmZXgvosXf
2..............
3..............
|
|
|
|
|
arulbero
Legendary
Offline
Activity: 1915
Merit: 2074
|
|
December 03, 2018, 05:16:44 PM |
|
arulbero Help!
what key can there be 1Dn8NF8qDyyfHMktmuoQLGyjWmZXgvosXf
2..............
3..............
Private key : 00000000000000000000000000000000000000000000000002c675b852189a21
Public key : 11569442e870326ceec0de24eb5478c19e146ecd9d15e4666440f2f638875f42 524c08d882f868347f8b69d3330dc1913a159d8fb2b27864f197693a0eb39a23
PrKey WIF c.: KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYjv2kTamEYQT9BNC7o1
Address c. : 8c2a6071f89c90c4dab5ab295d7729d1b54ea60f
Address c. : 1Dn8NF8qDyyfHMktmuoQLGyjWmZXgvosXf
|
|
|
|
|
arulbero
Legendary
Offline
Activity: 1915
Merit: 2074
|
|
December 03, 2018, 06:00:53 PM |
|
Using Pollard Rho method, the expected work is 3*2^80 group operations with almost zero memory requirements.
Note that unlike BSGS this method is probabilistic, and might fail with very low probability (on the order of 2^-160).
One can improve the algorithm using Distinguished Points, bringing the expected work down to 1.253*2^80 group operations, using both less memory and less group operations (on average) than BSGS.
Pollard Rho can be modified for an interval shorter than the whole group, at the cost of more group operations, i.e. for range 1 to 2^160 a possible solution would take 10*3*2^80 group ops plus 10*2^16 group points additional memory.
There are other probabilistic algorithms when private key is in a range significantly smaller than the size of the whole group - Pollard Kangaroo, and Gaudry-Schost algorithms.
Pollard Kangaroo with four kangaroos (the optimal) and distinguished points (DP) has expected work 1.715*2^80.
Four set Gaudry-Schost algorithm with DP gives 1.661*2^80 group operations, and is easy to parallelise.
There might be additional memory requirements for both methods, negligible compared to the enormous cost of BSGS.
Thanks for the information, I will take a look at these algorithms. |
|
|
|
|
Andzhig
Jr. Member
Offline
Activity: 183
Merit: 3
|
|
December 03, 2018, 08:00:04 PM
Last edit: December 05, 2018, 04:20:26 AM by Andzhig |
|
arulbero,thx.
(for reference)
1Dn8NF8qDyyfHMktmuoQLGyjWmZXgvosXf
bin 1011000110011101011011100001010010000110001001101000100001
hex 2C675B852189A21
dec 199976667976342049
1011000110011101011011100001010010000110001001101000100001 33 zeros,25 ones.
10110001 10011101 01101110 00010100 10000110 00100110 10001000 01 33-25
11110101 10010010 11100100 10000011 11001010 11101011 00001110 0 28-29
10011101 00011000 10110110 00111010 11000100 11111111 11011111 22-34
11010101 01111100 00111111 00110110 11001111 11000010 0010100 24-31
10001101 10111110 11011011 01010110 10110100 01111101 000100 23-31
1111111111111111111111111000000000000000000000000000000000
111111111111111111111111111110000000000000000000000000000
11111111111111111111111111111111110000000000000000000000
1111111111111111111111111111111000000000000000000000000
111111111111111111111111111111100000000000000000000000
79 1001111
86 1010110
71 1000111
81 1010001
86 1010110
104 1101000 (1+9+9+9+7+6+6+6+7+9+7+6+3+4+2+0+4+9)
7D4FE747
B862A62E
1A96CA8D8
34A65911D
4AED21170
9DE820A7C
1757756A93
22382FACD0
4B5F8303E9
E9AE4933D6
153869ACC5B
2A221C58D8F
6BD3B27C591
E02B35A358F
122FCA143C05
2EC18388D544
6CD610B53CBA
ADE6D7CE3B9B
174176B015F4D
22BD43C2E9354
75070A1A009D4
EFAE164CB9E3C
180788E47E326C
236FB6D5AD1F44
6ABE1F9B67E114
9D18B63AC4FFDF
1EB25C90795D61C
2C675B852189A21
5 or 6 or 7 ...
Well, what's next, 288230376151711744-576460752303423488 ,if 6 it's 430000000000000000-500000000000000000 if 7 500000000000000000-570000000000000000
|
|
|
|
|
holy_ship
Jr. Member
Offline
Activity: 109
Merit: 1
|
|
December 05, 2018, 04:54:03 AM |
|
haha! puzzle 58 is cracked. some guys with superclusters got involved?  |
|
|
|
|
PietCoin97
Jr. Member
Offline
Activity: 91
Merit: 3
|
|
December 05, 2018, 07:41:51 PM |
|
If the public key is revealed it is still safe from bruteforce if the attacker don't know the range of bits to search for?
Of course. Many blocks mined by Satoshi have txs with "pay to public key" script (P2PK) instead of "pay to public key hash" script (P2PKH, pay to address). The public keys are known, but the btc are still there: block #100 https://www.blockchain.com/it/btc/tx/2d05f0c9c3e1c226e63b5fac240137687544cf631cd616fd34fd188fc9020866PUSHDATA(65)[04 e70a02f5af48a1989bf630d92523c9d14c45c75f7d1b998e962bff6ff9995fc5bdb44f1793b3749 5d80324acba7c8f537caaf8432b8d47987313060cc82d8a93] CHECKSIG x = e70a02f5af48a1989bf630d92523c9d14c45c75f7d1b998e962bff6ff9995fc5
y = bdb44f1793b37495d80324acba7c8f537caaf8432b8d47987313060cc82d8a93
you say we could calculate a specific search space when we know the pub key from these addresses. but why are the BTC still there ? is it also impossible with the specific search space ? i have a list with 42k of this addresses |
|
|
|
|
bill32767
Newbie
Offline
Activity: 26
Merit: 1
|
|
December 05, 2018, 08:57:14 PM |
|
If the public key is revealed it is still safe from bruteforce if the attacker don't know the range of bits to search for?
Of course. Many blocks mined by Satoshi have txs with "pay to public key" script (P2PK) instead of "pay to public key hash" script (P2PKH, pay to address). The public keys are known, but the btc are still there: block #100 https://www.blockchain.com/it/btc/tx/2d05f0c9c3e1c226e63b5fac240137687544cf631cd616fd34fd188fc9020866PUSHDATA(65)[04 e70a02f5af48a1989bf630d92523c9d14c45c75f7d1b998e962bff6ff9995fc5bdb44f1793b3749 5d80324acba7c8f537caaf8432b8d47987313060cc82d8a93] CHECKSIG x = e70a02f5af48a1989bf630d92523c9d14c45c75f7d1b998e962bff6ff9995fc5
y = bdb44f1793b37495d80324acba7c8f537caaf8432b8d47987313060cc82d8a93
you say we could calculate a specific search space when we know the pub key from these addresses. but why are the BTC still there ? is it also impossible with the specific search space ? i have a list with 42k of this addresses I believe his explanations were clear. He could calculate the private key from a minimal range e.g 2^80 but cannot calculate if its above that using Baby Step Giant Step as he explained previously. The puzzle keys are within a known range making it easy to get the private key after the funds has been spent. Your 42k address is IMPOSSIBLE to crack (at least not in this generation or next) even if you got all their public keys because their range are scary and larger than you can imagine. |
|
|
|
|
bill32767
Newbie
Offline
Activity: 26
Merit: 1
|
|
December 05, 2018, 09:08:06 PM |
|
arulbero,thx.
(for reference)
1Dn8NF8qDyyfHMktmuoQLGyjWmZXgvosXf
bin 1011000110011101011011100001010010000110001001101000100001
hex 2C675B852189A21
dec 199976667976342049
1011000110011101011011100001010010000110001001101000100001 33 zeros,25 ones.
10110001 10011101 01101110 00010100 10000110 00100110 10001000 01 33-25
11110101 10010010 11100100 10000011 11001010 11101011 00001110 0 28-29
10011101 00011000 10110110 00111010 11000100 11111111 11011111 22-34
11010101 01111100 00111111 00110110 11001111 11000010 0010100 24-31
10001101 10111110 11011011 01010110 10110100 01111101 000100 23-31
1111111111111111111111111000000000000000000000000000000000
111111111111111111111111111110000000000000000000000000000
11111111111111111111111111111111110000000000000000000000
1111111111111111111111111111111000000000000000000000000
111111111111111111111111111111100000000000000000000000
79 1001111
86 1010110
71 1000111
81 1010001
86 1010110
104 1101000 (1+9+9+9+7+6+6+6+7+9+7+6+3+4+2+0+4+9)
7D4FE747
B862A62E
1A96CA8D8
34A65911D
4AED21170
9DE820A7C
1757756A93
22382FACD0
4B5F8303E9
E9AE4933D6
153869ACC5B
2A221C58D8F
6BD3B27C591
E02B35A358F
122FCA143C05
2EC18388D544
6CD610B53CBA
ADE6D7CE3B9B
174176B015F4D
22BD43C2E9354
75070A1A009D4
EFAE164CB9E3C
180788E47E326C
236FB6D5AD1F44
6ABE1F9B67E114
9D18B63AC4FFDF
1EB25C90795D61C
2C675B852189A21
5 or 6 or 7 ...
Well, what's next, 288230376151711744-576460752303423488 ,if 6 it's 430000000000000000-500000000000000000 if 7 500000000000000000-570000000000000000
You always gat some SH*T to post anytime an address is being swept. Are you the one sweeping them? Do you have a formula or anything close? What exactly do your calculations mean? I'll appreciate some explanations! |
|
|
|
|
arulbero
Legendary
Offline
Activity: 1915
Merit: 2074
|
|
December 05, 2018, 09:08:45 PM |
|
you say we could calculate a specific search space when we know the pub key from these addresses.
but why are the BTC still there ?
is it also impossible with the specific search space ?
We can't "calculate" a specific search space, we need to know the specific search space before starting the computation. That's the reason why those btc are still there, because nobody (except the btc owner) knows the specific search space for those private keys. |
|
|
|
|
PietCoin97
Jr. Member
Offline
Activity: 91
Merit: 3
|
|
December 05, 2018, 09:30:39 PM |
|
you say we could calculate a specific search space when we know the pub key from these addresses.
but why are the BTC still there ?
is it also impossible with the specific search space ?
We can't "calculate" a specific search space, we need to know the specific search space before starting the computation. That's the reason why those btc are still there, because nobody (except the btc owner) knows the specific search space for those private keys. OK so the possibility that the addresses are in the 250 - 256 space is high. When we take one of these space and make this with the baby step giant step? Or do I understand something really wrong? |
|
|
|
|
Bajula
Member
Offline
Activity: 166
Merit: 16
|
|
December 06, 2018, 04:38:50 AM |
|
you say we could calculate a specific search space when we know the pub key from these addresses.
but why are the BTC still there ?
is it also impossible with the specific search space ?
We can't "calculate" a specific search space, we need to know the specific search space before starting the computation. That's the reason why those btc are still there, because nobody (except the btc owner) knows the specific search space for those private keys. OK so the possibility that the addresses are in the 250 - 256 space is high. When we take one of these space and make this with the baby step giant step? Or do I understand something really wrong? Each is double what is was before.. so imagine the memory needed for such a thing. Let's say (arbitrary example- not real) it takes 8 gb ram to do giant step 1 >>> 28 then 29 would be 16 gb ram 30 would be 32 .. --> 40 would be 32 terrabytes ram ---> 50 would be 32 PETAbytes of on board ram... etc.... so you can see where the issue lies. |
|
|
|
|
Andzhig
Jr. Member
Offline
Activity: 183
Merit: 3
|
|
December 06, 2018, 05:08:14 AM
Last edit: December 06, 2018, 05:39:16 AM by Andzhig |
|
Do you have a formula or anything close? There is no formula, there is a random and our collective unconscious. Therefore, someone will write something, someone will think of something. You never know, I will write now and you will light up (light bulb lights up). Take the last number found. 1011000110011101011011100001010010000110001001101000100001 take the first 3 bytes from it 10110001 10011101 01101110 here we have 10 zeros. Check how many combinations will be from the first byte 10110001, 8008 combinations which we need in place 583 (depending on the given data of course, table for counting in python, I'll leave it down) bin 101100011001110101101110 dec 11640174 multiply this number 34 times by 2 will get ~199976666598998016 practically what you need 199976667976342049. 199976667976342049-199976666598998016=1377344033 error on 1377344033 using a scanner "bitcrack" it's practically nothing. You need to guess just 3 bytes then "bitcrack" will do everything himself. The most important question is how to guess these 3 bytes (and multiply by 2 35 times for 59 puzzle). Now back to my writing. 174176B015F4D
22BD43C2E9354
75070A1A009D4
EFAE164CB9E3C
180788E47E326C
236FB6D5AD1F44
6ABE1F9B67E114
9D18B63AC4FFDF
1EB25C90795D61C
2C675B852189A21
5 or 6 or 7 ...
Well, what's next, 288230376151711744-576460752303423488 ,if 6 it's 430000000000000000-500000000000000000 if 7 500000000000000000-570000000000000000 Depending on the initial number in hex, we get our initial bytes in bit. hex ~610000000000000-6F0000000000000 ~436849163854938112-499899558638125056, 710000000000000-7F0000000000000 ~508906757892866048-571957152676052992. 6 or 7 implies 110 or 111 ("11000000"),("11000001"),("11000010"),("11000011"),("11000100"),("11000101"),("11000110"),("11000111"),
("11001000"),("11001001"),("11001010"),("11001011"),("11001100"),("11001101"),("11001110"),("11001111"),
("11010000"),("11010001"),("11010010"),("11010011"),("11010100"),("11010101"),("11010110"),("11010111"),
("11011000"),("11011001"),("11011010"),("11011011"),("11011100"),("11011101"),("11011110"),("11011111"),
("11100000"),("11100001"),("11100010"),("11100011"),("11100100"),("11100101"),("11100110"),("11100111"),
("11101000"),("11101001"),("11101010"),("11101011"),("11101100"),("11101101"),("11101110"),("11101111"),
("11110000"),("11110001"),("11110010"),("11110011"),("11110100"),("11110101"),("11110110"),("11110111"),
("11111000"),("11111001"),("11111010"),("11111011"),("11111100"),("11111101"),("11111110"),("11111111"),
As we judging by the previous numbers 6 we have mostly hex letters 6ABCDEF and seven with hex numbers 7123456789. We narrow our space 6A0000000000000-6F0000000000000 477381560501272576-499899558638125056. And we get 16 bytes. ("11010000"),("11010001"),("11010010"),("11010011"),("11010100"),("11010101"),("11010110"),("11010111"),
("11011000"),("11011001"),("11011010"),("11011011"),("11011100"),("11011101"),("11011110"),("11011111"), For each of which options are possible with 8-15 zeros. But then you have to think further, or launch a "bitcrack" for everyone 16. It can run multiple copies at the same time. Or try to further filter for example in three bytes "111". On the example of our previous number 10110001 10011101 01101110 here are 2 of them "111" the number of options reduced from 8008 to 4802. python script l1= [("10110001")]
#l1= [("11010000"),("11010001"),("11010010"),("11010011"),("11010100"),("11010101"),("11010110"),("11010111"),
# ("11011000"),("11011001"),("11011010"),("11011011"),("11011100"),("11011101"),("11011110"),("11011111")]
l2= [("10000000"),("10000001"),("10000010"),("10000011"),("10000100"),("10000101"),("10000110"),("10000111"),
("10001000"),("10001001"),("10001010"),("10001011"),("10001100"),("10001101"),("10001110"),("10001111"),
("10010000"),("10010001"),("10010010"),("10010011"),("10010100"),("10010101"),("10010110"),("10010111"),
("10011000"),("10011001"),("10011010"),("10011011"),("10011100"),("10011101"),("10011110"),("10011111"),
("10100000"),("10100001"),("10100010"),("10100011"),("10100100"),("10100101"),("10100110"),("10100111"),
("10101000"),("10101001"),("10101010"),("10101011"),("10101100"),("10101101"),("10101110"),("10101111"),
("10110000"),("10110001"),("10110010"),("10110011"),("10110100"),("10110101"),("10110110"),("10110111"),
("10111000"),("10111001"),("10111010"),("10111011"),("10111100"),("10111101"),("10111110"),("10111111"),
("11000000"),("11000001"),("11000010"),("11000011"),("11000100"),("11000101"),("11000110"),("11000111"),
("11001000"),("11001001"),("11001010"),("11001011"),("11001100"),("11001101"),("11001110"),("11001111"),
("11010000"),("11010001"),("11010010"),("11010011"),("11010100"),("11010101"),("11010110"),("11010111"),
("11011000"),("11011001"),("11011010"),("11011011"),("11011100"),("11011101"),("11011110"),("11011111"),
("11100000"),("11100001"),("11100010"),("11100011"),("11100100"),("11100101"),("11100110"),("11100111"),
("11101000"),("11101001"),("11101010"),("11101011"),("11101100"),("11101101"),("11101110"),("11101111"),
("11110000"),("11110001"),("11110010"),("11110011"),("11110100"),("11110101"),("11110110"),("11110111"),
("11111000"),("11111001"),("11111010"),("11111011"),("11111100"),("11111101"),("11111110"),("11111111"),
("00000000"),("00000001"),("00000010"),("00000011"),("00000100"),("00000101"),("00000110"),("00000111"),
("00001000"),("00001001"),("00001010"),("00001011"),("00001100"),("00001101"),("00001110"),("00001111"),
("00010000"),("00010001"),("00010010"),("00010011"),("00010100"),("00010101"),("00010110"),("00010111"),
("00011000"),("00011001"),("00011010"),("00011011"),("00011100"),("00011101"),("00011110"),("00011111"),
("00100000"),("00100001"),("00100010"),("00100011"),("00100100"),("00100101"),("00100110"),("00100111"),
("00101000"),("00101001"),("00101010"),("00101011"),("00101100"),("00101101"),("00101110"),("00101111"),
("00110000"),("00110001"),("00110010"),("00110011"),("00110100"),("00110101"),("00110110"),("00110111"),
("00111000"),("00111001"),("00111010"),("00111011"),("00111100"),("00111101"),("00111110"),("00111111"),
("01000000"),("01000001"),("01000010"),("01000011"),("01000100"),("01000101"),("01000110"),("01000111"),
("01001000"),("01001001"),("01001010"),("01001011"),("01001100"),("01001101"),("01001110"),("01001111"),
("01010000"),("01010001"),("01010010"),("01010011"),("01010100"),("01010101"),("01010110"),("01010111"),
("01011000"),("01011001"),("01011010"),("01011011"),("01011100"),("01011101"),("01011110"),("01011111"),
("01100000"),("01100001"),("01100010"),("01100011"),("01100100"),("01100101"),("01100110"),("01100111"),
("01101000"),("01101001"),("01101010"),("01101011"),("01101100"),("01101101"),("01101110"),("01101111"),
("01110000"),("01110001"),("01110010"),("01110011"),("01110100"),("01110101"),("01110110"),("01110111"),
("01111000"),("01111001"),("01111010"),("01111011"),("01111100"),("01111101"),("01111110"),("01111111")]
def funk():
for element1 in (l1):
for element2 in (l2):
for element3 in (l2):
bina = element1+element2+element3
nuli = bina.count("0")
if nuli == 10: #zeros count
print(bina)
pass
else:
pass
return None
funk()
[/size] |
|
|
|
|
bill32767
Newbie
Offline
Activity: 26
Merit: 1
|
|
December 06, 2018, 08:22:43 AM |
|
Do you have a formula or anything close? There is no formula, there is a random and our collective unconscious. Therefore, someone will write something, someone will think of something. You never know, I will write now and you will light up (light bulb lights up). Take the last number found. 1011000110011101011011100001010010000110001001101000100001 take the first 3 bytes from it 10110001 10011101 01101110 here we have 10 zeros. Check how many combinations will be from the first byte 10110001, 8008 combinations which we need in place 583 (depending on the given data of course, table for counting in python, I'll leave it down) bin 101100011001110101101110 dec 11640174 multiply this number 34 times by 2 will get ~199976666598998016 practically what you need 199976667976342049. 199976667976342049-199976666598998016=1377344033 error on 1377344033 using a scanner "bitcrack" it's practically nothing. You need to guess just 3 bytes then "bitcrack" will do everything himself. The most important question is how to guess these 3 bytes (and multiply by 2 35 times for 59 puzzle). Now back to my writing. 174176B015F4D
22BD43C2E9354
75070A1A009D4
EFAE164CB9E3C
180788E47E326C
236FB6D5AD1F44
6ABE1F9B67E114
9D18B63AC4FFDF
1EB25C90795D61C
2C675B852189A21
5 or 6 or 7 ...
Well, what's next, 288230376151711744-576460752303423488 ,if 6 it's 430000000000000000-500000000000000000 if 7 500000000000000000-570000000000000000 Depending on the initial number in hex, we get our initial bytes in bit. hex ~610000000000000-6F0000000000000 ~436849163854938112-499899558638125056, 710000000000000-7F0000000000000 ~508906757892866048-571957152676052992. 6 or 7 implies 110 or 111 ("11000000"),("11000001"),("11000010"),("11000011"),("11000100"),("11000101"),("11000110"),("11000111"),
("11001000"),("11001001"),("11001010"),("11001011"),("11001100"),("11001101"),("11001110"),("11001111"),
("11010000"),("11010001"),("11010010"),("11010011"),("11010100"),("11010101"),("11010110"),("11010111"),
("11011000"),("11011001"),("11011010"),("11011011"),("11011100"),("11011101"),("11011110"),("11011111"),
("11100000"),("11100001"),("11100010"),("11100011"),("11100100"),("11100101"),("11100110"),("11100111"),
("11101000"),("11101001"),("11101010"),("11101011"),("11101100"),("11101101"),("11101110"),("11101111"),
("11110000"),("11110001"),("11110010"),("11110011"),("11110100"),("11110101"),("11110110"),("11110111"),
("11111000"),("11111001"),("11111010"),("11111011"),("11111100"),("11111101"),("11111110"),("11111111"),
As we judging by the previous numbers 6 we have mostly hex letters 6ABCDEF and seven with hex numbers 7123456789. We narrow our space 6A0000000000000-6F0000000000000 477381560501272576-499899558638125056. And we get 16 bytes. ("11010000"),("11010001"),("11010010"),("11010011"),("11010100"),("11010101"),("11010110"),("11010111"),
("11011000"),("11011001"),("11011010"),("11011011"),("11011100"),("11011101"),("11011110"),("11011111"), For each of which options are possible with 8-15 zeros. But then you have to think further, or launch a "bitcrack" for everyone 16. It can run multiple copies at the same time. Or try to further filter for example in three bytes "111". On the example of our previous number 10110001 10011101 01101110 here are 2 of them "111" the number of options reduced from 8008 to 4802. python script l1= [("10110001")]
#l1= [("11010000"),("11010001"),("11010010"),("11010011"),("11010100"),("11010101"),("11010110"),("11010111"),
# ("11011000"),("11011001"),("11011010"),("11011011"),("11011100"),("11011101"),("11011110"),("11011111")]
l2= [("10000000"),("10000001"),("10000010"),("10000011"),("10000100"),("10000101"),("10000110"),("10000111"),
("10001000"),("10001001"),("10001010"),("10001011"),("10001100"),("10001101"),("10001110"),("10001111"),
("10010000"),("10010001"),("10010010"),("10010011"),("10010100"),("10010101"),("10010110"),("10010111"),
("10011000"),("10011001"),("10011010"),("10011011"),("10011100"),("10011101"),("10011110"),("10011111"),
("10100000"),("10100001"),("10100010"),("10100011"),("10100100"),("10100101"),("10100110"),("10100111"),
("10101000"),("10101001"),("10101010"),("10101011"),("10101100"),("10101101"),("10101110"),("10101111"),
("10110000"),("10110001"),("10110010"),("10110011"),("10110100"),("10110101"),("10110110"),("10110111"),
("10111000"),("10111001"),("10111010"),("10111011"),("10111100"),("10111101"),("10111110"),("10111111"),
("11000000"),("11000001"),("11000010"),("11000011"),("11000100"),("11000101"),("11000110"),("11000111"),
("11001000"),("11001001"),("11001010"),("11001011"),("11001100"),("11001101"),("11001110"),("11001111"),
("11010000"),("11010001"),("11010010"),("11010011"),("11010100"),("11010101"),("11010110"),("11010111"),
("11011000"),("11011001"),("11011010"),("11011011"),("11011100"),("11011101"),("11011110"),("11011111"),
("11100000"),("11100001"),("11100010"),("11100011"),("11100100"),("11100101"),("11100110"),("11100111"),
("11101000"),("11101001"),("11101010"),("11101011"),("11101100"),("11101101"),("11101110"),("11101111"),
("11110000"),("11110001"),("11110010"),("11110011"),("11110100"),("11110101"),("11110110"),("11110111"),
("11111000"),("11111001"),("11111010"),("11111011"),("11111100"),("11111101"),("11111110"),("11111111"),
("00000000"),("00000001"),("00000010"),("00000011"),("00000100"),("00000101"),("00000110"),("00000111"),
("00001000"),("00001001"),("00001010"),("00001011"),("00001100"),("00001101"),("00001110"),("00001111"),
("00010000"),("00010001"),("00010010"),("00010011"),("00010100"),("00010101"),("00010110"),("00010111"),
("00011000"),("00011001"),("00011010"),("00011011"),("00011100"),("00011101"),("00011110"),("00011111"),
("00100000"),("00100001"),("00100010"),("00100011"),("00100100"),("00100101"),("00100110"),("00100111"),
("00101000"),("00101001"),("00101010"),("00101011"),("00101100"),("00101101"),("00101110"),("00101111"),
("00110000"),("00110001"),("00110010"),("00110011"),("00110100"),("00110101"),("00110110"),("00110111"),
("00111000"),("00111001"),("00111010"),("00111011"),("00111100"),("00111101"),("00111110"),("00111111"),
("01000000"),("01000001"),("01000010"),("01000011"),("01000100"),("01000101"),("01000110"),("01000111"),
("01001000"),("01001001"),("01001010"),("01001011"),("01001100"),("01001101"),("01001110"),("01001111"),
("01010000"),("01010001"),("01010010"),("01010011"),("01010100"),("01010101"),("01010110"),("01010111"),
("01011000"),("01011001"),("01011010"),("01011011"),("01011100"),("01011101"),("01011110"),("01011111"),
("01100000"),("01100001"),("01100010"),("01100011"),("01100100"),("01100101"),("01100110"),("01100111"),
("01101000"),("01101001"),("01101010"),("01101011"),("01101100"),("01101101"),("01101110"),("01101111"),
("01110000"),("01110001"),("01110010"),("01110011"),("01110100"),("01110101"),("01110110"),("01110111"),
("01111000"),("01111001"),("01111010"),("01111011"),("01111100"),("01111101"),("01111110"),("01111111")]
def funk():
for element1 in (l1):
for element2 in (l2):
for element3 in (l2):
bina = element1+element2+element3
nuli = bina.count("0")
if nuli == 10: #zeros count
print(bina)
pass
else:
pass
return None
funk()
[/size] Now I understand you but in the end its all guessing work. I have a similar pattern, I will post it here since I have given up...the value of bitcoin is really falling rapidly making the puzzle seam useless |
|
|
|
|
bill32767
Newbie
Offline
Activity: 26
Merit: 1
|
|
December 06, 2018, 08:44:53 AM |
|
For those interested:
Key
1 1 2^1 = 2 (-1)
2 3 2^2 = 4 (-1)
3 7 2^3 = 8 (-1)
4 8 2^4 = 16 (-NO3)
5 21 2^5 = 32 (-NO3,-NO2)
6 49 2^6 = 64 (-NO4)
7 76 2^7 = 128 (-NO5,-NO4,-NO2)___(-NO2)
8 224 2^8 = 256 (-NO5)
9 467 2^9 = 512 (-NO5,-NO4)
10 514 2^10 = 1024 (-NO9)
11 1155 2^11 = 2048 (-NO9,-NO8,-NO7)
12 2683 2^12 = 4096 (-NO10,-NO8,-NO7,*NO3*)
13 5216 2^13 = 8192 (-NO11,-NO9,-NO8,-NO7,-NO5)
14 10544 2^14 = 16384 (-NO12,-NO10,-NO9,-NO7,-NO6,-NO4)
15 26867 2^15 = 32768 (-NO13,+NO11,+NO8) OR (-NO12,-NO10,-NO9,-NO8,-NO4)
16 51510 2^16 = 65536 (-NO14,+NO11,+NO8) OR (-NO13,-NO12,-NO10,-NO9,-NO7,-NO6,-NO3,-NO1)
17 95823 2^17 = 131072 (-NO15,-NO11,-NO8,-NO7,-NO6)___(+NO14,-NO7)
18 198669 2^18 = 262144 (-NO16,+NO11) OR (-NO15,-NO14,-NO13,-NO12,-NO11)
19 357535 2^19 = 524288 (-NO17,NO15,NO11,NO10,*+NO7*)
20 863317 2^20 = 1048576 (-NO18,+NO16,+NO13,+NO11,+NO10,+NO6)
21 1811764 2^21 = 2097152 (-NO19,+NO18,-NO14,-NO12,-N011,-NO10)
22 3007503 2^22 = 4194304 (-NO20,NO17,NO13,+NO10)
23 5598802 2^23 = 8388608 (-NO21,NO19,NO17,NO15,NO13,+NO11,+NO10)
24 14,428,676 2^24 = 16,777,216 (-NO22,+N021,-NO18,+NO13,+NO11) OR (-NO21,-NO18,+NO13,+NO11)
25 33,185,509 2^25 = 33,554,432 (-NO18,-NO16,-NO15,-NO13,*-NO8,-NO5*) OR (-NO23)
26 54,538,862 2^26 = 67,108,864 (-NO24,+NO22,+NO13,+NO12,*+NO9,+NO6)
27 111,949,941 2^27 = 134,217,728 (-NO25,+NO23,+NO21,+NO19,+NO18,+NO13,+NO12,+NO11,)___(+NO24,+NO23,+NO22,+NO21,+NO19,+NO18,+NO)
28 227,634,408 2^28 = 268,435,456 (-NO26,+24,+23,+20,+16,+14,+13,+11,+10,*+7,+6,+5,+3) OR (-NO25,-23,+20,+16,+14,+13,+11,*+10,+7,+6,+5,+3)
29 400,708,894 2^29 = 536,870,912 (-NO27,-21,+17,+14,+12,+10,*+8,+4,+3,+2,+1)
30 1,033,162,084 2^30 = 1,073,741,824 (-NO25,-22,-21,-19,-17,-16,-13,-12,*-9,-7,-5)
31 2,102,388,551 2^31 = 2,147,483,648 (-NO25,-23,-21,-20,-12,-11,*-7,-5,-4,-3,-)
32 3,093,472,814 2^32 = 4,294,967,296 (-NO30,-26,-25,-24,-23,-21,*+17,+15,+13,+10,**+9,+5,+3,+2,+1) OR (-NO30,-27,+22,+21,*+17,+15,+13,+10,**+9,+5,+3,+2,+1)
33 7,137,437,912 2^33 = 8,589,934,592 (-NO30,-28,-26,-25,-23,-20,*-17,-16,-14,-12,-11,**+7,+6,+4,+3)
34 14,133,072,157 2^34 = 17,179,869,184 (-NO31,-29,-28,-26,-24,-23,-20,*-19,-17,-14,-13,-11,-10,**-9,-7,-6,-5,-1-)
35 20,112,871,792 2^35 = 34,359,738,368 (-NO33,-32,-30#,-28,-24,-21,-20,*+17,+12,*+8,+6,+5,+4)
36 42,387,769,980 2^36 = 68,719,476,736 (-NO34,-33#,-29,-24,-23,*+17,+11,+9,+6--2)
37 100,251,560,595 2^37 = 137,438,953,472 (-NO35,-31#,-29,-27,-23,-20,*+18,+16,+14,+13,+11,**+10)
38 146,971,536,592 2^38 = 274,877,906,944 (-NO36,-35,-34,-32,-31,-30,-29#,+28,+27,+21,+20,*-21K) OR (-NO36,-35,-34,-33,#+29,+28,+27,+21,+20,*-21K)
39 323,724,968,937 2^39 = 549,755,813,888 (-NO37,-36,-34,-31,-30#,+28--23,*+17,+16,+10,-023)
40 1,003,651,412,950 2^40 = 1,099,511,627,776 (-NO36,-34,-33,-30,#-28,-24,-23,-21,-20,*-18,-17,-15,-14,-12,*+)
41 1,458,252,205,147 2^41 = 2,199,023,255,552 (-NO39,-37,-35,-34,-31,#+26,+25,+23,+21,*-341K)
42 2,895,374,552,463 2^42 = 4,398,046,511,104 **(-NO40,-38,-36,-35,-34,-32,-31,-30,#-28,--25,-22,*+300K)
43 7,409,811,047,825 2^43 = 8,796,093,022,208 (-NO40,-38,-33,-31,-30,#-26,-23,-22,-20,*-19,-15K)
44 15,404,761,757,071 2^44 = 17,592,186,044,416 (-NO40,-39,$-38,-37,-36,-35,-34,-32,-30,#-27,-26,-23,-21,-20,*+600K)
45 19,996,463,086,597 2^45 = 35,184,372,088,832 (-NO43,-42,-40,-39,-38,-36,$-30,#+27,+25,+21,*-800K) OR (-NO43,-42,-41,$+37,+36,-1BILION*)
46 51,408,670,348,612 2^46 = 70,368,744,177,664 (-NO44,-40,$-37,-36,-35,-34,-33,-31,#+59M*)
47 119,666,659,114,170 2^47 = 140,737,488,355,328 (-NO44,-41,-40,$-37,-35,-33,*+200M)
48 191,206,974,700,443 2^48 = 281,474,976,710,656 (-NO46,-44,-41,$-36,-35,-32,-30,*+399M*)
49 409,118,905,032,525 2^49 = 562,949,953,421,312 (-NO47,-43,-41,-40,-39,$-38,-37,-35,-31,-30,*+700M*)
50 611,140,496,167,764 2^50 = 1,125,899,906,842,624 (-NO48,-47,-46,-44,-42$,-37,-35,-33,-32,-31,-30#,-26*+3M*)
51 2,058,769,515,153,876 2^51 = 2,251,799,813,685,248 (-NO47,-45,-43,-42,-41,-40,-39#,-36*+2BILION*)
52 4,216,495,639,600,700 2^52 = 4,503,599,627,370,496 (-NO48,-42,-40#,-36,-35,-34,-33,-31,-30*,+600M*)
53 6,763,683,971,478,124 2^53 = 9,007,199,254,740,992 (-NO50,-49,-48,-47$,-46,-45,-44,-43,-40#,+550BILION*)
54 9,974,455,244,496,710 2^54 = 18,014,398,509,481,984 (-NO52,-51,-50,-47$,-44#,-38,-35,-32*,-29,-27,-25,-22,-200k*)
55 30,045,390,491,869,460 2^55 = 36,028,797,018,963,968 (-NO52,-50$,-48,-46,-41#,+100BILLION)
56 44,218,742,292,676,575 2^56 = 72,057,594,037,927,936 (-NO54,-53,-49$,-47,-46,-45,-"[43]"42,-41,-40,-39#,+200BILION*)
57 138,245,758,910,846,492 2^57 = 144,115,188,075,855,872 (-NO52,-50$,-47,-46,-44,-43,-41*,-38*+30BILL)
58 199,976,667,976,342,049 2^58 = 288,230,376,151,711,744 (-NO56,-53,-52,-51,-48,-47$,-43,-41#,-40*)
59 2^59 = 576,460,752,303,423,488
60 2^60 = 1,152,921,504,606,846,976
* point of brute force
|
|
|
|
|
PietCoin97
Jr. Member
Offline
Activity: 91
Merit: 3
|
|
December 06, 2018, 10:15:42 PM |
|
Do you have a formula or anything close? There is no formula, there is a random and our collective unconscious. Therefore, someone will write something, someone will think of something. You never know, I will write now and you will light up (light bulb lights up). Take the last number found. 1011000110011101011011100001010010000110001001101000100001 take the first 3 bytes from it 10110001 10011101 01101110 here we have 10 zeros. Check how many combinations will be from the first byte 10110001, 8008 combinations which we need in place 583 (depending on the given data of course, table for counting in python, I'll leave it down) bin 101100011001110101101110 dec 11640174 multiply this number 34 times by 2 will get ~199976666598998016 practically what you need 199976667976342049. 199976667976342049-199976666598998016=1377344033 error on 1377344033 using a scanner "bitcrack" it's practically nothing. You need to guess just 3 bytes then "bitcrack" will do everything himself. The most important question is how to guess these 3 bytes (and multiply by 2 35 times for 59 puzzle). Now back to my writing. 174176B015F4D
22BD43C2E9354
75070A1A009D4
EFAE164CB9E3C
180788E47E326C
236FB6D5AD1F44
6ABE1F9B67E114
9D18B63AC4FFDF
1EB25C90795D61C
2C675B852189A21
5 or 6 or 7 ...
Well, what's next, 288230376151711744-576460752303423488 ,if 6 it's 430000000000000000-500000000000000000 if 7 500000000000000000-570000000000000000 Depending on the initial number in hex, we get our initial bytes in bit. hex ~610000000000000-6F0000000000000 ~436849163854938112-499899558638125056, 710000000000000-7F0000000000000 ~508906757892866048-571957152676052992. 6 or 7 implies 110 or 111 ("11000000"),("11000001"),("11000010"),("11000011"),("11000100"),("11000101"),("11000110"),("11000111"),
("11001000"),("11001001"),("11001010"),("11001011"),("11001100"),("11001101"),("11001110"),("11001111"),
("11010000"),("11010001"),("11010010"),("11010011"),("11010100"),("11010101"),("11010110"),("11010111"),
("11011000"),("11011001"),("11011010"),("11011011"),("11011100"),("11011101"),("11011110"),("11011111"),
("11100000"),("11100001"),("11100010"),("11100011"),("11100100"),("11100101"),("11100110"),("11100111"),
("11101000"),("11101001"),("11101010"),("11101011"),("11101100"),("11101101"),("11101110"),("11101111"),
("11110000"),("11110001"),("11110010"),("11110011"),("11110100"),("11110101"),("11110110"),("11110111"),
("11111000"),("11111001"),("11111010"),("11111011"),("11111100"),("11111101"),("11111110"),("11111111"),
As we judging by the previous numbers 6 we have mostly hex letters 6ABCDEF and seven with hex numbers 7123456789. We narrow our space 6A0000000000000-6F0000000000000 477381560501272576-499899558638125056. And we get 16 bytes. ("11010000"),("11010001"),("11010010"),("11010011"),("11010100"),("11010101"),("11010110"),("11010111"),
("11011000"),("11011001"),("11011010"),("11011011"),("11011100"),("11011101"),("11011110"),("11011111"), For each of which options are possible with 8-15 zeros. But then you have to think further, or launch a "bitcrack" for everyone 16. It can run multiple copies at the same time. Or try to further filter for example in three bytes "111". On the example of our previous number 10110001 10011101 01101110 here are 2 of them "111" the number of options reduced from 8008 to 4802. python script l1= [("10110001")]
#l1= [("11010000"),("11010001"),("11010010"),("11010011"),("11010100"),("11010101"),("11010110"),("11010111"),
# ("11011000"),("11011001"),("11011010"),("11011011"),("11011100"),("11011101"),("11011110"),("11011111")]
l2= [("10000000"),("10000001"),("10000010"),("10000011"),("10000100"),("10000101"),("10000110"),("10000111"),
("10001000"),("10001001"),("10001010"),("10001011"),("10001100"),("10001101"),("10001110"),("10001111"),
("10010000"),("10010001"),("10010010"),("10010011"),("10010100"),("10010101"),("10010110"),("10010111"),
("10011000"),("10011001"),("10011010"),("10011011"),("10011100"),("10011101"),("10011110"),("10011111"),
("10100000"),("10100001"),("10100010"),("10100011"),("10100100"),("10100101"),("10100110"),("10100111"),
("10101000"),("10101001"),("10101010"),("10101011"),("10101100"),("10101101"),("10101110"),("10101111"),
("10110000"),("10110001"),("10110010"),("10110011"),("10110100"),("10110101"),("10110110"),("10110111"),
("10111000"),("10111001"),("10111010"),("10111011"),("10111100"),("10111101"),("10111110"),("10111111"),
("11000000"),("11000001"),("11000010"),("11000011"),("11000100"),("11000101"),("11000110"),("11000111"),
("11001000"),("11001001"),("11001010"),("11001011"),("11001100"),("11001101"),("11001110"),("11001111"),
("11010000"),("11010001"),("11010010"),("11010011"),("11010100"),("11010101"),("11010110"),("11010111"),
("11011000"),("11011001"),("11011010"),("11011011"),("11011100"),("11011101"),("11011110"),("11011111"),
("11100000"),("11100001"),("11100010"),("11100011"),("11100100"),("11100101"),("11100110"),("11100111"),
("11101000"),("11101001"),("11101010"),("11101011"),("11101100"),("11101101"),("11101110"),("11101111"),
("11110000"),("11110001"),("11110010"),("11110011"),("11110100"),("11110101"),("11110110"),("11110111"),
("11111000"),("11111001"),("11111010"),("11111011"),("11111100"),("11111101"),("11111110"),("11111111"),
("00000000"),("00000001"),("00000010"),("00000011"),("00000100"),("00000101"),("00000110"),("00000111"),
("00001000"),("00001001"),("00001010"),("00001011"),("00001100"),("00001101"),("00001110"),("00001111"),
("00010000"),("00010001"),("00010010"),("00010011"),("00010100"),("00010101"),("00010110"),("00010111"),
("00011000"),("00011001"),("00011010"),("00011011"),("00011100"),("00011101"),("00011110"),("00011111"),
("00100000"),("00100001"),("00100010"),("00100011"),("00100100"),("00100101"),("00100110"),("00100111"),
("00101000"),("00101001"),("00101010"),("00101011"),("00101100"),("00101101"),("00101110"),("00101111"),
("00110000"),("00110001"),("00110010"),("00110011"),("00110100"),("00110101"),("00110110"),("00110111"),
("00111000"),("00111001"),("00111010"),("00111011"),("00111100"),("00111101"),("00111110"),("00111111"),
("01000000"),("01000001"),("01000010"),("01000011"),("01000100"),("01000101"),("01000110"),("01000111"),
("01001000"),("01001001"),("01001010"),("01001011"),("01001100"),("01001101"),("01001110"),("01001111"),
("01010000"),("01010001"),("01010010"),("01010011"),("01010100"),("01010101"),("01010110"),("01010111"),
("01011000"),("01011001"),("01011010"),("01011011"),("01011100"),("01011101"),("01011110"),("01011111"),
("01100000"),("01100001"),("01100010"),("01100011"),("01100100"),("01100101"),("01100110"),("01100111"),
("01101000"),("01101001"),("01101010"),("01101011"),("01101100"),("01101101"),("01101110"),("01101111"),
("01110000"),("01110001"),("01110010"),("01110011"),("01110100"),("01110101"),("01110110"),("01110111"),
("01111000"),("01111001"),("01111010"),("01111011"),("01111100"),("01111101"),("01111110"),("01111111")]
def funk():
for element1 in (l1):
for element2 in (l2):
for element3 in (l2):
bina = element1+element2+element3
nuli = bina.count("0")
if nuli == 10: #zeros count
print(bina)
pass
else:
pass
return None
funk()
[/size] when i take the only first 8 bits and start with 110 and the other bits change i have ths space from 60 to 6F i search now with this setting with 5 cards with 245 Mkeys per card cuBitCrack -d 0 -c -o found0.txt --keyspace 68*************:69************* -b 15 -t 512 -p 4120 -i adresses_50BTC.1.txt --continue test1.txt but for every card another search space in this area make this sense or not? |
|
|
|
|
Andzhig
Jr. Member
Offline
Activity: 183
Merit: 3
|
|
December 07, 2018, 12:09:40 AM
Last edit: December 07, 2018, 12:48:28 AM by Andzhig |
|
make this sense or not? Try to run bitcrack in python. It’s hard to say how best to look for 1 video card at full speed or run multiple copies of the program for one card at a lower speed but with more space options. Depends on the setting. Here is an example script for 20 copies of the program on 1 video card with minimal settings ( apologize, the code may look more compact, I don’t bother with that much). My setup example cuBitCrack.exe -d 0 -i new1.txt -o find.txt -c -u -b 32 -t 256 -p 15 -s where new1.txt address list, find.txt file for dropping found, -c -u comp, uncomp addresses we are also looking for collisions, -b 32 -t 256 -p 15 directly settings for video card it is necessary to select a compromise between the number of copies of the program, or rather the minimum ones at which the program will not begin to crash. for work script copy bitcrack prog. files to dir C:\crackbit ,in it to throw the file with addresses and name new1.txt create empty file find.txt. Create empty file with extension on C:\testpy.cmd Or rename to your own in the python editor itself Edite\Replace... Replace All... import random
from bitcoin import *
import subprocess
import time
#from PyRandLib import *
#rand = FastRand63()
#random.seed(rand())
while 1 == 1:
ii = 1
while ii <= 10000000:
rando = random.randrange(430000000000000000,440000000000000000,1) #288230376151711744,576460752303423488
ran = rando
myhex = "%064x" % ran
myhex = myhex[:64]
priv = myhex
pub = privtopub(priv)
pubkey1 = encode_pubkey(privtopub(priv), "bin_compressed")
addr = pubtoaddr(pubkey1)
oy = """cd "C:\crackbit" """
ey = "\nstart /min cuBitCrack.exe -d 0 -i new1.txt -o find.txt -c -u -b 32 -t 256 -p 15 -s "
f=open("C:/testpy.cmd","w")
f.write (oy)
f.write (ey)
f.write (priv)
f.close()
subprocess.Popen([r"C:/testpy.cmd"])
print(rando,addr,priv,bin(rando))
time.sleep(0.1)
rando = random.randrange(440000000000000000,450000000000000000,1) #288230376151711744,576460752303423488
ran = rando
myhex = "%064x" % ran
myhex = myhex[:64]
priv = myhex
pub = privtopub(priv)
pubkey1 = encode_pubkey(privtopub(priv), "bin_compressed")
addr = pubtoaddr(pubkey1)
oy = """cd "C:\crackbit" """
ey = "\nstart /min cuBitCrack.exe -d 0 -i new1.txt -o find.txt -c -u -b 32 -t 256 -p 15 -s "
f=open("C:/testpy.cmd","w")
f.write (oy)
f.write (ey)
f.write (priv)
f.close()
subprocess.Popen([r"C:/testpy.cmd"])
print(rando,addr,priv,bin(rando))
time.sleep(0.1)
rando = random.randrange(450000000000000000,460000000000000000,1) #288230376151711744,576460752303423488
ran = rando
myhex = "%064x" % ran
myhex = myhex[:64]
priv = myhex
pub = privtopub(priv)
pubkey1 = encode_pubkey(privtopub(priv), "bin_compressed")
addr = pubtoaddr(pubkey1)
oy = """cd "C:\crackbit" """
ey = "\nstart /min cuBitCrack.exe -d 0 -i new1.txt -o find.txt -c -u -b 32 -t 256 -p 15 -s "
f=open("C:/testpy.cmd","w")
f.write (oy)
f.write (ey)
f.write (priv)
f.close()
subprocess.Popen([r"C:/testpy.cmd"])
print(rando,addr,priv,bin(rando))
time.sleep(0.1)
rando = random.randrange(460000000000000000,470000000000000000,1) #288230376151711744,576460752303423488
ran = rando
myhex = "%064x" % ran
myhex = myhex[:64]
priv = myhex
pub = privtopub(priv)
pubkey1 = encode_pubkey(privtopub(priv), "bin_compressed")
addr = pubtoaddr(pubkey1)
oy = """cd "C:\crackbit" """
ey = "\nstart /min cuBitCrack.exe -d 0 -i new1.txt -o find.txt -c -u -b 32 -t 256 -p 15 -s "
f=open("C:/testpy.cmd","w")
f.write (oy)
f.write (ey)
f.write (priv)
f.close()
subprocess.Popen([r"C:/testpy.cmd"])
print(rando,addr,priv,bin(rando))
time.sleep(0.1)
rando = random.randrange(470000000000000000,480000000000000000,1) #288230376151711744,576460752303423488
ran = rando
myhex = "%064x" % ran
myhex = myhex[:64]
priv = myhex
pub = privtopub(priv)
pubkey1 = encode_pubkey(privtopub(priv), "bin_compressed")
addr = pubtoaddr(pubkey1)
oy = """cd "C:\crackbit" """
ey = "\nstart /min cuBitCrack.exe -d 0 -i new1.txt -o find.txt -c -u -b 32 -t 256 -p 15 -s "
f=open("C:/testpy.cmd","w")
f.write (oy)
f.write (ey)
f.write (priv)
f.close()
subprocess.Popen([r"C:/testpy.cmd"])
print(rando,addr,priv,bin(rando))
time.sleep(0.1)
rando = random.randrange(480000000000000000,490000000000000000,1) #288230376151711744,576460752303423488
ran = rando
myhex = "%064x" % ran
myhex = myhex[:64]
priv = myhex
pub = privtopub(priv)
pubkey1 = encode_pubkey(privtopub(priv), "bin_compressed")
addr = pubtoaddr(pubkey1)
oy = """cd "C:\crackbit" """
ey = "\nstart /min cuBitCrack.exe -d 0 -i new1.txt -o find.txt -c -u -b 32 -t 256 -p 15 -s "
f=open("C:/testpy.cmd","w")
f.write (oy)
f.write (ey)
f.write (priv)
f.close()
subprocess.Popen([r"C:/testpy.cmd"])
print(rando,addr,priv,bin(rando))
time.sleep(0.1)
rando = random.randrange(490000000000000000,500000000000000000,1) #288230376151711744,576460752303423488
ran = rando
myhex = "%064x" % ran
myhex = myhex[:64]
priv = myhex
pub = privtopub(priv)
pubkey1 = encode_pubkey(privtopub(priv), "bin_compressed")
addr = pubtoaddr(pubkey1)
oy = """cd "C:\crackbit" """
ey = "\nstart /min cuBitCrack.exe -d 0 -i new1.txt -o find.txt -c -u -b 32 -t 256 -p 15 -s "
f=open("C:/testpy.cmd","w")
f.write (oy)
f.write (ey)
f.write (priv)
f.close()
subprocess.Popen([r"C:/testpy.cmd"])
print(rando,addr,priv,bin(rando))
time.sleep(0.1)
rando = random.randrange(500000000000000000,510000000000000000,1) #288230376151711744,576460752303423488
ran = rando
myhex = "%064x" % ran
myhex = myhex[:64]
priv = myhex
pub = privtopub(priv)
pubkey1 = encode_pubkey(privtopub(priv), "bin_compressed")
addr = pubtoaddr(pubkey1)
oy = """cd "C:\crackbit" """
ey = "\nstart /min cuBitCrack.exe -d 0 -i new1.txt -o find.txt -c -u -b 32 -t 256 -p 15 -s "
f=open("C:/testpy.cmd","w")
f.write (oy)
f.write (ey)
f.write (priv)
f.close()
subprocess.Popen([r"C:/testpy.cmd"])
print(rando,addr,priv,bin(rando))
time.sleep(0.1)
rando = random.randrange(510000000000000000,520000000000000000,1) #288230376151711744,576460752303423488
ran = rando
myhex = "%064x" % ran
myhex = myhex[:64]
priv = myhex
pub = privtopub(priv)
pubkey1 = encode_pubkey(privtopub(priv), "bin_compressed")
addr = pubtoaddr(pubkey1)
oy = """cd "C:\crackbit" """
ey = "\nstart /min cuBitCrack.exe -d 0 -i new1.txt -o find.txt -c -u -b 32 -t 256 -p 15 -s "
f=open("C:/testpy.cmd","w")
f.write (oy)
f.write (ey)
f.write (priv)
f.close()
subprocess.Popen([r"C:/testpy.cmd"])
print(rando,addr,priv,bin(rando))
time.sleep(0.1)
rando = random.randrange(520000000000000000,530000000000000000,1) #288230376151711744,576460752303423488
ran = rando
myhex = "%064x" % ran
myhex = myhex[:64]
priv = myhex
pub = privtopub(priv)
pubkey1 = encode_pubkey(privtopub(priv), "bin_compressed")
addr = pubtoaddr(pubkey1)
oy = """cd "C:\crackbit" """
ey = "\nstart /min cuBitCrack.exe -d 0 -i new1.txt -o find.txt -c -u -b 32 -t 256 -p 15 -s "
f=open("C:/testpy.cmd","w")
f.write (oy)
f.write (ey)
f.write (priv)
f.close()
subprocess.Popen([r"C:/testpy.cmd"])
print(rando,addr,priv,bin(rando))
time.sleep(0.1)
rando = random.randrange(530000000000000000,540000000000000000,1) #288230376151711744,576460752303423488
ran = rando
myhex = "%064x" % ran
myhex = myhex[:64]
priv = myhex
pub = privtopub(priv)
pubkey1 = encode_pubkey(privtopub(priv), "bin_compressed")
addr = pubtoaddr(pubkey1)
oy = """cd "C:\crackbit" """
ey = "\nstart /min cuBitCrack.exe -d 0 -i new1.txt -o find.txt -c -u -b 32 -t 256 -p 15 -s "
f=open("C:/testpy.cmd","w")
f.write (oy)
f.write (ey)
f.write (priv)
f.close()
subprocess.Popen([r"C:/testpy.cmd"])
print(rando,addr,priv,bin(rando))
time.sleep(0.1)
rando = random.randrange(540000000000000000,550000000000000000,1) #288230376151711744,576460752303423488
ran = rando
myhex = "%064x" % ran
myhex = myhex[:64]
priv = myhex
pub = privtopub(priv)
pubkey1 = encode_pubkey(privtopub(priv), "bin_compressed")
addr = pubtoaddr(pubkey1)
oy = """cd "C:\crackbit" """
ey = "\nstart /min cuBitCrack.exe -d 0 -i new1.txt -o find.txt -c -u -b 32 -t 256 -p 15 -s "
f=open("C:/testpy.cmd","w")
f.write (oy)
f.write (ey)
f.write (priv)
f.close()
subprocess.Popen([r"C:/testpy.cmd"])
print(rando,addr,priv,bin(rando))
time.sleep(0.1)
rando = random.randrange(550000000000000000,560000000000000000,1) #288230376151711744,576460752303423488
ran = rando
myhex = "%064x" % ran
myhex = myhex[:64]
priv = myhex
pub = privtopub(priv)
pubkey1 = encode_pubkey(privtopub(priv), "bin_compressed")
addr = pubtoaddr(pubkey1)
oy = """cd "C:\crackbit" """
ey = "\nstart /min cuBitCrack.exe -d 0 -i new1.txt -o find.txt -c -u -b 32 -t 256 -p 15 -s "
f=open("C:/testpy.cmd","w")
f.write (oy)
f.write (ey)
f.write (priv)
f.close()
subprocess.Popen([r"C:/testpy.cmd"])
print(rando,addr,priv,bin(rando))
time.sleep(0.1)
rando = random.randrange(430000000000000000,440000000000000000,1) #288230376151711744,576460752303423488
ran = rando
myhex = "%064x" % ran
myhex = myhex[:64]
priv = myhex
pub = privtopub(priv)
pubkey1 = encode_pubkey(privtopub(priv), "bin_compressed")
addr = pubtoaddr(pubkey1)
oy = """cd "C:\crackbit" """
ey = "\nstart /min cuBitCrack.exe -d 0 -i new1.txt -o find.txt -c -u -b 32 -t 256 -p 15 -s "
f=open("C:/testpy.cmd","w")
f.write (oy)
f.write (ey)
f.write (priv)
f.close()
subprocess.Popen([r"C:/testpy.cmd"])
print(rando,addr,priv,bin(rando))
time.sleep(0.1)
rando = random.randrange(440000000000000000,450000000000000000,1) #288230376151711744,576460752303423488
ran = rando
myhex = "%064x" % ran
myhex = myhex[:64]
priv = myhex
pub = privtopub(priv)
pubkey1 = encode_pubkey(privtopub(priv), "bin_compressed")
addr = pubtoaddr(pubkey1)
oy = """cd "C:\crackbit" """
ey = "\nstart /min cuBitCrack.exe -d 0 -i new1.txt -o find.txt -c -u -b 32 -t 256 -p 15 -s "
f=open("C:/testpy.cmd","w")
f.write (oy)
f.write (ey)
f.write (priv)
f.close()
subprocess.Popen([r"C:/testpy.cmd"])
print(rando,addr,priv,bin(rando))
time.sleep(0.1)
rando = random.randrange(450000000000000000,460000000000000000,1) #288230376151711744,576460752303423488
ran = rando
myhex = "%064x" % ran
myhex = myhex[:64]
priv = myhex
pub = privtopub(priv)
pubkey1 = encode_pubkey(privtopub(priv), "bin_compressed")
addr = pubtoaddr(pubkey1)
oy = """cd "C:\crackbit" """
ey = "\nstart /min cuBitCrack.exe -d 0 -i new1.txt -o find.txt -c -u -b 32 -t 256 -p 15 -s "
f=open("C:/testpy.cmd","w")
f.write (oy)
f.write (ey)
f.write (priv)
f.close()
subprocess.Popen([r"C:/testpy.cmd"])
print(rando,addr,priv,bin(rando))
time.sleep(0.1)
rando = random.randrange(460000000000000000,470000000000000000,1) #288230376151711744,576460752303423488
ran = rando
myhex = "%064x" % ran
myhex = myhex[:64]
priv = myhex
pub = privtopub(priv)
pubkey1 = encode_pubkey(privtopub(priv), "bin_compressed")
addr = pubtoaddr(pubkey1)
oy = """cd "C:\crackbit" """
ey = "\nstart /min cuBitCrack.exe -d 0 -i new1.txt -o find.txt -c -u -b 32 -t 256 -p 15 -s "
f=open("C:/testpy.cmd","w")
f.write (oy)
f.write (ey)
f.write (priv)
f.close()
subprocess.Popen([r"C:/testpy.cmd"])
print(rando,addr,priv,bin(rando))
time.sleep(0.1)
rando = random.randrange(470000000000000000,480000000000000000,1) #288230376151711744,576460752303423488
ran = rando
myhex = "%064x" % ran
myhex = myhex[:64]
priv = myhex
pub = privtopub(priv)
pubkey1 = encode_pubkey(privtopub(priv), "bin_compressed")
addr = pubtoaddr(pubkey1)
oy = """cd "C:\crackbit" """
ey = "\nstart /min cuBitCrack.exe -d 0 -i new1.txt -o find.txt -c -u -b 32 -t 256 -p 15 -s "
f=open("C:/testpy.cmd","w")
f.write (oy)
f.write (ey)
f.write (priv)
f.close()
subprocess.Popen([r"C:/testpy.cmd"])
print(rando,addr,priv,bin(rando))
time.sleep(0.1)
rando = random.randrange(480000000000000000,490000000000000000,1) #288230376151711744,576460752303423488
ran = rando
myhex = "%064x" % ran
myhex = myhex[:64]
priv = myhex
pub = privtopub(priv)
pubkey1 = encode_pubkey(privtopub(priv), "bin_compressed")
addr = pubtoaddr(pubkey1)
oy = """cd "C:\crackbit" """
ey = "\nstart /min cuBitCrack.exe -d 0 -i new1.txt -o find.txt -c -u -b 32 -t 256 -p 15 -s "
f=open("C:/testpy.cmd","w")
f.write (oy)
f.write (ey)
f.write (priv)
f.close()
subprocess.Popen([r"C:/testpy.cmd"])
print(rando,addr,priv,bin(rando))
time.sleep(0.1)
rando = random.randrange(490000000000000000,550000000000000000,1) #288230376151711744,576460752303423488
ran = rando
myhex = "%064x" % ran
myhex = myhex[:64]
priv = myhex
pub = privtopub(priv)
pubkey1 = encode_pubkey(privtopub(priv), "bin_compressed")
addr = pubtoaddr(pubkey1)
oy = """cd "C:\crackbit" """
ey = "\nstart /min cuBitCrack.exe -d 0 -i new1.txt -o find.txt -c -u -b 32 -t 256 -p 15 -s "
f=open("C:/testpy.cmd","w")
f.write (oy)
f.write (ey)
f.write (priv)
f.close()
subprocess.Popen([r"C:/testpy.cmd"])
print(rando,addr,priv,bin(rando))
time.sleep(180.0) # time for scan in sec
subprocess.call("taskkill /IM cuBitCrack.exe")
ii = ii +1
pass
[/size] Will scan randomly assigned ranges.with a 180 second scan interval. 436255798676581527 1DEJj2kLLPApXWKtvN6LxK4khX6TWe1vRs 000000000000000000000000000000000000000000000000060de45667526c97 0b11000001101111001000101011001100111010100100110110010010111
441507056942360318 1PfpMYgqG1XvqGAB7VbmEkqi5LJcZXH1tE 00000000000000000000000000000000000000000000000006208c543ee0a6fe 0b11000100000100011000101010000111110111000001010011011111110
459138491207522404 1P65P9uq3jh6dQGn71ty1ncwetfsYYaDBJ 000000000000000000000000000000000000000000000000065f30066f221864 0b11001011111001100000000011001101111001000100001100001100100
461915945739820515 1AVY8PpJWoRitWvqLo3TM4Mkjox4DdXHMU 00000000000000000000000000000000000000000000000006690e1af5e91de3 0b11001101001000011100001101011110101111010010001110111100011
475748685656264755 1QCr7MjWX8KPqroPCGvCd8154TYQSQ7qjb 000000000000000000000000000000000000000000000000069a32e8b2e69033 0b11010011010001100101110100010110010111001101001000000110011
480437702123105246 1Q5bJch874J1qLFX9d1kGbg5hwS29WXYPZ 00000000000000000000000000000000000000000000000006aadb8b6bc0abde 0b11010101010110110111000101101101011110000001010101111011110
499681233881334263 1J2jKM66vsbxnQwhny6FNbnFhYW6SoPYhy 00000000000000000000000000000000000000000000000006ef396f4e6d01f7 0b11011101111001110010110111101001110011011010000000111110111
505963224890171215 1PmhNACinLrHKpZKAe2qRVQHUpb4fg64b2 00000000000000000000000000000000000000000000000007058adf50fd5f4f 0b11100000101100010101101111101010000111111010101111101001111
519981219040329526 1BdnH1wb1EJ8AerfecP8MoyhhAErELxhdN 00000000000000000000000000000000000000000000000007375829eac5ff36 0b11100110111010110000010100111101010110001011111111100110110
525573134512519358 1N51AuBTfKXuFW5gz8SmrvZSjXuJUqFS5v 000000000000000000000000000000000000000000000000074b35fb321b78be 0b11101001011001101011111101100110010000110110111100010111110
535208647800522894 1AKrVPBrepAGQ5iUh1hGtXZtK1UG9jM6oC 000000000000000000000000000000000000000000000000076d716df4de088e 0b11101101101011100010110110111110100110111100000100010001110
547573542492859303 1218GFAz7U2CMt3Dg1NANWXASRPd2GUehZ 00000000000000000000000000000000000000000000000007995f3c58b06ba7 0b11110011001010111110011110001011000101100000110101110100111
551235443847304427 1FWRjD8vc5V1292wmwETiEwKEvCRDwnN47 00000000000000000000000000000000000000000000000007a661b7321f94eb 0b11110100110011000011011011100110010000111111001010011101011
431862599371012664 1NQtY7KvWhLZSMvubxJ1N3qFobn9mWK3vR 00000000000000000000000000000000000000000000000005fe48befb493a38 0b10111111110010010001011111011111011010010010011101000111000
442689619007000816 1JZQqE3Hq7615DE7akCA6W8WgWGrbAQvpu 0000000000000000000000000000000000000000000000000624bfdceeaa50f0 0b11000100100101111111101110011101110101010100101000011110000
450054996901302633 1MY1L5LjuLGVqSEGkdTqMa2KrmjPMhBVfW 000000000000000000000000000000000000000000000000063eeaa29bb11169 0b11000111110111010101010001010011011101100010001000101101001
463404660570563360 1EwsCkEFdGfkDvkyjntydoq7Prrm6kXzeY 000000000000000000000000000000000000000000000000066e58156491a320 0b11001101110010110000001010101100100100100011010001100100000
476391074956334032 1HM3dYR8RUgwD2NpwpmbGaE5VPpej4hrbu 000000000000000000000000000000000000000000000000069c7b289cf053d0 0b11010011100011110110010100010011100111100000101001111010000
485975192431053672 1E4YP4KmAu62DiR1rxDmCoNvBKvyq8HAN2 00000000000000000000000000000000000000000000000006be87dcda814b68 0b11010111110100001111101110011011010100000010100101101101000
495091615987254152 12jHiq9UrxA9Uk38W9B1YH6Y8pVzKJ4VSx 00000000000000000000000000000000000000000000000006deeb339e31c388 0b11011011110111010110011001110011110001100011100001110001000 180 sec 434397307476904640 1KwmnYnwx3RBdai8Hg6gg9YioUqRE5SyPz 00000000000000000000000000000000000000000000000006074a0cb38c0ac0 0b11000000111010010100000110010110011100011000000101011000000
448180614452161049 1Dm66qi8M9XV1nXmUpNTXKPkuJfiCqAbka 000000000000000000000000000000000000000000000000063841e4efa32a19 0b11000111000010000011110010011101111101000110010101000011001
455848687860036132 1AohCP71Q6ETRPAJvfYL1YA9FgJimUrTYD 00000000000000000000000000000000000000000000000006537ff76739b224 0b11001010011011111111111011101100111001110011011001000100100
462603130947331666 1JRTAE82D57BKeK42BD7V6AEbaUXwVvQh1 000000000000000000000000000000000000000000000000066b7f18bc196652 0b11001101011011111110001100010111100000110010110011001010010
477874477159224936 1PiJTdZZXpU3qCLhJQ8XDJcTTGfjvyQWbW 00000000000000000000000000000000000000000000000006a1c04e1a4d1668 0b11010100001110000000100111000011010010011010001011001101000
489611196952328879 1J7acijCcCh6RomLPNGhziRz4UaKeuHWPe 00000000000000000000000000000000000000000000000006cb72ca2065baaf 0b11011001011011100101100101000100000011001011011101010101111
497692554980595627 1CZf3pPim9Qv5EaM4mPMbrNQ1WAd4bSFoR 00000000000000000000000000000000000000000000000006e828bdeaf997ab 0b11011101000001010001011110111101010111110011001011110101011
504154894995661991 1LhjwaKt5Z6ZRDp6zRspzxa66vm54L4Uf5 00000000000000000000000000000000000000000000000006ff1e34b3fda4a7 0b11011111111000111100011010010110011111111011010010010100111
513734719315617733 18S5yDG4t1z6cNy5XL3E4dCsZsLbzJFWuv 000000000000000000000000000000000000000000000000072127015d97a7c5 0b11100100001001001110000000101011101100101111010011111000101
524089558560688939 1HMtuBWjn84XVrPTp472avYm122Ug9J9mY 0000000000000000000000000000000000000000000000000745f0ad40804b2b 0b11101000101111100001010110101000000100000000100101100101011
533526184362501078 1LbVYerCAykwoFRNNq1HEcEETnx99kofNN 0000000000000000000000000000000000000000000000000767773ce94be3d6 0b11101100111011101110011110011101001010010111110001111010110
541141267079494343 1MkHc9tQ2zfWfmKqDjCyZ8mT8DFaxcmQwr 0000000000000000000000000000000000000000000000000782851d8593fac7 0b11110000010100001010001110110000101100100111111101011000111
557294163226682575 1GbmYRdFQ7Muj2qLETcnFTRjt6JT2nt65W 00000000000000000000000000000000000000000000000007bbe816ba8664cf 0b11110111011111010000001011010111010100001100110010011001111
431426588295510113 1H7JEXVK6n2DR2m5dvnCGS8mog2Ub5Hpob 00000000000000000000000000000000000000000000000005fcbc323e033861 0b10111111100101111000011001000111110000000110011100001100001
440184254933268814 16unzLvdVK3onNS5PkUELXvYELMEnj25Aj 000000000000000000000000000000000000000000000000061bd93f6704794e 0b11000011011110110010011111101100111000001000111100101001110
452076765920283756 13uebyVH62vYMvKKKiWWtXFCv1EMyFMxQE 0000000000000000000000000000000000000000000000000646196c63e2cc6c 0b11001000110000110010110110001100011111000101100110001101100
466109431548019383 14sP97eQyj6GRXAdccdpdpbLF67EzVNd4r 0000000000000000000000000000000000000000000000000677f40ef5e102b7 0b11001110111111101000000111011110101111000010000001010110111
473565831398854640 1GgMgAuUF4U8XjYo5pGFmuZvPRbSoxJYaJ 0000000000000000000000000000000000000000000000000692719d564a8ff0 0b11010010010011100011001110101010110010010101000111111110000
481001336899844371 13sMZvkWA7aqSKAXAtAPWEwS2UQFc3Wruc 00000000000000000000000000000000000000000000000006acdc2ade673913 0b11010101100110111000010101011011110011001110011100100010011
505710979847703937 19LpNTAN5orXp3pD27Hkqy3BKB1p88uyyz 0000000000000000000000000000000000000000000000000704a574f0d64d81 0b11100000100101001010111010011110000110101100100110110000001
On 5 cards, maybe you can run 500 copies of the program at the same time. |
|
|
|
|
Andzhig
Jr. Member
Offline
Activity: 183
Merit: 3
|
|
December 07, 2018, 12:35:24 AM |
|
It may be worth looking for the next 10-20 filter puzzles 60,61,62,63.... Need to analyze what bits can be in those addresses, there, of course, the error (deviation) may exceed the number with 9 zeros.
0 111 101
101100011001110101101110 0001010010000110001001101000100001 33-25 10 2 3 11640174 B19D6E
111101011001001011100100 100000111100101011101011000011100 28-29 11 2 2 16093924 F592E4
100111010001100010110110 00111010110001001111111111011111 22-34 12 1 3 10295478 9D18B6
110101010111110000111111 0011011011001111110000100010100 24-31 8 3 2 13990975 D57C3F
100011011011111011011011 010101101011010001111101000100 23-31 8 1 5 9289435 8DBEDB
110000000011110001000111 00100011111100011001001101100 29-24 14 2 0 12598343 C03C47
111011111010111000010110 0100110010111001111000111100 22-30 9 3 3 15707670 EFAE16
111010100000111000010100 001101000000000100111010000 33-18 14 2 2 15339028 EA0E14
100010101111010100001111 00001011101001001101010100 26-24 11 2 2 9106703 8AF50F
101110100000101110110101 1000000010101111101001101 24-25 11 2 5 12192693 BA0BB5
101011011110011011010111 110011100011101110011011 17-31 8 2 4 11396823 ADE6D7
110110011010110000100001 01101010011110010111010 23-24 13 0 2 14265377 D9AC21
101110110000011000001110 0010001101010101000100 27-19 13 2 2 12256782 BB060E
100100010111111001010000 101000011110000000101 26 -19 13 2 2 9535056 917E50
111000000010101100110101 10100011010110001111 22-22 13 1 2 14691125 E02B35
110101111010011101100100 1111100010110010001 19-24 10 2 3 14133092 D7A764
101010001000100001110001 011000110110001111 23-19 15 1 1 11044977 A88871
101010011100001101001101 01100110001011011 20-21 12 1 3 11125581 A9C34D
111010011010111001001001 0011001111010110 18-22 11 2 2 15314505 E9AE49
100101101011111100000110 000001111101001 19-20 11 2 2 9879302 96BF06
100010001110000010111110 10110011010000 21-17 13 2 1 8970430 88E0BE
101110101011101110101011 0101010010011 14 -22 8 3 6 12237739 BABBAB
100111011110100000100000 101001111100 19- 17 14 2 2 10348576 9DE820
100101011101101001000010 00101110000 20-15 13 1 3 9820738 95DA42
110100101001100101100100 0100011101 18-16 13 0 3 13801828 D29964
110101001011011001010100 011011000 17-16 12 0 4 13940308 D4B654
101110000110001010100110 00101110 17-15 13 1 2 12083878 B862A6
111110101001111111001110 1000111 10-21 7 4 1 16424910 FA9FCE
111101100101001100110101 100100 14-16 10 1 3 16143157 F65335
101111110001001010101000 11110 13-16 12 2 3 12522152 BF12A8
110110010001011011001110 1000 14-14 11 1 3 14227150 D916CE
110101011000011100001110 101 13-14 12 2 2 13993742 D5870E
110100000000110010011011 10 15-11 14 0 2 13634715 D00C9B
111111010010111101110010 1 8-17 8 4 3 16592754 FD2F72
110111000010101000000100 15-9 15 1 2 14428676 DC2A04
repeat 4 > 11 2 2, repeat 2 > 10 2 3, repeat 2 > 12 1 3, repeat 2 > 14 2 2 ,repeat 2> 13 2 2.
|
|
|
|
|
PietCoin97
Jr. Member
Offline
Activity: 91
Merit: 3
|
|
December 07, 2018, 02:32:00 PM |
|
OK so the code will be really long with 500 starting points.
So how do this code work do the code check mabey 10mkey per search space and then the change after 180 sec?
And do the code print all like you show me or only founds?
|
|
|
|
|
Andzhig
Jr. Member
Offline
Activity: 183
Merit: 3
|
|
December 07, 2018, 06:07:54 PM
Last edit: December 07, 2018, 06:20:54 PM by Andzhig |
|
And do the code print all like you show me or only founds? not understood. Only this will write or that you indicate to him in the "print (blablabla)". python 3 just run bitcrack so that it does not start manually. Can run from python idle, can simply double click on the blablabla.py file script without idle. 110101110001101001111000 484369781529509888 18PeFv41FQ7uVDdNGt7i1LfnZZyezSsejP 00000000000000000000000000000000000000000000000006b8d3c000000000 0b11010111000110100111100000000000000000000000000000000000000
110101101000001110001010 483042189958447104 1EJg7g9vsQPCRuGaVxAUHGiwsZ5b4H4h4K 00000000000000000000000000000000000000000000000006b41c5000000000 0b11010110100000111000101000000000000000000000000000000000000
110101110011000101010111 484570957797654528 1A1D9jeYo8r7fkkTRLDRoMMn4iMSkytjcw 00000000000000000000000000000000000000000000000006b98ab800000000 0b11010111001100010101011100000000000000000000000000000000000
110100111000001000111111 476275417443991552 16aVvWoxxC4eJ8cEtP4FUpz3cLaB2pPV12 000000000000000000000000000000000000000000000000069c11f800000000 0b11010011100000100011111100000000000000000000000000000000000
110100111011011000110111 476732539403239424 1Mbyuvjvyty1Lc849rn87mhQRE6v6FpQHQ 000000000000000000000000000000000000000000000000069db1b800000000 0b11010011101101100011011100000000000000000000000000000000000
110111010100111100011100 498343612245868544 121Hz1XawZudRzMhtEYNxceTUFvrLfwCYK 00000000000000000000000000000000000000000000000006ea78e000000000 0b11011101010011110001110000000000000000000000000000000000000
110101010000011010001000 479690809797509120 15EKuQWW97hDEysicZMbojpGGQWoB2VBhy 00000000000000000000000000000000000000000000000006a8344000000000 0b11010101000001101000100000000000000000000000000000000000000
110101000010000011110111 477671522333360128 1MvzoKWtgELYWMwMbstqyBEhDREGL4KwXN 00000000000000000000000000000000000000000000000006a107b800000000 0b11010100001000001111011100000000000000000000000000000000000
110101011001100111101000 480987134006657024 1DTwSYy5X2zLTcRZq5EcFKfk5ctMPFmcCt 00000000000000000000000000000000000000000000000006accf4000000000 0b11010101100110011110100000000000000000000000000000000000000
110110010011011010010000 489120496395223040 1J5WMtSWrufSZ5u36DoBucXQLqVHB3N7Qh 00000000000000000000000000000000000000000000000006c9b48000000000 0b11011001001101101001000000000000000000000000000000000000000Try this one for the test (yet without filter 111 101). Settings, anyway, will have to sort out. You have such -b 15 -t 512 -p 4120 why did you choose -b 15? Let's try these -b 32 -t 256 -p 512 for 10 copies. import random
from bitcoin import *
import subprocess
import time
#from PyRandLib import *
#rand = FastRand63()
#random.seed(rand())
#l1= [("11010000")]
l1= [("11010000"),("11010001"),("11010010"),("11010011"),("11010100"),("11010101"),("11010110"),("11010111"), # start 8 bit, random list or 1 first.
("11011000"),("11011001"),("11011010"),("11011011"),("11011100"),("11011101"),("11011110"),("11011111")]
l2= [("10000000"),("10000001"),("10000010"),("10000011"),("10000100"),("10000101"),("10000110"),("10000111"), # second and third bits random list.
("10001000"),("10001001"),("10001010"),("10001011"),("10001100"),("10001101"),("10001110"),("10001111"),
("10010000"),("10010001"),("10010010"),("10010011"),("10010100"),("10010101"),("10010110"),("10010111"),
("10011000"),("10011001"),("10011010"),("10011011"),("10011100"),("10011101"),("10011110"),("10011111"),
("10100000"),("10100001"),("10100010"),("10100011"),("10100100"),("10100101"),("10100110"),("10100111"),
("10101000"),("10101001"),("10101010"),("10101011"),("10101100"),("10101101"),("10101110"),("10101111"),
("10110000"),("10110001"),("10110010"),("10110011"),("10110100"),("10110101"),("10110110"),("10110111"),
("10111000"),("10111001"),("10111010"),("10111011"),("10111100"),("10111101"),("10111110"),("10111111"),
("11000000"),("11000001"),("11000010"),("11000011"),("11000100"),("11000101"),("11000110"),("11000111"),
("11001000"),("11001001"),("11001010"),("11001011"),("11001100"),("11001101"),("11001110"),("11001111"),
("11010000"),("11010001"),("11010010"),("11010011"),("11010100"),("11010101"),("11010110"),("11010111"),
("11011000"),("11011001"),("11011010"),("11011011"),("11011100"),("11011101"),("11011110"),("11011111"),
("11100000"),("11100001"),("11100010"),("11100011"),("11100100"),("11100101"),("11100110"),("11100111"),
("11101000"),("11101001"),("11101010"),("11101011"),("11101100"),("11101101"),("11101110"),("11101111"),
("11110000"),("11110001"),("11110010"),("11110011"),("11110100"),("11110101"),("11110110"),("11110111"),
("11111000"),("11111001"),("11111010"),("11111011"),("11111100"),("11111101"),("11111110"),("11111111"),
("00000000"),("00000001"),("00000010"),("00000011"),("00000100"),("00000101"),("00000110"),("00000111"),
("00001000"),("00001001"),("00001010"),("00001011"),("00001100"),("00001101"),("00001110"),("00001111"),
("00010000"),("00010001"),("00010010"),("00010011"),("00010100"),("00010101"),("00010110"),("00010111"),
("00011000"),("00011001"),("00011010"),("00011011"),("00011100"),("00011101"),("00011110"),("00011111"),
("00100000"),("00100001"),("00100010"),("00100011"),("00100100"),("00100101"),("00100110"),("00100111"),
("00101000"),("00101001"),("00101010"),("00101011"),("00101100"),("00101101"),("00101110"),("00101111"),
("00110000"),("00110001"),("00110010"),("00110011"),("00110100"),("00110101"),("00110110"),("00110111"),
("00111000"),("00111001"),("00111010"),("00111011"),("00111100"),("00111101"),("00111110"),("00111111"),
("01000000"),("01000001"),("01000010"),("01000011"),("01000100"),("01000101"),("01000110"),("01000111"),
("01001000"),("01001001"),("01001010"),("01001011"),("01001100"),("01001101"),("01001110"),("01001111"),
("01010000"),("01010001"),("01010010"),("01010011"),("01010100"),("01010101"),("01010110"),("01010111"),
("01011000"),("01011001"),("01011010"),("01011011"),("01011100"),("01011101"),("01011110"),("01011111"),
("01100000"),("01100001"),("01100010"),("01100011"),("01100100"),("01100101"),("01100110"),("01100111"),
("01101000"),("01101001"),("01101010"),("01101011"),("01101100"),("01101101"),("01101110"),("01101111"),
("01110000"),("01110001"),("01110010"),("01110011"),("01110100"),("01110101"),("01110110"),("01110111"),
("01111000"),("01111001"),("01111010"),("01111011"),("01111100"),("01111101"),("01111110"),("01111111")]
def take1():
yy = str(random.choice(l1))
return yy
def take2():
uu = str(random.choice(l2))
return uu
def rana():
s = [take2(),take2()]
d = ''.join(random.sample(s,len(s)))
bina = (take1()+d)
return bina
def funk():
aaa = rana()
b = int(aaa,2)*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2*2
ran = b
myhex = "%064x" % ran
myhex = myhex[:64]
priv = myhex
pub = privtopub(priv)
pubkey1 = encode_pubkey(privtopub(priv), "bin_compressed")
addr = pubtoaddr(pubkey1)
oy = """cd "C:\crackbit" """
ey = "\nstart /min cuBitCrack.exe -d 0 -i new1.txt -o find.txt -c -u -b 32 -t 256 -p 512 -s " # bitcrack settings
f=open("C:/testpy.cmd","w")
f.write (oy)
f.write (ey)
f.write (priv)
f.close()
subprocess.Popen([r"C:/testpy.cmd"])
print(aaa,b,addr,priv,bin(b)) # print(blablabla)
time.sleep(0.1)
return None
while True:
for a in range(10): # number of copies
funk()
time.sleep(180.0) # break between restarts, scan time, in sec
subprocess.call("taskkill /IM cuBitCrack.exe") [/size] |
|
|
|
|
|
