Bitcoin Forum
September 15, 2019, 11:14:45 PM *
News: If you like a topic and you see an orange "bump" link, click it. More info.
 
   Home   Help Search Login Register More  
Pages: « 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 [28] 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 »
  Print  
Author Topic: Bitcoin puzzle transaction ~32 BTC prize to who solves it  (Read 73831 times)
Amnuazka
Newbie
*
Offline Offline

Activity: 12
Merit: 0


View Profile
November 23, 2018, 03:35:09 AM
 #541

This puzzle is very strange. If it's for measuring the world's brute forcing capacity, 161-256 are just a waste (RIPEMD160 entropy is filled by 160, and by all of P2PKH Bitcoin). The puzzle creator could improve the puzzle's utility without bringing in any extra funds from outside - just spend 161-256 across to the unsolved portion 51-160, and roughly treble the puzzle's content density.

If on the other hand there's a pattern to find... well... that's awfully open-ended... can we have a hint or two? Cheesy

I am the creator.

You are quite right, 161-256 are silly.  I honestly just did not think of this.  What is especially embarrassing, is this did not occur to me once, in two years.  By way of excuse, I was not really thinking much about the puzzle at all.

I will make up for two years of stupidity.  I will spend from 161-256 to the unsolved parts, as you suggest.  In addition, I intend to add further funds.  My aim is to boost the density by a factor of 10, from 0.001*length(key) to 0.01*length(key).  Probably in the next few weeks.  At any rate, when I next have an extended period of quiet and calm, to construct the new transaction carefully.

A few words about the puzzle.  There is no pattern.  It is just consecutive keys from a deterministic wallet (masked with leading 000...0001 to set difficulty).  It is simply a crude measuring instrument, of the cracking strength of the community.

Finally, I wish to express appreciation of the efforts of all developers of new cracking tools and technology.  The "large bitcoin collider" is especially innovative and interesting!

The pattern is 12 or 24 mnemonic ?
1568589285
Hero Member
*
Offline Offline

Posts: 1568589285

View Profile Personal Message (Offline)

Ignore
1568589285
Reply with quote  #2

1568589285
Report to moderator
1568589285
Hero Member
*
Offline Offline

Posts: 1568589285

View Profile Personal Message (Offline)

Ignore
1568589285
Reply with quote  #2

1568589285
Report to moderator
Advertised sites are not endorsed by the Bitcoin Forum. They may be unsafe, untrustworthy, or illegal in your jurisdiction. Advertise here.
1568589285
Hero Member
*
Offline Offline

Posts: 1568589285

View Profile Personal Message (Offline)

Ignore
1568589285
Reply with quote  #2

1568589285
Report to moderator
1568589285
Hero Member
*
Offline Offline

Posts: 1568589285

View Profile Personal Message (Offline)

Ignore
1568589285
Reply with quote  #2

1568589285
Report to moderator
1568589285
Hero Member
*
Offline Offline

Posts: 1568589285

View Profile Personal Message (Offline)

Ignore
1568589285
Reply with quote  #2

1568589285
Report to moderator
zielar
Member
**
Offline Offline

Activity: 113
Merit: 26


View Profile
November 25, 2018, 11:35:40 AM
 #542

Wow.

Code:
james@research:~$ time ./baby-step-giant-step.exe
Build Hash
Search Keys
Found private key  1: ffffffffffffffff or                1
Found private key  2: fffffffffffffffd or                3
Found private key  3: fffffffffffffff9 or                7
Found private key  4: fffffffffffffff8 or                8
Found private key  5: ffffffffffffffeb or               15
Found private key  6: ffffffffffffffcf or               31
Found private key  7: ffffffffffffffb4 or               4c
Found private key  8: ffffffffffffff20 or               e0
Found private key  9: fffffffffffffe2d or              1d3
Found private key 10: fffffffffffffdfe or              202
Found private key 11: fffffffffffffb7d or              483
Found private key 12: fffffffffffff585 or              a7b
Found private key 13: ffffffffffffeba0 or             1460
Found private key 14: ffffffffffffd6d0 or             2930
Found private key 15: ffffffffffff970d or             68f3
Found private key 16: ffffffffffff36ca or             c936
Found private key 17: fffffffffffe89b1 or            1764f
Found private key 18: fffffffffffcf7f3 or            3080d
Found private key 19: fffffffffffa8b61 or            5749f
Found private key 20: fffffffffff2d3ab or            d2c55
Found private key 21: ffffffffffe45acc or           1ba534
Found private key 22: ffffffffffd21bf1 or           2de40f
Found private key 23: ffffffffffaa91ae or           556e52
Found private key 24: ffffffffff23d5fc or           dc2a04
Found private key 25: fffffffffe05a11b or          1fa5ee5
Found private key 26:          340326e or          4bfcd92
Found private key 27:          6ac3875 or          953c78b
Found private key 28:          a6e9318 or          d916ce8
Found private key 29:         17e2551e or         181daae2
Found private key 30:         3a6b329c or         3d94cd64
Found private key 31:         7ab018b9 or         7d4fe747
Found private key 32:         b79d59d2 or         b862a62e
Found private key 33:        1a6935728 or        1a96ca8d8
Found private key 34:        34a65911d or        34d9a6ee3
Found private key 35:        4aed21170 or        4b12dee90
Found private key 36:        9de820a7c or        9e17df584
Found private key 37:       1757756a93 or       17588a956d
Found private key 38:       2237d05330 or       22382facd0
Found private key 39:       4b5f8303e9 or       4b607cfc17
Found private key 40:       e9ae4933d6 or       e9b1b6cc2a
Found private key 41:      153869acc5b or      153896533a5
Found private key 42:      2a21e3a7271 or      2a221c58d8f
Found private key 43:      6bd3b27c591 or      6bd3cd83a6f
Found private key 44:      e02b35a358f or      e02b4a5ca71
Found private key 45:     122fca143c05 or     122fcdebc3fb
Found private key 46:     2ec18388d544 or     2ec184772abc
Found private key 47:     6cd60f4ac346 or     6cd610b53cba
Found private key 48:     ade6d7ce3b9b or     ade6d831c465
Found private key 49:    174176b015f4d or    174176cfea0b3
Found private key 50:    22bd43bd16cac or    22bd43c2e9354
Found private key 51:    750709e5ff62c or    75070a1a009d4

real    4m8.237s
user    4m7.784s
sys     0m0.432s
james@research:~$

Bearing in mind the above scheme and the fact that yesterday a new version of BitCrack released allowing to set the initial value and the final part of the selected key part - what is the correct setting in order to find the next private key? Possibly someone has a schematic how will the command syntax look to find more keys? I have 5x GTX 1080ti so I would like to try it because I was interested in this topic
j2002ba2
Newbie
*
Offline Offline

Activity: 12
Merit: 13


View Profile
November 25, 2018, 07:24:32 PM
Merited by arulbero (3)
 #543

This is correct only for BSGS (Baby-Step-Giant-Step).

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't exploit the fact that the private key is in the range from 1 to 2^160 for example, because it is probabilistic. It would need always 2^128 steps. Only BSGS is suitable for this task.

If you try to retrieve #57 with Pollard Rho, you won't retrieve the private key in a few seconds or in a few years.

With "space search is 2^160" in this context we mean a 2^160 points subset in the space of the 2^256 points of the secp256k1 curve.

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.
jason589
Newbie
*
Offline Offline

Activity: 1
Merit: 0


View Profile
November 29, 2018, 01:28:24 AM
 #544

Bearing in mind the above scheme and the fact that yesterday a new version of BitCrack released allowing to set the initial value and the final part of the selected key part - what is the correct setting in order to find the next private key? Possibly someone has a schematic how will the command syntax look to find more keys? I have 5x GTX 1080ti so I would like to try it because I was interested in this topic

^
racminer
Member
**
Offline Offline

Activity: 176
Merit: 16


View Profile
December 03, 2018, 06:57:32 AM
 #545


#58 1Dn8NF8qDyyfHMktmuoQLGyjWmZXgvosXf has been spent an hour ago


tx: 17d31de2bd300bc1bad430ec0db77ca27466bbb97bf03df6a3ff386d60e58996
stalker00075
Newbie
*
Offline Offline

Activity: 29
Merit: 0


View Profile
December 03, 2018, 09:14:52 AM
Last edit: December 03, 2018, 09:40:23 AM by stalker00075
 #546

arulbero Help!
what key can there be 1Dn8NF8qDyyfHMktmuoQLGyjWmZXgvosXf
2..............
3..............
arulbero
Legendary
*
Offline Offline

Activity: 1282
Merit: 1305


View Profile
December 03, 2018, 05:16:44 PM
 #547

arulbero Help!
what key can there be 1Dn8NF8qDyyfHMktmuoQLGyjWmZXgvosXf
2..............
3..............

Code:
Private key : 00000000000000000000000000000000000000000000000002c675b852189a21
Public key  : 11569442e870326ceec0de24eb5478c19e146ecd9d15e4666440f2f638875f42 524c08d882f868347f8b69d3330dc1913a159d8fb2b27864f197693a0eb39a23
 
PrKey WIF c.: KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYjv2kTamEYQT9BNC7o1
Address c.  : 8c2a6071f89c90c4dab5ab295d7729d1b54ea60f
Address c.  : 1Dn8NF8qDyyfHMktmuoQLGyjWmZXgvosXf
arulbero
Legendary
*
Offline Offline

Activity: 1282
Merit: 1305


View Profile
December 03, 2018, 06:00:53 PM
 #548

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
Newbie
*
Offline Offline

Activity: 107
Merit: 0


View Profile
December 03, 2018, 08:00:04 PM
Last edit: December 05, 2018, 04:20:26 AM by Andzhig
 #549

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 Offline

Activity: 104
Merit: 1


View Profile
December 05, 2018, 04:54:03 AM
 #550

haha! puzzle 58 is cracked. some guys with superclusters got involved?  Grin
PietCoin97
Jr. Member
*
Offline Offline

Activity: 60
Merit: 1


View Profile
December 05, 2018, 07:41:51 PM
 #551

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/2d05f0c9c3e1c226e63b5fac240137687544cf631cd616fd34fd188fc9020866

PUSHDATA(65)[04e70a02f5af48a1989bf630d92523c9d14c45c75f7d1b998e962bff6ff9995fc5bdb44f1793b3749 5d80324acba7c8f537caaf8432b8d47987313060cc82d8a93] CHECKSIG

Code:
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 Offline

Activity: 20
Merit: 1


View Profile
December 05, 2018, 08:57:14 PM
 #552

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/2d05f0c9c3e1c226e63b5fac240137687544cf631cd616fd34fd188fc9020866

PUSHDATA(65)[04e70a02f5af48a1989bf630d92523c9d14c45c75f7d1b998e962bff6ff9995fc5bdb44f1793b3749 5d80324acba7c8f537caaf8432b8d47987313060cc82d8a93] CHECKSIG

Code:
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 Offline

Activity: 20
Merit: 1


View Profile
December 05, 2018, 09:08:06 PM
 #553

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 Offline

Activity: 1282
Merit: 1305


View Profile
December 05, 2018, 09:08:45 PM
 #554

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 Offline

Activity: 60
Merit: 1


View Profile
December 05, 2018, 09:30:39 PM
 #555

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
**
Online Online

Activity: 165
Merit: 16


View Profile
December 06, 2018, 04:38:50 AM
 #556

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
Newbie
*
Offline Offline

Activity: 107
Merit: 0


View Profile
December 06, 2018, 05:08:14 AM
Last edit: December 06, 2018, 05:39:16 AM by Andzhig
 #557

Quote
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.  Grin 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.

Quote
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
Quote
("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.

Quote
("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
Quote
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 Offline

Activity: 20
Merit: 1


View Profile
December 06, 2018, 08:22:43 AM
 #558

Quote
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.  Grin 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.

Quote
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
Quote
("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.

Quote
("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
Quote
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 Offline

Activity: 20
Merit: 1


View Profile
December 06, 2018, 08:44:53 AM
 #559

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 Offline

Activity: 60
Merit: 1


View Profile
December 06, 2018, 10:15:42 PM
 #560

Quote
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.  Grin 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.

Quote
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
Quote
("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.

Quote
("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
Quote
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?
Pages: « 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 [28] 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 »
  Print  
 
Jump to:  

Sponsored by , a Bitcoin-accepting VPN.
Powered by MySQL Powered by PHP Powered by SMF 1.1.19 | SMF © 2006-2009, Simple Machines Valid XHTML 1.0! Valid CSS!