Initial revision of CPU miner.

NOTE: non-functional (incorrectly thinks it finds solution, too quickly)

.gitignore

@@ -0,0 +1,4 @@
+
+minerd
+*.o
+

Makefile

@@ -0,0 +1,22 @@
+
+CFLAGS= -O2 -Wall -g
+
+PROG	= minerd
+
+OBJS	= cpu-miner.o
+
+LDFLAGS	= $(CFLAGS)
+
+LIBS	= -lcurl -ljansson -lcrypto
+
+all:	$(PROG)
+
+.c.o:
+	gcc $(CFLAGS) -c $< -o $@
+
+clean:
+	rm -f $(PROG) $(OBJS)
+
+$(PROG):	$(OBJS)
+	gcc $(LDFLAGS) -o $(PROG) $(OBJS) $(LIBS)
+

cpu-miner.c

@@ -0,0 +1,391 @@
+
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdbool.h>
+#include <unistd.h>
+#include <jansson.h>
+#include <curl/curl.h>
+#include <openssl/bn.h>
+
+#include "sha256_generic.c"
+
+static const bool opt_verbose = true;
+static const bool opt_debug = true;
+
+struct data_buffer {
+	void		*buf;
+	size_t		len;
+};
+
+struct upload_buffer {
+	const void	*buf;
+	size_t		len;
+};
+
+struct work {
+	unsigned char	midstate[32];
+	unsigned char	data[128];
+	unsigned char	hash[64];
+	unsigned char	hash1[64];
+	BIGNUM		*target;
+};
+
+static void databuf_free(struct data_buffer *db)
+{
+	if (!db)
+		return;
+	
+	free(db->buf);
+
+	memset(db, 0, sizeof(*db));
+}
+
+static size_t all_data_cb(const void *ptr, size_t size, size_t nmemb,
+			  void *user_data)
+{
+	struct data_buffer *db = user_data;
+	size_t len = size * nmemb;
+	size_t oldlen, newlen;
+	void *newmem;
+	static const unsigned char zero;
+
+	if (opt_debug)
+		fprintf(stderr, "DBG(%s): %p, %lu, %lu, %p\n",
+			__func__, ptr, (unsigned long) size,
+			(unsigned long) nmemb, user_data);
+
+	oldlen = db->len;
+	newlen = oldlen + len;
+
+	newmem = realloc(db->buf, newlen + 1);
+	if (!newmem)
+		return 0;
+
+	db->buf = newmem;
+	db->len = newlen;
+	memcpy(db->buf + oldlen, ptr, len);
+	memcpy(db->buf + newlen, &zero, 1);	/* null terminate */
+
+	return len;
+}
+
+static size_t upload_data_cb(void *ptr, size_t size, size_t nmemb,
+			     void *user_data)
+{
+	struct upload_buffer *ub = user_data;
+	int len = size * nmemb;
+
+	if (opt_debug)
+		fprintf(stderr, "DBG(%s): %p, %lu, %lu, %p\n",
+			__func__, ptr, (unsigned long) size,
+			(unsigned long) nmemb, user_data);
+
+	if (len > ub->len)
+		len = ub->len;
+
+	if (len) {
+		memcpy(ptr, ub->buf, len);
+		ub->buf += len;
+		ub->len -= len;
+	}
+
+	return len;
+}
+
+static json_t *json_rpc_call(const char *url, const char *userpass,
+		       const char *rpc_req)
+{
+	CURL *curl;
+	json_t *val;
+	int rc;
+	struct data_buffer all_data = { };
+	struct upload_buffer upload_data;
+	json_error_t err = { };
+	struct curl_slist *headers = NULL;
+	char len_hdr[64];
+
+	curl = curl_easy_init();
+	if (!curl)
+		return NULL;
+
+	if (opt_verbose)
+		curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
+	curl_easy_setopt(curl, CURLOPT_URL, url);
+	curl_easy_setopt(curl, CURLOPT_ENCODING, "");
+	curl_easy_setopt(curl, CURLOPT_FAILONERROR, 1);
+	curl_easy_setopt(curl, CURLOPT_TCP_NODELAY, 1);
+	curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, all_data_cb);
+	curl_easy_setopt(curl, CURLOPT_WRITEDATA, &all_data);
+	curl_easy_setopt(curl, CURLOPT_READFUNCTION, upload_data_cb);
+	curl_easy_setopt(curl, CURLOPT_READDATA, &upload_data);
+	if (userpass) {
+		curl_easy_setopt(curl, CURLOPT_USERPWD, userpass);
+		curl_easy_setopt(curl, CURLOPT_HTTPAUTH, CURLAUTH_BASIC);
+	}
+	curl_easy_setopt(curl, CURLOPT_POST, 1);
+
+	upload_data.buf = rpc_req;
+	upload_data.len = strlen(rpc_req);
+	sprintf(len_hdr, "Content-Length: %lu",
+		(unsigned long) upload_data.len);
+
+	headers = curl_slist_append(headers,
+		"Content-type: application/json");
+	headers = curl_slist_append(headers, len_hdr);
+	headers = curl_slist_append(headers, "Expect:"); /* disable Expect hdr*/
+
+	curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
+
+	rc = curl_easy_perform(curl);
+	if (rc)
+		goto err_out;
+
+	if (opt_debug)
+		printf("====\nSERVER RETURNS:\n%s\n====\n",
+			(char *) all_data.buf);
+
+	val = json_loads(all_data.buf, &err);
+	if (!val) {
+		fprintf(stderr, "JSON failed(%d): %s\n", err.line, err.text);
+		goto err_out;
+	}
+
+	databuf_free(&all_data);
+	curl_slist_free_all(headers);
+	curl_easy_cleanup(curl);
+	return val;
+
+err_out:
+	databuf_free(&all_data);
+	curl_slist_free_all(headers);
+	curl_easy_cleanup(curl);
+	return NULL;
+}
+
+static bool hex2bin(unsigned char *p, const char *hexstr, size_t len)
+{
+	while (*hexstr && len) {
+		char hex_byte[3];
+		unsigned int v;
+
+		if (!hexstr[1]) {
+			fprintf(stderr, "hex2bin str truncated\n");
+			return false;
+		}
+
+		hex_byte[0] = hexstr[0];
+		hex_byte[1] = hexstr[1];
+		hex_byte[2] = 0;
+
+		if (sscanf(hex_byte, "%x", &v) != 1) {
+			fprintf(stderr, "hex2bin sscanf '%s' failed\n",
+				hex_byte);
+			return false;
+		}
+
+		*p = (unsigned char) v;
+
+		p++;
+		hexstr += 2;
+		len--;
+	}
+
+	return (len == 0 && *hexstr == 0) ? true : false;
+}
+
+static bool jobj_binary(const json_t *obj, const char *key,
+			void *buf, size_t buflen)
+{
+	const char *hexstr;
+	json_t *tmp;
+
+	tmp = json_object_get(obj, key);
+	if (!tmp) {
+		fprintf(stderr, "JSON key '%s' not found\n", key);
+		return false;
+	}
+	hexstr = json_string_value(tmp);
+	if (!hexstr) {
+		fprintf(stderr, "JSON key '%s' is not a string\n", key);
+		return false;
+	}
+	if (!hex2bin(buf, hexstr, buflen))
+		return false;
+
+	return true;
+}
+
+static void work_free(struct work *work)
+{
+	if (!work)
+		return;
+
+	if (work->target)
+		BN_free(work->target);
+
+	free(work);
+}
+
+static struct work *work_decode(const json_t *val)
+{
+	struct work *work;
+
+	work = calloc(1, sizeof(*work));
+	if (!work)
+		return NULL;
+
+	if (!jobj_binary(val, "midstate",
+			 work->midstate, sizeof(work->midstate))) {
+		fprintf(stderr, "JSON inval midstate\n");
+		goto err_out;
+	}
+
+	if (!jobj_binary(val, "data", work->data, sizeof(work->data))) {
+		fprintf(stderr, "JSON inval data\n");
+		goto err_out;
+	}
+
+	if (!jobj_binary(val, "hash1", work->hash1, sizeof(work->hash1))) {
+		fprintf(stderr, "JSON inval hash1\n");
+		goto err_out;
+	}
+
+	if (!BN_hex2bn(&work->target,
+		json_string_value(json_object_get(val, "target")))) {
+		fprintf(stderr, "JSON inval target\n");
+		goto err_out;
+	}
+
+	return work;
+
+err_out:
+	work_free(work);
+	return NULL;
+}
+
+static void runhash(void *state, void *input, const void *init)
+{
+	memcpy(state, init, 32);
+	sha256_transform(state, input);
+}
+
+static const uint32_t init_state[8] = {
+	0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
+	0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
+};
+
+static uint32_t scanhash(unsigned char *midstate, unsigned char *data,
+			 unsigned char *hash1, unsigned char *hash)
+{
+	uint32_t *nonce = (uint32_t *)(data + 12);
+	uint32_t n;
+
+	while (1) {
+		n = *nonce;
+		n++;
+		*nonce = n;
+
+		runhash(hash1, data, midstate);
+		runhash(hash, hash1, init_state);
+
+		if (((uint16_t *)hash)[14] == 0) {
+			if (opt_debug)
+				fprintf(stderr, "DBG: found zeroes in hash\n");
+			return n;
+		}
+
+		if ((n & 0xffffff) == 0) {
+			if (opt_debug)
+				fprintf(stderr, "DBG: end of nonce range\n");
+			return 0;
+		}
+	}
+}
+
+static const char *url = "http://127.0.0.1:8332/";
+static const char *userpass = "pretzel:smooth";
+
+static void submit_work(struct work *work)
+{
+	char hexstr[256 + 1], *s;
+	int i;
+	json_t *val;
+
+	printf("PROOF OF WORK FOUND\n");
+
+	for (i = 0; i < sizeof(work->data); i++)
+		sprintf(hexstr + (i * 2), "%02x", work->data[i]);
+
+	if (asprintf(&s,
+	    "{\"method\": \"getwork\", \"params\": [ \"%s\" ], \"id\":1}\r\n",
+	    hexstr) < 0) {
+		fprintf(stderr, "asprintf failed\n");
+		return;
+	}
+
+	if (opt_debug)
+		fprintf(stderr, "DBG: sending RPC call:\n%s", s);
+
+	val = json_rpc_call(url, userpass, s);
+	if (!val) {
+		fprintf(stderr, "submit_work json_rpc_call failed\n");
+		return;
+	}
+
+	free(s);
+	json_decref(val);
+}
+
+static int main_loop(void)
+{
+	static const char *rpc_req =
+		"{\"method\": \"getwork\", \"params\": [], \"id\":0}\r\n";
+
+	while (1) {
+		json_t *val;
+		struct work *work;
+		uint32_t nonce;
+
+		val = json_rpc_call(url, userpass, rpc_req);
+		if (!val) {
+			fprintf(stderr, "json_rpc_call failed\n");
+			return 1;
+		}
+
+		if (opt_verbose) {
+			char *s = json_dumps(val, JSON_INDENT(2));
+			printf("JSON output:\n%s\n", s);
+			free(s);
+		}
+
+		work = work_decode(json_object_get(val, "result"));
+		if (!work) {
+			fprintf(stderr, "work decode failed\n");
+			return 1;
+		}
+
+		json_decref(val);
+
+		nonce = scanhash(work->midstate, work->data + 64,
+				 work->hash1, work->hash);
+
+		if (nonce) {
+			submit_work(work);
+
+			fprintf(stderr, "sleeping, after proof-of-work...\n");
+			sleep(20);
+		}
+
+		work_free(work);
+	}
+
+	return 0;
+}
+
+int main (int argc, char *argv[])
+{
+	return main_loop();
+}
+

sha256_generic.c

@@ -0,0 +1,221 @@
+/*
+ * Cryptographic API.
+ *
+ * SHA-256, as specified in
+ * http://csrc.nist.gov/groups/STM/cavp/documents/shs/sha256-384-512.pdf
+ *
+ * SHA-256 code by Jean-Luc Cooke <jlcooke@certainkey.com>.
+ *
+ * Copyright (c) Jean-Luc Cooke <jlcooke@certainkey.com>
+ * Copyright (c) Andrew McDonald <andrew@mcdonald.org.uk>
+ * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
+ * SHA224 Support Copyright 2007 Intel Corporation <jonathan.lynch@intel.com>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option) 
+ * any later version.
+ *
+ */
+
+#include <stdint.h>
+#include <arpa/inet.h>
+
+typedef uint32_t u32;
+typedef uint8_t u8;
+
+static inline u32 ror32(u32 word, unsigned int shift)
+{
+	return (word >> shift) | (word << (32 - shift));
+}
+
+static inline u32 Ch(u32 x, u32 y, u32 z)
+{
+	return z ^ (x & (y ^ z));
+}
+
+static inline u32 Maj(u32 x, u32 y, u32 z)
+{
+	return (x & y) | (z & (x | y));
+}
+
+#define e0(x)       (ror32(x, 2) ^ ror32(x,13) ^ ror32(x,22))
+#define e1(x)       (ror32(x, 6) ^ ror32(x,11) ^ ror32(x,25))
+#define s0(x)       (ror32(x, 7) ^ ror32(x,18) ^ (x >> 3))
+#define s1(x)       (ror32(x,17) ^ ror32(x,19) ^ (x >> 10))
+
+static inline void LOAD_OP(int I, u32 *W, const u8 *input)
+{
+	W[I] = ntohl( ((u32*)(input))[I] );
+}
+
+static inline void BLEND_OP(int I, u32 *W)
+{
+	W[I] = s1(W[I-2]) + W[I-7] + s0(W[I-15]) + W[I-16];
+}
+
+static void sha256_transform(u32 *state, const u8 *input)
+{
+	u32 a, b, c, d, e, f, g, h, t1, t2;
+	u32 W[64];
+	int i;
+
+	/* load the input */
+	for (i = 0; i < 16; i++)
+		LOAD_OP(i, W, input);
+
+	/* now blend */
+	for (i = 16; i < 64; i++)
+		BLEND_OP(i, W);
+
+	/* load the state into our registers */
+	a=state[0];  b=state[1];  c=state[2];  d=state[3];
+	e=state[4];  f=state[5];  g=state[6];  h=state[7];
+
+	/* now iterate */
+	t1 = h + e1(e) + Ch(e,f,g) + 0x428a2f98 + W[ 0];
+	t2 = e0(a) + Maj(a,b,c);    d+=t1;    h=t1+t2;
+	t1 = g + e1(d) + Ch(d,e,f) + 0x71374491 + W[ 1];
+	t2 = e0(h) + Maj(h,a,b);    c+=t1;    g=t1+t2;
+	t1 = f + e1(c) + Ch(c,d,e) + 0xb5c0fbcf + W[ 2];
+	t2 = e0(g) + Maj(g,h,a);    b+=t1;    f=t1+t2;
+	t1 = e + e1(b) + Ch(b,c,d) + 0xe9b5dba5 + W[ 3];
+	t2 = e0(f) + Maj(f,g,h);    a+=t1;    e=t1+t2;
+	t1 = d + e1(a) + Ch(a,b,c) + 0x3956c25b + W[ 4];
+	t2 = e0(e) + Maj(e,f,g);    h+=t1;    d=t1+t2;
+	t1 = c + e1(h) + Ch(h,a,b) + 0x59f111f1 + W[ 5];
+	t2 = e0(d) + Maj(d,e,f);    g+=t1;    c=t1+t2;
+	t1 = b + e1(g) + Ch(g,h,a) + 0x923f82a4 + W[ 6];
+	t2 = e0(c) + Maj(c,d,e);    f+=t1;    b=t1+t2;
+	t1 = a + e1(f) + Ch(f,g,h) + 0xab1c5ed5 + W[ 7];
+	t2 = e0(b) + Maj(b,c,d);    e+=t1;    a=t1+t2;
+
+	t1 = h + e1(e) + Ch(e,f,g) + 0xd807aa98 + W[ 8];
+	t2 = e0(a) + Maj(a,b,c);    d+=t1;    h=t1+t2;
+	t1 = g + e1(d) + Ch(d,e,f) + 0x12835b01 + W[ 9];
+	t2 = e0(h) + Maj(h,a,b);    c+=t1;    g=t1+t2;
+	t1 = f + e1(c) + Ch(c,d,e) + 0x243185be + W[10];
+	t2 = e0(g) + Maj(g,h,a);    b+=t1;    f=t1+t2;
+	t1 = e + e1(b) + Ch(b,c,d) + 0x550c7dc3 + W[11];
+	t2 = e0(f) + Maj(f,g,h);    a+=t1;    e=t1+t2;
+	t1 = d + e1(a) + Ch(a,b,c) + 0x72be5d74 + W[12];
+	t2 = e0(e) + Maj(e,f,g);    h+=t1;    d=t1+t2;
+	t1 = c + e1(h) + Ch(h,a,b) + 0x80deb1fe + W[13];
+	t2 = e0(d) + Maj(d,e,f);    g+=t1;    c=t1+t2;
+	t1 = b + e1(g) + Ch(g,h,a) + 0x9bdc06a7 + W[14];
+	t2 = e0(c) + Maj(c,d,e);    f+=t1;    b=t1+t2;
+	t1 = a + e1(f) + Ch(f,g,h) + 0xc19bf174 + W[15];
+	t2 = e0(b) + Maj(b,c,d);    e+=t1;    a=t1+t2;
+
+	t1 = h + e1(e) + Ch(e,f,g) + 0xe49b69c1 + W[16];
+	t2 = e0(a) + Maj(a,b,c);    d+=t1;    h=t1+t2;
+	t1 = g + e1(d) + Ch(d,e,f) + 0xefbe4786 + W[17];
+	t2 = e0(h) + Maj(h,a,b);    c+=t1;    g=t1+t2;
+	t1 = f + e1(c) + Ch(c,d,e) + 0x0fc19dc6 + W[18];
+	t2 = e0(g) + Maj(g,h,a);    b+=t1;    f=t1+t2;
+	t1 = e + e1(b) + Ch(b,c,d) + 0x240ca1cc + W[19];
+	t2 = e0(f) + Maj(f,g,h);    a+=t1;    e=t1+t2;
+	t1 = d + e1(a) + Ch(a,b,c) + 0x2de92c6f + W[20];
+	t2 = e0(e) + Maj(e,f,g);    h+=t1;    d=t1+t2;
+	t1 = c + e1(h) + Ch(h,a,b) + 0x4a7484aa + W[21];
+	t2 = e0(d) + Maj(d,e,f);    g+=t1;    c=t1+t2;
+	t1 = b + e1(g) + Ch(g,h,a) + 0x5cb0a9dc + W[22];
+	t2 = e0(c) + Maj(c,d,e);    f+=t1;    b=t1+t2;
+	t1 = a + e1(f) + Ch(f,g,h) + 0x76f988da + W[23];
+	t2 = e0(b) + Maj(b,c,d);    e+=t1;    a=t1+t2;
+
+	t1 = h + e1(e) + Ch(e,f,g) + 0x983e5152 + W[24];
+	t2 = e0(a) + Maj(a,b,c);    d+=t1;    h=t1+t2;
+	t1 = g + e1(d) + Ch(d,e,f) + 0xa831c66d + W[25];
+	t2 = e0(h) + Maj(h,a,b);    c+=t1;    g=t1+t2;
+	t1 = f + e1(c) + Ch(c,d,e) + 0xb00327c8 + W[26];
+	t2 = e0(g) + Maj(g,h,a);    b+=t1;    f=t1+t2;
+	t1 = e + e1(b) + Ch(b,c,d) + 0xbf597fc7 + W[27];
+	t2 = e0(f) + Maj(f,g,h);    a+=t1;    e=t1+t2;
+	t1 = d + e1(a) + Ch(a,b,c) + 0xc6e00bf3 + W[28];
+	t2 = e0(e) + Maj(e,f,g);    h+=t1;    d=t1+t2;
+	t1 = c + e1(h) + Ch(h,a,b) + 0xd5a79147 + W[29];
+	t2 = e0(d) + Maj(d,e,f);    g+=t1;    c=t1+t2;
+	t1 = b + e1(g) + Ch(g,h,a) + 0x06ca6351 + W[30];
+	t2 = e0(c) + Maj(c,d,e);    f+=t1;    b=t1+t2;
+	t1 = a + e1(f) + Ch(f,g,h) + 0x14292967 + W[31];
+	t2 = e0(b) + Maj(b,c,d);    e+=t1;    a=t1+t2;
+
+	t1 = h + e1(e) + Ch(e,f,g) + 0x27b70a85 + W[32];
+	t2 = e0(a) + Maj(a,b,c);    d+=t1;    h=t1+t2;
+	t1 = g + e1(d) + Ch(d,e,f) + 0x2e1b2138 + W[33];
+	t2 = e0(h) + Maj(h,a,b);    c+=t1;    g=t1+t2;
+	t1 = f + e1(c) + Ch(c,d,e) + 0x4d2c6dfc + W[34];
+	t2 = e0(g) + Maj(g,h,a);    b+=t1;    f=t1+t2;
+	t1 = e + e1(b) + Ch(b,c,d) + 0x53380d13 + W[35];
+	t2 = e0(f) + Maj(f,g,h);    a+=t1;    e=t1+t2;
+	t1 = d + e1(a) + Ch(a,b,c) + 0x650a7354 + W[36];
+	t2 = e0(e) + Maj(e,f,g);    h+=t1;    d=t1+t2;
+	t1 = c + e1(h) + Ch(h,a,b) + 0x766a0abb + W[37];
+	t2 = e0(d) + Maj(d,e,f);    g+=t1;    c=t1+t2;
+	t1 = b + e1(g) + Ch(g,h,a) + 0x81c2c92e + W[38];
+	t2 = e0(c) + Maj(c,d,e);    f+=t1;    b=t1+t2;
+	t1 = a + e1(f) + Ch(f,g,h) + 0x92722c85 + W[39];
+	t2 = e0(b) + Maj(b,c,d);    e+=t1;    a=t1+t2;
+
+	t1 = h + e1(e) + Ch(e,f,g) + 0xa2bfe8a1 + W[40];
+	t2 = e0(a) + Maj(a,b,c);    d+=t1;    h=t1+t2;
+	t1 = g + e1(d) + Ch(d,e,f) + 0xa81a664b + W[41];
+	t2 = e0(h) + Maj(h,a,b);    c+=t1;    g=t1+t2;
+	t1 = f + e1(c) + Ch(c,d,e) + 0xc24b8b70 + W[42];
+	t2 = e0(g) + Maj(g,h,a);    b+=t1;    f=t1+t2;
+	t1 = e + e1(b) + Ch(b,c,d) + 0xc76c51a3 + W[43];
+	t2 = e0(f) + Maj(f,g,h);    a+=t1;    e=t1+t2;
+	t1 = d + e1(a) + Ch(a,b,c) + 0xd192e819 + W[44];
+	t2 = e0(e) + Maj(e,f,g);    h+=t1;    d=t1+t2;
+	t1 = c + e1(h) + Ch(h,a,b) + 0xd6990624 + W[45];
+	t2 = e0(d) + Maj(d,e,f);    g+=t1;    c=t1+t2;
+	t1 = b + e1(g) + Ch(g,h,a) + 0xf40e3585 + W[46];
+	t2 = e0(c) + Maj(c,d,e);    f+=t1;    b=t1+t2;
+	t1 = a + e1(f) + Ch(f,g,h) + 0x106aa070 + W[47];
+	t2 = e0(b) + Maj(b,c,d);    e+=t1;    a=t1+t2;
+
+	t1 = h + e1(e) + Ch(e,f,g) + 0x19a4c116 + W[48];
+	t2 = e0(a) + Maj(a,b,c);    d+=t1;    h=t1+t2;
+	t1 = g + e1(d) + Ch(d,e,f) + 0x1e376c08 + W[49];
+	t2 = e0(h) + Maj(h,a,b);    c+=t1;    g=t1+t2;
+	t1 = f + e1(c) + Ch(c,d,e) + 0x2748774c + W[50];
+	t2 = e0(g) + Maj(g,h,a);    b+=t1;    f=t1+t2;
+	t1 = e + e1(b) + Ch(b,c,d) + 0x34b0bcb5 + W[51];
+	t2 = e0(f) + Maj(f,g,h);    a+=t1;    e=t1+t2;
+	t1 = d + e1(a) + Ch(a,b,c) + 0x391c0cb3 + W[52];
+	t2 = e0(e) + Maj(e,f,g);    h+=t1;    d=t1+t2;
+	t1 = c + e1(h) + Ch(h,a,b) + 0x4ed8aa4a + W[53];
+	t2 = e0(d) + Maj(d,e,f);    g+=t1;    c=t1+t2;
+	t1 = b + e1(g) + Ch(g,h,a) + 0x5b9cca4f + W[54];
+	t2 = e0(c) + Maj(c,d,e);    f+=t1;    b=t1+t2;
+	t1 = a + e1(f) + Ch(f,g,h) + 0x682e6ff3 + W[55];
+	t2 = e0(b) + Maj(b,c,d);    e+=t1;    a=t1+t2;
+
+	t1 = h + e1(e) + Ch(e,f,g) + 0x748f82ee + W[56];
+	t2 = e0(a) + Maj(a,b,c);    d+=t1;    h=t1+t2;
+	t1 = g + e1(d) + Ch(d,e,f) + 0x78a5636f + W[57];
+	t2 = e0(h) + Maj(h,a,b);    c+=t1;    g=t1+t2;
+	t1 = f + e1(c) + Ch(c,d,e) + 0x84c87814 + W[58];
+	t2 = e0(g) + Maj(g,h,a);    b+=t1;    f=t1+t2;
+	t1 = e + e1(b) + Ch(b,c,d) + 0x8cc70208 + W[59];
+	t2 = e0(f) + Maj(f,g,h);    a+=t1;    e=t1+t2;
+	t1 = d + e1(a) + Ch(a,b,c) + 0x90befffa + W[60];
+	t2 = e0(e) + Maj(e,f,g);    h+=t1;    d=t1+t2;
+	t1 = c + e1(h) + Ch(h,a,b) + 0xa4506ceb + W[61];
+	t2 = e0(d) + Maj(d,e,f);    g+=t1;    c=t1+t2;
+	t1 = b + e1(g) + Ch(g,h,a) + 0xbef9a3f7 + W[62];
+	t2 = e0(c) + Maj(c,d,e);    f+=t1;    b=t1+t2;
+	t1 = a + e1(f) + Ch(f,g,h) + 0xc67178f2 + W[63];
+	t2 = e0(b) + Maj(b,c,d);    e+=t1;    a=t1+t2;
+
+	state[0] += a; state[1] += b; state[2] += c; state[3] += d;
+	state[4] += e; state[5] += f; state[6] += g; state[7] += h;
+
+#if 0
+	/* clear any sensitive info... */
+	a = b = c = d = e = f = g = h = t1 = t2 = 0;
+	memset(W, 0, 64 * sizeof(u32));
+#endif
+}
+