CudaBrainSecp

https://github.com/xopmc/cudabrainsecp
Admin
A CUDA-based GPU tool for efficient Secp256k1 brain wallet and mnemonic phrase recovery through...
Tokens:9,789
Snippets:50
Trust Score:8.9
License:MIT
Update:9 months ago
Show doc for...
Tokens:
Raw
### ModeCombo: Permutation-Based Wallet Recovery (C++)

Source: https://context7.com/xopmc/cudabrainsecp/llms.txt

Implements permutation-based wallet recovery by exhaustively trying all combinations of symbols within a specified size range. It validates configuration, calculates total combinations, and iterates through starting positions for GPU processing. Output includes found hash160, private keys, and seeds.

```cpp
// CudaBrainSecp.cpp - ModeCombo implementation

void startSecp256k1ModeCombo(uint8_t* gTableXCPU, uint8_t* gTableYCPU,
                             uint64_t* inputHashBufferCPU) {
    // Validate configuration
    if (SIZE_COMBO_MULTI < 4 || SIZE_COMBO_MULTI > 8) {
        printf("Supported combination sizes: 4-8\n");
        exit(-1);
    }

    // Initialize GPU
    GPUSecp* gpuSecp = new GPUSecp(0, 0, gTableXCPU, gTableYCPU,
                                   NULL, NULL, inputHashBufferCPU);

    // Calculate total combinations: COUNT_COMBO_SYMBOLS ^ SIZE_COMBO_MULTI
    long totalComboCount = 1;
    for (int i = 0; i < SIZE_COMBO_MULTI; i++) {
        totalComboCount *= COUNT_COMBO_SYMBOLS;
    }
    // Example: 100^4 = 100,000,000 combinations for 4-character passwords

    // Each iteration processes COUNT_COMBO_SYMBOLS^2 combinations per thread
    long comboPerIteration = COUNT_CUDA_THREADS * COUNT_COMBO_SYMBOLS * COUNT_COMBO_SYMBOLS;
    long maxIteration = 1 + (totalComboCount / comboPerIteration);

    // Starting position for iteration
    int8_t comboCPU[SIZE_COMBO_MULTI] = {0, 0, 0, 0};

    for (int iter = 0; iter < maxIteration; iter++) {
        // Current position: [0, 0, 0, 0] -> [0, 0, 0, 99] -> [0, 0, 1, 0] ...
        printf("Combo position: [");
        for (int i = 0; i < SIZE_COMBO_MULTI; i++) {
            printf("%d ", comboCPU[i]);
        }
        printf("]\n");

        // GPU kernel generates all permutations from this starting point
        // Thread N tests: comboCPU + [N, 0..99, 0..99]
        gpuSecp->doIterationSecp256k1Combo(comboCPU);
        gpuSecp->doPrintOutput();

        // Advance to next position
        adjustComboBuffer(comboCPU, COUNT_CUDA_THREADS);
    }

    printf("Total combinations tested: %lu\n", totalComboCount);
}

// Symbol set defined in GPUSecp.h:
// COMBO_SYMBOLS = [0-9, a-z, A-Z, special chars, space, etc.]
// Total: 100 symbols

```

--------------------------------

### Configure CudaBrainSecp GPU and Memory Parameters

Source: https://context7.com/xopmc/cudabrainsecp/llms.txt

This C++ header file (`GPUSecp.h`) defines critical configuration parameters for CudaBrainSecp, including CUDA grid dimensions (blocks and threads per block) for optimal GPU utilization, file paths for hash data, and parameters for ModeBooks (wordlist lengths and counts) and ModeCombo (symbol count and password length). It also specifies memory allocation sizes for CPU and GPU stacks.

```cpp
// GPU/GPUSecp.h - Main configuration file

// CUDA grid configuration - adjust based on GPU architecture
#define BLOCKS_PER_GRID 30        // Number of blocks in the grid
#define THREADS_PER_BLOCK 256     // Threads per block (30 * 256 = 7,680 threads)

// Hash160 file configuration
#define NAME_HASH_FOLDER "TestHash"                              // Directory with hash files
#define NAME_HASH_BUFFER "merged-sorted-unique-8-byte-hashes"   // Merged output file
#define COUNT_INPUT_HASH 204                                     // Total number of target hashes

// For ModeBooks: wordlist parameters
#define NAME_INPUT_PRIME "TestBook/list_prime"   // Primary wordlist (small)
#define NAME_INPUT_AFFIX "TestBook/list_affix"   // Affix wordlist (large)
#define MAX_LEN_WORD_PRIME 20                    // Max length of prime words
#define MAX_LEN_WORD_AFFIX 4                     // Max length of affix words
#define AFFIX_IS_SUFFIX true                     // If false, affix is prefix
#define COUNT_INPUT_PRIME 100                    // Number of prime words

// For ModeCombo: combination parameters
#define COUNT_COMBO_SYMBOLS 100    // Unique symbols in COMBO_SYMBOLS array
#define SIZE_COMBO_MULTI 4         // Password length (4-8 supported)

// Memory allocation
#define SIZE_CPU_STACK 1024 * 1024 * 1024  // 1GB CPU stack
#define SIZE_CUDA_STACK 32768              // 32KB per GPU thread

// Performance tuning recommendations:
// - RTX 3060/3070: BLOCKS_PER_GRID=30-40, THREADS_PER_BLOCK=256
// - RTX 2070/2080: BLOCKS_PER_GRID=25-35, THREADS_PER_BLOCK=256
// - GTX 1080 Ti:   BLOCKS_PER_GRID=20-30, THREADS_PER_BLOCK=256
// Higher values may cause out-of-memory errors

```

--------------------------------

### ModeBooks: Wordlist-Based Wallet Recovery (C++)

Source: https://context7.com/xopmc/cudabrainsecp/llms.txt

Implements wordlist-based wallet recovery by combining words from a primary wordlist and an affix wordlist. It loads wordlists into memory, initializes the GPU for parallel processing, and iterates through combinations. Output includes found hash160, private keys, and seeds.

```cpp
// CudaBrainSecp.cpp - ModeBooks implementation

// Example wordlist files:
// TestBook/list_prime (primary words):
// bitcoin
// blockchain
// satoshi
// wallet
// ...

// TestBook/list_affix (suffix/prefix words):
// 123
// 2023
// abc
// ...

void startSecp256k1ModeBooks(uint8_t* gTableXCPU, uint8_t* gTableYCPU,
                             uint64_t* inputHashBufferCPU) {
    // Load wordlists
    int countPrime = getBookWordCount(NAME_INPUT_PRIME);  // e.g., 100 words
    int countAffix = getBookWordCount(NAME_INPUT_AFFIX);  // e.g., 10,000 words

    // Load wordlists into memory
    uint8_t* inputBookPrimeCPU = loadInputBook(NAME_INPUT_PRIME, MAX_LEN_WORD_PRIME);
    uint8_t* inputBookAffixCPU = loadInputBook(NAME_INPUT_AFFIX, MAX_LEN_WORD_AFFIX);

    // Initialize GPU
    GPUSecp* gpuSecp = new GPUSecp(
        countPrime, countAffix,
        gTableXCPU, gTableYCPU,
        inputBookPrimeCPU, inputBookAffixCPU,
        inputHashBufferCPU
    );

    // Process all combinations
    long totalCount = countPrime * countAffix;  // e.g., 1,000,000 combinations
    int maxIteration = countAffix / COUNT_CUDA_THREADS;

    for (int iter = 0; iter < maxIteration; iter++) {
        // Each iteration processes COUNT_CUDA_THREADS combinations
        // GPU kernel combines: affix[thread_id] + all_prime_words
        // Or: all_prime_words + affix[thread_id] if AFFIX_IS_SUFFIX=false
        gpuSecp->doIterationSecp256k1Books(iter);
        gpuSecp->doPrintOutput();  // Print any found matches
    }

    // Example output:
    // Found Hash160: a1b2c3d4e5f6...
    // Private Key: 0123456789abcdef...
    // Seed: "bitcoin123"
}

// Performance example on RTX 3060:
// - 1 million seeds in ~300ms
// - ~3.3 million seeds per second

```

--------------------------------

### Load and Initialize Secp256k1 GTable in C++

Source: https://context7.com/xopmc/cudabrainsecp/llms.txt

Initializes the Secp256k1 curve and pre-computes a lookup table (GTable) for fast point multiplication. The GTable consists of 1,048,576 pre-computed points, stored as x and y coordinates, requiring approximately 67MB of memory. This table significantly reduces the number of operations required for point multiplication.

```cpp
// CudaBrainSecp.cpp - GTable initialization

void loadGTable(uint8_t* gTableX, uint8_t* gTableY) {
    // Initialize Secp256k1 curve
    Secp256K1* secp = new Secp256K1();
    secp->Init();

    // GTable structure:
    // - 16 chunks (NUM_GTABLE_CHUNK)
    // - 65,536 values per chunk (NUM_GTABLE_VALUE = 2^16)
    // - Total: 1,048,576 pre-computed points
    // - Memory: ~67MB (1M points * 64 bytes)

    for (int chunk = 0; chunk < NUM_GTABLE_CHUNK; chunk++) {
        for (int value = 0; value < NUM_GTABLE_VALUE - 1; value++) {
            int element = (chunk * NUM_GTABLE_VALUE) + value;
            Point p = secp->GTable[element];

            // Store x and y coordinates (32 bytes each)
            for (int b = 0; b < 32; b++) {
                gTableX[(element * SIZE_GTABLE_POINT) + b] = p.x.GetByte64(b);
                gTableY[(element * SIZE_GTABLE_POINT) + b] = p.y.GetByte64(b);
            }
        }
    }

    // GTable enables fast point multiplication:
    // privKey = 0x0123456789abcdef... (32 bytes = 16 chunks of 2 bytes)
    // pubKey = GTable[chunk0][0x0123] + GTable[chunk1][0x4567] + ... + GTable[chunk15][...]
    // Requires only 15 point additions instead of ~255 doublings + ~127 additions
}

int main(int argc, char** argv) {
    // Allocate GTable memory
    uint8_t* gTableXCPU = new uint8_t[COUNT_GTABLE_POINTS * SIZE_GTABLE_POINT];
    uint8_t* gTableYCPU = new uint8_t[COUNT_GTABLE_POINTS * SIZE_GTABLE_POINT];

    // Pre-compute all points
    loadGTable(gTableXCPU, gTableYCPU);

    // Load target hashes
    uint64_t* inputHashBufferCPU = new uint64_t[COUNT_INPUT_HASH];
    loadInputHash(inputHashBufferCPU);

    // Start recovery
    startSecp256k1ModeBooks(gTableXCPU, gTableYCPU, inputHashBufferCPU);

    // Cleanup
    free(gTableXCPU);
    free(gTableYCPU);
    free(inputHashBufferCPU);

    return 0;
}

```

--------------------------------

### Complete Wallet Recovery Workflow (Bash Script)

Source: https://context7.com/xopmc/cudabrainsecp/llms.txt

A bash script demonstrating the end-to-end workflow for recovering cryptocurrency wallets using CudaBrainSecp. It covers address conversion, wordlist creation, GPU configuration, and execution.

```bash
#!/bin/bash
# complete_recovery_workflow.sh

# Step 1: Collect target addresses
cat > target_addresses.txt << EOF
1BgGZ9tcN4rm9KBzDn7KprQz87SZ26SAMH
bc1qxy2kgdygjrsqtzq2n0yrf2493p83kkfjhx0wlh
LTC1qw508d6qejxtdg4y5r3zarvary0c5xw7kg5w4j5
EOF

# Step 2: Convert addresses to Hash160
python3 addr_to_hash.py target_addresses.txt RealHash/targets.bin

# Step 3: Create wordlists based on what you remember
cat > RealBook/list_prime << EOF
bitcoin
satoshi
nakamoto
myname
mypet
EOF

cat > RealBook/list_affix << EOF
123
2023
!
abc
xyz
EOF

# Step 4: Configure GPU parameters in GPUSecp.h
cat > GPU/GPUSecp.h << 'EOF'
#define NAME_HASH_FOLDER "RealHash"
#define NAME_SEED_FOLDER "RealBook"
#define COUNT_INPUT_HASH 3          // 3 target addresses
#define COUNT_INPUT_PRIME 5          // 5 prime words
#define BLOCKS_PER_GRID 30
#define THREADS_PER_BLOCK 256
#define CCAP 86                      // RTX 3060
EOF

# Step 5: Build and run
make clean
make all
./CudaBrainSecp

# Expected output:
# CudaBrainSecp Starting
# Loading hash buffer...
# loadInputBook started...
# CudaBrainSecp.ModeBooks Starting
# Iteration: 0, time: 245
# Found Hash160: 1b2c3d4e5f...
# Private Key: 0123456789abcdef...
# Seed: "bitcoin123"
# Seeds Per Second: 3.45 Million

```

--------------------------------

### Build CudaBrainSecp Project with Makefile

Source: https://context7.com/xopmc/cudabrainsecp/llms.txt

Compile the CudaBrainSecp tool for a specific GPU architecture by editing the Makefile. This process involves setting the GPU compute capability (CCAP) and optionally the CUDA toolkit path before running 'make clean' and 'make all'. Test cases can be executed using './CudaBrainSecp'.

```bash
# Edit Makefile to set your GPU compute capability
# For RTX 3060: CCAP = 86
# For RTX 2070: CCAP = 75
# For GTX 1080: CCAP = 61

# Set CUDA toolkit path
# CUDA = /usr/local/cuda-11.7

# Build the project
make clean
make all

# Run test cases (should find ~50 hashes in ~3 seconds)
./CudaBrainSecp
```

--------------------------------

### Convert Addresses to Hash160 Binary with Python

Source: https://context7.com/xopmc/cudabrainsecp/llms.txt

This Python script converts cryptocurrency addresses from a text file into binary Hash160 format, suitable for searching against target databases. It supports Base58 (Bitcoin), Bech32 (SegWit), and Litecoin address formats. The script uses the `base58` and `codecs` libraries for decoding and encoding.

```python
# addr_to_hash.py - Convert addresses to Hash160 binary files
# Usage: python3 addr_to_hash.py input_addresses.txt output_hash160.bin

# Example input_addresses.txt:
# 1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa
# bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4
# LTC1Q...

# The script handles:
# - Base58 Bitcoin addresses (1...)
# - Bech32 SegWit addresses (bc1...)
# - Litecoin addresses (ltc1...)

import base58
import codecs

def addresses_to_hash160(filein, fileout):
    with open(filein) as inf, open(fileout, 'wb') as outf:
        count = 0
        for address in inf.readlines():
            address = address.strip().split()[0]
            try:
                # Try Base58 decoding first
                hash160 = base58.b58decode_check(address)
                hash160 = codecs.encode(hash160, 'hex').decode()[2:]
                outf.write(bytes.fromhex(hash160))
                count += 1
            except:
                # Try Bech32 decoding for SegWit
                witness, list_of_bytes = bech32_decode('bc', address)
                outf.write(bytes(list_of_bytes))
                count += 1
        print(f'Processed {count} addresses')

# Convert addresses
addresses_to_hash160('my_addresses.txt', 'TestHash/hash160_custom.bin')
```

--------------------------------

### Merge Hashes and Binary Search in C++ and CUDA

Source: https://context7.com/xopmc/cudabrainsecp/llms.txt

Implements functionalities for merging multiple hash files into a single, sorted, and unique list of 8-byte hashes, suitable for binary search. It also includes a CUDA kernel for performing efficient binary searches on this sorted hash database. Note that using only the last 8 bytes can lead to a very low probability of false positives.

```cpp
// CPU/HashMerge.cpp - Merge multiple hash files

void mergeHashes(const char* folderName, const char* outputName) {
    // Merge all .bin files from TestHash/ folder
    // Example structure:
    // TestHash/
    //   hash160_book_btc      (100 hashes from wordlist tests)
    //   hash160_combo_4       (20 hashes for 4-char combos)
    //   hash160_custom.bin    (your target addresses)

    // Process:
    // 1. Read all hash files in folder
    // 2. Extract last 8 bytes of each Hash160
    // 3. Sort and remove duplicates
    // 4. Write to "merged-sorted-unique-8-byte-hashes"

    // Result: Single sorted file for binary search
    // Format: uint64_t array (8 bytes per hash)
    // Size: COUNT_INPUT_HASH * 8 bytes
}

```

```cuda
// GPU binary search implementation (in CUDA kernel):
__device__ bool searchHash160(uint64_t hash8bytes, uint64_t* inputHashBuffer) {
    // Binary search in sorted array
    int left = 0;
    int right = COUNT_INPUT_HASH - 1;

    while (left <= right) {
        int mid = (left + right) / 2;
        uint64_t midValue = inputHashBuffer[mid];

        if (midValue == hash8bytes) {
            return true;  // Found!
        } else if (midValue < hash8bytes) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    return false;  // Not found
}

// Note: Using only last 8 bytes means false positives are possible
// Probability: ~1 in 18 quintillion (2^64)
// False positive rate is lower than Bloom filter for this use case

```

--------------------------------

### GPU Secp256k1 Point Multiplication - Conceptual Outline (CUDA)

Source: https://context7.com/xopmc/cudabrainsecp/llms.txt

This is a conceptual outline of the GPU Secp256k1 point multiplication kernel, illustrating the steps involved without the full implementation details. It highlights the process of splitting the private key, using pre-computed tables, and performing point additions to derive the public key.

```cuda
// GPU/GPUSecp.cu - Point multiplication kernel

__device__ void _PointMultiSecp256k1(
    uint8_t* privKey,           // 32-byte private key input
    uint8_t* pubKeyX,           // 32-byte public key X output
    uint8_t* pubKeyY,           // 32-byte public key Y output
    uint8_t* gTableX,           // Pre-computed GTable X coordinates
    uint8_t* gTableY) {         // Pre-computed GTable Y coordinates

    // Split private key into 16 chunks of 2 bytes each
    // Example: 0x0123456789abcdef... -> [0x0123, 0x4567, 0x89ab, 0xcdef, ...]

    // Initialize accumulator point to infinity
    uint8_t accX[32], accY[32];
    bool isInfinity = true;

    // Add points from each chunk
    for (int chunk = 0; chunk < 16; chunk++) {
        // Extract 2-byte index from private key
        int idx = (privKey[chunk*2] << 8) | privKey[chunk*2 + 1];

        if (idx == 0) continue;  // Skip zero values

        // Load pre-computed point from GTable
        int tableIndex = CHUNK_FIRST_ELEMENT[chunk] + idx;
        uint8_t pointX[32], pointY[32];
        memcpy(pointX, &gTableX[tableIndex * 32], 32);
        memcpy(pointY, &gTableY[tableIndex * 32], 32);

        if (isInfinity) {
            // First point becomes accumulator
            memcpy(accX, pointX, 32);
            memcpy(accY, pointY, 32);
            isInfinity = false;
        } else {
            // Add point to accumulator
            _PointAddSecp256k1(accX, accY, pointX, pointY);
        }
    }

    // Copy result to output
    memcpy(pubKeyX, accX, 32);
    memcpy(pubKeyY, accY, 32);
}

```

--------------------------------

### GPU Secp256k1 Point Multiplication Kernel (CUDA)

Source: https://context7.com/xopmc/cudabrainsecp/llms.txt

The core CUDA kernel for performing Secp256k1 point multiplication on the GPU. It takes a private key and pre-computed GTable values to generate the public key coordinates (X and Y). It efficiently splits the private key and uses pre-computed tables to speed up the elliptic curve point additions.

```cuda
__device__ void _PointMultiSecp256k1(
    uint8_t* privKey,           // 32-byte private key input
    uint8_t* pubKeyX,           // 32-byte public key X output
    uint8_t* pubKeyY,           // 32-byte public key Y output
    uint8_t* gTableX,           // Pre-computed GTable X coordinates
    uint8_t* gTableY) {         // Pre-computed GTable Y coordinates

    // Split private key into 16 chunks of 2 bytes each
    // Example: 0x0123456789abcdef... -> [0x0123, 0x4567, 0x89ab, 0xcdef, ...]

    // Initialize accumulator point to infinity
    uint8_t accX[32], accY[32];
    bool isInfinity = true;

    // Add points from each chunk
    for (int chunk = 0; chunk < 16; chunk++) {
        // Extract 2-byte index from private key
        int idx = (privKey[chunk*2] << 8) | privKey[chunk*2 + 1];

        if (idx == 0) continue;  // Skip zero values

        // Load pre-computed point from GTable
        int tableIndex = CHUNK_FIRST_ELEMENT[chunk] + idx;
        uint8_t pointX[32], pointY[32];
        memcpy(pointX, &gTableX[tableIndex * 32], 32);
        memcpy(pointY, &gTableY[tableIndex * 32], 32);

        if (isInfinity) {
            // First point becomes accumulator
            memcpy(accX, pointX, 32);
            memcpy(accY, pointY, 32);
            isInfinity = false;
        } else {
            // Add point to accumulator
            _PointAddSecp256k1(accX, accY, pointX, pointY);
        }
    }

    // Copy result to output
    memcpy(pubKeyX, accX, 32);
    memcpy(pubKeyY, accY, 32);
}

```
Tokens:
Raw