Bitcoin puzzle transaction ~32 BTC prize to who solves it

[nomachine]

I doubt if 10 minutes for 66 even on a super computer is enough and after the 10 minutes its $1.60 per minute so 130 would cost a lot more money than 66. eventually the cost will go down.

Keep in mind the limitations imposed by the IBM Quantum provider, such as the number of allowed jobs, 10 minutes execution time, and queuing times (a shared resources).

Instead of applying Controlled-X gates individually in a loop, you can use Qiskit's QuantumCircuit.mct (Multiple-Control Toffoli) gate to combine multiple Controlled-X gates into a single operation.

qc.mct(list(range(16)), 16)

Code:

def sha256_compression_function(qc, message_bits, expression):
    # Ensure the length of message_bits is 256
    assert len(message_bits) == 256, 

    # Apply Controlled-X gates based on the message bits
    qc.mct(list(range(16)), 16)  # Combine Controlled-X gates into a single operation

    # Manually construct the boolean conditions from the expression
    qc.x([i for i, char in enumerate(expression) if char == '1' and i < 16])

Good Luck !

p.s.
I think it takes at least a week or two to hit something with this...... Every day is $1.60x1440.
High class gambling.

I need to make changes to the Kangaroo_CPU.dll file. How can I do this? I cannot see its content. I tried various programs but I could not see the codes. The programs give errors, I think it is encrypted

 DLLs and SOs are binary files that contain compiled code. If you have access to the source code of the library, it is always better to make the necessary changes there and recompile the library. This is the safest and most recommended approach. If not, the question arises as to what is hidden in them? 

[1714657218]

1714657218

[1714657218]

1714657218

[1714657218]

1714657218

[1714657218]

1714657218

[1714657218]

1714657218

[1714657218]

1714657218

[Kamoheapohea]

       # Implement the SHA-256 compression function using a quantum oracle search for target address prefix 20d45
        sha256_compression_function(qc, binary_message, expression="message[0] == '1' and message[1] == '0' and message[2] == '1' and message[3] == '1'")

You are applying sha256 on the privatekey and compare it to the #66 hash160??? How should this ever return something related to #66?
Also is the sha256_compression_function just trying random bits?

[unclevito]

I doubt if 10 minutes for 66 even on a super computer is enough and after the 10 minutes its $1.60 per minute so 130 would cost a lot more money than 66. eventually the cost will go down.

Keep in mind the limitations imposed by the IBM Quantum provider, such as the number of allowed jobs, 10 minutes execution time, and queuing times (a shared resources).

Instead of applying Controlled-X gates individually in a loop, you can use Qiskit's QuantumCircuit.mct (Multiple-Control Toffoli) gate to combine multiple Controlled-X gates into a single operation.

qc.mct(list(range(16)), 16)

Code:

def sha256_compression_function(qc, message_bits, expression):
    # Ensure the length of message_bits is 256
    assert len(message_bits) == 256, 

    # Apply Controlled-X gates based on the message bits
    qc.mct(list(range(16)), 16)  # Combine Controlled-X gates into a single operation

    # Manually construct the boolean conditions from the expression
    qc.x([i for i, char in enumerate(expression) if char == '1' and i < 16])

Good Luck !

p.s.
I think it takes at least a week or two to hit something with this...... Every day is $1.60x1440.
High class gambling.

I need to make changes to the Kangaroo_CPU.dll file. How can I do this? I cannot see its content. I tried various programs but I could not see the codes. The programs give errors, I think it is encrypted

 DLLs and SOs are binary files that contain compiled code. If you have access to the source code of the library, it is always better to make the necessary changes there and recompile the library. This is the safest and most recommended approach. If not, the question arises as to what is hidden in them? 

Yes no one should expect to hit it in 10 inutes but I put the code up so others could get a taste of the future and others could use it as a framework to modify and improve on the code.

[nomachine]

       # Implement the SHA-256 compression function using a quantum oracle search for target address prefix 20d45
        sha256_compression_function(qc, binary_message, expression="message[0] == '1' and message[1] == '0' and message[2] == '1' and message[3] == '1'")

You are applying sha256 on the privatekey and compare it to the #66 hash160??? How should this ever return something related to #66?
Also is the sha256_compression_function just trying random bits?

I just looked at the whole code now...you are right.

The expression "message[0] == '1' and message[1] == '0' and message[2] == '1' and message[3] == '1'" in the sha256_compression_function is hardcoding specific conditions based on the target address. In a real scenario, the conditions would depend on the actual hash function and Bitcoin address generation process.

The absence of ecdsa.SigningKey.from_string is notable.
For example

Code:

signing_key = ecdsa.SigningKey.from_string(private_key_bytes, curve=ecdsa.SECP256k1)

If we doesn't have this, there must be an encoder that does it. Let's say fastecdsa SEC1Encoder which is fully hardcoded in C.

This method is commonly used in classical (non-quantum) code for dealing with ECDSA (Elliptic Curve Digital Signature Algorithm) signatures in Bitcoin. If you are working with Bitcoin addresses, you would typically use libraries like ecdsa/fastecdsa to handle key generation and signing.

I'm losing 0.001 part of a second just for that in Python. ECDSA signing function is the most time consuming and is a bottleneck in the overall speed. It's painfully slow. I would love to throw it out as well, but i can't. That's not how things works.

The code seems to be treating the quantum computation as a search problem, attempting to find a hash collision that matches the target address. However, the actual Bitcoin address generation process involves public key derivation, hash functions, and elliptic curve cryptography, which are not accurately represented in the code.

[MoreForUs]

wow, iwas telling some co workers about the script i wrote and how it works.. They never heard of this puzzle and wanted a shot, my script is currently searching for puzzle 66,67,68 and 69 just by iterating through the decimal range for 20000000000000000 - 2ffffffffffffffff
they both bought the script for $50 bucks each lol. i'm fine with selling the shovels 

[citb0in]

my script is currently searching for puzzle 66,67,68 and 69 just by iterating through the decimal range for 20000000000000000 - 2ffffffffffffffff

cool! wish you best of luck in finding the jewels in the universe of simple 18,446,744,073,709,551,615 ... hum....whatever 

[WanderingPhilospher]

wow, iwas telling some co workers about the script i wrote and how it works.. They never heard of this puzzle and wanted a shot, my script is currently searching for puzzle 66,67,68 and 69 just by iterating through the decimal range for 20000000000000000 - 2ffffffffffffffff
they both bought the script for $50 bucks each lol. i'm fine with selling the shovels 

Good deal.

I really hope you added the suggestions that were mentioned by various people here in the forum, because your script was extremely slow and a lot of steps that were not needed.

Send me your coworkers contact info so I can sell them a better script that does the same thing at 120x the speed of yours. Maybe $500? 

[tmar777]

Working on a script to run on a quantum computer, WE SHALL SEE THE RESULTS 

Code:

.from qiskit import QuantumCircuit, execute, Aer
from qiskit.circuit.library import PhaseOracle

target_address_hex = "20d45a6a762535700ce9e0b216e31994335db8a5"
target_address_decimal = int(target_address_hex, 16)

def sha256_compression_function(qc, message_bits):
    # Implement SHA-256 compression using quantum gates
    # You need to add the actual logic here

    # For demonstration purposes, we'll just apply a simple quantum oracle
    oracle = PhaseOracle(message_bits, target=target_address_decimal)
    qc.append(oracle, range(qc.num_qubits))

# Define the range for iteration
start_range = 36893488147419103232
end_range = -73786976294838206464

# Main loop
for decimal_value in range(start_range, end_range+1):
    # Convert decimal value to bytes and binary string
    message_bytes = decimal_value.to_bytes(32, byteorder="big")
    binary_message = ''.join(format(byte, '08b') for byte in message_bytes)

    # Create quantum circuit
    qc = QuantumCircuit(256)

    # Apply bit operations to encode the initial state and message onto the qubits
    # Implement encoding logic based on your requirements

    # Implement the SHA-256 compression function using a quantum oracle
    sha256_compression_function(qc, binary_message)

    # Measure the final state of the qubits
    qc.measure_all()

    # Simulate the circuit
    job = execute(qc, backend=Aer.get_backend('qasm_simulator'), shots=1024)

    # Get the results and extract the final state
    counts = job.result().get_counts(qc)
    final_state = [int(bits, 2) for bits in counts.keys()][0]

    # Check if the generated hash matches the target address
    if final_state == target_address_decimal:
        print(f"Target address found!")
        print(f"Decimal Value: {decimal_value}")
        print(f"Simulated Bitcoin hash160: {hex(final_state)[2:].zfill(40)}")
        break

Hi mate,

how it is going so far? How much is the real rate of keys/s?

[mcdouglasx]

just to test if it's possible, not sure but for the sake of science.
let's do a test.

Someone send me a pubkey that is within the decimal range of puzzle #130 without revealing the pk.

start= 680564733841876926926749214863536422911 
         
end= 1361129467683753853853498429727072845823

       

What I want to experiment with is if I can tell you if a pubkey is greater or less than:

1000000000000000000000000000000000000000

I know it's crazy  but I don't lose anything by testing my calculations in ecc

[mcdouglasx]

Here, I give you 2 which are really close to each other, lets go.😉

Code:

03b4f75b9205bdcfcf269e604e27066ea422f11e7c1cf50dee6d6b005510e4deaf
02f92b4119e2ecdc2924ff6983f65c3b5af9ed036ce5a6469f3462965840e3daef

03b4f75b9205bdcfcf269e604e27066ea422f11e7c1cf50dee6d6b005510e4deaf
Actually, if this were possible, bitcoin was underground.
I would say it is above
1000000000000000000000000000000000000000
but my calculations have errors, so if I'm right I'll take it as a coincidence., but I will continue investigating.
Although I am more than 99% sure that this is not possible, we always have to explore all angles in science..

[yellowstripes]

Here, I give you 2 which are really close to each other, lets go.😉

Code:

03b4f75b9205bdcfcf269e604e27066ea422f11e7c1cf50dee6d6b005510e4deaf
02f92b4119e2ecdc2924ff6983f65c3b5af9ed036ce5a6469f3462965840e3daef

The difference between the two public keys is 6.

If I had more time I would find the sum. Once you know the difference and sum then you can solve for the private keys individually. Simple algebra really.

[WanderingPhilospher]

Here, I give you 2 which are really close to each other, lets go.😉

Code:

03b4f75b9205bdcfcf269e604e27066ea422f11e7c1cf50dee6d6b005510e4deaf
02f92b4119e2ecdc2924ff6983f65c3b5af9ed036ce5a6469f3462965840e3daef

03b4f75b9205bdcfcf269e604e27066ea422f11e7c1cf50dee6d6b005510e4deaf
Actually, if this were possible, bitcoin was underground.
I would say it is above
1000000000000000000000000000000000000000
but my calculations have errors, so if I'm right I'll take it as a coincidence., but I will continue investigating.
Although I am more than 99% sure that this is not possible, we always have to explore all angles in science..

Both of these are definitely above 1000000000000000000000000000000000000000.

I developed a script about a year ago that you can change the Generator and it will get you within 43 bits of a pubkeys location.

These are roughly 21,474,836,480 to 49,123,688,448 above 1000000000000000000000000000000000000000.

[nomachine]

Hi mate,

how it is going so far? How much is the real rate of keys/s?

Quantum computers, in theory, could provide a speedup for certain types of search problems, but finding hash collisions for cryptographic hash functions is not one of them. Cryptographic primitives like hash functions and ECDSA are designed to be resistant to preimage attacks, and quantum computers do not break this resistance.
Quantum computation do not pose an immediate threat to the security of Bitcoin or other widely used cryptographic systems.
This approach is more of a proof-of-concept or educational exercise rather than a practical implementation for breaking Bitcoin's security.
Quantum algorithm/hardware for solving such problems would need to be carefully designed to provide actual advantages over classical approaches.
Example:
https://arxiv.org/pdf/2302.06639.pdf
IBM Quantum Backend don't have the hardware (arithmetic circuits) available for "126 133 Cat Qubits"  
If someone succeeds in doing this, they will know exactly who is capable of it in the scientific community and they have their addresses where they live.
All other talk is just good advertising for these quantum backend providers.

[AlanJohnson]

Hi mate,

how it is going so far? How much is the real rate of keys/s?

Quantum computers, in theory, could provide a speedup for certain types of search problems, but finding hash collisions for cryptographic hash functions is not one of them. Cryptographic primitives like hash functions and ECDSA are designed to be resistant to preimage attacks, and quantum computers do not break this resistance.
Quantum computation do not pose an immediate threat to the security of Bitcoin or other widely used cryptographic systems.
This approach is more of a proof-of-concept or educational exercise rather than a practical implementation for breaking Bitcoin's security.
Quantum algorithm/hardware for solving such problems would need to be carefully designed to provide actual advantages over classical approaches.
Example:
https://arxiv.org/pdf/2302.06639.pdf
IBM Quantum Backend don't have the hardware (arithmetic circuits) available for "126 133 Cat Qubits"  
If someone succeeds in doing this, they will know exactly who is capable of it in the scientific community and they have their addresses where they live.
All other talk is just good advertising for these quantum backend providers.

Are you sure ?

From what i know ECDSA is vulnerable to quantum computers attack. Maybe not that one IBM allows to use for free for 10 minutes. But generally : IT'S VULNERABLE.

https://security.stackexchange.com/questions/34940/is-ecdsa-breakable-by-quantum-computers

[tmar777]

Here, I give you 2 which are really close to each other, lets go.😉

Code:

03b4f75b9205bdcfcf269e604e27066ea422f11e7c1cf50dee6d6b005510e4deaf
02f92b4119e2ecdc2924ff6983f65c3b5af9ed036ce5a6469f3462965840e3daef

The difference between the two public keys is 6.

If I had more time I would find the sum. Once you know the difference and sum then you can solve for the private keys individually. Simple algebra really.

Can you please explain this part how it works?
"Once you know the difference and sum then you can solve for the private keys individually. Simple algebra really."

Also, can somebody explain to me about which mode of searching for private keys is more efficient?
I mean is it more efficient to search sequentially each possible binary (of private key), the address (sequentially), the rmd160, the Xpoint or what else?
Is there any research paper about this?

Hi mate,

how it is going so far? How much is the real rate of keys/s?

Quantum computers, in theory, could provide a speedup for certain types of search problems, but finding hash collisions for cryptographic hash functions is not one of them. Cryptographic primitives like hash functions and ECDSA are designed to be resistant to preimage attacks, and quantum computers do not break this resistance.
Quantum computation do not pose an immediate threat to the security of Bitcoin or other widely used cryptographic systems.
This approach is more of a proof-of-concept or educational exercise rather than a practical implementation for breaking Bitcoin's security.
Quantum algorithm/hardware for solving such problems would need to be carefully designed to provide actual advantages over classical approaches.
Example:
https://arxiv.org/pdf/2302.06639.pdf
IBM Quantum Backend don't have the hardware (arithmetic circuits) available for "126 133 Cat Qubits"  
If someone succeeds in doing this, they will know exactly who is capable of it in the scientific community and they have their addresses where they live.
All other talk is just good advertising for these quantum backend providers.

Thanks for your reply mate :-)

[citb0in]

Here, I give you 2 which are really close to each other, lets go.😉

Code:

03b4f75b9205bdcfcf269e604e27066ea422f11e7c1cf50dee6d6b005510e4deaf
02f92b4119e2ecdc2924ff6983f65c3b5af9ed036ce5a6469f3462965840e3daef

The difference between the two public keys is 6.

If I had more time I would find the sum. Once you know the difference and sum then you can solve for the private keys individually. Simple algebra really.

it is 4

[nomachine]

Hi mate,

how it is going so far? How much is the real rate of keys/s?

Quantum computers, in theory, could provide a speedup for certain types of search problems, but finding hash collisions for cryptographic hash functions is not one of them. Cryptographic primitives like hash functions and ECDSA are designed to be resistant to preimage attacks, and quantum computers do not break this resistance.
Quantum computation do not pose an immediate threat to the security of Bitcoin or other widely used cryptographic systems.
This approach is more of a proof-of-concept or educational exercise rather than a practical implementation for breaking Bitcoin's security.
Quantum algorithm/hardware for solving such problems would need to be carefully designed to provide actual advantages over classical approaches.
Example:
https://arxiv.org/pdf/2302.06639.pdf
IBM Quantum Backend don't have the hardware (arithmetic circuits) available for "126 133 Cat Qubits"  
If someone succeeds in doing this, they will know exactly who is capable of it in the scientific community and they have their addresses where they live.
All other talk is just good advertising for these quantum backend providers.

Are you sure ?

From what i know ECDSA is vulnerable to quantum computers attack. Maybe not that one IBM allows to use for free for 10 minutes. But generally : IT'S VULNERABLE.

https://security.stackexchange.com/questions/34940/is-ecdsa-breakable-by-quantum-computers

Did you read the link above?  Theoretically it is. Practically not. Equipment required for something like this goes beyond home garages conditions. Even ordinary quantum computers. A special laboratory is needed for such a computer.
Not to mention that laser generated (radiated) random numbers are needed combined with a quantum computer. And such a quantum computer must have a special kind of qubit for Shor's algorithm, special efficiency power supplies, sub-zero cooling and a fully controlled environment.
Development and deployment of practical, large-scale quantum computers capable of breaking these algorithms are still in the early stages. Many technical challenges need to be addressed before quantum computers become a practical threat to current cryptographic systems.
Laser-generated random numbers, on the other hand, are not directly related to the security of ECDSA or other cryptographic algorithms. Random number generation is a separate aspect of cryptography that is crucial for key generation and other cryptographic processes.

[nomachine]

One does not become a university professor after posting one liner or few liner generic sh*tposts.

You still haven't answered the question of where your scientific works are. Where can we read online?

[citb0in]

@nomachine: you quoted him, so I see his messages... damn  it took me a while to find out about the great button IGNORE and I can highly recommend using it. You will find it under his name. Believe me or not - it helps!

[yellowstripes]

Here, I give you 2 which are really close to each other, lets go.😉

Code:

03b4f75b9205bdcfcf269e604e27066ea422f11e7c1cf50dee6d6b005510e4deaf
02f92b4119e2ecdc2924ff6983f65c3b5af9ed036ce5a6469f3462965840e3daef

The difference between the two public keys is 6.

If I had more time I would find the sum. Once you know the difference and sum then you can solve for the private keys individually. Simple algebra really.

it is 4

Yes. My bad. It is 4. I misread the column number on my spreadsheet.