Quote from: COBRAS on Today at 01:54:15 PM

Quote from: Etar on Today at 08:25:03 AM

Quote from: COBRAS on Today at 02:27:22 AM

how Etar do it this Huh

any body know how to get part of privkey(pubkey) in range 2**80 , use 2**361 ?

Here is an example of a script that will allow you to learn how to work with points:

Code:

# (Gx,Gy) is the secp256k1 generator point
Gx=0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798
Gy=0x483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8
n=0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141
p = 2**256 - 2**32 - 977
import operator
import math

def inverse(x, p):
   """
   Calculate the modular inverse of x ( mod p )
   the modular inverse is a number such that:
   (inverse(x, p) * x) % p == 1
   you could think of this as: 1/x
   """

I don't know who this guy is retarded or who answers him lol
   inv1 = 1
   inv2 = 0
   n=1
   while p != 1 and p!=0:
   quotient = x // p
   inv1, inv2 = inv2, inv1 - inv2 * quotient
   x, p = p, x % p
   n = n+1

   return inv2

def dblpt(pt, p):
   """
   Calculate pt+pt = 2*pt
   """
   if pt is None:
   return None
   (x,y)= pt
   if y==0:
   return None

   slope= 3*pow(x,2,p)*pow(2*y,p-2,p)
   xsum= pow(slope,2,p)-2*x
   ysum= slope*(x-xsum)-y

   return (xsum%p, ysum%p)

def addpt(p1,p2, p):
   """
   Calculate p1+p2
   """
   if p1 is None or p2 is None:
   return None
   (x1,y1)= p1
   (x2,y2)= p2
   if x1==x2:
   return dblpt(p1, p)

   # calculate (y1-y2)/(x1-x2) modulus p

   slope=(y1-y2)*pow(x1-x2,p-2,p)
   xsum= pow(slope,2,p)-(x1+x2)
   ysum= slope*(x1-xsum)-y1


   return (xsum%p, ysum%p)

def ptmul(pt,a, p):
   """
   Scalar multiplication: calculate pt*a
   basically adding pt to itself a times
   """
   scale= pt
   acc=None
   while a:
   if a&1:
   if acc is None:
   acc= scale
   else:
   acc= addpt(acc,scale, p)

   scale= dblpt(scale, p)
   a >>= 1
   return acc

def ptdiv(pt,a,p,n):
   divpt=inverse(a, n)%n
   return ptmul(pt, divpt, p)

def isoncurve(pt,p):
   """
   returns True when pt is on the secp256k1 curve
   """
   (x,y)= pt
   return (y**2 - x**3 - 7)%p == 0

def getuncompressedpub(compressed_key):
   """
   returns uncompressed public key
   """
   y_parity = int(compressed_key[:2]) - 2
   if y_parity>1:
   #it is uncompresse dpub
   x = int(compressed_key[2:66], 16)
   y = int(compressed_key[66:130], 16)
   return (x,y)

   x = int(compressed_key[2:], 16)
   a = (pow(x, 3, p) + 7) % p
   y = pow(a, (p+1)//4, p)
   if y % 2 != y_parity:
   y = -y % p
   return (x,y)

def compresspub(uncompressed_key):
   """
   returns uncompressed public key
   """
   (x,y)=uncompressed_key
   y_parity = y&1
   head='02'
   if y_parity ==1:
   head='03'
   compressed_key = head+'{:064x}'.format(x)
   return compressed_key


rangeBegin = 0x659756abf6c17ca70e0000000000000000000140be6ddd93e441f8d4b4a85653b20b4cdcc5c748207a0daa16191d07a425d8080c276f9412472e0429e61bc355
rangeEnd = 0x659756abf6c17ca70fffffffffffffffffffff40be6ddd93e441f8d4b4a85653b20b4cdcc5c748207a0daa16191d07a425d8080c276f9412472e0429e61bc355
pub_compressed = '03a61fc84b6429f07fc0edf25265ef7a0ced3cd9a0edea85e9f58b50b5d73f66e7'
Bits = 361

(pubx,puby) = getuncompressedpub(pub_compressed)
(x,y) = ptmul((Gx,Gy),rangeBegin,p)
#substract rangeBegin from public key
(Shiftpubx,Shiftpuby) = addpt((pubx,puby), (x,(p-y)%p), p)
print ("Shifted pub> ",compresspub((Shiftpubx,Shiftpuby)))
#pub / (2**361)
(SPubx,SPuby) = ptdiv((Shiftpubx,Shiftpuby),2**361,p,n)
print ("Pub> ",compresspub((SPubx,SPuby)))

#Convert private key
kangarooPrivKey=0x2d56cbf370cbeef9e80a
RealPrivKey = (kangarooPrivKey * (2**361) + rangeBegin ) % n
print ("Key> %x"% RealPrivKey)

Thank you

Quote from: farshadbbb on Today at 01:54:03 PM

maybe explain how use bsgs squence mode?

yes, and how Etar soft work with 1 pubkey, not will all 1024 pubs then divide to 1024. I seen screen of work a soft, sequence mode work with 1 pibkey.

interesting

Quote

# (Gx,Gy) is the secp256k1 generator point
Gx=0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798
Gy=0x483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8
n=0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141
p = 2**256 - 2**32 - 977
import operator
import math

def inverse(x, p):
   """
   Calculate the modular inverse of x ( mod p )
   the modular inverse is a number such that:
   (inverse(x, p) * x) % p == 1
   you could think of this as: 1/x
   """
   inv1 = 1
   inv2 = 0
   n=1
   while p != 1 and p!=0:
   quotient = x // p
   inv1, inv2 = inv2, inv1 - inv2 * quotient
   x, p = p, x % p
   n = n+1

   return inv2

def dblpt(pt, p):
   """
   Calculate pt+pt = 2*pt
   """
   if pt is None:
   return None
   (x,y)= pt
   if y==0:
   return None

   slope= 3*pow(x,2,p)*pow(2*y,p-2,p)
   xsum= pow(slope,2,p)-2*x
   ysum= slope*(x-xsum)-y

   return (xsum%p, ysum%p)

def addpt(p1,p2, p):
   """
   Calculate p1+p2
   """
   if p1 is None or p2 is None:
   return None
   (x1,y1)= p1
   (x2,y2)= p2
   if x1==x2:
   return dblpt(p1, p)

   # calculate (y1-y2)/(x1-x2) modulus p

   slope=(y1-y2)*pow(x1-x2,p-2,p)
   xsum= pow(slope,2,p)-(x1+x2)
   ysum= slope*(x1-xsum)-y1


   return (xsum%p, ysum%p)

def ptmul(pt,a, p):
   """
   Scalar multiplication: calculate pt*a
   basically adding pt to itself a times
   """
   scale= pt
   acc=None
   while a:
   if a&1:
   if acc is None:
   acc= scale
   else:
   acc= addpt(acc,scale, p)

   scale= dblpt(scale, p)
   a >>= 1
   return acc

def ptdiv(pt,a,p,n):
   divpt=inverse(a, n)%n
   return ptmul(pt, divpt, p)

def isoncurve(pt,p):
   """
   returns True when pt is on the secp256k1 curve
   """
   (x,y)= pt
   return (y**2 - x**3 - 7)%p == 0

def getuncompressedpub(compressed_key):
   """
   returns uncompressed public key
   """
   y_parity = int(compressed_key[:2]) - 2
   if y_parity>1:
   #it is uncompresse dpub
   x = int(compressed_key[2:66], 16)
   y = int(compressed_key[66:130], 16)
   return (x,y)

   x = int(compressed_key[2:], 16)
   a = (pow(x, 3, p) + 7) % p
   y = pow(a, (p+1)//4, p)
   if y % 2 != y_parity:
   y = -y % p
   return (x,y)

def compresspub(uncompressed_key):
   """
   returns uncompressed public key
   """
   (x,y)=uncompressed_key
   y_parity = y&1
   head='02'
   if y_parity ==1:
   head='03'
   compressed_key = head+'{:064x}'.format(x)
   return compressed_key


rangeBegin =0x900# 0x659756abf6c17ca70e0000000000000000000140be6ddd93e441f8d4b4a85653b20b4cdcc5c74 8207a0daa16191d07a425d8080c276f9412472e0429e61bc355
rangeEnd = 0x1000# 0x659756abf6c17ca70fffffffffffffffffffff40be6ddd93e441f8d4b4a85653b20b4cdcc5c74 8207a0daa16191d07a425d8080c276f9412472e0429e61bc355
pub_compressed = "03175e159f728b865a72f99cc6c6fc846de0b93833fd2222ed73fce5b551e5b739"
Bits = 0x1000

(pubx,puby) = getuncompressedpub(pub_compressed)
(x,y) = ptmul((Gx,Gy),rangeBegin,p)
#substract rangeBegin from public key
(Shiftpubx,Shiftpuby) = addpt((pubx,puby), (x,(p-y)%p), p)
print ("Shifted pub> ",compresspub((Shiftpubx,Shiftpuby)))
#pub / (2**361)
(SPubx,SPuby) = ptdiv((Shiftpubx,Shiftpuby),2**23,p,n)
print ("Pub> ",compresspub((SPubx,SPuby)))

#Convert private key
kangarooPrivKey=0x700
RealPrivKey = (kangarooPrivKey * (2**23) + rangeBegin ) % n
print ("Key> %x"% RealPrivKey)

result:

Code:

Shifted pub> 026f12d86c1160191443c5f56ec6c2999edfa58e345e1534e650ed09523d82824c

./calculatefromkey 1000
privatekey: 0000000000000000000000000000000000000000000000000000000000001000
publickey compressed: 03175e159f728b865a72f99cc6c6fc846de0b93833fd2222ed73fce5b551e5b739

./calculatefromkey 700
privatekey: 0000000000000000000000000000000000000000000000000000000000000700
publickey compressed: 026f12d86c1160191443c5f56ec6c2999edfa58e345e1534e650ed09523d82824c

then put shifted key to input of a scrypt, result smaler again

rangeBegin =100
pub_compressed = "03779bd0a11d17ea0e00a6addbc6dbb9690ef24ff6ed5f3cddb2c3abcf04d409e0"

Shifted pub> 02540f37a73add0efafa3713cfc198fb26c6134bcf12eac07e9e2c4501caee8a44 <<< priv 0xf38

and again:

Shifted pub> 02798457977876ce1a77d889edc7fc1213774e3276fd9525bd6168305a0ddbc6a4 << priv ed4

Thank you for "nice toy" Etar Wink