Build against local OpenSSL 1.0.2/PCRE1, add -c clipboard flag

This code targets OpenSSL's pre-1.1 BIGNUM layout and the legacy PCRE1
API, neither of which is available as a system package anymore on
current distros. Rather than rewrite the BIGNUM handling for opaque
structs, point the Makefile at self-built OpenSSL 1.0.2u/PCRE 8.45 via
overridable OPENSSL_PATH/PCRE_PATH variables (defaulting under $HOME).

Also add -c, which copies the private key to the clipboard instead of
printing it, clearing the clipboard automatically after 45 seconds if
it still holds what we put there (same approach as pass). Falls back
to printing the key if xclip or an X11 display isn't available, so the
key is never lost.

Author: isghe

CLAUDE.md

@@ -0,0 +1,52 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## What this is
+
+Vanitygen: a command-line vanity Bitcoin (and altcoin-family) address generator, written in C. Given a desired prefix or regex pattern, it brute-force searches EC keypairs until it finds an address matching the pattern. A CPU implementation (`vanitygen`) and an OpenCL/GPU implementation (`oclvanitygen`, `oclvanityminer`) share the same pattern-matching core.
+
+## Build
+
+```
+make            # builds vanitygen and keyconv only (the "most" target, no OpenCL deps needed)
+make all        # also builds oclvanitygen and oclvanityminer (requires OpenCL + libcurl)
+make clean
+```
+
+Dependencies: OpenSSL (`libcrypto`), PCRE (`libpcre`), pthreads. OpenCL targets additionally need an OpenCL SDK/driver and `libcurl` (oclvanityminer only, for pool mining).
+
+This code targets the OpenSSL 1.0.x API (`BIGNUM` as a transparent struct) and the legacy PCRE1 API (`<pcre.h>`), not OpenSSL 1.1+ (opaque `BIGNUM`) or PCRE2. On a system that only has newer versions installed system-wide, build OpenSSL 1.0.2 and PCRE1 from source under `$HOME/development/crypto/` and point the Makefile at them, e.g.:
+
+```
+make OPENSSL_PATH=$HOME/development/crypto/openssl-1.0.2u PCRE_PATH=$HOME/development/crypto/pcre-8.45
+```
+
+`OPENSSL_PATH`/`PCRE_PATH` default to those same paths under `$HOME`, so a plain `make` picks them up automatically if built there.
+
+Windows build uses `Makefile.Win32` with `nmake` (MSVC); see `INSTALL` for required SDK paths (OpenSSL, pthreads-Win32, PCRE, AMD APP SDK/CUDA).
+
+There is no test suite in this repository.
+
+## Architecture
+
+The codebase splits into a reusable pattern-matching/crypto core and multiple thin front ends:
+
+- **`pattern.c`/`pattern.h`** — the core `vg_context_t` / `vg_exec_context_t` abstraction. A `vg_context_t` holds the search parameters (address type, patterns, output callbacks) and dispatches to one of two pattern engines via function pointers (`vc_add_patterns`, `vc_test`, `vc_hash160_sort`, ...):
+  - **Prefix matching** (`vg_prefix_context_new`): builds a trie/AVL-based structure (see `avl.h`) over base58 prefixes for O(log N) matching against many patterns simultaneously, and can compute match difficulty.
+  - **Regex matching** (`vg_regex_context_new`): compiles PCRE patterns and matches against generated addresses.
+  Each worker thread owns a `vg_exec_context_t` (its own OpenSSL `BN_CTX`/`EC_KEY`/scratch bignums) and calls back into `vc_test` per candidate key. Thread coordination (locking, upgrade/downgrade, stop) lives here too.
+- **`util.c`/`util.h`** — base58check encode/decode, address/private-key encoding, private key protection/encryption (BIP38-like PBKDF2+AES), PKCS#8 import/export, password handling, and file reading helpers. Independent of the search engine.
+- **`vanitygen.c`** — CPU front end: parses CLI args, builds a `vg_context_t` (prefix or regex), spawns one pthread worker per CPU (or `-t` override), and calls into `pattern.c`.
+- **`oclengine.c`/`oclengine.h`** — the OpenCL execution engine (`vg_ocl_context_t`): device/platform enumeration, kernel compilation and dispatch, batched EC point arithmetic on the GPU. This is what makes GPU search fast — it computes many candidate public keys per kernel invocation rather than one key at a time.
+- **`calc_addrs.cl`** — the actual OpenCL kernel source (EC point math, hashing) compiled/loaded at runtime by `oclengine.c`.
+- **`oclvanitygen.c`** — GPU front end analogous to `vanitygen.c`, but driving `vg_ocl_context_t` instead of pthread workers.
+- **`oclvanityminer.c`** — a pool-mining-style variant of the OpenCL front end: pulls patterns from a remote server over HTTP (via libcurl) and reports matches back, instead of taking patterns from argv.
+- **`keyconv.c`** — standalone small utility to convert/reformat keys and addresses between formats (base58check, hex, PEM/PKCS#8), independent of the search engines.
+- **`winglue.c`/`winglue.h`** — Windows compatibility shims (pthreads/time/stat equivalents) used only when building with MSVC.
+
+### Key extension points
+
+- New coin/address types are just `addrtype`/`privtype` byte values passed into `vg_prefix_context_new`/`vg_regex_context_new` — see CLI handling in `vanitygen.c`/`oclvanitygen.c` for `-t`/address-version flags (Bitcoin, Namecoin, testnet variants).
+- Output is fully pluggable via `vc_output_match`/`vc_output_timing`/`vc_output_error` function pointers on `vg_context_t`; default console implementations are `vg_output_match_console`/`vg_output_timing_console` in `pattern.c`.
+- Both CPU and GPU front ends build the same `vg_context_t` and differ only in what drives `vc_test` (pthread loop vs. OpenCL kernel batches), so pattern-matching logic changes belong in `pattern.c`, not duplicated per front end.

Makefile

@@ -1,5 +1,8 @@
-LIBS=-lpcre -lcrypto -lm -lpthread
-CFLAGS=-ggdb -O3 -Wall
+OPENSSL_PATH ?= $(HOME)/development/crypto/openssl-1.0.2u
+PCRE_PATH ?= $(HOME)/development/crypto/pcre-8.45
+
+LIBS=-lpcre -lcrypto -lm -lpthread -ldl
+CFLAGS=-ggdb -O3 -Wall -I$(OPENSSL_PATH)/include -L$(OPENSSL_PATH) -I$(PCRE_PATH) -L$(PCRE_PATH)/.libs
 OBJS=vanitygen.o oclvanitygen.o oclvanityminer.o oclengine.o keyconv.o pattern.o util.o
 PROGS=vanitygen keyconv oclvanitygen oclvanityminer
 

README

@@ -9,10 +9,21 @@ CPU and does not use OpenCL or CUDA.  Vanitygen is also a bit more
 user-friendly in that it provides feedback on its rate of progress and 
 how many keys it has checked.
 
-Vanitygen is written in C, and is provided in source code form and 
-pre-built Win32 binaries.  At present, vanitygen can be built on Linux, 
+Vanitygen is written in C, and is provided in source code form and
+pre-built Win32 binaries.  At present, vanitygen can be built on Linux,
 and requires the openssl and pcre libraries.
 
+Vanitygen targets the OpenSSL 1.0.x API and the legacy PCRE1 API.  It will
+not build against OpenSSL 1.1+ (where BIGNUM became an opaque type) or
+PCRE2.  On a system that only has newer versions installed, build OpenSSL
+1.0.2 and PCRE1 from source and point the Makefile at them:
+
+$ make OPENSSL_PATH=/path/to/openssl-1.0.2u PCRE_PATH=/path/to/pcre-8.45
+
+OPENSSL_PATH and PCRE_PATH default to $HOME/development/crypto/openssl-1.0.2u
+and $HOME/development/crypto/pcre-8.45, so a plain "make" picks them up
+automatically if built there.
+
 Vanitygen can generate regular bitcoin addresses, namecoin addresses, 
 and testnet addresses.
 
@@ -32,10 +43,18 @@ lists of prefixes will have little effect on search rate.  Searching
 for N regular expressions will have varied performance depending on the 
 complexity of the expressions, but O(N) performance can be expected.
 
-By default, vanitygen will spawn one worker thread for each CPU in your 
-system.  If you wish to limit the number of worker threads created by 
+By default, vanitygen will spawn one worker thread for each CPU in your
+system.  If you wish to limit the number of worker threads created by
 vanitygen, use the "-t" option.
 
+For safety, the "-c" option copies the private key to the clipboard
+instead of printing it to the screen (the address is still printed, since
+it isn't sensitive).  The clipboard is cleared automatically 45 seconds
+later, provided nothing else has been copied in the meantime -- the same
+approach used by "pass" (passwordstore.org).  This requires "xclip" and a
+running X11 session; if either is unavailable, vanitygen falls back to
+printing the private key as usual.
+
 The example below completed quicker than average, and took about 45 sec 
 to finish, using both cores of my aging Core 2 Duo E6600:
 

pattern.c

@@ -553,6 +553,9 @@ vg_output_match_console(vg_context_t *vcp, EC_KEY *pkey, const char *pattern)
 		vg_encode_privkey(pkey, vcp->vc_privtype, privkey_buf);
 	}
 
+	int clipped = vcp->vc_clip ?
+		vg_clipboard_copy_secret(privkey_buf, 45) : 0;
+
 	if (!vcp->vc_result_file || (vcp->vc_verbose > 0)) {
 		printf("\r%79s\rPattern: %s\n", "", pattern);
 	}
@@ -563,22 +566,34 @@ vg_output_match_console(vg_context_t *vcp, EC_KEY *pkey, const char *pattern)
 			len = i2o_ECPublicKey(pkey, &pend);
 			printf("Pubkey (hex): ");
 			dumphex(key_buf, len);
-			printf("Privkey (hex): ");
-			dumpbn(EC_KEY_get0_private_key(pkey));
-			pend = key_buf;
-			len = i2d_ECPrivateKey(pkey, &pend);
-			printf("Privkey (ASN1): ");
-			dumphex(key_buf, len);
+			if (clipped) {
+				printf("Privkey (hex): "
+				       "(copied to clipboard, "
+				       "clearing in 45s)\n");
+			} else {
+				printf("Privkey (hex): ");
+				dumpbn(EC_KEY_get0_private_key(pkey));
+				pend = key_buf;
+				len = i2d_ECPrivateKey(pkey, &pend);
+				printf("Privkey (ASN1): ");
+				dumphex(key_buf, len);
+			}
 		}
 
 	}
 
 	if (!vcp->vc_result_file || (vcp->vc_verbose > 0)) {
 		if (isscript)
 			printf("P2SHAddress: %s\n", addr2_buf);
-		printf("Address: %s\n"
-		       "%s: %s\n",
-		       addr_buf, keytype, privkey_buf);
+		if (clipped) {
+			printf("Address: %s\n"
+			       "%s: (copied to clipboard, clearing in 45s)\n",
+			       addr_buf, keytype);
+		} else {
+			printf("Address: %s\n"
+			       "%s: %s\n",
+			       addr_buf, keytype, privkey_buf);
+		}
 	}
 
 	if (vcp->vc_result_file) {

pattern.h

@@ -100,6 +100,7 @@ struct _vg_context_s {
 	int			vc_remove_on_match;
 	int			vc_only_one;
 	int			vc_verbose;
+	int			vc_clip;
 	enum vg_format		vc_format;
 	int			vc_pubkeytype;
 	EC_POINT		*vc_pubkey_base;

util.c

@@ -39,6 +39,11 @@
 #include "pattern.h"
 #include "util.h"
 
+#if !defined(_WIN32)
+#include <unistd.h>
+#include <sys/wait.h>
+#endif
+
 const char *vg_b58_alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
 
 const signed char vg_b58_reverse_map[256] = {
@@ -1086,3 +1091,81 @@ vg_read_file(FILE *fp, char ***result, int *rescount)
 
 	return ret;
 }
+
+
+/*
+ * Copy a secret (e.g. a private key) to the X11 clipboard using xclip,
+ * and schedule it to be cleared after timeout_secs -- but only if the
+ * clipboard still holds exactly what we put there, so we don't clobber
+ * something else the user copied in the meantime.  Modeled after the
+ * clipboard handling in "pass" (passwordstore.org).
+ *
+ * Returns 1 if the secret was copied to the clipboard, 0 if no clipboard
+ * tool was available (in which case the caller should fall back to
+ * printing the secret).
+ */
+int
+vg_clipboard_copy_secret(const char *secret, int timeout_secs)
+{
+#if defined(_WIN32)
+	return 0;
+#else
+	FILE *fp;
+	pid_t pid;
+	char cmd[256];
+	int status;
+
+	if (system("command -v xclip >/dev/null 2>&1") != 0) {
+		fprintf(stderr,
+			"vanitygen: xclip not found in PATH, "
+			"printing private key instead\n");
+		return 0;
+	}
+
+	fp = popen("xclip -selection clipboard", "w");
+	if (!fp) {
+		fprintf(stderr,
+			"vanitygen: could not run xclip (%s), "
+			"printing private key instead\n", strerror(errno));
+		return 0;
+	}
+	fputs(secret, fp);
+	status = pclose(fp);
+	if (status != 0) {
+		fprintf(stderr,
+			"vanitygen: xclip exited with status %d, "
+			"printing private key instead\n", status);
+		return 0;
+	}
+
+	pid = fork();
+	if (pid < 0)
+		/* Copy succeeded even though we can't schedule the clear */
+		return 1;
+
+	if (pid == 0) {
+		/* Detach a grandchild so the parent doesn't have to wait */
+		if (fork() > 0)
+			_exit(0);
+		setsid();
+		close(0);
+		close(1);
+		close(2);
+
+		if (setenv("VG_CLIP_SECRET", secret, 1) == 0) {
+			snprintf(cmd, sizeof(cmd),
+				"sleep %d; "
+				"[ \"$(xclip -selection clipboard -o "
+				"2>/dev/null)\" = \"$VG_CLIP_SECRET\" ] && "
+				"printf '' | xclip -selection clipboard",
+				timeout_secs);
+			system(cmd);
+		}
+		_exit(0);
+	}
+
+	/* Reap the intermediate child, which exits immediately */
+	waitpid(pid, NULL, 0);
+	return 1;
+#endif
+}

util.h

@@ -75,4 +75,6 @@ extern int vg_check_password_complexity(const char *pass, int verbose);
 
 extern int vg_read_file(FILE *fp, char ***result, int *rescount);
 
+extern int vg_clipboard_copy_secret(const char *secret, int timeout_secs);
+
 #endif /* !defined (__VG_UTIL_H__) */

vanitygen.c

@@ -295,7 +295,7 @@ usage(const char *name)
 {
 	fprintf(stderr,
 "Vanitygen %s (" OPENSSL_VERSION_TEXT ")\n"
-"Usage: %s [-vqnrik1NT] [-t <threads>] [-f <filename>|-] [<pattern>...]\n"
+"Usage: %s [-vqnrik1cNT] [-t <threads>] [-f <filename>|-] [<pattern>...]\n"
 "Generates a bitcoin receiving address matching <pattern>, and outputs the\n"
 "address and associated private key.  The private key may be stored in a safe\n"
 "location or imported into a bitcoin client to spend any balance received on\n"
@@ -311,6 +311,8 @@ usage(const char *name)
 "-i            Case-insensitive prefix search\n"
 "-k            Keep pattern and continue search after finding a match\n"
 "-1            Stop after first match\n"
+"-c            Copy private key to the clipboard instead of printing it\n"
+"              (cleared automatically after 45 seconds; requires xclip)\n"
 "-N            Generate namecoin address\n"
 "-T            Generate bitcoin testnet address\n"
 "-X <version>  Generate address with the given version\n"
@@ -342,6 +344,7 @@ main(int argc, char **argv)
 	int simulate = 0;
 	int remove_on_match = 1;
 	int only_one = 0;
+	int clip = 0;
 	int prompt_password = 0;
 	int opt;
 	char *seedfile = NULL;
@@ -361,7 +364,7 @@ main(int argc, char **argv)
 
 	int i;
 
-	while ((opt = getopt(argc, argv, "vqnrik1eE:P:NTX:F:t:h?f:o:s:")) != -1) {
+	while ((opt = getopt(argc, argv, "vqnrik1ceE:P:NTX:F:t:h?f:o:s:")) != -1) {
 		switch (opt) {
 		case 'v':
 			verbose = 2;
@@ -384,6 +387,9 @@ main(int argc, char **argv)
 		case '1':
 			only_one = 1;
 			break;
+		case 'c':
+			clip = 1;
+			break;
 		case 'N':
 			addrtype = 52;
 			privtype = 180;
@@ -551,6 +557,7 @@ main(int argc, char **argv)
 	vcp->vc_format = format;
 	vcp->vc_pubkeytype = pubkeytype;
 	vcp->vc_pubkey_base = pubkey_base;
+	vcp->vc_clip = clip;
 
 	vcp->vc_output_match = vg_output_match_console;
 	vcp->vc_output_timing = vg_output_timing_console;