commit 9599867d8b9ddd909ea3dc37679b34cab5de5674 Author: Jeff Garzik Date: Tue Nov 23 23:33:20 2010 -0500 Initial revision of CPU miner. NOTE: non-functional (incorrectly thinks it finds solution, too quickly) diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..0ab7390 --- /dev/null +++ b/.gitignore @@ -0,0 +1,4 @@ + +minerd +*.o + diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..ac4519e --- /dev/null +++ b/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) + diff --git a/cpu-miner.c b/cpu-miner.c new file mode 100644 index 0000000..cb61ae2 --- /dev/null +++ b/cpu-miner.c @@ -0,0 +1,391 @@ + +#define _GNU_SOURCE +#include +#include +#include +#include +#include +#include +#include +#include + +#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(); +} + diff --git a/sha256_generic.c b/sha256_generic.c new file mode 100644 index 0000000..579e014 --- /dev/null +++ b/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 . + * + * Copyright (c) Jean-Luc Cooke + * Copyright (c) Andrew McDonald + * Copyright (c) 2002 James Morris + * SHA224 Support Copyright 2007 Intel Corporation + * + * 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 +#include + +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 +} +