v3.7.1

Makefile.am

@@ -138,7 +138,6 @@ cpuminer_SOURCES = \
   algo/x17/x17.c \
   algo/xevan.c \
   algo/yescrypt/yescrypt.c \
-  algo/yescrypt/yescrypt-common.c \
   algo/yescrypt/sha256_Y.c\
   algo/yescrypt/yescrypt-simd.c\
   algo/zr5.c

README.md

@@ -77,7 +77,8 @@ Supported Algorithms
                           x15          X15
                           x17
                           xevan        Bitsend
-                          yescrypt
+                          yescrypt     Globalboost-Y (BSTY)
+                          yescryptr16  Yenten (YTN)
                           zr5          Ziftr
 
 Requirements

RELEASE_NOTES

@@ -139,12 +139,18 @@ Support for even older x86_64 without AES_NI or SSE2 is not availble.
 Change Log
 ----------
 
+v3.7.1
+
+Added yescryptr16 algo for Yenten coin
+Added SHA support to yescrypt and yescryptr16
+Small code cleanup
+
 v3.7.0
 
 Fixed x14 misalignment bug.
 Fixed decred stake version bug.
 Getwork fixes for algos that use big endian data encoding: m7m, zr5, neoscrypt,
-blake2b, decred.
+decred.
 
 v3.6.10
 

algo-gate-api.c

@@ -211,6 +211,7 @@ bool register_algo_gate( int algo, algo_gate_t *gate )
      case ALGO_X17:          register_x17_algo         ( gate ); break;
      case ALGO_XEVAN:        register_xevan_algo       ( gate ); break;
      case ALGO_YESCRYPT:     register_yescrypt_algo    ( gate ); break;
+     case ALGO_YESCRYPTR16:  register_yescryptr16_algo ( gate ); break;
      case ALGO_ZR5:          register_zr5_algo         ( gate ); break;
 
 // restore warnings
@@ -294,6 +295,8 @@ const char* const algo_alias_map[][2] =
   { "timetravel8",       "timetravel"   },
   { "yes",               "yescrypt"     },
   { "ziftr",             "zr5"          },
+  { "yenten",            "yescryptr16"  },
+  { "yescryptr8",        "yescrypt"     },
   { "zcoin",             "lyra2z"       },
   { "zoin",              "lyra2z330"    },
   { NULL,                NULL           }   

algo/argon2/argon2a.c

@@ -1,5 +1,3 @@
-#include "miner.h"
-
 #include <stdlib.h>
 #include <stdint.h>
 #include <string.h>

algo/axiom.c

@@ -1,4 +1,3 @@
-#include "miner.h"
 #include "algo-gate-api.h"
 
 #include <string.h>

algo/blake/blake.c

@@ -1,4 +1,3 @@
-#include "miner.h"
 #include "algo-gate-api.h"
 #include "sph_blake.h"
 

algo/blake/blake2b.c

@@ -3,7 +3,6 @@
  * tpruvot@github 2015-2016
  */
 
-#include "miner.h"
 #include "algo-gate-api.h"
 #include <string.h>
 #include <stdint.h>
@@ -28,6 +27,7 @@ void blake2b_hash(void *output, const void *input)
 	memcpy(output, hash, 32);
 }
 
+/*
 static void blake2b_hash_end(uint32_t *output, const uint32_t *input)
 {
 	s_ctx.outlen = MIDLEN;
@@ -35,6 +35,7 @@ static void blake2b_hash_end(uint32_t *output, const uint32_t *input)
 	sph_blake2b_update(&s_ctx, (uint8_t*) &input[MIDLEN/4], 80 - MIDLEN);
 	sph_blake2b_final(&s_ctx, (uint8_t*) output);
 }
+*/
 
 int scanhash_blake2b( int thr_id, struct work *work, uint32_t max_nonce,
                       uint64_t *hashes_done )

algo/blake/blake2s.c

@@ -1,4 +1,3 @@
-#include "miner.h"
 #include "algo-gate-api.h"
 
 #include <string.h>

algo/blake/blakecoin.c

@@ -1,4 +1,3 @@
-#include "miner.h"
 #include "algo-gate-api.h"
 #define BLAKE32_ROUNDS 8
 #include "sph_blake.h"

algo/blake/decred.c

@@ -1,4 +1,3 @@
-#include "miner.h"
 #include "algo-gate-api.h"
 #include "sph_blake.h"
 

algo/blake/pentablake.c

@@ -1,4 +1,3 @@
-#include "miner.h"
 #include "algo-gate-api.h"
 #include <stdlib.h>
 #include <stdint.h>

algo/bmw/bmw256.c

@@ -1,4 +1,3 @@
-#include "miner.h"
 #include "algo-gate-api.h"
 
 #include <string.h>

algo/cryptonight/cryptolight.c

@@ -2,7 +2,6 @@
 // Distributed under the MIT/X11 software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include "miner.h"
 #include "algo-gate-api.h"
 
 #if defined(__arm__) || defined(_MSC_VER)

algo/cryptonight/cryptonight-common.c

@@ -5,7 +5,6 @@
 // Modified for CPUminer by Lucas Jones
 
 #include "cpuminer-config.h"
-//#include "miner.h"
 #include "algo-gate-api.h"
 
 #ifndef NO_AES_NI

algo/drop.c

@@ -32,7 +32,6 @@
 #define POK_BOOL_MASK 0x00008000
 #define POK_DATA_MASK 0xFFFF0000
  
-#include "miner.h"
 #include "algo-gate-api.h"
 
 #include <string.h>

algo/echo/aes_ni/vperm.h

@@ -53,11 +53,12 @@ extern const unsigned int _k_aesmix4[];
 	x  = _mm_shuffle_epi8(*((__m128i*)table + 0), x);\
 	x  = _mm_xor_si128(x, t1)
 
+#if 0
 // compiled erroneously with 32-bit msc compiler
-	//t2 = _mm_shuffle_epi8(table[0], x);\
+	t2 = _mm_shuffle_epi8(table[0], x);\
-	//x  = _mm_shuffle_epi8(table[1], t1);\
+	x  = _mm_shuffle_epi8(table[1], t1);\
-	//x  = _mm_xor_si128(x, t2)
+	x  = _mm_xor_si128(x, t2)
-
+#endif
 
 // input: x
 // output: t2, t3

algo/fresh.c

@@ -1,4 +1,3 @@
-#include "miner.h"
 #include "algo-gate-api.h"
 
 #include <stdlib.h>

algo/groestl/groestl.c

@@ -1,4 +1,3 @@
-#include "miner.h"
 #include "algo-gate-api.h"
 
 #include <stdio.h>

algo/groestl/myr-groestl.c

@@ -1,4 +1,3 @@
-#include "miner.h"
 #include "algo-gate-api.h"
 
 #include <stdio.h>

algo/heavy/bastion.c

@@ -1,4 +1,3 @@
-#include "miner.h"
 #include "algo-gate-api.h"
 
 #include <stdio.h>

algo/heavy/heavy.c

@@ -2,7 +2,6 @@
 #include <openssl/sha.h>
 #include <stdint.h>
 
-#include "miner.h"
 #include "algo-gate-api.h"
 #include "sph_hefty1.h"
 #include "algo/keccak/sph_keccak.h"

algo/hmq1725.c

@@ -1,4 +1,3 @@
-#include "miner.h"
 #include "algo-gate-api.h"
 
 #include <string.h>

algo/hodl/hodl-gate.c

@@ -1,10 +1,7 @@
 #include <memory.h>
 #include <stdlib.h>
 
-#include "miner.h"
-//#include "algo-gate-api.h"
 #include "hodl-gate.h"
-//#include "hodl.h"
 #include "hodl-wolf.h"
 
 #define HODL_NSTARTLOC_INDEX 20

algo/jh/jha.c

@@ -1,4 +1,3 @@
-#include "miner.h"
 #include "algo-gate-api.h"
 
 #include <stdlib.h>

algo/keccak/keccak.c

@@ -1,4 +1,3 @@
-#include "miner.h"
 #include "algo-gate-api.h"
 
 #include <stdlib.h>

algo/lbry.c

@@ -1,4 +1,3 @@
-#include "miner.h"
 #include "algo-gate-api.h"
 #include <stdlib.h>
 #include <stdint.h>

algo/luffa/luffa.c

@@ -1,4 +1,3 @@
-#include "miner.h"
 #include "algo-gate-api.h"
 
 #include <stdlib.h>

algo/lyra2/lyra2re.c

@@ -1,6 +1,5 @@
 #include <memory.h>
 
-#include "miner.h"
 #include "algo/blake/sph_blake.h"
 #include "algo/groestl/sph_groestl.h"
 #include "algo/skein/sph_skein.h"

algo/lyra2/lyra2rev2.c

@@ -1,6 +1,5 @@
 #include <memory.h>
 
-#include "miner.h"
 #include "algo-gate-api.h"
 
 #include "algo/blake/sph_blake.h"

algo/lyra2/lyra2z330.c

@@ -1,5 +1,4 @@
 #include <memory.h>
-#include "miner.h"
 #include "algo-gate-api.h"
 #include "lyra2.h"
 #include "avxdefs.h"

algo/lyra2/zcoin.c

@@ -1,6 +1,5 @@
 #include <memory.h>
 #include <mm_malloc.h>
-#include "miner.h"
 #include "algo-gate-api.h"
 #include "lyra2.h"
 #include "algo/blake/sph_blake.h"

algo/m7m.c

@@ -1,5 +1,4 @@
 #include "cpuminer-config.h"
-#include "miner.h"
 #include "algo-gate-api.h"
 
 #include <gmp.h>

algo/neoscrypt.c

@@ -31,7 +31,6 @@
 #include <string.h>
 #include <unistd.h>
 
-#include "miner.h"
 #include "algo-gate-api.h"
 
 #define USE_CUSTOM_BLAKE2S

algo/nist5.c

@@ -1,4 +1,3 @@
-#include "miner.h"
 #include "algo-gate-api.h"
 
 #include <stdlib.h>

algo/pluck.c

@@ -25,7 +25,6 @@
  */
 
 #include "cpuminer-config.h"
-#include "miner.h"
 #include "algo-gate-api.h"
 
 #include <stdlib.h>

algo/quark/quark.c

@@ -1,5 +1,4 @@
 #include "cpuminer-config.h"
-#include "miner.h"
 #include "algo-gate-api.h"
 
 #include <stdio.h>

algo/qubit/deep.c

@@ -1,4 +1,3 @@
-#include "miner.h"
 #include "algo-gate-api.h"
 
 #include <stdlib.h>

algo/qubit/qubit.c

@@ -1,4 +1,3 @@
-#include "miner.h"
 #include "algo-gate-api.h"
 
 #include <stdlib.h>

algo/scrypt.c

@@ -27,7 +27,6 @@
  * online backup system.
  */
 
-#include "miner.h"
 #include "algo-gate-api.h"
 
 #include <stdlib.h>

algo/scryptjane/scrypt-jane.c

@@ -1,5 +1,3 @@
-#include "miner.h"
-
 #include <stdlib.h>
 #include <string.h>
 #include "inttypes.h"

algo/sha/sha2.c

@@ -8,7 +8,6 @@
  * any later version.  See COPYING for more details.
  */
 
-#include "miner.h"
 #include "algo-gate-api.h"
 
 #include <string.h>

algo/sha/sha256t.c

@@ -1,4 +1,3 @@
-#include "miner.h"
 #include "algo-gate-api.h"
 
 #include <stdlib.h>

algo/skein/skein.c

@@ -1,4 +1,3 @@
-#include "miner.h"
 #include "algo-gate-api.h"
 
 #include <string.h>

algo/skein/skein2.c

@@ -1,4 +1,3 @@
-#include "miner.h"
 #include "algo-gate-api.h"
 #include <string.h>
 #include <stdint.h>

algo/skunk.c

@@ -1,4 +1,3 @@
-#include "miner.h"
 #include "algo-gate-api.h"
 
 #include <stdlib.h>

algo/timetravel.c

@@ -1,4 +1,3 @@
-#include <miner.h>
 #include "algo-gate-api.h"
 
 #include <stdlib.h>

algo/timetravel10.c

@@ -1,4 +1,3 @@
-#include <miner.h>
 #include "algo-gate-api.h"
 
 #include <stdlib.h>

algo/tribus.c

@@ -1,4 +1,3 @@
-#include "miner.h"
 #include "algo-gate-api.h"
 #include <stdlib.h>
 #include <stdint.h>

algo/veltor.c

@@ -1,4 +1,3 @@
-#include "miner.h"
 #include "algo-gate-api.h"
 #include <stdlib.h>
 #include <stdint.h>

algo/whirlpool/whirlpool.c

@@ -1,4 +1,3 @@
-#include "miner.h"
 #include "algo-gate-api.h"
 
 #include <stdlib.h>

algo/whirlpool/whirlpoolx.c

@@ -1,4 +1,3 @@
-#include "miner.h"
 #include "algo-gate-api.h"
 
 #include <stdlib.h>

algo/x11/c11.c

@@ -1,4 +1,3 @@
-#include "miner.h"
 #include "algo-gate-api.h"
 
 #include <stdlib.h>

algo/x11/phi1612.c

@@ -1,4 +1,3 @@
-#include "miner.h"
 #include "algo-gate-api.h"
 
 #include <stdlib.h>

algo/x11/x11.c

@@ -1,5 +1,4 @@
 #include "cpuminer-config.h"
-#include "miner.h"
 #include "algo-gate-api.h"
 
 #include <string.h>

algo/x11/x11evo.c

@@ -1,5 +1,4 @@
 #include "cpuminer-config.h"
-#include "miner.h"
 #include "algo-gate-api.h"
 
 #include <string.h>

algo/x11/x11gost.c

@@ -1,4 +1,3 @@
-#include "miner.h"
 #include "algo-gate-api.h"
 
 #include <stdlib.h>

algo/x13/x13.c

@@ -1,4 +1,3 @@
-#include "miner.h"
 #include "algo-gate-api.h"
 
 #include <stdlib.h>

algo/x13/x13sm3.c

@@ -1,4 +1,3 @@
-#include "miner.h"
 #include "algo-gate-api.h"
 
 #include <stdlib.h>

algo/x14/x14.c

@@ -1,4 +1,3 @@
-#include "miner.h"
 #include "algo-gate-api.h"
 
 #include <stdlib.h>

algo/x15/x15.c

@@ -1,4 +1,3 @@
-#include "miner.h"
 #include "algo-gate-api.h"
 
 #include <stdlib.h>

algo/x17/x17.c

@@ -1,4 +1,3 @@
-#include "miner.h"
 #include "algo-gate-api.h"
 
 #include <stdlib.h>

algo/xevan.c

@@ -1,4 +1,3 @@
-#include <miner.h>
 #include "algo-gate-api.h"
 
 #include <stdlib.h>

algo/yescrypt/sha256_Y.c

@@ -90,7 +90,7 @@ be32dec_vect(uint32_t *dst, const unsigned char *src, size_t len)
  * the 512-bit input block to produce a new state.
  */
 static void
-SHA256_Transform(uint32_t * state, const unsigned char block[64])
+SHA256_Transform_Y(uint32_t * state, const unsigned char block[64])
 {
 	uint32_t _ALIGN(128) W[64], S[8];
 	uint32_t t0, t1;
@@ -190,7 +190,7 @@ static unsigned char PAD[64] = {
 
 /* Add padding and terminating bit-count. */
 static void
-SHA256_Pad(SHA256_CTX_Y * ctx)
+SHA256_Pad_Y(SHA256_CTX_Y * ctx)
 {
 	unsigned char len[8];
 	uint32_t r, plen;
@@ -214,7 +214,6 @@ SHA256_Pad(SHA256_CTX_Y * ctx)
 void
 SHA256_Init_Y(SHA256_CTX_Y * ctx)
 {
-
 	/* Zero bits processed so far */
 	ctx->count[0] = ctx->count[1] = 0;
 
@@ -257,13 +256,13 @@ SHA256_Update_Y(SHA256_CTX_Y * ctx, const void *in, size_t len)
 
 	/* Finish the current block */
 	memcpy(&ctx->buf[r], src, 64 - r);
-	SHA256_Transform(ctx->state, ctx->buf);
+        SHA256_Transform_Y(ctx->state, ctx->buf);
 	src += 64 - r;
 	len -= 64 - r;
 
 	/* Perform complete blocks */
 	while (len >= 64) {
-		SHA256_Transform(ctx->state, src);
+		SHA256_Transform_Y(ctx->state, src);
 		src += 64;
 		len -= 64;
 	}
@@ -279,9 +278,8 @@ SHA256_Update_Y(SHA256_CTX_Y * ctx, const void *in, size_t len)
 void
 SHA256_Final_Y(unsigned char digest[32], SHA256_CTX_Y * ctx)
 {
-
 	/* Add padding */
-	SHA256_Pad(ctx);
+	SHA256_Pad_Y(ctx);
 
 	/* Write the hash */
 	be32enc_vect(digest, ctx->state, 32);
@@ -292,7 +290,7 @@ SHA256_Final_Y(unsigned char digest[32], SHA256_CTX_Y * ctx)
 
 /* Initialize an HMAC-SHA256 operation with the given key. */
 void
-HMAC_SHA256_Init_Y(HMAC_SHA256_CTX_Y * ctx, const void * _K, size_t Klen)
+HMAC_SHA256_Init(HMAC_SHA256_CTX * ctx, const void * _K, size_t Klen)
 {
 	unsigned char pad[64];
 	unsigned char khash[32];
@@ -301,26 +299,48 @@ HMAC_SHA256_Init_Y(HMAC_SHA256_CTX_Y * ctx, const void * _K, size_t Klen)
 
 	/* If Klen > 64, the key is really SHA256(K). */
 	if (Klen > 64) {
-		SHA256_Init_Y(&ctx->ictx);
+#if defined __SHA__
-		SHA256_Update_Y(&ctx->ictx, K, Klen);
+		SHA256_Init(&ctx->ictx);
-		SHA256_Final_Y(khash, &ctx->ictx);
+		SHA256_Update(&ctx->ictx, K, Klen);
+		SHA256_Final(khash, &ctx->ictx);
+#else
+                SHA256_Init_Y(&ctx->ictx);
+                SHA256_Update_Y(&ctx->ictx, K, Klen);
+                SHA256_Final_Y(khash, &ctx->ictx);
+#endif
 		K = khash;
 		Klen = 32;
 	}
 
 	/* Inner SHA256 operation is SHA256(K xor [block of 0x36] || data). */
-	SHA256_Init_Y(&ctx->ictx);
+#if defined __SHA__
+	SHA256_Init(&ctx->ictx);
+#else
+        SHA256_Init_Y(&ctx->ictx);
+#endif
 	memset(pad, 0x36, 64);
 	for (i = 0; i < Klen; i++)
 		pad[i] ^= K[i];
-	SHA256_Update_Y(&ctx->ictx, pad, 64);
+#if defined __SHA__
+	SHA256_Update(&ctx->ictx, pad, 64);
+#else
+        SHA256_Update_Y(&ctx->ictx, pad, 64);
+#endif
 
 	/* Outer SHA256 operation is SHA256(K xor [block of 0x5c] || hash). */
-	SHA256_Init_Y(&ctx->octx);
+#if defined __SHA__
+	SHA256_Init(&ctx->octx);
+#else
+        SHA256_Init_Y(&ctx->octx);
+#endif
 	memset(pad, 0x5c, 64);
 	for (i = 0; i < Klen; i++)
 		pad[i] ^= K[i];
-	SHA256_Update_Y(&ctx->octx, pad, 64);
+#if defined __SHA__
+	SHA256_Update(&ctx->octx, pad, 64);
+#else
+        SHA256_Update_Y(&ctx->octx, pad, 64);
+#endif
 
 	/* Clean the stack. */
 	//memset(khash, 0, 32);
@@ -328,27 +348,42 @@ HMAC_SHA256_Init_Y(HMAC_SHA256_CTX_Y * ctx, const void * _K, size_t Klen)
 
 /* Add bytes to the HMAC-SHA256 operation. */
 void
-HMAC_SHA256_Update_Y(HMAC_SHA256_CTX_Y * ctx, const void *in, size_t len)
+HMAC_SHA256_Update(HMAC_SHA256_CTX * ctx, const void *in, size_t len)
 {
 
 	/* Feed data to the inner SHA256 operation. */
-	SHA256_Update_Y(&ctx->ictx, in, len);
+#if defined __SHA__
+	SHA256_Update(&ctx->ictx, in, len);
+#else
+        SHA256_Update_Y(&ctx->ictx, in, len);
+#endif
 }
 
 /* Finish an HMAC-SHA256 operation. */
 void
-HMAC_SHA256_Final_Y(unsigned char digest[32], HMAC_SHA256_CTX_Y * ctx)
+HMAC_SHA256_Final(unsigned char digest[32], HMAC_SHA256_CTX * ctx)
 {
 	unsigned char ihash[32];
 
+#if defined __SHA__
 	/* Finish the inner SHA256 operation. */
-	SHA256_Final_Y(ihash, &ctx->ictx);
+	SHA256_Final(ihash, &ctx->ictx);
 
 	/* Feed the inner hash to the outer SHA256 operation. */
-	SHA256_Update_Y(&ctx->octx, ihash, 32);
+	SHA256_Update(&ctx->octx, ihash, 32);
 
 	/* Finish the outer SHA256 operation. */
-	SHA256_Final_Y(digest, &ctx->octx);
+	SHA256_Final(digest, &ctx->octx);
+#else
+        /* Finish the inner SHA256 operation. */
+        SHA256_Final_Y(ihash, &ctx->ictx);
+
+        /* Feed the inner hash to the outer SHA256 operation. */
+        SHA256_Update_Y(&ctx->octx, ihash, 32);
+
+        /* Finish the outer SHA256 operation. */
+        SHA256_Final_Y(digest, &ctx->octx);
+#endif
 
 	/* Clean the stack. */
 	//memset(ihash, 0, 32);
@@ -363,7 +398,7 @@ void
 PBKDF2_SHA256(const uint8_t * passwd, size_t passwdlen, const uint8_t * salt,
     size_t saltlen, uint64_t c, uint8_t * buf, size_t dkLen)
 {
-	HMAC_SHA256_CTX_Y PShctx, hctx;
+	HMAC_SHA256_CTX PShctx, hctx;
 	uint8_t _ALIGN(128) T[32];
 	uint8_t _ALIGN(128) U[32];
 	uint8_t ivec[4];
@@ -372,8 +407,8 @@ PBKDF2_SHA256(const uint8_t * passwd, size_t passwdlen, const uint8_t * salt,
 	int k;
 
 	/* Compute HMAC state after processing P and S. */
-	HMAC_SHA256_Init_Y(&PShctx, passwd, passwdlen);
+	HMAC_SHA256_Init(&PShctx, passwd, passwdlen);
-	HMAC_SHA256_Update_Y(&PShctx, salt, saltlen);
+	HMAC_SHA256_Update(&PShctx, salt, saltlen);
 
 	/* Iterate through the blocks. */
 	for (i = 0; i * 32 < dkLen; i++) {
@@ -381,18 +416,18 @@ PBKDF2_SHA256(const uint8_t * passwd, size_t passwdlen, const uint8_t * salt,
 		be32enc(ivec, (uint32_t)(i + 1));
 
 		/* Compute U_1 = PRF(P, S || INT(i)). */
-		memcpy(&hctx, &PShctx, sizeof(HMAC_SHA256_CTX_Y));
+		memcpy(&hctx, &PShctx, sizeof(HMAC_SHA256_CTX));
-		HMAC_SHA256_Update_Y(&hctx, ivec, 4);
+		HMAC_SHA256_Update(&hctx, ivec, 4);
-		HMAC_SHA256_Final_Y(U, &hctx);
+		HMAC_SHA256_Final(U, &hctx);
 
 		/* T_i = U_1 ... */
 		memcpy(T, U, 32);
 
 		for (j = 2; j <= c; j++) {
 			/* Compute U_j. */
-			HMAC_SHA256_Init_Y(&hctx, passwd, passwdlen);
+			HMAC_SHA256_Init(&hctx, passwd, passwdlen);
-			HMAC_SHA256_Update_Y(&hctx, U, 32);
+			HMAC_SHA256_Update(&hctx, U, 32);
-			HMAC_SHA256_Final_Y(U, &hctx);
+			HMAC_SHA256_Final(U, &hctx);
 
 			/* ... xor U_j ... */
 			for (k = 0; k < 32; k++)

algo/yescrypt/sha256_Y.h

@@ -33,23 +33,39 @@
 
 #include <stdint.h>
 
+#if defined __SHA__
+  #include <openssl/sha.h>
+#endif
+
 typedef struct SHA256Context {
 	uint32_t state[8];
 	uint32_t count[2];
 	unsigned char buf[64];
 } SHA256_CTX_Y;
 
+/*
 typedef struct HMAC_SHA256Context {
 	SHA256_CTX_Y ictx;
 	SHA256_CTX_Y octx;
 } HMAC_SHA256_CTX_Y;
+*/
+
+typedef struct HMAC_SHA256Context {
+#if defined __SHA__
+        SHA256_CTX ictx;
+        SHA256_CTX octx;
+#else
+        SHA256_CTX_Y ictx;
+        SHA256_CTX_Y octx;
+#endif
+} HMAC_SHA256_CTX;
 
 void	SHA256_Init_Y(SHA256_CTX_Y *);
 void	SHA256_Update_Y(SHA256_CTX_Y *, const void *, size_t);
 void	SHA256_Final_Y(unsigned char [32], SHA256_CTX_Y *);
-void	HMAC_SHA256_Init_Y(HMAC_SHA256_CTX_Y *, const void *, size_t);
+void	HMAC_SHA256_Init(HMAC_SHA256_CTX *, const void *, size_t);
-void	HMAC_SHA256_Update_Y(HMAC_SHA256_CTX_Y *, const void *, size_t);
+void	HMAC_SHA256_Update(HMAC_SHA256_CTX *, const void *, size_t);
-void	HMAC_SHA256_Final_Y(unsigned char [32], HMAC_SHA256_CTX_Y *);
+void	HMAC_SHA256_Final(unsigned char [32], HMAC_SHA256_CTX *);
 
 /**
  * PBKDF2_SHA256(passwd, passwdlen, salt, saltlen, c, buf, dkLen):

algo/yescrypt/yescrypt-common.c

@@ -1,374 +0,0 @@
-/*-
- * Copyright 2013,2014 Alexander Peslyak
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <stdint.h>
-#include <string.h>
-#include <stdio.h>
-
-#include "compat.h"
-
-#include "yescrypt.h"
-
-#define BYTES2CHARS(bytes) \
-	((((bytes) * 8) + 5) / 6)
-
-#define HASH_SIZE 32 /* bytes */
-#define HASH_LEN BYTES2CHARS(HASH_SIZE) /* base-64 chars */
-#define YESCRYPT_FLAGS (YESCRYPT_RW | YESCRYPT_PWXFORM)
-
-static const char * const itoa64 =
-	"./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-
-static uint8_t* encode64_uint32(uint8_t* dst, size_t dstlen, uint32_t src, uint32_t srcbits)
-{
-	uint32_t bit;
-
-	for (bit = 0; bit < srcbits; bit += 6) {
-		if (dstlen < 1)
-			return NULL;
-		*dst++ = itoa64[src & 0x3f];
-		dstlen--;
-		src >>= 6;
-	}
-
-	return dst;
-}
-
-static uint8_t* encode64(uint8_t* dst, size_t dstlen, const uint8_t* src, size_t srclen)
-{
-	size_t i;
-
-	for (i = 0; i < srclen; ) {
-		uint8_t * dnext;
-		uint32_t value = 0, bits = 0;
-		do {
-			value |= (uint32_t)src[i++] << bits;
-			bits += 8;
-		} while (bits < 24 && i < srclen);
-		dnext = encode64_uint32(dst, dstlen, value, bits);
-		if (!dnext)
-			return NULL;
-		dstlen -= dnext - dst;
-		dst = dnext;
-	}
-
-	return dst;
-}
-
-static int decode64_one(uint32_t* dst, uint8_t src)
-{
-	const char * ptr = strchr(itoa64, src);
-	if (ptr) {
-		*dst = (uint32_t) (ptr - itoa64);
-		return 0;
-	}
-	*dst = 0;
-	return -1;
-}
-
-static const uint8_t* decode64_uint32(uint32_t* dst, uint32_t dstbits, const uint8_t* src)
-{
-	uint32_t bit;
-	uint32_t value;
-
-	value = 0;
-	for (bit = 0; bit < dstbits; bit += 6) {
-		uint32_t one;
-		if (decode64_one(&one, *src)) {
-			*dst = 0;
-			return NULL;
-		}
-		src++;
-		value |= one << bit;
-	}
-
-	*dst = value;
-	return src;
-}
-
-uint8_t* yescrypt_r(const yescrypt_shared_t* shared, yescrypt_local_t* local,
-    const uint8_t* passwd, size_t passwdlen, const uint8_t* setting, uint8_t* buf, size_t buflen)
-{
-	uint8_t hash[HASH_SIZE];
-	const uint8_t * src, * salt;
-	uint8_t * dst;
-	size_t prefixlen, saltlen, need;
-	uint8_t version;
-	uint64_t N;
-	uint32_t r, p;
-	yescrypt_flags_t flags = YESCRYPT_WORM;
-
-	printf("pass1 ...");
-	fflush(stdout);
-
-	if (setting[0] != '$' || setting[1] != '7') {
-		printf("died$7 ...");
-		fflush(stdout);
-		return NULL;
-	}
-
-	printf("died80 ...");
-	fflush(stdout);
-
-	src = setting + 2;
-
-	printf("hello '%p'\n", (char *)src);
-	fflush(stdout);
-
-	switch ((version = *src)) {
-	case '$':
-		printf("died2 ...");
-		fflush(stdout);
-		break;
-	case 'X':
-		src++;
-		flags = YESCRYPT_RW;
-		printf("died3 ...");
-		fflush(stdout);
-		break;
-	default:
-		printf("died4 ...");
-		fflush(stdout);
-		return NULL;
-	}
-
-	printf("pass2 ...");
-	fflush(stdout);
-
-	if (*src != '$') {
-		uint32_t decoded_flags;
-		if (decode64_one(&decoded_flags, *src)) {
-			printf("died5 ...");
-			fflush(stdout);
-			return NULL;
-		}
-		flags = decoded_flags;
-		if (*++src != '$') {
-			printf("died6 ...");
-			fflush(stdout);
-			return NULL;
-		}
-	}
-
-	src++;
-
-	{
-		uint32_t N_log2;
-		if (decode64_one(&N_log2, *src)) {
-			printf("died7 ...");
-			return NULL;
-		}
-		src++;
-		N = (uint64_t)1 << N_log2;
-	}
-
-	src = decode64_uint32(&r, 30, src);
-	if (!src) {
-		printf("died6 ...");
-		return NULL;
-	}
-
-	src = decode64_uint32(&p, 30, src);
-	if (!src) {
-		printf("died7 ...");
-		return NULL;
-	}
-
-	prefixlen = src - setting;
-
-	salt = src;
-	src = (uint8_t *)strrchr((char *)salt, '$');
-	if (src)
-		saltlen = src - salt;
-	else
-		saltlen = strlen((char *)salt);
-
-	need = prefixlen + saltlen + 1 + HASH_LEN + 1;
-	if (need > buflen || need < saltlen) {
-		printf("'%d %d %d'", (int) need, (int) buflen, (int) saltlen);
-		printf("died8killbuf ...");
-		fflush(stdout);
-		return NULL;
-	}
-
-	if (yescrypt_kdf(shared, local, passwd, passwdlen, salt, saltlen, N, r, p, 0, flags, hash, sizeof(hash))) {
-		printf("died10 ...");
-		fflush(stdout);
-		return NULL;
-	}
-
-	dst = buf;
-	memcpy(dst, setting, prefixlen + saltlen);
-	dst += prefixlen + saltlen;
-	*dst++ = '$';
-
-	dst = encode64(dst, buflen - (dst - buf), hash, sizeof(hash));
-	/* Could zeroize hash[] here, but yescrypt_kdf() doesn't zeroize its
-	 * memory allocations yet anyway. */
-	if (!dst || dst >= buf + buflen) { /* Can't happen */
-		printf("died11 ...");
-		return NULL;
-	}
-
-	*dst = 0; /* NUL termination */
-
-	printf("died12 ...");
-	fflush(stdout);
-
-	return buf;
-}
-
-uint8_t* yescrypt(const uint8_t* passwd, const uint8_t* setting)
-{
-	static uint8_t buf[4 + 1 + 5 + 5 + BYTES2CHARS(32) + 1 + HASH_LEN + 1];
-	yescrypt_shared_t shared;
-	yescrypt_local_t local;
-	uint8_t * retval;
-
-	if (yescrypt_init_shared(&shared, NULL, 0,
-	    0, 0, 0, YESCRYPT_SHARED_DEFAULTS, 0, NULL, 0))
-		return NULL;
-	if (yescrypt_init_local(&local)) {
-		yescrypt_free_shared(&shared);
-		return NULL;
-	}
-	retval = yescrypt_r(&shared, &local,
-	    passwd, 80, setting, buf, sizeof(buf));
-	//printf("hashse='%s'\n", (char *)retval);
-	if (yescrypt_free_local(&local)) {
-		yescrypt_free_shared(&shared);
-		return NULL;
-	}
-	if (yescrypt_free_shared(&shared))
-		return NULL;
-	return retval;
-}
-
-uint8_t* yescrypt_gensalt_r(uint32_t N_log2, uint32_t r, uint32_t p, yescrypt_flags_t flags,
-    const uint8_t* src, size_t srclen, uint8_t* buf, size_t buflen)
-{
-	uint8_t * dst;
-	size_t prefixlen = 3 + 1 + 5 + 5;
-	size_t saltlen = BYTES2CHARS(srclen);
-	size_t need;
-
-	if (p == 1)
-		flags &= ~YESCRYPT_PARALLEL_SMIX;
-
-	if (flags) {
-		if (flags & ~0x3f)
-			return NULL;
-
-		prefixlen++;
-		if (flags != YESCRYPT_RW)
-			prefixlen++;
-	}
-
-	need = prefixlen + saltlen + 1;
-	if (need > buflen || need < saltlen || saltlen < srclen)
-		return NULL;
-
-	if (N_log2 > 63 || ((uint64_t)r * (uint64_t)p >= (1U << 30)))
-		return NULL;
-
-	dst = buf;
-	*dst++ = '$';
-	*dst++ = '7';
-	if (flags) {
-		*dst++ = 'X'; /* eXperimental, subject to change */
-		if (flags != YESCRYPT_RW)
-			*dst++ = itoa64[flags];
-	}
-	*dst++ = '$';
-
-	*dst++ = itoa64[N_log2];
-
-	dst = encode64_uint32(dst, buflen - (dst - buf), r, 30);
-	if (!dst) /* Can't happen */
-		return NULL;
-
-	dst = encode64_uint32(dst, buflen - (dst - buf), p, 30);
-	if (!dst) /* Can't happen */
-		return NULL;
-
-	dst = encode64(dst, buflen - (dst - buf), src, srclen);
-	if (!dst || dst >= buf + buflen) /* Can't happen */
-		return NULL;
-
-	*dst = 0; /* NUL termination */
-
-	return buf;
-}
-
-uint8_t* yescrypt_gensalt(uint32_t N_log2, uint32_t r, uint32_t p, yescrypt_flags_t flags,
-    const uint8_t * src, size_t srclen)
-{
-	static uint8_t buf[4 + 1 + 5 + 5 + BYTES2CHARS(32) + 1];
-	return yescrypt_gensalt_r(N_log2, r, p, flags, src, srclen,
-	    buf, sizeof(buf));
-}
-
-static int yescrypt_bsty(const uint8_t * passwd, size_t passwdlen,
-    const uint8_t * salt, size_t saltlen, uint64_t N, uint32_t r, uint32_t p,
-    uint8_t * buf, size_t buflen)
-{
-	static __thread int initialized = 0;
-	static __thread yescrypt_shared_t shared;
-	static __thread yescrypt_local_t local;
-	int retval;
-	if (!initialized) {
-/* "shared" could in fact be shared, but it's simpler to keep it private
- * along with "local".  It's dummy and tiny anyway. */
-		if (yescrypt_init_shared(&shared, NULL, 0,
-		    0, 0, 0, YESCRYPT_SHARED_DEFAULTS, 0, NULL, 0))
-			return -1;
-		if (yescrypt_init_local(&local)) {
-			yescrypt_free_shared(&shared);
-			return -1;
-		}
-		initialized = 1;
-	}
-	retval = yescrypt_kdf(&shared, &local,
-	    passwd, passwdlen, salt, saltlen, N, r, p, 0, YESCRYPT_FLAGS,
-	    buf, buflen);
-#if 0
-	if (yescrypt_free_local(&local)) {
-		yescrypt_free_shared(&shared);
-		return -1;
-	}
-	if (yescrypt_free_shared(&shared))
-		return -1;
-	initialized = 0;
-#endif
-	return retval;
-}
-
-/* main hash 80 bytes input */
-void yescrypt_hash(const char *input, char *output, uint32_t len)
-{
-	yescrypt_bsty((uint8_t*)input, len, (uint8_t*)input, len, 2048, 8, 1, (uint8_t*)output, 32);
-}
-
-/* for util.c test */
-void yescrypthash(void *output, const void *input)
-{
-	yescrypt_hash((char*) input, (char*) output, 80);
-}
-

algo/yescrypt/yescrypt-opt.c

@@ -913,10 +913,10 @@ yescrypt_kdf(const yescrypt_shared_t * shared, yescrypt_local_t * local,
 	if ((t || flags) && buflen == sizeof(sha256)) {
 		/* Compute ClientKey */
 		{
-			HMAC_SHA256_CTX_Y ctx;
+			HMAC_SHA256_CTX ctx;
-			HMAC_SHA256_Init_Y(&ctx, buf, buflen);
+			HMAC_SHA256_Init(&ctx, buf, buflen);
-			HMAC_SHA256_Update_Y(&ctx, salt, saltlen);
+			HMAC_SHA256_Update(&ctx, salt, saltlen);
-			HMAC_SHA256_Final_Y((uint8_t *)sha256, &ctx);
+			HMAC_SHA256_Final((uint8_t *)sha256, &ctx);
 		}
 		/* Compute StoredKey */
 		{

algo/yescrypt/yescrypt-simd.c

@@ -1302,10 +1302,17 @@ yescrypt_kdf(const yescrypt_shared_t * shared, yescrypt_local_t * local,
 		S = (uint8_t *)XY + XY_size;
 
 	if (t || flags) {
-		SHA256_CTX_Y ctx;
+#if defined __SHA__
-		SHA256_Init_Y(&ctx);
+		SHA256_CTX ctx;
-		SHA256_Update_Y(&ctx, passwd, passwdlen);
+		SHA256_Init(&ctx);
-		SHA256_Final_Y(sha256, &ctx);
+		SHA256_Update(&ctx, passwd, passwdlen);
+		SHA256_Final(sha256, &ctx);
+#else
+                SHA256_CTX_Y ctx;
+                SHA256_Init_Y(&ctx);
+                SHA256_Update_Y(&ctx, passwd, passwdlen);
+                SHA256_Final_Y(sha256, &ctx);
+#endif
 		passwd = sha256;
 		passwdlen = sizeof(sha256);
 	}
@@ -1353,23 +1360,30 @@ yescrypt_kdf(const yescrypt_shared_t * shared, yescrypt_local_t * local,
 	if ((t || flags) && buflen == sizeof(sha256)) {
 		/* Compute ClientKey */
 		{
-			HMAC_SHA256_CTX_Y ctx;
+			HMAC_SHA256_CTX ctx;
-			HMAC_SHA256_Init_Y(&ctx, buf, buflen);
+			HMAC_SHA256_Init(&ctx, buf, buflen);
 #if 0
 /* Proper yescrypt */
  			HMAC_SHA256_Update_Y(&ctx, "Client Key", 10);
 #else
 /* GlobalBoost-Y buggy yescrypt */
-			HMAC_SHA256_Update_Y(&ctx, salt, saltlen);
+			HMAC_SHA256_Update(&ctx, salt, saltlen);
 #endif
-			HMAC_SHA256_Final_Y(sha256, &ctx);
+			HMAC_SHA256_Final(sha256, &ctx);
 		}
 		/* Compute StoredKey */
 		{
-			SHA256_CTX_Y ctx;
+#if defined __SHA__
-			SHA256_Init_Y(&ctx);
+			SHA256_CTX ctx;
-			SHA256_Update_Y(&ctx, sha256, sizeof(sha256));
+			SHA256_Init(&ctx);
-			SHA256_Final_Y(buf, &ctx);
+			SHA256_Update(&ctx, sha256, sizeof(sha256));
+			SHA256_Final(buf, &ctx);
+#else
+                        SHA256_CTX_Y ctx;
+                        SHA256_Init_Y(&ctx);
+                        SHA256_Update_Y(&ctx, sha256, sizeof(sha256));
+                        SHA256_Final_Y(buf, &ctx);
+#endif
 		}
 	}
 

algo/yescrypt/yescrypt.c

@@ -1,60 +1,451 @@
-#include "miner.h"
+/*-
-#include "algo-gate-api.h"
+ * Copyright 2013,2014 Alexander Peslyak
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
 
-#include <stdio.h>
-#include <string.h>
-#include <openssl/sha.h>
 #include <stdint.h>
-#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+#include "compat.h"
 
 #include "yescrypt.h"
 
-// segfaults, scanhash never returns
+#include "algo-gate-api.h"
 
+#define BYTES2CHARS(bytes) \
+	((((bytes) * 8) + 5) / 6)
 
-int scanhash_yescrypt(int thr_id, struct work *work, uint32_t max_nonce, uint64_t *hashes_done)
+#define HASH_SIZE 32 /* bytes */
+#define HASH_LEN BYTES2CHARS(HASH_SIZE) /* base-64 chars */
+#define YESCRYPT_FLAGS (YESCRYPT_RW | YESCRYPT_PWXFORM)
+
+static const char * const itoa64 =
+	"./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+
+static uint8_t* encode64_uint32(uint8_t* dst, size_t dstlen, uint32_t src, uint32_t srcbits)
 {
-	uint32_t _ALIGN(64) vhash[8];
+	uint32_t bit;
-	uint32_t _ALIGN(64) endiandata[20];
-	uint32_t *pdata = work->data;
-	uint32_t *ptarget = work->target;
 
-	const uint32_t Htarg = ptarget[7];
+	for (bit = 0; bit < srcbits; bit += 6) {
-	const uint32_t first_nonce = pdata[19];
+		if (dstlen < 1)
-	uint32_t n = first_nonce;
+			return NULL;
+		*dst++ = itoa64[src & 0x3f];
+		dstlen--;
+		src >>= 6;
+	}
+
+	return dst;
+}
+
+static uint8_t* encode64(uint8_t* dst, size_t dstlen, const uint8_t* src, size_t srclen)
+{
+	size_t i;
+
+	for (i = 0; i < srclen; ) {
+		uint8_t * dnext;
+		uint32_t value = 0, bits = 0;
+		do {
+			value |= (uint32_t)src[i++] << bits;
+			bits += 8;
+		} while (bits < 24 && i < srclen);
+		dnext = encode64_uint32(dst, dstlen, value, bits);
+		if (!dnext)
+			return NULL;
+		dstlen -= dnext - dst;
+		dst = dnext;
+	}
+
+	return dst;
+}
+
+static int decode64_one(uint32_t* dst, uint8_t src)
+{
+	const char * ptr = strchr(itoa64, src);
+	if (ptr) {
+		*dst = (uint32_t) (ptr - itoa64);
+		return 0;
+	}
+	*dst = 0;
+	return -1;
+}
+
+static const uint8_t* decode64_uint32(uint32_t* dst, uint32_t dstbits, const uint8_t* src)
+{
+	uint32_t bit;
+	uint32_t value;
+
+	value = 0;
+	for (bit = 0; bit < dstbits; bit += 6) {
+		uint32_t one;
+		if (decode64_one(&one, *src)) {
+			*dst = 0;
+			return NULL;
+		}
+		src++;
+		value |= one << bit;
+	}
+
+	*dst = value;
+	return src;
+}
+
+uint8_t* yescrypt_r(const yescrypt_shared_t* shared, yescrypt_local_t* local,
+    const uint8_t* passwd, size_t passwdlen, const uint8_t* setting, uint8_t* buf, size_t buflen)
+{
+	uint8_t hash[HASH_SIZE];
+	const uint8_t * src, * salt;
+	uint8_t * dst;
+	size_t prefixlen, saltlen, need;
+	uint8_t version;
+	uint64_t N;
+	uint32_t r, p;
+	yescrypt_flags_t flags = YESCRYPT_WORM;
+
+	printf("pass1 ...");
+	fflush(stdout);
+
+	if (setting[0] != '$' || setting[1] != '7') {
+		printf("died$7 ...");
+		fflush(stdout);
+		return NULL;
+	}
+
+	printf("died80 ...");
+	fflush(stdout);
+
+	src = setting + 2;
+
+	printf("hello '%p'\n", (char *)src);
+	fflush(stdout);
+
+	switch ((version = *src)) {
+	case '$':
+		printf("died2 ...");
+		fflush(stdout);
+		break;
+	case 'X':
+		src++;
+		flags = YESCRYPT_RW;
+		printf("died3 ...");
+		fflush(stdout);
+		break;
+	default:
+		printf("died4 ...");
+		fflush(stdout);
+		return NULL;
+	}
+
+	printf("pass2 ...");
+	fflush(stdout);
+
+	if (*src != '$') {
+		uint32_t decoded_flags;
+		if (decode64_one(&decoded_flags, *src)) {
+			printf("died5 ...");
+			fflush(stdout);
+			return NULL;
+		}
+		flags = decoded_flags;
+		if (*++src != '$') {
+			printf("died6 ...");
+			fflush(stdout);
+			return NULL;
+		}
+	}
+
+	src++;
+
+	{
+		uint32_t N_log2;
+		if (decode64_one(&N_log2, *src)) {
+			printf("died7 ...");
+			return NULL;
+		}
+		src++;
+		N = (uint64_t)1 << N_log2;
+	}
+
+	src = decode64_uint32(&r, 30, src);
+	if (!src) {
+		printf("died6 ...");
+		return NULL;
+	}
+
+	src = decode64_uint32(&p, 30, src);
+	if (!src) {
+		printf("died7 ...");
+		return NULL;
+	}
+
+	prefixlen = src - setting;
+
+	salt = src;
+	src = (uint8_t *)strrchr((char *)salt, '$');
+	if (src)
+		saltlen = src - salt;
+	else
+		saltlen = strlen((char *)salt);
+
+	need = prefixlen + saltlen + 1 + HASH_LEN + 1;
+	if (need > buflen || need < saltlen) {
+		printf("'%d %d %d'", (int) need, (int) buflen, (int) saltlen);
+		printf("died8killbuf ...");
+		fflush(stdout);
+		return NULL;
+	}
+
+	if (yescrypt_kdf(shared, local, passwd, passwdlen, salt, saltlen, N, r, p, 0, flags, hash, sizeof(hash))) {
+		printf("died10 ...");
+		fflush(stdout);
+		return NULL;
+	}
+
+	dst = buf;
+	memcpy(dst, setting, prefixlen + saltlen);
+	dst += prefixlen + saltlen;
+	*dst++ = '$';
+
+	dst = encode64(dst, buflen - (dst - buf), hash, sizeof(hash));
+	/* Could zeroize hash[] here, but yescrypt_kdf() doesn't zeroize its
+	 * memory allocations yet anyway. */
+	if (!dst || dst >= buf + buflen) { /* Can't happen */
+		printf("died11 ...");
+		return NULL;
+	}
+
+	*dst = 0; /* NUL termination */
+
+	printf("died12 ...");
+	fflush(stdout);
+
+	return buf;
+}
+
+uint8_t* yescrypt(const uint8_t* passwd, const uint8_t* setting)
+{
+	static uint8_t buf[4 + 1 + 5 + 5 + BYTES2CHARS(32) + 1 + HASH_LEN + 1];
+	yescrypt_shared_t shared;
+	yescrypt_local_t local;
+	uint8_t * retval;
+
+	if (yescrypt_init_shared(&shared, NULL, 0,
+	    0, 0, 0, YESCRYPT_SHARED_DEFAULTS, 0, NULL, 0))
+		return NULL;
+	if (yescrypt_init_local(&local)) {
+		yescrypt_free_shared(&shared);
+		return NULL;
+	}
+	retval = yescrypt_r(&shared, &local,
+	    passwd, 80, setting, buf, sizeof(buf));
+	//printf("hashse='%s'\n", (char *)retval);
+	if (yescrypt_free_local(&local)) {
+		yescrypt_free_shared(&shared);
+		return NULL;
+	}
+	if (yescrypt_free_shared(&shared))
+		return NULL;
+	return retval;
+}
+
+uint8_t* yescrypt_gensalt_r(uint32_t N_log2, uint32_t r, uint32_t p, yescrypt_flags_t flags,
+    const uint8_t* src, size_t srclen, uint8_t* buf, size_t buflen)
+{
+	uint8_t * dst;
+	size_t prefixlen = 3 + 1 + 5 + 5;
+	size_t saltlen = BYTES2CHARS(srclen);
+	size_t need;
+
+	if (p == 1)
+		flags &= ~YESCRYPT_PARALLEL_SMIX;
+
+	if (flags) {
+		if (flags & ~0x3f)
+			return NULL;
+
+		prefixlen++;
+		if (flags != YESCRYPT_RW)
+			prefixlen++;
+	}
+
+	need = prefixlen + saltlen + 1;
+	if (need > buflen || need < saltlen || saltlen < srclen)
+		return NULL;
+
+	if (N_log2 > 63 || ((uint64_t)r * (uint64_t)p >= (1U << 30)))
+		return NULL;
+
+	dst = buf;
+	*dst++ = '$';
+	*dst++ = '7';
+	if (flags) {
+		*dst++ = 'X'; /* eXperimental, subject to change */
+		if (flags != YESCRYPT_RW)
+			*dst++ = itoa64[flags];
+	}
+	*dst++ = '$';
+
+	*dst++ = itoa64[N_log2];
+
+	dst = encode64_uint32(dst, buflen - (dst - buf), r, 30);
+	if (!dst) /* Can't happen */
+		return NULL;
+
+	dst = encode64_uint32(dst, buflen - (dst - buf), p, 30);
+	if (!dst) /* Can't happen */
+		return NULL;
+
+	dst = encode64(dst, buflen - (dst - buf), src, srclen);
+	if (!dst || dst >= buf + buflen) /* Can't happen */
+		return NULL;
+
+	*dst = 0; /* NUL termination */
+
+	return buf;
+}
+
+uint8_t* yescrypt_gensalt(uint32_t N_log2, uint32_t r, uint32_t p, yescrypt_flags_t flags,
+    const uint8_t * src, size_t srclen)
+{
+	static uint8_t buf[4 + 1 + 5 + 5 + BYTES2CHARS(32) + 1];
+	return yescrypt_gensalt_r(N_log2, r, p, flags, src, srclen,
+	    buf, sizeof(buf));
+}
+
+static int yescrypt_bsty(const uint8_t * passwd, size_t passwdlen,
+    const uint8_t * salt, size_t saltlen, uint64_t N, uint32_t r, uint32_t p,
+    uint8_t * buf, size_t buflen)
+{
+	static __thread int initialized = 0;
+	static __thread yescrypt_shared_t shared;
+	static __thread yescrypt_local_t local;
+	int retval;
+	if (!initialized) {
+/* "shared" could in fact be shared, but it's simpler to keep it private
+ * along with "local".  It's dummy and tiny anyway. */
+		if (yescrypt_init_shared(&shared, NULL, 0,
+		    0, 0, 0, YESCRYPT_SHARED_DEFAULTS, 0, NULL, 0))
+			return -1;
+		if (yescrypt_init_local(&local)) {
+			yescrypt_free_shared(&shared);
+			return -1;
+		}
+		initialized = 1;
+	}
+	retval = yescrypt_kdf(&shared, &local,
+	    passwd, passwdlen, salt, saltlen, N, r, p, 0, YESCRYPT_FLAGS,
+	    buf, buflen);
+#if 0
+	if (yescrypt_free_local(&local)) {
+		yescrypt_free_shared(&shared);
+		return -1;
+	}
+	if (yescrypt_free_shared(&shared))
+		return -1;
+	initialized = 0;
+#endif
+	return retval;
+}
+
+// scrypt parameters initialized at run time.
+uint64_t YESCRYPT_N;
+uint32_t YESCRYPT_R;
+uint32_t YESCRYPT_P;
+
+/* main hash 80 bytes input */
+void yescrypt_hash( const char *input, char *output, uint32_t len )
+{
+   yescrypt_bsty( (uint8_t*)input, len, (uint8_t*)input, len, YESCRYPT_N,
+                  YESCRYPT_R, YESCRYPT_P, (uint8_t*)output, 32 );
+}
+
+/* for util.c test */
+void yescrypthash(void *output, const void *input)
+{
+	yescrypt_hash((char*) input, (char*) output, 80);
+}
+
+int scanhash_yescrypt( int thr_id, struct work *work, uint32_t max_nonce,
+                       uint64_t *hashes_done )
+{
+        uint32_t _ALIGN(64) vhash[8];
+        uint32_t _ALIGN(64) endiandata[20];
+        uint32_t *pdata = work->data;
+        uint32_t *ptarget = work->target;
+
+        const uint32_t Htarg = ptarget[7];
+        const uint32_t first_nonce = pdata[19];
+        uint32_t n = first_nonce;
 
         for (int k = 0; k < 19; k++)
                 be32enc(&endiandata[k], pdata[k]);
 
-	do {
+        do {
-		be32enc(&endiandata[19], n);
+                be32enc(&endiandata[19], n);
-		yescrypt_hash((char*) endiandata, (char*) vhash, 80);
+                yescrypt_hash((char*) endiandata, (char*) vhash, 80);
-		if (vhash[7] < Htarg && fulltest(vhash, ptarget)) {
+                if (vhash[7] < Htarg && fulltest(vhash, ptarget)) {
-			work_set_target_ratio( work, vhash );
+                        work_set_target_ratio( work, vhash );
-			*hashes_done = n - first_nonce + 1;
+                        *hashes_done = n - first_nonce + 1;
-			pdata[19] = n;
+                        pdata[19] = n;
-			return true;
+                        return true;
-		}
+                }
-		n++;
+                n++;
-	} while (n < max_nonce && !work_restart[thr_id].restart);
+        } while (n < max_nonce && !work_restart[thr_id].restart);
 
-	*hashes_done = n - first_nonce + 1;
+        *hashes_done = n - first_nonce + 1;
-	pdata[19] = n;
+        pdata[19] = n;
 
-	return 0;
+        return 0;
 }
 
-int64_t yescrypt_get_max64 ()
+int64_t yescrypt_get_max64()
 {
   return 0x1ffLL;
 }
 
-bool register_yescrypt_algo ( algo_gate_t* gate )
+int64_t yescryptr16_get_max64()
 {
+  return 0xfffLL;
+}
+
+bool register_yescrypt_algo( algo_gate_t* gate )
+{
+   gate->optimizations = SSE2_OPT | SHA_OPT;
    gate->scanhash   = (void*)&scanhash_yescrypt;
    gate->hash       = (void*)&yescrypt_hash;
    gate->set_target = (void*)&scrypt_set_target;
    gate->get_max64  = (void*)&yescrypt_get_max64;
+   YESCRYPT_N = 2048;
+   YESCRYPT_R = 8;
+   YESCRYPT_P = 1;
+   return true;
+}
+
+bool register_yescryptr16_algo( algo_gate_t* gate )
+{
+   gate->optimizations = SSE2_OPT | SHA_OPT;
+   gate->scanhash   = (void*)&scanhash_yescrypt;
+   gate->hash       = (void*)&yescrypt_hash;
+   gate->set_target = (void*)&scrypt_set_target;
+   gate->get_max64  = (void*)&yescryptr16_get_max64;
+   YESCRYPT_N = 4096;   
+   YESCRYPT_R = 16;   
+   YESCRYPT_P = 1;   
    return true;
 }
 

algo/zr5.c

@@ -27,7 +27,6 @@
  */
 
 #include "cpuminer-config.h"
-#include "miner.h"
 #include "algo-gate-api.h"
 #include <string.h>
 #include <stdint.h>

configure

@@ -1,6 +1,6 @@
 #! /bin/sh
 # Guess values for system-dependent variables and create Makefiles.
-# Generated by GNU Autoconf 2.69 for cpuminer-opt 3.7.0.
+# Generated by GNU Autoconf 2.69 for cpuminer-opt 3.7.1.
 #
 #
 # Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc.
@@ -577,8 +577,8 @@ MAKEFLAGS=
 # Identity of this package.
 PACKAGE_NAME='cpuminer-opt'
 PACKAGE_TARNAME='cpuminer-opt'
-PACKAGE_VERSION='3.7.0'
+PACKAGE_VERSION='3.7.1'
-PACKAGE_STRING='cpuminer-opt 3.7.0'
+PACKAGE_STRING='cpuminer-opt 3.7.1'
 PACKAGE_BUGREPORT=''
 PACKAGE_URL=''
 
@@ -1321,7 +1321,7 @@ if test "$ac_init_help" = "long"; then
   # Omit some internal or obsolete options to make the list less imposing.
   # This message is too long to be a string in the A/UX 3.1 sh.
   cat <<_ACEOF
-\`configure' configures cpuminer-opt 3.7.0 to adapt to many kinds of systems.
+\`configure' configures cpuminer-opt 3.7.1 to adapt to many kinds of systems.
 
 Usage: $0 [OPTION]... [VAR=VALUE]...
 
@@ -1392,7 +1392,7 @@ fi
 
 if test -n "$ac_init_help"; then
   case $ac_init_help in
-     short | recursive ) echo "Configuration of cpuminer-opt 3.7.0:";;
+     short | recursive ) echo "Configuration of cpuminer-opt 3.7.1:";;
    esac
   cat <<\_ACEOF
 
@@ -1497,7 +1497,7 @@ fi
 test -n "$ac_init_help" && exit $ac_status
 if $ac_init_version; then
   cat <<\_ACEOF
-cpuminer-opt configure 3.7.0
+cpuminer-opt configure 3.7.1
 generated by GNU Autoconf 2.69
 
 Copyright (C) 2012 Free Software Foundation, Inc.
@@ -2000,7 +2000,7 @@ cat >config.log <<_ACEOF
 This file contains any messages produced by compilers while
 running configure, to aid debugging if configure makes a mistake.
 
-It was created by cpuminer-opt $as_me 3.7.0, which was
+It was created by cpuminer-opt $as_me 3.7.1, which was
 generated by GNU Autoconf 2.69.  Invocation command line was
 
   $ $0 $@
@@ -2981,7 +2981,7 @@ fi
 
 # Define the identity of the package.
  PACKAGE='cpuminer-opt'
- VERSION='3.7.0'
+ VERSION='3.7.1'
 
 
 cat >>confdefs.h <<_ACEOF
@@ -6677,7 +6677,7 @@ cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
 # report actual input values of CONFIG_FILES etc. instead of their
 # values after options handling.
 ac_log="
-This file was extended by cpuminer-opt $as_me 3.7.0, which was
+This file was extended by cpuminer-opt $as_me 3.7.1, which was
 generated by GNU Autoconf 2.69.  Invocation command line was
 
   CONFIG_FILES    = $CONFIG_FILES
@@ -6743,7 +6743,7 @@ _ACEOF
 cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
 ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
 ac_cs_version="\\
-cpuminer-opt config.status 3.7.0
+cpuminer-opt config.status 3.7.1
 configured by $0, generated by GNU Autoconf 2.69,
   with options \\"\$ac_cs_config\\"
 

configure.ac

@@ -1,4 +1,4 @@
-AC_INIT([cpuminer-opt], [3.7.0])
+AC_INIT([cpuminer-opt], [3.7.1])
 
 AC_PREREQ([2.59c])
 AC_CANONICAL_SYSTEM

miner.h

@@ -332,7 +332,7 @@ bool   has_xop();
 bool   has_fma3();
 bool   has_sse42();
 bool   has_sse();
-void   cpu_bestcpu_feature( char *outbuf, size_t maxsz );
+void   cpu_bestfeature( char *outbuf, size_t maxsz );
 void   cpu_getname(char *outbuf, size_t maxsz);
 void   cpu_getmodelid(char *outbuf, size_t maxsz);
 void   cpu_brand_string( char* s );
@@ -537,6 +537,7 @@ enum algos {
         ALGO_X17,
         ALGO_XEVAN,
         ALGO_YESCRYPT,
+        ALGO_YESCRYPTR16,
         ALGO_ZR5,
         ALGO_COUNT
 };
@@ -604,6 +605,7 @@ static const char* const algo_names[] = {
         "x17",
         "xevan",
         "yescrypt",
+        "yescryptr16",
         "zr5",
         "\0"
 };
@@ -725,7 +727,8 @@ Options:\n\
                           x15          X15\n\
                           x17\n\
                           xevan        Bitsend\n\
-                          yescrypt\n\
+                          yescrypt     Globlboost-Y (BSTY)\n\
+                          yescryptr16  Yenten (YTN)\n\
                           zr5          Ziftr\n\
   -o, --url=URL         URL of mining server\n\
   -O, --userpass=U:P    username:password pair for mining server\n\

sysinfos.c

@@ -431,7 +431,7 @@ void cpuid_get_highest_function( char* s )
   }
 }
 
-void cpu_bestfeature(char *outbuf, int maxsz)
+void cpu_bestfeature(char *outbuf, size_t maxsz)
 {
 #ifdef __arm__
 	sprintf(outbuf, "ARM");