mirror of https://github.com/GOSTSec/ccminer
Tanguy Pruvot
9 years ago
14 changed files with 1086 additions and 6 deletions
@ -0,0 +1,514 @@ |
|||||||
|
#include <stdio.h> |
||||||
|
#include <string.h> |
||||||
|
#include <stdint.h> |
||||||
|
#include <memory.h> |
||||||
|
|
||||||
|
#include "miner.h" |
||||||
|
|
||||||
|
#define NATIVE_LITTLE_ENDIAN |
||||||
|
|
||||||
|
extern "C" { |
||||||
|
#include <sph/blake2s.h> |
||||||
|
} |
||||||
|
|
||||||
|
static __thread blake2s_state ALIGN(64) s_midstate; |
||||||
|
static __thread blake2s_state ALIGN(64) s_ctx; |
||||||
|
|
||||||
|
//#define GPU_MIDSTATE |
||||||
|
#define MIDLEN 76 |
||||||
|
#define A 64 |
||||||
|
|
||||||
|
#include "cuda_helper.h" |
||||||
|
|
||||||
|
#ifdef __INTELLISENSE__ |
||||||
|
#define __byte_perm(x, y, b) x |
||||||
|
#endif |
||||||
|
|
||||||
|
#ifndef GPU_MIDSTATE |
||||||
|
__constant__ uint32_t d_data[20]; |
||||||
|
#else |
||||||
|
__constant__ blake2s_state ALIGN(8) d_state[1]; |
||||||
|
#endif |
||||||
|
|
||||||
|
/* 16 adapters max */ |
||||||
|
static uint32_t *d_resNonce[MAX_GPUS]; |
||||||
|
static uint32_t *h_resNonce[MAX_GPUS]; |
||||||
|
|
||||||
|
/* threads per block */ |
||||||
|
#define TPB 512 |
||||||
|
|
||||||
|
/* max count of found nonces in one call */ |
||||||
|
#define NBN 2 |
||||||
|
static uint32_t extra_results[NBN] = { UINT32_MAX }; |
||||||
|
|
||||||
|
extern "C" void blake2s_hash(void *output, const void *input) |
||||||
|
{ |
||||||
|
uint8_t _ALIGN(A) hash[BLAKE2S_OUTBYTES]; |
||||||
|
blake2s_state blake2_ctx; |
||||||
|
|
||||||
|
blake2s_init(&blake2_ctx, BLAKE2S_OUTBYTES); |
||||||
|
blake2s_update(&blake2_ctx, (uint8_t*) input, 80); |
||||||
|
blake2s_final(&blake2_ctx, hash, BLAKE2S_OUTBYTES); |
||||||
|
|
||||||
|
memcpy(output, hash, 32); |
||||||
|
} |
||||||
|
|
||||||
|
__host__ |
||||||
|
inline void blake2s_hash_end(uint32_t *output, const uint32_t *input) |
||||||
|
{ |
||||||
|
s_ctx.buflen = MIDLEN; |
||||||
|
memcpy(&s_ctx, &s_midstate, 32 + 16 + MIDLEN); |
||||||
|
blake2s_update(&s_ctx, (uint8_t*) &input[MIDLEN/4], 80-MIDLEN); |
||||||
|
blake2s_final(&s_ctx, (uint8_t*) output, BLAKE2S_OUTBYTES); |
||||||
|
} |
||||||
|
|
||||||
|
__host__ |
||||||
|
void blake2s_cpu_setBlock(uint32_t *penddata, blake2s_state *pstate) |
||||||
|
{ |
||||||
|
#ifndef GPU_MIDSTATE |
||||||
|
CUDA_SAFE_CALL(cudaMemcpyToSymbol(d_data, penddata, 80, 0, cudaMemcpyHostToDevice)); |
||||||
|
#else |
||||||
|
CUDA_SAFE_CALL(cudaMemcpyToSymbol(d_state, pstate, sizeof(blake2s_state), 0, cudaMemcpyHostToDevice)); |
||||||
|
#endif |
||||||
|
} |
||||||
|
|
||||||
|
__device__ __forceinline__ |
||||||
|
uint32_t gpu_load32(const void *src) { |
||||||
|
return *(uint32_t *)(src); |
||||||
|
} |
||||||
|
|
||||||
|
__device__ __forceinline__ |
||||||
|
void gpu_store32(void *dst, uint32_t dw) { |
||||||
|
*(uint32_t *)(dst) = dw; |
||||||
|
} |
||||||
|
|
||||||
|
__device__ __forceinline__ |
||||||
|
void gpu_store64(void *dst, uint64_t lw) { |
||||||
|
*(uint64_t *)(dst) = lw; |
||||||
|
} |
||||||
|
|
||||||
|
__device__ __forceinline__ |
||||||
|
uint64_t gpu_load48(const void *src) |
||||||
|
{ |
||||||
|
const uint8_t *p = (const uint8_t *)src; |
||||||
|
uint64_t w = *p++; |
||||||
|
w |= (uint64_t)(*p++) << 8; |
||||||
|
w |= (uint64_t)(*p++) << 16; |
||||||
|
w |= (uint64_t)(*p++) << 24; |
||||||
|
w |= (uint64_t)(*p++) << 32; |
||||||
|
w |= (uint64_t)(*p++) << 40; |
||||||
|
return w; |
||||||
|
} |
||||||
|
|
||||||
|
__device__ __forceinline__ |
||||||
|
void gpu_blake2s_set_lastnode(blake2s_state *S) { |
||||||
|
S->f[1] = ~0U; |
||||||
|
} |
||||||
|
|
||||||
|
__device__ __forceinline__ |
||||||
|
void gpu_blake2s_clear_lastnode(blake2s_state *S) { |
||||||
|
S->f[1] = 0U; |
||||||
|
} |
||||||
|
|
||||||
|
__device__ __forceinline__ |
||||||
|
void gpu_blake2s_increment_counter(blake2s_state *S, const uint32_t inc) |
||||||
|
{ |
||||||
|
S->t[0] += inc; |
||||||
|
S->t[1] += ( S->t[0] < inc ); |
||||||
|
} |
||||||
|
|
||||||
|
__device__ __forceinline__ |
||||||
|
void gpu_blake2s_set_lastblock(blake2s_state *S) |
||||||
|
{ |
||||||
|
if (S->last_node) gpu_blake2s_set_lastnode(S); |
||||||
|
S->f[0] = ~0U; |
||||||
|
} |
||||||
|
|
||||||
|
__device__ |
||||||
|
void gpu_blake2s_compress(blake2s_state *S, const uint32_t *block) |
||||||
|
{ |
||||||
|
uint32_t m[16]; |
||||||
|
uint32_t v[16]; |
||||||
|
|
||||||
|
const uint32_t blake2s_IV[8] = { |
||||||
|
0x6A09E667UL, 0xBB67AE85UL, 0x3C6EF372UL, 0xA54FF53AUL, |
||||||
|
0x510E527FUL, 0x9B05688CUL, 0x1F83D9ABUL, 0x5BE0CD19UL |
||||||
|
}; |
||||||
|
|
||||||
|
const uint8_t blake2s_sigma[10][16] = { |
||||||
|
{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }, |
||||||
|
{ 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 }, |
||||||
|
{ 11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4 }, |
||||||
|
{ 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8 }, |
||||||
|
{ 9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13 }, |
||||||
|
{ 2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9 }, |
||||||
|
{ 12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11 }, |
||||||
|
{ 13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10 }, |
||||||
|
{ 6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5 }, |
||||||
|
{ 10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13 , 0 }, |
||||||
|
}; |
||||||
|
|
||||||
|
#pragma unroll |
||||||
|
for(int i = 0; i < 16; i++) |
||||||
|
m[i] = block[i]; |
||||||
|
|
||||||
|
#pragma unroll |
||||||
|
for(int i = 0; i < 8; i++) |
||||||
|
v[i] = S->h[i]; |
||||||
|
|
||||||
|
v[ 8] = blake2s_IV[0]; |
||||||
|
v[ 9] = blake2s_IV[1]; |
||||||
|
v[10] = blake2s_IV[2]; |
||||||
|
v[11] = blake2s_IV[3]; |
||||||
|
v[12] = S->t[0] ^ blake2s_IV[4]; |
||||||
|
v[13] = S->t[1] ^ blake2s_IV[5]; |
||||||
|
v[14] = S->f[0] ^ blake2s_IV[6]; |
||||||
|
v[15] = S->f[1] ^ blake2s_IV[7]; |
||||||
|
|
||||||
|
#define G(r,i,a,b,c,d) { \ |
||||||
|
a += b + m[blake2s_sigma[r][2*i+0]]; \ |
||||||
|
d = __byte_perm(d ^ a, 0, 0x1032); /* d = ROTR32(d ^ a, 16); */ \ |
||||||
|
c = c + d; \ |
||||||
|
b = ROTR32(b ^ c, 12); \ |
||||||
|
a += b + m[blake2s_sigma[r][2*i+1]]; \ |
||||||
|
d = __byte_perm(d ^ a, 0, 0x0321); /* ROTR32(d ^ a, 8); */ \ |
||||||
|
c = c + d; \ |
||||||
|
b = ROTR32(b ^ c, 7); \ |
||||||
|
} |
||||||
|
|
||||||
|
#define ROUND(r) { \ |
||||||
|
G(r,0,v[ 0],v[ 4],v[ 8],v[12]); \ |
||||||
|
G(r,1,v[ 1],v[ 5],v[ 9],v[13]); \ |
||||||
|
G(r,2,v[ 2],v[ 6],v[10],v[14]); \ |
||||||
|
G(r,3,v[ 3],v[ 7],v[11],v[15]); \ |
||||||
|
G(r,4,v[ 0],v[ 5],v[10],v[15]); \ |
||||||
|
G(r,5,v[ 1],v[ 6],v[11],v[12]); \ |
||||||
|
G(r,6,v[ 2],v[ 7],v[ 8],v[13]); \ |
||||||
|
G(r,7,v[ 3],v[ 4],v[ 9],v[14]); \ |
||||||
|
} |
||||||
|
|
||||||
|
ROUND( 0 ); |
||||||
|
ROUND( 1 ); |
||||||
|
ROUND( 2 ); |
||||||
|
ROUND( 3 ); |
||||||
|
ROUND( 4 ); |
||||||
|
ROUND( 5 ); |
||||||
|
ROUND( 6 ); |
||||||
|
ROUND( 7 ); |
||||||
|
ROUND( 8 ); |
||||||
|
ROUND( 9 ); |
||||||
|
|
||||||
|
#pragma unroll |
||||||
|
for(int i = 0; i < 8; i++) |
||||||
|
S->h[i] = S->h[i] ^ v[i] ^ v[i + 8]; |
||||||
|
|
||||||
|
#undef G |
||||||
|
#undef ROUND |
||||||
|
} |
||||||
|
|
||||||
|
__device__ __forceinline__ |
||||||
|
void gpu_blake2s_update(blake2s_state *S, const uint8_t *in, uint64_t inlen) |
||||||
|
{ |
||||||
|
while(inlen > 0) |
||||||
|
{ |
||||||
|
const int left = S->buflen; |
||||||
|
size_t fill = 2 * BLAKE2S_BLOCKBYTES - left; |
||||||
|
if(inlen > fill) |
||||||
|
{ |
||||||
|
memcpy(S->buf + left, in, fill); // Fill buffer |
||||||
|
S->buflen += fill; |
||||||
|
|
||||||
|
gpu_blake2s_increment_counter(S, BLAKE2S_BLOCKBYTES); |
||||||
|
gpu_blake2s_compress(S, (uint32_t*) S->buf); // Compress |
||||||
|
memcpy(S->buf, S->buf + BLAKE2S_BLOCKBYTES, BLAKE2S_BLOCKBYTES); // Shift buffer left |
||||||
|
S->buflen -= BLAKE2S_BLOCKBYTES; |
||||||
|
in += fill; |
||||||
|
inlen -= fill; |
||||||
|
} |
||||||
|
else // inlen <= fill |
||||||
|
{ |
||||||
|
memcpy(S->buf + left, in, (size_t) inlen); |
||||||
|
S->buflen += (size_t) inlen; // Be lazy, do not compress |
||||||
|
in += inlen; |
||||||
|
inlen -= inlen; |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
__device__ __forceinline__ |
||||||
|
void gpu_blake2s_update76(blake2s_state *S, const void *in) |
||||||
|
{ |
||||||
|
uint64_t *b64 = (uint64_t*) S->buf; |
||||||
|
uint64_t *i64 = (uint64_t*) in; |
||||||
|
#pragma unroll |
||||||
|
for (int i=0; i < 80/8; i++) |
||||||
|
b64[i] = i64[i]; |
||||||
|
//S->buflen = 76; |
||||||
|
} |
||||||
|
|
||||||
|
__device__ __forceinline__ |
||||||
|
void gpu_blake2s_update_nonce(blake2s_state *S, const uint32_t nonce) |
||||||
|
{ |
||||||
|
gpu_store32(&S->buf[76], nonce); |
||||||
|
S->buflen = 80; |
||||||
|
} |
||||||
|
|
||||||
|
__device__ __forceinline__ |
||||||
|
void gpu_blake2s_final(blake2s_state *S, uint32_t *out) |
||||||
|
{ |
||||||
|
//if (S->buflen > BLAKE2S_BLOCKBYTES) |
||||||
|
{ |
||||||
|
gpu_blake2s_increment_counter(S, BLAKE2S_BLOCKBYTES); |
||||||
|
gpu_blake2s_compress(S, (uint32_t*) S->buf); |
||||||
|
S->buflen -= BLAKE2S_BLOCKBYTES; |
||||||
|
//memcpy(S->buf, S->buf + BLAKE2S_BLOCKBYTES, S->buflen); |
||||||
|
} |
||||||
|
|
||||||
|
gpu_blake2s_increment_counter(S, (uint32_t)S->buflen); |
||||||
|
gpu_blake2s_set_lastblock(S); |
||||||
|
//memset(&S->buf[S->buflen], 0, 2 * BLAKE2S_BLOCKBYTES - S->buflen); /* Padding */ |
||||||
|
gpu_blake2s_compress(S, (uint32_t*) (S->buf + BLAKE2S_BLOCKBYTES)); |
||||||
|
|
||||||
|
#pragma unroll |
||||||
|
for (int i = 0; i < 8; i++) |
||||||
|
out[i] = S->h[i]; |
||||||
|
} |
||||||
|
|
||||||
|
/* init2 xors IV with input parameter block */ |
||||||
|
__device__ __forceinline__ |
||||||
|
void gpu_blake2s_init_param(blake2s_state *S, const blake2s_param *P) |
||||||
|
{ |
||||||
|
//blake2s_IV |
||||||
|
S->h[0] = 0x6A09E667UL; |
||||||
|
S->h[1] = 0xBB67AE85UL; |
||||||
|
S->h[2] = 0x3C6EF372UL; |
||||||
|
S->h[3] = 0xA54FF53AUL; |
||||||
|
S->h[4] = 0x510E527FUL; |
||||||
|
S->h[5] = 0x9B05688CUL; |
||||||
|
S->h[6] = 0x1F83D9ABUL; |
||||||
|
S->h[7] = 0x5BE0CD19UL; |
||||||
|
|
||||||
|
S->t[0] = 0; S->t[1] = 0; |
||||||
|
S->f[0] = 0; S->f[1] = 0; |
||||||
|
S->last_node = 0; |
||||||
|
|
||||||
|
S->buflen = 0; |
||||||
|
|
||||||
|
#pragma unroll |
||||||
|
for (int i = 0; i < sizeof(S->buf)/4; i++) |
||||||
|
gpu_store32(S->buf + (4*i), 0); |
||||||
|
|
||||||
|
uint32_t *p = (uint32_t*) P; |
||||||
|
|
||||||
|
/* IV XOR ParamBlock */ |
||||||
|
for (int i = 0; i < 8; i++) |
||||||
|
S->h[i] ^= gpu_load32(&p[i]); |
||||||
|
} |
||||||
|
|
||||||
|
// Sequential blake2s initialization |
||||||
|
__device__ __forceinline__ |
||||||
|
void gpu_blake2s_init(blake2s_state *S, const uint8_t outlen) |
||||||
|
{ |
||||||
|
blake2s_param P[1]; |
||||||
|
|
||||||
|
// if (!outlen || outlen > BLAKE2S_OUTBYTES) return; |
||||||
|
|
||||||
|
P->digest_length = outlen; |
||||||
|
P->key_length = 0; |
||||||
|
P->fanout = 1; |
||||||
|
P->depth = 1; |
||||||
|
|
||||||
|
P->leaf_length = 0; |
||||||
|
gpu_store64(P->node_offset, 0); |
||||||
|
//P->node_depth = 0; |
||||||
|
//P->inner_length = 0; |
||||||
|
|
||||||
|
gpu_store64(&P->salt, 0); |
||||||
|
gpu_store64(&P->personal, 0); |
||||||
|
|
||||||
|
gpu_blake2s_init_param(S, P); |
||||||
|
} |
||||||
|
|
||||||
|
__device__ __forceinline__ |
||||||
|
void gpu_copystate(blake2s_state *dst, blake2s_state *src) |
||||||
|
{ |
||||||
|
uint64_t* d64 = (uint64_t*) dst; |
||||||
|
uint64_t* s64 = (uint64_t*) src; |
||||||
|
#pragma unroll |
||||||
|
for (int i=0; i < (32 + 16 + 2 * BLAKE2S_BLOCKBYTES)/8; i++) |
||||||
|
gpu_store64(&d64[i], s64[i]); |
||||||
|
dst->buflen = src->buflen; |
||||||
|
dst->last_node = src->last_node; |
||||||
|
} |
||||||
|
|
||||||
|
__global__ |
||||||
|
void blake2s_gpu_hash(const uint32_t threads, const uint32_t startNonce, uint32_t *resNonce, const uint2 target2) |
||||||
|
{ |
||||||
|
const uint32_t thread = (blockDim.x * blockIdx.x + threadIdx.x); |
||||||
|
const uint32_t nonce = startNonce + thread; |
||||||
|
blake2s_state ALIGN(8) blake2_ctx; |
||||||
|
|
||||||
|
#ifndef GPU_MIDSTATE |
||||||
|
gpu_blake2s_init(&blake2_ctx, BLAKE2S_OUTBYTES); |
||||||
|
//gpu_blake2s_update(&blake2_ctx, (uint8_t*) d_data, 76); |
||||||
|
gpu_blake2s_update76(&blake2_ctx, (uint64_t*) d_data); |
||||||
|
#else |
||||||
|
gpu_copystate(&blake2_ctx, &d_state[0]); |
||||||
|
#endif |
||||||
|
gpu_blake2s_update_nonce(&blake2_ctx, nonce); |
||||||
|
|
||||||
|
uint32_t hash[8]; |
||||||
|
gpu_blake2s_final(&blake2_ctx, hash); |
||||||
|
|
||||||
|
if (hash[7] <= target2.x && hash[6] <= target2.y) { |
||||||
|
#if NBN == 2 |
||||||
|
if (resNonce[0] != UINT32_MAX) |
||||||
|
resNonce[1] = nonce; |
||||||
|
else |
||||||
|
resNonce[0] = nonce; |
||||||
|
#else |
||||||
|
resNonce[0] = nonce; |
||||||
|
#endif |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
__host__ |
||||||
|
uint32_t blake2s_host_hash(const int thr_id, const uint32_t threads, const uint32_t startNonce, const uint2 target2) |
||||||
|
{ |
||||||
|
uint32_t result = UINT32_MAX; |
||||||
|
|
||||||
|
dim3 grid((threads + TPB-1)/TPB); |
||||||
|
dim3 block(TPB); |
||||||
|
|
||||||
|
/* Check error on Ctrl+C or kill to prevent segfaults on exit */ |
||||||
|
if (cudaMemset(d_resNonce[thr_id], 0xff, NBN*sizeof(uint32_t)) != cudaSuccess) |
||||||
|
return result; |
||||||
|
|
||||||
|
blake2s_gpu_hash <<<grid, block>>> (threads, startNonce, d_resNonce[thr_id], target2); |
||||||
|
cudaThreadSynchronize(); |
||||||
|
|
||||||
|
if (cudaSuccess == cudaMemcpy(h_resNonce[thr_id], d_resNonce[thr_id], NBN*sizeof(uint32_t), cudaMemcpyDeviceToHost)) { |
||||||
|
result = h_resNonce[thr_id][0]; |
||||||
|
for (int n=0; n < (NBN-1); n++) |
||||||
|
extra_results[n] = h_resNonce[thr_id][n+1]; |
||||||
|
} |
||||||
|
return result; |
||||||
|
} |
||||||
|
|
||||||
|
static bool init[MAX_GPUS] = { 0 }; |
||||||
|
|
||||||
|
extern "C" int scanhash_blake2s(int thr_id, struct work *work, uint32_t max_nonce, unsigned long *hashes_done) |
||||||
|
{ |
||||||
|
uint32_t _ALIGN(64) endiandata[20]; |
||||||
|
uint32_t *pdata = work->data; |
||||||
|
uint32_t *ptarget = work->target; |
||||||
|
|
||||||
|
const uint32_t first_nonce = pdata[19]; |
||||||
|
|
||||||
|
int dev_id = device_map[thr_id]; |
||||||
|
int intensity = (device_sm[dev_id] >= 500 && !is_windows()) ? 26 : 22; |
||||||
|
if (device_sm[dev_id] < 350) intensity = 22; |
||||||
|
|
||||||
|
uint32_t throughput = cuda_default_throughput(thr_id, 1U << intensity); |
||||||
|
if (init[thr_id]) throughput = min(throughput, max_nonce - first_nonce); |
||||||
|
|
||||||
|
if (opt_benchmark) { |
||||||
|
ptarget[7] = swab32(0xff); |
||||||
|
} |
||||||
|
|
||||||
|
if (!init[thr_id]) |
||||||
|
{ |
||||||
|
cudaSetDevice(dev_id); |
||||||
|
if (opt_cudaschedule == -1 && gpu_threads == 1) { |
||||||
|
cudaDeviceReset(); |
||||||
|
// reduce cpu usage (linux) |
||||||
|
cudaSetDeviceFlags(cudaDeviceScheduleBlockingSync); |
||||||
|
cudaDeviceSetCacheConfig(cudaFuncCachePreferL1); |
||||||
|
CUDA_LOG_ERROR(); |
||||||
|
} |
||||||
|
|
||||||
|
CUDA_CALL_OR_RET_X(cudaMalloc(&d_resNonce[thr_id], NBN * sizeof(uint32_t)), -1); |
||||||
|
CUDA_CALL_OR_RET_X(cudaMallocHost(&h_resNonce[thr_id], NBN * sizeof(uint32_t)), -1); |
||||||
|
init[thr_id] = true; |
||||||
|
} |
||||||
|
|
||||||
|
for (int i=0; i < 19; i++) { |
||||||
|
be32enc(&endiandata[i], pdata[i]); |
||||||
|
} |
||||||
|
|
||||||
|
// midstate |
||||||
|
memset(s_midstate.buf, 0, sizeof(s_midstate.buf)); |
||||||
|
blake2s_init(&s_midstate, BLAKE2S_OUTBYTES); |
||||||
|
blake2s_update(&s_midstate, (uint8_t*) endiandata, MIDLEN); |
||||||
|
memcpy(&s_ctx, &s_midstate, sizeof(blake2s_state)); |
||||||
|
|
||||||
|
blake2s_cpu_setBlock(endiandata, &s_midstate); |
||||||
|
|
||||||
|
uint2 gpu_target = make_uint2(ptarget[7], ptarget[6]); |
||||||
|
const uint32_t Htarg = ptarget[7]; |
||||||
|
|
||||||
|
do { |
||||||
|
uint32_t foundNonce = blake2s_host_hash(thr_id, throughput, pdata[19], gpu_target); |
||||||
|
|
||||||
|
if (foundNonce != UINT32_MAX) |
||||||
|
{ |
||||||
|
uint32_t _ALIGN(A) vhashcpu[8]; |
||||||
|
|
||||||
|
//blake2s_hash(vhashcpu, endiandata); |
||||||
|
le32enc(&endiandata[19], foundNonce); |
||||||
|
blake2s_hash_end(vhashcpu, endiandata); |
||||||
|
|
||||||
|
if (vhashcpu[7] <= Htarg && fulltest(vhashcpu, ptarget)) { |
||||||
|
work_set_target_ratio(work, vhashcpu); |
||||||
|
*hashes_done = pdata[19] + throughput - first_nonce + 1; |
||||||
|
pdata[19] = work->nonces[0] = swab32(foundNonce); |
||||||
|
#if NBN > 1 |
||||||
|
if (extra_results[0] != UINT32_MAX) { |
||||||
|
le32enc(&endiandata[19], extra_results[0]); |
||||||
|
blake2s_hash_end(vhashcpu, endiandata); |
||||||
|
if (vhashcpu[7] <= Htarg && fulltest(vhashcpu, ptarget)) { |
||||||
|
work->nonces[1] = swab32(extra_results[0]); |
||||||
|
if (bn_hash_target_ratio(vhashcpu, ptarget) > work->shareratio) { |
||||||
|
work_set_target_ratio(work, vhashcpu); |
||||||
|
xchg(work->nonces[1], pdata[19]); |
||||||
|
} |
||||||
|
return 2; |
||||||
|
} |
||||||
|
extra_results[0] = UINT32_MAX; |
||||||
|
} |
||||||
|
#endif |
||||||
|
return 1; |
||||||
|
} else { |
||||||
|
gpulog(LOG_WARNING, thr_id, "result for %08x does not validate on CPU!", foundNonce); |
||||||
|
applog_hex(pdata, 80); |
||||||
|
applog_hex(ptarget, 32); |
||||||
|
applog_hex(vhashcpu, 32); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
pdata[19] += throughput; |
||||||
|
|
||||||
|
} while (!work_restart[thr_id].restart && max_nonce > (uint64_t)throughput + pdata[19]); |
||||||
|
|
||||||
|
*hashes_done = pdata[19] - first_nonce + 1; |
||||||
|
|
||||||
|
MyStreamSynchronize(NULL, 0, device_map[thr_id]); |
||||||
|
|
||||||
|
return 0; |
||||||
|
} |
||||||
|
|
||||||
|
// cleanup |
||||||
|
extern "C" void free_blake2s(int thr_id) |
||||||
|
{ |
||||||
|
if (!init[thr_id]) |
||||||
|
return; |
||||||
|
|
||||||
|
cudaDeviceSynchronize(); |
||||||
|
|
||||||
|
cudaFreeHost(h_resNonce[thr_id]); |
||||||
|
cudaFree(d_resNonce[thr_id]); |
||||||
|
|
||||||
|
init[thr_id] = false; |
||||||
|
|
||||||
|
cudaDeviceSynchronize(); |
||||||
|
} |
||||||
@ -0,0 +1,387 @@ |
|||||||
|
/**
|
||||||
|
* BLAKE2 reference source code package - reference C implementations |
||||||
|
* |
||||||
|
* Written in 2012 by Samuel Neves <sneves@dei.uc.pt> |
||||||
|
* |
||||||
|
* To the extent possible under law, the author(s) have dedicated all copyright |
||||||
|
* and related and neighboring rights to this software to the public domain |
||||||
|
* worldwide. This software is distributed without any warranty. |
||||||
|
* |
||||||
|
* You should have received a copy of the CC0 Public Domain Dedication along with |
||||||
|
* this software. If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
|
||||||
|
*/ |
||||||
|
|
||||||
|
#include <stdint.h> |
||||||
|
#include <string.h> |
||||||
|
#include <stdio.h> |
||||||
|
|
||||||
|
#if defined(__cplusplus) |
||||||
|
extern "C" { |
||||||
|
#endif |
||||||
|
|
||||||
|
#include "sph_types.h" |
||||||
|
#include "blake2s.h" |
||||||
|
|
||||||
|
static const uint32_t blake2s_IV[8] = |
||||||
|
{ |
||||||
|
0x6A09E667UL, 0xBB67AE85UL, 0x3C6EF372UL, 0xA54FF53AUL, |
||||||
|
0x510E527FUL, 0x9B05688CUL, 0x1F83D9ABUL, 0x5BE0CD19UL |
||||||
|
}; |
||||||
|
|
||||||
|
static const uint8_t blake2s_sigma[10][16] = |
||||||
|
{ |
||||||
|
{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 } , |
||||||
|
{ 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 } , |
||||||
|
{ 11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4 } , |
||||||
|
{ 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8 } , |
||||||
|
{ 9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13 } , |
||||||
|
{ 2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9 } , |
||||||
|
{ 12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11 } , |
||||||
|
{ 13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10 } , |
||||||
|
{ 6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5 } , |
||||||
|
{ 10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13 , 0 } , |
||||||
|
}; |
||||||
|
|
||||||
|
static inline int blake2s_set_lastnode( blake2s_state *S ) |
||||||
|
{ |
||||||
|
S->f[1] = ~0U; |
||||||
|
return 0; |
||||||
|
} |
||||||
|
|
||||||
|
static inline int blake2s_clear_lastnode( blake2s_state *S ) |
||||||
|
{ |
||||||
|
S->f[1] = 0U; |
||||||
|
return 0; |
||||||
|
} |
||||||
|
|
||||||
|
/* Some helper functions, not necessarily useful */ |
||||||
|
static inline int blake2s_set_lastblock( blake2s_state *S ) |
||||||
|
{ |
||||||
|
if( S->last_node ) blake2s_set_lastnode( S ); |
||||||
|
|
||||||
|
S->f[0] = ~0U; |
||||||
|
return 0; |
||||||
|
} |
||||||
|
|
||||||
|
static inline int blake2s_clear_lastblock( blake2s_state *S ) |
||||||
|
{ |
||||||
|
if( S->last_node ) blake2s_clear_lastnode( S ); |
||||||
|
|
||||||
|
S->f[0] = 0U; |
||||||
|
return 0; |
||||||
|
} |
||||||
|
|
||||||
|
static inline int blake2s_increment_counter( blake2s_state *S, const uint32_t inc ) |
||||||
|
{ |
||||||
|
S->t[0] += inc; |
||||||
|
S->t[1] += ( S->t[0] < inc ); |
||||||
|
return 0; |
||||||
|
} |
||||||
|
|
||||||
|
// Parameter-related functions
|
||||||
|
static inline int blake2s_param_set_digest_length( blake2s_param *P, const uint8_t digest_length ) |
||||||
|
{ |
||||||
|
P->digest_length = digest_length; |
||||||
|
return 0; |
||||||
|
} |
||||||
|
|
||||||
|
static inline int blake2s_param_set_fanout( blake2s_param *P, const uint8_t fanout ) |
||||||
|
{ |
||||||
|
P->fanout = fanout; |
||||||
|
return 0; |
||||||
|
} |
||||||
|
|
||||||
|
static inline int blake2s_param_set_max_depth( blake2s_param *P, const uint8_t depth ) |
||||||
|
{ |
||||||
|
P->depth = depth; |
||||||
|
return 0; |
||||||
|
} |
||||||
|
|
||||||
|
static inline int blake2s_param_set_leaf_length( blake2s_param *P, const uint32_t leaf_length ) |
||||||
|
{ |
||||||
|
store32( &P->leaf_length, leaf_length ); |
||||||
|
return 0; |
||||||
|
} |
||||||
|
|
||||||
|
static inline int blake2s_param_set_node_offset( blake2s_param *P, const uint64_t node_offset ) |
||||||
|
{ |
||||||
|
store48( P->node_offset, node_offset ); |
||||||
|
return 0; |
||||||
|
} |
||||||
|
|
||||||
|
static inline int blake2s_param_set_node_depth( blake2s_param *P, const uint8_t node_depth ) |
||||||
|
{ |
||||||
|
P->node_depth = node_depth; |
||||||
|
return 0; |
||||||
|
} |
||||||
|
|
||||||
|
static inline int blake2s_param_set_inner_length( blake2s_param *P, const uint8_t inner_length ) |
||||||
|
{ |
||||||
|
P->inner_length = inner_length; |
||||||
|
return 0; |
||||||
|
} |
||||||
|
|
||||||
|
static inline int blake2s_param_set_salt( blake2s_param *P, const uint8_t salt[BLAKE2S_SALTBYTES] ) |
||||||
|
{ |
||||||
|
memcpy( P->salt, salt, BLAKE2S_SALTBYTES ); |
||||||
|
return 0; |
||||||
|
} |
||||||
|
|
||||||
|
static inline int blake2s_param_set_personal( blake2s_param *P, const uint8_t personal[BLAKE2S_PERSONALBYTES] ) |
||||||
|
{ |
||||||
|
memcpy( P->personal, personal, BLAKE2S_PERSONALBYTES ); |
||||||
|
return 0; |
||||||
|
} |
||||||
|
|
||||||
|
static inline int blake2s_init0( blake2s_state *S ) |
||||||
|
{ |
||||||
|
memset( S, 0, sizeof( blake2s_state ) ); |
||||||
|
|
||||||
|
for( int i = 0; i < 8; ++i ) S->h[i] = blake2s_IV[i]; |
||||||
|
|
||||||
|
return 0; |
||||||
|
} |
||||||
|
|
||||||
|
/* init2 xors IV with input parameter block */ |
||||||
|
int blake2s_init_param( blake2s_state *S, const blake2s_param *P ) |
||||||
|
{ |
||||||
|
blake2s_init0( S ); |
||||||
|
uint32_t *p = ( uint32_t * )( P ); |
||||||
|
|
||||||
|
/* IV XOR ParamBlock */ |
||||||
|
for( size_t i = 0; i < 8; ++i ) |
||||||
|
S->h[i] ^= load32( &p[i] ); |
||||||
|
|
||||||
|
return 0; |
||||||
|
} |
||||||
|
|
||||||
|
|
||||||
|
// Sequential blake2s initialization
|
||||||
|
int blake2s_init( blake2s_state *S, const uint8_t outlen ) |
||||||
|
{ |
||||||
|
blake2s_param P[1]; |
||||||
|
|
||||||
|
/* Move interval verification here? */ |
||||||
|
if ( ( !outlen ) || ( outlen > BLAKE2S_OUTBYTES ) ) return -1; |
||||||
|
|
||||||
|
P->digest_length = outlen; |
||||||
|
P->key_length = 0; |
||||||
|
P->fanout = 1; |
||||||
|
P->depth = 1; |
||||||
|
store32( &P->leaf_length, 0 ); |
||||||
|
store48( &P->node_offset, 0 ); |
||||||
|
P->node_depth = 0; |
||||||
|
P->inner_length = 0; |
||||||
|
// memset(P->reserved, 0, sizeof(P->reserved) );
|
||||||
|
memset( P->salt, 0, sizeof( P->salt ) ); |
||||||
|
memset( P->personal, 0, sizeof( P->personal ) ); |
||||||
|
return blake2s_init_param( S, P ); |
||||||
|
} |
||||||
|
|
||||||
|
int blake2s_init_key( blake2s_state *S, const uint8_t outlen, const void *key, const uint8_t keylen ) |
||||||
|
{ |
||||||
|
blake2s_param P[1]; |
||||||
|
|
||||||
|
if ( ( !outlen ) || ( outlen > BLAKE2S_OUTBYTES ) ) return -1; |
||||||
|
|
||||||
|
if ( !key || !keylen || keylen > BLAKE2S_KEYBYTES ) return -1; |
||||||
|
|
||||||
|
P->digest_length = outlen; |
||||||
|
P->key_length = keylen; |
||||||
|
P->fanout = 1; |
||||||
|
P->depth = 1; |
||||||
|
store32( &P->leaf_length, 0 ); |
||||||
|
store48( &P->node_offset, 0 ); |
||||||
|
P->node_depth = 0; |
||||||
|
P->inner_length = 0; |
||||||
|
// memset(P->reserved, 0, sizeof(P->reserved) );
|
||||||
|
memset( P->salt, 0, sizeof( P->salt ) ); |
||||||
|
memset( P->personal, 0, sizeof( P->personal ) ); |
||||||
|
|
||||||
|
if( blake2s_init_param( S, P ) < 0 ) return -1; |
||||||
|
|
||||||
|
{ |
||||||
|
uint8_t block[BLAKE2S_BLOCKBYTES]; |
||||||
|
memset( block, 0, BLAKE2S_BLOCKBYTES ); |
||||||
|
memcpy( block, key, keylen ); |
||||||
|
blake2s_update( S, block, BLAKE2S_BLOCKBYTES ); |
||||||
|
secure_zero_memory( block, BLAKE2S_BLOCKBYTES ); /* Burn the key from stack */ |
||||||
|
} |
||||||
|
return 0; |
||||||
|
} |
||||||
|
|
||||||
|
int blake2s_compress( blake2s_state *S, const uint8_t block[BLAKE2S_BLOCKBYTES] ) |
||||||
|
{ |
||||||
|
uint32_t m[16]; |
||||||
|
uint32_t v[16]; |
||||||
|
|
||||||
|
for( size_t i = 0; i < 16; ++i ) |
||||||
|
m[i] = load32( block + i * sizeof( m[i] ) ); |
||||||
|
|
||||||
|
for( size_t i = 0; i < 8; ++i ) |
||||||
|
v[i] = S->h[i]; |
||||||
|
|
||||||
|
v[ 8] = blake2s_IV[0]; |
||||||
|
v[ 9] = blake2s_IV[1]; |
||||||
|
v[10] = blake2s_IV[2]; |
||||||
|
v[11] = blake2s_IV[3]; |
||||||
|
v[12] = S->t[0] ^ blake2s_IV[4]; |
||||||
|
v[13] = S->t[1] ^ blake2s_IV[5]; |
||||||
|
v[14] = S->f[0] ^ blake2s_IV[6]; |
||||||
|
v[15] = S->f[1] ^ blake2s_IV[7]; |
||||||
|
#define G(r,i,a,b,c,d) \ |
||||||
|
do { \ |
||||||
|
a = a + b + m[blake2s_sigma[r][2*i+0]]; \ |
||||||
|
d = SPH_ROTR32(d ^ a, 16); \ |
||||||
|
c = c + d; \ |
||||||
|
b = SPH_ROTR32(b ^ c, 12); \ |
||||||
|
a = a + b + m[blake2s_sigma[r][2*i+1]]; \ |
||||||
|
d = SPH_ROTR32(d ^ a, 8); \ |
||||||
|
c = c + d; \ |
||||||
|
b = SPH_ROTR32(b ^ c, 7); \ |
||||||
|
} while(0) |
||||||
|
#define ROUND(r) \ |
||||||
|
do { \ |
||||||
|
G(r,0,v[ 0],v[ 4],v[ 8],v[12]); \ |
||||||
|
G(r,1,v[ 1],v[ 5],v[ 9],v[13]); \ |
||||||
|
G(r,2,v[ 2],v[ 6],v[10],v[14]); \ |
||||||
|
G(r,3,v[ 3],v[ 7],v[11],v[15]); \ |
||||||
|
G(r,4,v[ 0],v[ 5],v[10],v[15]); \ |
||||||
|
G(r,5,v[ 1],v[ 6],v[11],v[12]); \ |
||||||
|
G(r,6,v[ 2],v[ 7],v[ 8],v[13]); \ |
||||||
|
G(r,7,v[ 3],v[ 4],v[ 9],v[14]); \ |
||||||
|
} while(0) |
||||||
|
ROUND( 0 ); |
||||||
|
ROUND( 1 ); |
||||||
|
ROUND( 2 ); |
||||||
|
ROUND( 3 ); |
||||||
|
ROUND( 4 ); |
||||||
|
ROUND( 5 ); |
||||||
|
ROUND( 6 ); |
||||||
|
ROUND( 7 ); |
||||||
|
ROUND( 8 ); |
||||||
|
ROUND( 9 ); |
||||||
|
|
||||||
|
for( size_t i = 0; i < 8; ++i ) |
||||||
|
S->h[i] = S->h[i] ^ v[i] ^ v[i + 8]; |
||||||
|
|
||||||
|
#undef G |
||||||
|
#undef ROUND |
||||||
|
return 0; |
||||||
|
} |
||||||
|
|
||||||
|
|
||||||
|
int blake2s_update( blake2s_state *S, const uint8_t *in, uint64_t inlen ) |
||||||
|
{ |
||||||
|
while( inlen > 0 ) |
||||||
|
{ |
||||||
|
size_t left = S->buflen; |
||||||
|
size_t fill = 2 * BLAKE2S_BLOCKBYTES - left; |
||||||
|
|
||||||
|
if( inlen > fill ) |
||||||
|
{ |
||||||
|
memcpy( S->buf + left, in, fill ); // Fill buffer
|
||||||
|
S->buflen += fill; |
||||||
|
blake2s_increment_counter( S, BLAKE2S_BLOCKBYTES ); |
||||||
|
blake2s_compress( S, S->buf ); // Compress
|
||||||
|
memcpy( S->buf, S->buf + BLAKE2S_BLOCKBYTES, BLAKE2S_BLOCKBYTES ); // Shift buffer left
|
||||||
|
S->buflen -= BLAKE2S_BLOCKBYTES; |
||||||
|
in += fill; |
||||||
|
inlen -= fill; |
||||||
|
} |
||||||
|
else // inlen <= fill
|
||||||
|
{ |
||||||
|
memcpy(S->buf + left, in, (size_t) inlen); |
||||||
|
S->buflen += (size_t) inlen; // Be lazy, do not compress
|
||||||
|
in += inlen; |
||||||
|
inlen -= inlen; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
return 0; |
||||||
|
} |
||||||
|
|
||||||
|
int blake2s_final( blake2s_state *S, uint8_t *out, uint8_t outlen ) |
||||||
|
{ |
||||||
|
uint8_t buffer[BLAKE2S_OUTBYTES]; |
||||||
|
|
||||||
|
if( S->buflen > BLAKE2S_BLOCKBYTES ) |
||||||
|
{ |
||||||
|
blake2s_increment_counter( S, BLAKE2S_BLOCKBYTES ); |
||||||
|
blake2s_compress( S, S->buf ); |
||||||
|
S->buflen -= BLAKE2S_BLOCKBYTES; |
||||||
|
memcpy( S->buf, S->buf + BLAKE2S_BLOCKBYTES, S->buflen ); |
||||||
|
} |
||||||
|
|
||||||
|
blake2s_increment_counter( S, ( uint32_t )S->buflen ); |
||||||
|
blake2s_set_lastblock( S ); |
||||||
|
memset( S->buf + S->buflen, 0, 2 * BLAKE2S_BLOCKBYTES - S->buflen ); /* Padding */ |
||||||
|
blake2s_compress( S, S->buf ); |
||||||
|
|
||||||
|
for( int i = 0; i < 8; ++i ) /* Output full hash to temp buffer */ |
||||||
|
store32( buffer + sizeof( S->h[i] ) * i, S->h[i] ); |
||||||
|
|
||||||
|
memcpy( out, buffer, outlen ); |
||||||
|
return 0; |
||||||
|
} |
||||||
|
|
||||||
|
int blake2s( uint8_t *out, const void *in, const void *key, const uint8_t outlen, const uint64_t inlen, uint8_t keylen ) |
||||||
|
{ |
||||||
|
blake2s_state S[1]; |
||||||
|
|
||||||
|
/* Verify parameters */ |
||||||
|
if ( NULL == in ) return -1; |
||||||
|
|
||||||
|
if ( NULL == out ) return -1; |
||||||
|
|
||||||
|
if ( NULL == key ) keylen = 0; /* Fail here instead if keylen != 0 and key == NULL? */ |
||||||
|
|
||||||
|
if( keylen > 0 ) |
||||||
|
{ |
||||||
|
if( blake2s_init_key( S, outlen, key, keylen ) < 0 ) return -1; |
||||||
|
} |
||||||
|
else |
||||||
|
{ |
||||||
|
if( blake2s_init( S, outlen ) < 0 ) return -1; |
||||||
|
} |
||||||
|
|
||||||
|
blake2s_update( S, ( uint8_t * )in, inlen ); |
||||||
|
blake2s_final( S, out, outlen ); |
||||||
|
return 0; |
||||||
|
} |
||||||
|
|
||||||
|
#if defined(__cplusplus) |
||||||
|
} |
||||||
|
#endif |
||||||
|
|
||||||
|
|
||||||
|
#if defined(BLAKE2S_SELFTEST) |
||||||
|
#include <string.h> |
||||||
|
#include "blake2-kat.h" /* test data not included */ |
||||||
|
int main( int argc, char **argv ) |
||||||
|
{ |
||||||
|
uint8_t key[BLAKE2S_KEYBYTES]; |
||||||
|
uint8_t buf[KAT_LENGTH]; |
||||||
|
|
||||||
|
for( size_t i = 0; i < BLAKE2S_KEYBYTES; ++i ) |
||||||
|
key[i] = ( uint8_t )i; |
||||||
|
|
||||||
|
for( size_t i = 0; i < KAT_LENGTH; ++i ) |
||||||
|
buf[i] = ( uint8_t )i; |
||||||
|
|
||||||
|
for( size_t i = 0; i < KAT_LENGTH; ++i ) |
||||||
|
{ |
||||||
|
uint8_t hash[BLAKE2S_OUTBYTES]; |
||||||
|
blake2s( hash, buf, key, BLAKE2S_OUTBYTES, i, BLAKE2S_KEYBYTES ); |
||||||
|
|
||||||
|
if( 0 != memcmp( hash, blake2s_keyed_kat[i], BLAKE2S_OUTBYTES ) ) |
||||||
|
{ |
||||||
|
puts( "error" ); |
||||||
|
return -1; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
puts( "ok" ); |
||||||
|
return 0; |
||||||
|
} |
||||||
|
#endif |
||||||
@ -0,0 +1,150 @@ |
|||||||
|
/**
|
||||||
|
* BLAKE2 reference source code package - reference C implementations |
||||||
|
* |
||||||
|
* Written in 2012 by Samuel Neves <sneves@dei.uc.pt> |
||||||
|
* |
||||||
|
* To the extent possible under law, the author(s) have dedicated all copyright |
||||||
|
* and related and neighboring rights to this software to the public domain |
||||||
|
* worldwide. This software is distributed without any warranty. |
||||||
|
* |
||||||
|
* You should have received a copy of the CC0 Public Domain Dedication along with |
||||||
|
* this software. If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
|
||||||
|
*/ |
||||||
|
#pragma once |
||||||
|
#ifndef __BLAKE2_H__ |
||||||
|
#define __BLAKE2_H__ |
||||||
|
|
||||||
|
#include <stddef.h> |
||||||
|
#include <stdint.h> |
||||||
|
|
||||||
|
#if defined(_MSC_VER) |
||||||
|
#include <inttypes.h> |
||||||
|
#define inline __inline |
||||||
|
#define ALIGN(x) __declspec(align(x)) |
||||||
|
#else |
||||||
|
#define ALIGN(x) __attribute__((aligned(x))) |
||||||
|
#endif |
||||||
|
|
||||||
|
/* blake2-impl.h */ |
||||||
|
|
||||||
|
static inline uint32_t load32(const void *src) |
||||||
|
{ |
||||||
|
#if defined(NATIVE_LITTLE_ENDIAN) |
||||||
|
return *(uint32_t *)(src); |
||||||
|
#else |
||||||
|
const uint8_t *p = (uint8_t *)src; |
||||||
|
uint32_t w = *p++; |
||||||
|
w |= (uint32_t)(*p++) << 8; |
||||||
|
w |= (uint32_t)(*p++) << 16; |
||||||
|
w |= (uint32_t)(*p++) << 24; |
||||||
|
return w; |
||||||
|
#endif |
||||||
|
} |
||||||
|
|
||||||
|
static inline void store32(void *dst, uint32_t w) |
||||||
|
{ |
||||||
|
#if defined(NATIVE_LITTLE_ENDIAN) |
||||||
|
*(uint32_t *)(dst) = w; |
||||||
|
#else |
||||||
|
uint8_t *p = (uint8_t *)dst; |
||||||
|
*p++ = (uint8_t)w; w >>= 8; |
||||||
|
*p++ = (uint8_t)w; w >>= 8; |
||||||
|
*p++ = (uint8_t)w; w >>= 8; |
||||||
|
*p++ = (uint8_t)w; |
||||||
|
#endif |
||||||
|
} |
||||||
|
|
||||||
|
static inline uint64_t load48(const void *src) |
||||||
|
{ |
||||||
|
const uint8_t *p = (const uint8_t *)src; |
||||||
|
uint64_t w = *p++; |
||||||
|
w |= (uint64_t)(*p++) << 8; |
||||||
|
w |= (uint64_t)(*p++) << 16; |
||||||
|
w |= (uint64_t)(*p++) << 24; |
||||||
|
w |= (uint64_t)(*p++) << 32; |
||||||
|
w |= (uint64_t)(*p++) << 40; |
||||||
|
return w; |
||||||
|
} |
||||||
|
|
||||||
|
static inline void store48(void *dst, uint64_t w) |
||||||
|
{ |
||||||
|
uint8_t *p = (uint8_t *)dst; |
||||||
|
*p++ = (uint8_t)w; w >>= 8; |
||||||
|
*p++ = (uint8_t)w; w >>= 8; |
||||||
|
*p++ = (uint8_t)w; w >>= 8; |
||||||
|
*p++ = (uint8_t)w; w >>= 8; |
||||||
|
*p++ = (uint8_t)w; w >>= 8; |
||||||
|
*p++ = (uint8_t)w; |
||||||
|
} |
||||||
|
|
||||||
|
/* prevents compiler optimizing out memset() */ |
||||||
|
static inline void secure_zero_memory(void *v, size_t n) |
||||||
|
{ |
||||||
|
volatile uint8_t *p = ( volatile uint8_t * )v; |
||||||
|
|
||||||
|
while( n-- ) *p++ = 0; |
||||||
|
} |
||||||
|
|
||||||
|
/* blake2.h */ |
||||||
|
|
||||||
|
enum blake2s_constant |
||||||
|
{ |
||||||
|
BLAKE2S_BLOCKBYTES = 64, |
||||||
|
BLAKE2S_OUTBYTES = 32, |
||||||
|
BLAKE2S_KEYBYTES = 32, |
||||||
|
BLAKE2S_SALTBYTES = 8, |
||||||
|
BLAKE2S_PERSONALBYTES = 8 |
||||||
|
}; |
||||||
|
|
||||||
|
#pragma pack(push, 1) |
||||||
|
typedef struct __blake2s_param |
||||||
|
{ |
||||||
|
uint8_t digest_length; // 1
|
||||||
|
uint8_t key_length; // 2
|
||||||
|
uint8_t fanout; // 3
|
||||||
|
uint8_t depth; // 4
|
||||||
|
uint32_t leaf_length; // 8
|
||||||
|
uint8_t node_offset[6];// 14
|
||||||
|
uint8_t node_depth; // 15
|
||||||
|
uint8_t inner_length; // 16
|
||||||
|
// uint8_t reserved[0];
|
||||||
|
uint8_t salt[BLAKE2S_SALTBYTES]; // 24
|
||||||
|
uint8_t personal[BLAKE2S_PERSONALBYTES]; // 32
|
||||||
|
} blake2s_param; |
||||||
|
|
||||||
|
ALIGN( 64 ) typedef struct __blake2s_state |
||||||
|
{ |
||||||
|
uint32_t h[8]; |
||||||
|
uint32_t t[2]; |
||||||
|
uint32_t f[2]; |
||||||
|
uint8_t buf[2 * BLAKE2S_BLOCKBYTES]; |
||||||
|
size_t buflen; |
||||||
|
uint8_t last_node; |
||||||
|
} blake2s_state; |
||||||
|
#pragma pack(pop) |
||||||
|
|
||||||
|
#if defined(__cplusplus) |
||||||
|
extern "C" { |
||||||
|
#endif |
||||||
|
|
||||||
|
int blake2s_compress( blake2s_state *S, const uint8_t block[BLAKE2S_BLOCKBYTES] ); |
||||||
|
|
||||||
|
// Streaming API
|
||||||
|
int blake2s_init( blake2s_state *S, const uint8_t outlen ); |
||||||
|
int blake2s_init_key( blake2s_state *S, const uint8_t outlen, const void *key, const uint8_t keylen ); |
||||||
|
int blake2s_init_param( blake2s_state *S, const blake2s_param *P ); |
||||||
|
int blake2s_update( blake2s_state *S, const uint8_t *in, uint64_t inlen ); |
||||||
|
int blake2s_final( blake2s_state *S, uint8_t *out, uint8_t outlen ); |
||||||
|
|
||||||
|
// Simple API
|
||||||
|
int blake2s( uint8_t *out, const void *in, const void *key, const uint8_t outlen, const uint64_t inlen, uint8_t keylen ); |
||||||
|
|
||||||
|
// Direct Hash Mining Helpers
|
||||||
|
#define blake2s_salt32(out, in, inlen, key32) blake2s(out, in, key32, 32, inlen, 32) /* neoscrypt */ |
||||||
|
#define blake2s_simple(out, in, inlen) blake2s(out, in, NULL, 32, inlen, 0) |
||||||
|
|
||||||
|
#if defined(__cplusplus) |
||||||
|
} |
||||||
|
#endif |
||||||
|
|
||||||
|
#endif |
||||||
Loading…
Reference in new issue