Search content
Sort by
Showing 20 of 80 results by bjpark
⭐ Merited by vjudeu (1)
Hello everyone,
I would like to present a challenge to the forum participants.
Consider the following constant:
0x7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a1
The challenge is: given a random private key, can you determine whether the key is greater than or less than this constant?
Importantly, this is not about random guessing (50% probability), but about whether there exists a mathematical or cryptographic logic that allows one to consistently and correctly determine the result.
To make the challenge clearer:
Suppose 100 such comparison problems are given.
Is there anyone who can answer all 100 correctly without relying on random chance?
The purpose of this challenge is twofold:
To check if there exists any known logic or method to solve such problems consistently.
To confirm whether, according to current knowledge, this task is impossible without random guessing.
If you believe a method exists, please share your reasoning or approach. If you believe it is impossible, your confirmation would also be valuable.
Thank you for your thoughts and participation.
I would like to present a challenge to the forum participants.
Consider the following constant:
0x7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a1
The challenge is: given a random private key, can you determine whether the key is greater than or less than this constant?
Importantly, this is not about random guessing (50% probability), but about whether there exists a mathematical or cryptographic logic that allows one to consistently and correctly determine the result.
To make the challenge clearer:
Suppose 100 such comparison problems are given.
Is there anyone who can answer all 100 correctly without relying on random chance?
The purpose of this challenge is twofold:
To check if there exists any known logic or method to solve such problems consistently.
To confirm whether, according to current knowledge, this task is impossible without random guessing.
If you believe a method exists, please share your reasoning or approach. If you believe it is impossible, your confirmation would also be valuable.
Thank you for your thoughts and participation.
Code:
import random
import ecdsa
import binascii
# Generate random values for the test
# a and b are private keys (a > b by a fixed amount), and they can be positive or negative
def generate_random_values():
a = random.randint(2**134, 2**135) # random large number (134~135 bits)
am = 10**37 # fixed delta between a and b
b = a - am
# Randomly assign positive or negative sign
sign = random.choice([1, -1])
pma = sign * a # signed private key a
pmb = sign * b # signed private key b
return a, b, am, pma, pmb
# Order of the secp256k1 curve (Bitcoin/Ethereum)
N = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
# Generate public key from a given (signed) private key
def generate_public_key(private_key_int):
private_key_bytes = abs(private_key_int).to_bytes(32, byteorder="big", signed=True)
sk = ecdsa.SigningKey.from_string(private_key_bytes, curve=ecdsa.SECP256k1)
vk = sk.verifying_key
# Uncompressed public key (0x04 + x + y)
public_key_bytes_uncompressed = b"\x04" + vk.to_string()
# Compressed public key (0x02 / 0x03 prefix)
if private_key_int < 0:
public_key_bytes_compressed = (
b"\x03" + vk.to_string()[:32] if vk.to_string()[-1] % 2 == 0 else b"\x02" + vk.to_string()[:32]
)
else:
public_key_bytes_compressed = (
b"\x02" + vk.to_string()[:32] if vk.to_string()[-1] % 2 == 0 else b"\x03" + vk.to_string()[:32]
)
return (
binascii.hexlify(public_key_bytes_uncompressed).decode(),
binascii.hexlify(public_key_bytes_compressed).decode()
)
# Threshold for sign determination
threshold = 0x7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a1
# Adjust for negative keys (mod N)
def get_adjusted_value(key_int):
return key_int if key_int >= 0 else N + key_int
# Store challenge public key pairs
public_keys_by_iteration = []
# Generate 100 randomized test pairs
for i in range(1, 101):
a, b, am, pma, pmb = generate_random_values()
# --- INTERNAL USE (scoring reference) ---
# These are for internal grading only, not to be shared outside.
# print("a:", a)
# print("b:", b)
# print("am:", am)
# print("pma (Private Key a):", pma)
# print("pmb (Private Key b):", pmb)
# Generate public keys
_, public_key_a_compressed = generate_public_key(pma)
_, public_key_b_compressed = generate_public_key(pmb)
# --- INTERNAL SIGN CHECK (not shared) ---
adjusted_pma = get_adjusted_value(pma)
if adjusted_pma < threshold:
sign_label = "+"
else:
sign_label = "-"
# print("pma sign:", sign_label)
# Store compressed keys for challenge
public_keys_by_iteration.append([public_key_a_compressed, public_key_b_compressed])
# --- PUBLIC OUTPUT: Challenge only ---
print("\n--- Public Keys for Each Challenge ---")
for idx, keys in enumerate(public_keys_by_iteration, start=1):
print(f"\nChallenge {idx}:")
for key in keys:
print(key)
import ecdsa
import binascii
# Generate random values for the test
# a and b are private keys (a > b by a fixed amount), and they can be positive or negative
def generate_random_values():
a = random.randint(2**134, 2**135) # random large number (134~135 bits)
am = 10**37 # fixed delta between a and b
b = a - am
# Randomly assign positive or negative sign
sign = random.choice([1, -1])
pma = sign * a # signed private key a
pmb = sign * b # signed private key b
return a, b, am, pma, pmb
# Order of the secp256k1 curve (Bitcoin/Ethereum)
N = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
# Generate public key from a given (signed) private key
def generate_public_key(private_key_int):
private_key_bytes = abs(private_key_int).to_bytes(32, byteorder="big", signed=True)
sk = ecdsa.SigningKey.from_string(private_key_bytes, curve=ecdsa.SECP256k1)
vk = sk.verifying_key
# Uncompressed public key (0x04 + x + y)
public_key_bytes_uncompressed = b"\x04" + vk.to_string()
# Compressed public key (0x02 / 0x03 prefix)
if private_key_int < 0:
public_key_bytes_compressed = (
b"\x03" + vk.to_string()[:32] if vk.to_string()[-1] % 2 == 0 else b"\x02" + vk.to_string()[:32]
)
else:
public_key_bytes_compressed = (
b"\x02" + vk.to_string()[:32] if vk.to_string()[-1] % 2 == 0 else b"\x03" + vk.to_string()[:32]
)
return (
binascii.hexlify(public_key_bytes_uncompressed).decode(),
binascii.hexlify(public_key_bytes_compressed).decode()
)
# Threshold for sign determination
threshold = 0x7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a1
# Adjust for negative keys (mod N)
def get_adjusted_value(key_int):
return key_int if key_int >= 0 else N + key_int
# Store challenge public key pairs
public_keys_by_iteration = []
# Generate 100 randomized test pairs
for i in range(1, 101):
a, b, am, pma, pmb = generate_random_values()
# --- INTERNAL USE (scoring reference) ---
# These are for internal grading only, not to be shared outside.
# print("a:", a)
# print("b:", b)
# print("am:", am)
# print("pma (Private Key a):", pma)
# print("pmb (Private Key b):", pmb)
# Generate public keys
_, public_key_a_compressed = generate_public_key(pma)
_, public_key_b_compressed = generate_public_key(pmb)
# --- INTERNAL SIGN CHECK (not shared) ---
adjusted_pma = get_adjusted_value(pma)
if adjusted_pma < threshold:
sign_label = "+"
else:
sign_label = "-"
# print("pma sign:", sign_label)
# Store compressed keys for challenge
public_keys_by_iteration.append([public_key_a_compressed, public_key_b_compressed])
# --- PUBLIC OUTPUT: Challenge only ---
print("\n--- Public Keys for Each Challenge ---")
for idx, keys in enumerate(public_keys_by_iteration, start=1):
print(f"\nChallenge {idx}:")
for key in keys:
print(key)
Re: [CHALLENGE] 5 BTC Reward – ECDSA Structured Nonce k Puzzle (1M Signatures)
I’m releasing a cryptographic challenge designed for experts in Bitcoin ECDSA internals, elliptic curve analysis, and nonce pattern vulnerabilities. There is a 5 BTC reward for the first person who solves it. Read the structure carefully.
The Puzzle Overview:
I have posted a file containing 1,000,000 valid signatures for one fixed public key.
Each signature is given as (sig_num, r, s, z, A, rx, ry) where:
r, s, and z are standard ECDSA signature parameters (z is the hashed message)
A is added to the private key to produce the nonce k used for that signature
k = d + A (mod n)
rx, ry are the elliptic curve point coordinates of r
PUBLIC KEY:
04c1c1e912c51061424286bdea075e0a19a96be1869566f4ebc9ea3e565f9c334d1779371fd313e dc2955b14f3eaabf8af027f77a7b3e1e908839d4f7ee81aef28
X = 87638989873003743107580407194345607023493955367007042197569832403610862629709
Y = 10617364466289823353593438673072375587688363537404447133738278709366498193192
Important Details
The nonce values for signatures increase incrementally:
1st signature: k = d + 2
2nd signature: k = d + 3
3rd signature: k = d + 4
... and so forth, continuing this pattern for all 1,000,000 signatures.
In every signature, r == s
Apply for only this dataset,
CSV file download (1 million signatures): https://is.gd/1million_rsz
Edit : Additional 2,000,000 ECDSA Signatures Released for Making this puzzle Solvable
Data Access: https://is.gd/Another1M_RSZ
Data Access: https://is.gd/Another1M_RSZ2
Important: All signatures satisfy r ≠ s.
Each line contains: r, s, z, ry
where r and s are the ECDSA signature components, z is the message hash, and ry is the y-coordinate of the curve point corresponding to r.
Bounty:
Recover any valid k and post it here with the corresponding signature index.
Or recover the private key directly from any subset of signatures.
Post your result here along with your Bitcoin address to receive the bounty.
💰 Prize: 5 BTC
⏱ Paid within 24 hours of verified result.
If you successfully recover any nonce k or the private key d, post your result here along with your BTC address to receive the 5 BTC reward.
Rewards & Rules
5 BTC payout within 24 hours after proof of valid nonce or private key recovery.
Puzzle Purpose:
This cryptographic challenge is an integral step in advancing the development of a novel cryptocurrency protocol inspired by Bitcoin’s UTXO model, yet architected with quantum-resistant cryptographic primitives. By analyzing structured ECDSA nonce patterns and their vulnerabilities, the goal is to rigorously test classical elliptic curve assumptions, improve nonce generation schemes, and inform the design of next-generation signature algorithms resilient against quantum adversaries.
The Puzzle Overview:
I have posted a file containing 1,000,000 valid signatures for one fixed public key.
Each signature is given as (sig_num, r, s, z, A, rx, ry) where:
r, s, and z are standard ECDSA signature parameters (z is the hashed message)
A is added to the private key to produce the nonce k used for that signature
k = d + A (mod n)
rx, ry are the elliptic curve point coordinates of r
PUBLIC KEY:
04c1c1e912c51061424286bdea075e0a19a96be1869566f4ebc9ea3e565f9c334d1779371fd313e dc2955b14f3eaabf8af027f77a7b3e1e908839d4f7ee81aef28
X = 87638989873003743107580407194345607023493955367007042197569832403610862629709
Y = 10617364466289823353593438673072375587688363537404447133738278709366498193192
Important Details
The nonce values for signatures increase incrementally:
1st signature: k = d + 2
2nd signature: k = d + 3
3rd signature: k = d + 4
... and so forth, continuing this pattern for all 1,000,000 signatures.
In every signature, r == s
Apply for only this dataset,
CSV file download (1 million signatures): https://is.gd/1million_rsz
Edit : Additional 2,000,000 ECDSA Signatures Released for Making this puzzle Solvable
Data Access: https://is.gd/Another1M_RSZ
Data Access: https://is.gd/Another1M_RSZ2
Important: All signatures satisfy r ≠ s.
Each line contains: r, s, z, ry
where r and s are the ECDSA signature components, z is the message hash, and ry is the y-coordinate of the curve point corresponding to r.
Bounty:
Recover any valid k and post it here with the corresponding signature index.
Or recover the private key directly from any subset of signatures.
Post your result here along with your Bitcoin address to receive the bounty.
💰 Prize: 5 BTC
⏱ Paid within 24 hours of verified result.
If you successfully recover any nonce k or the private key d, post your result here along with your BTC address to receive the 5 BTC reward.
Rewards & Rules
5 BTC payout within 24 hours after proof of valid nonce or private key recovery.
Puzzle Purpose:
This cryptographic challenge is an integral step in advancing the development of a novel cryptocurrency protocol inspired by Bitcoin’s UTXO model, yet architected with quantum-resistant cryptographic primitives. By analyzing structured ECDSA nonce patterns and their vulnerabilities, the goal is to rigorously test classical elliptic curve assumptions, improve nonce generation schemes, and inform the design of next-generation signature algorithms resilient against quantum adversaries.
To the person who created this problem...
Please solve this problem first.
There are 13.5 bits.
It is exactly the same, R == S, and Z is created by me.
I can create millions of them, but it's a waste of time, so I will only present two problems in the same format.
Here is the public key:
02145d2611c823a396ef6712ce0f712f09b9b4f3135e3e0aa3230fb9b6d08d1e16
R = 0x4806fcc582332d33610d925fc06afcbb8b141cb4d87fa401effdfb59d4011f99
S = 0x4806fcc582332d33610d925fc06afcbb8b141cb4d87fa401effdfb59d4011f99
Z = 0xa5f9777f19c3d9d3443e09e0a8120b413da3a78bc8b182791bf14cd4a33466a3
R = 0xe12ec23c6d7ee189c248807bac60206a5cf8ea7f899214ca9d0a2a8ddc44d7cf
S = 0xe12ec23c6d7ee189c248807bac60206a5cf8ea7f899214ca9d0a2a8ddc44d7cf
Z = 0x6d17d3bc1305497d13b0bc8f7abe94ccd448a1377ea79d5e7f57da8d4ede8f1
so, you say it is possible to create z by only rs and pub key. how?
To explain a simple formula:
Private Key: 120
Public Key:
(0xdd5ba67cfb807824bd3ff25e9d1667fa89e7020e8e0becb79caa00f574adc826,
0xd6b837116fa89fa1d0d6e193aaaf5a5642425d84290545f294a0753a915b644c)
Now, let’s say we are using a formula where we add the private key like this:
Public Key 120 + (Private Key 56457)
Then we get:
R = 56,577 → (which is just 56457 + 120)
S = 1
Z = 56457
This is the most basic relationship among R, S, and Z.
So, for example:
Public Key 120 = 56577 - 56457
This kind of thing used to be difficult to understand or build, but over time, many people studied cryptography and math concepts, and now it’s much more approachable.
In fact, I created this kind of concept on YouTube three years ago:
📺 https://youtu.be/G3veKAXGyFo
And I even made a calculator that can perform these kinds of operations three years ago too:
📺 https://youtu.be/9i6cQOTYAkU
Re: [CHALLENGE] 5 BTC Reward – ECDSA Structured Nonce k Puzzle (1M Signatures)
I’m releasing a cryptographic challenge designed for experts in Bitcoin ECDSA internals, elliptic curve analysis, and nonce pattern vulnerabilities. There is a 5 BTC reward for the first person who solves it. Read the structure carefully.
The Puzzle Overview:
I have posted a file containing 1,000,000 valid signatures for one fixed public key.
Each signature is given as (sig_num, r, s, z, A, rx, ry) where:
r, s, and z are standard ECDSA signature parameters (z is the hashed message)
A is added to the private key to produce the nonce k used for that signature
k = d + A (mod n)
rx, ry are the elliptic curve point coordinates of r
PUBLIC KEY:
04c1c1e912c51061424286bdea075e0a19a96be1869566f4ebc9ea3e565f9c334d1779371fd313e dc2955b14f3eaabf8af027f77a7b3e1e908839d4f7ee81aef28
X = 87638989873003743107580407194345607023493955367007042197569832403610862629709
Y = 10617364466289823353593438673072375587688363537404447133738278709366498193192
Important Details
The nonce values for signatures increase incrementally:
1st signature: k = d + 2
2nd signature: k = d + 3
3rd signature: k = d + 4
... and so forth, continuing this pattern for all 1,000,000 signatures.
In every signature, r == s
Apply for only this dataset,
CSV file download (1 million signatures): https://is.gd/1million_rsz
Edit : Additional 2,000,000 ECDSA Signatures Released for Making this puzzle Solvable
Data Access: https://is.gd/Another1M_RSZ
Data Access: https://is.gd/Another1M_RSZ2
Important: All signatures satisfy r ≠ s.
Each line contains: r, s, z, ry
where r and s are the ECDSA signature components, z is the message hash, and ry is the y-coordinate of the curve point corresponding to r.
Bounty:
Recover any valid k and post it here with the corresponding signature index.
Or recover the private key directly from any subset of signatures.
Post your result here along with your Bitcoin address to receive the bounty.
💰 Prize: 5 BTC
⏱ Paid within 24 hours of verified result.
If you successfully recover any nonce k or the private key d, post your result here along with your BTC address to receive the 5 BTC reward.
Rewards & Rules
5 BTC payout within 24 hours after proof of valid nonce or private key recovery.
Puzzle Purpose:
This cryptographic challenge is an integral step in advancing the development of a novel cryptocurrency protocol inspired by Bitcoin’s UTXO model, yet architected with quantum-resistant cryptographic primitives. By analyzing structured ECDSA nonce patterns and their vulnerabilities, the goal is to rigorously test classical elliptic curve assumptions, improve nonce generation schemes, and inform the design of next-generation signature algorithms resilient against quantum adversaries.
The Puzzle Overview:
I have posted a file containing 1,000,000 valid signatures for one fixed public key.
Each signature is given as (sig_num, r, s, z, A, rx, ry) where:
r, s, and z are standard ECDSA signature parameters (z is the hashed message)
A is added to the private key to produce the nonce k used for that signature
k = d + A (mod n)
rx, ry are the elliptic curve point coordinates of r
PUBLIC KEY:
04c1c1e912c51061424286bdea075e0a19a96be1869566f4ebc9ea3e565f9c334d1779371fd313e dc2955b14f3eaabf8af027f77a7b3e1e908839d4f7ee81aef28
X = 87638989873003743107580407194345607023493955367007042197569832403610862629709
Y = 10617364466289823353593438673072375587688363537404447133738278709366498193192
Important Details
The nonce values for signatures increase incrementally:
1st signature: k = d + 2
2nd signature: k = d + 3
3rd signature: k = d + 4
... and so forth, continuing this pattern for all 1,000,000 signatures.
In every signature, r == s
Apply for only this dataset,
CSV file download (1 million signatures): https://is.gd/1million_rsz
Edit : Additional 2,000,000 ECDSA Signatures Released for Making this puzzle Solvable
Data Access: https://is.gd/Another1M_RSZ
Data Access: https://is.gd/Another1M_RSZ2
Important: All signatures satisfy r ≠ s.
Each line contains: r, s, z, ry
where r and s are the ECDSA signature components, z is the message hash, and ry is the y-coordinate of the curve point corresponding to r.
Bounty:
Recover any valid k and post it here with the corresponding signature index.
Or recover the private key directly from any subset of signatures.
Post your result here along with your Bitcoin address to receive the bounty.
💰 Prize: 5 BTC
⏱ Paid within 24 hours of verified result.
If you successfully recover any nonce k or the private key d, post your result here along with your BTC address to receive the 5 BTC reward.
Rewards & Rules
5 BTC payout within 24 hours after proof of valid nonce or private key recovery.
Puzzle Purpose:
This cryptographic challenge is an integral step in advancing the development of a novel cryptocurrency protocol inspired by Bitcoin’s UTXO model, yet architected with quantum-resistant cryptographic primitives. By analyzing structured ECDSA nonce patterns and their vulnerabilities, the goal is to rigorously test classical elliptic curve assumptions, improve nonce generation schemes, and inform the design of next-generation signature algorithms resilient against quantum adversaries.
To the person who created this problem...
Please solve this problem first.
There are 13.5 bits.
It is exactly the same, R == S, and Z is created by me.
I can create millions of them, but it's a waste of time, so I will only present two problems in the same format.
Here is the public key:
02145d2611c823a396ef6712ce0f712f09b9b4f3135e3e0aa3230fb9b6d08d1e16
R = 0x4806fcc582332d33610d925fc06afcbb8b141cb4d87fa401effdfb59d4011f99
S = 0x4806fcc582332d33610d925fc06afcbb8b141cb4d87fa401effdfb59d4011f99
Z = 0xa5f9777f19c3d9d3443e09e0a8120b413da3a78bc8b182791bf14cd4a33466a3
R = 0xe12ec23c6d7ee189c248807bac60206a5cf8ea7f899214ca9d0a2a8ddc44d7cf
S = 0xe12ec23c6d7ee189c248807bac60206a5cf8ea7f899214ca9d0a2a8ddc44d7cf
Z = 0x6d17d3bc1305497d13b0bc8f7abe94ccd448a1377ea79d5e7f57da8d4ede8f1
I can perform arithmetic operations on public keys.
I am the person who created the public key shown in this YouTube video.
Using my own calculation method, I reduced the 135 puzzle’s range to 113.
Then, by dividing 113 into 128 parts, I further reduced it to a range of 106.
0x200000000000000000000000000 : 0x400000000000000000000000000
If my calculation method is correct, it seems that one of the 128 public keys can be found.
The 128 public keys are as follows:
If anyone finds one among them, please contact me—I would like to share the prize with you.
https://t.me/kyscolx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 am the person who created the public key shown in this YouTube video.
Using my own calculation method, I reduced the 135 puzzle’s range to 113.
Then, by dividing 113 into 128 parts, I further reduced it to a range of 106.
0x200000000000000000000000000 : 0x400000000000000000000000000
If my calculation method is correct, it seems that one of the 128 public keys can be found.
The 128 public keys are as follows:
If anyone finds one among them, please contact me—I would like to share the prize with you.
https://t.me/kyscolx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 can perform arithmetic operations on public keys.
I am the person who created the public key shown in this YouTube video.
Using my own calculation method, I reduced the 135 puzzle’s range to 113.
Then, by dividing 113 into 128 parts, I further reduced it to a range of 106.
0x200000000000000000000000000 : 0x400000000000000000000000000
If my calculation method is correct, it seems that one of the 128 public keys can be found.
The 128 public keys are as follows:
If anyone finds one among them, please contact me—I would like to share the prize with you.
https://t.me/kyscolx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 am the person who created the public key shown in this YouTube video.
Using my own calculation method, I reduced the 135 puzzle’s range to 113.
Then, by dividing 113 into 128 parts, I further reduced it to a range of 106.
0x200000000000000000000000000 : 0x400000000000000000000000000
If my calculation method is correct, it seems that one of the 128 public keys can be found.
The 128 public keys are as follows:
If anyone finds one among them, please contact me—I would like to share the prize with you.
https://t.me/kyscolx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 complexity doubles with every new range.
So count how many 4090s one needs to solve 135bits or 250-256bits ranges?
Kangaroo-wise solution will not do that. As of now there is no solution to do that.
So count how many 4090s one needs to solve 135bits or 250-256bits ranges?
Kangaroo-wise solution will not do that. As of now there is no solution to do that.
#135 takes about 5.6 more calculations than #130, so I think #135 is the last high puzzle that will be solved in this decade.
I will make public a solver that does at least 10.5 Gk/s on RTX 4090 by the end of this year. I believe I can make it reach 11 Gk/s by then. Combined with symmetry and 3-kang method, it will be at least as fast as RC's solver, per total, if not faster.
About zero code, may be people mean this your post where you promise to show something? It's ok that you changed your mind
I think 135 puzzles will be broken before 25 years, April 30th.
I'll keep that promise ^^
Good luck.
I'm trying to find the range by adding or subtracting public keys.
Re: Determine if a public key point y is negative or positive, odd or even?
i can do it
Code:
import random
import ecdsa
import binascii
# Define the range
def generate_random_values():
a = random.randint(2**134, 2**135)
am = 10**37
b = a - am
# Set pma and pmb: both values must have the same sign
sign = random.choice([1, -1]) # Set as positive or negative
pma = sign * a
pmb = sign * b
return a, b, am, pma, pmb
# Define the order N of the secp256k1 curve
N = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
# Function to generate public key from private key
def generate_public_key(private_key_int):
# Convert the private key to 32-byte format
private_key_bytes = abs(private_key_int).to_bytes(32, byteorder="big", signed=True)
# Generate elliptic curve public key (secp256k1)
sk = ecdsa.SigningKey.from_string(private_key_bytes, curve=ecdsa.SECP256k1)
vk = sk.verifying_key
# Create uncompressed public key format
public_key_bytes_uncompressed = b"\x04" + vk.to_string()
# Determine the prefix of the compressed public key based on the sign of the private key
if private_key_int < 0:
public_key_bytes_compressed = (
b"\x03" + vk.to_string()[:32] if vk.to_string()[-1] % 2 == 0 else b"\x02" + vk.to_string()[:32]
)
else:
public_key_bytes_compressed = (
b"\x02" + vk.to_string()[:32] if vk.to_string()[-1] % 2 == 0 else b"\x03" + vk.to_string()[:32]
)
# Convert the public key to a hexadecimal string
public_key_uncompressed = binascii.hexlify(public_key_bytes_uncompressed).decode()
public_key_compressed = binascii.hexlify(public_key_bytes_compressed).decode()
return public_key_uncompressed, public_key_compressed
# Adjust private key representation
def adjust_private_key(private_key_int):
if private_key_int < 0:
adjusted_key = N + private_key_int
return f"0x{adjusted_key:064x}"
else:
return str(private_key_int)
# Generate and output results 10 times
all_public_keys = [] # List to store public keys
for i in range(1, 31):
print(f"\n=== Random Output {i} ===")
a, b, am, pma, pmb = generate_random_values()
public_key_a_uncompressed, public_key_a_compressed = generate_public_key(pma)
public_key_b_uncompressed, public_key_b_compressed = generate_public_key(pmb)
print("a:", a)
print("b:", b)
print("am:", am)
print("pma (Private Key a):", adjust_private_key(pma))
print("pmb (Private Key b):", adjust_private_key(pmb))
print("public_key_a (Compressed Public Key a):", public_key_a_compressed)
print("public_key_b (Compressed Public Key b):", public_key_b_compressed)
# Store public keys
all_public_keys.append((public_key_a_compressed, public_key_b_compressed))
# Add sign of pma and pmb
sign_a = "+" if pma > 0 else "-"
sign_b = "+" if pmb > 0 else "-"
print("Sign of pma:", sign_a)
print("Sign of pmb:", sign_b)
# Additional public key output
print("What has been printed above is what you have, and if you provide only what is printed now, I can match positive and negative signs.")
print("\nAdditional public key output:")
for i, (pub_a, pub_b) in enumerate(all_public_keys, start=1):
print(f"\n=== Random Output {i} ===")
print("public_key_a (Compressed Public Key a):", pub_a)
print("public_key_b (Compressed Public Key b):", pub_b)
import ecdsa
import binascii
# Define the range
def generate_random_values():
a = random.randint(2**134, 2**135)
am = 10**37
b = a - am
# Set pma and pmb: both values must have the same sign
sign = random.choice([1, -1]) # Set as positive or negative
pma = sign * a
pmb = sign * b
return a, b, am, pma, pmb
# Define the order N of the secp256k1 curve
N = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
# Function to generate public key from private key
def generate_public_key(private_key_int):
# Convert the private key to 32-byte format
private_key_bytes = abs(private_key_int).to_bytes(32, byteorder="big", signed=True)
# Generate elliptic curve public key (secp256k1)
sk = ecdsa.SigningKey.from_string(private_key_bytes, curve=ecdsa.SECP256k1)
vk = sk.verifying_key
# Create uncompressed public key format
public_key_bytes_uncompressed = b"\x04" + vk.to_string()
# Determine the prefix of the compressed public key based on the sign of the private key
if private_key_int < 0:
public_key_bytes_compressed = (
b"\x03" + vk.to_string()[:32] if vk.to_string()[-1] % 2 == 0 else b"\x02" + vk.to_string()[:32]
)
else:
public_key_bytes_compressed = (
b"\x02" + vk.to_string()[:32] if vk.to_string()[-1] % 2 == 0 else b"\x03" + vk.to_string()[:32]
)
# Convert the public key to a hexadecimal string
public_key_uncompressed = binascii.hexlify(public_key_bytes_uncompressed).decode()
public_key_compressed = binascii.hexlify(public_key_bytes_compressed).decode()
return public_key_uncompressed, public_key_compressed
# Adjust private key representation
def adjust_private_key(private_key_int):
if private_key_int < 0:
adjusted_key = N + private_key_int
return f"0x{adjusted_key:064x}"
else:
return str(private_key_int)
# Generate and output results 10 times
all_public_keys = [] # List to store public keys
for i in range(1, 31):
print(f"\n=== Random Output {i} ===")
a, b, am, pma, pmb = generate_random_values()
public_key_a_uncompressed, public_key_a_compressed = generate_public_key(pma)
public_key_b_uncompressed, public_key_b_compressed = generate_public_key(pmb)
print("a:", a)
print("b:", b)
print("am:", am)
print("pma (Private Key a):", adjust_private_key(pma))
print("pmb (Private Key b):", adjust_private_key(pmb))
print("public_key_a (Compressed Public Key a):", public_key_a_compressed)
print("public_key_b (Compressed Public Key b):", public_key_b_compressed)
# Store public keys
all_public_keys.append((public_key_a_compressed, public_key_b_compressed))
# Add sign of pma and pmb
sign_a = "+" if pma > 0 else "-"
sign_b = "+" if pmb > 0 else "-"
print("Sign of pma:", sign_a)
print("Sign of pmb:", sign_b)
# Additional public key output
print("What has been printed above is what you have, and if you provide only what is printed now, I can match positive and negative signs.")
print("\nAdditional public key output:")
for i, (pub_a, pub_b) in enumerate(all_public_keys, start=1):
print(f"\n=== Random Output {i} ===")
print("public_key_a (Compressed Public Key a):", pub_a)
print("public_key_b (Compressed Public Key b):", pub_b)
If my friends give me 30 problems, I can submit the answers for the signs of pma (Sign of pma:) within 30 minutes. You can easily test me.
Re: Determining the positivity or negativity of a Bitcoin public key
By analyzing the public key values alone, the program effectively narrows down the characteristics of the private keys, aiding in identifying whether the private key is positive or negative.
Private Key:
In Bitcoin, a private key is defined as a positive integer between 1 and n-1, where n is the order of the curve used. For the secp256k1 curve, n = 2^256 - 2^32 - 977. Therefore, private keys are always positive integers and cannot have a negative sign.
Public Key:
A private key generates a public key by performing elliptic curve multiplication on the secp256k1 curve. The public key is represented as a point (x, y) on the elliptic curve, where x and y are integers. Mathematically, these integers can be either positive or negative.
2. Misunderstanding About the Negative Sign
Since private keys cannot be negative, some developers mistakenly assume that public keys also cannot have negative values.
However, the public key (x, y) lies on the elliptic curve defined by the equation:
y^2 = x^3 + 7
For any given x, the equation ensures there are two possible y values: one positive and one negative. This is due to the symmetric nature of the elliptic curve about the x-axis.
3. Why Public Keys Are Thought to Lack Negative Signs
In Bitcoin, public keys are stored and transmitted in specific formats, which often abstract away the negative sign:
Compressed Public Key Format:
In the compressed format, only the x coordinate is stored, along with a prefix that indicates the sign of y (even or odd).
The prefix is 02 if y is even and 03 if y is odd.
For example, a public key (x, y) where y > 0 or y < 0 is reduced to x and a single bit of information about the parity of y.
Uncompressed Public Key Format:
In the uncompressed format, both x and y are included. However, the protocol does not store negative integers directly. Instead, it uses the absolute values of x and y and assumes a positive representation.
Due to these storage and transmission methods, the negative sign of y is not explicitly visible. This abstraction leads to the mistaken belief that public keys never have negative components.
4. Conclusion: Public Keys Can Correspond to Negative Values
Public keys have two perspectives:
Mathematical Perspective:
Public keys (x, y) are points on the elliptic curve. For a given x, there are always two possible y values (one positive and one negative), meaning the negative version of the public key exists mathematically.
Bitcoin Protocol Perspective:
The Bitcoin protocol stores and transmits public keys in formats that either compress or use absolute values, making negative signs implicit rather than explicit. This is why many developers mistakenly believe public keys cannot have negative values.
Final Summary
Negative public key values exist mathematically, but they are abstracted away in Bitcoin's implementation. This abstraction leads to the common misconception that public keys cannot be negative.
This plain text version is free of special characters and encoding issues, ensuring it can be copied and pasted without any problems.
Re: Determining the positivity or negativity of a Bitcoin public key
Code:
import random
import ecdsa
import binascii
# Define the range
def generate_random_values():
a = random.randint(2**134, 2**135)
am = 10**37
b = a - am
# Set pma and pmb: both values should have the same sign
sign = random.choice([1, -1]) # Set both as either positive or negative
pma = sign * a
pmb = sign * b
return a, b, am, pma, pmb
# Define N (order of the secp256k1 curve)
N = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
# Function to generate a public key from a private key
def generate_public_key(private_key_int):
# Convert the private key to a 32-byte format
private_key_bytes = abs(private_key_int).to_bytes(32, byteorder="big", signed=True)
# Generate the elliptic curve public key (secp256k1)
sk = ecdsa.SigningKey.from_string(private_key_bytes, curve=ecdsa.SECP256k1)
vk = sk.verifying_key
# Create uncompressed public key format
public_key_bytes_uncompressed = b"\x04" + vk.to_string()
# Determine the compressed public key's prefix based on the private key's sign
if private_key_int < 0:
public_key_bytes_compressed = (
b"\x03" + vk.to_string()[:32] if vk.to_string()[-1] % 2 == 0 else b"\x02" + vk.to_string()[:32]
)
else:
public_key_bytes_compressed = (
b"\x02" + vk.to_string()[:32] if vk.to_string()[-1] % 2 == 0 else b"\x03" + vk.to_string()[:32]
)
# Convert the public keys to hexadecimal strings
public_key_uncompressed = binascii.hexlify(public_key_bytes_uncompressed).decode()
public_key_compressed = binascii.hexlify(public_key_bytes_compressed).decode()
return public_key_uncompressed, public_key_compressed
# Adjust private key representation
def adjust_private_key(private_key_int):
if private_key_int < 0:
adjusted_key = N + private_key_int
return f"0x{adjusted_key:064x}"
else:
return str(private_key_int)
# Generate and output results 10 times
for i in range(1, 11):
print(f"\n=== Random Output {i} ===")
a, b, am, pma, pmb = generate_random_values()
public_key_a_uncompressed, public_key_a_compressed = generate_public_key(pma)
public_key_b_uncompressed, public_key_b_compressed = generate_public_key(pmb)
print("a:", a)
print("b:", b)
print("am:", am)
print("pma (Private Key a):", adjust_private_key(pma))
print("pmb (Private Key b):", adjust_private_key(pmb))
print("public_key_a (Compressed Public Key a):", public_key_a_compressed)
print("public_key_b (Compressed Public Key b):", public_key_b_compressed)
import ecdsa
import binascii
# Define the range
def generate_random_values():
a = random.randint(2**134, 2**135)
am = 10**37
b = a - am
# Set pma and pmb: both values should have the same sign
sign = random.choice([1, -1]) # Set both as either positive or negative
pma = sign * a
pmb = sign * b
return a, b, am, pma, pmb
# Define N (order of the secp256k1 curve)
N = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
# Function to generate a public key from a private key
def generate_public_key(private_key_int):
# Convert the private key to a 32-byte format
private_key_bytes = abs(private_key_int).to_bytes(32, byteorder="big", signed=True)
# Generate the elliptic curve public key (secp256k1)
sk = ecdsa.SigningKey.from_string(private_key_bytes, curve=ecdsa.SECP256k1)
vk = sk.verifying_key
# Create uncompressed public key format
public_key_bytes_uncompressed = b"\x04" + vk.to_string()
# Determine the compressed public key's prefix based on the private key's sign
if private_key_int < 0:
public_key_bytes_compressed = (
b"\x03" + vk.to_string()[:32] if vk.to_string()[-1] % 2 == 0 else b"\x02" + vk.to_string()[:32]
)
else:
public_key_bytes_compressed = (
b"\x02" + vk.to_string()[:32] if vk.to_string()[-1] % 2 == 0 else b"\x03" + vk.to_string()[:32]
)
# Convert the public keys to hexadecimal strings
public_key_uncompressed = binascii.hexlify(public_key_bytes_uncompressed).decode()
public_key_compressed = binascii.hexlify(public_key_bytes_compressed).decode()
return public_key_uncompressed, public_key_compressed
# Adjust private key representation
def adjust_private_key(private_key_int):
if private_key_int < 0:
adjusted_key = N + private_key_int
return f"0x{adjusted_key:064x}"
else:
return str(private_key_int)
# Generate and output results 10 times
for i in range(1, 11):
print(f"\n=== Random Output {i} ===")
a, b, am, pma, pmb = generate_random_values()
public_key_a_uncompressed, public_key_a_compressed = generate_public_key(pma)
public_key_b_uncompressed, public_key_b_compressed = generate_public_key(pmb)
print("a:", a)
print("b:", b)
print("am:", am)
print("pma (Private Key a):", adjust_private_key(pma))
print("pmb (Private Key b):", adjust_private_key(pmb))
print("public_key_a (Compressed Public Key a):", public_key_a_compressed)
print("public_key_b (Compressed Public Key b):", public_key_b_compressed)
The purpose of this program is to distinguish whether a given public key corresponds to a positive or negative private key. Once the program is executed, it generates a series of random private keys and their associated public keys. By analyzing the public key alone, the program can determine whether the original private key was positive or negative.
Key Conditions:
Always a > b: This ensures that the value of a is strictly greater than b in all generated cases.
am can be modified: The value of am (used to calculate b) can be adjusted by the user or problem setter to fall within the range of
10**35 ~ 10**38
Functionality:
After execution, the program outputs 10 sets of public keys (public_key_a and public_key_b), each derived from randomly generated private keys (pma and pmb).
By analyzing these 10 public keys, it is possible to accurately determine whether the original private keys are positive or negative with 100% certainty.
This distinction is made based on the structure and prefix of the generated compressed public keys, which encode the sign of the private key in their format.
Re: Determining the positivity or negativity of a Bitcoin public key
Thank you for your response. Is it possible to communicate with you via private messages? I believe we could find common ground on this topic, but I can't send you a private message because I'm new to this forum.
My contact information is t.me/kyscolxhttps://t.me/kyscolx
I will delete this contact after you contact me...
Re: Determining the positivity or negativity of a Bitcoin public key
Hello, I read your post, "Determining the positivity or negativity of a Bitcoin public key," and I find this topic quite interesting. I would like to know what exactly you have discovered on this matter so far, if it’s not too much trouble.
1.Bitcoin public keys have both positive and negative values.
2.Tracking Bitcoin private keys theoretically involves factoring large numbers, but the numbers are so large that it is practically impossible.
3.If there were an app capable of distinguishing between the positive and negative aspects of a public key, all private keys could theoretically be found in just 5 minutes. However, no method to achieve this has been discovered so far.
Here is a site where you can study the basics of positive and negative values:
https://royalforkblog.github.io/2014/09/04/ecc/
Good luck!
Re: Determining the positivity or negativity of a Bitcoin public key
⭐ Merited by vapourminer (1)
@odolvlobo
@kTimesG
I would like to apologize to both of you.
The part you pointed out as an error was indeed an error.
I was wrong to think that as long as the result was correct, it would be fine.
Thank you to everyone who showed interest.
The issue has been resolved. Thank you!
@kTimesG
I would like to apologize to both of you.
The part you pointed out as an error was indeed an error.
I was wrong to think that as long as the result was correct, it would be fine.
Thank you to everyone who showed interest.
The issue has been resolved. Thank you!
Re: Determining the positivity or negativity of a Bitcoin public key
Code:
# Determine the first byte of the compressed public key based on the private key's sign
if private_key_int < 0:
public_key_bytes_compressed = (
b"\x03" + vk.to_string()[:32] if vk.to_string()[-1] % 2 == 0 else b"\x02" + vk.to_string()[:32]
)
else:
public_key_bytes_compressed = (
b"\x02" + vk.to_string()[:32] if vk.to_string()[-1] % 2 == 0 else b"\x03" + vk.to_string()[:32]
)
if private_key_int < 0:
public_key_bytes_compressed = (
b"\x03" + vk.to_string()[:32] if vk.to_string()[-1] % 2 == 0 else b"\x02" + vk.to_string()[:32]
)
else:
public_key_bytes_compressed = (
b"\x02" + vk.to_string()[:32] if vk.to_string()[-1] % 2 == 0 else b"\x03" + vk.to_string()[:32]
)
You code is incorrect. The 0x02, 0x03 prefixes are based only on the value of the public key.
Furthermore, a valid secp256k1 private key is an integer in the range 1 to FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364140, so testing if it is less than 0 should always return false. If your test returns true, then the private key is invalid or there is a bug in your code.
Since the program itself knows the private key, the public key output result is 100% accurate.
There are no errors in the program.
Please check the private key and the outputted public key.
Re: Determining the positivity or negativity of a Bitcoin public key
With this program, if only the public key is provided, I can determine with 100% accuracy whether it is positive or negative.
import random
import ecdsa
import binascii
# Public key generation function
def generate_public_key(private_key_int):
# Convert the private key to a 32-byte format
private_key_bytes = abs(private_key_int).to_bytes(32, byteorder="big", signed=True)
# Generate the elliptic curve public key (secp256k1)
sk = ecdsa.SigningKey.from_string(private_key_bytes, curve=ecdsa.SECP256k1)
vk = sk.verifying_key
# Determine the first byte of the compressed public key based on the private key's sign
if private_key_int < 0:
public_key_bytes_compressed = (
b"\x03" + vk.to_string()[:32] if vk.to_string()[-1] % 2 == 0 else b"\x02" + vk.to_string()[:32]
)
else:
public_key_bytes_compressed = (
b"\x02" + vk.to_string()[:32] if vk.to_string()[-1] % 2 == 0 else b"\x03" + vk.to_string()[:32]
)
# Convert the public key to a hexadecimal string
public_key_compressed = binascii.hexlify(public_key_bytes_compressed).decode()
return public_key_compressed
# List to store (pma, pmb) pairs
pma_pmb_pairs = []
# Loop 10 times to generate and print public keys for pma and pmb
for i in range(20):
# Set range and generate pma, pmb
a = random.randint(2**134, 2**135)
am = 10**37
b = a - am
sign = random.choice([1, -1]) # Set both as either positive or negative
pma = sign * a
pmb = sign * b
# Generate public keys using pma and pmb as private keys
public_key_a_compressed = generate_public_key(pma)
public_key_b_compressed = generate_public_key(pmb)
# Store only the signs of pma and pmb
pma_sign = '+' if pma > 0 else '-'
pmb_sign = '+' if pmb > 0 else '-'
pma_pmb_pairs.append((pma_sign, pmb_sign))
# Print results
print(f"Problem {i + 1}:")
print("public_key_a (compressed public key a):", public_key_a_compressed)
print("public_key_b (compressed public key b):", public_key_b_compressed)
print()
# List of (pma, pmb) sign pairs (answer key for private reference)
print("List of (pma, pmb) sign pairs:")
for pair in pma_pmb_pairs:
print(f"({pair[0]}, {pair[1]})")
import random
import ecdsa
import binascii
# Public key generation function
def generate_public_key(private_key_int):
# Convert the private key to a 32-byte format
private_key_bytes = abs(private_key_int).to_bytes(32, byteorder="big", signed=True)
# Generate the elliptic curve public key (secp256k1)
sk = ecdsa.SigningKey.from_string(private_key_bytes, curve=ecdsa.SECP256k1)
vk = sk.verifying_key
# Determine the first byte of the compressed public key based on the private key's sign
if private_key_int < 0:
public_key_bytes_compressed = (
b"\x03" + vk.to_string()[:32] if vk.to_string()[-1] % 2 == 0 else b"\x02" + vk.to_string()[:32]
)
else:
public_key_bytes_compressed = (
b"\x02" + vk.to_string()[:32] if vk.to_string()[-1] % 2 == 0 else b"\x03" + vk.to_string()[:32]
)
# Convert the public key to a hexadecimal string
public_key_compressed = binascii.hexlify(public_key_bytes_compressed).decode()
return public_key_compressed
# List to store (pma, pmb) pairs
pma_pmb_pairs = []
# Loop 10 times to generate and print public keys for pma and pmb
for i in range(20):
# Set range and generate pma, pmb
a = random.randint(2**134, 2**135)
am = 10**37
b = a - am
sign = random.choice([1, -1]) # Set both as either positive or negative
pma = sign * a
pmb = sign * b
# Generate public keys using pma and pmb as private keys
public_key_a_compressed = generate_public_key(pma)
public_key_b_compressed = generate_public_key(pmb)
# Store only the signs of pma and pmb
pma_sign = '+' if pma > 0 else '-'
pmb_sign = '+' if pmb > 0 else '-'
pma_pmb_pairs.append((pma_sign, pmb_sign))
# Print results
print(f"Problem {i + 1}:")
print("public_key_a (compressed public key a):", public_key_a_compressed)
print("public_key_b (compressed public key b):", public_key_b_compressed)
print()
# List of (pma, pmb) sign pairs (answer key for private reference)
print("List of (pma, pmb) sign pairs:")
for pair in pma_pmb_pairs:
print(f"({pair[0]}, {pair[1]})")
Re: Determining the positivity or negativity of a Bitcoin public key
Due to the nature of elliptic curves over finite fields, (when using secure parameters) it is not possible (or at least, no one knows how) to take the public key and infer any information about the private key.
===>
I am not trying to find out the private key; I want a program that can distinguish the positivity or negativity of the public key.
===>
I am not trying to find out the private key; I want a program that can distinguish the positivity or negativity of the public key.
Determining the positivity or negativity of a Bitcoin public key
This program generates public keys from randomly created private keys using elliptic curve cryptography, specifically the secp256k1 curve used in Bitcoin. The private keys (pma and pmb) are set with the same sign, either both positive or both negative. Based on the sign of each private key, the program outputs corresponding compressed and uncompressed public keys. The compressed public keys’ prefixes (0x02 or 0x03) are adjusted according to whether the private key is positive or negative.
There is a program that determines whether the private key is positive or negative based solely on the generated public key output.
program
import random
import ecdsa
import binascii
# Define the range
a = random.randint(2**134, 2**135)
am = 10**37
b = a - am
# Set pma and pmb: both values should have the same sign
sign = random.choice([1, -1]) # Set both as either positive or negative
pma = sign * a
pmb = sign * b
# Function to generate a public key from a private key
def generate_public_key(private_key_int):
# Convert the private key to a 32-byte format
private_key_bytes = abs(private_key_int).to_bytes(32, byteorder="big", signed=True)
# Generate the elliptic curve public key (secp256k1)
sk = ecdsa.SigningKey.from_string(private_key_bytes, curve=ecdsa.SECP256k1)
vk = sk.verifying_key
# Create uncompressed public key format
public_key_bytes_uncompressed = b"\x04" + vk.to_string()
# Determine the compressed public key's prefix based on the private key's sign
if private_key_int < 0:
public_key_bytes_compressed = (
b"\x03" + vk.to_string()[:32] if vk.to_string()[-1] % 2 == 0 else b"\x02" + vk.to_string()[:32]
)
else:
public_key_bytes_compressed = (
b"\x02" + vk.to_string()[:32] if vk.to_string()[-1] % 2 == 0 else b"\x03" + vk.to_string()[:32]
)
# Convert the public keys to hexadecimal strings
public_key_uncompressed = binascii.hexlify(public_key_bytes_uncompressed).decode()
public_key_compressed = binascii.hexlify(public_key_bytes_compressed).decode()
return public_key_uncompressed, public_key_compressed
# Generate public keys using pma and pmb as private keys
public_key_a_uncompressed, public_key_a_compressed = generate_public_key(pma)
public_key_b_uncompressed, public_key_b_compressed = generate_public_key(pmb)
# Output the results
print("a:", a)
print("b:", b)
print("am:", am)
print("pma (Private Key a):", pma)
print("pmb (Private Key b):", pmb)
print("public_key_a (Uncompressed Public Key a):", public_key_a_uncompressed)
print("public_key_a (Compressed Public Key a):", public_key_a_compressed)
print("public_key_b (Uncompressed Public Key b):", public_key_b_uncompressed)
print("public_key_b (Compressed Public Key b):", public_key_b_compressed)
When |pma| > |pmb|, the positivity or negativity can be determined with 100% accuracy, but when |pma| < |pmb|, errors occur in determining positivity or negativity. I am looking for someone to collaborate on this issue.
There is a program that determines whether the private key is positive or negative based solely on the generated public key output.
program
import random
import ecdsa
import binascii
# Define the range
a = random.randint(2**134, 2**135)
am = 10**37
b = a - am
# Set pma and pmb: both values should have the same sign
sign = random.choice([1, -1]) # Set both as either positive or negative
pma = sign * a
pmb = sign * b
# Function to generate a public key from a private key
def generate_public_key(private_key_int):
# Convert the private key to a 32-byte format
private_key_bytes = abs(private_key_int).to_bytes(32, byteorder="big", signed=True)
# Generate the elliptic curve public key (secp256k1)
sk = ecdsa.SigningKey.from_string(private_key_bytes, curve=ecdsa.SECP256k1)
vk = sk.verifying_key
# Create uncompressed public key format
public_key_bytes_uncompressed = b"\x04" + vk.to_string()
# Determine the compressed public key's prefix based on the private key's sign
if private_key_int < 0:
public_key_bytes_compressed = (
b"\x03" + vk.to_string()[:32] if vk.to_string()[-1] % 2 == 0 else b"\x02" + vk.to_string()[:32]
)
else:
public_key_bytes_compressed = (
b"\x02" + vk.to_string()[:32] if vk.to_string()[-1] % 2 == 0 else b"\x03" + vk.to_string()[:32]
)
# Convert the public keys to hexadecimal strings
public_key_uncompressed = binascii.hexlify(public_key_bytes_uncompressed).decode()
public_key_compressed = binascii.hexlify(public_key_bytes_compressed).decode()
return public_key_uncompressed, public_key_compressed
# Generate public keys using pma and pmb as private keys
public_key_a_uncompressed, public_key_a_compressed = generate_public_key(pma)
public_key_b_uncompressed, public_key_b_compressed = generate_public_key(pmb)
# Output the results
print("a:", a)
print("b:", b)
print("am:", am)
print("pma (Private Key a):", pma)
print("pmb (Private Key b):", pmb)
print("public_key_a (Uncompressed Public Key a):", public_key_a_uncompressed)
print("public_key_a (Compressed Public Key a):", public_key_a_compressed)
print("public_key_b (Uncompressed Public Key b):", public_key_b_uncompressed)
print("public_key_b (Compressed Public Key b):", public_key_b_compressed)
When |pma| > |pmb|, the positivity or negativity can be determined with 100% accuracy, but when |pma| < |pmb|, errors occur in determining positivity or negativity. I am looking for someone to collaborate on this issue.
(Same public key) * (Same public key) = Public key possible or not.
Research Bitcoin I have a question. Public key*(private key) = Public key has operation and device. (Same public key) * (Same public key) = Public key
I'd like to know if the second one is possible or not.
from ecdsa import SECP256k1, VerifyingKey
from ecdsa.ellipticcurve import Point
def public_key_to_scalar(public_key) -> int:
"""Converts a public key to an integer scalar."""
return int.from_bytes(public_key.to_string(), 'big')
def multiply_public_key_by_scalar(pub_key, scalar) -> Point:
"""Multiplies a public key by a scalar."""
return pub_key.pubkey.point * scalar
def point_to_hex(point) -> str:
"""Converts an elliptic curve point to a hexadecimal string in 0x format."""
x_hex = "0x" + format(point.x(), '064x')
y_hex = "0x" + format(point.y(), '064x')
return x_hex, y_hex
# Input public key as a hexadecimal string (should be a valid uncompressed public key)
####Corresponds to the decimal value 0.234
input_hex1 = "b84a76136d0c86725a8a305f4a87aeeaa9f44eead621dd1e84d0ea1ad85d82ab" + \
"9deccad50c1d1b9575d2fd2223215b5d74e29a87cd7879e343296eb688206713"
# Convert the hexadecimal string to a VerifyingKey object
pub_key1 = VerifyingKey.from_string(bytes.fromhex(input_hex1), curve=SECP256k1)
# Define a valid scalar (could be a private key or a large random integer)
# Corresponds to a private key value of 0.1
scalar = 0x2 # Example scalar value
# Multiply the public key by the scalar
result_point = multiply_public_key_by_scalar(pub_key1, scalar)
# Convert the result to a hexadecimal string in 0x format
x_hex, y_hex = point_to_hex(result_point)
print(f"Result of multiplication in hex (x): {x_hex}")
print(f"Result of multiplication in hex (y): {y_hex}")
I'd like to know if the second one is possible or not.
from ecdsa import SECP256k1, VerifyingKey
from ecdsa.ellipticcurve import Point
def public_key_to_scalar(public_key) -> int:
"""Converts a public key to an integer scalar."""
return int.from_bytes(public_key.to_string(), 'big')
def multiply_public_key_by_scalar(pub_key, scalar) -> Point:
"""Multiplies a public key by a scalar."""
return pub_key.pubkey.point * scalar
def point_to_hex(point) -> str:
"""Converts an elliptic curve point to a hexadecimal string in 0x format."""
x_hex = "0x" + format(point.x(), '064x')
y_hex = "0x" + format(point.y(), '064x')
return x_hex, y_hex
# Input public key as a hexadecimal string (should be a valid uncompressed public key)
####Corresponds to the decimal value 0.234
input_hex1 = "b84a76136d0c86725a8a305f4a87aeeaa9f44eead621dd1e84d0ea1ad85d82ab" + \
"9deccad50c1d1b9575d2fd2223215b5d74e29a87cd7879e343296eb688206713"
# Convert the hexadecimal string to a VerifyingKey object
pub_key1 = VerifyingKey.from_string(bytes.fromhex(input_hex1), curve=SECP256k1)
# Define a valid scalar (could be a private key or a large random integer)
# Corresponds to a private key value of 0.1
scalar = 0x2 # Example scalar value
# Multiply the public key by the scalar
result_point = multiply_public_key_by_scalar(pub_key1, scalar)
# Convert the result to a hexadecimal string in 0x format
x_hex, y_hex = point_to_hex(result_point)
print(f"Result of multiplication in hex (x): {x_hex}")
print(f"Result of multiplication in hex (y): {y_hex}")
I'm happy to announce that I have completed my work based on JeanLucPons' original source code and the results are at least 1.5x and up to 2x faster.
My implementation supports CPU only, Windows 64 bits, and any normal Unix-like OS should work. (Note: tested with ubuntu/Linux only)
Also support for arm64 CPUs is in the works.
You can verify the results using the following demo executable provided in our telegram group:
https://t.me/puzzlesearch
The full program that connects to the pool is also available on our telegram group.
The program is currently closed source - for one reason - I want to create a single pool for the 130th puzzle. Once I see people join, I will open-source the code on this github account: https://github.com/puzzlesearch.
When the reward is found, the rewards will be distributed according to the work done by each user. We will use IPs logged in our server as a proof of identity.
Thanks!
If you want to upload the file, please check it a few times before uploading itMy implementation supports CPU only, Windows 64 bits, and any normal Unix-like OS should work. (Note: tested with ubuntu/Linux only)
Also support for arm64 CPUs is in the works.
You can verify the results using the following demo executable provided in our telegram group:
https://t.me/puzzlesearch
The full program that connects to the pool is also available on our telegram group.
The program is currently closed source - for one reason - I want to create a single pool for the 130th puzzle. Once I see people join, I will open-source the code on this github account: https://github.com/puzzlesearch.
When the reward is found, the rewards will be distributed according to the work done by each user. We will use IPs logged in our server as a proof of identity.
Thanks!
Don't waste your time...
It doesn't work at all.
Re: ⭐️⭐️ I want to purchase an empty Bitcoin private key after sending the funds⭐️⭐️
"A few people asked, but the balance was
There was only one person, and I'm in the process of doing business with that person.
And importantly, you need to have a bitcoin balance before January 2019 to receive hardpog rewards.
Please check it and contact me
I want buy address
1DVN3ETJcz2quNU8jfUiiWAdGgMGSGbvZV $630
1HvhpaLmyhKHEupJRJcrZAX6UXmmTpZuHL $310
12PWzPoKYkcmQWKsDfMc2CGPoEYE3ARECCb $570
1NuNHWG4Ujs9wjH9wciVEoJCsgXmn6PfX9 $360
add address
18xGHNrU26w6HSCEL8DD5o1whfiDaYgp6i $50000
1CRxCGjqn9f3h7xpexc3MT6ne7rfqLngQt $500
17yJQXQgJYvfA31M9HYsGXFteuBfpNGzeD $500"
Have you successfully bought any of these addresses you are listing?
I want to buy the addresses listed at the price of the Bitcoin private keyThere was only one person, and I'm in the process of doing business with that person.
And importantly, you need to have a bitcoin balance before January 2019 to receive hardpog rewards.
Please check it and contact me
I want buy address
1DVN3ETJcz2quNU8jfUiiWAdGgMGSGbvZV $630
1HvhpaLmyhKHEupJRJcrZAX6UXmmTpZuHL $310
12PWzPoKYkcmQWKsDfMc2CGPoEYE3ARECCb $570
1NuNHWG4Ujs9wjH9wciVEoJCsgXmn6PfX9 $360
add address
18xGHNrU26w6HSCEL8DD5o1whfiDaYgp6i $50000
1CRxCGjqn9f3h7xpexc3MT6ne7rfqLngQt $500
17yJQXQgJYvfA31M9HYsGXFteuBfpNGzeD $500"
Have you successfully bought any of these addresses you are listing?
If you have a private key for this address, I'd like to purchase it at the price I suggested.
Re: I want to purchase an empty Bitcoin private key after sending the funds
The balance comes out as zero on the blockchain I know.
I'm sorry that I couldn't disclose the blockchain address that I can check.
Are you talking about Bitcoin, or a different Blockchain? If so, do tell. Or PM LoyceV.I'm sorry that I couldn't disclose the blockchain address that I can check.
I know some people from my Fork recovery service, but I'm not going to bug them without knowing what it's really about.
I want to buy a private key.