As the "master math guru" of this community 🤥😂 I have always wondered, can God make it so when 2+2 you get 5, I mean he can do anything right? So how could we believe all of the rules of physics, mathematics? If it's possible to change the rules like that? It would be like saying since God can do anything, he should be able to clone himself infinitely, or more importantly, can God kill himself? These questions are taunting and impossible to know the answer for sure, but logic says he shouldn't be able to make 2+2=5, or create clones of himself or self destruct, that means logically even God has limits to his power.
But is that really the case? Did he create the rules out of nothing or were these rules always there along side him?
I believe we are only one of the versions of infinite possible versions, so yes it is possible to see 2+2=5 under different governing rules of different universes, while it doesn't make any sense to us because we only know of 2+2=4, governing principles of our universe does not allow us to figure out how it is possible to have two plus two equal five, this is our limit, we can't go beyond this limit.
Now what is my point? There is a solution to solve these keys, also there is a relation between rmd160 and ecc keys, just because we can't think what they are doesn't mean they don't exist. If you seek knowledge, ask the source of knowledge. But if you quit trying midway, you will get nothing, so chop chop and God bless you.😉
Edit : this is my achievement after working on elliptic curve cryptography for more than 8 months.
I set it to print the result of subtraction, if you want to see the result for scalar_1 remove "print" from the third line and add "print" to first line, so result_1 is the result of scalar_2 division, this happens when I work by myself and a world dominating AI. 😂
import gmpy2 as mpz
from gmpy2 import powmod
# Define the ec_operations function
def ec_operations(start_range, end_range, scalar_1, scalar_2, n, divide_1_by_odd=True, divide_1_by_even=True, divide_2_by_odd=True, divide_2_by_even=True):
for i in range(start_range + (start_range%2), end_range, 1):
# divide scalar 1 by odd or even numbers
if i%2 == 0 and not divide_1_by_even:
continue
elif i%2 == 1 and not divide_1_by_odd:
continue
try:
# calculate inverse modulo of i
i_inv = powmod(i, n-2, n)
# multiply the scalar targets by i modulo n
result_1 = scalar_2 * i_inv % n
result_2 = scalar_1 * i_inv % n
# divide scalar 2 by odd or even numbers
if i%2 == 0 and not divide_2_by_even:
continue
elif i%2 == 1 and not divide_2_by_odd:
continue
# subtract the results
sub_result = (result_2 - result_1) % n
# print results separately
(f"{i}-{hex(result_1)[2:]}")
(f"{i}-{hex(result_2)[2:]}")
print(f"{i}-{hex(sub_result)[2:]}")
except ZeroDivisionError:
pass
if __name__ == "__main__":
# Set the targets and range for the operations
scalar_1 = 0x0000000000000000000000000000000ff9450a667168a48762abcbe86653a6a1
scalar_2 = 0x0000000000000000000000000000000000000000000000000000000000000001
n = mpz.mpz("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141")
start_range = 2
end_range = 65
ec_operations(start_range, end_range, scalar_1, scalar_2, n)
Note, you can also change "1" in the following line to divide by odd or even,
for i in range(start_range + (start_range%2), end_range, 1):
Replace 1 with 2 and print subtraction result to see it divides by 2, 4, 6 etc, replacing it with 3, will divide by 2, 5, 8, 11 etc, since our start range is 2 it will start from 2 and adds 3 each step.
Even though I have already posted the script for point calculations, to make it easier for you to havd both scripts in one place, here goes the same script operating with public keys:
import gmpy2 as mpz
from gmpy2 import powmod
# Define the EllipticCurve class
class EllipticCurve:
def __init__(self, a, b, p):
self.a = mpz.mpz(a)
self.b = mpz.mpz(b)
self.p = mpz.mpz(p)
def contains(self, point):
x, y = point.x, point.y
return (y * y) % self.p == (x * x * x + self.a * x + self.b) % self.p
def __str__(self):
return f"y^2 = x^3 + {self.a}x + {self.b} mod {self.p}"
# Define the Point class
class Point:
def __init__(self, x, y, curve):
self.x = mpz.mpz(x)
self.y = mpz.mpz(y)
self.curve = curve
def __eq__(self, other):
return self.x == other.x and self.y == other.y and self.curve == other.curve
def __ne__(self, other):
return not self == other
def __add__(self, other):
if self.curve != other.curve:
raise ValueError("Cannot add points on different curves")
# Case when one point is zero
if self == Point.infinity(self.curve):
return other
if other == Point.infinity(self.curve):
return self
if self.x == other.x and self.y != other.y:
return Point.infinity(self.curve)
p = self.curve.p
s = 0
if self == other:
s = ((3 * self.x * self.x + self.curve.a) * powmod(2 * self.y, -1, p)) % p
else:
s = ((other.y - self.y) * powmod(other.x - self.x, -1, p)) % p
x = (s * s - self.x - other.x) % p
y = (s * (self.x - x) - self.y) % p
return Point(x, y, self.curve)
def __sub__(self, other):
if self.curve != other.curve:
raise ValueError("Cannot subtract points on different curves")
# Case when one point is zero
if self == Point.infinity(self.curve):
return other
if other == Point.infinity(self.curve):
return self
return self + Point(other.x, (-other.y) % self.curve.p, self.curve)
def __mul__(self, n):
if not isinstance(n, int):
raise ValueError("Multiplication is defined for integers only")
n = n % (self.curve.p - 1)
res = Point.infinity(self.curve)
addend = self
while n:
if n & 1:
res += addend
addend += addend
n >>= 1
return res
def __str__(self):
return f"({self.x}, {self.y}) on {self.curve}"
@staticmethod
def from_hex(s, curve):
if len(s) == 66 and s.startswith("02") or s.startswith("03"):
compressed = True
elif len(s) == 130 and s.startswith("04"):
compressed = False
else:
raise ValueError("Hex string is not a valid compressed or uncompressed point")
if compressed:
is_odd = s.startswith("03")
x = mpz.mpz(s[2:], 16)
# Calculate y-coordinate from x and parity bit
y_square = (x * x * x + curve.a * x + curve.b) % curve.p
y = powmod(y_square, (curve.p + 1) // 4, curve.p)
if is_odd != (y & 1):
y = -y % curve.p
return Point(x, y, curve)
else:
s_bytes = bytes.fromhex(s)
uncompressed = s_bytes[0] == 4
if not uncompressed:
raise ValueError("Only uncompressed or compressed points are supported")
num_bytes = len(s_bytes) // 2
x_bytes = s_bytes[1 : num_bytes + 1]
y_bytes = s_bytes[num_bytes + 1 :]
x = mpz.mpz(int.from_bytes(x_bytes, byteorder="big"))
y = mpz.mpz(int.from_bytes(y_bytes, byteorder="big"))
return Point(x, y, curve)
def to_hex(self, compressed=True):
if self.x is None and self.y is None:
return "00"
elif compressed:
prefix = "03" if self.y & 1 else "02"
return prefix + hex(self.x)[2:].zfill(64)
else:
x_hex = hex(self.x)[2:].zfill(64)
y_hex = hex(self.y)[2:].zfill(64)
return "04" + x_hex + y_hex
@staticmethod
def infinity(curve):
return Point(-1, -1, curve)
# Define the ec_mul function
def ec_mul(point, scalar, base_point):
result = Point.infinity(point.curve)
addend = point
while scalar:
if scalar & 1:
result += addend
addend += addend
scalar >>= 1
return result
# Define the ec_operations function
def ec_operations(start_range, end_range, target_1, target_2, curve, divide_1_by_odd=True, divide_1_by_even=True, divide_2_by_odd=True, divide_2_by_even=True):
# Define parameters for secp256k1 curve
n = mpz.mpz("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141")
G = Point(
mpz.mpz("0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798"),
mpz.mpz("0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8"),
curve
)
for i in range(start_range + ( start_range%2), end_range, 1 ):
# divide target 1 by odd or even numbers
if i%2 == 0 and not divide_1_by_even:
continue
elif i%2 == 1 and not divide_1_by_odd:
continue
try:
# calculate inverse modulo of i
i_inv = powmod(i, n-2, n)
# divide the targets by i modulo n
result_1 = ec_mul(target_1, i_inv, G)
result_2 = ec_mul(target_2, i_inv, G)
# divide target 2 by odd or even numbers
if i%2 == 0 and not divide_2_by_even:
continue
elif i%2 == 1 and not divide_2_by_odd:
continue
# subtract the results
sub_result = result_1 - result_2
# print the results separately
(f"{i}-{result_1.to_hex()}")
(f"{i}-{result_2.to_hex()}")
print(f"{i}-{sub_result.to_hex()}")
except ZeroDivisionError:
pass
if __name__ == "__main__":
# Set the targets and range for the operations
curve = EllipticCurve(
mpz.mpz(0),
mpz.mpz(7),
mpz.mpz("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F")
)
target_1 = Point.from_hex("03db8705a402eabb367c23a611249d01f4c631c0a449093ca97ff5d19a5cbce7aa", curve)
target_2 = Point.from_hex("0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798", curve)
start_range = 1
end_range = 65
ec_operations(start_range, end_range, target_2, target_1, curve)
Special thanks to @mcdouglasx for dividing by range code, and to @nomachine for gympy2 and mpz introduction.
Ps, I'm not working to solve these puzzles, I am just studying elliptic curve, I haven't tested my methods on puzzle keys.
