keyfmt.py

#!/usr/bin/env python
#
# Read a private key from stdin and output formatted data values.
# Input one key per line either hex (64 chars) or WIF key (51 base 58 chars).
#
# The format argument can contain variables:
#
# %h = HEX privkey
# %w = WIF privkey
# %p = public key
# %a = address
#
# eg. "Address: %a\nPrivkey: %w" outputs a format like the vanitygen program
#     "a:%w" outputs a format good for importing to Electrum
# 
# This generates a new key for importing to Electrum:
#
#     hexdump -v -e '/1 "%02X"' -n 32 /dev/urandom | keyfmt "%a:%w"
#

import sys, binascii, hashlib

if len(sys.argv) < 2:
        print "Usage: %s <format string>\n\nRead a hex private key from stdin and output formatted data.\n" % sys.argv[0]
        print "These variables are supported:\n%h = HEX privkey\n%w = WIF privkey\n%p = public key\n%a = address\n" 
        print "eg. 'Address: %a\\nPrivkey: %w' outputs a format like the vanitygen program\n"
        sys.exit(1)

alphabet="123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
advanced = any(v in sys.argv[1] for v in ['%p', '%a'])

def b58encode(num, pad=''):
        out = ''
        while num >= 58:
                num,m = divmod(num, 58)
                out = alphabet[m] + out
        return pad + alphabet[num] + out

def b58hex(s58):
        num = 0L
        for (i, c) in enumerate(s58[::-1]):
                num += alphabet.find(c) * (58**i)
        return hex(num)[4:-9].upper()
        
if advanced:
        import ecdsa

        # secp256k1, http://www.oid-info.com/get/1.3.132.0.10
        _p = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2FL
        _r = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141L
        _b = 0x0000000000000000000000000000000000000000000000000000000000000007L
        _a = 0x0000000000000000000000000000000000000000000000000000000000000000L
        _Gx = 0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798L
        _Gy = 0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8L
        curve_secp256k1 = ecdsa.ellipticcurve.CurveFp( _p, _a, _b )
        generator_secp256k1 = ecdsa.ellipticcurve.Point( curve_secp256k1, _Gx, _Gy, _r )
        oid_secp256k1 = (1,3,132,0,10)
        SECP256k1 = ecdsa.curves.Curve("SECP256k1", curve_secp256k1, generator_secp256k1, oid_secp256k1 ) 

for line in sys.stdin:
        line = line.replace(' ', '')
        line = b58hex(line[:51]) if line[0] == '5' and len(line) < 64 else line[:64]
        chksum = binascii.hexlify(hashlib.sha256(hashlib.sha256(binascii.unhexlify('80'+line)).digest()).digest()[:4])
        privkey = long('80'+line+chksum, 16)
        
        if advanced:
                pubkey = chr(4) + ecdsa.SigningKey.from_secret_exponent(long(line, 16), curve=SECP256k1 ).get_verifying_key().to_string()
                pad = ""
                rmd = hashlib.new('ripemd160')
                rmd.update(hashlib.sha256(pubkey).digest())
                an = chr(0) + rmd.digest()
                for c in an:
                        if c == '\0': pad += '1'
                        else: break
                addr = long(binascii.hexlify(an + hashlib.sha256(hashlib.sha256(an).digest()).digest()[0:4]), 16)
        
        out = sys.argv[1].replace('%h', line).replace('%w', b58encode(privkey))
        if advanced:
                out = out.replace('%p', binascii.hexlify(pubkey).upper()).replace('%a', b58encode(addr, pad))
        print out.decode('string-escape')