Topic: Question about public key (Read 1006 times)

# bitaddr.py - print bitcoin addresses given hex private key
# As a bonus do brainwallet encoding too

# Incorporates code from ...

# jackjack's pywallet.py
# https://github.com/jackjack-jj/pywallet

# https://bitcointalk.org/index.php?topic=23241.0

import hashlib

# Code from pywallet.py for bas58 encoding

__b58chars = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
__b58base = len(__b58chars)

def b58encode(v):
	""" encode v, which is a string of bytes, to base58.		
	"""

	long_value = 0L
	for (i, c) in enumerate(v[::-1]):
		long_value += (256**i) * ord(c)

	result = ''
	while long_value >= __b58base:
		div, mod = divmod(long_value, __b58base)
		result = __b58chars[mod] + result
		long_value = div
	result = __b58chars[long_value] + result

	# Bitcoin does a little leading-zero-compression:
	# leading 0-bytes in the input become leading-1s
	nPad = 0
	for c in v:
		if c == '\0': nPad += 1
		else: break

	return (__b58chars[0]*nPad) + result

def b58decode(v, length):
	""" decode v into a string of len bytes
	"""
	long_value = 0L
	for (i, c) in enumerate(v[::-1]):
		long_value += __b58chars.find(c) * (__b58base**i)

	result = ''
	while long_value >= 256:
		div, mod = divmod(long_value, 256)
		result = chr(mod) + result
		long_value = div
	result = chr(long_value) + result

	nPad = 0
	for c in v:
		if c == __b58chars[0]: nPad += 1
		else: break

	result = chr(0)*nPad + result
	if length is not None and len(result) != length:
		return None

	return result

# end of bitcointools base58 implementation

# https://bitcointalk.org/index.php?topic=23241.0
# Actually this is also from pywallet.py

class CurveFp( object ):
		def __init__( self, p, a, b ):
		 	self.__p = p
		 	self.__a = a
		 	self.__b = b

		def p( self ):
		 	return self.__p

		def a( self ):
		 	return self.__a

		def b( self ):
		 	return self.__b

		def contains_point( self, x, y ):
		 	return ( y * y - ( x * x * x + self.__a * x + self.__b ) ) % self.__p == 0

class Point( object ):
		def __init__( self, curve, x, y, order = None ):
		 	self.__curve = curve
		 	self.__x = x
		 	self.__y = y
		 	self.__order = order
		 	if self.__curve: assert self.__curve.contains_point( x, y )
		 	if order: assert self * order == INFINITY
	
		def __add__( self, other ):
		 	if other == INFINITY: return self
		 	if self == INFINITY: return other
		 	assert self.__curve == other.__curve
		 	if self.__x == other.__x:
		 	 	if ( self.__y + other.__y ) % self.__curve.p() == 0:
		 	 	 	return INFINITY
		 	 	else:
		 	 	 	return self.double()

		 	p = self.__curve.p()
		 	l = ( ( other.__y - self.__y ) * \
		 	 	 	 	inverse_mod( other.__x - self.__x, p ) ) % p
		 	x3 = ( l * l - self.__x - other.__x ) % p
		 	y3 = ( l * ( self.__x - x3 ) - self.__y ) % p
		 	return Point( self.__curve, x3, y3 )

		def __mul__( self, other ):
		 	def leftmost_bit( x ):
		 	 	assert x > 0
		 	 	result = 1L
		 	 	while result <= x: result = 2 * result
		 	 	return result / 2

		 	e = other
		 	if self.__order: e = e % self.__order
		 	if e == 0: return INFINITY
		 	if self == INFINITY: return INFINITY
		 	assert e > 0
		 	e3 = 3 * e
		 	negative_self = Point( self.__curve, self.__x, -self.__y, self.__order )
		 	i = leftmost_bit( e3 ) / 2
		 	result = self
		 	while i > 1:
		 	 	result = result.double()
		 	 	if ( e3 & i ) != 0 and ( e & i ) == 0: result = result + self
		 	 	if ( e3 & i ) == 0 and ( e & i ) != 0: result = result + negative_self
		 	 	i = i / 2
		 	return result

		def __rmul__( self, other ):
		 	return self * other

		def __str__( self ):
		 	if self == INFINITY: return "infinity"
		 	return "(%d,%d)" % ( self.__x, self.__y )

		def double( self ):
		 	if self == INFINITY:
		 	 	return INFINITY

		 	p = self.__curve.p()
		 	a = self.__curve.a()
		 	l = ( ( 3 * self.__x * self.__x + a ) * \
		 	 	 	 	inverse_mod( 2 * self.__y, p ) ) % p
		 	x3 = ( l * l - 2 * self.__x ) % p
		 	y3 = ( l * ( self.__x - x3 ) - self.__y ) % p
		 	return Point( self.__curve, x3, y3 )

		def x( self ):
		 	return self.__x

		def y( self ):
		 	return self.__y

		def curve( self ):
		 	return self.__curve
		
		def order( self ):
		 	return self.__order
		 	
INFINITY = Point( None, None, None )

def inverse_mod( a, m ):
		if a < 0 or m <= a: a = a % m
		c, d = a, m
		uc, vc, ud, vd = 1, 0, 0, 1
		while c != 0:
		 	q, c, d = divmod( d, c ) + ( c, )
		 	uc, vc, ud, vd = ud - q*uc, vd - q*vc, uc, vc
		assert d == 1
		if ud > 0: return ud
		else: return ud + m

# secp256k1
_p = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2FL
_r = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141L
_b = 0x0000000000000000000000000000000000000000000000000000000000000007L
_a = 0x0000000000000000000000000000000000000000000000000000000000000000L
_Gx = 0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798L
_Gy = 0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8L

class Signature( object ):
		def __init__( self, r, s ):
		 	self.r = r
		 	self.s = s
		 	
class Public_key( object ):
		def __init__( self, generator, point ):
		 	self.curve = generator.curve()
		 	self.generator = generator
		 	self.point = point
		 	n = generator.order()
		 	if not n:
		 	 	raise RuntimeError, "Generator point must have order."
		 	if not n * point == INFINITY:
		 	 	raise RuntimeError, "Generator point order is bad."
		 	if point.x() < 0 or n <= point.x() or point.y() < 0 or n <= point.y():
		 	 	raise RuntimeError, "Generator point has x or y out of range."

		def verifies( self, hash, signature ):
		 	G = self.generator
		 	n = G.order()
		 	r = signature.r
		 	s = signature.s
		 	if r < 1 or r > n-1: return False
		 	if s < 1 or s > n-1: return False
		 	c = inverse_mod( s, n )
		 	u1 = ( hash * c ) % n
		 	u2 = ( r * c ) % n
		 	xy = u1 * G + u2 * self.point
		 	v = xy.x() % n
		 	return v == r

class Private_key( object ):
		def __init__( self, public_key, secret_multiplier ):
		 	self.public_key = public_key
		 	self.secret_multiplier = secret_multiplier

		def der( self ):
		 	hex_der_key = '06052b8104000a30740201010420' + \
		 	 	 	 	 	 	 	 	'%064x' % self.secret_multiplier + \
		 	 	 	 	 	 	 	 	'a00706052b8104000aa14403420004' + \
		 	 	 	 	 	 	 	 	'%064x' % self.public_key.point.x() + \
		 	 	 	 	 	 	 	 	'%064x' % self.public_key.point.y()
		 	return hex_der_key.decode('hex')

		def sign( self, hash, random_k ):
		 	G = self.public_key.generator
		 	n = G.order()
		 	k = random_k % n
		 	p1 = k * G
		 	r = p1.x()
		 	if r == 0: raise RuntimeError, "amazingly unlucky random number r"
		 	s = ( inverse_mod( k, n ) * \
		 	 	 	 	( hash + ( self.secret_multiplier * r ) % n ) ) % n
		 	if s == 0: raise RuntimeError, "amazingly unlucky random number s"
		 	return Signature( r, s )

curve_256 = CurveFp( _p, _a, _b )
generator_256 = Point( curve_256, _Gx, _Gy, _r )
g = generator_256

def hexprivkey2addr(privkey_hex):
	print privkey_hex, " priv key HEX"

	# Encode the private key in WIF see https://en.bitcoin.it/wiki/Base58Check_encoding

	data_hex = "80" + privkey_hex
	data_bin = data_hex.decode('hex')

	hash = hashlib.sha256(hashlib.sha256(data_bin).digest()).digest()
	sha_hex = hash.encode('hex_codec')

	step2_hex = data_hex + sha_hex[:8]

	privkey = b58encode(step2_hex.decode('hex'))
	print privkey, " private key WIF"

	# Now print the compressed WIF private key
	# bitaddress.org appends 01 so try that ...

	data_hex = "80" + privkey_hex + "01"
	data_bin = data_hex.decode('hex')

	hash = hashlib.sha256(hashlib.sha256(data_bin).digest()).digest()
	sha_hex = hash.encode('hex_codec')

	step2_hex = data_hex + sha_hex[:8]

	privkey = b58encode(step2_hex.decode('hex'))
	print privkey, " private key WIF (comp)"
	
	
	# ===========================================
	# The next step is to convert to a public key
	# ===========================================
	
	secret = int(privkey_hex,16)	# Need this as decimal number

	# generate pubkey
	pubkey = Public_key( g, g * secret )
	# print 'pubkey', hex(pubkey.point.x()), hex(pubkey.point.y())
	
	# This is clunky, there is probably a better way ...
	x_hex = hex(pubkey.point.x())
	x_hex = x_hex[2:]	# Remove leading 0x
	x_hex = x_hex[:-1]	# Remove trailing L
	# Pad with leading 0's to 64 chars...
	x_hex = x_hex.zfill(64)
	# print "x", x_hex
	y_hex = hex(pubkey.point.y())
	y_hex = y_hex[2:]	# Remove leading 0x
	y_hex = y_hex[:-1]	# Remove trailing L
	# Probably need to pad with leading 0's to 64 chars...
	y_hex = y_hex.zfill(64)
	# print "y", y_hex
	
	pubkey_hex = "04" + x_hex + y_hex
	print pubkey_hex, " public key"
	
	# ==================
	# Address generation
	# ==================
	
	pubkey = pubkey_hex

	data_bin = pubkey.decode('hex')

	# First step is a SHA256
	data_bin = hashlib.sha256(data_bin).digest()

	# Second step is RIPEMD160
	hash = hashlib.new('ripemd160')
	hash.update(data_bin)
	hash_digest = hash.digest()
	hash_hex = hash.hexdigest()

	print hash_hex + "  uncompressed hash (pubkey)"

	# Now encode the address

	data_hex = "00" + hash_hex	# 00 is version byte, could also be 05
	data_bin = data_hex.decode('hex')

	hash = hashlib.sha256(hashlib.sha256(data_bin).digest()).digest()
	sha_hex = hash.encode('hex_codec')
	step2_hex = data_hex + sha_hex[:8]

	print b58encode(step2_hex.decode('hex')), " address"

	# ============================================================================================
	# Now do the same for the COMPRESSED public key (see https://bitcointalk.org/index.php?topic=205490.0)
	# ============================================================================================

	lastchar = pubkey[-2:]
	val = lastchar.decode('hex')
	if (ord(val)%2):
		# print "odd"
		xpubkey = "03" + pubkey[2:66]	
	else:
		# print "even"
		xpubkey = "02" + pubkey[2:66]	

	print xpubkey + "  comp pubkey"

	data_bin = xpubkey.decode('hex')

	# First step is a SHA256
	data_bin = hashlib.sha256(data_bin).digest()

	# Second step is RIPEMD160
	hash = hashlib.new('ripemd160')
	hash.update(data_bin)
	hash_digest = hash.digest()
	hash_hex = hash.hexdigest()		# Saves the encoding step

	print hash_hex + "  hash (compressed pubkey)"

	# Now encode the address

	data_hex = "00" + hash_hex	# 00 is version byte, could also be 05
	data_bin = data_hex.decode('hex')

	hash = hashlib.sha256(hashlib.sha256(data_bin).digest()).digest()
	sha_hex = hash.encode('hex_codec')
	step2_hex = data_hex + sha_hex[:8]

	print b58encode(step2_hex.decode('hex')), " compressed address"
	
def brainwallet(keyphrase):
	print "keyphrase=[" + keyphrase + "]"
	privkey_bin = hashlib.sha256(keyphrase).digest()		# Single sha256 (standard brain algorithm)
	# privkey_bin = hashlib.sha256(privkey_bin).digest()	# Double sha256 (not useful)

	# privkey_hex = hashlib.sha256(keyphrase).hexdigest()	# Can generate hex directly
	privkey_hex = privkey_bin.encode('hex_codec')			# Alternatively from bin
	hexprivkey2addr(privkey_hex)
	
	# ============================= main ==============================
if __name__ == "__main__":
	# Examples
	hexprivkey2addr("0000000000000000000000000000000000000000000000000000000000000001")
	print
	hexprivkey2addr("00000000000000000000000000000000000000000000000000000000000000b6")	# Has a 11 prefix address
	print
	hexprivkey2addr("deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef")
	print
	brainwallet("correct horse battery staple")