Bitcoin Forum
February 16, 2025, 04:28:52 PM *
News: Community Awards voting is open
 
   Home   Help Search Login Register More  
Pages: « 1 ... 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 [150] 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 ... 368 »
  Print  
Author Topic: Bitcoin puzzle transaction ~32 BTC prize to who solves it  (Read 254677 times)
DegenHero
Newbie
*
Offline Offline

Activity: 4
Merit: 0


View Profile
July 25, 2023, 10:22:59 AM
 #2981


@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
Copper Member
Hero Member
*****
Offline Offline

Activity: 1330
Merit: 900

🖤😏


View Profile
July 25, 2023, 01:49:12 PM
 #2982

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
Jr. Member
*
Offline Offline

Activity: 75
Merit: 5


View Profile
July 28, 2023, 07:24:52 AM
 #2983

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
Copper Member
Jr. Member
*
Offline Offline

Activity: 205
Merit: 1


View Profile
July 28, 2023, 07:34:44 AM
 #2984

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
Jr. Member
*
Offline Offline

Activity: 57
Merit: 1


View Profile
July 28, 2023, 08:51:11 AM
 #2985


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.


If you want to buy me a coffee

Btc = 3246y1G9YjnQQNRUrVMnaeCFrymZRgJAP7

Doge = DGNd8UTi8jVTVZ2twhKydyqicynbsERMjs
bestie1549
Jr. Member
*
Offline Offline

Activity: 75
Merit: 5


View Profile
July 28, 2023, 02:22:18 PM
 #2986


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
Newbie
*
Offline Offline

Activity: 10
Merit: 0


View Profile WWW
July 29, 2023, 08:24:46 AM
 #2987

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

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


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

Activity: 546
Merit: 161



View Profile WWW
July 30, 2023, 04:48:10 PM
 #2988

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
Hero Member
*****
Offline Offline

Activity: 583
Merit: 502


View Profile WWW
July 30, 2023, 06:21:12 PM
 #2989

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

I can help you to restore/recover your wallet or password.
https://bitcointalk.org/index.php?topic=1234619.0
digaran
Copper Member
Hero Member
*****
Offline Offline

Activity: 1330
Merit: 900

🖤😏


View Profile
July 30, 2023, 06:21:55 PM
 #2990

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
Full Member
***
Offline Offline

Activity: 546
Merit: 161



View Profile WWW
July 30, 2023, 09:13:41 PM
 #2991

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.



mcdouglasx
Full Member
***
Offline Offline

Activity: 546
Merit: 161



View Profile WWW
July 30, 2023, 09:26:21 PM
 #2992

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

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


Code:
[code]x= 115792089237316195423570985008687907852837564279074904382605163141518161494337
pk= 1
r= pk-x
pub 0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798
[/code]


Code:
Pk decimal: -1
pub  0379be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798

Pk decimal: 1

pub 0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798

Pk decimal: 115792089237316195423570985008687907852837564279074904382605163141518161494336

pub 0379be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798

Pk decimal: 115792089237316195423570985008687907852837564279074904382605163141518161494338

pub 0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798

digaran
Copper Member
Hero Member
*****
Offline Offline

Activity: 1330
Merit: 900

🖤😏


View Profile
July 31, 2023, 10:17:41 AM
 #2993

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

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


Code:
[code]x= 115792089237316195423570985008687907852837564279074904382605163141518161494337
pk= 1
r= pk-x
pub 0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798
[/code]


Code:
Pk decimal: -1
pub  0379be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798

Pk decimal: 1

pub 0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798

Pk decimal: 115792089237316195423570985008687907852837564279074904382605163141518161494336

pub 0379be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798

Pk decimal: 115792089237316195423570985008687907852837564279074904382605163141518161494338

pub 0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798
When I say misinformation, now I know you are misinformed, this key :
Code:
115792089237316195423570985008687907852837564279074904382605163141518161494338
is an invalid key, but mod n it is the same as G or 0x1. You see, whatever you add to n, it's like adding to zero, if you add 5 to n, what you get is just 5. So no, they are not all the same, if you convert the key above to WIF no wallet will accept it because it has a wrong format. All pk are mod n.

🖤😏
crewchill
Newbie
*
Offline Offline

Activity: 5
Merit: 0


View Profile
July 31, 2023, 12:39:53 PM
 #2994

Code:
import time
import random
import multiprocessing
from bit import *

add = "13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so"

s = 0
cores = 8
def lucky(s):
F = []
while True:
x = "0123456789abcdef"
a = "3f" #prefix range, can be modified.
b = ''.join(random.choice(x) for _ in range (15))
private_key = (f'{a}{b}')
key = Key.from_hex(private_key)
address = key.address

if address.startswith('13zb1hQ'): #can be used as vanity search
print ("Pattern Found :",private_key, address)

if address == add:
print("Lucky mf! :" ,address, private_key)

if __name__ =='__main__':
t = time.ctime()
job =[]
for s in range (cores):
p = multiprocessing.Process(target=lucky, args=(s,))
jobs.append(p)
p.start()

if you want to find puzzle #66 in slow mode. I leave the code here.
mcdouglasx
Full Member
***
Offline Offline

Activity: 546
Merit: 161



View Profile WWW
July 31, 2023, 01:02:29 PM
Last edit: July 31, 2023, 02:32:40 PM by mcdouglasx
 #2995

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

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


Code:
[code]x= 115792089237316195423570985008687907852837564279074904382605163141518161494337
pk= 1
r= pk-x
pub 0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798
[/code]


Code:
Pk decimal: -1
pub  0379be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798

Pk decimal: 1

pub 0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798

Pk decimal: 115792089237316195423570985008687907852837564279074904382605163141518161494336

pub 0379be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798

Pk decimal: 115792089237316195423570985008687907852837564279074904382605163141518161494338

pub 0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798
When I say misinformation, now I know you are misinformed, this key :
Code:
115792089237316195423570985008687907852837564279074904382605163141518161494338
is an invalid key, but mod n it is the same as G or 0x1. You see, whatever you add to n, it's like adding to zero, if you add 5 to n, what you get is just 5. So no, they are not all the same, if you convert the key above to WIF no wallet will accept it because it has a wrong format. All pk are mod n.

bro honestly you are not good for maths, sorry about that, you do not think with mathematics you talk about invalid key as if the discrete logarithm and its request depended on the parameters that were imposed on the curve as a standard, the goal is to get any of pk, you can not only find a key by subtracting and dividing.

X=115792089237316195423570985008687907852837564279074904382605163141518161494337
Y=115792089237316195423570985008687907852837564279074904382605163141518161494336
If X represents a zero in the calculations of your library, a good mathematician would logically use Y and add 1 to the result.

Like

(Y-pk)+1

The goal is to find some key, it doesn't matter if it is invalid for the bitcoin standard, because knowing the pk of any of them will know the original pk you are looking for. If you limit your mind thinking about the parameters that satoshi imposed, you will not achieve

example: suppose you want to find an unknown key that we call Z Z= 1200 if we know that its range is between 1000:2000 if we subtract 2000 we will get -800 wow yes, an invalid key?? should i care The answer is no, because if we find the value -800, even if it represents an invalid key, we will know that the original pk is 1200.

mcdouglasx
Full Member
***
Offline Offline

Activity: 546
Merit: 161



View Profile WWW
July 31, 2023, 02:44:46 PM
 #2996

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

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


Code:
[code]x= 115792089237316195423570985008687907852837564279074904382605163141518161494337
pk= 1
r= pk-x
pub 0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798
[/code]


Code:
Pk decimal: -1
pub  0379be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798

Pk decimal: 1

pub 0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798

Pk decimal: 115792089237316195423570985008687907852837564279074904382605163141518161494336

pub 0379be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798

Pk decimal: 115792089237316195423570985008687907852837564279074904382605163141518161494338

pub 0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798
When I say misinformation, now I know you are misinformed, this key :
Code:
115792089237316195423570985008687907852837564279074904382605163141518161494338
is an invalid key, but mod n it is the same as G or 0x1. You see, whatever you add to n, it's like adding to zero, if you add 5 to n, what you get is just 5. So no, they are not all the same, if you convert the key above to WIF no wallet will accept it because it has a wrong format. All pk are mod n.

bro honestly you are not good for maths, sorry about that, you do not think with mathematics you talk about invalid key as if the discrete logarithm and its request depended on the parameters that were imposed on the curve as a standard, the goal is to get any of pk, you can not only find a key by subtracting and dividing.

X=115792089237316195423570985008687907852837564279074904382605163141518161494337
Y=115792089237316195423570985008687907852837564279074904382605163141518161494336
If X represents a zero in the calculations of your library, a good mathematician would logically use Y and add 1 to the result.

Like

(Y-pk)+1

The goal is to find some key, it doesn't matter if it is invalid for the bitcoin standard, because knowing the pk of any of them will know the original pk you are looking for. If you limit your mind thinking about the parameters that satoshi imposed, you will not achieve

example: suppose you want to find an unknown key that we call Z Z= 1200 if we know that its range is between 1000:2000 if we subtract 2000 we will get -800 wow yes, an invalid key?? should i care The answer is no, because if we find the value -800, even if it represents an invalid key, we will know that the original pk is 1200.


I recommend the python module ICE secp256k1 has no N limits, it will give you the exact results even when these results are negative or over the imposed limit. An example, the Bitcoin module, gives erroneous results when it comes to negative values ​​or above the imposed limit. Let's remember that numbers are infinite and that a program only recognizes from 1-10, for example, does not mean that you cannot add 4+7 or that 11 does not exist.

GR Sasa
Member
**
Offline Offline

Activity: 200
Merit: 14


View Profile
July 31, 2023, 02:58:39 PM
 #2997


I recommend the python module ICE secp256k1 has no N limits, it will give you the exact results even when these results are negative or over the imposed limit. An example, the Bitcoin module, gives erroneous results when it comes to negative values ​​or above the imposed limit. Let's remember that numbers are infinite and that a program only recognizes from 1-10, for example, does not mean that you cannot add 4+7 or that 11 does not exist.

You are making yourself a professional user, even though no one of us are.

Even if you divide, multiply, add, subtract a key million of times to get back to the targeted key, you'll not find an single answer for the new values. Because they will still be represented as 255 bits, so the complexity did not changed at all. You just moved the targeted key from A to B, with absolutely the same complexity.
mcdouglasx
Full Member
***
Offline Offline

Activity: 546
Merit: 161



View Profile WWW
July 31, 2023, 04:52:47 PM
 #2998


I recommend the python module ICE secp256k1 has no N limits, it will give you the exact results even when these results are negative or over the imposed limit. An example, the Bitcoin module, gives erroneous results when it comes to negative values ​​or above the imposed limit. Let's remember that numbers are infinite and that a program only recognizes from 1-10, for example, does not mean that you cannot add 4+7 or that 11 does not exist.

You are making yourself a professional user, even though no one of us are.

Even if you divide, multiply, add, subtract a key million of times to get back to the targeted key, you'll not find an single answer for the new values. Because they will still be represented as 255 bits, so the complexity did not changed at all. You just moved the targeted key from A to B, with absolutely the same complexity.
no bro, I don't move the key without differences, as if I were using simple additions and subtractions, I reduce many bits (the beautiful thing about maths, things happen as if it were magic), my problem is that my algorithm is not perfect (yet, or so I want to believe) I have not found a way to reduce more without the need to create thousands of keys, and also that I was born in a poor country and my resources to scan that bit limit me. therefore it is not like you say that there is no difference, there are differences, only you do not know it.

digaran
Copper Member
Hero Member
*****
Offline Offline

Activity: 1330
Merit: 900

🖤😏


View Profile
July 31, 2023, 06:41:12 PM
 #2999

The goal is to find some key, it doesn't matter if it is invalid for the bitcoin standard, because knowing the pk of any of them will know the original pk you are looking for. If you limit your mind thinking about the parameters that satoshi imposed, you will not achieve

example: suppose you want to find an unknown key that we call Z Z= 1200 if we know that its range is between 1000:2000 if we subtract 2000 we will get -800 wow yes, an invalid key?? should i care The answer is no, because if we find the value -800, even if it represents an invalid key, we will know that the original pk is 1200.

Ok, how do you know the result is -800? And whatever the result, it's not invalid, but what if the key is 1890? You'd be searching from 700 to 800 in hopes of finding you imaginary -800, while the actual result is 110, far away from your searching range. I guess you haven't figured out a way to  validate whether your target is greater than 1500 or not, once you figure that out, you can base your future calculations on the fact that your target is greater or smaller than 1500.

E.g. if the key is 1650, multiply by 3 to get 4950, divide by 2 to get 2475, subtract your target from 2475 to get 825, which is half of your target.
Or just subtract 1 divide by 2, to name a few methods.



X=115792089237316195423570985008687907852837564279074904382605163141518161494337
Y=115792089237316195423570985008687907852837564279074904382605163141518161494336
If X represents a zero in the calculations of your library, a good mathematician would logically use Y and add 1 to the result.

Like

(Y-pk)+1


So the expert mathematician would use Y and then adds 1? I wonder about the logic in doing that, he might be crazy if he thinks that he can use a different algorithm to find secp256k1 keys faster. Are you sure this "good mathematician" knows about mod n in secp256k1 curve?
Anyways, when searching for unkown keys, doesn't matter if the keys are greater than n or not, because you don't have the pk to check, though if we use  standard implementation then we can be sure all keys are valid since they are all calculated mod n, whatever you do, public keys are always mod p, otherwise you get invalid public keys.

When we are talking about bitcoin's curve, you can NOT use different values expecting the results to work on bitcoin keys.

🖤😏
mcdouglasx
Full Member
***
Offline Offline

Activity: 546
Merit: 161



View Profile WWW
August 01, 2023, 02:29:15 AM
 #3000

The goal is to find some key, it doesn't matter if it is invalid for the bitcoin standard, because knowing the pk of any of them will know the original pk you are looking for. If you limit your mind thinking about the parameters that satoshi imposed, you will not achieve

example: suppose you want to find an unknown key that we call Z Z= 1200 if we know that its range is between 1000:2000 if we subtract 2000 we will get -800 wow yes, an invalid key?? should i care The answer is no, because if we find the value -800, even if it represents an invalid key, we will know that the original pk is 1200.

Ok, how do you know the result is -800? And whatever the result, it's not invalid, but what if the key is 1890? You'd be searching from 700 to 800 in hopes of finding you imaginary -800, while the actual result is 110, far away from your searching range. I guess you haven't figured out a way to  validate whether your target is greater than 1500 or not, once you figure that out, you can base your future calculations on the fact that your target is greater or smaller than 1500.

E.g. if the key is 1650, multiply by 3 to get 4950, divide by 2 to get 2475, subtract your target from 2475 to get 825, which is half of your target.
Or just subtract 1 divide by 2, to name a few methods.



X=115792089237316195423570985008687907852837564279074904382605163141518161494337
Y=115792089237316195423570985008687907852837564279074904382605163141518161494336
If X represents a zero in the calculations of your library, a good mathematician would logically use Y and add 1 to the result.

Like

(Y-pk)+1


So the expert mathematician would use Y and then adds 1? I wonder about the logic in doing that, he might be crazy if he thinks that he can use a different algorithm to find secp256k1 keys faster. Are you sure this "good mathematician" knows about mod n in secp256k1 curve?
Anyways, when searching for unkown keys, doesn't matter if the keys are greater than n or not, because you don't have the pk to check, though if we use  standard implementation then we can be sure all keys are valid since they are all calculated mod n, whatever you do, public keys are always mod p, otherwise you get invalid public keys.

When we are talking about bitcoin's curve, you can NOT use different values expecting the results to work on bitcoin keys.

If you cannot understand that, you do not know about Maths, if you think that I am somehow lost in what I speak and you think the solution is in the same ECC, I will shut up, but surely you would read on me later when I publish the PK of the puzzle.
Meanwhile, suppose you are right

Pages: « 1 ... 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 [150] 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 ... 368 »
  Print  
 
Jump to:  

Powered by MySQL Powered by PHP Powered by SMF 1.1.19 | SMF © 2006-2009, Simple Machines Valid XHTML 1.0! Valid CSS!