duco_hash.cpp

#include "duco_hash.h"

#pragma GCC optimize ("-Ofast")

#define sha1_rotl(bits,word)     (((word) << (bits)) | ((word) >> (32 - (bits))))

void duco_hash_block(duco_hash_state_t * hasher) {
	// NOTE: keeping this static improves performance quite a lot
	static uint32_t w[16];

	for (uint8_t i = 0, i4 = 0; i < 16; i++, i4 += 4) {
		w[i] = (uint32_t(hasher->buffer[i4]) << 24) |
			(uint32_t(hasher->buffer[i4 + 1]) << 16) |
			(uint32_t(hasher->buffer[i4 + 2]) << 8) |
			(uint32_t(hasher->buffer[i4 + 3]));
	}
	
	uint32_t a = hasher->tempState[0];
	uint32_t b = hasher->tempState[1];
	uint32_t c = hasher->tempState[2];
	uint32_t d = hasher->tempState[3];
	uint32_t e = hasher->tempState[4];

	for (uint8_t i = 10; i < 80; i++) {
		if (i >= 16) {
			w[i & 15] = sha1_rotl(1, w[(i-3) & 15] ^ w[(i-8) & 15] ^ w[(i-14) & 15] ^ w[(i-16) & 15]);
		}

		uint32_t temp = sha1_rotl(5, a) + e + w[i & 15];
		if (i < 20) {
			temp += (b & c) | ((~b) & d);
			temp += 0x5a827999;
		} else if(i < 40) {
			temp += b ^ c ^ d;
			temp += 0x6ed9eba1;
		} else if(i < 60) {
			temp += (b & c) | (b & d) | (c & d);
			temp += 0x8f1bbcdc;
		} else {
			temp += b ^ c ^ d;
			temp += 0xca62c1d6;
		}

		e = d;
		d = c;
		c = sha1_rotl(30, b);
		b = a;
		a = temp;
	}

	a += 0x67452301;
	b += 0xefcdab89;
	c += 0x98badcfe;
	d += 0x10325476;
	e += 0xc3d2e1f0;

	hasher->result[0 * 4 + 0] = a >> 24;
	hasher->result[0 * 4 + 1] = a >> 16;
	hasher->result[0 * 4 + 2] = a >> 8;
	hasher->result[0 * 4 + 3] = a;
	hasher->result[1 * 4 + 0] = b >> 24;
	hasher->result[1 * 4 + 1] = b >> 16;
	hasher->result[1 * 4 + 2] = b >> 8;
	hasher->result[1 * 4 + 3] = b;
	hasher->result[2 * 4 + 0] = c >> 24;
	hasher->result[2 * 4 + 1] = c >> 16;
	hasher->result[2 * 4 + 2] = c >> 8;
	hasher->result[2 * 4 + 3] = c;
	hasher->result[3 * 4 + 0] = d >> 24;
	hasher->result[3 * 4 + 1] = d >> 16;
	hasher->result[3 * 4 + 2] = d >> 8;
	hasher->result[3 * 4 + 3] = d;
	hasher->result[4 * 4 + 0] = e >> 24;
	hasher->result[4 * 4 + 1] = e >> 16;
	hasher->result[4 * 4 + 2] = e >> 8;
	hasher->result[4 * 4 + 3] = e;
}

void duco_hash_init(duco_hash_state_t * hasher, char const * prevHash) {
	memcpy(hasher->buffer, prevHash, 40);

	if (prevHash == (void*)(0xffffffff)) {
		// NOTE: THIS IS NEVER CALLED
		// This is here to keep a live reference to hash_block
		// Otherwise GCC tries to inline it entirely into the main loop
		// Which causes massive perf degradation
		duco_hash_block(nullptr);
	}

	// Do first 10 rounds as these are going to be the same all time

	uint32_t a = 0x67452301;
	uint32_t b = 0xefcdab89;
	uint32_t c = 0x98badcfe;
	uint32_t d = 0x10325476;
	uint32_t e = 0xc3d2e1f0;

	static uint32_t w[10];

	for (uint8_t i = 0, i4 = 0; i < 10; i++, i4 += 4) {
		w[i] = (uint32_t(hasher->buffer[i4]) << 24) |
			(uint32_t(hasher->buffer[i4 + 1]) << 16) |
			(uint32_t(hasher->buffer[i4 + 2]) << 8) |
			(uint32_t(hasher->buffer[i4 + 3]));
	}

	for (uint8_t i = 0; i < 10; i++) {
		uint32_t temp = sha1_rotl(5, a) + e + w[i & 15];
		temp += (b & c) | ((~b) & d);
		temp += 0x5a827999;

		e = d;
		d = c;
		c = sha1_rotl(30, b);
		b = a;
		a = temp;
	}

	hasher->tempState[0] = a;
	hasher->tempState[1] = b;
	hasher->tempState[2] = c;
	hasher->tempState[3] = d;
	hasher->tempState[4] = e;
}

void duco_hash_set_nonce(duco_hash_state_t * hasher, char const * nonce) {
	uint8_t * b = hasher->buffer;

	uint8_t off = SHA1_HASH_LEN * 2;
	for (uint8_t i = 0; i < 10 && nonce[i] != 0; i++) {
		b[off++] = nonce[i];
	}

	uint8_t total_bytes = off;

	b[off++] = 0x80;
	while (off < 62) {
		b[off++] = 0;
	}

	b[62] = total_bytes >> 5;
	b[63] = total_bytes << 3;
}

uint8_t const * duco_hash_try_nonce(duco_hash_state_t * hasher, char const * nonce) {
	duco_hash_set_nonce(hasher, nonce);
	duco_hash_block(hasher);

	return hasher->result;
}