Topic: Pollard's kangaroo ECDLP solver - page 12. (Read 60189 times)
is there a multicore version out
or can we edit this to do that , thanks mate for sharing.
or can we edit this to do that , thanks mate for sharing.
Sure, here's the full script with multiprocessing added:
Code:
import time
import random
import gmpy2
from functools import lru_cache
import multiprocessing
modulo = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F
order = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
Gx = 0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798
Gy = 0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8
class Point:
def __init__(self, x=0, y=0):
self.x = x
self.y = y
PG = Point(Gx, Gy)
Z = Point(0, 0) # zero-point, infinite in real x,y-plane
def mul2(P, p=modulo):
c = (3 * P.x * P.x * pow(2 * P.y, -1, p)) % p
R = Point()
R.x = (c * c - 2 * P.x) % p
R.y = (c * (P.x - R.x) - P.y) % p
return R
def add(P, Q, p=modulo):
dx = Q.x - P.x
dy = Q.y - P.y
c = dy * gmpy2.invert(dx, p) % p
R = Point()
R.x = (c * c - P.x - Q.x) % p
R.y = (c * (P.x - R.x) - P.y) % p
return R
@lru_cache(maxsize=None)
def X2Y(X, p=modulo):
if p % 4 != 3:
print('prime must be 3 modulo 4')
return 0
X = (X ** 3 + 7) % p
pw = (p + 1) // 4
Y = 1
tmp = X
for w in range(256):
if (pw >> w) & 1 == 1:
Y = (Y * tmp) % p
tmp = pow(tmp, 2, p)
return Y
def compute_P_table():
P = [PG]
for k in range(255):
P.append(mul2(P[k]))
return P
P = compute_P_table()
print('P-table prepared')
def comparator(A, Ak, B, Bk):
result = set(A).intersection(set(B))
if result:
sol_kt = A.index(next(iter(result)))
sol_kw = B.index(next(iter(result)))
print('total time: %.2f sec' % (time.time() - starttime))
d = Ak[sol_kt] - Bk[sol_kw]
print('SOLVED:', d)
with open("results.txt", 'a') as file:
file.write(('%d' % (Ak[sol_kt] - Bk[sol_kw])) + "\n")
file.write("---------------\n")
return True
else:
return False
def check(P, Pindex, DP_rarity, file2save, A, Ak, B, Bk):
if P.x % DP_rarity == 0:
A.append(P.x)
Ak.append(Pindex)
with open(file2save, 'a') as file:
file.write(('%064x %d' % (P.x, Pindex)) + "\n")
return comparator(A, Ak, B, Bk)
else:
return False
def mulk(k, P=PG, p=modulo):
if k == 0:
return Z
elif k == 1:
return P
elif k % 2 == 0:
return mulk(k // 2, mul2(P, p), p)
else:
return add(P, mulk((k - 1) // 2, mul2(P, p), p))
def search(process_id, Nt, Nw, problem, kangoo_power, starttime):
DP_rarity = 1 << ((problem - 2 * kangoo_power) // 2 - 2)
hop_modulo = ((problem - 1) // 2) + kangoo_power
T, t, dt = [], [], []
W, w, dw = [], [], []
for k in range(Nt):
t.append((3 << (problem - 2)) + random.randint(1, (1 << (problem - 1))))
T.append(mulk(t[k]))
dt.append(0)
for k in range(Nw):
w.append(random.randint(1, (1 << (problem - 1))))
W.append(add(W0, mulk(w[k])))
dw.append(0)
print('tame and wild herds are prepared')
oldtime = time.time()
Hops, Hops_old = 0, 0
t0 = time.time()
oldtime = time.time()
starttime = oldtime
while True:
for k in range(Nt):
Hops += 1
pw = T[k].x % hop_modulo
dt[k] = 1 << pw
solved = check(T[k], t[k], DP_rarity, "tame.txt", T, t, W, w)
if solved:
return 'sol. time: %.2f sec' % (time.time() - starttime)
t[k] += dt[k]
T[k] = add(P[pw], T[k])
for k in range(Nw):
Hops += 1
pw = W[k].x % hop_modulo
dw[k] = 1 << pw
solved = check(W[k], w[k], DP_rarity, "wild.txt", W, w, T, t)
if solved:
return 'sol. time: %.2f sec' % (time.time() - starttime)
w[k] += dw[k]
W[k] = add(P[pw], W[k])
t1 = time.time()
if (t1 - t0) > 5:
print('%.3f h/s' % ((Hops - Hops_old) / (t1 - t0)))
t0 = t1
Hops_old = Hops
start = 2147483647
end = 4294967295
search_range = end - start + 1
problem = search_range.bit_length()
compreessed_public_key = "0209c58240e50e3ba3f833c82655e8725c037a2294e14cf5d73a5df8d56159de69" #Puzzle 32
kangoo_power = 3
Nt = Nw = 2 ** kangoo_power
X = int(compreessed_public_key, 16)
Y = X2Y(X % (2 ** 256))
if Y % 2 != (X >> 256) % 2:
Y = modulo - Y
X = X % (2 ** 256)
W0 = Point(X, Y)
starttime = oldtime = time.time()
Hops = 0
random.seed()
hops_list = []
N_tests = 3
def search_wrapper(process_id):
return search(process_id, Nt, Nw, problem, kangoo_power, starttime)
if __name__ == "__main__":
num_cpus = multiprocessing.cpu_count()
N_tests = num_cpus # Use the number of CPU cores as the number of tests
with multiprocessing.Pool(processes=N_tests) as pool:
results = pool.map(search_wrapper, range(N_tests))
for result in results:
print(result)
M, D = 0, 0
if len(hops_list) > 0:
M = sum(hops_list) * 1.0 / len(hops_list)
D = sum((xi - M) ** 2 for xi in hops_list) * 1.0 / len(hops_list)
print(M, '+/-', (D / (len(hops_list) - 1)) ** 0.5)
print('Average time to solve: %.2f sec' % ((time.time() - starttime) / N_tests))
import random
import gmpy2
from functools import lru_cache
import multiprocessing
modulo = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F
order = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
Gx = 0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798
Gy = 0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8
class Point:
def __init__(self, x=0, y=0):
self.x = x
self.y = y
PG = Point(Gx, Gy)
Z = Point(0, 0) # zero-point, infinite in real x,y-plane
def mul2(P, p=modulo):
c = (3 * P.x * P.x * pow(2 * P.y, -1, p)) % p
R = Point()
R.x = (c * c - 2 * P.x) % p
R.y = (c * (P.x - R.x) - P.y) % p
return R
def add(P, Q, p=modulo):
dx = Q.x - P.x
dy = Q.y - P.y
c = dy * gmpy2.invert(dx, p) % p
R = Point()
R.x = (c * c - P.x - Q.x) % p
R.y = (c * (P.x - R.x) - P.y) % p
return R
@lru_cache(maxsize=None)
def X2Y(X, p=modulo):
if p % 4 != 3:
print('prime must be 3 modulo 4')
return 0
X = (X ** 3 + 7) % p
pw = (p + 1) // 4
Y = 1
tmp = X
for w in range(256):
if (pw >> w) & 1 == 1:
Y = (Y * tmp) % p
tmp = pow(tmp, 2, p)
return Y
def compute_P_table():
P = [PG]
for k in range(255):
P.append(mul2(P[k]))
return P
P = compute_P_table()
print('P-table prepared')
def comparator(A, Ak, B, Bk):
result = set(A).intersection(set(B))
if result:
sol_kt = A.index(next(iter(result)))
sol_kw = B.index(next(iter(result)))
print('total time: %.2f sec' % (time.time() - starttime))
d = Ak[sol_kt] - Bk[sol_kw]
print('SOLVED:', d)
with open("results.txt", 'a') as file:
file.write(('%d' % (Ak[sol_kt] - Bk[sol_kw])) + "\n")
file.write("---------------\n")
return True
else:
return False
def check(P, Pindex, DP_rarity, file2save, A, Ak, B, Bk):
if P.x % DP_rarity == 0:
A.append(P.x)
Ak.append(Pindex)
with open(file2save, 'a') as file:
file.write(('%064x %d' % (P.x, Pindex)) + "\n")
return comparator(A, Ak, B, Bk)
else:
return False
def mulk(k, P=PG, p=modulo):
if k == 0:
return Z
elif k == 1:
return P
elif k % 2 == 0:
return mulk(k // 2, mul2(P, p), p)
else:
return add(P, mulk((k - 1) // 2, mul2(P, p), p))
def search(process_id, Nt, Nw, problem, kangoo_power, starttime):
DP_rarity = 1 << ((problem - 2 * kangoo_power) // 2 - 2)
hop_modulo = ((problem - 1) // 2) + kangoo_power
T, t, dt = [], [], []
W, w, dw = [], [], []
for k in range(Nt):
t.append((3 << (problem - 2)) + random.randint(1, (1 << (problem - 1))))
T.append(mulk(t[k]))
dt.append(0)
for k in range(Nw):
w.append(random.randint(1, (1 << (problem - 1))))
W.append(add(W0, mulk(w[k])))
dw.append(0)
print('tame and wild herds are prepared')
oldtime = time.time()
Hops, Hops_old = 0, 0
t0 = time.time()
oldtime = time.time()
starttime = oldtime
while True:
for k in range(Nt):
Hops += 1
pw = T[k].x % hop_modulo
dt[k] = 1 << pw
solved = check(T[k], t[k], DP_rarity, "tame.txt", T, t, W, w)
if solved:
return 'sol. time: %.2f sec' % (time.time() - starttime)
t[k] += dt[k]
T[k] = add(P[pw], T[k])
for k in range(Nw):
Hops += 1
pw = W[k].x % hop_modulo
dw[k] = 1 << pw
solved = check(W[k], w[k], DP_rarity, "wild.txt", W, w, T, t)
if solved:
return 'sol. time: %.2f sec' % (time.time() - starttime)
w[k] += dw[k]
W[k] = add(P[pw], W[k])
t1 = time.time()
if (t1 - t0) > 5:
print('%.3f h/s' % ((Hops - Hops_old) / (t1 - t0)))
t0 = t1
Hops_old = Hops
start = 2147483647
end = 4294967295
search_range = end - start + 1
problem = search_range.bit_length()
compreessed_public_key = "0209c58240e50e3ba3f833c82655e8725c037a2294e14cf5d73a5df8d56159de69" #Puzzle 32
kangoo_power = 3
Nt = Nw = 2 ** kangoo_power
X = int(compreessed_public_key, 16)
Y = X2Y(X % (2 ** 256))
if Y % 2 != (X >> 256) % 2:
Y = modulo - Y
X = X % (2 ** 256)
W0 = Point(X, Y)
starttime = oldtime = time.time()
Hops = 0
random.seed()
hops_list = []
N_tests = 3
def search_wrapper(process_id):
return search(process_id, Nt, Nw, problem, kangoo_power, starttime)
if __name__ == "__main__":
num_cpus = multiprocessing.cpu_count()
N_tests = num_cpus # Use the number of CPU cores as the number of tests
with multiprocessing.Pool(processes=N_tests) as pool:
results = pool.map(search_wrapper, range(N_tests))
for result in results:
print(result)
M, D = 0, 0
if len(hops_list) > 0:
M = sum(hops_list) * 1.0 / len(hops_list)
D = sum((xi - M) ** 2 for xi in hops_list) * 1.0 / len(hops_list)
print(M, '+/-', (D / (len(hops_list) - 1)) ** 0.5)
print('Average time to solve: %.2f sec' % ((time.time() - starttime) / N_tests))
In the __name__ == "__main__" block, the number of available CPU cores is determined using multiprocessing.cpu_count(), and N_tests is set to this number. This means that the script will create a separate process for each CPU core available for parallel processing.
i guess did not even clicked it or looked at it, cause i already have used that one,
wasn't what i was looking for actually i guess, the gpu already also working so,
the code of 57fe/Pollard-Rho-Kangaroo should be ai 'ed quickly..
wasn't what i was looking for actually i guess, the gpu already also working so,
the code of 57fe/Pollard-Rho-Kangaroo should be ai 'ed quickly..
hi nomachine, doing a nice 250 300 but it is single core version is there a multicore version out
or can we edit this to do that , thanks mate for sharing.
or can we edit this to do that , thanks mate for sharing.
https://github.com/Telariust/pollard-kangaroo/blob/master/pollard-kangaroo-multi.py
There is a link in his post.
hi nomachine, doing a nice 250 300 but it is single core version is there a multicore version out
or can we edit this to do that , thanks mate for sharing.
or can we edit this to do that , thanks mate for sharing.
two script python
http://bitchain.pl/100btc/pollard_kangaroo.txt
and
https://github.com/Telariust/pollard-kangaroo/blob/master/pollard-kangaroo-multi.py
That link no longer exists. I barely managed to find the original pollard_kangaroo.txt on some Russian site. But it is deprecated for Python 2.x. I updated to 3.x and it's still slow, but if you want to play, here you go.
Code:
import time
import random
import gmpy2
from functools import lru_cache
modulo = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F
order = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
Gx = 0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798
Gy = 0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8
class Point:
def __init__(self, x=0, y=0):
self.x = x
self.y = y
PG = Point(Gx, Gy)
Z = Point(0, 0) # zero-point, infinite in real x,y-plane
def mul2(P, p=modulo):
c = (3 * P.x * P.x * pow(2 * P.y, -1, p)) % p
R = Point()
R.x = (c * c - 2 * P.x) % p
R.y = (c * (P.x - R.x) - P.y) % p
return R
def add(P, Q, p=modulo):
dx = Q.x - P.x
dy = Q.y - P.y
#c = (dy * pow(dx, -1, p)) % p
c = dy * gmpy2.invert(dx, p) % p
R = Point()
R.x = (c * c - P.x - Q.x) % p
R.y = (c * (P.x - R.x) - P.y) % p
return R
@lru_cache(maxsize=None)
def X2Y(X, p=modulo):
if p % 4 != 3:
print('prime must be 3 modulo 4')
return 0
X = (X ** 3 + 7) % p
pw = (p + 1) // 4
Y = 1
tmp = X
for w in range(256):
if (pw >> w) & 1 == 1:
Y = (Y * tmp) % p
tmp = pow(tmp, 2, p)
return Y
def compute_P_table():
P = [PG]
for k in range(255):
P.append(mul2(P[k]))
return P
P = compute_P_table()
print('P-table prepared')
def comparator(A, Ak, B, Bk):
result = set(A).intersection(set(B))
if result:
sol_kt = A.index(next(iter(result)))
sol_kw = B.index(next(iter(result)))
print('total time: %.2f sec' % (time.time() - starttime))
d = Ak[sol_kt] - Bk[sol_kw]
print('SOLVED:', d)
with open("results.txt", 'a') as file:
file.write(('%d' % (Ak[sol_kt] - Bk[sol_kw])) + "\n")
file.write("---------------\n")
return True
else:
return False
def check(P, Pindex, DP_rarity, file2save, A, Ak, B, Bk):
if P.x % DP_rarity == 0:
A.append(P.x)
Ak.append(Pindex)
with open(file2save, 'a') as file:
file.write(('%064x %d' % (P.x, Pindex)) + "\n")
return comparator(A, Ak, B, Bk)
else:
return False
def mulk(k, P=PG, p=modulo):
if k == 0:
return Z
elif k == 1:
return P
elif k % 2 == 0:
return mulk(k // 2, mul2(P, p), p)
else:
return add(P, mulk((k - 1) // 2, mul2(P, p), p), p)
def search(Nt, Nw, problem, kangoo_power, starttime):
DP_rarity = 1 << ((problem - 2 * kangoo_power) // 2 - 2)
hop_modulo = ((problem - 1) // 2) + kangoo_power
T, t, dt = [], [], []
W, w, dw = [], [], []
for k in range(Nt):
t.append((3 << (problem - 2)) + random.randint(1, (1 << (problem - 1))))
T.append(mulk(t[k]))
dt.append(0)
for k in range(Nw):
w.append(random.randint(1, (1 << (problem - 1))))
W.append(add(W0, mulk(w[k])))
dw.append(0)
print('tame and wild herds are prepared')
oldtime = time.time()
Hops, Hops_old = 0, 0
t0 = time.time()
oldtime = time.time()
starttime = oldtime
while True:
for k in range(Nt):
Hops += 1
pw = T[k].x % hop_modulo
dt[k] = 1 << pw
solved = check(T[k], t[k], DP_rarity, "tame.txt", T, t, W, w)
if solved:
return 'sol. time: %.2f sec' % (time.time() - starttime)
t[k] += dt[k]
T[k] = add(P[pw], T[k])
for k in range(Nw):
Hops += 1
pw = W[k].x % hop_modulo
dw[k] = 1 << pw
solved = check(W[k], w[k], DP_rarity, "wild.txt", W, w, T, t)
if solved:
return 'sol. time: %.2f sec' % (time.time() - starttime)
w[k] += dw[k]
W[k] = add(P[pw], W[k])
t1 = time.time()
if (t1 - t0) > 5:
print('%.3f h/s' % ((Hops - Hops_old) / (t1 - t0)))
t0 = t1
Hops_old = Hops
start = 2147483647
end = 4294967295
search_range = end - start + 1
problem = search_range.bit_length()
compreessed_public_key = "0209c58240e50e3ba3f833c82655e8725c037a2294e14cf5d73a5df8d56159de69" #Puzzle 32
kangoo_power = 3
Nt = Nw = 2 ** kangoo_power
X = int(compreessed_public_key, 16)
Y = X2Y(X % (2 ** 256))
if Y % 2 != (X >> 256) % 2:
Y = modulo - Y
X = X % (2 ** 256)
W0 = Point(X, Y)
starttime = oldtime = time.time()
Hops = 0
random.seed()
hops_list = []
N_tests = 3
for k in range(N_tests):
with open("tame.txt", 'w') as tame_file, open("wild.txt", 'w') as wild_file:
tame_file.write('')
wild_file.write('')
search_result = search(Nt, Nw, problem, kangoo_power, starttime)
print(search_result)
M, D = 0, 0
if len(hops_list) > 0:
M = sum(hops_list) * 1.0 / len(hops_list)
D = sum((xi - M) ** 2 for xi in hops_list) * 1.0 / len(hops_list)
print(M, '+/-', (D / (len(hops_list) - 1)) ** 0.5)
print('Average time to solve: %.2f sec' % ((time.time() - starttime) / N_tests))
import random
import gmpy2
from functools import lru_cache
modulo = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F
order = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
Gx = 0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798
Gy = 0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8
class Point:
def __init__(self, x=0, y=0):
self.x = x
self.y = y
PG = Point(Gx, Gy)
Z = Point(0, 0) # zero-point, infinite in real x,y-plane
def mul2(P, p=modulo):
c = (3 * P.x * P.x * pow(2 * P.y, -1, p)) % p
R = Point()
R.x = (c * c - 2 * P.x) % p
R.y = (c * (P.x - R.x) - P.y) % p
return R
def add(P, Q, p=modulo):
dx = Q.x - P.x
dy = Q.y - P.y
#c = (dy * pow(dx, -1, p)) % p
c = dy * gmpy2.invert(dx, p) % p
R = Point()
R.x = (c * c - P.x - Q.x) % p
R.y = (c * (P.x - R.x) - P.y) % p
return R
@lru_cache(maxsize=None)
def X2Y(X, p=modulo):
if p % 4 != 3:
print('prime must be 3 modulo 4')
return 0
X = (X ** 3 + 7) % p
pw = (p + 1) // 4
Y = 1
tmp = X
for w in range(256):
if (pw >> w) & 1 == 1:
Y = (Y * tmp) % p
tmp = pow(tmp, 2, p)
return Y
def compute_P_table():
P = [PG]
for k in range(255):
P.append(mul2(P[k]))
return P
P = compute_P_table()
print('P-table prepared')
def comparator(A, Ak, B, Bk):
result = set(A).intersection(set(B))
if result:
sol_kt = A.index(next(iter(result)))
sol_kw = B.index(next(iter(result)))
print('total time: %.2f sec' % (time.time() - starttime))
d = Ak[sol_kt] - Bk[sol_kw]
print('SOLVED:', d)
with open("results.txt", 'a') as file:
file.write(('%d' % (Ak[sol_kt] - Bk[sol_kw])) + "\n")
file.write("---------------\n")
return True
else:
return False
def check(P, Pindex, DP_rarity, file2save, A, Ak, B, Bk):
if P.x % DP_rarity == 0:
A.append(P.x)
Ak.append(Pindex)
with open(file2save, 'a') as file:
file.write(('%064x %d' % (P.x, Pindex)) + "\n")
return comparator(A, Ak, B, Bk)
else:
return False
def mulk(k, P=PG, p=modulo):
if k == 0:
return Z
elif k == 1:
return P
elif k % 2 == 0:
return mulk(k // 2, mul2(P, p), p)
else:
return add(P, mulk((k - 1) // 2, mul2(P, p), p), p)
def search(Nt, Nw, problem, kangoo_power, starttime):
DP_rarity = 1 << ((problem - 2 * kangoo_power) // 2 - 2)
hop_modulo = ((problem - 1) // 2) + kangoo_power
T, t, dt = [], [], []
W, w, dw = [], [], []
for k in range(Nt):
t.append((3 << (problem - 2)) + random.randint(1, (1 << (problem - 1))))
T.append(mulk(t[k]))
dt.append(0)
for k in range(Nw):
w.append(random.randint(1, (1 << (problem - 1))))
W.append(add(W0, mulk(w[k])))
dw.append(0)
print('tame and wild herds are prepared')
oldtime = time.time()
Hops, Hops_old = 0, 0
t0 = time.time()
oldtime = time.time()
starttime = oldtime
while True:
for k in range(Nt):
Hops += 1
pw = T[k].x % hop_modulo
dt[k] = 1 << pw
solved = check(T[k], t[k], DP_rarity, "tame.txt", T, t, W, w)
if solved:
return 'sol. time: %.2f sec' % (time.time() - starttime)
t[k] += dt[k]
T[k] = add(P[pw], T[k])
for k in range(Nw):
Hops += 1
pw = W[k].x % hop_modulo
dw[k] = 1 << pw
solved = check(W[k], w[k], DP_rarity, "wild.txt", W, w, T, t)
if solved:
return 'sol. time: %.2f sec' % (time.time() - starttime)
w[k] += dw[k]
W[k] = add(P[pw], W[k])
t1 = time.time()
if (t1 - t0) > 5:
print('%.3f h/s' % ((Hops - Hops_old) / (t1 - t0)))
t0 = t1
Hops_old = Hops
start = 2147483647
end = 4294967295
search_range = end - start + 1
problem = search_range.bit_length()
compreessed_public_key = "0209c58240e50e3ba3f833c82655e8725c037a2294e14cf5d73a5df8d56159de69" #Puzzle 32
kangoo_power = 3
Nt = Nw = 2 ** kangoo_power
X = int(compreessed_public_key, 16)
Y = X2Y(X % (2 ** 256))
if Y % 2 != (X >> 256) % 2:
Y = modulo - Y
X = X % (2 ** 256)
W0 = Point(X, Y)
starttime = oldtime = time.time()
Hops = 0
random.seed()
hops_list = []
N_tests = 3
for k in range(N_tests):
with open("tame.txt", 'w') as tame_file, open("wild.txt", 'w') as wild_file:
tame_file.write('')
wild_file.write('')
search_result = search(Nt, Nw, problem, kangoo_power, starttime)
print(search_result)
M, D = 0, 0
if len(hops_list) > 0:
M = sum(hops_list) * 1.0 / len(hops_list)
D = sum((xi - M) ** 2 for xi in hops_list) * 1.0 / len(hops_list)
print(M, '+/-', (D / (len(hops_list) - 1)) ** 0.5)
print('Average time to solve: %.2f sec' % ((time.time() - starttime) / N_tests))
It is about 142827.704 h/s here....
Who can solve
p = 115792089237316195423570985008687907852837564279074904382605163141518161494335
a = 1099511627776
b = 115792089237316195423570985008687907852837564279074904382605163141005436653346
c = (a-b) %p
result = 1612236468765
in pubkey
p =115792089237316195423570985008687907852837564279074904382605163141518161494335
a = 02feea6cae46d55b530ac2839f143bd7ec5cf8b266a41d6af52d5e688d9094696d
b = 02746bd76e07a0dbbcc610245439ee1db94f73b70df43bc543d4046ebe119ad6b3
c = (a-b) %p
result = 02b21dd66bfde832c2dae35688c0e15b91b274ec018e2c14e23f1ca7cb32fcca73
substract formula
p = int(2**256 - 2**32 - 977)
x1 = # fill pubkey1-x
y1= # fill pubkey1-y
x2= # fill pubkey2-x
y2= # fill pubkey2-y
dx = (x1 - x2) % p
dy = (y1 - (-y2)) % p
c = dy * gmpy2.invert(dx, p) % p
Rx = (c*c - x2 - x1) % p
Ry = (c*(x2 - Rx) - y2) % p
print (Rx , Ry)
print (hex(Rx) , hex(Ry))
if you have alternate formula for adjust with mod p, apply and check for get acurate result in pubkey
p = 115792089237316195423570985008687907852837564279074904382605163141518161494335
a = 1099511627776
b = 115792089237316195423570985008687907852837564279074904382605163141005436653346
c = (a-b) %p
result = 1612236468765
in pubkey
p =115792089237316195423570985008687907852837564279074904382605163141518161494335
a = 02feea6cae46d55b530ac2839f143bd7ec5cf8b266a41d6af52d5e688d9094696d
b = 02746bd76e07a0dbbcc610245439ee1db94f73b70df43bc543d4046ebe119ad6b3
c = (a-b) %p
result = 02b21dd66bfde832c2dae35688c0e15b91b274ec018e2c14e23f1ca7cb32fcca73
substract formula
p = int(2**256 - 2**32 - 977)
x1 = # fill pubkey1-x
y1= # fill pubkey1-y
x2= # fill pubkey2-x
y2= # fill pubkey2-y
dx = (x1 - x2) % p
dy = (y1 - (-y2)) % p
c = dy * gmpy2.invert(dx, p) % p
Rx = (c*c - x2 - x1) % p
Ry = (c*(x2 - Rx) - y2) % p
print (Rx , Ry)
print (hex(Rx) , hex(Ry))
if you have alternate formula for adjust with mod p, apply and check for get acurate result in pubkey
Would you plz be specific, like solve for what? What is expected result conditions? How result should look like, can explain how the successful result should be some how
Substraction formula original ecc with original mod P
Adjust mod P to 2 digit less for get correct pubkey as mention in pubkey result
Who can solve
p = 115792089237316195423570985008687907852837564279074904382605163141518161494335
a = 1099511627776
b = 115792089237316195423570985008687907852837564279074904382605163141005436653346
c = (a-b) %p
result = 1612236468765
in pubkey
p =115792089237316195423570985008687907852837564279074904382605163141518161494335
a = 02feea6cae46d55b530ac2839f143bd7ec5cf8b266a41d6af52d5e688d9094696d
b = 02746bd76e07a0dbbcc610245439ee1db94f73b70df43bc543d4046ebe119ad6b3
c = (a-b) %p
result = 02b21dd66bfde832c2dae35688c0e15b91b274ec018e2c14e23f1ca7cb32fcca73
substract formula
p = int(2**256 - 2**32 - 977)
x1 = # fill pubkey1-x
y1= # fill pubkey1-y
x2= # fill pubkey2-x
y2= # fill pubkey2-y
dx = (x1 - x2) % p
dy = (y1 - (-y2)) % p
c = dy * gmpy2.invert(dx, p) % p
Rx = (c*c - x2 - x1) % p
Ry = (c*(x2 - Rx) - y2) % p
print (Rx , Ry)
print (hex(Rx) , hex(Ry))
if you have alternate formula for adjust with mod p, apply and check for get acurate result in pubkey
p = 115792089237316195423570985008687907852837564279074904382605163141518161494335
a = 1099511627776
b = 115792089237316195423570985008687907852837564279074904382605163141005436653346
c = (a-b) %p
result = 1612236468765
in pubkey
p =115792089237316195423570985008687907852837564279074904382605163141518161494335
a = 02feea6cae46d55b530ac2839f143bd7ec5cf8b266a41d6af52d5e688d9094696d
b = 02746bd76e07a0dbbcc610245439ee1db94f73b70df43bc543d4046ebe119ad6b3
c = (a-b) %p
result = 02b21dd66bfde832c2dae35688c0e15b91b274ec018e2c14e23f1ca7cb32fcca73
substract formula
p = int(2**256 - 2**32 - 977)
x1 = # fill pubkey1-x
y1= # fill pubkey1-y
x2= # fill pubkey2-x
y2= # fill pubkey2-y
dx = (x1 - x2) % p
dy = (y1 - (-y2)) % p
c = dy * gmpy2.invert(dx, p) % p
Rx = (c*c - x2 - x1) % p
Ry = (c*(x2 - Rx) - y2) % p
print (Rx , Ry)
print (hex(Rx) , hex(Ry))
if you have alternate formula for adjust with mod p, apply and check for get acurate result in pubkey
Would you plz be specific, like solve for what? What is expected result conditions? How result should look like, can explain how the successful result should be some how
Who can solve
p = 115792089237316195423570985008687907852837564279074904382605163141518161494335
a = 1099511627776
b = 115792089237316195423570985008687907852837564279074904382605163141005436653346
c = (a-b) %p
result = 1612236468765
in pubkey
p =115792089237316195423570985008687907852837564279074904382605163141518161494335
a = 02feea6cae46d55b530ac2839f143bd7ec5cf8b266a41d6af52d5e688d9094696d
b = 02746bd76e07a0dbbcc610245439ee1db94f73b70df43bc543d4046ebe119ad6b3
c = (a-b) %p
result = 02b21dd66bfde832c2dae35688c0e15b91b274ec018e2c14e23f1ca7cb32fcca73
substract formula
p = int(2**256 - 2**32 - 977)
x1 = # fill pubkey1-x
y1= # fill pubkey1-y
x2= # fill pubkey2-x
y2= # fill pubkey2-y
dx = (x1 - x2) % p
dy = (y1 - (-y2)) % p
c = dy * gmpy2.invert(dx, p) % p
Rx = (c*c - x2 - x1) % p
Ry = (c*(x2 - Rx) - y2) % p
print (Rx , Ry)
print (hex(Rx) , hex(Ry))
if you have alternate formula for adjust with mod p, apply and check for get acurate result in pubkey
p = 115792089237316195423570985008687907852837564279074904382605163141518161494335
a = 1099511627776
b = 115792089237316195423570985008687907852837564279074904382605163141005436653346
c = (a-b) %p
result = 1612236468765
in pubkey
p =115792089237316195423570985008687907852837564279074904382605163141518161494335
a = 02feea6cae46d55b530ac2839f143bd7ec5cf8b266a41d6af52d5e688d9094696d
b = 02746bd76e07a0dbbcc610245439ee1db94f73b70df43bc543d4046ebe119ad6b3
c = (a-b) %p
result = 02b21dd66bfde832c2dae35688c0e15b91b274ec018e2c14e23f1ca7cb32fcca73
substract formula
p = int(2**256 - 2**32 - 977)
x1 = # fill pubkey1-x
y1= # fill pubkey1-y
x2= # fill pubkey2-x
y2= # fill pubkey2-y
dx = (x1 - x2) % p
dy = (y1 - (-y2)) % p
c = dy * gmpy2.invert(dx, p) % p
Rx = (c*c - x2 - x1) % p
Ry = (c*(x2 - Rx) - y2) % p
print (Rx , Ry)
print (hex(Rx) , hex(Ry))
if you have alternate formula for adjust with mod p, apply and check for get acurate result in pubkey
In the 30+ minutes that I wasted hammering (and subsequently trashing) a reply to this, I just updated the pkarith script to spit out the correct end points... took me just two minutes and 2 lines of code change. https://gist.github.com/ZenulAbidin/e8687d9e16189c99d192e97d37e71dbe
See how more effectively and faster I can implement stuff when I have all the info I need, clearly (emphasis on that), beforehand?
I can only work with information I have at hand (without guessing random stuff). Nowhere was it said that you had to divide max value by 32 and add that to start value to get the end value... take a look back at them yourself.
Otherwise you get stuff like a broken Kangaroo-256 with a borked hashtable lookup function.
There wouldn't have even been a flamewar if I had that info. Instead I got "0.01325 to 0.0625" which I understood to mean that the zones themselves are the start and end points. With this info, making an assumption about division at that stage would've been a guess.
And none of this was resolved until Counselor explained this important point a few posts up.
Hello.
I read the topic from the end and saw this script and discussion.
I checked how it works, but no matches are found when searching for public keys with the ranges that go in the same block in the keyhunt.
Do the public keys in the output of this script match the ranges?
It is the same person or group which solve 120 bit.
So it is not kangaroo and not bsgs.
They must know something which we do not know.
The questions is -> what kind of math they use. And second questions : I'm afraid BTC is not secure any more.
So it is not kangaroo and not bsgs.
They must know something which we do not know.
The questions is -> what kind of math they use. And second questions : I'm afraid BTC is not secure any more.
Hi there 
Congratulations to the solver (or solvers) of the puzzle #125
Congratulations to the solver (or solvers) of the puzzle #125
Hey, guys! somebody can explain me why ive got error :
this is -winfo
Code:
D:\kangaroo>kangaroo.exe -wm 125.save 1252.save
Kangaroo v2.2
MergeWork: destination argument missing
Kangaroo v2.2
MergeWork: destination argument missing
this is -winfo
Code:
Loading: 1252.save
Version : 0
DP bits : 33
Start : 10000000000000000000000000000000
Stop : 1FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
Key : 0233709EB11E0D4439A729F21C2C443DEDB727528229713F0065721BA8FA46F00E
Count : 2238135375233024 2^50.991
Time : 6.7d
DP Size : 10.0/17.0MB
DP Count : 261003 2^17.994
HT Max : 8 [@ 0074C5]
HT Min : 0 [@ 000003]
HT Avg : 1.00
HT SDev : 1.00
Kangaroos : 0 2^-inf
Loading: 125.save
Version : 0
DP bits : 33
Start : 10000000000000000000000000000000
Stop : 1FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
Key : 0233709EB11E0D4439A729F21C2C443DEDB727528229713F0065721BA8FA46F00E
Count : 1982479057551360 2^50.816
Time : 6.0d
DP Size : 9.0/29.8MB
DP Count : 231003 2^17.818
HT Max : 8 [@ 0074C5]
HT Min : 0 [@ 000003]
HT Avg : 0.88
HT SDev : 0.94
Kangaroos : 67108864 2^26.000
Version : 0
DP bits : 33
Start : 10000000000000000000000000000000
Stop : 1FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
Key : 0233709EB11E0D4439A729F21C2C443DEDB727528229713F0065721BA8FA46F00E
Count : 2238135375233024 2^50.991
Time : 6.7d
DP Size : 10.0/17.0MB
DP Count : 261003 2^17.994
HT Max : 8 [@ 0074C5]
HT Min : 0 [@ 000003]
HT Avg : 1.00
HT SDev : 1.00
Kangaroos : 0 2^-inf
Loading: 125.save
Version : 0
DP bits : 33
Start : 10000000000000000000000000000000
Stop : 1FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
Key : 0233709EB11E0D4439A729F21C2C443DEDB727528229713F0065721BA8FA46F00E
Count : 1982479057551360 2^50.816
Time : 6.0d
DP Size : 9.0/29.8MB
DP Count : 231003 2^17.818
HT Max : 8 [@ 0074C5]
HT Min : 0 [@ 000003]
HT Avg : 0.88
HT SDev : 0.94
Kangaroos : 67108864 2^26.000
MergeWork: destination argument missing = you are missing the 3rd argument.
If you are trying to merge 2 different work files, you have to tell it what to save it as; merge file1 file2 file3 = merge file1 and file2 and save it as file3
Hey, guys! somebody can explain me why ive got error :
this is -winfo
Code:
D:\kangaroo>kangaroo.exe -wm 125.save 1252.save
Kangaroo v2.2
MergeWork: destination argument missing
Kangaroo v2.2
MergeWork: destination argument missing
this is -winfo
Code:
Loading: 1252.save
Version : 0
DP bits : 33
Start : 10000000000000000000000000000000
Stop : 1FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
Key : 0233709EB11E0D4439A729F21C2C443DEDB727528229713F0065721BA8FA46F00E
Count : 2238135375233024 2^50.991
Time : 6.7d
DP Size : 10.0/17.0MB
DP Count : 261003 2^17.994
HT Max : 8 [@ 0074C5]
HT Min : 0 [@ 000003]
HT Avg : 1.00
HT SDev : 1.00
Kangaroos : 0 2^-inf
Loading: 125.save
Version : 0
DP bits : 33
Start : 10000000000000000000000000000000
Stop : 1FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
Key : 0233709EB11E0D4439A729F21C2C443DEDB727528229713F0065721BA8FA46F00E
Count : 1982479057551360 2^50.816
Time : 6.0d
DP Size : 9.0/29.8MB
DP Count : 231003 2^17.818
HT Max : 8 [@ 0074C5]
HT Min : 0 [@ 000003]
HT Avg : 0.88
HT SDev : 0.94
Kangaroos : 67108864 2^26.000
Version : 0
DP bits : 33
Start : 10000000000000000000000000000000
Stop : 1FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
Key : 0233709EB11E0D4439A729F21C2C443DEDB727528229713F0065721BA8FA46F00E
Count : 2238135375233024 2^50.991
Time : 6.7d
DP Size : 10.0/17.0MB
DP Count : 261003 2^17.994
HT Max : 8 [@ 0074C5]
HT Min : 0 [@ 000003]
HT Avg : 1.00
HT SDev : 1.00
Kangaroos : 0 2^-inf
Loading: 125.save
Version : 0
DP bits : 33
Start : 10000000000000000000000000000000
Stop : 1FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
Key : 0233709EB11E0D4439A729F21C2C443DEDB727528229713F0065721BA8FA46F00E
Count : 1982479057551360 2^50.816
Time : 6.0d
DP Size : 9.0/29.8MB
DP Count : 231003 2^17.818
HT Max : 8 [@ 0074C5]
HT Min : 0 [@ 000003]
HT Avg : 0.88
HT SDev : 0.94
Kangaroos : 67108864 2^26.000
MergeWork: destination argument missing = you are missing the 3rd argument.
If you are trying to merge 2 different work files, you have to tell it what to save it as; merge file1 file2 file3 = merge file1 and file2 and save it as file3
Hey, guys! somebody can explain me why ive got error :
this is -winfo
Code:
D:\kangaroo>kangaroo.exe -wm 125.save 1252.save
Kangaroo v2.2
MergeWork: destination argument missing
Kangaroo v2.2
MergeWork: destination argument missing
this is -winfo
Code:
Loading: 1252.save
Version : 0
DP bits : 33
Start : 10000000000000000000000000000000
Stop : 1FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
Key : 0233709EB11E0D4439A729F21C2C443DEDB727528229713F0065721BA8FA46F00E
Count : 2238135375233024 2^50.991
Time : 6.7d
DP Size : 10.0/17.0MB
DP Count : 261003 2^17.994
HT Max : 8 [@ 0074C5]
HT Min : 0 [@ 000003]
HT Avg : 1.00
HT SDev : 1.00
Kangaroos : 0 2^-inf
Loading: 125.save
Version : 0
DP bits : 33
Start : 10000000000000000000000000000000
Stop : 1FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
Key : 0233709EB11E0D4439A729F21C2C443DEDB727528229713F0065721BA8FA46F00E
Count : 1982479057551360 2^50.816
Time : 6.0d
DP Size : 9.0/29.8MB
DP Count : 231003 2^17.818
HT Max : 8 [@ 0074C5]
HT Min : 0 [@ 000003]
HT Avg : 0.88
HT SDev : 0.94
Kangaroos : 67108864 2^26.000
Version : 0
DP bits : 33
Start : 10000000000000000000000000000000
Stop : 1FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
Key : 0233709EB11E0D4439A729F21C2C443DEDB727528229713F0065721BA8FA46F00E
Count : 2238135375233024 2^50.991
Time : 6.7d
DP Size : 10.0/17.0MB
DP Count : 261003 2^17.994
HT Max : 8 [@ 0074C5]
HT Min : 0 [@ 000003]
HT Avg : 1.00
HT SDev : 1.00
Kangaroos : 0 2^-inf
Loading: 125.save
Version : 0
DP bits : 33
Start : 10000000000000000000000000000000
Stop : 1FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
Key : 0233709EB11E0D4439A729F21C2C443DEDB727528229713F0065721BA8FA46F00E
Count : 1982479057551360 2^50.816
Time : 6.0d
DP Size : 9.0/29.8MB
DP Count : 231003 2^17.818
HT Max : 8 [@ 0074C5]
HT Min : 0 [@ 000003]
HT Avg : 0.88
HT SDev : 0.94
Kangaroos : 67108864 2^26.000
MergeWork: destination argument missing = you are missing the 3rd argument.
If you are trying to merge 2 different work files, you have to tell it what to save it as; merge file1 file2 file3 = merge file1 and file2 and save it as file3
Hey, guys! somebody can explain me why ive got error :
this is -winfo
Code:
D:\kangaroo>kangaroo.exe -wm 125.save 1252.save
Kangaroo v2.2
MergeWork: destination argument missing
Kangaroo v2.2
MergeWork: destination argument missing
this is -winfo
Code:
Loading: 1252.save
Version : 0
DP bits : 33
Start : 10000000000000000000000000000000
Stop : 1FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
Key : 0233709EB11E0D4439A729F21C2C443DEDB727528229713F0065721BA8FA46F00E
Count : 2238135375233024 2^50.991
Time : 6.7d
DP Size : 10.0/17.0MB
DP Count : 261003 2^17.994
HT Max : 8 [@ 0074C5]
HT Min : 0 [@ 000003]
HT Avg : 1.00
HT SDev : 1.00
Kangaroos : 0 2^-inf
Loading: 125.save
Version : 0
DP bits : 33
Start : 10000000000000000000000000000000
Stop : 1FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
Key : 0233709EB11E0D4439A729F21C2C443DEDB727528229713F0065721BA8FA46F00E
Count : 1982479057551360 2^50.816
Time : 6.0d
DP Size : 9.0/29.8MB
DP Count : 231003 2^17.818
HT Max : 8 [@ 0074C5]
HT Min : 0 [@ 000003]
HT Avg : 0.88
HT SDev : 0.94
Kangaroos : 67108864 2^26.000
Version : 0
DP bits : 33
Start : 10000000000000000000000000000000
Stop : 1FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
Key : 0233709EB11E0D4439A729F21C2C443DEDB727528229713F0065721BA8FA46F00E
Count : 2238135375233024 2^50.991
Time : 6.7d
DP Size : 10.0/17.0MB
DP Count : 261003 2^17.994
HT Max : 8 [@ 0074C5]
HT Min : 0 [@ 000003]
HT Avg : 1.00
HT SDev : 1.00
Kangaroos : 0 2^-inf
Loading: 125.save
Version : 0
DP bits : 33
Start : 10000000000000000000000000000000
Stop : 1FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
Key : 0233709EB11E0D4439A729F21C2C443DEDB727528229713F0065721BA8FA46F00E
Count : 1982479057551360 2^50.816
Time : 6.0d
DP Size : 9.0/29.8MB
DP Count : 231003 2^17.818
HT Max : 8 [@ 0074C5]
HT Min : 0 [@ 000003]
HT Avg : 0.88
HT SDev : 0.94
Kangaroos : 67108864 2^26.000
Anyway to answer your PM I'm 80% certain about the range. I created the wallet years ago manually and was dumb enough to use it!!
That said, I think I prefer searching for it myself. If you would like to help with the setup, where it's best to rent GPUs, what version of Kangaroo to use, etc happy to pay a fee. I hope you understand, it's too much BTC to just give away the public key on a forum!
Thanks!!
You're implying that he's lying?
Do you know what i should say to you?
Do you?
I agree with you loool
Anyway to answer your PM I'm 80% certain about the range. I created the wallet years ago manually and was dumb enough to use it!!
That said, I think I prefer searching for it myself. If you would like to help with the setup, where it's best to rent GPUs, what version of Kangaroo to use, etc happy to pay a fee. I hope you understand, it's too much BTC to just give away the public key on a forum!
Thanks!!
Jump to: