Bitcoin Forum

#include <cstdint>
#include <iostream>
#include <cuda_runtime.h>
#include <iomanip>
#include <openssl/ripemd.h>
#include <openssl/sha.h>

#define BLOCK_SIZE 1024

__global__ void hash160(char *pattern, unsigned char *out, uint32_t *nonce)
{
	uint32_t index = blockIdx.x * blockDim.x + threadIdx.x;

	unsigned char hash[SHA256_DIGEST_LENGTH];
	char str[64];

	for (int i = 0; i < 9; i++) {
		str[i] = pattern[i];
	}

	for (uint32_t i = *nonce; i < UINT32_MAX; i += gridDim.x * blockDim.x) {
		sprintf(&str[9], "%08x", i);
		SHA256((const unsigned char*)str, strlen(str), hash);
		RIPEMD160(hash, SHA256_DIGEST_LENGTH, &out[index * 20]);
		if (out[index * 20] == 0x00 && out[index * 20 + 1] == 0x00) {
			// Found a match!
			*nonce = i;
			break;
		}
	}
}

int main()
{
	char pattern[10] = "1abcdefg"; // 9 characters pattern

								   // Allocate memory on the host
	unsigned char *out = new unsigned char[3 * 20];
	uint32_t *nonce = new uint32_t;
	*nonce = 0;

	// Allocate memory on the device
	char *dev_pattern;
	unsigned char *dev_out;
	uint32_t *dev_nonce;

	cudaMalloc((void**)&dev_pattern, 10);
	cudaMalloc((void**)&dev_out, 3 * 20);
	cudaMalloc((void**)&dev_nonce, sizeof(uint32_t));

	// Copy input data to the device
	cudaMemcpy(dev_pattern, pattern, 10, cudaMemcpyHostToDevice);
	cudaMemcpy(dev_out, out, 3 * 20, cudaMemcpyHostToDevice);
	cudaMemcpy(dev_nonce, nonce, sizeof(uint32_t), cudaMemcpyHostToDevice);

	// Launch the kernel
	hash160 << < 3, BLOCK_SIZE >> >(dev_pattern, dev_out, dev_nonce);

	// Copy output data from the device
	cudaMemcpy(out, dev_out, 3 * 20, cudaMemcpyDeviceToHost);
	cudaMemcpy(nonce, dev_nonce, sizeof(uint32_t), cudaMemcpyDeviceToHost);

	// Print the results
	for (int i = 0; i < 3; i++) {
		std::cout << "Address " << i + 1 << ": " << std::setbase(16);
		for (int j = 0; j < 20; j++) {
			std::cout << std::setw(2) << std::setfill('0') << (int)out[i * 20 + j];
		}
		std::cout << std::endl;
	}
	std::cout << "Nonce: " << *nonce << std::endl;

	// Free memory
	delete[] out;
	delete nonce;
	cudaFree(dev_pattern);
	cudaFree(dev_out);
	cudaFree(dev_nonce);

	return 0;
}

uint32_t index = blockIdx.x * blockDim.x + threadIdx.x;

hash160 <<< 3, BLOCK_SIZE >>>(dev_pattern, dev_out, dev_nonce);