I started 4 month ago with an obsolete GPU and it only runs when I am home and I feel like that. I have checked 576_006_654_001_152 keys with about 150 MKeys/sec speed.
I know these are rookie numbers.
Topic: Bitcoin puzzle transaction ~32 BTC prize to who solves it - page 70. (Read 244959 times)
If it is not a secret how many keys have you checked total, per sec?
I started 4 month ago with an obsolete GPU and it only runs when I am home and I feel like that. I have checked 576_006_654_001_152 keys with about 150 MKeys/sec speed.
I know these are rookie numbers.
I started 4 month ago with an obsolete GPU and it only runs when I am home and I feel like that. I have checked 576_006_654_001_152 keys with about 150 MKeys/sec speed.
I know these are rookie numbers.
Number of numbers with unequal bits: 431910
Number of numbers with equal bits: 92378
Number of numbers differing by 1 bit: 0
Number of numbers differing by 2 bits: 167960
Number of numbers differing by 3 bits: 0
Number of numbers differing by 4 bits: 125970
Number of numbers differing by 5 bits: 0
Maximum deviation from 50/50: 20
[Program finished]
so in your search ranges not 2^20-2^19 = 524288, but 92378 calculations )) 5 times smaller, yes ?))
priv of puz 2^19-2^20 is 11010010110001010101 so, my darlings, you are soend 75 percent of yor time for free then you brute all range
Number of numbers with equal bits: 92378
Number of numbers differing by 1 bit: 0
Number of numbers differing by 2 bits: 167960
Number of numbers differing by 3 bits: 0
Number of numbers differing by 4 bits: 125970
Number of numbers differing by 5 bits: 0
Maximum deviation from 50/50: 20
[Program finished]
so in your search ranges not 2^20-2^19 = 524288, but 92378 calculations )) 5 times smaller, yes ?))
priv of puz 2^19-2^20 is 11010010110001010101 so, my darlings
, you are soend 75 percent of yor time for free then you brute all rangeI wonder how you convert the 92378 calculations to a valid search range? and do you have any plan to make it in a more efficient language so it could possibly be run using higher bit ranges.
I not search range, try research how many bits 0 and zero in range, and how many 0 and 1 in https://privatekeys.pw/puzzles/bitcoin-puzzle-tx
after, remove not valid generations. Yes, calculate all ranges not needs as for me, for other guy's I don know
Number of numbers with unequal bits: 431910
Number of numbers with equal bits: 92378
Number of numbers differing by 1 bit: 0
Number of numbers differing by 2 bits: 167960
Number of numbers differing by 3 bits: 0
Number of numbers differing by 4 bits: 125970
Number of numbers differing by 5 bits: 0
Maximum deviation from 50/50: 20
[Program finished]
so in your search ranges not 2^20-2^19 = 524288, but 92378 calculations )) 5 times smaller, yes ?))
priv of puz 2^19-2^20 is 11010010110001010101 so, my darlings, you are soend 75 percent of yor time for free then you brute all range
Number of numbers with equal bits: 92378
Number of numbers differing by 1 bit: 0
Number of numbers differing by 2 bits: 167960
Number of numbers differing by 3 bits: 0
Number of numbers differing by 4 bits: 125970
Number of numbers differing by 5 bits: 0
Maximum deviation from 50/50: 20
[Program finished]
so in your search ranges not 2^20-2^19 = 524288, but 92378 calculations )) 5 times smaller, yes ?))
priv of puz 2^19-2^20 is 11010010110001010101 so, my darlings
, you are soend 75 percent of yor time for free then you brute all rangeI wonder how you convert the 92378 calculations to a valid search range? and do you have any plan to make it in a more efficient language so it could possibly be run using higher bit ranges.
not range, random generator do 92378, not fool range
Number of numbers with unequal bits: 431910
Number of numbers with equal bits: 92378
Number of numbers differing by 1 bit: 0
Number of numbers differing by 2 bits: 167960
Number of numbers differing by 3 bits: 0
Number of numbers differing by 4 bits: 125970
Number of numbers differing by 5 bits: 0
Maximum deviation from 50/50: 20
[Program finished]
so in your search ranges not 2^20-2^19 = 524288, but 92378 calculations )) 5 times smaller, yes ?))
priv of puz 2^19-2^20 is 11010010110001010101 so, my darlings, you are soend 75 percent of yor time for free then you brute all range
Number of numbers with equal bits: 92378
Number of numbers differing by 1 bit: 0
Number of numbers differing by 2 bits: 167960
Number of numbers differing by 3 bits: 0
Number of numbers differing by 4 bits: 125970
Number of numbers differing by 5 bits: 0
Maximum deviation from 50/50: 20
[Program finished]
so in your search ranges not 2^20-2^19 = 524288, but 92378 calculations )) 5 times smaller, yes ?))
priv of puz 2^19-2^20 is 11010010110001010101 so, my darlings
, you are soend 75 percent of yor time for free then you brute all rangeI wonder how you convert the 92378 calculations to a valid search range? and do you have any plan to make it in a more efficient language so it could possibly be run using higher bit ranges.
Can someone please give a technical explanation of how they find (how this similarity search works) private key after someone already finds the private key and starts a transaction? I know mining means finding a part of private key and these private keys are in a narrow window. But there are too many pools, so I would expect to 1 or 2 approvals "quickly". Even if my transaction got let say 1 approval are they allowed to cancel the transaction when they have private key?
Is it a naive approach to create a bot to make ~60 transactions 0.1 BTC each?
This was discussed to death dozens of times, why don't you read the last pages of the thread?Is it a naive approach to create a bot to make ~60 transactions 0.1 BTC each?
Once the private key is found it is inevitable to have to make its public key, well... public when you create the transaction, so that the signature can be verified. It doesn't matter if you create 1 output or 100 outputs. Since the public key gets, well... public, everyone will know it. Knowing the public key of a "small" private key (< 100 bits, less or more depending on current technology) allows to find the corresponding private key in anywhere between less than a second and 10 minutes, before your original transaction gets confirmed in a mined block. Knowing the private key allows for creating a new valid (signed via the private key) overriding transaction, with a higher fee, which replaces your transaction, irrelevant of how it looked like or of its content, flags, etc.
Can someone please give a technical explanation of how they find (how this similarity search works) private key after someone already finds the private key and starts a transaction? I know mining means finding a part of private key and these private keys are in a narrow window. But there are too many pools, so I would expect to 1 or 2 approvals "quickly". Even if my transaction got let say 1 approval are they allowed to cancel the transaction when they have private key?
Is it a naive approach to create a bot to make ~60 transactions 0.1 BTC each?
Is it a naive approach to create a bot to make ~60 transactions 0.1 BTC each?
I don know anout DP, for good DP generation I think take a look for puzle privkeys are normal random,so if your generator generates no privkeys what have 50/50 0 and 1 they waste time....
---cut---
---cut---
Unequal bits scrypt what calculate no normal disrtributed numbers
---cut---
---cut---
I modify scrypt, so, not normal in 2^20 buts is mach many:
---cut---
---cut---
puzzle transactions especially in 50/50, but some of them 49
my scryot for you, darlings: ))
[...]
---cut---
my scryot for you, darlings: ))
[...]
---cut---
Please stop making (mass) consecutive posts. You’ve been warned multiple times already to avoid this behavior. Use the edit function to merge your posts and ensure this doesn't happen again in the future. If this continues, further action will be taken.
posible prevompute part for ex from 1 to 99
then you start 100 use precomputed fo 101 to 199. 101 = 1+ 01..99(from file)
Also I think posible generated previously agresses for nex step , if calculate 1 to 99 use in 1xx after use what you generated in 1xx to calc 2xxx etc
then you start 100 use precomputed fo 101 to 199. 101 = 1+ 01..99(from file)
Also I think posible generated previously agresses for nex step , if calculate 1 to 99 use in 1xx after use what you generated in 1xx to calc 2xxx etc
What part of "walks that use different rules hit different DPs" was unclear? Besides that, only 50% of the higher-degree interval is covered by the previous interval. Adding DPs from lower intervals to higher intervals is just a waste of resources and slows down the lookup, if the jump rules are different, those older DPs will almost certainly NEVER be hit by any walk of any kangaroo. This is just the result of the probabilities that are involved, which at the end of the day produce the lambdas when the paths merge together.
It's like playing lottery tickets and then you go into a casino and play the tickets at the roulette, or the same if you want to play blackjack by rolling dices. There's nothing in common.
I don know anout DP, for good DP generation I think take a look for puzle privkeys are normal random,so if your generator generates no privkeys what have 50/50 0 and 1 they waste time....
1000 not walid for brute, valid 1010 1100, 0011, not 0100.... lenght of fake and good is same ,agree ? ))
another stoopid question, WanderPhilosepher tell , what for divide privkey to 2^30 need take 2^30 keys, but, why for duvide 2^130 to 2^90 and take only 2^30 in valu range needs 2^90 publick keys ,? How 2^90 was 'trsansormed' to 2^30 ? )))
Unequal bits scrypt what calculate no normal disrtributed numbers
Number of numbers with unequal bits: 431910
Maximum deviation from 50/50: 20
[Program finished]
def count_unequal_bits(start, end):
# Initialize count of numbers with unequal bits and maximum deviation
unequal_count = 0
max_deviation = 0
# Iterate over all numbers in the range
for i in range(start, end):
# Convert number to binary string and remove '0b' prefix
bin_str = bin(i)[2:]
# Count number of ones and zeros in binary string
ones = bin_str.count('1')
zeros = bin_str.count('0')
# Check if number of ones and zeros is not equal
if ones != zeros:
# Increment count of numbers with unequal bits
unequal_count += 1
# Calculate deviation from 50/50
deviation = abs(ones - zeros)
# Update maximum deviation if current deviation is greater
max_deviation = max(max_deviation, deviation)
# Return count of numbers with unequal bits and maximum deviation
return unequal_count, max_deviation
# Define range of numbers to check
start = 2**19
end = 2**20
# Run the function and print results
result, max_deviation = count_unequal_bits(start, end)
print(f"Number of numbers with unequal bits: {result}")
print(f"Maximum deviation from 50/50: {max_deviation}")
I modify scrypt, so, not normal in 2^20 buts is mach many:
Number of numbers with unequal bits: 431910
Number of numbers with equal bits: 92378
Maximum deviation from 50/50: 20
[Program finished]
def count_bits(start, end):
# Initialize counts of numbers with unequal and equal bits
unequal_count = 0
equal_count = 0
max_deviation = 0
# Iterate over all numbers in the range
for i in range(start, end):
# Convert number to binary string and remove '0b' prefix
bin_str = bin(i)[2:]
# Count number of ones and zeros in binary string
ones = bin_str.count('1')
zeros = bin_str.count('0')
# Check if number of ones and zeros is not equal
if ones != zeros:
# Increment count of numbers with unequal bits
unequal_count += 1
# Calculate deviation from 50/50
deviation = abs(ones - zeros)
# Update maximum deviation if current deviation is greater
max_deviation = max(max_deviation, deviation)
else:
# Increment count of numbers with equal bits
equal_count += 1
# Return counts of numbers with unequal and equal bits, and maximum deviation
return unequal_count, equal_count, max_deviation
# Define range of numbers to check
start = 2**19
end = 2**20
# Run the function and print results
unequal_count, equal_count, max_deviation = count_bits(start, end)
print(f"Number of numbers with unequal bits: {unequal_count}")
print(f"Number of numbers with equal bits: {equal_count}")
print(f"Maximum deviation from 50/50: {max_deviation}")
puzzle transactions especially in 50/50, but some of them 49
my scryot for you, darlings: ))
Number of numbers with unequal bits: 431910
Number of numbers with equal bits: 92378
Number of numbers differing by 1 bit: 0
Number of numbers differing by 2 bits: 167960
Number of numbers differing by 3 bits: 0
Number of numbers differing by 4 bits: 125970
Number of numbers differing by 5 bits: 0
Maximum deviation from 50/50: 20
[Program finished]
so in your search ranges not 2^20-2^19 = 524288, but 92378 calculations )) 5 times smaller, yes ?))
priv of puz 2^19-2^20 is 11010010110001010101 so, my darlings
, you are soend 75 percent of yor time for free then you brute all rangedef count_bits(start, end):
# Initialize counts of numbers with unequal, equal, and differing by 1, 2, 3, 4, and 5 bits
unequal_count = 0
equal_count = 0
diff_1_count = 0
diff_2_count = 0
diff_3_count = 0
diff_4_count = 0
diff_5_count = 0
max_deviation = 0
# Iterate over all numbers in the range
for i in range(start, end):
# Convert number to binary string and remove '0b' prefix
bin_str = bin(i)[2:]
# Count number of ones and zeros in binary string
ones = bin_str.count('1')
zeros = bin_str.count('0')
# Check if number of ones and zeros is not equal
if ones != zeros:
# Increment count of numbers with unequal bits
unequal_count += 1
# Calculate deviation from 50/50
deviation = abs(ones - zeros)
# Update maximum deviation if current deviation is greater
max_deviation = max(max_deviation, deviation)
# Check if difference is 1, 2, 3, 4, or 5 bits
if deviation == 1:
diff_1_count += 1
elif deviation == 2:
diff_2_count += 1
elif deviation == 3:
diff_3_count += 1
elif deviation == 4:
diff_4_count += 1
elif deviation == 5:
diff_5_count += 1
else:
# Increment count of numbers with equal bits
equal_count += 1
# Return counts of numbers with unequal, equal, and differing by 1, 2, 3, 4, and 5 bits, and maximum deviation
return unequal_count, equal_count, diff_1_count, diff_2_count, diff_3_count, diff_4_count, diff_5_count, max_deviation
# Define range of numbers to check
start = 2**19
end = 2**20
# Run the function and print results
unequal_count, equal_count, diff_1_count, diff_2_count, diff_3_count, diff_4_count, diff_5_count, max_deviation = count_bits(start, end)
print(f"Number of numbers with unequal bits: {unequal_count}")
print(f"Number of numbers with equal bits: {equal_count}")
print(f"Number of numbers differing by 1 bit: {diff_1_count}")
print(f"Number of numbers differing by 2 bits: {diff_2_count}")
print(f"Number of numbers differing by 3 bits: {diff_3_count}")
print(f"Number of numbers differing by 4 bits: {diff_4_count}")
print(f"Number of numbers differing by 5 bits: {diff_5_count}")
print(f"Maximum deviation from 50/50: {max_deviation}")
posible prevompute part for ex from 1 to 99
then you start 100 use precomputed fo 101 to 199. 101 = 1+ 01..99(from file)
Also I think posible generated previously agresses for nex step , if calculate 1 to 99 use in 1xx after use what you generated in 1xx to calc 2xxx etc
then you start 100 use precomputed fo 101 to 199. 101 = 1+ 01..99(from file)
Also I think posible generated previously agresses for nex step , if calculate 1 to 99 use in 1xx after use what you generated in 1xx to calc 2xxx etc
What part of "walks that use different rules hit different DPs" was unclear? Besides that, only 50% of the higher-degree interval is covered by the previous interval. Adding DPs from lower intervals to higher intervals is just a waste of resources and slows down the lookup, if the jump rules are different, those older DPs will almost certainly NEVER be hit by any walk of any kangaroo. This is just the result of the probabilities that are involved, which at the end of the day produce the lambdas when the paths merge together.
It's like playing lottery tickets and then you go into a casino and play the tickets at the roulette, or the same if you want to play blackjack by rolling dices. There's nothing in common.
Puzzle 130: ~ [Expected Hops: 2^65.64 (57392798431464251392)]
How much storage is needed to precompute Puzzle 130 ?
How much storage is needed to precompute Puzzle 130 ?
1. That number is kind of a reference point, can vary ± 20% Besides, the best known complexity is rather 1.66 * sqrt(b) but requires special attention when jumping through the point at infinity. Speed is better when we're certain we'll never need to double a point or go through O, since that special branch goes away..
2. It's non-sense to precompute stuff when you know all the variables. It's just faster to solve the problem. Pre-computation makes sense to search and save traps inside the same space where the wild kangaroos will jump around.
You don't need any storage to solve 130 or 160 or 66 or 250+ bits. Storage is only needed if DP > 0 or if you have more than a single Tame and Wild kangaroo. But since we don't have forever to do all those gazillion ops, the catch is to compute a lot of kangaroos in parallel - as we definitely can't compute just two kangaroos in parallel, the next jump depends on their current value.
So storage depends on whatever you wish to accomplish. Might as well just save an ID of the kangaroo that reached a DP, and re-create the walk when a match occurs, to get the distance. But it's slow if the walk was a long one.
posible prevompute part for ex from 1 to 99
then you start 100 use precomputed fo 101 to 199. 101 = 1+ 01..99(from file)
Also I think posible generated previously agresses for nex step , if calculate 1 to 99 use in 1xx after use what you generated in 1xx to calc 2xxx etc
Does anyone know if this one forum post of 288 pages is the only place for most of the puzzle discussion about puzzles 66 - 160? Or are there actual other community groups too like a discord or telegram for example? Just thought I would ask since I had more free time during the last 2 days and finally managed to read through at least 200 pages here. Decided to skip reading the first 88 pages though since they are probably only about the puzzles below 66 that were already solved since a very long time ago, lol. And thought I would just ask about the withdrawal problem too. The creator made no announcement still about it right? So even if anyone manages to solve, they also must find their own method to not lose the funds during transfer to their own wallet? I havent solved it either, just wondered if the situation was still the same. Guessing it is unfortunately.
Puzzle 130: ~ [Expected Hops: 2^65.64 (57392798431464251392)]
How much storage is needed to precompute Puzzle 130 ?
How much storage is needed to precompute Puzzle 130 ?
1. That number is kind of a reference point, can vary ± 20% Besides, the best known complexity is rather 1.66 * sqrt(b) but requires special attention when jumping through the point at infinity. Speed is better when we're certain we'll never need to double a point or go through O, since that special branch goes away..
2. It's non-sense to precompute stuff when you know all the variables. It's just faster to solve the problem. Pre-computation makes sense to search and save traps inside the same space where the wild kangaroos will jump around.
You don't need any storage to solve 130 or 160 or 66 or 250+ bits. Storage is only needed if DP > 0 or if you have more than a single Tame and Wild kangaroo. But since we don't have forever to do all those gazillion ops, the catch is to compute a lot of kangaroos in parallel - as we definitely can't compute just two kangaroos in parallel, the next jump depends on their current value.
So storage depends on whatever you wish to accomplish. Might as well just save an ID of the kangaroo that reached a DP, and re-create the walk when a match occurs, to get the distance. But it's slow if the walk was a long one.
Pre-compute is just running all "tames"... (k*g) through whatever range and store the points (public key x points, not the whole thing but however many bits you chose (not to few though or then you have false collisions)) That's all pre-computing really is. Same as BSGS, 1*g all the way up to however many points you want in your baby step file. And all of those points are DP 0.
For the 130 puzzle, we are using DP 32. So we will roughly need to find 2^33.55 distinguished points. File size, should be right around 400GB; that's my estimate.
And albert0, since you know BSGS better than most, a 100,000 view way to look at Kangaroo, consider the baby step file the tame kangaroos, and the giant steps, the wilds (offsets). BSGS is like a brute force mixed with Kangaroo lol. But Kangaroo is just more spread out with it's jumps, whereas BSGS takes the exact same "step" each time. Kangaroo creates multiple offset pubkeys (addition or subtraction or both), those are the wilds. And once one of those offset points matches a tame point, basic math just like BSGS.
Tames are just k*g, with some distinguishable point. The 130 pool, DP 32, so we save every x point that has at least 8 zeros at the end (trailing). The wilds are k*g + public key, that you are searching for. Same thing, if it ends with 8 zeros, it gets stored. Once we get a collision / match, we merely take the tame distance (k*g or private key really) and subtract the wild distance. And like BSGS, if you reduced the range by subtracting the start range up front, then you have to add it back. (tame distance - wild distance) + initial subtracted start range.
Puzzle 130: ~ [Expected Hops: 2^65.64 (57392798431464251392)]
How much storage is needed to precompute Puzzle 130 ?
How much storage is needed to precompute Puzzle 130 ?
1. That number is kind of a reference point, can vary ± 20% Besides, the best known complexity is rather 1.66 * sqrt(b) but requires special attention when jumping through the point at infinity. Speed is better when we're certain we'll never need to double a point or go through O, since that special branch goes away..
2. It's non-sense to precompute stuff when you know all the variables. It's just faster to solve the problem. Pre-computation makes sense to search and save traps inside the same space where the wild kangaroos will jump around.
You don't need any storage to solve 130 or 160 or 66 or 250+ bits. Storage is only needed if DP > 0 or if you have more than a single Tame and Wild kangaroo. But since we don't have forever to do all those gazillion ops, the catch is to compute a lot of kangaroos in parallel - as we definitely can't compute just two kangaroos in parallel, the next jump depends on their current value.
So storage depends on whatever you wish to accomplish. Might as well just save an ID of the kangaroo that reached a DP, and re-create the walk when a match occurs, to get the distance. But it's slow if the walk was a long one.
Puzzle 130: ~ [Expected Hops: 2^65.64 (57392798431464251392)]
How much storage is needed to precompute Puzzle 130 ?
How much storage is needed to precompute Puzzle 130 ?
The set of Tame distinguished points that are used for cracking any public key are the same ones, no matter what public key is being cracked.
Thank you for the explanation. question... The Set of tame Points depends of the KEY Range?
My questions is: those set of 60 Million of DP can be used in the 130 bit range or any other bit range?
1. Yes, but indirectly. 2. No. Let's look at an example: puzzle 66. Interval size is 2**65.
If we put the theory into practice (Pollard 1978, Oorschot parallelization in 1996, etc.) than the deterministic jumps need to have somewhat of an optimal average jump distance.
And that value directly depends on the interval size. So in effect the set of detected DPs (though valid) between problems of different interval sizes will differ a lot, so while they could be looked up to, there is a very low chance they will ever get hit when used for a different interval size.
Practical example: to solve interval 2**65 the optimal average jump requires a deterministic jump table of 53 points. For higher intervals the jump table size increases, and this results in different deterministic walks. So the traversed DPs will most likely not intersect with the DPs that were encountered on problems of different sizes.
For puzzle 66 with a DP of 17 there exists around 2**(65 - 17) valid DPs in the interval = 281 trillion points.
However since it's basically guaranteed that a collision will be found after 2**32.5 operations, and the DP is 17, it means that only around 2**16 out of all those 2**48 DPs will be collected during a solving session.
Out of those, we can collect before-hand 2**16 Tame DPs (using 2**33 ops), and then on average we'll need another 2**32 ops to solve any key in the interval, once we have its public key.
But if we collect more and more Tame DPs, than we decrease the average required number of ops to solve for any public key in that interval
So, precomputing 2**24 DP (in 2**41 ops) decreases a lot the number of ops that will be needed to solve any key, from the initial remaining 2**32.5 ops to a lot less, smth like 2**25 ops (200 times faster). On average.. Double the amounts of collected DPs = decrease somewhat by half the time needed to solve. Hope it makes sense!
It's tempting to think that DPs could be reused between search intervals of different sizes, but in practice this will not work. The whole shenanigan works because:
1. we chose parameters that minimize the number of expected operations - if we want to reuse the same DPs it means we'd have to make jumps that are on average more than or less than the optimal value, resulting in more number of operations.
2. All kangaroos jump the same way. They don't (usually) jump the same way between intervals of different size, in order to minimize the number of expected ops. So the hit DPs will be a different subset of the whole set of possible DPs.
Did I get this right? With a slight adjustment from 5 s on a i9 to 7 s on i7 (might not matter though).
...
this makes BSGS 100 times slower, and also requires a ton of data to be stored in RAM, correct?
...
this makes BSGS 100 times slower, and also requires a ton of data to be stored in RAM, correct?
Yes you get it right BSGS it is slower because it direct dependency of the size of the precalculated data.
The set of Tame distinguished points that are used for cracking any public key are the same ones, no matter what public key is being cracked. That is the precomputation part. So since the total ops to perform are somewhere around 2 * sqrt(b) the probability of success remains almost the same if you have a lot of ops performed in advance just for finding Tame DPs. It's similar to having a lot of traps into which Wild kangaroos can fall into once the public key is known.
Thank you for the explanation. question... The Set of tame Points depends of the KEY Range?
My take on Puzzle #66 (65 missing bits)
Generated 60 million DP all of which have X ending in 17 zero bits.
This took less than 8 hours using a slow GPU (around 500 M op/s).
Generated 60 million DP all of which have X ending in 17 zero bits.
This took less than 8 hours using a slow GPU (around 500 M op/s).
My questions is: those set of 60 Million of DP can be used in the 130 bit range or any other bit range?
BSGS can solve any 65 bit key in some 30 seconds with 16 GB of precalculated data with a i7 13700K 24 threads.
Did I get this right? With a slight adjustment from 5 s on a i9 to 7 s on i7 (might not matter though).
BSGS 24 threads ... 30 seconds. ... 16 GB RAM
Kang 1 thread. ... 7 seconds. ... 1.5 GB storage
So, BSGS takes 720 seconds to do the same job, when it runs on 1 thread? With precomputed data in both cases, this makes BSGS 100 times slower, and also requires a ton of data to be stored in RAM, correct?
How exactly are you using the kangaroo algorithm to solve random private keys?
My understanding is that the kangaroo algorithm is typically used for solving discrete logarithm problems when the public key (EC Point X, Y Coordinates) is known. Are you using it differently here, or is there some additional context or method you're employing that allows it to work with random private keys?
My understanding is that the kangaroo algorithm is typically used for solving discrete logarithm problems when the public key (EC Point X, Y Coordinates) is known. Are you using it differently here, or is there some additional context or method you're employing that allows it to work with random private keys?
Sorry for the confusion. I meant solving random public keys - e.g. pick a random key in the interval, compute its public key, feed it to the solver, and check that it returns the correct private key.
The set of Tame distinguished points that are used for cracking any public key are the same ones, no matter what public key is being cracked. That is the precomputation part. So since the total ops to perform are somewhere around 2 * sqrt(b) the probability of success remains almost the same if you have a lot of ops performed in advance just for finding Tame DPs. It's similar to having a lot of traps into which Wild kangaroos can fall into once the public key is known.
He turned the game around like a fast slot machine. 
My take on Puzzle #66 (65 missing bits)
Running random private key solving on this foundation... any key is solved in less than 5 seconds. On a CPU - using only 512 Wild kangaroos.
Running random private key solving on this foundation... any key is solved in less than 5 seconds. On a CPU - using only 512 Wild kangaroos.
How exactly are you using the kangaroo algorithm to solve random private keys?
My understanding is that the kangaroo algorithm is typically used for solving discrete logarithm problems when the public key (EC Point X, Y Coordinates) is known. Are you using it differently here, or is there some additional context or method you're employing that allows it to work with random private keys?
Can BSGS compete with this?
Of course NOT we all (those who has some time in this topic) knows that Kangaroo is faster than BSGS there is no point to debate that.
BSGS can solve any 65 bit key in some 30 seconds with 16 GB of precalculated data with a i7 13700K 24 threads.
Kangaroo is still a mystery for me, i don't know exactly what those DP are used for or how they help to its algorithm. I don't know how the collision should happen or how those jumos between tame and wild kangaroos need to be made.
Repeat It is a mistery for me, It is a little of shame for me but i need to admit it.
BSGS is clear like water, but kangaroo no
https://andrea.corbellini.name/2015/06/08/elliptic-curve-cryptography-breaking-security-and-a-comparison-with-rsa/
My take on Puzzle #66 (65 missing bits)
Generated 60 million DP all of which have X ending in 17 zero bits.
This took less than 8 hours using a slow GPU (around 500 M op/s).
Offline storage for DP search tree: 1.5 GB (64-bit keys + 10 bytes distance to base point payload)
The DP tree is a B*-tree. No need to store all of it in RAM.
Patched libsecp256k1 to do batched affine jumps --> got around 10 M op/s single-threaded.
Running random private key solving on this foundation... any key is solved in less than 5 seconds. On a CPU - using only 512 Wild kangaroos.
RAM consumption: 20 MB
Storage: 1.5 GB (B*-tree)
Device: Intel i9 13900H CPU
GPU: not required.
Next steps: building tables all the way up to 100 bits.
Can BSGS compete with this?
Generated 60 million DP all of which have X ending in 17 zero bits.
This took less than 8 hours using a slow GPU (around 500 M op/s).
Offline storage for DP search tree: 1.5 GB (64-bit keys + 10 bytes distance to base point payload)
The DP tree is a B*-tree. No need to store all of it in RAM.
Patched libsecp256k1 to do batched affine jumps --> got around 10 M op/s single-threaded.
Running random private key solving on this foundation... any key is solved in less than 5 seconds. On a CPU - using only 512 Wild kangaroos.
RAM consumption: 20 MB
Storage: 1.5 GB (B*-tree)
Device: Intel i9 13900H CPU
GPU: not required.
Next steps: building tables all the way up to 100 bits.
Can BSGS compete with this?
Code:
[000] Solving for random private key: 0x1aff3ddb034b5e55d -> 03240e9d8d78ff7b1ef805b98f68693a255090a0f4c4a52006d2692c92e07c5223
Creating 512 kangaroos to fill a herd
prepare: 5 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
DP COLLISION: 064546b5d64d0bf3
PRIVATE KEY: 1aff3ddb034b5e55d
[000] Solve time / key: 0.687 s
[001] Solving for random private key: 0xac48a090862abf76 -> 0344a0a999bdddefb1fba4845ce25dd2907f0e13c742b99687ccb0b284d7e5f3a5
Creating 512 kangaroos to fill a herd
prepare: 5 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
3.35s 2.00% 33554432 | 10016607 op/s | ETA 164 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
DP COLLISION: 9c6d9c083735e9a1
PRIVATE KEY: ac48a090862abf76
[001] Solve time / key: 3.084 s
[002] Solving for random private key: 0x9300e54ba34c75d7 -> 0220290834adbbd6a1c42468d4b3a8ab134c681629b9cdb2b0048a28f6615e5a72
Creating 512 kangaroos to fill a herd
prepare: 5 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
3.35s 2.00% 33554432 | 10014562 op/s | ETA 164 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
DP COLLISION: 716fd239faaa1276
PRIVATE KEY: 9300e54ba34c75d7
[002] Solve time / key: 3.556 s
[003] Solving for random private key: 0xa1cf51c457122fd3 -> 02b0bf220404ad97f33610325c836dab6a6c39125072f1f956f282582a0bedfc2d
Creating 512 kangaroos to fill a herd
prepare: 5 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
3.35s 2.00% 33554432 | 10019382 op/s | ETA 164 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
6.70s 4.00% 67108864 | 10021298 op/s | ETA 161 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 67108864
DP COLLISION: f42b808056af65b2
PRIVATE KEY: a1cf51c457122fd3
[003] Solve time / key: 4.504 s
[004] Solving for random private key: 0xa2bd8f3a435e2d36 -> 02b63eeb94b4fd1fe85ae767e64731c0c74f8120e2ac41e17a9034312766d020f5
Creating 512 kangaroos to fill a herd
prepare: 5 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
3.35s 2.00% 33554432 | 10020020 op/s | ETA 164 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
6.70s 4.00% 67108864 | 10019617 op/s | ETA 161 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 67108864
DP COLLISION: 010628ab5d861d54
PRIVATE KEY: a2bd8f3a435e2d36
[004] Solve time / key: 5.122 s
[005] Solving for random private key: 0x60771fb71eb3aefc -> 025fd9940fef8c2d0549da3108a65f419f9df7486736017eb6ba9be068e9d4d301
Creating 512 kangaroos to fill a herd
prepare: 5 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
3.35s 2.00% 33554432 | 10015183 op/s | ETA 164 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
DP COLLISION: 2be577bb94cd3aa3
PRIVATE KEY: 60771fb71eb3aefc
[005] Solve time / key: 4.876 s
[006] Solving for random private key: 0x17d86000f53262f88 -> 02dbaf5d00d3f26d94d04c80d4d7810099079a221514e05ac7c804ffbe3cca417a
Creating 512 kangaroos to fill a herd
prepare: 5 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
DP COLLISION: 4faa98c4869c148d
PRIVATE KEY: 17d86000f53262f88
[006] Solve time / key: 4.482 s
[007] Solving for random private key: 0x1f4aa45c588edfd62 -> 03b22c18653d4ba3fad4acc6c4f1e0c48fcc05eefa78bc8e3e7e52f40e6ef17240
Creating 512 kangaroos to fill a herd
prepare: 4 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
3.35s 2.00% 33554432 | 10014356 op/s | ETA 164 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
DP COLLISION: d43507795ac781dc
PRIVATE KEY: 1f4aa45c588edfd62
[007] Solve time / key: 4.663 s
[008] Solving for random private key: 0xd74fbfc1772631f7 -> 025f9c1c93e5049a039e138ca7d7551c39bec80f910167a8eb5d574a413dbf28b5
Creating 512 kangaroos to fill a herd
prepare: 4 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
3.35s 2.00% 33554432 | 10017025 op/s | ETA 164 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
DP COLLISION: e9fb03cbbc40241d
PRIVATE KEY: d74fbfc1772631f7
[008] Solve time / key: 4.833 s
[009] Solving for random private key: 0x22af69bdd474d055 -> 03a413485290a45629fae44582c92b0efff4f86f9f37aa006227c991eec9edd431
Creating 512 kangaroos to fill a herd
prepare: 4 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
3.35s 2.00% 33554432 | 10017498 op/s | ETA 164 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
6.70s 4.00% 67108864 | 10018371 op/s | ETA 161 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 67108864
DP COLLISION: 3d2a25b3c1b7f0dd
PRIVATE KEY: 22af69bdd474d055
[009] Solve time / key: 5.023 s
[010] Solving for random private key: 0x1ce81735afd57d92d -> 03144bea86943352105f01260f35df2d6fee052f56fd2640ecc9e1680b3c8fcdc0
Creating 512 kangaroos to fill a herd
prepare: 4 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
3.35s 2.00% 33554432 | 10010573 op/s | ETA 164 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
DP COLLISION: e2971ba23f7cca42
PRIVATE KEY: 1ce81735afd57d92d
[010] Solve time / key: 5.008 s
[011] Solving for random private key: 0x16d78eaad443ec9d7 -> 03b5bf0e73d2e230c2795c3a74ba07a1fe0403b0bc6c9eb60fb34c48170900356c
Creating 512 kangaroos to fill a herd
prepare: 5 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
DP COLLISION: 73712a66401660ad
PRIVATE KEY: 16d78eaad443ec9d7
[011] Solve time / key: 4.792 s
[012] Solving for random private key: 0xac897c2f44e218ad -> 032cc52f8bcfd1980ff2fa93238dcbee32b3856a838e1733590a34fe426ff517e1
Creating 512 kangaroos to fill a herd
prepare: 4 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
3.35s 2.00% 33554432 | 10019304 op/s | ETA 164 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
DP COLLISION: a43d77c660406b54
PRIVATE KEY: ac897c2f44e218ad
[012] Solve time / key: 4.842 s
[013] Solving for random private key: 0xc080166608fdd537 -> 03d60fee4a6be8e359deb56c8fc82d37dfd16e5b893288b0d5db7d1fc1afb219cc
Creating 512 kangaroos to fill a herd
prepare: 5 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
3.35s 2.00% 33554432 | 10015324 op/s | ETA 164 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
DP COLLISION: a5ed600bf1ff8796
PRIVATE KEY: c080166608fdd537
[013] Solve time / key: 4.861 s
[014] Solving for random private key: 0x15176634735559589 -> 025ffc6426ae01e832aae04edf0f1e2a24b4ca89b8e0d1f294bd6c02abb19aa97e
Creating 512 kangaroos to fill a herd
prepare: 5 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
3.35s 2.00% 33554432 | 10011870 op/s | ETA 164 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
DP COLLISION: 74ede73b91d65d45
PRIVATE KEY: 15176634735559589
[014] Solve time / key: 4.787 s
[015] Solving for random private key: 0x172e65e285533dac3 -> 03b574c6f26a57e77aef676f8d75c722aa275d3e6035dc8c8a57df67098b91d002
Creating 512 kangaroos to fill a herd
prepare: 5 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
DP COLLISION: fe2a8394c3dc456a
PRIVATE KEY: 172e65e285533dac3
[015] Solve time / key: 4.686 s
[016] Solving for random private key: 0xa44ecac3c9b00e51 -> 0227349606b63a8e8e1b7508d3bf52aa8d1a54d74189edcc9186d5d75d7d1eb832
Creating 512 kangaroos to fill a herd
prepare: 5 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
3.35s 2.00% 33554432 | 10014487 op/s | ETA 164 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
DP COLLISION: 04ee6e30b37592e1
PRIVATE KEY: a44ecac3c9b00e51
[016] Solve time / key: 4.620 s
[017] Solving for random private key: 0x1ea856bf547b0c99b -> 0217bb9fef5ea4ca18bfa6085d64fc8ad70cb1b8ffc9ca608da5f2911713dbd867
Creating 512 kangaroos to fill a herd
prepare: 4 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
DP COLLISION: 8e35d51bc7e5a58f
PRIVATE KEY: 1ea856bf547b0c99b
[017] Solve time / key: 4.463 s
[018] Solving for random private key: 0x465a7d5f108b9618 -> 0221490f554bbc14ac88d60a2b8df7ae947cfe7f9c63de856985688956b7dda13e
Creating 512 kangaroos to fill a herd
prepare: 6 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
3.35s 2.00% 33554432 | 10015937 op/s | ETA 164 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
DP COLLISION: 69d1ec33eaf23a66
PRIVATE KEY: 465a7d5f108b9618
[018] Solve time / key: 4.415 s
[019] Solving for random private key: 0x4ac140e1add537a5 -> 03f9bde44a6b7f1df7f62a66c5a70c0148ec3f4fe47c08bd745c2b0d8b0785d7aa
Creating 512 kangaroos to fill a herd
prepare: 5 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
DP COLLISION: a675b57193d63bfd
PRIVATE KEY: fff915bdb1ec91d317
[019] Solve time / key: 4.225 s
[020] Solving for random private key: 0xc5cbebd7b68bd04a -> 0279678b7e3d70348c7e53810a147b9c472601ad08902f48b97f91a4126891db9a
Creating 512 kangaroos to fill a herd
prepare: 5 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
3.35s 2.00% 33554432 | 10013896 op/s | ETA 164 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
6.70s 4.00% 67108864 | 10015644 op/s | ETA 161 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 67108864
10.05s 6.00% 100663296 | 10015729 op/s | ETA 157 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 100663296
13.40s 8.00% 134217728 | 10015936 op/s | ETA 154 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 134217728
DP COLLISION: f75a07a7af834651
PRIVATE KEY: c5cbebd7b68bd04a
[020] Solve time / key: 4.700 s
[021] Solving for random private key: 0x1396e04bf63708b68 -> 03f42364f5a018f9bfc1d2f53781ce3f1f6b3ef47fa87c9ce9413e0b81eb4380e4
Creating 512 kangaroos to fill a herd
prepare: 5 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
3.35s 2.00% 33554432 | 10015235 op/s | ETA 164 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
DP COLLISION: 9f732a70c71200be
PRIVATE KEY: 1396e04bf63708b68
[021] Solve time / key: 4.734 s
[022] Solving for random private key: 0x10ea77053bbdbf904 -> 027dab1fc5dfb8b3d686e0eb13c2b2b562348b0152d780cd21cd15bed36fa037b7
Creating 512 kangaroos to fill a herd
prepare: 5 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
3.35s 2.00% 33554432 | 10014645 op/s | ETA 164 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
DP COLLISION: a62bd36aef66ae55
PRIVATE KEY: 10ea77053bbdbf904
[022] Solve time / key: 4.693 s
[023] Solving for random private key: 0x601efb73c8fbd41b -> 032e9dd1d29ed481a86182e0bc39e190afcad7bfb927746ce97db03ace3917a0ca
Creating 512 kangaroos to fill a herd
prepare: 5 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
3.35s 2.00% 33554432 | 10008450 op/s | ETA 164 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
6.70s 4.00% 67108864 | 10012360 op/s | ETA 161 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 67108864
DP COLLISION: 534ef9b1f6f7611d
PRIVATE KEY: 601efb73c8fbd41b
[023] Solve time / key: 4.794 s
[024] Solving for random private key: 0x17c7b1f721591a86a -> 022aa262a59a45d69a21b195abf90d2108a21030e034dc01a1d1566451f6c8883d
Creating 512 kangaroos to fill a herd
prepare: 5 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
3.35s 2.00% 33554432 | 10013970 op/s | ETA 164 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
DP COLLISION: 3232c3f1124dd1ff
PRIVATE KEY: 17c7b1f721591a86a
[024] Solve time / key: 4.740 s
[025] Solving for random private key: 0x14071ec95e8bc839b -> 037c71ab7b557021c484eef140cdeed3ff9a0067838a1a3dae6ffb45f728f75ca9
Creating 512 kangaroos to fill a herd
prepare: 5 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
3.36s 2.00% 33554432 | 9982688 op/s | ETA 165 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
DP COLLISION: f0b4eaf75d1076f4
PRIVATE KEY: 14071ec95e8bc839b
[025] Solve time / key: 4.723 s
[026] Solving for random private key: 0x9575fd3c7120207f -> 037b278b424b88195b10eaa039ab30515dd9a4f3f47730ded3346c5eea771e9927
Creating 512 kangaroos to fill a herd
prepare: 5 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
3.36s 2.00% 33554432 | 9997706 op/s | ETA 164 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
6.71s 4.00% 67108864 | 10008719 op/s | ETA 161 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 67108864
DP COLLISION: 02eddc154150913b
PRIVATE KEY: 9575fd3c7120207f
[026] Solve time / key: 4.807 s
[027] Solving for random private key: 0x16a50bdd54acabb5 -> 039e1d57f57455e4a187c2f56cf622e4e2dddee3cbe5cf7bae5e151fc9d300d5c7
Creating 512 kangaroos to fill a herd
prepare: 4 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
3.35s 2.00% 33554432 | 10015877 op/s | ETA 164 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
6.70s 4.00% 67108864 | 10016237 op/s | ETA 161 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 67108864
DP COLLISION: 48f5b971d42d7c14
PRIVATE KEY: 16a50bdd54acabb5
[027] Solve time / key: 4.948 s
[028] Solving for random private key: 0x1a554ce1457bb49be -> 034268ad4874a56f40bffea05117fe417ba29121e2d160bdd825365dfcf4d1bf25
Creating 512 kangaroos to fill a herd
prepare: 4 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
DP COLLISION: 953588735706990f
PRIVATE KEY: 1a554ce1457bb49be
[028] Solve time / key: 4.887 s
[029] Solving for random private key: 0x1023dcfdb57669105 -> 03c9fe8fd0baa717aa2346ac85cb8acbb80419a4c59488192e813cec1722b33f2e
Creating 512 kangaroos to fill a herd
prepare: 4 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
3.35s 2.00% 33554432 | 10013746 op/s | ETA 164 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
DP COLLISION: 858c30cb0ad9e092
PRIVATE KEY: 1023dcfdb57669105
[029] Solve time / key: 4.842 s
[030] Solving for random private key: 0x1a75b6c3a451d4ab6 -> 02019dd67243d2d2c7838be52fb9d4c3ecd79674d2e86b3ac7679b83b77c8799cf
Creating 512 kangaroos to fill a herd
prepare: 4 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
3.35s 2.00% 33554432 | 10014974 op/s | ETA 164 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
DP COLLISION: fe4fe22214eee437
PRIVATE KEY: 1a75b6c3a451d4ab6
[030] Solve time / key: 4.795 s
[031] Solving for random private key: 0x168cb9ddb0d88504d -> 02daa1b97df8933c9c9c8965953c944a48070ec6dffd888c2c1b4359e362ed9a49
Creating 512 kangaroos to fill a herd
prepare: 4 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
DP COLLISION: 8ff40134f7ea91e0
PRIVATE KEY: 168cb9ddb0d88504d
[031] Solve time / key: 4.723 s
[032] Solving for random private key: 0x14b5ec495a1c95663 -> 027664faafcc3e26d9461648ce04209bf35fa0282029b4e45af23793ac7644fe55
Creating 512 kangaroos to fill a herd
prepare: 5 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
3.35s 2.00% 33554432 | 10015620 op/s | ETA 164 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
6.70s 4.00% 67108864 | 10010178 op/s | ETA 161 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 67108864
DP COLLISION: c4fa8f7eff2d225f
PRIVATE KEY: 14b5ec495a1c95663
[032] Solve time / key: 4.802 s
[033] Solving for random private key: 0x54c33562418c8987 -> 037ef296765e0388853025cdd70b190fa3eb17f8b65bd25b2f97b8a154b83e5647
Creating 512 kangaroos to fill a herd
prepare: 5 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
3.35s 2.00% 33554432 | 10017426 op/s | ETA 164 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
6.70s 4.00% 67108864 | 10018063 op/s | ETA 161 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 67108864
DP COLLISION: edbdf2f63a0b159a
PRIVATE KEY: 54c33562418c8987
[033] Solve time / key: 4.874 s
[034] Solving for random private key: 0x1fdbd1db056ba3822 -> 03b3a361e153c4db80767fdf8f59542482d752cce41045d8276a6f8a9a1666e643
Creating 512 kangaroos to fill a herd
prepare: 5 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
3.35s 2.00% 33554432 | 10018033 op/s | ETA 164 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
DP COLLISION: 2a4a7296a7627e45
PRIVATE KEY: 1fdbd1db056ba3822
[034] Solve time / key: 4.890 s
[035] Solving for random private key: 0x1b11c14646cf5b85f -> 028abe5d7b337ee94e08df4cbe7a7eed76294a52a5ee63d330ed16c9b836e983d0
Creating 512 kangaroos to fill a herd
prepare: 5 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
DP COLLISION: 65790871936e4bb7
PRIVATE KEY: 1b11c14646cf5b85f
[035] Solve time / key: 4.815 s
[036] Solving for random private key: 0xcc2e94d189943178 -> 03691739875405307e8cdeacbd462509ab14cebaacc2e7201e2b7dd6545ff80b91
Creating 512 kangaroos to fill a herd
prepare: 5 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
DP COLLISION: a7292a211b889eea
PRIVATE KEY: cc2e94d189943178
[036] Solve time / key: 4.754 s
[037] Solving for random private key: 0x153dbc8e6475532ce -> 03047f77a3e9ab96ecd8248531b513a3d47cc07ea5a5960c7d48dad36903c7f5e1
Creating 512 kangaroos to fill a herd
prepare: 5 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
3.35s 2.00% 33554432 | 10014938 op/s | ETA 164 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
DP COLLISION: 2e2033da0db2031b
PRIVATE KEY: 153dbc8e6475532ce
[037] Solve time / key: 4.730 s
[038] Solving for random private key: 0x5b0c6f75664672cf -> 02d0fea28f433237c0e050d1465f07951fe058f02f62eb8eb63d350d94eeb1f935
Creating 512 kangaroos to fill a herd
prepare: 5 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
3.35s 2.00% 33554432 | 10016690 op/s | ETA 164 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
6.70s 4.00% 67108864 | 10014032 op/s | ETA 161 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 67108864
DP COLLISION: 27fafd8a79c35e5a
PRIVATE KEY: 5b0c6f75664672cf
[038] Solve time / key: 4.817 s
[039] Solving for random private key: 0x1d83532d7399e5d8c -> 03690646657c41c6d51e87b14dabe9f69d73014fbe225e7fb82dacba95f6ab7284
Creating 512 kangaroos to fill a herd
prepare: 5 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
DP COLLISION: 3c1287417331dcb8
PRIVATE KEY: 1d83532d7399e5d8c
[039] Solve time / key: 4.749 s
[040] Solving for random private key: 0x14cd127e35d257e91 -> 03fe5a60fb826927cf54395be40d9a0aecd9d2f2d568d8e4e9911a0ef414ef5a6a
Creating 512 kangaroos to fill a herd
prepare: 5 ms, fill herd: 8 ms
Group ops to perform: 1677721600, 1 jumps / step, 32768 steps / range
3.35s 2.00% 33554432 | 10015393 op/s | ETA 164 s
cached: 0 saved: 59739056 skipped: 0 collisions: 0 ops: 33554432
DP COLLISION: 7d8ac74143c1a1f8
PRIVATE KEY: 14cd127e35d257e91
[040] Solve time / key: 4.756 s
Jump to: