Bitcoin puzzle transaction ~32 BTC prize to who solves it

[modma]

Speed? No benchmark? We already have GPU enabled tools which are 20 to 30 times faster than CPU versions, I don't know what you are promising, but definitely your tool is not faster than others whatsoever, besides searching with CPU is useless.

On my slow CPU i get about 30% more speed (now i get about 2.6 million keys/s on one core), but the speedgain may be different on other CPUs - hard to say. I would be happy if some users would post keyrates of their CPUs.

what cave did you come out of?
KEYHUNT by alberto 4 million keys per stream.
bitcrack 3 million keys per stream.
I personally have GPU generation - 4 billion keys per second.
And this is in open source - which the developers provided for free.

[1714885958]

1714885958

[1714885958]

1714885958

[1714885958]

1714885958

[puzzle-dev]

This is my last reply regarding useless speed comparisions:


you simply have to compare the speed of my tool with your prefered tool on your own!!!
MY TOOL IS FOR CPU *NOT* FOR GPU - GPUs ARE FASTER - I KNOW IT - EVERYBODY KNOWS IT!


i just gave you a number for my very slow CPU and only on one core and this is a mobile CPU! This does not say anything about keyrates on your CPU!
if your prefered tool is faster, then use it and be happy with it! On my CPU my tool is faster - is this so hard to understand?

you are talking about an increased chance of searching - how is this statement justified?

only through tests...
i run competiton tests between my tool and other CPU tools and my tool always found the key faster, so i guess my search logic works somehow better than a simple random search, but you cannot exspect miracles like a 10x speed improvement.

[modma]

this is a mobile CPU! This does not say anything about keyrates on your CPU!

very strange argument.
Next time, tell me about new mathematics right away.

[mcdouglasx]

You can't even read...

 and there are also online virus-scanners where you could upload the executeables, but you just want to tell lies...

online scanner Lol, to bypass all antivirus you only need tools like pyarmor and other techniques that I will not mention for the sake of honest people.

[unclevito]

This is my last reply regarding useless speed comparisions:


you simply have to compare the speed of my tool with your prefered tool on your own!!!
MY TOOL IS FOR CPU *NOT* FOR GPU - GPUs ARE FASTER - I KNOW IT - EVERYBODY KNOWS IT!


i just gave you a number for my very slow CPU and only on one core and this is a mobile CPU! This does not say anything about keyrates on your CPU!
if your prefered tool is faster, then use it and be happy with it! On my CPU my tool is faster - is this so hard to understand?

you are talking about an increased chance of searching - how is this statement justified?

only through tests...
i run competiton tests between my tool and other CPU tools and my tool always found the key faster, so i guess my search logic works somehow better than a simple random search, but you cannot exspect miracles like a 10x speed improvement.

I downloaded them this morning and ran them through the online scanner and they were all clean. Ran the generic on wsl and it worked 1 thread as about 2 mil/second older Xeon it seems to make a file that is either a checkpoint or remembers the addresses tried or both. works well but since I paid for a rtx GPU and made a control program so it runs unattended I am going to use that, but for CPU users it should be ok. Suggestion: put them on github and maybe others will be more comfortable then being on a file share website which makes others a little suspicious. you can open a free account there.

[puzzle-dev]

I downloaded them this morning and ran them through the online scanner and they were all clean. Ran the generic on wsl and it worked 1 thread as about 2 mil/second older Xeon it seems to make a file that is either a checkpoint or remembers the addresses tried or both. works well but since I paid for a rtx GPU and made a control program so it runs unattended I am going to use that, but for CPU users it should be ok. Suggestion: put them on github and maybe others will be more comfortable then being on a file share website which makes others a little suspicious. you can open a free account there.

Thanks for your trust and reply!

I don't know if it helps to gain more trust, but i updated the tool, removed the executeable permissions and included a warning about running binaries from unknown sources in the README.txt and added some hints how to run binaries if you do not trust the developer. Actually there are serveral tools on github where binaries are included (like iceland and the pool) and there are no sources available for these tools available, so i don't see a big difference if i would use github. I do not exspect anybody to trust me, but at least to be fair. i just offer a different approach an my tool is quite fast on CPUs and it would be very interesting to see the keyrates on modern CPUs.

[digaran]

i just offer a different approach an my tool is quite fast on CPUs and it would be very interesting to see the keyrates on modern CPUs.

Why don't you share this different approach in details with the rest of us? If it was working, you wouldn't be here talking, instead you'd have rented hundreds of CPUs to find #66.

[GR Sasa]

Guys, stop the hate and the harassment of him!

Yes there's a doubt; The "Developer" could be suspected; Yes it could be a scam; Yes it could have a trojan; But it could be also real!

It's just a doubt, you are guys acting like he's 100% fake and scammer which is of course not the case! Nobody knows if he's real or not, but at least you could've friendly just asked him to upload his source code to GitHub instead of attacking him like this! What if he's real? You can't imagine how bad he will feel. You guys are hurting him so stop it please! We don't know if he's real or not, so we can't judge him that early!!

Maybe he's real and really developed a tool for CPU users for help. Who knows? And yes, it's his right for him to ask for 50% since he is the developer of it.

@puzzle-dev We apologize for that, but we are a sensitive community, so please we respectfully ask you to upload its source code just incase for us to be in the safe side.

Thanks,

[digaran]

@puzzle-dev We apologize for that, but we are a sensitive community, so please we respectfully ask you to upload its source code just incase for us to be in the safe side.

Thanks,

Did you just use good cop, bad cop method on him? Lol.
If he wanted to share the code, he'd have done it at the first place and nobody would have attacked him.

In case some of you haven't noticed, around these woods we paint toads and sell them as porsche!

Personally I have nothing against him, I know enough not to run the tool, even if I do I have nothing of value on my system.
Besides, his tool, your tool, my tool, none of them really help unless you have 100+ GPUs, then having that many GPUs, you wouldn't go for #66, you'd use them to search for #130. So if we are talking about "luck" searching a site like keys.lol should do the trick, if it's up to your "luck" clicking on page numbers is enough or buying a lottery ticket could also give a better result. Being "lucky" is not exclusive to finding a puzzle key, So your and his argument is not reasonable.

[DegenHero]

@puzzle-dev We apologize for that, but we are a sensitive community, so please we respectfully ask you to upload its source code just incase for us to be in the safe side.

Thanks,

Did you just use good cop, bad cop method on him? Lol.
If he wanted to share the code, he'd have done it at the first place and nobody would have attacked him.

In case some of you haven't noticed, around these woods we paint toads and sell them as porsche!

Personally I have nothing against him, I know enough not to run the tool, even if I do I have nothing of value on my system.
Besides, his tool, your tool, my tool, none of them really help unless you have 100+ GPUs, then having that many GPUs, you wouldn't go for #66, you'd use them to search for #130. So if we are talking about "luck" searching a site like keys.lol should do the trick, if it's up to your "luck" clicking on page numbers is enough or buying a lottery ticket could also give a better result. Being "lucky" is not exclusive to finding a puzzle key, So your and his argument is not reasonable.

Hello, all.
Hope you are doing well.
I am new to here, and would like to attend this puzzle.
What tool can I use in my pc(Windows10)?

Thanks

[digaran]

Hello, all.
Hope you are doing well.
I am new to here, and would like to attend this puzzle.
What tool can I use in my pc(Windows10)?

Thanks

Nvidia GPU, also not open source, modified version of 2 different tools.
https://bitcointalk.org/index.php?topic=5328080.msg56699222#msg56699222

Bitcrack :
https://bitcointalk.org/index.php?topic=4453897.0

I'd suggest to dive into the ocean of public keys, learn how to add/subtract/divide, your chance of success is better than brute forcing for keys.

[bestie1549]

Hello, all.
Hope you are doing well.
I am new to here, and would like to attend this puzzle.
What tool can I use in my pc(Windows10)?

Thanks

Nvidia GPU, also not open source, modified version of 2 different tools.
https://bitcointalk.org/index.php?topic=5328080.msg56699222#msg56699222

Bitcrack :
https://bitcointalk.org/index.php?topic=4453897.0

I'd suggest to dive into the ocean of public keys, learn how to add/subtract/divide, your chance of success is better than brute forcing for keys.

I keep asking myself how that works but  always get very confused too. If there were an alleged calculator you could prescribe and a little bit of some explanation as to how the addition and subtraction works it'd be very understandable. I even tried to write a code to add and multiply below is the code. still all I got was an awkward result.

"import argparse
import ecdsa
from ecdsa.ellipticcurve import Point

# Function ato perform point addition
def point_addition(point1, point2):
    return point1 + point2

# Function to perform point subtraction
def point_subtraction(point1, point2):
    return point1 - point2

# Function to perform point multiplication
def point_multiplication(point, scalar):
    return scalar * point

# Function to perform point division (using scalar multiplication by the inverse)
def point_division(point, scalar):
    return point_multiplication(point, ecdsa.numbertheory.inverse_mod(scalar, curve.order()))

# Parse command-line arguments
parser = argparse.ArgumentParser(description="Elliptic Curve Point Operations")
parser.add_argument("-p1", dest="public_key1", type=str, help="Public key 1 (in hexadecimal)")
parser.add_argument("-p2", dest="public_key2", type=str, help="Public key 2 (in hexadecimal)")
parser.add_argument("operation", choices=["+", "-", "*", "/"], help="Operation to perform (+ for add, - for subtract, * for multiply, / for divide)")

args = parser.parse_args()

# Define the elliptic curve parameters (SECP256k1 in Bitcoin)
curve = ecdsa.SECP256k1

# Parse the public keys from the command-line arguments
public_key1 = ecdsa.VerifyingKey.from_string(bytes.fromhex(args.public_key1), curve=curve).pubkey.point
public_key2 = ecdsa.VerifyingKey.from_string(bytes.fromhex(args.public_key2), curve=curve).pubkey.point

# Perform the specified operation on the public keys
if args.operation == "+":
    result_point = point_addition(public_key1, public_key2)
elif args.operation == "-":
    result_point = point_subtraction(public_key1, public_key2)
elif args.operation == "*":
    scalar = int(input("Enter the scalar value (private key): "), 16)
    result_point = point_multiplication(public_key1, scalar)
elif args.operation == "/":
    scalar = int(input("Enter the scalar value (private key): "), 16)
    result_point = point_division(public_key1, scalar)

# Print the coordinates of the result point
result_x, result_y = ecdsa.util.number_to_string(result_point.x(), curve.order), ecdsa.util.number_to_string(result_point.y(), curve.order)
print("Result Point (x, y):", result_x.hex(), ",", result_y.hex())" result was awkward but anyway,

how do we go about the addition and subtraction, division and multiplication and how do we make sense off of the result from this process??
what tools are required?
Calculators and procedures involved. I'm down to learn too

[sssergy2705]

Hello, all.
Hope you are doing well.
I am new to here, and would like to attend this puzzle.
What tool can I use in my pc(Windows10)?

Thanks

Nvidia GPU, also not open source, modified version of 2 different tools.
https://bitcointalk.org/index.php?topic=5328080.msg56699222#msg56699222

Bitcrack :
https://bitcointalk.org/index.php?topic=4453897.0

I'd suggest to dive into the ocean of public keys, learn how to add/subtract/divide, your chance of success is better than brute forcing for keys.

I keep asking myself how that works but  always get very confused too. If there were an alleged calculator you could prescribe and a little bit of some explanation as to how the addition and subtraction works it'd be very understandable. I even tried to write a code to add and multiply below is the code. still all I got was an awkward result.

"import argparse
import ecdsa
from ecdsa.ellipticcurve import Point

# Function ato perform point addition
def point_addition(point1, point2):
    return point1 + point2

# Function to perform point subtraction
def point_subtraction(point1, point2):
    return point1 - point2

# Function to perform point multiplication
def point_multiplication(point, scalar):
    return scalar * point

# Function to perform point division (using scalar multiplication by the inverse)
def point_division(point, scalar):
    return point_multiplication(point, ecdsa.numbertheory.inverse_mod(scalar, curve.order()))

# Parse command-line arguments
parser = argparse.ArgumentParser(description="Elliptic Curve Point Operations")
parser.add_argument("-p1", dest="public_key1", type=str, help="Public key 1 (in hexadecimal)")
parser.add_argument("-p2", dest="public_key2", type=str, help="Public key 2 (in hexadecimal)")
parser.add_argument("operation", choices=["+", "-", "*", "/"], help="Operation to perform (+ for add, - for subtract, * for multiply, / for divide)")

args = parser.parse_args()

# Define the elliptic curve parameters (SECP256k1 in Bitcoin)
curve = ecdsa.SECP256k1

# Parse the public keys from the command-line arguments
public_key1 = ecdsa.VerifyingKey.from_string(bytes.fromhex(args.public_key1), curve=curve).pubkey.point
public_key2 = ecdsa.VerifyingKey.from_string(bytes.fromhex(args.public_key2), curve=curve).pubkey.point

# Perform the specified operation on the public keys
if args.operation == "+":
    result_point = point_addition(public_key1, public_key2)
elif args.operation == "-":
    result_point = point_subtraction(public_key1, public_key2)
elif args.operation == "*":
    scalar = int(input("Enter the scalar value (private key): "), 16)
    result_point = point_multiplication(public_key1, scalar)
elif args.operation == "/":
    scalar = int(input("Enter the scalar value (private key): "), 16)
    result_point = point_division(public_key1, scalar)

# Print the coordinates of the result point
result_x, result_y = ecdsa.util.number_to_string(result_point.x(), curve.order), ecdsa.util.number_to_string(result_point.y(), curve.order)
print("Result Point (x, y):", result_x.hex(), ",", result_y.hex())" result was awkward but anyway,

how do we go about the addition and subtraction, division and multiplication and how do we make sense off of the result from this process??
what tools are required?
Calculators and procedures involved. I'm down to learn too

https://github.com/albertobsd/ecctools

[lordfrs]

I keep asking myself how that works but  always get very confused too. If there were an alleged calculator you could prescribe and a little bit of some explanation as to how the addition and subtraction works it'd be very understandable. I even tried to write a code to add and multiply below is the code. still all I got was an awkward result.

"import argparse
import ecdsa
from ecdsa.ellipticcurve import Point

# Function ato perform point addition
def point_addition(point1, point2):
    return point1 + point2

# Function to perform point subtraction
def point_subtraction(point1, point2):
    return point1 - point2

# Function to perform point multiplication
def point_multiplication(point, scalar):
    return scalar * point

# Function to perform point division (using scalar multiplication by the inverse)
def point_division(point, scalar):
    return point_multiplication(point, ecdsa.numbertheory.inverse_mod(scalar, curve.order()))

# Parse command-line arguments
parser = argparse.ArgumentParser(description="Elliptic Curve Point Operations")
parser.add_argument("-p1", dest="public_key1", type=str, help="Public key 1 (in hexadecimal)")
parser.add_argument("-p2", dest="public_key2", type=str, help="Public key 2 (in hexadecimal)")
parser.add_argument("operation", choices=["+", "-", "*", "/"], help="Operation to perform (+ for add, - for subtract, * for multiply, / for divide)")

args = parser.parse_args()

# Define the elliptic curve parameters (SECP256k1 in Bitcoin)
curve = ecdsa.SECP256k1

# Parse the public keys from the command-line arguments
public_key1 = ecdsa.VerifyingKey.from_string(bytes.fromhex(args.public_key1), curve=curve).pubkey.point
public_key2 = ecdsa.VerifyingKey.from_string(bytes.fromhex(args.public_key2), curve=curve).pubkey.point

# Perform the specified operation on the public keys
if args.operation == "+":
    result_point = point_addition(public_key1, public_key2)
elif args.operation == "-":
    result_point = point_subtraction(public_key1, public_key2)
elif args.operation == "*":
    scalar = int(input("Enter the scalar value (private key): "), 16)
    result_point = point_multiplication(public_key1, scalar)
elif args.operation == "/":
    scalar = int(input("Enter the scalar value (private key): "), 16)
    result_point = point_division(public_key1, scalar)

# Print the coordinates of the result point
result_x, result_y = ecdsa.util.number_to_string(result_point.x(), curve.order), ecdsa.util.number_to_string(result_point.y(), curve.order)
print("Result Point (x, y):", result_x.hex(), ",", result_y.hex())" result was awkward but anyway,

how do we go about the addition and subtraction, division and multiplication and how do we make sense off of the result from this process??
what tools are required?
Calculators and procedures involved. I'm down to learn too

Code:

Pcurve = 2**256 - 2**32 - 2**9 - 2**8 - 2**7 - 2**6 - 2**4 -1 # The proven prime
N=0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 # Number of points in the field
Acurve = 0; Bcurve = 7 # This defines the curve. y^2 = x^3 + Acurve * x + Bcurve
Gx = 55066263022277343669578718895168534326250603453777594175500187360389116729240
Gy = 32670510020758816978083085130507043184471273380659243275938904335757337482424

def modinv(a,n=Pcurve): #Extended Euclidean Algorithm/'division' in elliptic curves
    lm, hm = 1,0
    low, high = a%n,n
    while low > 1:
        ratio = high/low
        nm, new = hm-lm*ratio, high-low*ratio
        lm, low, hm, high = nm, new, lm, low
    return int(lm % n)

def ECadd(xp,yp,xq,yq): # Not true addition, invented for EC. It adds Point-P with Point-Q.
    m = ((yq-yp) * mod_inverse(xq-xp,Pcurve)) % Pcurve
    xr = (m*m-xp-xq) % Pcurve
    yr = (m*(xp-xr)-yp) % Pcurve
    return (xr,yr)

def ECdouble(xp,yp): # EC point doubling,  invented for EC. It doubles Point-P.
    LamNumer = 3*xp*xp+Acurve
    LamDenom = 2*yp
    Lam = (LamNumer * mod_inverse(LamDenom,Pcurve)) % Pcurve
    xr = (Lam*Lam-2*xp) % Pcurve
    yr = (Lam*(xp-xr)-yp) % Pcurve
    return (xr,yr)

def EccMultiply(xs,ys,Scalar): # Double & add. EC Multiplication, Not true multiplication
    #if Scalar == 0 or Scalar >= N: raise Exception("Invalid Scalar/Private Key")
    ScalarBin = str(bin(Scalar))[2:]
    Qx,Qy=xs,ys
    for i in range (1, len(ScalarBin)): # This is invented EC multiplication.
        Qx,Qy=ECdouble(Qx,Qy); # print "DUB", Qx; print
        #print(Qx,Qy)
        if ScalarBin[i] == "1":
            Qx,Qy=ECadd(Qx,Qy,xs,ys); # print "ADD", Qx; print
    return (Qx,Qy)

You can understand how it works by looking at the code.

[bestie1549]

I keep asking myself how that works but  always get very confused too. If there were an alleged calculator you could prescribe and a little bit of some explanation as to how the addition and subtraction works it'd be very understandable. I even tried to write a code to add and multiply below is the code. still all I got was an awkward result.

"import argparse
import ecdsa
from ecdsa.ellipticcurve import Point

# Function ato perform point addition
def point_addition(point1, point2):
    return point1 + point2

# Function to perform point subtraction
def point_subtraction(point1, point2):
    return point1 - point2

# Function to perform point multiplication
def point_multiplication(point, scalar):
    return scalar * point

# Function to perform point division (using scalar multiplication by the inverse)
def point_division(point, scalar):
    return point_multiplication(point, ecdsa.numbertheory.inverse_mod(scalar, curve.order()))

# Parse command-line arguments
parser = argparse.ArgumentParser(description="Elliptic Curve Point Operations")
parser.add_argument("-p1", dest="public_key1", type=str, help="Public key 1 (in hexadecimal)")
parser.add_argument("-p2", dest="public_key2", type=str, help="Public key 2 (in hexadecimal)")
parser.add_argument("operation", choices=["+", "-", "*", "/"], help="Operation to perform (+ for add, - for subtract, * for multiply, / for divide)")

args = parser.parse_args()

# Define the elliptic curve parameters (SECP256k1 in Bitcoin)
curve = ecdsa.SECP256k1

# Parse the public keys from the command-line arguments
public_key1 = ecdsa.VerifyingKey.from_string(bytes.fromhex(args.public_key1), curve=curve).pubkey.point
public_key2 = ecdsa.VerifyingKey.from_string(bytes.fromhex(args.public_key2), curve=curve).pubkey.point

# Perform the specified operation on the public keys
if args.operation == "+":
    result_point = point_addition(public_key1, public_key2)
elif args.operation == "-":
    result_point = point_subtraction(public_key1, public_key2)
elif args.operation == "*":
    scalar = int(input("Enter the scalar value (private key): "), 16)
    result_point = point_multiplication(public_key1, scalar)
elif args.operation == "/":
    scalar = int(input("Enter the scalar value (private key): "), 16)
    result_point = point_division(public_key1, scalar)

# Print the coordinates of the result point
result_x, result_y = ecdsa.util.number_to_string(result_point.x(), curve.order), ecdsa.util.number_to_string(result_point.y(), curve.order)
print("Result Point (x, y):", result_x.hex(), ",", result_y.hex())" result was awkward but anyway,

how do we go about the addition and subtraction, division and multiplication and how do we make sense off of the result from this process??
what tools are required?
Calculators and procedures involved. I'm down to learn too

Code:

Pcurve = 2**256 - 2**32 - 2**9 - 2**8 - 2**7 - 2**6 - 2**4 -1 # The proven prime
N=0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 # Number of points in the field
Acurve = 0; Bcurve = 7 # This defines the curve. y^2 = x^3 + Acurve * x + Bcurve
Gx = 55066263022277343669578718895168534326250603453777594175500187360389116729240
Gy = 32670510020758816978083085130507043184471273380659243275938904335757337482424

def modinv(a,n=Pcurve): #Extended Euclidean Algorithm/'division' in elliptic curves
    lm, hm = 1,0
    low, high = a%n,n
    while low > 1:
        ratio = high/low
        nm, new = hm-lm*ratio, high-low*ratio
        lm, low, hm, high = nm, new, lm, low
    return int(lm % n)

def ECadd(xp,yp,xq,yq): # Not true addition, invented for EC. It adds Point-P with Point-Q.
    m = ((yq-yp) * mod_inverse(xq-xp,Pcurve)) % Pcurve
    xr = (m*m-xp-xq) % Pcurve
    yr = (m*(xp-xr)-yp) % Pcurve
    return (xr,yr)

def ECdouble(xp,yp): # EC point doubling,  invented for EC. It doubles Point-P.
    LamNumer = 3*xp*xp+Acurve
    LamDenom = 2*yp
    Lam = (LamNumer * mod_inverse(LamDenom,Pcurve)) % Pcurve
    xr = (Lam*Lam-2*xp) % Pcurve
    yr = (Lam*(xp-xr)-yp) % Pcurve
    return (xr,yr)

def EccMultiply(xs,ys,Scalar): # Double & add. EC Multiplication, Not true multiplication
    #if Scalar == 0 or Scalar >= N: raise Exception("Invalid Scalar/Private Key")
    ScalarBin = str(bin(Scalar))[2:]
    Qx,Qy=xs,ys
    for i in range (1, len(ScalarBin)): # This is invented EC multiplication.
        Qx,Qy=ECdouble(Qx,Qy); # print "DUB", Qx; print
        #print(Qx,Qy)
        if ScalarBin[i] == "1":
            Qx,Qy=ECadd(Qx,Qy,xs,ys); # print "ADD", Qx; print
    return (Qx,Qy)

You can understand how it works by looking at the code.

Thank you very much for this code.
i will study the code further to understand how it works as I'm still a newbie in this but learning is my thing. thanks a lot.

[puzzle-dev]

A new version of my "solve66" tool for puzzle #66 is available!

Code:

- added version number
- enabled option -M for additional search modes

WARNING:
- NEVER DOWNLOAD THIS TOOL FROM ANY OTHER SOURCE THAN THE LINK IN MY PROFILE!
- READ README.TXT FIRST BEFORE USING THIS TOOL!

[mcdouglasx]

for new users!
 Imagine the elliptic curve as a constant repetition of patterns where the negative or positive sign does not matter. example in a curve composed of 0-10 (in reality it is a huge number) the private key of 1 equals ...-19,-11,-9,-1, 1,9, 11, 19... to infinity in both directions.
 Any of those combinations work for all the others.
That is to say, a public key has copies of itself represented with different numbers but on paper they are the same and if you have the private key of 1, you have pk 9, pk 2 you have pk 8....

public key = pub
private key=pk

so if we have
pk=3
we apply

pk-10= 7
3=7 for the example, both pk's are mirrors.

Having said this, we understand that there is no way to know the range of a pk, if it is a pk - or positive. however there are mathematical tricks to reduce the size of these pk until finding a reasonable range to apply brute force.

[GoldTiger69]

I'm sorry, but if pk = 3; then pk -  10 =/= 7, pk - 10 = -7, very different.

[digaran]

for new users!
 Imagine the elliptic curve as a constant repetition of patterns where the negative or positive sign does not matter. example in a curve composed of 0-10 (in reality it is a huge number) the private key of 1 equals ...-19,-11,-9,-1, 1,9, 11, 19... to infinity in both directions.
 Any of those combinations work for all the others.
That is to say, a public key has copies of itself represented with different numbers but on paper they are the same and if you have the private key of 1, you have pk 9, pk 2 you have pk 8....

public key = pub
private key=pk

so if we have
pk=3
we apply

pk-10= 7
3=7 for the example, both pk's are mirrors.

Having said this, we understand that there is no way to know the range of a pk, if it is a pk - or positive. however there are mathematical tricks to reduce the size of these pk until finding a reasonable range to apply brute force.

How exactly did you come up with those numbers? Since when 3=7?
If you don't know how it works don't spread misinformation!

This is -n private key of 0x7,

Code:

fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd036413a

And this is +n private key of 0x7,

Code:

0000000000000000000000000000000000000000000000000000000000000007

Now where is 3 here?
If you divide 7 by 2, you will have -n of 0x3, which you will obtain by subtracting 4 from N =

Code:

fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141

One useful trick is dividing an odd key without having any remainder, that is dividing by 2 then adding n/2, or just subtract 1 from pk then divide by 2.

The only advantage we have regarding the range of keys is that we know the exact range for each one of them yet we can't do anything about it.

Do you have any tricks to reduce the range bit by bit? Well there is one, subtraction is the key, but you'd need to know what to subtract from your key. 😉

[mcdouglasx]

for new users!
 Imagine the elliptic curve as a constant repetition of patterns where the negative or positive sign does not matter. example in a curve composed of 0-10 (in reality it is a huge number) the private key of 1 equals ...-19,-11,-9,-1, 1,9, 11, 19... to infinity in both directions.
 Any of those combinations work for all the others.
That is to say, a public key has copies of itself represented with different numbers but on paper they are the same and if you have the private key of 1, you have pk 9, pk 2 you have pk 8....

public key = pub
private key=pk

so if we have
pk=3
we apply

pk-10= 7
3=7 for the example, both pk's are mirrors.

Having said this, we understand that there is no way to know the range of a pk, if it is a pk - or positive. however there are mathematical tricks to reduce the size of these pk until finding a reasonable range to apply brute force.

How exactly did you come up with those numbers? Since when 3=7?
If you don't know how it works don't spread misinformation!

This is -n private key of 0x7,

Code:

fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd036413a

And this is +n private key of 0x7,

Code:

0000000000000000000000000000000000000000000000000000000000000007

Now where is 3 here?
If you divide 7 by 2, you will have -n of 0x3, which you will obtain by subtracting 4 from N =

Code:

fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141

One useful trick is dividing an odd key without having any remainder, that is dividing by 2 then adding n/2, or just subtract 1 from pk then divide by 2.

The only advantage we have regarding the range of keys is that we know the exact range for each one of them yet we can't do anything about it.

Do you have any tricks to reduce the range bit by bit? Well there is one, subtraction is the key, but you'd need to know what to subtract from your key. 😉

I used 0-10 as an example but they are really:115792089237316195423570985008687907852837564279074904382605163141518161494337

Code:

x=115792089237316195423570985008687907852837564279074904382605163141518161494337
pk= 1
r= pk-x
>>r= 1 = 115792089237316195423570985008687907852837564279074904382605163141518161494336 = 115792089237316195423570985008687907852837564279074904382605163141518161494338 = -1 /code]


And so the same with all the variants they represent the same, it is not misinformation.
is a reality.