input                        : 364418013028066184840389067627669083066973950082174194140176493054\
                                 21238822064/odd
network                      : Bitcoin mainnet
symbol                       : BTC
public pair x                : 36441801302806618484038906762766908306697395008217419414017649305421238822064
public pair y                : 106819920335407981491505420347768958799539175113579525933191638145241450448183
 x as hex                    : 5091541f5851647a93df0c14152a4516169b5bd6acf793dee8c9dfa27710e4b0
 y as hex                    : ec29eeaf3d880023f13d2608200ec283c971081ee88ec05247bf6d65b57e8537
y parity                     : odd
key pair as sec              : 035091541f5851647a93df0c14152a4516169b5bd6acf793dee8c9dfa27710e4b0
 uncompressed                : 045091541f5851647a93df0c14152a4516169b5bd6acf793dee8c9dfa27710e4b0\
                                 ec29eeaf3d880023f13d2608200ec283c971081ee88ec05247bf6d65b57e8537
hash160                      : 1182656ec95539347711226db2dbd34b73126c22
 uncompressed                : 3b2e26fcd8888c57d99652937ac9e975e9f64dd7
Bitcoin address              : 12bahMGWAnSEYS3PKURvhScm8GmZhejY7t
Bitcoin address uncompressed : 16PvA358rPPhyirFyko9zRptKWL69EinoN
Bitcoin segwit address       : bc1qzxpx2mkf25ungac3yfkm9k7nfde3ympzxk6sqj
p2sh segwit                  : 3EZXJeaZVsF1eFFXyLGHZ6CBn1ctwC9fHx
 corresponding p2sh script   : 00141182656ec95539347711226db2dbd34b73126c22

#!/usr/bin/python

#################################################################################
#                                                                               #
#.______               _______.  ______     ___      .__   __.                  #
#|   _  \             /       | /      |   /   \     |  \ |  |                  #
#|  |_)  |    ______ |   (----`|  ,----'  /  ^  \    |   \|  |                  #
#|      /    |______| \   \    |  |      /  /_\  \   |  . `  |                  #
#|  |\  \----.    .----)   |   |  `----./  _____  \  |  |\   |                  #
#| _| `._____|    |_______/     \______/__/     \__\ |__| \__|  v0.2.0          #
#                                                                               #
#GNU PL - 2015 - ca333  (modified by simcity4242)                                                           #
#                                                                               #
#USE AT OWN RISK!                                                               #
#################################################################################

import json
import urllib2
import time
import sys

#for some reason blockchain.info api-chain is 59711 blocks short..
#blockstart = 170399
#blockstart += 59711
#blockcount = urllib2.urlopen("https://blockchain.info/en/q/getblockcount").read()

def rscan(addr):
        """Check address for duplicated r values."""
        # TODO: add BCI API check address

        print "WELCOME TO R-scan v0.1.2!"
        print "ADDRESS-R-SCAN: "

        urladdr = 'https://blockchain.info/address/%s?format=json&offset=%s'

        ###control api-url
        #print str(urladdr[:-22] % addr)

        addrdata = json.load(urllib2.urlopen(urladdr % (addr, '0')))
        ntx = addrdata['n_tx']
        print "Data for pubkey: " + str(addr) + " has " + str(addrdata['n_tx']).center(6) + "Tx%s" % 's'[ntx==1:]
        #print "number of txs: " + str(addrdata['n_tx'])

        #tx-details:

        txs = []
        for i in range(0, ntx//50 + 1):
                sys.stderr.write("Fetching Txs from offset\t%s\n" % str(i*50))
                jdata = json.load(urllib2.urlopen(urladdr % (addr, str(i*50))))
                txs.extend(jdata['txs'])

        #assert len(txs) == ntx
        addrdata['txs'] = txs


        y = 0
        inputs = []
        while y < ntx:
                #print "#################################################################################"
                #print "TX nr :" + str(y+1)
                #print "hash: " + str(addrdata['txs'][y]['hash'])
                #print "number of inputs: " + str(addrdata['txs'][y]['vin_sz'])
                #only if
                        #if addrdata['txs'][y]['vin_sz'] > 1:
                zy = 0
                while zy < addrdata['txs'][y]['vin_sz']:
                        print "Input-ScriptNR " + str(zy+1) + " :" + str(addrdata['txs'][y]['inputs'][zy]['script'])
                        inputs.append(addrdata['txs'][y]['inputs'][zy]['script'])
                        zy += 1
                y += 1

        xi = 0
        zi = 1
        lenx = len(inputs)
        alert = 0

        bad = []
        #compare the sig values in each input script
        while xi < lenx-1:
                x = 0
                while x < lenx-zi:
                        if inputs[xi][10:74] == inputs[x+zi][10:74]:
                                print "In Input NR: " + str(xi) + "[global increment] " + str(inputs[xi])
                                print('\a')
                                print "Resued R-Value: "
                                print inputs[x+zi]
                                bad.append((int(x), str(inputs[x+zi][10:74])))
                                alert += 1
                        x += 1
                        zi += 1
                xi += 1

        #check duplicates
        #alert when everything ok

        if alert < 1:
                print "Good pubKey. No problems."
        else:
                print "Address %s has %d reused R value%s!" % (addr, len(bad), "s"[len(bad)==1:])
                return bad

if __name__ == '__main__':
        from sys import argv
        print """python rscan.py 1BFhrfTTZP3Nw4BNy4eX4KFLsn9ZeijcMm"""
        if len(argv) == 1:
                addr = raw_input("Enter Bitcoin address eg 1BFhrfTTZP3Nw4BNy4eX4KFLsn9ZeijcMm")
        elif len(argv) == 2 and isinstance(argv[1], basestring):
                addr = str(argv[1])
        rscan(addr)

# 9ec4bc49e828d924af1d1029cacf709431abbde46d59554b62bc270e3b29c4b1

#!/usr/bin/python

#################################################################################
#                                                                               #
#.______               _______.  ______     ___      .__   __.                  #
#|   _  \             /       | /      |   /   \     |  \ |  |                  #
#|  |_)  |    ______ |   (----`|  ,----'  /  ^  \    |   \|  |                  #
#|      /    |______| \   \    |  |      /  /_\  \   |  . `  |                  #
#|  |\  \----.    .----)   |   |  `----./  _____  \  |  |\   |                  #
#| _| `._____|    |_______/     \______/__/     \__\ |__| \__|  v0.2.0          #
#                                                                               #
#GNU PL - 2015 - ca333  (modified by simcity4242)							    #
#                                                                               #
#USE AT OWN RISK!                                                               #
#################################################################################

import json
import urllib2
import time
import sys

#for some reason blockchain.info api-chain is 59711 blocks short..
#blockstart = 170399
#blockstart += 59711
#blockcount = urllib2.urlopen("https://blockchain.info/en/q/getblockcount").read()

def rscan(addr):
	"""Check address for duplicated r values."""
	# TODO: add BCI API check address

	print "WELCOME TO R-scan v0.1.2!"
	print "ADDRESS-R-SCAN: "
	
	urladdr = 'https://blockchain.info/address/%s?format=json&offset=%s'

	###control api-url
	#print str(urladdr[:-22] % addr)

	addrdata = json.load(urllib2.urlopen(urladdr % (addr, '0')))
	ntx = addrdata['n_tx']
	print "Data for pubkey: " + str(addr) + " has " + str(addrdata['n_tx']).center(6) + "Tx%s" % 's'[ntx==1:]
	#print "number of txs: " + str(addrdata['n_tx'])

	#tx-details:

	txs = []
	for i in range(0, ntx//50 + 1):
		sys.stderr.write("Fetching Txs from offset\t%s\n" % str(i*50))
		jdata = json.load(urllib2.urlopen(urladdr % (addr, str(i*50))))
		txs.extend(jdata['txs'])	

	#assert len(txs) == ntx
	addrdata['txs'] = txs


	y = 0
	inputs = []
	while y < ntx:	
		#print "#################################################################################"
		#print "TX nr :" + str(y+1)
		#print "hash: " + str(addrdata['txs'][y]['hash'])
		#print "number of inputs: " + str(addrdata['txs'][y]['vin_sz'])
		#only if
			#if addrdata['txs'][y]['vin_sz'] > 1:
		zy = 0
		while zy < addrdata['txs'][y]['vin_sz']:
			print "Input-ScriptNR " + str(zy+1) + " :" + str(addrdata['txs'][y]['inputs'][zy]['script'])
			inputs.append(addrdata['txs'][y]['inputs'][zy]['script'])
			zy += 1
		y += 1

	xi = 0
	zi = 1
	lenx = len(inputs)
	alert = 0
	
	bad = []
	#compare the sig values in each input script
	while xi < lenx-1:
		x = 0
		while x < lenx-zi:
			if inputs[xi][10:74] == inputs[x+zi][10:74]:
				print "In Input NR: " + str(xi) + "[global increment] " + str(inputs[xi])
				print('\a')
				print "Resued R-Value: "
				print inputs[x+zi]
				bad.append((int(x), str(inputs[x+zi][10:74])))
				alert += 1
			x += 1
			zi += 1
		xi += 1

	#check duplicates
	#alert when everything ok

	if alert < 1:
		print "Good pubKey. No problems."
	else:
		print "Address %s has %d reused R value%s!" % (addr, len(bad), "s"[len(bad)==1:])
		return bad
		
if __name__ == '__main__':
	from sys import argv
	print """python rscan.py 1BFhrfTTZP3Nw4BNy4eX4KFLsn9ZeijcMm"""
	if len(argv) == 1:
		addr = raw_input("Enter Bitcoin address eg 1BFhrfTTZP3Nw4BNy4eX4KFLsn9ZeijcMm")
	elif len(argv) == 2 and isinstance(argv[1], basestring):
		addr = str(argv[1])
	rscan(addr)
	
# 9ec4bc49e828d924af1d1029cacf709431abbde46d59554b62bc270e3b29c4b1

#!/usr/bin/env python
"""
searchbin.py -t PATTERN [FILE [FILE...]]
searchbin.py -p PATTERN [FILE [FILE...]]
searchbin.py -f FILE    [FILE [FILE...]]

examples:
./searchbin.py -t "hello" myfile.exe
Searches for the text "hello" in myfile.exe.

./searchbin.py -p "CCDDFF" myfile.exe
Searches for the hexidecimal pattern "CCDDFF" in myfile.exe.

./searchbin.py -f pattern.bin myfile.exe
Reads the file pattern.bin, and searches for a binary match within myfile.exe.

Many more capabilites, just run ./searchbin.py --help

+Features: no compiling, fast, small file, wild card matches, search multiple files of unlimited size, all operating systems
+Minimum Py2.7 required for argparse library
+keywords binary grep search seek find fast

license: BSD 2-Clause License, 2012, Sepero
license: http://www.opensource.org/licenses/BSD-2-Clause
"""

from __future__ import unicode_literals
import re
import signal
import sys

# Global variables.
CONTACT=("sepero 111 @ gmx . com\n"
		"https://bitbucket.org/Sepero/searchbin/issues/new\n"
		"http://seperohacker.blogspot.com/2012/04/binary-grep-program-searchbin.html")

VERSION="1.00"
DEBUG = False
STDOUT = sys.stdout

try:    # Python 3 modifications.
	STDIN = sys.stdin.buffer
except: # Python 2 modifications.
	STDIN = sys.stdin
	range = xrange


def _exit_error(code, option="", err=None):
	"""
	Error information is kept here for the purposes of easier management and possibly language tranlation.
	Returns nothing. All calls exit the program, error status 128.
	"""
	error_codes = {
		"Xpatterns":
			"Cannot search for multiple patterns. '-t -p -f'",
		"0patterns":
			"No pattern to search for was supplied. '-t -p -f'",
		"decode":
			"The pattern string is invalid.\n" + str(option),
		"bsize":
			"The buffer size must be at least %s bytes." % str(option),
		"sizes":
			"Size parameters (-b -s -e -m) must be in decimal format.",
		"fpattern":
			"No pattern file found named: %s" % option,
		"startend":
			"The start of search must come before the end.",
		"openfile":
			"Failed opening file: %s" % option,
		"logwrite":
			"Could not write to the log file: %s" % option,
		"read":
			"Failed reading from file: %s" % option,
			
	}
	
	import traceback
	sys.stderr.write(traceback.format_exc() + "\n")
	if not DEBUG:
		sys.stderr.write("version: %s\n" % VERSION)
		sys.stderr.write("Please Report issues to: %s\n" % CONTACT)
		if err: sys.stderr.write("%s\n" % str(err))
	sys.stderr.write("Error <%s>: %s\n\n" % (code, error_codes[code]))
	if __name__ == "__main__":
		sys.exit(128) # Exit under normal operation.
	raise # Raise error on unittest or other execution.


def get_args():
	"""
	Parse all arguments from the command line using ArgumentParser.
	Returns an args object with attributes representing all arguments.
	"""
	from argparse import ArgumentParser
	description = CONTACT + """
	An argument -t or -p or -f is required. The -p argument accepts a 
	hexidecimal pattern string and allows for missing characters, 
	such as 'FF??FF'. When using -f argument, the pattern file will 
	be read as a binary file (not hex strings). If no search files are 
	specified, %prog will read from standard input. The minimum memory 
	required is about 3 times the size of the pattern byte length. 
	Increasing buffer-size will increase program search speed for 
	large search files. All size arguments (-b -s -e) are read in decimal 
	format, for example: '-s 1024' will start searching after 1kilobyte.
	format, for example: '-s 1024' will start searching after 1kilobyte.
	Reported finds are 0-based offset.
	"""
	p = ArgumentParser(description=description)
	
	def add(s, **kwargs):
		args = s.split(':')
		
		value = args.pop(2) # Pop item at index 2 (argument type).
		if value: kwargs['type'] = eval(value) #(type)(value) # str(value) or long(value).
		value = args.pop(2) # Pop item at index 2 (argument metavar).
		if value: kwargs['metavar'] = value
		value = args.pop(2) # Pop item at index 2 (argument name/destination).
		if value: kwargs['dest'] = value
		
		p.add_argument(*args, **kwargs)
	
	p.add_argument('-f', '--file', type=str,
			metavar='FILE', dest='fpattern',
			help='file to read search pattern from')
	p.add_argument('-t', '--text', type=str,
			metavar='PATTERN', dest='tpattern',
			help='a (utf-8 case-sensitive) text string to search for')
	p.add_argument('-p', '--pattern', type=str, # I would use -h for hex, but that's used for help output.
			metavar='PATTERN', dest='ppattern',
			help='a hexidecimal pattern to search for')
	try:    # Python 3.
		p.add_argument('-b', '--buffer-size', type=int,
				metavar='NUM', dest='bsize',
				help='read buffer size (in bytes). 8MB default')
		p.add_argument('-s', '--start', type=int,
				metavar='NUM', dest='start',
				help='starting position in file to begin searching, as bytes')
		p.add_argument('-e', '--end', type=int,
				metavar='NUM', dest='end',
				help='end search at this position, measuring from beginning of file')
		p.add_argument('-m', '--max-matches', type=int,
				metavar='NUM', dest='max_matches',
				help='maximum number of matches to find (0=infinite)')
	except: # Python 2.
		p.add_argument('-b', '--buffer-size', type=long,
				metavar='NUM', dest='bsize',
				help='read buffer size (in bytes). default is 8388608 (8MB)')
		p.add_argument('-s', '--start', type=long,
				metavar='NUM', dest='start',
				help='starting position in file to begin searching, as bytes')
		p.add_argument('-e', '--end', type=long,
				metavar='NUM', dest='end',
				help='end search at this position, measuring from beginning of file')
		p.add_argument('-m', '--max-matches', type=long,
				metavar='NUM', dest='max_matches',
				help='maximum number of matches to find (0=infinite)')
	p.add_argument('-l', '--log', type=str,
			metavar='FILE', dest='log',
			help='write matched offsets to FILE, instead of standard output')
	p.add_argument(type=str,
			metavar='FILE', dest='fsearch', nargs='*',
			help='files to search within')
	p.add_argument('-v', '--verbose',
			dest='verbose', action='store_true',
			help='verbose, output the number of bytes searched after each buffer read')
	p.add_argument('-V', '--version',
			action='version', version='%(prog)s ' + VERSION)
	p.add_argument('-d', '--debug',
			dest='debug', action='store_true',
			help='debugging (don\'t use this)')
	
	return p.parse_args()


"""
=Patterns=
A pattern is a list. It represents the division between known and unknown
bytes to search for. All hex/text/file input is converted to a pattern.
Examples of conversions:
hex "31??33" becomes ['A', 'C']  # Everything is converted internally to strings, even though they may not be printable characters.
text "A?C"   becomes ['A', 'C']
text "A??C"  becomes ['A', '', 'C']
"""
def hex_to_pattern(hex):
	""" Converts a hex string into a pattern. """
	ret = []
	pattern = hex
	if hex[:2] == "0x": # Remove "0x" from start if it exists.
		pattern = hex[2:]
	try:
		ret = [ p for p in pattern.split("??") ]
		try:                  # Python 3.
			return [ bytes.fromhex(p) for p in ret ]
		except AttributeError: # Python 2.
			return [ p.decode("hex") for p in ret ]
	except(TypeError, ValueError):
		e = sys.exc_info()[1]
		_exit_error("decode", hex, e)


def text_to_pattern(text):
	""" Converts a text string into a pattern. """
	try:              # Python 3.
		return [ t.encode('utf-8') for t in text.split("?") ]
	except TypeError: # Python 2.
		return [ t for t in text.split("?") ]


def file_to_pattern(fname):
	""" Converts a file into a pattern. """
	try: # If file specified, read it into memory.
		with open(fname, "rb") as f:
			return [f.read()]
	except IOError:
		e = sys.exc_info()[1]
		_exit_error("fpattern", fname, e)


# We will be keeping the parsed args object and editing its attributes!
def verify_args(ar):
	"""
	Verify that all the parsed args are correct and work well together.
	Returns the modified args object.
	"""
	DEBUG = ar.debug
	
	# Make sure that exactly 1 pattern argument was given.
	all_patterns = list(filter(None, [ar.fpattern, ar.ppattern, ar.tpattern]))
	if len(all_patterns) > 1:
		_exit_error("Xpatterns")
	if len(all_patterns) == 0:
		_exit_error("0patterns")
	
	# Create a new variable ar.pattern, and fill it with
	# whichever pattern we have -t -f -p. ar.pattern will be a list.
	if ar.fpattern:
		ar.pattern = file_to_pattern(ar.fpattern)
	elif ar.tpattern:
		ar.pattern = text_to_pattern(ar.tpattern)
	else:
		ar.pattern = hex_to_pattern(ar.ppattern)
	
	# Convert all number args from strings into long integers.
	try:
		for attr in [ "bsize", "max_matches", "start", "end" ]:
			if getattr(ar, attr):
				setattr(ar, attr, long(getattr(ar, attr)))
	except ValueError:
		e = sys.exc_info()[1]
		_exit_error("sizes", err=e)
	
	# Buffer size must be at least double maximum pattern size.
	if ar.bsize:
		if ar.bsize < len("?".join(ar.pattern)) * 2:
			_exit_error("bsize", len("?".join(ar.pattern)) * 2)
	else:
		ar.bsize = len(b"".join(ar.pattern)) * 2
		ar.bsize = max(ar.bsize, 2**23) # If bsize is < default, set to default.
	
	# Set start and end values to 0 if not set.
	ar.start =  ar.start or 0
	ar.end = ar.end or 0
	# End must be after start.  :)
	if ar.end and ar.start >= ar.end:
		_exit_error("startend")
	
	# If log file is True, open it and replace ar.log with the file handler.
	if ar.log:
		try:
			ar.log = open(ar.log, "w")
		except IOError:
			e = sys.exc_info()[1]
			_exit_error("openfile", ar.log, e)
	
	return ar


def search(ar, fh):
	"""
	This function is simply a wrapper to forward needed variables in a way
	to make them all local variables. Accessing local variables is faster than
	accessing object.attribute variables.
	Returns nothing.
	"""
	if not DEBUG:
		_search_loop(ar.start, ar.end, ar.bsize, ar.pattern,
				ar.max_matches, ar.log, ar.verbose, fh.name,
				fh.read, fh.seek)
	else:
		_debug_search(ar.pattern, fh.name, fh.read)


def _debug_search(pattern, fh_name, fh_read):
	"""
	Slower, less functional, but less error prone simple search.
	For debugging purposes.
	Returns nothing.
	"""
	len_pattern = len(b"?".join(pattern))
	read_size = 2**24 - len_pattern # Amount to read each loop.
	pattern = [ re.escape(p) for p in pattern ]
	pattern = b".".join(pattern)
	regex = re.compile(pattern, re.DOTALL+re.MULTILINE)
	
	try:
		buffer = fh_read(len_pattern + read_size)
		offset = 0
		match = regex.search(buffer)
		while True:
			if not match:
				offset += read_size
				buffer = buffer[read_size:] # Erase front portion of buffer.
				buffer += fh_read(read_size)
				match = regex.search(buffer)
			else:
				STDOUT.write("Match at offset: %14d %12X in  %s\n" % (
						offset+match.start(), offset+match.start(), fh_name))
				match = regex.search(buffer, match.start()+1)
			
			if len(buffer) <= len_pattern:
				return
	except IOError:
		e = sys.exc_info()[1]
		_exit_error("read", fh_name, e)


def _search_loop(start, end, bsize, pattern, max_matches,
		log, verbose, fh_name, fh_read, fh_seek):
	"""
	Primary search function.
	Returns nothing.
	"""
	len_pattern = len(b"?".join(pattern)) # Byte length of pattern.
	read_size = bsize - len_pattern # Amount to read each loop.
	
	# Convert pattern into a regular expression for insane fast searching.
	pattern = [ re.escape(p) for p in pattern ]
	pattern = b".".join(pattern)
	# Grab regex search function directly to speed up function calls.
	regex_search = re.compile(pattern, re.DOTALL+re.MULTILINE).search
	
	offset = start or 0
	# Set start reading position in file.
	try:
		if offset:
			fh_seek(offset)
	except IOError:
		e = sys.exc_info()[1]
		_exit_error("read", fh_name, err=e)
	
	try:
		buffer = fh_read(len_pattern + read_size) # Get initial buffer amount.
		match = regex_search(buffer) # Search for a match in the buffer.
		# Set match to -1 if no match, else set it to the match position.
		match = -1 if match == None else match.start()
		
		while True: # Begin main loop for searching through a file.
			if match == -1: # No match.
				offset += read_size
				# If end exists and we are beyond end, finish search.
				if end and offset > end:
					return
				buffer = buffer[read_size:] # Erase front portion of buffer.
				buffer += fh_read(read_size) # Read more into the buffer.
				match = regex_search(buffer) # Search for next match in the buffer.
				# If there is no match set match to -1, else the matching position.
				match = -1 if match == None else match.start()
				if verbose: # Print each loop offset if verbose is on.
					STDOUT.write("Passing offset: %14d %12X\n" % (offset, offset))
			else: # Else- there was a match.
				# If end exists and we are beyond end, finish search.
				if match == -1 and offset + match > end:
					return
				
				# Print matched offset.
				find_offset = offset + match
				STDOUT.write("Match at offset: %14d %12X in  %s\n" % (
						find_offset, find_offset, fh_name))
				
				if max_matches:
					max_matches -= 1
					if max_matches == 0: # If maximum matches are found, then end.
						STDOUT.write("Found maximum number of matches.\n")
						return
				
				# Search for next match in the buffer.
				match = regex_search(buffer, match+1)
				match = -1 if match == None else match.start()
				
			if len(buffer) <= len_pattern: # If finished reading input then end.
				return
				
		# Main loop closes here.
	
	except IOError:
		e = sys.exc_info()[1]
		_exit_error("read", fh_name, e)


def main():
	args = get_args() # Get commandline arguments.
	args = verify_args(args) # Check arguments for sanity, and edit them a bit.
	if args.fsearch: # If filenames were given on the commandline, process them.
		while args.fsearch: # List of files to search inside.
			try: # Open a filehandler for the filename.
				filehandler = open(args.fsearch[0], "rb")
			except IOError:
				e = sys.exc_info()[1]
				_exit_error("openfile", args.fsearch[0], e)
			search(args, filehandler)
			filehandler.close()
			args.fsearch.pop(0) # Remove each file after search.
	else: # If no files were given, search using stdin.
		
		search(args, STDIN)
	sys.exit(0)


if __name__ == "__main__":
	# This allows the program to exit quickly when pressing ctrl+c.
	signal.signal(signal.SIGINT, signal.SIG_DFL)
	
	main()

searchbin -p 01010420 "path to disk image of .img" file,

searchbin -p 01010420 /dev/whicheverpath 

searchbin -p 10141f

searchbin.py -p 6231050009000000 "path to disk image"

db_dump -r lsn

db_dump -r | db_load -t btree wallet.dat 

db_dump -d ar wallet.dat

#!/usr/bin/env python

# This software is
# Copyright (c) 2012-2018 Dhiru Kholia <dhiru at openwall.com>
# Copyright (c) 2019 Solar Designer
# Copyright (c) 2019 exploide
# Redistribution and use in source and binary forms, with or without
# modification, are permitted.  (This is a heavily cut-down "BSD license".)
#
# While the above applies to the stated copyright holders' contributions,
# this software is also dual-licensed under the MIT License, to be certain
# of license compatibility with that of the components listed below.
#
# This script (bitcoin2john.py) might still contain portions of jackjack's
# pywallet.py [1] which is forked from Joric's pywallet.py whose licensing
# information follows,
#
# [1] https://github.com/jackjack-jj/pywallet
#
# PyWallet 1.2.1 (Public Domain)
# http://github.com/joric/pywallet
# Most of the actual PyWallet code placed in the public domain.
# PyWallet includes portions of free software, listed below.
#
# BitcoinTools (wallet.dat handling code, MIT License)
# https://github.com/gavinandresen/bitcointools
# Copyright (c) 2010 Gavin Andresen

import binascii
import logging
import struct
import sys

try:
    from bsddb.db import *
except:
    try:
        from bsddb3.db import *
    except:
        sys.stderr.write("Error: This script needs bsddb3 to be installed!\n")
        sys.exit(1)


json_db = {}

def hexstr(bytestr):
    return binascii.hexlify(bytestr).decode('ascii')

# bitcointools wallet.dat handling code

class SerializationError(Exception):
        """ Thrown when there's a problem deserializing or serializing """

class BCDataStream(object):
        def __init__(self):
                self.input = None
                self.read_cursor = 0

        def clear(self):
                self.input = None
                self.read_cursor = 0

        def write(self, bytes):  # Initialize with string of bytes
                if self.input is None:
                        self.input = bytes
                else:
                        self.input += bytes

        def read_string(self):
                # Strings are encoded depending on length:
                # 0 to 252 :    1-byte-length followed by bytes (if any)
                # 253 to 65,535 : byte'253' 2-byte-length followed by bytes
                # 65,536 to 4,294,967,295 : byte '254' 4-byte-length followed by bytes
                # ... and the Bitcoin client is coded to understand:
                # greater than 4,294,967,295 : byte '255' 8-byte-length followed by bytes of string
                # ... but I don't think it actually handles any strings that big.
                if self.input is None:
                        raise SerializationError("call write(bytes) before trying to deserialize")

                try:
                        length = self.read_compact_size()
                except IndexError:
                        raise SerializationError("attempt to read past end of buffer")

                return self.read_bytes(length).decode('ascii')

        def read_bytes(self, length):
                try:
                        result = self.input[self.read_cursor:self.read_cursor + length]
                        self.read_cursor += length
                        return result
                except IndexError:
                        raise SerializationError("attempt to read past end of buffer")

                return ''

        def read_uint32(self): return self._read_num('<I')

        def read_compact_size(self):
                size = self.input[self.read_cursor]
                if isinstance(size, str):
                    size = ord(self.input[self.read_cursor])
                self.read_cursor += 1
                if size == 253:
                        size = self._read_num('<H')
                elif size == 254:
                        size = self._read_num('<I')
                elif size == 255:
                        size = self._read_num('<Q')
                return size

        def _read_num(self, format):
                (i,) = struct.unpack_from(format, self.input, self.read_cursor)
                self.read_cursor += struct.calcsize(format)
                return i

def open_wallet(walletfile):
        db = DB()
        DB_TYPEOPEN = DB_RDONLY
        flags = DB_THREAD | DB_TYPEOPEN
        try:
                r = db.open(walletfile, "main", DB_BTREE, flags)
        except DBError as e:
                logging.error(e)
                r = True

        if r is not None:
                logging.error("Couldn't open wallet.dat/main. Try quitting Bitcoin and running this again.")
                logging.error("See our doc/README.bitcoin for how to setup and use this script correctly.")
                sys.exit(1)

        return db

def parse_wallet(db, item_callback):
        kds = BCDataStream()
        vds = BCDataStream()

        for (key, value) in db.items():
                d = { }

                kds.clear(); kds.write(key)
                vds.clear(); vds.write(value)

                type = kds.read_string()

                d["__key__"] = key
                d["__value__"] = value
                d["__type__"] = type

                try:
                        if type == "mkey":
                                #d['nID'] = kds.read_uint32()
                                d['encrypted_key'] = vds.read_bytes(vds.read_compact_size())
                                d['salt'] = vds.read_bytes(vds.read_compact_size())
                                d['nDerivationMethod'] = vds.read_uint32()
                                d['nDerivationIterations'] = vds.read_uint32()
                                #d['otherParams'] = vds.read_string()

                        item_callback(type, d)

                except Exception:
                        sys.stderr.write("ERROR parsing wallet.dat, type %s\n" % type)
                        sys.stderr.write("key data in hex: %s\n" % hexstr(key))
                        sys.stderr.write("value data in hex: %s\n" % hexstr(value))
                        sys.exit(1)

# end of bitcointools wallet.dat handling code

# wallet.dat reader

def read_wallet(json_db, walletfile):
        db = open_wallet(walletfile)

        json_db['mkey'] = {}

        def item_callback(type, d):
                if type == "mkey":
                        #json_db['mkey']['nID'] = d['nID']
                        json_db['mkey']['encrypted_key'] = hexstr(d['encrypted_key'])
                        json_db['mkey']['salt'] = hexstr(d['salt'])
                        json_db['mkey']['nDerivationMethod'] = d['nDerivationMethod']
                        json_db['mkey']['nDerivationIterations'] = d['nDerivationIterations']
                        #json_db['mkey']['otherParams'] = d['otherParams']

        parse_wallet(db, item_callback)

        db.close()

        crypted = 'salt' in json_db['mkey']

        if not crypted:
                sys.stderr.write("%s: this wallet is not encrypted\n" % walletfile)
                return -1

        return {'crypted':crypted}


if __name__ == '__main__':

    if len(sys.argv) < 2:
        sys.stderr.write("Usage: %s [Bitcoin/Litecoin/PRiVCY wallet (.dat) files]\n" % sys.argv[0])
        sys.exit(1)

    for i in range(1, len(sys.argv)):
        filename = sys.argv[i]
        if read_wallet(json_db, filename) == -1:
            continue

        cry_master = binascii.unhexlify(json_db['mkey']['encrypted_key'])
        cry_salt = binascii.unhexlify(json_db['mkey']['salt'])
        cry_rounds = json_db['mkey']['nDerivationIterations']
        cry_method = json_db['mkey']['nDerivationMethod']

        crypted = 'salt' in json_db['mkey']

        if not crypted:
            sys.stderr.write("%s: this wallet is not encrypted\n" % filename)
            continue

        if cry_method != 0:
            sys.stderr.write("%s: this wallet uses unknown key derivation method\n" % filename)
            continue

        cry_salt = json_db['mkey']['salt']

        if len(cry_salt) == 16:
            expected_mkey_len = 96  # 32 bytes padded to 3 AES blocks (last block is padding-only)
        elif len(cry_salt) == 36:  # Nexus legacy wallet
            expected_mkey_len = 160  # 72 bytes padded to whole AES blocks
        else:
            sys.stderr.write("%s: this wallet uses unsupported salt size\n" % filename)
            continue

# When cracking we only use the last two AES blocks, and thus we could support
# any encrypted master key size of 32 bytes (64 hex) or more.  However, there's
# no reliable way for us to infer what the unencrypted key size was before it
# got padded to whole AES blocks, and thus no way for us to confidently detect
# correct guesses by checking the last block's padding.  We rely on that check
# for expected encrypted master key sizes (assuming that 48 was 32, and 80 was
# 72, like specific known wallets use), but we don't dare to do that for
# unexpected sizes where we'd very likely end up with 100% (false) negatives.
        if len(json_db['mkey']['encrypted_key']) != expected_mkey_len:
            sys.stderr.write("%s: this wallet uses unsupported master key size\n" % filename)
            continue

        cry_master = json_db['mkey']['encrypted_key'][-64:]  # last two AES blocks are enough

        sys.stdout.write("$bitcoin$%s$%s$%s$%s$%s$2$00$2$00\n" %
            (len(cry_master), cry_master, len(cry_salt), cry_salt, cry_rounds))