Genesis Block Generator

#include <stdlib.h>
#include <stdio.h>
#include <stdbool.h>
#include <inttypes.h>
#include <ctype.h>
#include <string.h>
#include <time.h>
#include <openssl/sha.h>

//Copied from Bitcoin source
const uint64_t COIN = 100000000;
const uint64_t CENT = 1000000;

uint32_t OP_CHECKSIG = 172; // This is expressed as 0xAC
bool generateBlock = false;
uint32_t startNonce = 0;
uint32_t unixtime = 0;

typedef struct {
	/* Hash of Tx */
	uint8_t merkleHash[32];

	/* Tx serialization before hashing */
	uint8_t *serializedData;

	/* Tx version */
	uint32_t version;

	/* Input */
	uint8_t numInputs; // Program assumes one input
	uint8_t prevOutput[32];
	uint32_t prevoutIndex;
	uint8_t *scriptSig;
	uint32_t sequence;

	/* Output */
	uint8_t numOutputs; // Program assumes one output
	uint64_t outValue;
	uint8_t *pubkeyScript;

	/* Final */
	uint32_t locktime;
} Transaction;

// Got this off the internet. Am not sure if it can fail in some circumstances
void byteswap(uint8_t *buf, int length)
{
	int i;
	uint8_t temp;

	for(i = 0; i < length / 2; i++)
	{
		temp = buf[i];
		buf[i] = buf[length - i - 1];
		buf[length - i - 1] = temp;
	}
}

// Following two functions are borrowed from cgminer.
char *bin2hex(const unsigned char *p, size_t len)
{
	char *s = malloc((len * 2) + 1);
	unsigned int i;

	if (!s)
		return NULL;

	for (i = 0; i < len; i++)
		sprintf(s + (i * 2), "%02x", (unsigned int) p[i]);

	return s;
}

size_t hex2bin(unsigned char *p, const char *hexstr, size_t len)
{
	int ret = 0;
	size_t retlen = len;

	while (*hexstr && len) {
		char hex_byte[4];
		unsigned int v;

		if (!hexstr[1]) {
			return ret;
		}

		memset(hex_byte, 0, 4);
		hex_byte[0] = hexstr[0];
		hex_byte[1] = hexstr[1];

		if (sscanf(hex_byte, "%x", &v) != 1) {
			return ret;
		}

		*p = (unsigned char) v;

		p++;
		hexstr += 2;
		len--;
	}

	if (len == 0 && *hexstr == 0)
		ret = retlen;

	return ret;
}

Transaction *InitTransaction()
{
	Transaction *transaction;

	transaction = calloc(1, sizeof(*transaction));
	if(!transaction)
	{
		return NULL;
	}

	// Set some initial data that will remain constant throughout the program
	transaction->version = 1;
	transaction->numInputs = 1;
	transaction->numOutputs = 1;
	transaction->locktime = 0;
	transaction->prevoutIndex = 0xFFFFFFFF;
	transaction->sequence = 0xFFFFFFFF;
	transaction->outValue = 50*COIN;

	// We initialize the previous output to 0 as there is none
	memset(transaction->prevOutput, 0, 32);

	return transaction;
}

int main(int argc, char *argv[])
{
	Transaction *transaction;
	unsigned char hash1[32], hash2[32];
	char timestamp[255], pubkey[132];
	uint32_t timestamp_len = 0, scriptSig_len = 0, pubkey_len = 0, pubkeyScript_len = 0;
	uint32_t nBits = 0;

	if((argc-1) < 3)
	{
		fprintf(stderr, "Usage: genesisgen [options] <pubkey> \"<timestamp>\" <nBits>\n");
		return 0;
	}

	pubkey_len = strlen(argv[1]) / 2; // One byte is represented as two hex characters, thus we divide by two to get real length.
	timestamp_len = strlen(argv[2]);

	if(pubkey_len != 65)
	{
		fprintf(stderr, "Invalid public key length! %s\n", argv[1]);
		return 0;
	}

	if(timestamp_len > 254 || timestamp_len <= 0)
	{
		fprintf(stderr, "Size of timestamp is 0 or exceeds maximum length of 254 characters!\n");
		return 0;
	}

	transaction = InitTransaction();
	if(!transaction)
	{
		fprintf(stderr, "Could not allocate memory! Exiting...\n");
		return 0;
	}

	strncpy(pubkey, argv[1], sizeof(pubkey));
	strncpy(timestamp, argv[2], sizeof(timestamp));
	sscanf(argv[3], "%lu", (long unsigned int *)&nBits);

	pubkey_len = strlen(pubkey) >> 1;
	scriptSig_len = timestamp_len;

	// Encode pubkey to binary and prepend pubkey size, then append the OP_CHECKSIG byte
	transaction->pubkeyScript = malloc((pubkey_len+2)*sizeof(uint8_t));
	pubkeyScript_len = hex2bin(transaction->pubkeyScript+1, pubkey, pubkey_len); // No error checking, yeah.
	transaction->pubkeyScript[0] = 0x41; // A public key is 32 bytes X coordinate, 32 bytes Y coordinate and one byte 0x04, so 65 bytes i.e 0x41 in Hex.
	pubkeyScript_len+=1;
	transaction->pubkeyScript[pubkeyScript_len++] = OP_CHECKSIG;

	// Encode timestamp to binary
	transaction->scriptSig = malloc(scriptSig_len*sizeof(uint8_t));
	uint32_t scriptSig_pos = 0;


	// This is basically how I believe the size of the nBits is calculated
	if(nBits <= 255)
	{
		transaction->scriptSig[scriptSig_pos++] = 0x01;
		transaction->scriptSig[scriptSig_pos++] = (uint8_t)nBits;
	}
	else if(nBits <= 65535)
	{
		transaction->scriptSig[scriptSig_pos++] = 0x02;
		memcpy(transaction->scriptSig+scriptSig_pos, &nBits, 2);
		scriptSig_pos+=2;
	}
	else if(nBits <= 16777215)
	{
		transaction->scriptSig[scriptSig_pos++] = 0x03;
		memcpy(transaction->scriptSig+scriptSig_pos, &nBits, 3);
		scriptSig_pos+=3;
	}
	else //else if(nBits <= 4294967296LL)
	{
		transaction->scriptSig[scriptSig_pos++] = 0x04;
		memcpy(transaction->scriptSig+scriptSig_pos, &nBits, 4);
		scriptSig_pos+=4;
	}

	// Important! In the Bitcoin code there is a statement 'CBigNum(4)'
	// i've been wondering for a while what it is but
	// seeing as alt-coins keep it the same, we'll do it here as well
	// It should essentially mean PUSH 1 byte on the stack which in this case is 0x04 or just 4
	transaction->scriptSig[scriptSig_pos++] = 0x01;
	transaction->scriptSig[scriptSig_pos++] = 0x04;

	transaction->scriptSig[scriptSig_pos++] = (uint8_t)scriptSig_len;

	scriptSig_len += scriptSig_pos;
	transaction->scriptSig = realloc(transaction->scriptSig, scriptSig_len*sizeof(uint8_t));
	memcpy(transaction->scriptSig+scriptSig_pos, (const unsigned char *)timestamp, timestamp_len);

	// Here we are asuming some values will have the same size
	uint32_t serializedLen =
	4    // tx version
	+1   // number of inputs
	+32  // hash of previous output
	+4   // previous output's index
	+1   // 1 byte for the size of scriptSig
	+scriptSig_len
	+4   // size of sequence
	+1   // number of outputs
	+8   // 8 bytes for coin value
	+1   // 1 byte to represent size of the pubkey Script
	+pubkeyScript_len
	+4;   // 4 bytes for lock time

	// Now let's serialize the data
	uint32_t serializedData_pos = 0;
	transaction->serializedData = malloc(serializedLen*sizeof(uint8_t));
	memcpy(transaction->serializedData+serializedData_pos, &transaction->version, 4);
	serializedData_pos += 4;
	memcpy(transaction->serializedData+serializedData_pos, &transaction->numInputs, 1);
	serializedData_pos += 1;
	memcpy(transaction->serializedData+serializedData_pos, transaction->prevOutput, 32);
	serializedData_pos += 32;
	memcpy(transaction->serializedData+serializedData_pos, &transaction->prevoutIndex, 4);
	serializedData_pos += 4;
	memcpy(transaction->serializedData+serializedData_pos, &scriptSig_len, 1);
	serializedData_pos += 1;
	memcpy(transaction->serializedData+serializedData_pos, transaction->scriptSig, scriptSig_len);
	serializedData_pos += scriptSig_len;
	memcpy(transaction->serializedData+serializedData_pos, &transaction->sequence, 4);
	serializedData_pos += 4;
	memcpy(transaction->serializedData+serializedData_pos, &transaction->numOutputs, 1);
	serializedData_pos += 1;
	memcpy(transaction->serializedData+serializedData_pos, &transaction->outValue, 8);
	serializedData_pos += 8;
	memcpy(transaction->serializedData+serializedData_pos, &pubkeyScript_len, 1);
	serializedData_pos += 1;
	memcpy(transaction->serializedData+serializedData_pos, transaction->pubkeyScript, pubkeyScript_len);
	serializedData_pos += pubkeyScript_len;
	memcpy(transaction->serializedData+serializedData_pos, &transaction->locktime, 4);
	serializedData_pos += 4;

	// Now that the data is serialized
	// we hash it with SHA256 and then hash that result to get merkle hash
	SHA256(transaction->serializedData, serializedLen, hash1);
	SHA256(hash1, 32, hash2);

	// This copy isn't necessary imo, but here for clarity
	memcpy(transaction->merkleHash, hash2, 32);

	char *merkleHash = bin2hex(transaction->merkleHash, 32);
	byteswap(transaction->merkleHash, 32);
	char *merkleHashSwapped = bin2hex(transaction->merkleHash, 32);
	char *txScriptSig = bin2hex(transaction->scriptSig, scriptSig_len);
	char *pubScriptSig = bin2hex(transaction->pubkeyScript, pubkeyScript_len);
	printf("\nCoinbase: %s\n\nPubkeyScript: %s\n\nMerkle Hash: %s\nByteswapped: %s\n",txScriptSig, pubScriptSig, merkleHash, merkleHashSwapped);

	//if(generateBlock)
	{
		printf("Generating block...\n");
		if(!unixtime)
		{
			unixtime = time(NULL);
		}

		unsigned char block_header[80], block_hash1[32], block_hash2[32];
		uint32_t blockversion = 1;
		memcpy(block_header, &blockversion, 4);
		memset(block_header+4, 0, 32);
		byteswap(transaction->merkleHash, 32); // We swapped it before, so do it again now.
		memcpy(block_header+36, transaction->merkleHash, 32);
		memcpy(block_header+68, &unixtime, 4);
		memcpy(block_header+72, &nBits, 4);
		memcpy(block_header+76, &startNonce, 4);

		uint32_t *pNonce = (uint32_t *)(block_header + 76);
		uint32_t *pUnixtime = (uint32_t *)(block_header + 68);
		unsigned int counter, start = time(NULL);
		while(1)
		{
			SHA256(block_header, 80, block_hash1);
			SHA256(block_hash1, 32, block_hash2);

			unsigned int check = *((uint32_t *)(block_hash2 + 28)); // The hash is in little-endian, so we check the last 4 bytes.
			if(check == 0) // \x00\x00\x00\x00
			{
				byteswap(block_hash2, 32);
				char *blockHash = bin2hex(block_hash2, 32);
				printf("\nBlock found!\nHash: %s\nNonce: %u\nUnix time: %u", blockHash, startNonce, unixtime);
				free(blockHash);
				break;
			}

			startNonce++;
			counter+=1;
			if(time(NULL)-start >= 1)
			{
				printf("\r%d Hashes/s, Nonce %u\r", counter, startNonce);
				counter = 0;
				start = time(NULL);
			}
			*pNonce = startNonce;
			if(startNonce > 4294967294LL)
			{
				//printf("\nBlock found!\nHash: %s\nNonce: %u\nUnix time: %u", blockHash, startNonce, unixtime);
				unixtime++;
				*pUnixtime = unixtime;
				startNonce = 0;
			}
		}
	}


	// Lots of cleanup
	free(merkleHash);
	free(merkleHashSwapped);
	free(txScriptSig);
	free(pubScriptSig);
	free(transaction->serializedData);
	free(transaction->scriptSig);
	free(transaction->pubkeyScript);
	free(transaction);

	return 0;
}