Bitcoin puzzle transaction ~32 BTC prize to who solves it

[Daltonik]

@f4lc0n90 also has a pool for finding puzzle #67 by downloading the client v7 https://github.com/f4lc0n90/f4lc0npool/releases/  you can participate in the search http://f4lc0n.com:8081/ 

[r1ckpwn]

Yeah .. He, most likely, generated 256 keys and manually updated the first character on the left whenever necessary.

You really think he just changed 1 digit? Some one who is an expert in cryptography would know better, but maybe he didn't want to make it very difficult and really used randomly generated keys. But if I were him, I'd have changed a few characters to make it really really hard, for example having a few 0s in a key will make it hard to reverse engineer a key manually, and brute force/kangaroo, well they have their limits.

One other thing could be placing a key outside a bit range, I'm curious did Satoshi ever confirmed that the keys are truly in the assumed bit ranges or we just hope the amounts of transactions are enough of a proof that the keys are exactly there?

But you know what I'd like to see? A large amount in a key with no exactly known bit range, somewhere between 160 and 180 bit not lower and not higher, then solving that key would be a global challenge, though not any amount which someone could spend half of it to use special tools and grab it, something which could only be solved by math and new methods.

For example, I haven't seen any tool/ algorithm capable of  adding or subtracting 1 to a key and then divide it by 2, kangaroo  engages square root calculations, BSGS looks for a match after adding/subtracting calculations, but no tool does + or - 1 then divide!

Now I look at it from a different angle. In binary, the program is more practical, for example, I know the last 8 bits of the private key anyway, because 8 bits equals a maximum of 256 digits. There was a friend who said that if the curve math is 0, multiply, if 1, add, knowing the last bit means solving ecdsa, the last 8 bits are 1 in 256, you can find the rest. If you say the last 16 bits, there is 1 possibility in 65536, these numbers can be tried, you will reduce 125 bits -16 bits =109bits.

This is the code

Code:

from sympy import mod_inverse
import secp256k1 as ice

k=mod_inverse(2,N)
neg1=ice.point_negation(ice.scalar_multiplication(1))

def ters(Qx,Scalar):
     ScalarBin = str(bin(Scalar))[2:]
     le=len(ScalarBin)
     for i in range (0,le):
        if ScalarBin[le-i] == "0":
            Qx=ice.point_multiplication(k,Qx)
        else:
            Qx=ice.point_addition(Qx,neg1)
            Qx=ice.point_multiplication(k,Qx)
     return ice.point_to_cpub(Qx)

for x in range(65536):
         print(ters(pub,x))

If the last bit is 1, it moves the point forward when divided by (2).

7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a1 +

if the last bit is 0 then normal divides

You trying to do mod_inverse using N. But N what is?

[lordfrs]

Yeah .. He, most likely, generated 256 keys and manually updated the first character on the left whenever necessary.

You really think he just changed 1 digit? Some one who is an expert in cryptography would know better, but maybe he didn't want to make it very difficult and really used randomly generated keys. But if I were him, I'd have changed a few characters to make it really really hard, for example having a few 0s in a key will make it hard to reverse engineer a key manually, and brute force/kangaroo, well they have their limits.

One other thing could be placing a key outside a bit range, I'm curious did Satoshi ever confirmed that the keys are truly in the assumed bit ranges or we just hope the amounts of transactions are enough of a proof that the keys are exactly there?

But you know what I'd like to see? A large amount in a key with no exactly known bit range, somewhere between 160 and 180 bit not lower and not higher, then solving that key would be a global challenge, though not any amount which someone could spend half of it to use special tools and grab it, something which could only be solved by math and new methods.

For example, I haven't seen any tool/ algorithm capable of  adding or subtracting 1 to a key and then divide it by 2, kangaroo  engages square root calculations, BSGS looks for a match after adding/subtracting calculations, but no tool does + or - 1 then divide!

Now I look at it from a different angle. In binary, the program is more practical, for example, I know the last 8 bits of the private key anyway, because 8 bits equals a maximum of 256 digits. There was a friend who said that if the curve math is 0, multiply, if 1, add, knowing the last bit means solving ecdsa, the last 8 bits are 1 in 256, you can find the rest. If you say the last 16 bits, there is 1 possibility in 65536, these numbers can be tried, you will reduce 125 bits -16 bits =109bits.

This is the code

Code:

from sympy import mod_inverse
import secp256k1 as ice

k=mod_inverse(2,N)
neg1=ice.point_negation(ice.scalar_multiplication(1))

def ters(Qx,Scalar):
     ScalarBin = str(bin(Scalar))[2:]
     le=len(ScalarBin)
     for i in range (0,le):
        if ScalarBin[le-i] == "0":
            Qx=ice.point_multiplication(k,Qx)
        else:
            Qx=ice.point_addition(Qx,neg1)
            Qx=ice.point_multiplication(k,Qx)
     return ice.point_to_cpub(Qx)

for x in range(65536):
         print(ters(pub,x))

If the last bit is 1, it moves the point forward when divided by (2).

7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a1 +

if the last bit is 0 then normal divides

You trying to do mod_inverse using N. But N what is?

N=0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141

[Denis_Hitov]

Yeah .. He, most likely, generated 256 keys and manually updated the first character on the left whenever necessary.

You really think he just changed 1 digit? Some one who is an expert in cryptography would know better, but maybe he didn't want to make it very difficult and really used randomly generated keys. But if I were him, I'd have changed a few characters to make it really really hard, for example having a few 0s in a key will make it hard to reverse engineer a key manually, and brute force/kangaroo, well they have their limits.

One other thing could be placing a key outside a bit range, I'm curious did Satoshi ever confirmed that the keys are truly in the assumed bit ranges or we just hope the amounts of transactions are enough of a proof that the keys are exactly there?

But you know what I'd like to see? A large amount in a key with no exactly known bit range, somewhere between 160 and 180 bit not lower and not higher, then solving that key would be a global challenge, though not any amount which someone could spend half of it to use special tools and grab it, something which could only be solved by math and new methods.

For example, I haven't seen any tool/ algorithm capable of  adding or subtracting 1 to a key and then divide it by 2, kangaroo  engages square root calculations, BSGS looks for a match after adding/subtracting calculations, but no tool does + or - 1 then divide!

Now I look at it from a different angle. In binary, the program is more practical, for example, I know the last 8 bits of the private key anyway, because 8 bits equals a maximum of 256 digits. There was a friend who said that if the curve math is 0, multiply, if 1, add, knowing the last bit means solving ecdsa, the last 8 bits are 1 in 256, you can find the rest. If you say the last 16 bits, there is 1 possibility in 65536, these numbers can be tried, you will reduce 125 bits -16 bits =109bits.

This is the code

Code:

from sympy import mod_inverse
import secp256k1 as ice

k=mod_inverse(2,N)
neg1=ice.point_negation(ice.scalar_multiplication(1))

def ters(Qx,Scalar):
     ScalarBin = str(bin(Scalar))[2:]
     le=len(ScalarBin)
     for i in range (0,le):
        if ScalarBin[le-i] == "0":
            Qx=ice.point_multiplication(k,Qx)
        else:
            Qx=ice.point_addition(Qx,neg1)
            Qx=ice.point_multiplication(k,Qx)
     return ice.point_to_cpub(Qx)

for x in range(65536):
         print(ters(pub,x))

If the last bit is 1, it moves the point forward when divided by (2).

7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a1 +

if the last bit is 0 then normal divides

You trying to do mod_inverse using N. But N what is?

N=0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141

The code doesn't work.

NameError: name 'pub' is not defined

How to fix?

[lordfrs]

Yeah .. He, most likely, generated 256 keys and manually updated the first character on the left whenever necessary.

You really think he just changed 1 digit? Some one who is an expert in cryptography would know better, but maybe he didn't want to make it very difficult and really used randomly generated keys. But if I were him, I'd have changed a few characters to make it really really hard, for example having a few 0s in a key will make it hard to reverse engineer a key manually, and brute force/kangaroo, well they have their limits.

One other thing could be placing a key outside a bit range, I'm curious did Satoshi ever confirmed that the keys are truly in the assumed bit ranges or we just hope the amounts of transactions are enough of a proof that the keys are exactly there?

But you know what I'd like to see? A large amount in a key with no exactly known bit range, somewhere between 160 and 180 bit not lower and not higher, then solving that key would be a global challenge, though not any amount which someone could spend half of it to use special tools and grab it, something which could only be solved by math and new methods.

For example, I haven't seen any tool/ algorithm capable of  adding or subtracting 1 to a key and then divide it by 2, kangaroo  engages square root calculations, BSGS looks for a match after adding/subtracting calculations, but no tool does + or - 1 then divide!

Now I look at it from a different angle. In binary, the program is more practical, for example, I know the last 8 bits of the private key anyway, because 8 bits equals a maximum of 256 digits. There was a friend who said that if the curve math is 0, multiply, if 1, add, knowing the last bit means solving ecdsa, the last 8 bits are 1 in 256, you can find the rest. If you say the last 16 bits, there is 1 possibility in 65536, these numbers can be tried, you will reduce 125 bits -16 bits =109bits.

This is the code

Code:

from sympy import mod_inverse
import secp256k1 as ice

k=mod_inverse(2,N)
neg1=ice.point_negation(ice.scalar_multiplication(1))

def ters(Qx,Scalar):
     ScalarBin = str(bin(Scalar))[2:]
     le=len(ScalarBin)
     for i in range (0,le):
        if ScalarBin[le-i] == "0":
            Qx=ice.point_multiplication(k,Qx)
        else:
            Qx=ice.point_addition(Qx,neg1)
            Qx=ice.point_multiplication(k,Qx)
     return ice.point_to_cpub(Qx)

for x in range(65536):
         print(ters(pub,x))

If the last bit is 1, it moves the point forward when divided by (2).

7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a1 +

if the last bit is 0 then normal divides

You trying to do mod_inverse using N. But N what is?

N=0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141

The code doesn't work.

NameError: name 'pub' is not defined

How to fix?

pub=ice.pub2upub('0433709eb11e0d4439a729f21c2c443dedb727528229713f0065721ba8fa46f00e2a1c304a39a77 775d3579d077b6ee5e4d26fd3ec36f52ad674a9b47fdd999c48')

[NomadTheSavior]

I see this thing is still going, has anyone solved any of the puzzles yet? Or has anyone made any type of progress? Can I get a TLDR of the events over the years from the start of the puzzle until now?

[digaran]

I see this thing is still going, has anyone solved any of the puzzles yet? Or has anyone made any type of progress? Can I get a TLDR of the events over the years from the start of the puzzle until now?

Over how many years exactly? 😂, #65 and #120 been solved. Prize has been increased 10 fold, now there is around 1000 bitcoins for us to loot ( yeah right).

[cryptoDEADBEEFFFFF]

I see this thing is still going, has anyone solved any of the puzzles yet? Or has anyone made any type of progress? Can I get a TLDR of the events over the years from the start of the puzzle until now?

Over how many years exactly? 😂, #65 and #120 been solved. Prize has been increased 10 fold, now there is around 1000 bitcoins for us to loot ( yeah right).

You forgot one important detaill: puzzle #65 was solved before #64. Idk why!!! 

[GoldTiger69]

I see this thing is still going, has anyone solved any of the puzzles yet? Or has anyone made any type of progress? Can I get a TLDR of the events over the years from the start of the puzzle until now?

Over how many years exactly? 😂, #65 and #120 been solved. Prize has been increased 10 fold, now there is around 1000 bitcoins for us to loot ( yeah right).

You forgot one important detaill: puzzle #65 was solved before #64. Idk why!!! 

That was because public key of #65 was revealed, so Kangaroo was used to find its private key.

[sssergy2705]

Can anyone suggest a Python script to subtract compressed public keys, like in the keymath program from albertobsd's ecctools library?

[kalos15btc]

Can anyone suggest a Python script to subtract compressed public keys, like in the keymath program from albertobsd's ecctools library?

https://github.com/WanderingPhilosopher/Windows-KeySubtractor

[sssergy2705]

Can anyone suggest a Python script to subtract compressed public keys, like in the keymath program from albertobsd's ecctools library?

https://github.com/WanderingPhilosopher/Windows-KeySubtractor

Of course thanks, but I need a library or a python script.

[lordfrs]

Can anyone suggest a Python script to subtract compressed public keys, like in the keymath program from albertobsd's ecctools library?

https://github.com/WanderingPhilosopher/Windows-KeySubtractor

Of course thanks, but I need a library or a python script.

import secp256k1 as ice

def ECsubtract(Q1,Q2):# compressed or uncompressed pubkey
    Q1=ice.pub2upub(Q1)
    Q2=ice.pub2upub(Q2)
    sub=ice.point_negation(Q2)# -Q2
    return (ice.point_additioni(Q1,sub).hex()) #Q1 - Q2



Will this code work or are you looking for something more advanced?

[sssergy2705]

Can anyone suggest a Python script to subtract compressed public keys, like in the keymath program from albertobsd's ecctools library?

https://github.com/WanderingPhilosopher/Windows-KeySubtractor

Of course thanks, but I need a library or a python script.

import secp256k1 as ice

def ECsubtract(Q1,Q2):# compressed or uncompressed pubkey
    Q1=ice.pub2upub(Q1)
    Q2=ice.pub2upub(Q2)
    sub=ice.point_negation(Q2)# -Q2
    return (ice.point_additioni(Q1,sub).hex()) #Q1 - Q2



Will this code work or are you looking for something more advanced?

Thank you.
Quite suitable. I just didn't even think that this library has such functions. ))

[lordfrs]

Can anyone suggest a Python script to subtract compressed public keys, like in the keymath program from albertobsd's ecctools library?

https://github.com/WanderingPhilosopher/Windows-KeySubtractor

Of course thanks, but I need a library or a python script.

import secp256k1 as ice

def ECsubtract(Q1,Q2):# compressed or uncompressed pubkey
    Q1=ice.pub2upub(Q1)
    Q2=ice.pub2upub(Q2)
    sub=ice.point_negation(Q2)# -Q2
    return (ice.point_additioni(Q1,sub).hex()) #Q1 - Q2



Will this code work or are you looking for something more advanced?

Thank you.
Quite suitable. I just didn't even think that this library has such functions. ))

You can just use ice.point_subtraction() function and ice.point_to_cpub() to convert uncompressed public key to compressed

[Denis_Hitov]

Yeah .. He, most likely, generated 256 keys and manually updated the first character on the left whenever necessary.

You really think he just changed 1 digit? Some one who is an expert in cryptography would know better, but maybe he didn't want to make it very difficult and really used randomly generated keys. But if I were him, I'd have changed a few characters to make it really really hard, for example having a few 0s in a key will make it hard to reverse engineer a key manually, and brute force/kangaroo, well they have their limits.

One other thing could be placing a key outside a bit range, I'm curious did Satoshi ever confirmed that the keys are truly in the assumed bit ranges or we just hope the amounts of transactions are enough of a proof that the keys are exactly there?

But you know what I'd like to see? A large amount in a key with no exactly known bit range, somewhere between 160 and 180 bit not lower and not higher, then solving that key would be a global challenge, though not any amount which someone could spend half of it to use special tools and grab it, something which could only be solved by math and new methods.

For example, I haven't seen any tool/ algorithm capable of  adding or subtracting 1 to a key and then divide it by 2, kangaroo  engages square root calculations, BSGS looks for a match after adding/subtracting calculations, but no tool does + or - 1 then divide!

Now I look at it from a different angle. In binary, the program is more practical, for example, I know the last 8 bits of the private key anyway, because 8 bits equals a maximum of 256 digits. There was a friend who said that if the curve math is 0, multiply, if 1, add, knowing the last bit means solving ecdsa, the last 8 bits are 1 in 256, you can find the rest. If you say the last 16 bits, there is 1 possibility in 65536, these numbers can be tried, you will reduce 125 bits -16 bits =109bits.

This is the code

Code:

from sympy import mod_inverse
import secp256k1 as ice

k=mod_inverse(2,N)
neg1=ice.point_negation(ice.scalar_multiplication(1))

def ters(Qx,Scalar):
     ScalarBin = str(bin(Scalar))[2:]
     le=len(ScalarBin)
     for i in range (0,le):
        if ScalarBin[le-i] == "0":
            Qx=ice.point_multiplication(k,Qx)
        else:
            Qx=ice.point_addition(Qx,neg1)
            Qx=ice.point_multiplication(k,Qx)
     return ice.point_to_cpub(Qx)

for x in range(65536):
         print(ters(pub,x))

If the last bit is 1, it moves the point forward when divided by (2).

7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a1 +

if the last bit is 0 then normal divides

You trying to do mod_inverse using N. But N what is?

N=0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141

The code doesn't work.

NameError: name 'pub' is not defined

How to fix?

pub=ice.pub2upub('0433709eb11e0d4439a729f21c2c443dedb727528229713f0065721ba8fa46f00e2a1c304a39a77 775d3579d077b6ee5e4d26fd3ec36f52ad674a9b47fdd999c48')

I'm sorry, but I can't run your code.
Writes this:

Traceback (most recent call last):
  File "D:\user\test.py", line 22, in <module>
    print(ters(pub,x))
  File "D:\user\test.py", line 14, in ters
    if ScalarBin[le-i] == "0":
IndexError: string index out of range

How to fix? Help me please.

[lordfrs]

I'm sorry, but I can't run your code.
Writes this:

Traceback (most recent call last):
  File "D:\user\test.py", line 22, in <module>
    print(ters(pub,x))
  File "D:\user\test.py", line 14, in ters
    if ScalarBin[le-i] == "0":
IndexError: string index out of range

How to fix? Help me please.
[/quote]

Code:

from sympy import mod_inverse
import secp256k1 as ice
pub=ice.pub2upub('0433709eb11e0d4439a729f21c2c443dedb727528229713f0065721ba8fa46f00e2a1c304a39a77775d3579d077b6ee5e4d26fd3ec36f52ad674a9b47fdd999c48')
N=0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141

k=mod_inverse(2,N)
neg1=ice.point_negation(ice.scalar_multiplication(1))


def ters(Qx,Scalar):
     ScalarBin = str(bin(Scalar))[2:]
     le=len(ScalarBin)
     for i in range (1,le+1):
        if ScalarBin[le-i] == "0":
            Qx=ice.point_multiplication(k,Qx)
        else:
            Qx=ice.point_addition(Qx,neg1)
            Qx=ice.point_multiplication(k,Qx)
     return ice.point_to_cpub(Qx)


for x in range(1,65536):
         print(ters(pub,x))

[Denis_Hitov]

I'm sorry, but I can't run your code.
Writes this:

Traceback (most recent call last):
  File "D:\user\test.py", line 22, in <module>
    print(ters(pub,x))
  File "D:\user\test.py", line 14, in ters
    if ScalarBin[le-i] == "0":
IndexError: string index out of range

How to fix? Help me please.

Code:

from sympy import mod_inverse
import secp256k1 as ice
pub=ice.pub2upub('0433709eb11e0d4439a729f21c2c443dedb727528229713f0065721ba8fa46f00e2a1c304a39a77775d3579d077b6ee5e4d26fd3ec36f52ad674a9b47fdd999c48')
N=0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141

k=mod_inverse(2,N)
neg1=ice.point_negation(ice.scalar_multiplication(1))


def ters(Qx,Scalar):
     ScalarBin = str(bin(Scalar))[2:]
     le=len(ScalarBin)
     for i in range (1,le+1):
        if ScalarBin[le-i] == "0":
            Qx=ice.point_multiplication(k,Qx)
        else:
            Qx=ice.point_addition(Qx,neg1)
            Qx=ice.point_multiplication(k,Qx)
     return ice.point_to_cpub(Qx)


for x in range(1,65536):
         print(ters(pub,x))

[/quote]


Launched!
Thank you very much!

[Milly1]

How long would it take you to verify 5,000,000,000 possibilities?

[citb0in]

How long would it take you to verify 5,000,000,000 possibilities?

less than a second