bip38: add multiproc with bip38scanx

Author: neocogent

README

@@ -7,10 +7,13 @@ scripts:
     supernova - generate a Bitcoin black hole address matching prefix
     watchaddr - insert addresses from stdin into Electrum (2.0) watch-only wallet
     mchat - test multicast local network peer messaging
-    pwscan - simple Electrum password cracker, wild char sub. (needs pycrypto)
-    pwscanx - simple Electrum password cracker, wild char sub. (multi-processing)(needs pycrypto)
-    bip38pwd - simple BIP38 password cracker, wild char sub.
-    bip38scan - simple BIP38 password cracker, token selection
+    
+    need pycrypto ( pip install pycrypto ):
+        pwscan - simple Electrum password cracker, template char sub.
+        pwscanx - simple Electrum password cracker, template char sub., multi-processing
+        bip38pwd - simple BIP38 password cracker, template char sub.
+        bip38scan - simple BIP38 password cracker, token combination
+        bip38scanx - simple BIP38 password cracker, token combination, multi-processing
 
 greasemonkey:
     collapsetips - script to collapse ChangeTips on /r/bitcoin

scripts/bip38pwd

@@ -4,7 +4,7 @@
 #
 
 import sys, time
-import aes, hashlib, base64, binascii, ecdsa
+import hashlib, base64, binascii, ecdsa
 
 wildchar = '?'
 pwd_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"

scripts/bip38scanx

@@ -0,0 +1,130 @@
+#!/usr/bin/env python
+#
+# BIP38 password scanner with tokens
+#
+
+import sys, time, multiprocessing
+import hashlib, base64, binascii, ecdsa
+
+alphabet="123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
+
+# 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 ) 
+
+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)[2:-1].upper()
+
+def priv2pub(priv, compress=False):
+    verkey = ecdsa.SigningKey.from_secret_exponent(long(priv, 16), curve=SECP256k1 ).get_verifying_key()
+    prefix = '04' if not compress else ( '03' if verkey.pubkey.point.y() % 2 == 1 else '02' )
+    return prefix + ( '%032x' % verkey.pubkey.point.x() if compress else verkey.to_string() )
+    
+def mkaddr(pubkey):
+    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
+    return b58encode(long(binascii.hexlify(an + hashlib.sha256(hashlib.sha256(an).digest()).digest()[0:4]), 16), pad)
+    
+def bip38_decrypt(encrypted_privkey, passphrase):
+    from Crypto.Cipher import AES
+    import scrypt
+    
+    data = binascii.unhexlify("0"+b58hex(encrypted_privkey))
+    compress = '' if data[2] == '\xc0' else '01'
+    key = scrypt.hash(passphrase, data[3:7], 16384, 8, 8)
+    aes = AES.new(key[32:64])
+    priv = aes.decrypt(data[7:23]) + aes.decrypt(data[23:39])
+    priv = '%064x' % (long(binascii.hexlify(priv), 16) ^ long(binascii.hexlify(key[0:32]), 16))
+    pub = priv2pub(priv, data[2] != '\xc0')
+    if hashlib.sha256(hashlib.sha256(mkaddr(pub)).digest()).digest()[0:4] != data[3:7]:
+        return None
+    chksum = binascii.hexlify(hashlib.sha256(hashlib.sha256(binascii.unhexlify('80'+priv)).digest()).digest()[:4])
+    return b58encode(long('80'+priv+chksum+compress, 16))
+    
+def scanproc(pwd):
+    for token in tokens:
+        privkey = bip38_decrypt( sys.argv[2], pwd+token )
+        if privkey == None:
+            continue
+        else:
+            print "\nPWD:", pwd+token
+            print "KEY:", privkey
+            print "Took %.1f seconds" % (time.time() - started,)
+            sys.exit(2)
+    
+def pwd_scan(pwd, depth):
+    global done, procs
+    if len(procs) == max_procs:
+        for p in procs:
+            p.join()
+            if p.exitcode == 2:
+                done = True
+        procs = []
+    if not done:
+        if depth == 0:
+            proc = multiprocessing.Process(target = scanproc, args = (pwd,))
+            procs.append(proc)
+            proc.start()
+        else:
+            for token in tokens:
+                pwd_scan(pwd+token, depth-1)
+
+if __name__ == '__main__':
+    
+    max_procs = multiprocessing.cpu_count()
+    procs = []
+    done = False   
+     
+    if len(sys.argv) < 3:
+        print "BIP38 password scanner (multi-processing)"
+        print "Reads tokens from file and tries every combination as password for BIP38 key"
+        print "Default depth is 6. ie. scan up to 6 token combinations."
+        print "Usage: %s <token file> <BIP38 encoded key> [depth]\n" % sys.argv[0]
+        sys.exit(0)
+    
+    with open(sys.argv[1]) as f:
+        tokens = f.read()
+    tokens = tokens.split()
+    
+    started = time.time()
+    depth = int(sys.argv[3]) if len(sys.argv) > 3 else 6
+    for n in range(depth):
+        pwd_scan("", n)
+    
+    for p in procs:
+        p.join()
+        if p.exitcode == 2:
+            done = True
+                            
+    if not done:
+        print "Password not found"
+
+
+    
+
+
+
+

scripts/pwscan

@@ -14,7 +14,6 @@ def sha256(x):
 
 def pwd_subst(pwd):
     if pwd.count(wildchar) == 1:
-        sys.stdout.flush()
         p = pwd.find(wildchar)
         for c in pwd_chars:
             try:

scripts/pwscanx

@@ -44,7 +44,6 @@ def pwd_subst(pwd):
         procs = []
     if not done:
         if pwd.count(wildchar) <= 2:
-            sys.stdout.flush()
             proc = multiprocessing.Process(target = scanproc, args = (pwd,))
             procs.append(proc)
             proc.start()