DegenHero
Newbie
Offline
Activity: 4
Merit: 0
|
 |
July 25, 2023, 10:22:59 AM |
|
@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
|
|
|
|
|
bestie1549
Jr. Member
Offline
Activity: 75
Merit: 5
|
 |
July 28, 2023, 07:24:52 AM |
|
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
Activity: 205
Merit: 1
|
 |
July 28, 2023, 07:34:44 AM |
|
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
Activity: 57
Merit: 1
|
 |
July 28, 2023, 08:51:11 AM |
|
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
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
Activity: 75
Merit: 5
|
 |
July 28, 2023, 02:22:18 PM |
|
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
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
Activity: 10
Merit: 0
|
 |
July 29, 2023, 08:24:46 AM |
|
A new version of my "solve66" tool for puzzle #66 is available!- 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
|
 |
July 30, 2023, 04:48:10 PM |
|
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
|
 |
July 30, 2023, 06:21:12 PM |
|
I'm sorry, but if pk = 3; then pk - 10 =/= 7, pk - 10 = -7, very different.
|
|
|
|
digaran
Copper Member
Hero Member
   
Offline
Activity: 1330
Merit: 900
🖤😏
|
 |
July 30, 2023, 06:21:55 PM |
|
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, fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd036413a And this is +n private key of 0x7, 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 = 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
|
 |
July 30, 2023, 09:13:41 PM |
|
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, fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd036413a And this is +n private key of 0x7, 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 = 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 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
|
 |
July 30, 2023, 09:26:21 PM |
|
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]x= 115792089237316195423570985008687907852837564279074904382605163141518161494337 pk= 1 r= pk-x pub 0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798
[/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
Activity: 1330
Merit: 900
🖤😏
|
 |
July 31, 2023, 10:17:41 AM |
|
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]x= 115792089237316195423570985008687907852837564279074904382605163141518161494337 pk= 1 r= pk-x pub 0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798
[/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 : 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
Activity: 5
Merit: 0
|
 |
July 31, 2023, 12:39:53 PM |
|
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
|
 |
July 31, 2023, 01:02:29 PM Last edit: July 31, 2023, 02:32:40 PM by mcdouglasx |
|
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]x= 115792089237316195423570985008687907852837564279074904382605163141518161494337 pk= 1 r= pk-x pub 0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798
[/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 : 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
|
 |
July 31, 2023, 02:44:46 PM |
|
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]x= 115792089237316195423570985008687907852837564279074904382605163141518161494337 pk= 1 r= pk-x pub 0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798
[/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 : 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
Activity: 200
Merit: 14
|
 |
July 31, 2023, 02:58:39 PM |
|
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
|
 |
July 31, 2023, 04:52:47 PM |
|
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
Activity: 1330
Merit: 900
🖤😏
|
 |
July 31, 2023, 06:41:12 PM |
|
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
|
 |
August 01, 2023, 02:29:15 AM |
|
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
|
|
|
|
|