vanitygen.c

/*
 * Vanitygen, vanity bitcoin address generator
 * Copyright (C) 2011 <samr7@cs.washington.edu>
 *
 * Vanitygen is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * any later version.
 *
 * Vanitygen is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with Vanitygen.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <assert.h>
#include <stdio.h>
#include <string.h>

#if defined(_WIN32) && !defined(HAVE_STRUCT_TIMESPEC)
#define HAVE_STRUCT_TIMESPEC
#endif
#include <pthread.h>
#include <thread>

#include <openssl/bn.h>
#include <openssl/ec.h>
#include <openssl/rand.h>
#include <openssl/ripemd.h>
#include <openssl/sha.h>

#include "pattern.h"
#include "util.h"

const char *version = VANITYGEN_VERSION;

/*
 * Address search thread main loop
 */

void *vg_thread_loop(void *arg) {
	unsigned char hash_buf[128];
	unsigned char *eckey_buf;
	unsigned char hash1[32];

	int c, len, output_interval;
	unsigned int i;

	const BN_ULONG rekey_max = 10000000;
	BN_ULONG npoints, rekey_at, nbatch;

	vg_context_t *vcp = (vg_context_t *) arg;
	EC_KEY *pkey = NULL;
	const EC_GROUP *pgroup;
	const EC_POINT *pgen;
	const int ptarraysize = 256;
	EC_POINT *ppnt[ptarraysize];
	EC_POINT *pbatchinc;

	vg_test_func_t test_func = vcp->vc_test;
	vg_exec_context_t ctx;
	vg_exec_context_t *vxcp;

	struct timeval tvstart;

	memset(&ctx, 0, sizeof(ctx));
	vxcp = &ctx;

	vg_exec_context_init(vcp, &ctx);

	pkey = vxcp->vxc_key;
	pgroup = EC_KEY_get0_group(pkey);
	pgen = EC_GROUP_get0_generator(pgroup);

	for (i = 0; i < ptarraysize; i++) {
		ppnt[i] = EC_POINT_new(pgroup);
		if (!ppnt[i]) {
			fprintf(stderr, "ERROR: out of memory?\n");
			exit(1);
		}
	}
	pbatchinc = EC_POINT_new(pgroup);
	if (!pbatchinc) {
		fprintf(stderr, "ERROR: out of memory?\n");
		exit(1);
	}

	BN_set_word(vxcp->vxc_bntmp, ptarraysize);
	EC_POINT_mul(pgroup, pbatchinc, vxcp->vxc_bntmp, NULL, NULL,
		vxcp->vxc_bnctx);
	EC_POINT_make_affine(pgroup, pbatchinc, vxcp->vxc_bnctx);

	npoints = 0;
	rekey_at = 0;
	nbatch = 0;
	vxcp->vxc_key = pkey;
	// vxcp->vxc_binres[0] = vcp->vc_addrtype;
	c = 0;
	output_interval = 1000;
	gettimeofday(&tvstart, NULL);

	if (vcp->vc_addrtype == (1 << 3)) {
		hash_buf[0] = 0x51; // OP_1
		hash_buf[1] = 0x41; // pubkey length
		// gap for pubkey
		hash_buf[67] = 0x51; // OP_1
		hash_buf[68] = 0xae; // OP_CHECKMULTISIG
		eckey_buf = hash_buf + 2;
	} else {
		eckey_buf = hash_buf;
	}

	while (!vcp->vc_halt) {
		if (++npoints >= rekey_at) {
			vg_exec_context_upgrade_lock(vxcp);
			/* Generate a new random private key */
			EC_KEY_generate_key(pkey);
			if (vcp->vc_privkey_prefix_length != 0) {
				BIGNUM *pkbn =
					BN_dup(EC_KEY_get0_private_key(pkey));
				unsigned char pkey_arr[32];
				assert(BN_bn2bin(pkbn, pkey_arr) < 33);
				memcpy((char *) pkey_arr,
					vcp->vc_privkey_prefix,
					vcp->vc_privkey_prefix_length);
				BN_bin2bn(pkey_arr, 32, pkbn);
				EC_KEY_set_private_key(pkey, pkbn);

				EC_POINT *origin = EC_POINT_new(pgroup);
				EC_POINT_mul(pgroup, origin, pkbn, NULL, NULL,
					vxcp->vxc_bnctx);
				EC_KEY_set_public_key(pkey, origin);
			}
			npoints = 0;

			/* Determine rekey interval */
			EC_GROUP_get_order(
				pgroup, vxcp->vxc_bntmp, vxcp->vxc_bnctx);
			BN_sub(vxcp->vxc_bntmp2, vxcp->vxc_bntmp,
				EC_KEY_get0_private_key(pkey));
			rekey_at = BN_get_word(vxcp->vxc_bntmp2);

			if (rekey_at > rekey_max) rekey_at = rekey_max;
			assert(rekey_at > 0);

			EC_POINT_copy(ppnt[0], EC_KEY_get0_public_key(pkey));
			vg_exec_context_downgrade_lock(vxcp);

			npoints++;
			vxcp->vxc_delta = 0;

			if (vcp->vc_pubkey_base)
				EC_POINT_add(pgroup, ppnt[0], ppnt[0],
					vcp->vc_pubkey_base, vxcp->vxc_bnctx);

			for (nbatch = 1;
				(nbatch < ptarraysize) && (npoints < rekey_at);
				nbatch++, npoints++) {
				EC_POINT_add(pgroup, ppnt[nbatch],
					ppnt[nbatch - 1], pgen,
					vxcp->vxc_bnctx);
			}

		} else {
			/*
			 * Common case
			 *
			 * EC_POINT_add() can skip a few multiplies if
			 * one or both inputs are affine (Z_is_one).
			 * This is the case for every point in ppnt, as
			 * well as pbatchinc.
			 */
			assert(nbatch == ptarraysize);
			for (nbatch = 0;
				(nbatch < ptarraysize) && (npoints < rekey_at);
				nbatch++, npoints++) {
				EC_POINT_add(pgroup, ppnt[nbatch], ppnt[nbatch],
					pbatchinc, vxcp->vxc_bnctx);
			}
		}

		/*
		 * The single most expensive operation performed in this
		 * loop is modular inversion of ppnt->Z.  There is an
		 * algorithm implemented in OpenSSL to do batched inversion
		 * that only does one actual BN_mod_inverse(), and saves
		 * a _lot_ of time.
		 *
		 * To take advantage of this, we batch up a few points,
		 * and feed them to EC_POINTs_make_affine() below.
		 */

		EC_POINTs_make_affine(pgroup, nbatch, ppnt, vxcp->vxc_bnctx);

		if (vcp->vc_addrtype == (1 << 3)) {
			for (i = 0; i < (unsigned) nbatch;
				i++, vxcp->vxc_delta++) {
				/* Hash the public key */
				len = EC_POINT_point2oct(pgroup, ppnt[i],
					POINT_CONVERSION_UNCOMPRESSED,
					eckey_buf, 65, vxcp->vxc_bnctx);
				assert(len == 65);

				SHA256(hash_buf, 69, hash1);
				RIPEMD160(
					hash1, sizeof(hash1), vxcp->vxc_binres);
				switch (test_func(vxcp, 0)) {
				case 1:
					npoints = 0;
					rekey_at = 0;
					i = nbatch;
					break;
				case 2: goto out; break;
				default: break;
				}
			}
			c += i;
		} else {
			for (i = 0; i < (unsigned) nbatch;
				i++, vxcp->vxc_delta++) {
				/* Hash the public key */
				len = EC_POINT_point2oct(pgroup, ppnt[i],
					POINT_CONVERSION_UNCOMPRESSED,
					eckey_buf, 65, vxcp->vxc_bnctx);
				assert(len == 65);

				SHA256(hash_buf, 65, hash1);
				RIPEMD160(
					hash1, sizeof(hash1), vxcp->vxc_binres);
				switch (test_func(vxcp, 0)) {
				case 1:
					npoints = 0;
					rekey_at = 0;
					goto outloop;
					break;
				case 2: goto out; break;
				default: break;
				}

				eckey_buf[0] = 0x02 | (eckey_buf[64] & 1);

				SHA256(hash_buf, 33, hash1);
				RIPEMD160(
					hash1, sizeof(hash1), vxcp->vxc_binres);
				switch (test_func(vxcp, 1)) {
				case 1:
					npoints = 0;
					rekey_at = 0;
					i = nbatch;
					break;
				case 2: goto out; break;
				default: break;
				}
			}
			c += i << 1;
		}
	outloop:
		if (c >= output_interval) {
			output_interval = vg_output_timing(vcp, c, &tvstart);
			if (output_interval > 250000) output_interval = 250000;
			c = 0;
		}

		vg_exec_context_yield(vxcp);
	}

out:
	vg_exec_context_del(&ctx);
	vg_context_thread_exit(vcp);

	for (i = 0; i < ptarraysize; i++)
		if (ppnt[i]) EC_POINT_free(ppnt[i]);
	if (pbatchinc) EC_POINT_free(pbatchinc);
	return NULL;
}

#if !defined(_WIN32) || (_MSC_FULL_VER > 189999999)
unsigned int count_processors(void) {
#if (__GNUC__ > 4) || (_MSC_FULL_VER > 189999999) || (__clang_major__ > 3)
	// C++11
	return std::thread::hardware_concurrency();
#else
	int i = sysconf(_SC_NPROCESSORS_ONLN);
	if (i == -1) return 0;
	return (unsigned) i;
#endif
}
#endif

int start_threads(vg_context_t *vcp, int nthreads) {
	pthread_t thread;

	while (--nthreads) {
		if (pthread_create(&thread, NULL, vg_thread_loop, vcp))
			return 0;
	}

	vg_thread_loop(vcp);
	return 1;
}

void usage(const char *name) {
	// clang-format off
	fprintf(stderr,
		COLOR44
"Vanitygen Cash %s" COLOR0 " (" OPENSSL_VERSION_TEXT ")\n"
"Usage: %s [-vcqnrk1T] [-t <threads>] [-f <filename>|-] [<pattern>...]\n"
"Generates a Bitcoin Cash receiving address matching <pattern>, and outputs\n"
"the address and associated private key. The private key may be stored in a\n"
"safe location or imported into a wallet client to spend any balance\n"
"received on the address.\n"
"By default, <pattern> is interpreted as an exact prefix.\n"
"\n"
"Options:\n"
"-v            Verbose output\n"
"-c            Print conditions for a valid address prefix\n"
"              (i.e. alphabet) and quit\n"
"-q            Quiet output\n"
"-n            Simulate\n"
#ifndef _WIN32
"-r            Use regular expression match instead of prefix\n"
#endif
"              (Feasibility of expression is not checked)\n"
"-k            Keep pattern and continue search after finding a match\n"
"-1            Stop after first match\n"
"-T            Generate Bitcoin Cash testnet address\n"
"-l <hex>      Choose prefix for the hex format of private key (EXPERTS)\n"
"-F            Generate address with the script format (EXPERTS ONLY!)\n"
"-P <pubkey>   Specify base public key for piecewise key generation\n"
"-t <threads>  Set number of worker threads (Default: number of CPUs)\n"
"-f <file>     File containing list of patterns, one per line\n"
"              (Use \"-\" as the file name for stdin)\n"
"-G <file>     Rangegen pattern file\n"
"-o <file>     Write pattern matches to <file> in TSV format (readable)\n"
"-O <file>     Write pattern matches to <file> in CSV format\n"
"              (importable e.g. Excel)\n"
"-s <file>     Seed random number generator from <file>\n",
		version, name);
	// clang-format on
}

#define MAX_FILE 4

int main(int argc, char **argv) {
	int testnet = 0;
	int addrtype = 0;
	int privtype = 128;
	int regex = 0;
	unsigned int verbose = 1;
	int simulate = 0;
	int remove_on_match = 1;
	int only_one = 0;
	int opt;
	char *seedfile = NULL;
	const char *result_file = NULL;
	const char *result_file_csv = NULL;
	char **patterns;
	int npatterns = 0;
	int nthreads = 0;
	vg_context_t *vcp = NULL;
	EC_POINT *pubkey_base = NULL;
	char privkey_prefix[32];
	unsigned int privkey_prefix_length = 0;

	FILE *pattfp[MAX_FILE], *fp;
	int npattfp = 0;
	int pattstdin = 0;

	const char **rangef = (const char **) malloc(4 * sizeof(const char *));
	int range_alloc = 4;
	int nrange = 0;

	unsigned int i;

	while ((opt = getopt(argc, argv, "cvqnrk1P:Tl:Ft:h?f:G:o:O:s:")) !=
		-1) {
		switch (opt) {
		case 'c':
			fprintf(stderr, "%s\n",
				"Conditions:\n"
				"• The alphabet is 023456789acdefghjklmnpqrstuvwxyz\n"
				"• The first character must be 'q' for standard addresses or 'p' for P2SH\n"
				"• The second character must be either 'p', 'q', 'r' or 'z'.\n"
				"• The prefix must be lowercase and typed without the CashAddr prefix (e.g. no \"bitcoincash:\")\n");
			return 0;
		case 'v': verbose = 2; break;
		case 'q': verbose = 0; break;
		case 'n': simulate = 1; break;
		case 'r': regex = 1; break;
		case 'k': remove_on_match = 0; break;
		case '1': only_one = 1; break;
		case 'T':
			privtype = 239;
			testnet = 1;
			break;
		case 'l':
			if (privkey_prefix_length != 0) {
				fprintf(stderr,
					"Hex privkey prefix has been set "
					"before.\n");
				return 1;
			}
			privkey_prefix_length = strlen(optarg);
			if (privkey_prefix_length % 2) {
				fprintf(stderr,
					"Hex privkey prefix length must be a "
					"multiple of 2.\n");
				return 1;
			}
			privkey_prefix_length /= 2;
			if (privkey_prefix_length > 15) {
				fprintf(stderr,
					"At most 30 characters, please.\n");
				return 1;
			}

			if (privkey_prefix_length > 24) {
				fprintf(stderr,
					"Pkey prefix is longer than 48 characters, will try, but no promise.\n"
					"Pkey prefix with at most 48 characters is advised for security, or "
					"a private key may not be found at all.\n");
			}
			for (unsigned int i = 0;
				i < (unsigned int) privkey_prefix_length; i++) {
				int value; // Can't sscanf directly to char
					   // array because of overlapping on
					   // Win32
				sscanf(&optarg[i * 2], "%2x",
					(unsigned int *) &value);
				privkey_prefix[i] = value;
			}
			break;
		case 'F': addrtype = 1 << 3; break;
		case 'P': {
			if (pubkey_base != NULL) {
				fprintf(stderr,
					"Multiple base pubkeys specified\n");
				return 1;
			}
			EC_KEY *pkey = vg_exec_context_new_key();
			pubkey_base = EC_POINT_hex2point(
				EC_KEY_get0_group(pkey), optarg, NULL, NULL);
			EC_KEY_free(pkey);
			if (pubkey_base == NULL) {
				fprintf(stderr, "Invalid base pubkey\n");
				return 1;
			}
			break;
		}
		case 't':
			nthreads = atoi(optarg);
			if (nthreads == 0) {
				fprintf(stderr, "Invalid thread count '%s'\n",
					optarg);
				return 1;
			}
			break;
		case 'f':
			if (npattfp >= MAX_FILE) {
				fprintf(stderr,
					"Too many input files specified\n");
				return 1;
			}
			if (!strcmp(optarg, "-")) {
				if (pattstdin) {
					fprintf(stderr,
						"ERROR: stdin "
						"specified multiple times\n");
					return 1;
				}
				fp = stdin;
			} else {
				fp = fopen(optarg, "r");
				if (!fp) {
					fprintf(stderr,
						"Could not open %s: %s\n",
						optarg, strerror(errno));
					return 1;
				}
			}
			pattfp[npattfp++] = fp;
			break;
		case 'G':
			if (nrange == range_alloc) {
				range_alloc *= 2;
				rangef = (const char **) realloc(rangef,
					range_alloc * sizeof(const char *));
			}
			rangef[nrange++] = optarg;
			break;
		case 'o':
			if (result_file) {
				fprintf(stderr,
					"Multiple TSV output files "
					"specified\n");
				return 1;
			}
			result_file = optarg;
			break;
		case 'O':
			if (result_file_csv) {
				fprintf(stderr,
					"Multiple CSV output files "
					"specified\n");
				return 1;
			}
			result_file_csv = optarg;
			break;
		case 's':
			if (seedfile != NULL) {
				fprintf(stderr,
					"Multiple RNG seeds specified\n");
				return 1;
			}
			seedfile = optarg;
			break;
		default: usage(argv[0]); return 1;
		}
	}

#ifdef _WIN32
	if (regex) {
		fprintf(stderr,
			"regex pattern matching is not possible on Windows!\n");
		return 1;
	}
#else
	if (!seedfile) {
		struct stat st1;
		if (stat("/dev/urandom", &st1) == 0) {
			seedfile = (char *) "/dev/urandom";
		}
	}
#endif

	if (regex && nrange != 0) {
		fprintf(stderr,
			"Can't have range files specified in regex mode!\n");
		return 1;
	}

	if (seedfile) {
		opt = -1;
#ifndef _WIN32
		{
			struct stat st;
			if (!stat(seedfile, &st) &&
				(st.st_mode & (S_IFBLK | S_IFCHR))) {
				opt = 32;
			}
		}
#endif
		opt = RAND_load_file(seedfile, opt);
		if (!opt) {
			fprintf(stderr, "Could not load RNG seed %s\n", optarg);
			return 1;
		}
		if (verbose > 0 && strcmp(seedfile, (char *) "/dev/urandom")) {
			fprintf(stderr, "Read %d bytes from RNG seed file\n",
				opt);
		}
	}

#ifdef _WIN32
	vcp = vg_prefix_context_new(addrtype, privtype, testnet);
#else
	if (regex) {
		vcp = vg_regex_context_new(addrtype, privtype, testnet);
	} else {
		vcp = vg_prefix_context_new(addrtype, privtype, testnet);
	}
#endif

	if (result_file) {
		FILE *fp = fopen(result_file, "a");
		if (!fp) {
			fprintf(stderr,
				"ERROR: could not open TSV result file: %s\n",
				strerror(errno));
			return 1;
		} else {
			fprintf(fp, "Pattern\t");
			if (addrtype == (1 << 3))
				fprintf(fp, "Address\t");
			else
				fprintf(fp, "P2SH Address\t");
			if (pubkey_base == NULL)
				fprintf(fp, "Private Key\n");
			else
				fprintf(fp, "Private Key Part\n");
			fclose(fp);
		}
	}

	if (result_file_csv) {
		FILE *fp = fopen(result_file_csv, "a");
		if (!fp) {
			fprintf(stderr,
				"ERROR: could not open CSV result file: %s\n",
				strerror(errno));
			return 1;
		} else {
			fprintf(fp, "Pattern,");
			if (addrtype == (1 << 3))
				fprintf(fp, "Address,");
			else
				fprintf(fp, "P2SH Address,");
			if (pubkey_base == NULL)
				fprintf(fp, "Private Key\n");
			else
				fprintf(fp, "Private Key Part\n");
			fclose(fp);
		}
	}

	if (nthreads <= 0) {
		/* Determine the number of threads */
		nthreads = count_processors();
		if (nthreads == 0) {
			fprintf(stderr,
				"ERROR: could not determine processor count\n");
			nthreads = 1;
		}
	}

	if (verbose > 1) {
		fprintf(stderr, "Using %d worker thread(s)\n", nthreads);
	}

	vcp->vc_verbose = verbose;
	vcp->vc_result_file = result_file;
	vcp->vc_result_file_csv = result_file_csv;
	vcp->vc_remove_on_match = remove_on_match;
	vcp->vc_only_one = only_one;
	vcp->vc_pubkey_base = pubkey_base;
	memcpy(vcp->vc_privkey_prefix, privkey_prefix, privkey_prefix_length);
	vcp->vc_privkey_prefix_length = privkey_prefix_length;

	vcp->vc_output_match = vg_output_match_console;
	vcp->vc_output_timing = vg_output_timing_console;

	if (!npattfp && !nrange) {
		if (optind >= argc) {
			usage(argv[0]);
			return 1;
		}
		patterns = &argv[optind];
		npatterns = argc - optind;

		if (!vg_context_add_patterns(
			    vcp, (const char **) patterns, npatterns))
			return 1;
	}

	for (i = 0; i < (unsigned) npattfp; i++) {
		fp = pattfp[i];
		if (!vg_read_file(fp, &patterns, &npatterns)) {
			fprintf(stderr, "Failed to load pattern file\n");
			return 1;
		}
		if (fp != stdin) fclose(fp);

		if (!vg_context_add_patterns(
			    vcp, (const char **) patterns, npatterns))
			return 1;
	}

	for (i = 0; i < (unsigned) nrange; i++) {
		fp = fopen(rangef[i], "r");
		if (!fp) {
			fprintf(stderr, "Could not open %s: %s\n", rangef[i],
				strerror(errno));
			return 1;
		}
		char **range_list = (char **) malloc(8 * sizeof(char *));
		int range_count = 0;
		int range_alloc = 8;
		if (!vg_read_range_file(fp, (const char ***) &range_list,
			    &range_count, &range_alloc))
			return 1;
		fclose(fp);
		vg_prefix_context_add_ranges(vcp, rangef[i],
			(const char **) range_list, range_count);
		for (int k = 0; k < range_count; k++) {
			free(range_list[k]);
		}
		free(range_list);
		// if (!r)
		//	return 1;
	}

	if (!vcp->vc_npatterns) {
		fprintf(stderr, "No patterns to search\n");
		return 1;
	}

	if ((verbose > 0) && regex && (vcp->vc_npatterns > 1))
		fprintf(stderr, "Regular expressions: %ld\n",
			vcp->vc_npatterns);

#ifndef _WIN32
	if (regex && !vg_regex_context_prep_scratch(vcp)) {
		return 1;
	}
#endif

	if (simulate) return 0;

	if (!start_threads(vcp, nthreads)) return 1;

	return 0;
}