Compare commits
4
Commits
ethash
...
opencl-test
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
666249eb5d | ||
|
|
e3b45b392d | ||
|
|
fb3c720717 | ||
|
|
4ec901acf8 |
No files matched your search
+49
-43
@@ -5,57 +5,63 @@ else
|
||||
JANSSON_INCLUDES=
|
||||
endif
|
||||
|
||||
EXTRA_DIST = autogen.sh README.txt LICENSE.txt \
|
||||
cudaminer.sln cudaminer.vcxproj cudaminer.vcxproj.filters \
|
||||
compat/gettimeofday.c compat/getopt/getopt_long.c cpuminer-config.h.in
|
||||
EXTRA_DIST = autogen.sh README.txt LICENSE.txt \
|
||||
cudaminer.sln cudaminer.vcxproj cudaminer.vcxproj.filters \
|
||||
compat/gettimeofday.c compat/getopt/getopt_long.c cpuminer-config.h.in
|
||||
|
||||
SUBDIRS = compat
|
||||
SUBDIRS = compat
|
||||
|
||||
bin_PROGRAMS = ccminer
|
||||
bin_PROGRAMS = ccminer
|
||||
|
||||
ccminer_SOURCES = elist.h miner.h compat.h \
|
||||
compat/inttypes.h compat/stdbool.h compat/unistd.h \
|
||||
compat/sys/time.h compat/getopt/getopt.h \
|
||||
cpu-miner.c util.c crc32.c hefty1.c scrypt.c \
|
||||
hashlog.cpp \
|
||||
heavy/heavy.cu \
|
||||
heavy/cuda_blake512.cu heavy/cuda_blake512.h \
|
||||
heavy/cuda_combine.cu heavy/cuda_combine.h \
|
||||
heavy/cuda_groestl512.cu heavy/cuda_groestl512.h \
|
||||
heavy/cuda_hefty1.cu heavy/cuda_hefty1.h \
|
||||
heavy/cuda_keccak512.cu heavy/cuda_keccak512.h \
|
||||
heavy/cuda_sha256.cu heavy/cuda_sha256.h \
|
||||
keccak/cuda_keccak256.cu keccak/keccak256.cu \
|
||||
fuguecoin.cpp cuda_fugue256.cu sph/fugue.c sph/sph_fugue.h uint256.h \
|
||||
groestlcoin.cpp cuda_groestlcoin.cu cuda_groestlcoin.h \
|
||||
myriadgroestl.cpp cuda_myriadgroestl.cu \
|
||||
JHA/jackpotcoin.cu JHA/cuda_jha_keccak512.cu \
|
||||
JHA/cuda_jha_compactionTest.cu cuda_checkhash.cu \
|
||||
quark/cuda_jh512.cu quark/cuda_quark_blake512.cu quark/cuda_quark_groestl512.cu quark/cuda_skein512.cu \
|
||||
quark/cuda_bmw512.cu quark/cuda_quark_keccak512.cu \
|
||||
quark/quarkcoin.cu quark/animecoin.cu \
|
||||
quark/cuda_quark_compactionTest.cu \
|
||||
cuda_nist5.cu blake32.cu pentablake.cu \
|
||||
sph/bmw.c sph/blake.c sph/groestl.c sph/jh.c sph/keccak.c sph/skein.c \
|
||||
sph/cubehash.c sph/echo.c sph/luffa.c sph/sha2.c sph/shavite.c sph/simd.c \
|
||||
sph/hamsi.c sph/hamsi_helper.c sph/sph_hamsi.h \
|
||||
sph/shabal.c sph/whirlpool.c sph/sha2big.c sph/haval.c \
|
||||
qubit/qubit.cu qubit/qubit_luffa512.cu qubit/deep.cu qubit/doom.cu \
|
||||
x11/x11.cu x11/fresh.cu x11/cuda_x11_luffa512.cu x11/cuda_x11_cubehash512.cu \
|
||||
x11/cuda_x11_shavite512.cu x11/cuda_x11_simd512.cu x11/cuda_x11_echo.cu \
|
||||
x13/x13.cu x13/cuda_x13_hamsi512.cu x13/cuda_x13_fugue512.cu \
|
||||
x15/x14.cu x15/x15.cu x15/cuda_x14_shabal512.cu x15/cuda_x15_whirlpool.cu \
|
||||
x15/whirlpool.cu \
|
||||
x17/x17.cu x17/cuda_x17_haval512.cu x17/cuda_x17_sha512.cu \
|
||||
x11/s3.cu
|
||||
ccminer_SOURCES = \
|
||||
compat/inttypes.h compat/stdbool.h compat/unistd.h \
|
||||
compat/sys/time.h compat/getopt/getopt.h \
|
||||
cpu-miner.c util.c crc32.c hefty1.c scrypt.c \
|
||||
hashlog.cpp \
|
||||
heavy/heavy.cu \
|
||||
heavy/cuda_blake512.cu \
|
||||
heavy/cuda_combine.cu \
|
||||
heavy/cuda_groestl512.cu \
|
||||
heavy/cuda_hefty1.cu \
|
||||
heavy/cuda_keccak512.cu \
|
||||
heavy/cuda_sha256.cu \
|
||||
keccak/cuda_keccak256.cu keccak/keccak256.cu \
|
||||
fuguecoin.cpp cuda_fugue256.cu sph/fugue.c \
|
||||
groestlcoin.cpp cuda_groestlcoin.cu \
|
||||
myriadgroestl.cpp cuda_myriadgroestl.cu \
|
||||
JHA/jackpotcoin.cu JHA/cuda_jha_keccak512.cu \
|
||||
JHA/cuda_jha_compactionTest.cu cuda_checkhash.cu \
|
||||
quark/cuda_jh512.cu quark/cuda_quark_blake512.cu quark/cuda_quark_groestl512.cu quark/cuda_skein512.cu \
|
||||
quark/cuda_bmw512.cu quark/cuda_quark_keccak512.cu \
|
||||
quark/quarkcoin.cu quark/animecoin.cu \
|
||||
quark/cuda_quark_compactionTest.cu \
|
||||
cuda_nist5.cu blake32.cu pentablake.cu \
|
||||
sph/bmw.c sph/blake.c sph/groestl.c sph/jh.c sph/keccak.c sph/skein.c \
|
||||
sph/cubehash.c sph/echo.c sph/luffa.c sph/sha2.c sph/shavite.c sph/simd.c \
|
||||
sph/hamsi.c sph/hamsi_helper.c \
|
||||
sph/shabal.c sph/whirlpool.c sph/sha2big.c sph/haval.c \
|
||||
sph/blake2s.c \
|
||||
qubit/qubit.cu qubit/qubit_luffa512.cu qubit/deep.cu qubit/doom.cu \
|
||||
x11/x11.cu x11/fresh.cu x11/s3.cu x11/cuda_x11_luffa512.cu x11/cuda_x11_cubehash512.cu \
|
||||
x11/cuda_x11_shavite512.cu x11/cuda_x11_simd512.cu x11/cuda_x11_echo.cu \
|
||||
x13/x13.cu x13/cuda_x13_hamsi512.cu x13/cuda_x13_fugue512.cu \
|
||||
x15/x14.cu x15/x15.cu x15/cuda_x14_shabal512.cu x15/cuda_x15_whirlpool.cu \
|
||||
x15/whirlpool.cu \
|
||||
x17/x17.cu x17/cuda_x17_haval512.cu x17/cuda_x17_sha512.cu
|
||||
|
||||
if HAVE_WINDOWS
|
||||
ccminer_SOURCES += compat/winansi.c
|
||||
endif
|
||||
|
||||
ccminer_LDFLAGS = $(PTHREAD_FLAGS) @CUDA_LDFLAGS@
|
||||
ccminer_LDADD = @LIBCURL@ @JANSSON_LIBS@ @PTHREAD_LIBS@ @WS2_LIBS@ @CUDA_LIBS@ @OPENMP_CFLAGS@ @LIBS@
|
||||
ccminer_CPPFLAGS = @LIBCURL_CPPFLAGS@ @OPENMP_CFLAGS@ $(CPPFLAGS) $(PTHREAD_FLAGS) -fno-strict-aliasing $(JANSSON_INCLUDES) -DSCRYPT_KECCAK512 -DSCRYPT_CHACHA -DSCRYPT_CHOOSE_COMPILETIME
|
||||
ccminer_LDFLAGS = $(PTHREAD_FLAGS) @CUDA_LDFLAGS@
|
||||
ccminer_LDADD = @LIBCURL@ @JANSSON_LIBS@ @PTHREAD_LIBS@ @WS2_LIBS@ @CUDA_LIBS@ @OPENMP_CFLAGS@ @LIBS@
|
||||
ccminer_CPPFLAGS = -msse2 @LIBCURL_CPPFLAGS@ @OPENMP_CFLAGS@ $(CPPFLAGS) $(PTHREAD_FLAGS) -fno-strict-aliasing $(JANSSON_INCLUDES) -DSCRYPT_KECCAK512 -DSCRYPT_CHACHA -DSCRYPT_CHOOSE_COMPILETIME
|
||||
|
||||
if WANT_OPENCL
|
||||
ccminer_SOURCES += opencl.c
|
||||
ccminer_LDADD += @OPENCL_LIBS@
|
||||
ccminer_CPPFLAGS += @OPENCL_CFLAGS@
|
||||
endif
|
||||
|
||||
nvcc_ARCH = -gencode=arch=compute_50,code=\"sm_50,compute_50\"
|
||||
#nvcc_ARCH += -gencode=arch=compute_35,code=\"sm_35,compute_35\"
|
||||
|
||||
+18
-1
@@ -1,4 +1,4 @@
|
||||
AC_INIT([ccminer], [1.4.7])
|
||||
AC_INIT([cncminer], [1.5.0])
|
||||
|
||||
AC_PREREQ([2.59c])
|
||||
AC_CANONICAL_SYSTEM
|
||||
@@ -103,6 +103,23 @@ AC_CHECK_LIB([pthread], [pthread_create], PTHREAD_LIBS="-lpthread",
|
||||
AC_CHECK_LIB([ssl],[SSL_library_init], [], [AC_MSG_ERROR([OpenSSL library required])])
|
||||
AC_CHECK_LIB([crypto],[EVP_DigestFinal_ex], [], [AC_MSG_ERROR([OpenSSL library required])])
|
||||
|
||||
# *** OpenCL ***
|
||||
AC_ARG_ENABLE([opencl],
|
||||
[AC_HELP_STRING([--disable-opencl],[Disable optional OpenCL support])],
|
||||
[opencl=$enableval]
|
||||
)
|
||||
|
||||
if test "x$opencl" != xno; then
|
||||
OPENCL_CFLAGS="-DWITH_OPENCL -I$with_cuda/include"
|
||||
OPENCL_LIBS="-lOpenCL"
|
||||
else
|
||||
OPENCL_CFLAGS=""
|
||||
OPENCL_LIBS=""
|
||||
fi
|
||||
AC_SUBST(OPENCL_CFLAGS)
|
||||
AC_SUBST(OPENCL_LIBS)
|
||||
|
||||
AM_CONDITIONAL([WANT_OPENCL], [test x$opencl != xno])
|
||||
AM_CONDITIONAL([WANT_JANSSON], [test x$request_jansson = xtrue])
|
||||
AM_CONDITIONAL([HAVE_WINDOWS], [test x$have_win32 = xtrue])
|
||||
AM_CONDITIONAL([ARCH_x86], [test x$have_x86 = xtrue])
|
||||
|
||||
+60
-14
@@ -1,6 +1,8 @@
|
||||
/*
|
||||
/* vim: set ts=4 sw=4 sts=4 tw=0 cindent: */
|
||||
/*
|
||||
* Copyright 2010 Jeff Garzik
|
||||
* Copyright 2012-2014 pooler
|
||||
* Copyright 2014 tpruvot / #ccminer team
|
||||
*
|
||||
* 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
|
||||
@@ -51,9 +53,9 @@
|
||||
BOOL WINAPI ConsoleHandler(DWORD);
|
||||
#endif
|
||||
|
||||
#define PROGRAM_NAME "ccminer"
|
||||
#define LP_SCANTIME 60
|
||||
#define HEAVYCOIN_BLKHDR_SZ 84
|
||||
#define PROGRAM_NAME "cncminer"
|
||||
#define LP_SCANTIME 60
|
||||
#define HEAVYCOIN_BLKHDR_SZ 84
|
||||
#define MNR_BLKHDR_SZ 80
|
||||
|
||||
// from heavy.cu
|
||||
@@ -235,6 +237,10 @@ static unsigned long rejected_count = 0L;
|
||||
static double *thr_hashrates;
|
||||
uint64_t global_hashrate = 0;
|
||||
|
||||
const char * opt_kernel = NULL;
|
||||
const char * kernel_path = NULL;
|
||||
uint32_t opt_work_size = 0; /* default */
|
||||
|
||||
#ifdef HAVE_GETOPT_LONG
|
||||
#include <getopt.h>
|
||||
#else
|
||||
@@ -278,7 +284,14 @@ Options:\n\
|
||||
-d, --devices Comma separated list of CUDA devices to use.\n\
|
||||
Device IDs start counting from 0! Alternatively takes\n\
|
||||
string names of your cards like gtx780ti or gt640#2\n\
|
||||
(matching 2nd gt640 in the PC)\n\
|
||||
(match 2nd GT640 in the PC)\n\
|
||||
-i --intensity=N GPU intensity 0-31 (default: auto) \n"
|
||||
#ifdef WITH_OPENCL
|
||||
"\
|
||||
-k --kernel=... OpenCL kernel.cl file \n\
|
||||
-K --kernel-path=... OpenCL .cl files folder (default: current) \n"
|
||||
#endif
|
||||
"\
|
||||
-f, --diff Divide difficulty by this factor (std is 1) \n\
|
||||
-v, --vote=VOTE block reward vote (for HeavyCoin)\n\
|
||||
-m, --trust-pool trust the max block reward vote (maxvote) sent by the pool\n\
|
||||
@@ -298,7 +311,7 @@ Options:\n\
|
||||
--no-longpoll disable X-Long-Polling support\n\
|
||||
--no-stratum disable X-Stratum support\n\
|
||||
-q, --quiet disable per-thread hashmeter output\n\
|
||||
-K, --no-color disable colored output\n\
|
||||
--no-color disable colored output\n\
|
||||
-D, --debug enable debug output\n\
|
||||
-P, --protocol-dump verbose dump of protocol-level activities\n"
|
||||
#ifdef HAVE_SYSLOG_H
|
||||
@@ -324,7 +337,7 @@ static char const short_options[] =
|
||||
#ifdef HAVE_SYSLOG_H
|
||||
"S"
|
||||
#endif
|
||||
"a:c:CKDhp:Px:qr:R:s:t:T:o:u:O:Vd:f:mv:";
|
||||
"a:c:i:k:K:Dhp:Px:qr:R:s:t:T:o:u:O:Vd:f:mv:";
|
||||
|
||||
static struct option const options[] = {
|
||||
{ "algo", 1, NULL, 'a' },
|
||||
@@ -335,9 +348,14 @@ static struct option const options[] = {
|
||||
{ "cputest", 0, NULL, 1006 },
|
||||
{ "cert", 1, NULL, 1001 },
|
||||
{ "config", 1, NULL, 'c' },
|
||||
{ "no-color", 0, NULL, 'K' },
|
||||
{ "no-color", 0, NULL, 1002 },
|
||||
{ "debug", 0, NULL, 'D' },
|
||||
{ "help", 0, NULL, 'h' },
|
||||
{ "intensity", 1, NULL, 'i' },
|
||||
#ifdef WITH_OPENCL
|
||||
{ "kernel", 1, NULL, 'k' },
|
||||
{ "kernel-path", 1, NULL, 'K' },
|
||||
#endif
|
||||
{ "no-longpoll", 0, NULL, 1003 },
|
||||
{ "no-stratum", 0, NULL, 1007 },
|
||||
{ "pass", 1, NULL, 'p' },
|
||||
@@ -1221,8 +1239,12 @@ continue_scan:
|
||||
break;
|
||||
|
||||
case ALGO_BLAKE:
|
||||
rc = scanhash_blake256(thr_id, work.data, work.target,
|
||||
max_nonce, &hashes_done, 14);
|
||||
if (opt_kernel != NULL)
|
||||
rc = opencl_scan_blake256(thr_id, mythr->gpu,
|
||||
work.data, work.target, max_nonce, &hashes_done);
|
||||
else
|
||||
rc = scanhash_blake256(thr_id, work.data, work.target,
|
||||
max_nonce, &hashes_done, 14);
|
||||
break;
|
||||
|
||||
case ALGO_FRESH:
|
||||
@@ -1603,12 +1625,19 @@ static void parse_arg (int key, char *arg)
|
||||
}
|
||||
break;
|
||||
}
|
||||
case 'C':
|
||||
/* color for compat */
|
||||
use_colors = true;
|
||||
case 'i':
|
||||
v = atoi(arg);
|
||||
if (v < 0 || v > 31)
|
||||
show_usage_and_exit(1);
|
||||
opt_work_size = (1 << v);
|
||||
break;
|
||||
case 'k':
|
||||
/* OpenCL kernel name */
|
||||
opt_kernel = arg;
|
||||
break;
|
||||
case 'K':
|
||||
use_colors = false;
|
||||
/* OpenCL kernel path */
|
||||
kernel_path = arg;
|
||||
break;
|
||||
case 'D':
|
||||
opt_debug = true;
|
||||
@@ -1754,6 +1783,9 @@ static void parse_arg (int key, char *arg)
|
||||
case 1007:
|
||||
want_stratum = false;
|
||||
break;
|
||||
case 1002:
|
||||
use_colors = false;
|
||||
break;
|
||||
case 'S':
|
||||
use_syslog = true;
|
||||
break;
|
||||
@@ -1932,6 +1964,10 @@ int main(int argc, char *argv[])
|
||||
/* parse command line */
|
||||
parse_cmdline(argc, argv);
|
||||
|
||||
if (kernel_path == NULL) {
|
||||
kernel_path = get_current_dir_name();
|
||||
}
|
||||
|
||||
cuda_devicenames();
|
||||
|
||||
if (!opt_benchmark && !rpc_url) {
|
||||
@@ -2007,6 +2043,16 @@ int main(int argc, char *argv[])
|
||||
if (!thr_hashrates)
|
||||
return 1;
|
||||
|
||||
if (opt_kernel != NULL) {
|
||||
for (i = 0; i < opt_n_threads; i++) {
|
||||
thr = &thr_info[i];
|
||||
thr->gpu = cl_gpu_init(device_map[i], opt_kernel);
|
||||
if (thr->gpu == NULL)
|
||||
break;
|
||||
}
|
||||
opt_n_threads = i;
|
||||
}
|
||||
|
||||
/* init workio thread info */
|
||||
work_thr_id = opt_n_threads;
|
||||
thr = &thr_info[work_thr_id];
|
||||
|
||||
+6
-6
@@ -147,25 +147,25 @@
|
||||
#define LIBCURL_PROTOCOL_TFTP 1
|
||||
|
||||
/* Name of package */
|
||||
#define PACKAGE "ccminer"
|
||||
#define PACKAGE "cncminer"
|
||||
|
||||
/* Define to the address where bug reports for this package should be sent. */
|
||||
#define PACKAGE_BUGREPORT ""
|
||||
|
||||
/* Define to the full name of this package. */
|
||||
#define PACKAGE_NAME "ccminer"
|
||||
#define PACKAGE_NAME "cncminer"
|
||||
|
||||
/* Define to the full name and version of this package. */
|
||||
#define PACKAGE_STRING "ccminer 1.4.7"
|
||||
#define PACKAGE_STRING "cncminer 1.5.0"
|
||||
|
||||
/* Define to the one symbol short name of this package. */
|
||||
#define PACKAGE_TARNAME "ccminer"
|
||||
#define PACKAGE_TARNAME "cncminer"
|
||||
|
||||
/* Define to the home page for this package. */
|
||||
#define PACKAGE_URL ""
|
||||
|
||||
/* Define to the version of this package. */
|
||||
#define PACKAGE_VERSION "1.4.7"
|
||||
#define PACKAGE_VERSION "1.5.0"
|
||||
|
||||
/* If using the C implementation of alloca, define if you know the
|
||||
direction of stack growth for your system; otherwise it will be
|
||||
@@ -188,7 +188,7 @@
|
||||
#define USE_XOP 1
|
||||
|
||||
/* Version number of package */
|
||||
#define VERSION "1.4.7"
|
||||
#define VERSION "1.5.0"
|
||||
|
||||
/* Define curl_free() as free() if our version of curl lacks curl_free. */
|
||||
/* #undef curl_free */
|
||||
|
||||
@@ -7,6 +7,10 @@ extern "C" {
|
||||
|
||||
#include "cpuminer-config.h"
|
||||
|
||||
#ifdef WITH_OPENCL
|
||||
#include "opencl.h"
|
||||
#endif
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <inttypes.h>
|
||||
#include <sys/time.h>
|
||||
@@ -341,6 +345,12 @@ struct thr_info {
|
||||
int id;
|
||||
pthread_t pth;
|
||||
struct thread_q *q;
|
||||
|
||||
#ifdef WITH_OPENCL
|
||||
CLGPU* gpu;
|
||||
uint32_t shares_accepted;
|
||||
uint32_t shares_rejected;
|
||||
#endif
|
||||
};
|
||||
|
||||
struct work_restart {
|
||||
@@ -370,6 +380,7 @@ extern int stratum_thr_id;
|
||||
extern struct work_restart *work_restart;
|
||||
extern bool opt_trust_pool;
|
||||
extern uint16_t opt_vote;
|
||||
extern uint32_t opt_work_size;
|
||||
extern uint64_t global_hashrate;
|
||||
|
||||
#define CL_N "\x1B[0m"
|
||||
|
||||
@@ -0,0 +1,446 @@
|
||||
#include "miner.h"
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "sph/sph_blake.h"
|
||||
|
||||
enum platform_type {
|
||||
AMD,
|
||||
NVIDIA,
|
||||
OTHER
|
||||
};
|
||||
|
||||
extern const char* kernel_path;
|
||||
|
||||
void CHECK_OPENCL_ERROR(cl_int err, uint32_t id)
|
||||
{
|
||||
if (err != CL_SUCCESS)
|
||||
{
|
||||
switch (err)
|
||||
{
|
||||
case CL_DEVICE_NOT_FOUND:
|
||||
applog(LOG_ERR, "[GPU%u] error: CL_DEVICE_NOT_FOUND", id); exit(1);
|
||||
case CL_DEVICE_NOT_AVAILABLE:
|
||||
applog(LOG_ERR, "[GPU%u] error: CL_DEVICE_NOT_AVAILABLE", id); exit(1);
|
||||
case CL_COMPILER_NOT_AVAILABLE:
|
||||
applog(LOG_ERR, "[GPU%u] error: CL_COMPILER_NOT_AVAILABLE", id); exit(1);
|
||||
case CL_MEM_OBJECT_ALLOCATION_FAILURE:
|
||||
applog(LOG_ERR, "[GPU%u] error: CL_MEM_OBJECT_ALLOCATION_FAILURE", id); exit(1);
|
||||
case CL_OUT_OF_RESOURCES:
|
||||
applog(LOG_ERR, "[GPU%u] error: CL_OUT_OF_RESOURCES", id); exit(1);
|
||||
case CL_OUT_OF_HOST_MEMORY:
|
||||
applog(LOG_ERR, "[GPU%u] error: CL_OUT_OF_HOST_MEMORY", id); exit(1);
|
||||
case CL_PROFILING_INFO_NOT_AVAILABLE:
|
||||
applog(LOG_ERR, "[GPU%u] error: CL_PROFILING_INFO_NOT_AVAILABLE", id); exit(1);
|
||||
case CL_MEM_COPY_OVERLAP:
|
||||
applog(LOG_ERR, "[GPU%u] error: CL_MEM_COPY_OVERLAP", id); exit(1);
|
||||
case CL_IMAGE_FORMAT_MISMATCH:
|
||||
applog(LOG_ERR, "[GPU%u] error: CL_IMAGE_FORMAT_MISMATCH", id); exit(1);
|
||||
case CL_IMAGE_FORMAT_NOT_SUPPORTED:
|
||||
applog(LOG_ERR, "[GPU%u] error: CL_IMAGE_FORMAT_NOT_SUPPORTED", id); exit(1);
|
||||
case CL_BUILD_PROGRAM_FAILURE:
|
||||
applog(LOG_ERR, "[GPU%u] error: CL_BUILD_PROGRAM_FAILURE", id); exit(1);
|
||||
case CL_MAP_FAILURE:
|
||||
applog(LOG_ERR, "[GPU%u] error: CL_MAP_FAILURE", id); exit(1);
|
||||
|
||||
case CL_INVALID_VALUE:
|
||||
applog(LOG_ERR, "[GPU%u] error: CL_INVALID_VALUE", id); exit(1);
|
||||
case CL_INVALID_DEVICE_TYPE:
|
||||
applog(LOG_ERR, "[GPU%u] error: CL_INVALID_DEVICE_TYPE", id); exit(1);
|
||||
case CL_INVALID_PLATFORM:
|
||||
applog(LOG_ERR, "[GPU%u] error: CL_INVALID_PLATFORM", id); exit(1);
|
||||
case CL_INVALID_DEVICE:
|
||||
applog(LOG_ERR, "[GPU%u] error: CL_INVALID_DEVICE", id); exit(1);
|
||||
case CL_INVALID_CONTEXT:
|
||||
applog(LOG_ERR, "[GPU%u] error: CL_INVALID_CONTEXT", id); exit(1);
|
||||
case CL_INVALID_QUEUE_PROPERTIES:
|
||||
applog(LOG_ERR, "[GPU%u] error: CL_INVALID_QUEUE_PROPERTIES", id); exit(1);
|
||||
case CL_INVALID_COMMAND_QUEUE:
|
||||
applog(LOG_ERR, "[GPU%u] error: CL_INVALID_COMMAND_QUEUE", id); exit(1);
|
||||
case CL_INVALID_HOST_PTR:
|
||||
applog(LOG_ERR, "[GPU%u] error: CL_INVALID_HOST_PTR", id); exit(1);
|
||||
case CL_INVALID_MEM_OBJECT:
|
||||
applog(LOG_ERR, "[GPU%u] error: CL_INVALID_MEM_OBJECT", id); exit(1);
|
||||
case CL_INVALID_IMAGE_FORMAT_DESCRIPTOR:
|
||||
applog(LOG_ERR, "[GPU%u] error: CL_INVALID_IMAGE_FORMAT_DESCRIPTOR", id); exit(1);
|
||||
case CL_INVALID_IMAGE_SIZE:
|
||||
applog(LOG_ERR, "[GPU%u] error: CL_INVALID_IMAGE_SIZE", id); exit(1);
|
||||
case CL_INVALID_SAMPLER:
|
||||
applog(LOG_ERR, "[GPU%u] error: CL_INVALID_SAMPLER", id); exit(1);
|
||||
case CL_INVALID_BINARY:
|
||||
applog(LOG_ERR, "[GPU%u] error: CL_INVALID_BINARY", id); exit(1);
|
||||
case CL_INVALID_BUILD_OPTIONS:
|
||||
applog(LOG_ERR, "[GPU%u] error: CL_INVALID_BUILD_OPTIONS", id); exit(1);
|
||||
case CL_INVALID_PROGRAM:
|
||||
applog(LOG_ERR, "[GPU%u] error: CL_INVALID_PROGRAM", id); exit(1);
|
||||
case CL_INVALID_PROGRAM_EXECUTABLE:
|
||||
applog(LOG_ERR, "[GPU%u] error: CL_INVALID_PROGRAM_EXECUTABLE", id); exit(1);
|
||||
case CL_INVALID_KERNEL_NAME:
|
||||
applog(LOG_ERR, "[GPU%u] error: CL_INVALID_KERNEL_NAME", id); exit(1);
|
||||
case CL_INVALID_KERNEL_DEFINITION:
|
||||
applog(LOG_ERR, "[GPU%u] error: CL_INVALID_KERNEL_DEFINITION", id); exit(1);
|
||||
case CL_INVALID_KERNEL:
|
||||
applog(LOG_ERR, "[GPU%u] error: CL_INVALID_KERNEL", id); exit(1);
|
||||
case CL_INVALID_ARG_INDEX:
|
||||
applog(LOG_ERR, "[GPU%u] error: CL_INVALID_ARG_INDEX", id); exit(1);
|
||||
case CL_INVALID_ARG_VALUE:
|
||||
applog(LOG_ERR, "[GPU%u] error: CL_INVALID_ARG_VALUE", id); exit(1);
|
||||
case CL_INVALID_ARG_SIZE:
|
||||
applog(LOG_ERR, "[GPU%u] error: CL_INVALID_ARG_SIZE", id); exit(1);
|
||||
case CL_INVALID_KERNEL_ARGS:
|
||||
applog(LOG_ERR, "[GPU%u] error: CL_INVALID_KERNEL_ARGS", id); exit(1);
|
||||
case CL_INVALID_WORK_DIMENSION:
|
||||
applog(LOG_ERR, "[GPU%u] error: CL_INVALID_WORK_DIMENSION", id); exit(1);
|
||||
case CL_INVALID_WORK_GROUP_SIZE:
|
||||
applog(LOG_ERR, "[GPU%u] error: CL_INVALID_WORK_GROUP_SIZE", id); exit(1);
|
||||
case CL_INVALID_WORK_ITEM_SIZE:
|
||||
applog(LOG_ERR, "[GPU%u] error: CL_INVALID_WORK_ITEM_SIZE", id); exit(1);
|
||||
case CL_INVALID_GLOBAL_OFFSET:
|
||||
applog(LOG_ERR, "[GPU%u] error: CL_INVALID_GLOBAL_OFFSET", id); exit(1);
|
||||
case CL_INVALID_EVENT_WAIT_LIST:
|
||||
applog(LOG_ERR, "[GPU%u] error: CL_INVALID_EVENT_WAIT_LIST", id); exit(1);
|
||||
case CL_INVALID_EVENT:
|
||||
applog(LOG_ERR, "[GPU%u] error: CL_INVALID_EVENT", id); exit(1);
|
||||
case CL_INVALID_OPERATION:
|
||||
applog(LOG_ERR, "[GPU%u] error: CL_INVALID_OPERATION", id); exit(1);
|
||||
case CL_INVALID_GL_OBJECT:
|
||||
applog(LOG_ERR, "[GPU%u] error: CL_INVALID_GL_OBJECT", id); exit(1);
|
||||
case CL_INVALID_BUFFER_SIZE:
|
||||
applog(LOG_ERR, "[GPU%u] error: CL_INVALID_BUFFER_SIZE", id); exit(1);
|
||||
case CL_INVALID_MIP_LEVEL:
|
||||
applog(LOG_ERR, "[GPU%u] error: CL_INVALID_MIP_LEVEL", id); exit(1);
|
||||
case CL_INVALID_GLOBAL_WORK_SIZE:
|
||||
applog(LOG_ERR, "[GPU%u] error: CL_INVALID_GLOBAL_WORK_SIZE", id); exit(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Convert the kernel file into a string */
|
||||
char * kernelToString(const char *filename)
|
||||
{
|
||||
FILE *fp;
|
||||
long lSize;
|
||||
char *buffer;
|
||||
char filen[512];
|
||||
|
||||
fp = fopen(filename, "rb");
|
||||
if (!fp) {
|
||||
sprintf(filen, "%s/%s", kernel_path, filename);
|
||||
fp = fopen(filen, "rb");
|
||||
}
|
||||
if (!fp)
|
||||
perror(filen),exit(1);
|
||||
|
||||
fseek( fp , 0L , SEEK_END);
|
||||
lSize = ftell( fp );
|
||||
rewind( fp );
|
||||
|
||||
/* allocate memory for entire content */
|
||||
buffer = calloc( 1, lSize+1 );
|
||||
if( !buffer ) fclose(fp),fputs("memory alloc fails",stderr),exit(1);
|
||||
|
||||
/* copy the file into the buffer */
|
||||
if( 1!=fread( buffer , lSize, 1 , fp) )
|
||||
fclose(fp),free(buffer),fputs("entire read fails",stderr),exit(1);
|
||||
|
||||
fclose(fp);
|
||||
|
||||
return buffer;
|
||||
}
|
||||
|
||||
enum platform_type PrintPlatformInfo(unsigned int id, cl_platform_id platformId)
|
||||
{
|
||||
enum platform_type result;
|
||||
// Get Required Size
|
||||
size_t length;
|
||||
clGetPlatformInfo(platformId, CL_PLATFORM_NAME, 0, NULL, &length);
|
||||
char* sInfo = malloc(length);
|
||||
clGetPlatformInfo(platformId, CL_PLATFORM_NAME, length, sInfo, NULL);
|
||||
applog(LOG_INFO, "[GPU%u] Platform: %s", id, sInfo);
|
||||
if (strstr(sInfo, "NVIDIA") != NULL)
|
||||
result = NVIDIA;
|
||||
else if (strstr(sInfo, "AMD") != NULL)
|
||||
result = AMD;
|
||||
else
|
||||
result = OTHER;
|
||||
free(sInfo);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
void PrintDeviceInfo(unsigned int id, cl_device_id deviceId, cl_ulong *maxMem, cl_ulong *maxBuffer)
|
||||
{
|
||||
// Get Required Size
|
||||
size_t length;
|
||||
clGetDeviceInfo(deviceId, CL_DEVICE_NAME, 0, NULL, &length);
|
||||
// Get actual device name
|
||||
char* sInfo = malloc(length);
|
||||
clGetDeviceInfo(deviceId, CL_DEVICE_NAME, length, sInfo, NULL);
|
||||
applog(LOG_INFO, "[GPU%u] Device: %s", id, sInfo);
|
||||
|
||||
clGetDeviceInfo(deviceId, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof(cl_ulong), maxMem, NULL);
|
||||
applog(LOG_INFO, "[GPU%u] Total device memory: %d MB", id, *maxMem >> 20);
|
||||
|
||||
clGetDeviceInfo(deviceId, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof(cl_ulong), maxBuffer, NULL);
|
||||
applog(LOG_INFO, "[GPU%u] Maximum buffer size: %d MB", id, *maxBuffer >> 20);
|
||||
|
||||
free(sInfo);
|
||||
}
|
||||
|
||||
cl_kernel GetKernel(cl_program program, const char* sKernelName)
|
||||
{
|
||||
cl_int err;
|
||||
cl_kernel kernel = clCreateKernel(program, sKernelName, &err);
|
||||
CHECK_OPENCL_ERROR(err, 0);
|
||||
|
||||
return kernel;
|
||||
}
|
||||
|
||||
cl_mem DeviceMalloc(cl_context m_context, size_t size)
|
||||
{
|
||||
cl_int err;
|
||||
cl_mem mem = clCreateBuffer(m_context, CL_MEM_READ_WRITE, size, NULL, &err);
|
||||
CHECK_OPENCL_ERROR(err, 0);
|
||||
|
||||
return mem;
|
||||
}
|
||||
|
||||
void CopyBufferToDevice(cl_command_queue queue, cl_mem buffer, void* h_Buffer, size_t size)
|
||||
{
|
||||
/* to check: clEnqueueMapBuffer */
|
||||
cl_int err = clEnqueueWriteBuffer(queue, buffer, CL_TRUE, 0, size, h_Buffer, 0, NULL, NULL);
|
||||
CHECK_OPENCL_ERROR(err, 0);
|
||||
}
|
||||
|
||||
void CopyBufferToHost(cl_command_queue queue, cl_mem buffer, void* h_Buffer, size_t size)
|
||||
{
|
||||
cl_int err = clEnqueueReadBuffer(queue, buffer, CL_TRUE, 0, size, h_Buffer, 0, NULL, NULL);
|
||||
CHECK_OPENCL_ERROR(err, 0);
|
||||
}
|
||||
|
||||
static device_init[8] = { 0 };
|
||||
|
||||
CLGPU* cl_gpu_init(uint32_t id, const char* kernel) {
|
||||
applog(LOG_DEBUG, "[GPU%u] Init", id);
|
||||
CLGPU* gpu = (CLGPU*)calloc(1, sizeof(CLGPU));
|
||||
gpu->threadNumber = id;
|
||||
gpu->kernel_name = kernel;
|
||||
|
||||
/* Step1: Getting platforms and choose an available one. */
|
||||
cl_uint numPlatforms; //the NO. of platforms
|
||||
cl_platform_id platform = NULL; //the chosen platform
|
||||
cl_int status = clGetPlatformIDs(0, NULL, &numPlatforms);
|
||||
if (status != CL_SUCCESS)
|
||||
{
|
||||
applog(LOG_ERR, "Error %d getting platform list!", status);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* Step 2: Query the platform and choose the first GPU device if has one.Otherwise use the CPU as device. */
|
||||
cl_uint numDevices = 0;
|
||||
cl_device_id *devices;
|
||||
cl_platform_id* platforms = (cl_platform_id*)malloc(numPlatforms* sizeof(cl_platform_id));
|
||||
status = clGetPlatformIDs(numPlatforms, platforms, NULL);
|
||||
unsigned int gpuCount = 0;
|
||||
for (int i = 0; i < numPlatforms; i++) {
|
||||
platform = platforms[i];
|
||||
status = clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU, 0, NULL, &numDevices);
|
||||
if (numDevices > 0) {
|
||||
if (id - gpuCount < numDevices) {
|
||||
devices = (cl_device_id*)malloc(numDevices * sizeof(cl_device_id));
|
||||
status = clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU, numDevices, devices, NULL);
|
||||
gpu->device = devices[id - gpuCount];
|
||||
break;
|
||||
}
|
||||
else
|
||||
gpuCount += numDevices;
|
||||
}
|
||||
}
|
||||
free(platforms);
|
||||
|
||||
if (gpu->device == NULL) {
|
||||
applog(LOG_INFO, "[GPU%u] Device not found", id);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
enum platform_type platformType = PrintPlatformInfo(id, platform);
|
||||
cl_ulong maxMem, maxBuffer;
|
||||
PrintDeviceInfo(id, gpu->device, &maxMem, &maxBuffer);
|
||||
|
||||
gpu->context = clCreateContext(NULL, 1, &gpu->device, NULL, NULL, NULL);
|
||||
gpu->commandQueue = clCreateCommandQueue(gpu->context, gpu->device, 0, NULL);
|
||||
|
||||
const char *filename = gpu->kernel_name == NULL ? "blake256.cl" : gpu->kernel_name;
|
||||
char *source = kernelToString(filename);
|
||||
size_t sourceSize[] = { strlen(source) };
|
||||
|
||||
applog(LOG_DEBUG, "Creating the program: %s, size %d", filename, *sourceSize);
|
||||
gpu->program = clCreateProgramWithSource(gpu->context, 1, (const char**)&source, sourceSize, &status);
|
||||
if (status != CL_SUCCESS) {
|
||||
applog(LOG_ERR, "Error %d creating the program: %s", status, filename);
|
||||
return NULL;
|
||||
}
|
||||
free(source);
|
||||
|
||||
char *CompilerOptions = (char *)calloc(1, 256);
|
||||
memset(CompilerOptions, 0, 256);
|
||||
/*
|
||||
sprintf(CompilerOptions, "-D OUTPUT_SIZE=%u ", OUTPUT_SIZE);
|
||||
if (platformType == AMD)
|
||||
strcat(CompilerOptions, "-D RADEON=1 ");
|
||||
else if (platformType == NVIDIA)
|
||||
*/
|
||||
strcat(CompilerOptions, "-DNVIDIA=1 ");
|
||||
|
||||
if (strlen(CompilerOptions) > 0)
|
||||
applog(LOG_DEBUG, "Compiler options: %s", CompilerOptions);
|
||||
|
||||
status = clBuildProgram(gpu->program, 1, &gpu->device, CompilerOptions, NULL, NULL);
|
||||
if (status != CL_SUCCESS) {
|
||||
applog(LOG_ERR, "Error %d building the program: %s", status, filename);
|
||||
|
||||
if (opt_debug) {
|
||||
char *programLog;
|
||||
size_t logSize;
|
||||
cl_int error = 0;
|
||||
cl_build_status buildStatus;
|
||||
|
||||
// check build error and build status first
|
||||
clGetProgramBuildInfo(gpu->program, gpu->device, CL_PROGRAM_BUILD_STATUS, sizeof(cl_build_status), &buildStatus, NULL);
|
||||
// check build log
|
||||
clGetProgramBuildInfo(gpu->program, gpu->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &logSize);
|
||||
programLog = (char*) calloc (logSize+1, sizeof(char));
|
||||
clGetProgramBuildInfo(gpu->program, gpu->device, CL_PROGRAM_BUILD_LOG, logSize+1, programLog, NULL);
|
||||
printf("Build failed; error=%d, status=%d, programLog:\n\n%s", error, buildStatus, programLog);
|
||||
free(programLog);
|
||||
}
|
||||
CHECK_OPENCL_ERROR(status, gpu->threadNumber);
|
||||
}
|
||||
|
||||
if (strcmp(gpu->kernel_name, "blake256.cl") == 0)
|
||||
gpu->kernel = GetKernel(gpu->program, "search");
|
||||
else if (strcmp(gpu->kernel_name, "wild_keccak.cl") == 0)
|
||||
gpu->kernel = GetKernel(gpu->program, "search");
|
||||
else {
|
||||
applog(LOG_ERR, "[GPU%u] kernel %s not supported", id, gpu->kernel_name);
|
||||
exit(1);
|
||||
}
|
||||
gpu->inputBuffer = DeviceMalloc(gpu->context, 128); /* 80 req for blake */
|
||||
gpu->outputBuffer = DeviceMalloc(gpu->context, OUTPUT_SIZE + sizeof(uint32_t) /* result count */);
|
||||
|
||||
gpu->output = (uint32_t*) malloc(OUTPUT_SIZE);
|
||||
|
||||
applog(LOG_INFO, "[GPU%u] initialized successfully", id);
|
||||
|
||||
device_init[id] = true;
|
||||
|
||||
return gpu;
|
||||
}
|
||||
|
||||
void cl_gpu_release(CLGPU* gpu)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
static void opencl_run_blake256(CLGPU* gpu, uint32_t work_size, size_t offset, cl_ulong target)
|
||||
{
|
||||
if (opt_debug)
|
||||
applog(LOG_INFO, "[GPU%u] run work = %u, offset = %x", gpu->threadNumber, work_size, offset);
|
||||
|
||||
size_t off = offset;
|
||||
size_t num = work_size;
|
||||
int p = 0;
|
||||
cl_int err;
|
||||
cl_ulong targetArg = target;
|
||||
|
||||
err = clSetKernelArg(gpu->kernel, p++, sizeof(cl_mem), &gpu->outputBuffer);
|
||||
CHECK_OPENCL_ERROR(err, gpu->threadNumber);
|
||||
err = clSetKernelArg(gpu->kernel, p++, sizeof(cl_mem), &gpu->inputBuffer);
|
||||
CHECK_OPENCL_ERROR(err, gpu->threadNumber);
|
||||
err = clSetKernelArg(gpu->kernel, p++, sizeof(targetArg), &targetArg);
|
||||
CHECK_OPENCL_ERROR(err, gpu->threadNumber);
|
||||
|
||||
#if 0
|
||||
/* specific params */
|
||||
if (strcmp(gpu->kernel_name, "blake256.cl") == 0) {
|
||||
}
|
||||
|
||||
if (strcmp(gpu->kernel_name, "wild_keccak.cl") == 0) {
|
||||
gpu->extraBufferSz = 4;
|
||||
gpu->extraBuffer = DeviceMalloc(gpu->context, gpu->extraBufferSz);
|
||||
err = clSetKernelArg(gpu->kernel, p++, sizeof(cl_mem), &gpu->extraBuffer);
|
||||
CHECK_OPENCL_ERROR(err, gpu->threadNumber);
|
||||
err = clSetKernelArg(gpu->kernel, p++, sizeof(cl_int), &gpu->extraBufferSz);
|
||||
CHECK_OPENCL_ERROR(err, gpu->threadNumber);
|
||||
}
|
||||
#endif
|
||||
|
||||
err = clEnqueueNDRangeKernel(gpu->commandQueue, gpu->kernel, 1, &off, &num, NULL, 0, NULL, NULL);
|
||||
CHECK_OPENCL_ERROR(err, gpu->threadNumber);
|
||||
|
||||
err = clFinish(gpu->commandQueue);
|
||||
CHECK_OPENCL_ERROR(err, gpu->threadNumber);
|
||||
}
|
||||
|
||||
int opencl_scan_blake256(int thr_id, CLGPU *gpu, uint32_t *pdata, const uint32_t *ptarget, uint32_t max_nonce, unsigned long *hashes_done)
|
||||
{
|
||||
uint32_t throughput = opt_work_size ? opt_work_size : (1 << 18);
|
||||
uint32_t *nonceptr = (uint32_t*) (((char*)pdata) + 1);
|
||||
uint32_t n = *nonceptr;
|
||||
const uint32_t first_nonce = n;
|
||||
uint32_t hash[32 / 4] __attribute__((aligned(32)));
|
||||
cl_int err;
|
||||
|
||||
char buf[80];
|
||||
sph_blake256_context ctx;
|
||||
sph_blake256_init(&ctx);
|
||||
sph_blake256(&ctx, pdata, 64);
|
||||
sph_blake256_close(&ctx, buf);
|
||||
|
||||
memcpy(&buf[32], pdata + 16, 12);
|
||||
|
||||
//applog_hash(buf);
|
||||
//applog_hash(buf+32);
|
||||
do {
|
||||
CopyBufferToDevice(gpu->commandQueue, gpu->inputBuffer, buf, 80);
|
||||
|
||||
if (first_nonce == n) {
|
||||
memset(gpu->output, 0, OUTPUT_SIZE + 4);
|
||||
CopyBufferToDevice(gpu->commandQueue, gpu->outputBuffer, gpu->output, OUTPUT_SIZE + 4);
|
||||
} else {
|
||||
memset(gpu->output, 0, 4);
|
||||
CopyBufferToDevice(gpu->commandQueue, gpu->outputBuffer, gpu->output, 4);
|
||||
}
|
||||
|
||||
opencl_run_blake256(gpu, throughput, n, *((uint64_t*)&ptarget[6]));
|
||||
|
||||
CopyBufferToHost(gpu->commandQueue, gpu->outputBuffer, gpu->output, OUTPUT_SIZE);
|
||||
for (uint32_t i = 1; i < ((uint32_t*)gpu->output)[0]; i++) {
|
||||
applog_hash(gpu->output);
|
||||
uint64_t found_nonce = gpu->output[i];
|
||||
*nonceptr = found_nonce;
|
||||
blake256hash(pdata, hash, 14);
|
||||
if (unlikely(hash[7] < ptarget[7])) {
|
||||
*hashes_done = n - first_nonce;
|
||||
return true;
|
||||
}
|
||||
else
|
||||
applog(LOG_ERR, "[GPU%u] share doesn't validate on CPU, hash=%08x, target=%08x", gpu->threadNumber, hash[7], ptarget[7]);
|
||||
}
|
||||
|
||||
if (n + opt_work_size < max_nonce && n < UINT_MAX - throughput)
|
||||
n += throughput;
|
||||
else {
|
||||
pdata[19] = max_nonce;
|
||||
break;
|
||||
}
|
||||
|
||||
} while (!work_restart[thr_id].restart);
|
||||
|
||||
*hashes_done = pdata[19] - first_nonce + 1;
|
||||
|
||||
cl_gpu_release(gpu);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,47 @@
|
||||
#ifndef __GPU_H__
|
||||
#define __GPU_H__
|
||||
|
||||
#define OUTPUT_SIZE 32
|
||||
#define MAX_GPU 8
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdio.h>
|
||||
#include <CL/cl.h>
|
||||
|
||||
typedef struct {
|
||||
cl_device_id device;
|
||||
cl_context context;
|
||||
cl_command_queue commandQueue;
|
||||
|
||||
cl_kernel kernel;
|
||||
cl_kernel initKernel;
|
||||
cl_kernel init2Kernel;
|
||||
cl_kernel rndKernel;
|
||||
cl_kernel mixinKernel;
|
||||
cl_kernel resultKernel;
|
||||
|
||||
cl_program program;
|
||||
cl_mem inputBuffer;
|
||||
cl_mem outputBuffer;
|
||||
cl_mem stateBuffer;
|
||||
|
||||
cl_mem extraBuffer;
|
||||
uint32_t extraBufferSz;
|
||||
|
||||
uint32_t *output;
|
||||
uint32_t threadNumber;
|
||||
const char * kernel_name;
|
||||
|
||||
} CLGPU;
|
||||
|
||||
CLGPU* cl_gpu_init(uint32_t id, const char* kernel);
|
||||
void cl_gpu_run(CLGPU* gpu, uint32_t work_size, size_t offset, cl_ulong target);
|
||||
void cl_gpu_release(CLGPU* gpu);
|
||||
|
||||
void CopyBufferToDevice(cl_command_queue queue, cl_mem buffer, void* h_Buffer, size_t size);
|
||||
void CopyBufferToHost (cl_command_queue queue, cl_mem buffer, void* h_Buffer, size_t size);
|
||||
|
||||
/* algos */
|
||||
int opencl_scan_blake256(int thr_id, CLGPU *gpu, uint32_t *pdata, const uint32_t *ptarget, uint32_t max_nonce, unsigned long *hashes_done);
|
||||
|
||||
#endif /* __GPU_H__ */
|
||||
@@ -0,0 +1,167 @@
|
||||
// (c) 2013 originally written by smolen
|
||||
// 2014 ccminer adaptation by tpruvot
|
||||
|
||||
#define SPH_ROTR32(v,n) rotate((uint)(v),(uint)(32-(n)))
|
||||
|
||||
// precalc hash from first part of message
|
||||
#define h0 (const uint) in[0];
|
||||
#define h1 (const uint) in[1];
|
||||
#define h2 (const uint) in[2];
|
||||
#define h3 (const uint) in[3];
|
||||
#define h4 (const uint) in[4];
|
||||
#define h5 (const uint) in[5];
|
||||
#define h6 (const uint) in[6];
|
||||
#define h7 (const uint) in[7];
|
||||
|
||||
// last 12 bytes of original message
|
||||
#define in16 (const uint) in[8];
|
||||
#define in17 (const uint) in[9];
|
||||
#define in18 (const uint) in[10];
|
||||
|
||||
// to check : https://www.khronos.org/registry/cl/sdk/2.0/docs/man/xhtml/clEnqueueNDRangeKernel.html
|
||||
|
||||
__kernel /* __attribute__((reqd_work_group_size(WORKSIZE, 1, 1))) */
|
||||
void search(
|
||||
volatile __global uint * restrict output,
|
||||
__global const uint * restrict in,
|
||||
const ulong target
|
||||
)
|
||||
{
|
||||
uint M0, M1, M2, M3, M4, M5, M6, M7;
|
||||
uint M8, M9, MA, MB, MC, MD, ME, MF;
|
||||
uint V0, V1, V2, V3, V4, V5, V6, V7;
|
||||
uint V8, V9, VA, VB, VC, VD, VE, VF;
|
||||
uint pre7;
|
||||
|
||||
uint nonce = get_global_id(0);
|
||||
|
||||
V0 = h0;
|
||||
V1 = h1;
|
||||
V2 = h2;
|
||||
V3 = h3;
|
||||
V4 = h4;
|
||||
V5 = h5;
|
||||
V6 = h6;
|
||||
pre7 = V7 = h7;
|
||||
M0 = in16;
|
||||
M1 = in17;
|
||||
M2 = in18;
|
||||
M3 = nonce;
|
||||
|
||||
V8 = 0x243F6A88UL;
|
||||
V9 = 0x85A308D3UL;
|
||||
VA = 0x13198A2EUL;
|
||||
VB = 0x03707344UL;
|
||||
VC = 640 ^ 0xA4093822UL;
|
||||
VD = 640 ^ 0x299F31D0UL;
|
||||
VE = 0x082EFA98UL;
|
||||
VF = 0xEC4E6C89UL;
|
||||
|
||||
M4 = 0x80000000;
|
||||
M5 = 0;
|
||||
M6 = 0;
|
||||
M7 = 0;
|
||||
M8 = 0;
|
||||
M9 = 0;
|
||||
MA = 0;
|
||||
MB = 0;
|
||||
MC = 0;
|
||||
MD = 1;
|
||||
ME = 0;
|
||||
MF = 640;
|
||||
|
||||
V0 = (V0 + V4 + (M0 ^ 0x85A308D3UL)); VC = SPH_ROTR32(VC ^ V0, 16); V8 = (V8 + VC); V4 = SPH_ROTR32(V4 ^ V8, 12); V0 = (V0 + V4 + (M1 ^ 0x243F6A88UL)); VC = SPH_ROTR32(VC ^ V0, 8); V8 = (V8 + VC); V4 = SPH_ROTR32(V4 ^ V8, 7);; V1 = (V1 + V5 + (M2 ^ 0x03707344UL)); VD = SPH_ROTR32(VD ^ V1, 16); V9 = (V9 + VD); V5 = SPH_ROTR32(V5 ^ V9, 12); V1 = (V1 + V5 + (M3 ^ 0x13198A2EUL)); VD = SPH_ROTR32(VD ^ V1, 8); V9 = (V9 + VD); V5 = SPH_ROTR32(V5 ^ V9, 7);; V2 = (V2 + V6 + (M4 ^ 0x299F31D0UL)); VE = SPH_ROTR32(VE ^ V2, 16); VA = (VA + VE); V6 = SPH_ROTR32(V6 ^ VA, 12); V2 = (V2 + V6 + (M5 ^ 0xA4093822UL)); VE = SPH_ROTR32(VE ^ V2, 8); VA = (VA + VE); V6 = SPH_ROTR32(V6 ^ VA, 7);; V3 = (V3 + V7 + (M6 ^ 0xEC4E6C89UL)); VF = SPH_ROTR32(VF ^ V3, 16); VB = (VB + VF); V7 = SPH_ROTR32(V7 ^ VB, 12); V3 = (V3 + V7 + (M7 ^ 0x082EFA98UL)); VF = SPH_ROTR32(VF ^ V3, 8); VB = (VB + VF); V7 = SPH_ROTR32(V7 ^ VB, 7);; V0 = (V0 + V5 + (M8 ^ 0x38D01377UL)); VF = SPH_ROTR32(VF ^ V0, 16); VA = (VA + VF); V5 = SPH_ROTR32(V5 ^ VA, 12); V0 = (V0 + V5 + (M9 ^ 0x452821E6UL)); VF = SPH_ROTR32(VF ^ V0, 8); VA = (VA + VF); V5 = SPH_ROTR32(V5 ^ VA, 7);; V1 = (V1 + V6 + (MA ^ 0x34E90C6CUL)); VC = SPH_ROTR32(VC ^ V1, 16); VB = (VB + VC); V6 = SPH_ROTR32(V6 ^ VB, 12); V1 = (V1 + V6 + (MB ^ 0xBE5466CFUL)); VC = SPH_ROTR32(VC ^ V1, 8); VB = (VB + VC); V6 = SPH_ROTR32(V6 ^ VB, 7);; V2 = (V2 + V7 + (MC ^ 0xC97C50DDUL)); VD = SPH_ROTR32(VD ^ V2, 16); V8 = (V8 + VD); V7 = SPH_ROTR32(V7 ^ V8, 12); V2 = (V2 + V7 + (MD ^ 0xC0AC29B7UL)); VD = SPH_ROTR32(VD ^ V2, 8); V8 = (V8 + VD); V7 = SPH_ROTR32(V7 ^ V8, 7);; V3 = (V3 + V4 + (ME ^ 0xB5470917UL)); VE = SPH_ROTR32(VE ^ V3, 16); V9 = (V9 + VE); V4 = SPH_ROTR32(V4 ^ V9, 12); V3 = (V3 + V4 + (MF ^ 0x3F84D5B5UL)); VE = SPH_ROTR32(VE ^ V3, 8); V9 = (V9 + VE); V4 = SPH_ROTR32(V4 ^ V9, 7);
|
||||
V0 = (V0 + V4 + (ME ^ 0xBE5466CFUL)); VC = SPH_ROTR32(VC ^ V0, 16); V8 = (V8 + VC); V4 = SPH_ROTR32(V4 ^ V8, 12); V0 = (V0 + V4 + (MA ^ 0x3F84D5B5UL)); VC = SPH_ROTR32(VC ^ V0, 8); V8 = (V8 + VC); V4 = SPH_ROTR32(V4 ^ V8, 7);; V1 = (V1 + V5 + (M4 ^ 0x452821E6UL)); VD = SPH_ROTR32(VD ^ V1, 16); V9 = (V9 + VD); V5 = SPH_ROTR32(V5 ^ V9, 12); V1 = (V1 + V5 + (M8 ^ 0xA4093822UL)); VD = SPH_ROTR32(VD ^ V1, 8); V9 = (V9 + VD); V5 = SPH_ROTR32(V5 ^ V9, 7);; V2 = (V2 + V6 + (M9 ^ 0xB5470917UL)); VE = SPH_ROTR32(VE ^ V2, 16); VA = (VA + VE); V6 = SPH_ROTR32(V6 ^ VA, 12); V2 = (V2 + V6 + (MF ^ 0x38D01377UL)); VE = SPH_ROTR32(VE ^ V2, 8); VA = (VA + VE); V6 = SPH_ROTR32(V6 ^ VA, 7);; V3 = (V3 + V7 + (MD ^ 0x082EFA98UL)); VF = SPH_ROTR32(VF ^ V3, 16); VB = (VB + VF); V7 = SPH_ROTR32(V7 ^ VB, 12); V3 = (V3 + V7 + (M6 ^ 0xC97C50DDUL)); VF = SPH_ROTR32(VF ^ V3, 8); VB = (VB + VF); V7 = SPH_ROTR32(V7 ^ VB, 7);; V0 = (V0 + V5 + (M1 ^ 0xC0AC29B7UL)); VF = SPH_ROTR32(VF ^ V0, 16); VA = (VA + VF); V5 = SPH_ROTR32(V5 ^ VA, 12); V0 = (V0 + V5 + (MC ^ 0x85A308D3UL)); VF = SPH_ROTR32(VF ^ V0, 8); VA = (VA + VF); V5 = SPH_ROTR32(V5 ^ VA, 7);; V1 = (V1 + V6 + (M0 ^ 0x13198A2EUL)); VC = SPH_ROTR32(VC ^ V1, 16); VB = (VB + VC); V6 = SPH_ROTR32(V6 ^ VB, 12); V1 = (V1 + V6 + (M2 ^ 0x243F6A88UL)); VC = SPH_ROTR32(VC ^ V1, 8); VB = (VB + VC); V6 = SPH_ROTR32(V6 ^ VB, 7);; V2 = (V2 + V7 + (MB ^ 0xEC4E6C89UL)); VD = SPH_ROTR32(VD ^ V2, 16); V8 = (V8 + VD); V7 = SPH_ROTR32(V7 ^ V8, 12); V2 = (V2 + V7 + (M7 ^ 0x34E90C6CUL)); VD = SPH_ROTR32(VD ^ V2, 8); V8 = (V8 + VD); V7 = SPH_ROTR32(V7 ^ V8, 7);; V3 = (V3 + V4 + (M5 ^ 0x03707344UL)); VE = SPH_ROTR32(VE ^ V3, 16); V9 = (V9 + VE); V4 = SPH_ROTR32(V4 ^ V9, 12); V3 = (V3 + V4 + (M3 ^ 0x299F31D0UL)); VE = SPH_ROTR32(VE ^ V3, 8); V9 = (V9 + VE); V4 = SPH_ROTR32(V4 ^ V9, 7);
|
||||
V0 = (V0 + V4 + (MB ^ 0x452821E6UL)); VC = SPH_ROTR32(VC ^ V0, 16); V8 = (V8 + VC); V4 = SPH_ROTR32(V4 ^ V8, 12); V0 = (V0 + V4 + (M8 ^ 0x34E90C6CUL)); VC = SPH_ROTR32(VC ^ V0, 8); V8 = (V8 + VC); V4 = SPH_ROTR32(V4 ^ V8, 7);; V1 = (V1 + V5 + (MC ^ 0x243F6A88UL)); VD = SPH_ROTR32(VD ^ V1, 16); V9 = (V9 + VD); V5 = SPH_ROTR32(V5 ^ V9, 12); V1 = (V1 + V5 + (M0 ^ 0xC0AC29B7UL)); VD = SPH_ROTR32(VD ^ V1, 8); V9 = (V9 + VD); V5 = SPH_ROTR32(V5 ^ V9, 7);; V2 = (V2 + V6 + (M5 ^ 0x13198A2EUL)); VE = SPH_ROTR32(VE ^ V2, 16); VA = (VA + VE); V6 = SPH_ROTR32(V6 ^ VA, 12); V2 = (V2 + V6 + (M2 ^ 0x299F31D0UL)); VE = SPH_ROTR32(VE ^ V2, 8); VA = (VA + VE); V6 = SPH_ROTR32(V6 ^ VA, 7);; V3 = (V3 + V7 + (MF ^ 0xC97C50DDUL)); VF = SPH_ROTR32(VF ^ V3, 16); VB = (VB + VF); V7 = SPH_ROTR32(V7 ^ VB, 12); V3 = (V3 + V7 + (MD ^ 0xB5470917UL)); VF = SPH_ROTR32(VF ^ V3, 8); VB = (VB + VF); V7 = SPH_ROTR32(V7 ^ VB, 7);; V0 = (V0 + V5 + (MA ^ 0x3F84D5B5UL)); VF = SPH_ROTR32(VF ^ V0, 16); VA = (VA + VF); V5 = SPH_ROTR32(V5 ^ VA, 12); V0 = (V0 + V5 + (ME ^ 0xBE5466CFUL)); VF = SPH_ROTR32(VF ^ V0, 8); VA = (VA + VF); V5 = SPH_ROTR32(V5 ^ VA, 7);; V1 = (V1 + V6 + (M3 ^ 0x082EFA98UL)); VC = SPH_ROTR32(VC ^ V1, 16); VB = (VB + VC); V6 = SPH_ROTR32(V6 ^ VB, 12); V1 = (V1 + V6 + (M6 ^ 0x03707344UL)); VC = SPH_ROTR32(VC ^ V1, 8); VB = (VB + VC); V6 = SPH_ROTR32(V6 ^ VB, 7);; V2 = (V2 + V7 + (M7 ^ 0x85A308D3UL)); VD = SPH_ROTR32(VD ^ V2, 16); V8 = (V8 + VD); V7 = SPH_ROTR32(V7 ^ V8, 12); V2 = (V2 + V7 + (M1 ^ 0xEC4E6C89UL)); VD = SPH_ROTR32(VD ^ V2, 8); V8 = (V8 + VD); V7 = SPH_ROTR32(V7 ^ V8, 7);; V3 = (V3 + V4 + (M9 ^ 0xA4093822UL)); VE = SPH_ROTR32(VE ^ V3, 16); V9 = (V9 + VE); V4 = SPH_ROTR32(V4 ^ V9, 12); V3 = (V3 + V4 + (M4 ^ 0x38D01377UL)); VE = SPH_ROTR32(VE ^ V3, 8); V9 = (V9 + VE); V4 = SPH_ROTR32(V4 ^ V9, 7);
|
||||
V0 = (V0 + V4 + (M7 ^ 0x38D01377UL)); VC = SPH_ROTR32(VC ^ V0, 16); V8 = (V8 + VC); V4 = SPH_ROTR32(V4 ^ V8, 12); V0 = (V0 + V4 + (M9 ^ 0xEC4E6C89UL)); VC = SPH_ROTR32(VC ^ V0, 8); V8 = (V8 + VC); V4 = SPH_ROTR32(V4 ^ V8, 7);; V1 = (V1 + V5 + (M3 ^ 0x85A308D3UL)); VD = SPH_ROTR32(VD ^ V1, 16); V9 = (V9 + VD); V5 = SPH_ROTR32(V5 ^ V9, 12); V1 = (V1 + V5 + (M1 ^ 0x03707344UL)); VD = SPH_ROTR32(VD ^ V1, 8); V9 = (V9 + VD); V5 = SPH_ROTR32(V5 ^ V9, 7);; V2 = (V2 + V6 + (MD ^ 0xC0AC29B7UL)); VE = SPH_ROTR32(VE ^ V2, 16); VA = (VA + VE); V6 = SPH_ROTR32(V6 ^ VA, 12); V2 = (V2 + V6 + (MC ^ 0xC97C50DDUL)); VE = SPH_ROTR32(VE ^ V2, 8); VA = (VA + VE); V6 = SPH_ROTR32(V6 ^ VA, 7);; V3 = (V3 + V7 + (MB ^ 0x3F84D5B5UL)); VF = SPH_ROTR32(VF ^ V3, 16); VB = (VB + VF); V7 = SPH_ROTR32(V7 ^ VB, 12); V3 = (V3 + V7 + (ME ^ 0x34E90C6CUL)); VF = SPH_ROTR32(VF ^ V3, 8); VB = (VB + VF); V7 = SPH_ROTR32(V7 ^ VB, 7);; V0 = (V0 + V5 + (M2 ^ 0x082EFA98UL)); VF = SPH_ROTR32(VF ^ V0, 16); VA = (VA + VF); V5 = SPH_ROTR32(V5 ^ VA, 12); V0 = (V0 + V5 + (M6 ^ 0x13198A2EUL)); VF = SPH_ROTR32(VF ^ V0, 8); VA = (VA + VF); V5 = SPH_ROTR32(V5 ^ VA, 7);; V1 = (V1 + V6 + (M5 ^ 0xBE5466CFUL)); VC = SPH_ROTR32(VC ^ V1, 16); VB = (VB + VC); V6 = SPH_ROTR32(V6 ^ VB, 12); V1 = (V1 + V6 + (MA ^ 0x299F31D0UL)); VC = SPH_ROTR32(VC ^ V1, 8); VB = (VB + VC); V6 = SPH_ROTR32(V6 ^ VB, 7);; V2 = (V2 + V7 + (M4 ^ 0x243F6A88UL)); VD = SPH_ROTR32(VD ^ V2, 16); V8 = (V8 + VD); V7 = SPH_ROTR32(V7 ^ V8, 12); V2 = (V2 + V7 + (M0 ^ 0xA4093822UL)); VD = SPH_ROTR32(VD ^ V2, 8); V8 = (V8 + VD); V7 = SPH_ROTR32(V7 ^ V8, 7);; V3 = (V3 + V4 + (MF ^ 0x452821E6UL)); VE = SPH_ROTR32(VE ^ V3, 16); V9 = (V9 + VE); V4 = SPH_ROTR32(V4 ^ V9, 12); V3 = (V3 + V4 + (M8 ^ 0xB5470917UL)); VE = SPH_ROTR32(VE ^ V3, 8); V9 = (V9 + VE); V4 = SPH_ROTR32(V4 ^ V9, 7);
|
||||
V0 = (V0 + V4 + (M9 ^ 0x243F6A88UL)); VC = SPH_ROTR32(VC ^ V0, 16); V8 = (V8 + VC); V4 = SPH_ROTR32(V4 ^ V8, 12); V0 = (V0 + V4 + (M0 ^ 0x38D01377UL)); VC = SPH_ROTR32(VC ^ V0, 8); V8 = (V8 + VC); V4 = SPH_ROTR32(V4 ^ V8, 7);; V1 = (V1 + V5 + (M5 ^ 0xEC4E6C89UL)); VD = SPH_ROTR32(VD ^ V1, 16); V9 = (V9 + VD); V5 = SPH_ROTR32(V5 ^ V9, 12); V1 = (V1 + V5 + (M7 ^ 0x299F31D0UL)); VD = SPH_ROTR32(VD ^ V1, 8); V9 = (V9 + VD); V5 = SPH_ROTR32(V5 ^ V9, 7);; V2 = (V2 + V6 + (M2 ^ 0xA4093822UL)); VE = SPH_ROTR32(VE ^ V2, 16); VA = (VA + VE); V6 = SPH_ROTR32(V6 ^ VA, 12); V2 = (V2 + V6 + (M4 ^ 0x13198A2EUL)); VE = SPH_ROTR32(VE ^ V2, 8); VA = (VA + VE); V6 = SPH_ROTR32(V6 ^ VA, 7);; V3 = (V3 + V7 + (MA ^ 0xB5470917UL)); VF = SPH_ROTR32(VF ^ V3, 16); VB = (VB + VF); V7 = SPH_ROTR32(V7 ^ VB, 12); V3 = (V3 + V7 + (MF ^ 0xBE5466CFUL)); VF = SPH_ROTR32(VF ^ V3, 8); VB = (VB + VF); V7 = SPH_ROTR32(V7 ^ VB, 7);; V0 = (V0 + V5 + (ME ^ 0x85A308D3UL)); VF = SPH_ROTR32(VF ^ V0, 16); VA = (VA + VF); V5 = SPH_ROTR32(V5 ^ VA, 12); V0 = (V0 + V5 + (M1 ^ 0x3F84D5B5UL)); VF = SPH_ROTR32(VF ^ V0, 8); VA = (VA + VF); V5 = SPH_ROTR32(V5 ^ VA, 7);; V1 = (V1 + V6 + (MB ^ 0xC0AC29B7UL)); VC = SPH_ROTR32(VC ^ V1, 16); VB = (VB + VC); V6 = SPH_ROTR32(V6 ^ VB, 12); V1 = (V1 + V6 + (MC ^ 0x34E90C6CUL)); VC = SPH_ROTR32(VC ^ V1, 8); VB = (VB + VC); V6 = SPH_ROTR32(V6 ^ VB, 7);; V2 = (V2 + V7 + (M6 ^ 0x452821E6UL)); VD = SPH_ROTR32(VD ^ V2, 16); V8 = (V8 + VD); V7 = SPH_ROTR32(V7 ^ V8, 12); V2 = (V2 + V7 + (M8 ^ 0x082EFA98UL)); VD = SPH_ROTR32(VD ^ V2, 8); V8 = (V8 + VD); V7 = SPH_ROTR32(V7 ^ V8, 7);; V3 = (V3 + V4 + (M3 ^ 0xC97C50DDUL)); VE = SPH_ROTR32(VE ^ V3, 16); V9 = (V9 + VE); V4 = SPH_ROTR32(V4 ^ V9, 12); V3 = (V3 + V4 + (MD ^ 0x03707344UL)); VE = SPH_ROTR32(VE ^ V3, 8); V9 = (V9 + VE); V4 = SPH_ROTR32(V4 ^ V9, 7);
|
||||
V0 = (V0 + V4 + (M2 ^ 0xC0AC29B7UL)); VC = SPH_ROTR32(VC ^ V0, 16); V8 = (V8 + VC); V4 = SPH_ROTR32(V4 ^ V8, 12); V0 = (V0 + V4 + (MC ^ 0x13198A2EUL)); VC = SPH_ROTR32(VC ^ V0, 8); V8 = (V8 + VC); V4 = SPH_ROTR32(V4 ^ V8, 7);; V1 = (V1 + V5 + (M6 ^ 0xBE5466CFUL)); VD = SPH_ROTR32(VD ^ V1, 16); V9 = (V9 + VD); V5 = SPH_ROTR32(V5 ^ V9, 12); V1 = (V1 + V5 + (MA ^ 0x082EFA98UL)); VD = SPH_ROTR32(VD ^ V1, 8); V9 = (V9 + VD); V5 = SPH_ROTR32(V5 ^ V9, 7);; V2 = (V2 + V6 + (M0 ^ 0x34E90C6CUL)); VE = SPH_ROTR32(VE ^ V2, 16); VA = (VA + VE); V6 = SPH_ROTR32(V6 ^ VA, 12); V2 = (V2 + V6 + (MB ^ 0x243F6A88UL)); VE = SPH_ROTR32(VE ^ V2, 8); VA = (VA + VE); V6 = SPH_ROTR32(V6 ^ VA, 7);; V3 = (V3 + V7 + (M8 ^ 0x03707344UL)); VF = SPH_ROTR32(VF ^ V3, 16); VB = (VB + VF); V7 = SPH_ROTR32(V7 ^ VB, 12); V3 = (V3 + V7 + (M3 ^ 0x452821E6UL)); VF = SPH_ROTR32(VF ^ V3, 8); VB = (VB + VF); V7 = SPH_ROTR32(V7 ^ VB, 7);; V0 = (V0 + V5 + (M4 ^ 0xC97C50DDUL)); VF = SPH_ROTR32(VF ^ V0, 16); VA = (VA + VF); V5 = SPH_ROTR32(V5 ^ VA, 12); V0 = (V0 + V5 + (MD ^ 0xA4093822UL)); VF = SPH_ROTR32(VF ^ V0, 8); VA = (VA + VF); V5 = SPH_ROTR32(V5 ^ VA, 7);; V1 = (V1 + V6 + (M7 ^ 0x299F31D0UL)); VC = SPH_ROTR32(VC ^ V1, 16); VB = (VB + VC); V6 = SPH_ROTR32(V6 ^ VB, 12); V1 = (V1 + V6 + (M5 ^ 0xEC4E6C89UL)); VC = SPH_ROTR32(VC ^ V1, 8); VB = (VB + VC); V6 = SPH_ROTR32(V6 ^ VB, 7);; V2 = (V2 + V7 + (MF ^ 0x3F84D5B5UL)); VD = SPH_ROTR32(VD ^ V2, 16); V8 = (V8 + VD); V7 = SPH_ROTR32(V7 ^ V8, 12); V2 = (V2 + V7 + (ME ^ 0xB5470917UL)); VD = SPH_ROTR32(VD ^ V2, 8); V8 = (V8 + VD); V7 = SPH_ROTR32(V7 ^ V8, 7);; V3 = (V3 + V4 + (M1 ^ 0x38D01377UL)); VE = SPH_ROTR32(VE ^ V3, 16); V9 = (V9 + VE); V4 = SPH_ROTR32(V4 ^ V9, 12); V3 = (V3 + V4 + (M9 ^ 0x85A308D3UL)); VE = SPH_ROTR32(VE ^ V3, 8); V9 = (V9 + VE); V4 = SPH_ROTR32(V4 ^ V9, 7);
|
||||
V0 = (V0 + V4 + (MC ^ 0x299F31D0UL)); VC = SPH_ROTR32(VC ^ V0, 16); V8 = (V8 + VC); V4 = SPH_ROTR32(V4 ^ V8, 12); V0 = (V0 + V4 + (M5 ^ 0xC0AC29B7UL)); VC = SPH_ROTR32(VC ^ V0, 8); V8 = (V8 + VC); V4 = SPH_ROTR32(V4 ^ V8, 7);; V1 = (V1 + V5 + (M1 ^ 0xB5470917UL)); VD = SPH_ROTR32(VD ^ V1, 16); V9 = (V9 + VD); V5 = SPH_ROTR32(V5 ^ V9, 12); V1 = (V1 + V5 + (MF ^ 0x85A308D3UL)); VD = SPH_ROTR32(VD ^ V1, 8); V9 = (V9 + VD); V5 = SPH_ROTR32(V5 ^ V9, 7);; V2 = (V2 + V6 + (ME ^ 0xC97C50DDUL)); VE = SPH_ROTR32(VE ^ V2, 16); VA = (VA + VE); V6 = SPH_ROTR32(V6 ^ VA, 12); V2 = (V2 + V6 + (MD ^ 0x3F84D5B5UL)); VE = SPH_ROTR32(VE ^ V2, 8); VA = (VA + VE); V6 = SPH_ROTR32(V6 ^ VA, 7);; V3 = (V3 + V7 + (M4 ^ 0xBE5466CFUL)); VF = SPH_ROTR32(VF ^ V3, 16); VB = (VB + VF); V7 = SPH_ROTR32(V7 ^ VB, 12); V3 = (V3 + V7 + (MA ^ 0xA4093822UL)); VF = SPH_ROTR32(VF ^ V3, 8); VB = (VB + VF); V7 = SPH_ROTR32(V7 ^ VB, 7);; V0 = (V0 + V5 + (M0 ^ 0xEC4E6C89UL)); VF = SPH_ROTR32(VF ^ V0, 16); VA = (VA + VF); V5 = SPH_ROTR32(V5 ^ VA, 12); V0 = (V0 + V5 + (M7 ^ 0x243F6A88UL)); VF = SPH_ROTR32(VF ^ V0, 8); VA = (VA + VF); V5 = SPH_ROTR32(V5 ^ VA, 7);; V1 = (V1 + V6 + (M6 ^ 0x03707344UL)); VC = SPH_ROTR32(VC ^ V1, 16); VB = (VB + VC); V6 = SPH_ROTR32(V6 ^ VB, 12); V1 = (V1 + V6 + (M3 ^ 0x082EFA98UL)); VC = SPH_ROTR32(VC ^ V1, 8); VB = (VB + VC); V6 = SPH_ROTR32(V6 ^ VB, 7);; V2 = (V2 + V7 + (M9 ^ 0x13198A2EUL)); VD = SPH_ROTR32(VD ^ V2, 16); V8 = (V8 + VD); V7 = SPH_ROTR32(V7 ^ V8, 12); V2 = (V2 + V7 + (M2 ^ 0x38D01377UL)); VD = SPH_ROTR32(VD ^ V2, 8); V8 = (V8 + VD); V7 = SPH_ROTR32(V7 ^ V8, 7);; V3 = (V3 + V4 + (M8 ^ 0x34E90C6CUL)); VE = SPH_ROTR32(VE ^ V3, 16); V9 = (V9 + VE); V4 = SPH_ROTR32(V4 ^ V9, 12); V3 = (V3 + V4 + (MB ^ 0x452821E6UL)); VE = SPH_ROTR32(VE ^ V3, 8); V9 = (V9 + VE); V4 = SPH_ROTR32(V4 ^ V9, 7);
|
||||
V0 = (V0 + V4 + (MD ^ 0x34E90C6CUL)); VC = SPH_ROTR32(VC ^ V0, 16); V8 = (V8 + VC); V4 = SPH_ROTR32(V4 ^ V8, 12); V0 = (V0 + V4 + (MB ^ 0xC97C50DDUL)); VC = SPH_ROTR32(VC ^ V0, 8); V8 = (V8 + VC); V4 = SPH_ROTR32(V4 ^ V8, 7);; V1 = (V1 + V5 + (M7 ^ 0x3F84D5B5UL)); VD = SPH_ROTR32(VD ^ V1, 16); V9 = (V9 + VD); V5 = SPH_ROTR32(V5 ^ V9, 12); V1 = (V1 + V5 + (ME ^ 0xEC4E6C89UL)); VD = SPH_ROTR32(VD ^ V1, 8); V9 = (V9 + VD); V5 = SPH_ROTR32(V5 ^ V9, 7);; V2 = (V2 + V6 + (MC ^ 0x85A308D3UL)); VE = SPH_ROTR32(VE ^ V2, 16); VA = (VA + VE); V6 = SPH_ROTR32(V6 ^ VA, 12); V2 = (V2 + V6 + (M1 ^ 0xC0AC29B7UL)); VE = SPH_ROTR32(VE ^ V2, 8); VA = (VA + VE); V6 = SPH_ROTR32(V6 ^ VA, 7);; V3 = (V3 + V7 + (M3 ^ 0x38D01377UL)); VF = SPH_ROTR32(VF ^ V3, 16); VB = (VB + VF); V7 = SPH_ROTR32(V7 ^ VB, 12); V3 = (V3 + V7 + (M9 ^ 0x03707344UL)); VF = SPH_ROTR32(VF ^ V3, 8); VB = (VB + VF); V7 = SPH_ROTR32(V7 ^ VB, 7);; V0 = (V0 + V5 + (M5 ^ 0x243F6A88UL)); VF = SPH_ROTR32(VF ^ V0, 16); VA = (VA + VF); V5 = SPH_ROTR32(V5 ^ VA, 12); V0 = (V0 + V5 + (M0 ^ 0x299F31D0UL)); VF = SPH_ROTR32(VF ^ V0, 8); VA = (VA + VF); V5 = SPH_ROTR32(V5 ^ VA, 7);; V1 = (V1 + V6 + (MF ^ 0xA4093822UL)); VC = SPH_ROTR32(VC ^ V1, 16); VB = (VB + VC); V6 = SPH_ROTR32(V6 ^ VB, 12); V1 = (V1 + V6 + (M4 ^ 0xB5470917UL)); VC = SPH_ROTR32(VC ^ V1, 8); VB = (VB + VC); V6 = SPH_ROTR32(V6 ^ VB, 7);; V2 = (V2 + V7 + (M8 ^ 0x082EFA98UL)); VD = SPH_ROTR32(VD ^ V2, 16); V8 = (V8 + VD); V7 = SPH_ROTR32(V7 ^ V8, 12); V2 = (V2 + V7 + (M6 ^ 0x452821E6UL)); VD = SPH_ROTR32(VD ^ V2, 8); V8 = (V8 + VD); V7 = SPH_ROTR32(V7 ^ V8, 7);; V3 = (V3 + V4 + (M2 ^ 0xBE5466CFUL)); VE = SPH_ROTR32(VE ^ V3, 16); V9 = (V9 + VE); V4 = SPH_ROTR32(V4 ^ V9, 12); V3 = (V3 + V4 + (MA ^ 0x13198A2EUL)); VE = SPH_ROTR32(VE ^ V3, 8); V9 = (V9 + VE); V4 = SPH_ROTR32(V4 ^ V9, 7);
|
||||
|
||||
// Constants
|
||||
// 00 = 0x243F6A88UL
|
||||
// 01 = 0x85A308D3UL
|
||||
// 02 = 0x13198A2EUL
|
||||
// 03 = 0x03707344UL
|
||||
// 04 = 0xA4093822UL
|
||||
// 05 = 0x299F31D0UL
|
||||
// 06 = 0x082EFA98UL
|
||||
// 07 = 0xEC4E6C89UL
|
||||
// 08 = 0x452821E6UL
|
||||
// 09 = 0x38D01377UL
|
||||
// 10 = 0xBE5466CFUL
|
||||
// 11 = 0x34E90C6CUL
|
||||
// 12 = 0xC0AC29B7UL
|
||||
// 13 = 0xC97C50DDUL
|
||||
// 14 = 0x3F84D5B5UL
|
||||
// 15 = 0xB5470917UL
|
||||
// A=10,B=11,C=12,D=13,E=14,F=15
|
||||
|
||||
// Round 9:
|
||||
// 6^15
|
||||
V0 = (V0 + V4 + (M6 ^ 0xB5470917UL)); VC = SPH_ROTR32(VC ^ V0, 16); V8 = (V8 + VC); V4 = SPH_ROTR32(V4 ^ V8, 12); V0 = (V0 + V4 + (MF ^ 0x082EFA98UL)); VC = SPH_ROTR32(VC ^ V0, 8); V8 = (V8 + VC); V4 = SPH_ROTR32(V4 ^ V8, 7);;
|
||||
// 14^9
|
||||
V1 = (V1 + V5 + (ME ^ 0x38D01377UL)); VD = SPH_ROTR32(VD ^ V1, 16); V9 = (V9 + VD); V5 = SPH_ROTR32(V5 ^ V9, 12); V1 = (V1 + V5 + (M9 ^ 0x3F84D5B5UL)); VD = SPH_ROTR32(VD ^ V1, 8); V9 = (V9 + VD); V5 = SPH_ROTR32(V5 ^ V9, 7);;
|
||||
// 11^3
|
||||
V2 = (V2 + V6 + (MB ^ 0x03707344UL)); VE = SPH_ROTR32(VE ^ V2, 16); VA = (VA + VE); V6 = SPH_ROTR32(V6 ^ VA, 12); V2 = (V2 + V6 + (M3 ^ 0x34E90C6CUL)); VE = SPH_ROTR32(VE ^ V2, 8); VA = (VA + VE); V6 = SPH_ROTR32(V6 ^ VA, 7);;
|
||||
// 0^8
|
||||
V3 = (V3 + V7 + (M0 ^ 0x452821E6UL)); VF = SPH_ROTR32(VF ^ V3, 16); VB = (VB + VF); V7 = SPH_ROTR32(V7 ^ VB, 12); V3 = (V3 + V7 + (M8 ^ 0x243F6A88UL)); VF = SPH_ROTR32(VF ^ V3, 8); VB = (VB + VF); V7 = SPH_ROTR32(V7 ^ VB, 7);;
|
||||
// 12^2
|
||||
V0 = (V0 + V5 + (MC ^ 0x13198A2EUL)); VF = SPH_ROTR32(VF ^ V0, 16); VA = (VA + VF); V5 = SPH_ROTR32(V5 ^ VA, 12); V0 = (V0 + V5 + (M2 ^ 0xC0AC29B7UL)); VF = SPH_ROTR32(VF ^ V0, 8); VA = (VA + VF); V5 = SPH_ROTR32(V5 ^ VA, 7);;
|
||||
// 13^7
|
||||
V1 = (V1 + V6 + (MD ^ 0xEC4E6C89UL)); VC = SPH_ROTR32(VC ^ V1, 16); VB = (VB + VC); V6 = SPH_ROTR32(V6 ^ VB, 12); V1 = (V1 + V6 + (M7 ^ 0xC97C50DDUL)); VC = SPH_ROTR32(VC ^ V1, 8); VB = (VB + VC); V6 = SPH_ROTR32(V6 ^ VB, 7);;
|
||||
// 1^4
|
||||
V2 = (V2 + V7 + (M1 ^ 0xA4093822UL)); VD = SPH_ROTR32(VD ^ V2, 16); V8 = (V8 + VD); V7 = SPH_ROTR32(V7 ^ V8, 12); V2 = (V2 + V7 + (M4 ^ 0x85A308D3UL)); VD = SPH_ROTR32(VD ^ V2, 8); V8 = (V8 + VD); V7 = SPH_ROTR32(V7 ^ V8, 7);;
|
||||
// 10^5
|
||||
V3 = (V3 + V4 + (MA ^ 0x299F31D0UL)); VE = SPH_ROTR32(VE ^ V3, 16); V9 = (V9 + VE); V4 = SPH_ROTR32(V4 ^ V9, 12); V3 = (V3 + V4 + (M5 ^ 0xBE5466CFUL)); VE = SPH_ROTR32(VE ^ V3, 8); V9 = (V9 + VE); V4 = SPH_ROTR32(V4 ^ V9, 7);
|
||||
|
||||
// Constants
|
||||
// 00 = 0x243F6A88UL
|
||||
// 01 = 0x85A308D3UL
|
||||
// 02 = 0x13198A2EUL
|
||||
// 03 = 0x03707344UL
|
||||
// 04 = 0xA4093822UL
|
||||
// 05 = 0x299F31D0UL
|
||||
// 06 = 0x082EFA98UL
|
||||
// 07 = 0xEC4E6C89UL
|
||||
// 08 = 0x452821E6UL
|
||||
// 09 = 0x38D01377UL
|
||||
// 10 = 0xBE5466CFUL
|
||||
// 11 = 0x34E90C6CUL
|
||||
// 12 = 0xC0AC29B7UL
|
||||
// 13 = 0xC97C50DDUL
|
||||
// 14 = 0x3F84D5B5UL
|
||||
// 15 = 0xB5470917UL
|
||||
// A=10,B=11,C=12,D=13,E=14,F=15
|
||||
|
||||
// Round 10
|
||||
// 10^2
|
||||
V0 = (V0 + V4 + (MA ^ 0x13198A2EUL)); VC = SPH_ROTR32(VC ^ V0, 16); V8 = (V8 + VC); V4 = SPH_ROTR32(V4 ^ V8, 12); V0 = (V0 + V4 + (M2 ^ 0xBE5466CFUL)); VC = SPH_ROTR32(VC ^ V0, 8); V8 = (V8 + VC); V4 = SPH_ROTR32(V4 ^ V8, 7);;
|
||||
// 8^4
|
||||
V1 = (V1 + V5 + (M8 ^ 0xA4093822UL)); VD = SPH_ROTR32(VD ^ V1, 16); V9 = (V9 + VD); V5 = SPH_ROTR32(V5 ^ V9, 12); V1 = (V1 + V5 + (M4 ^ 0x452821E6UL)); VD = SPH_ROTR32(VD ^ V1, 8); V9 = (V9 + VD); V5 = SPH_ROTR32(V5 ^ V9, 7);;
|
||||
// 7^6
|
||||
V2 = (V2 + V6 + (M7 ^ 0x082EFA98UL)); VE = SPH_ROTR32(VE ^ V2, 16); VA = (VA + VE); V6 = SPH_ROTR32(V6 ^ VA, 12); V2 = (V2 + V6 + (M6 ^ 0xEC4E6C89UL)); VE = SPH_ROTR32(VE ^ V2, 8); VA = (VA + VE); V6 = SPH_ROTR32(V6 ^ VA, 7);;
|
||||
// 1^5
|
||||
V3 = (V3 + V7 + (M1 ^ 0x299F31D0UL)); VF = SPH_ROTR32(VF ^ V3, 16); VB = (VB + VF); V7 = SPH_ROTR32(V7 ^ VB, 12); V3 = (V3 + V7 + (M5 ^ 0x85A308D3UL)); VF = SPH_ROTR32(VF ^ V3, 8); VB = (VB + VF); V7 = SPH_ROTR32(V7 ^ VB, 7);;
|
||||
// 15^11
|
||||
V0 = (V0 + V5 + (MF ^ 0x34E90C6CUL)); VF = SPH_ROTR32(VF ^ V0, 16); VA = (VA + VF); V5 = SPH_ROTR32(V5 ^ VA, 12); V0 = (V0 + V5 + (MB ^ 0xB5470917UL)); VF = SPH_ROTR32(VF ^ V0, 8); VA = (VA + VF); V5 = SPH_ROTR32(V5 ^ VA, 7);;
|
||||
// 9^14
|
||||
V1 = (V1 + V6 + (M9 ^ 0x3F84D5B5UL)); VC = SPH_ROTR32(VC ^ V1, 16); VB = (VB + VC); V6 = SPH_ROTR32(V6 ^ VB, 12); V1 = (V1 + V6 + (ME ^ 0x38D01377UL)); VC = SPH_ROTR32(VC ^ V1, 8); VB = (VB + VC); V6 = SPH_ROTR32(V6 ^ VB, 7);;
|
||||
// 3^12
|
||||
V2 = (V2 + V7 + (M3 ^ 0xC0AC29B7UL)); VD = SPH_ROTR32(VD ^ V2, 16); V8 = (V8 + VD); V7 = SPH_ROTR32(V7 ^ V8, 12); V2 = (V2 + V7 + (MC ^ 0x03707344UL)); VD = SPH_ROTR32(VD ^ V2, 8); V8 = (V8 + VD); V7 = SPH_ROTR32(V7 ^ V8, 7);;
|
||||
// 13^0
|
||||
V3 = (V3 + V4 + (MD ^ 0x243F6A88UL)); VE = SPH_ROTR32(VE ^ V3, 16); V9 = (V9 + VE); V4 = SPH_ROTR32(V4 ^ V9, 12); V3 = (V3 + V4 + (M0 ^ 0xC97C50DDUL)); VE = SPH_ROTR32(VE ^ V3, 8); V9 = (V9 + VE); V4 = SPH_ROTR32(V4 ^ V9, 7);
|
||||
|
||||
// Round 11,12,13,14 repeated from beginning again
|
||||
V0 = (V0 + V4 + (M0 ^ 0x85A308D3UL)); VC = SPH_ROTR32(VC ^ V0, 16); V8 = (V8 + VC); V4 = SPH_ROTR32(V4 ^ V8, 12); V0 = (V0 + V4 + (M1 ^ 0x243F6A88UL)); VC = SPH_ROTR32(VC ^ V0, 8); V8 = (V8 + VC); V4 = SPH_ROTR32(V4 ^ V8, 7);; V1 = (V1 + V5 + (M2 ^ 0x03707344UL)); VD = SPH_ROTR32(VD ^ V1, 16); V9 = (V9 + VD); V5 = SPH_ROTR32(V5 ^ V9, 12); V1 = (V1 + V5 + (M3 ^ 0x13198A2EUL)); VD = SPH_ROTR32(VD ^ V1, 8); V9 = (V9 + VD); V5 = SPH_ROTR32(V5 ^ V9, 7);; V2 = (V2 + V6 + (M4 ^ 0x299F31D0UL)); VE = SPH_ROTR32(VE ^ V2, 16); VA = (VA + VE); V6 = SPH_ROTR32(V6 ^ VA, 12); V2 = (V2 + V6 + (M5 ^ 0xA4093822UL)); VE = SPH_ROTR32(VE ^ V2, 8); VA = (VA + VE); V6 = SPH_ROTR32(V6 ^ VA, 7);; V3 = (V3 + V7 + (M6 ^ 0xEC4E6C89UL)); VF = SPH_ROTR32(VF ^ V3, 16); VB = (VB + VF); V7 = SPH_ROTR32(V7 ^ VB, 12); V3 = (V3 + V7 + (M7 ^ 0x082EFA98UL)); VF = SPH_ROTR32(VF ^ V3, 8); VB = (VB + VF); V7 = SPH_ROTR32(V7 ^ VB, 7);; V0 = (V0 + V5 + (M8 ^ 0x38D01377UL)); VF = SPH_ROTR32(VF ^ V0, 16); VA = (VA + VF); V5 = SPH_ROTR32(V5 ^ VA, 12); V0 = (V0 + V5 + (M9 ^ 0x452821E6UL)); VF = SPH_ROTR32(VF ^ V0, 8); VA = (VA + VF); V5 = SPH_ROTR32(V5 ^ VA, 7);; V1 = (V1 + V6 + (MA ^ 0x34E90C6CUL)); VC = SPH_ROTR32(VC ^ V1, 16); VB = (VB + VC); V6 = SPH_ROTR32(V6 ^ VB, 12); V1 = (V1 + V6 + (MB ^ 0xBE5466CFUL)); VC = SPH_ROTR32(VC ^ V1, 8); VB = (VB + VC); V6 = SPH_ROTR32(V6 ^ VB, 7);; V2 = (V2 + V7 + (MC ^ 0xC97C50DDUL)); VD = SPH_ROTR32(VD ^ V2, 16); V8 = (V8 + VD); V7 = SPH_ROTR32(V7 ^ V8, 12); V2 = (V2 + V7 + (MD ^ 0xC0AC29B7UL)); VD = SPH_ROTR32(VD ^ V2, 8); V8 = (V8 + VD); V7 = SPH_ROTR32(V7 ^ V8, 7);; V3 = (V3 + V4 + (ME ^ 0xB5470917UL)); VE = SPH_ROTR32(VE ^ V3, 16); V9 = (V9 + VE); V4 = SPH_ROTR32(V4 ^ V9, 12); V3 = (V3 + V4 + (MF ^ 0x3F84D5B5UL)); VE = SPH_ROTR32(VE ^ V3, 8); V9 = (V9 + VE); V4 = SPH_ROTR32(V4 ^ V9, 7);
|
||||
V0 = (V0 + V4 + (ME ^ 0xBE5466CFUL)); VC = SPH_ROTR32(VC ^ V0, 16); V8 = (V8 + VC); V4 = SPH_ROTR32(V4 ^ V8, 12); V0 = (V0 + V4 + (MA ^ 0x3F84D5B5UL)); VC = SPH_ROTR32(VC ^ V0, 8); V8 = (V8 + VC); V4 = SPH_ROTR32(V4 ^ V8, 7);; V1 = (V1 + V5 + (M4 ^ 0x452821E6UL)); VD = SPH_ROTR32(VD ^ V1, 16); V9 = (V9 + VD); V5 = SPH_ROTR32(V5 ^ V9, 12); V1 = (V1 + V5 + (M8 ^ 0xA4093822UL)); VD = SPH_ROTR32(VD ^ V1, 8); V9 = (V9 + VD); V5 = SPH_ROTR32(V5 ^ V9, 7);; V2 = (V2 + V6 + (M9 ^ 0xB5470917UL)); VE = SPH_ROTR32(VE ^ V2, 16); VA = (VA + VE); V6 = SPH_ROTR32(V6 ^ VA, 12); V2 = (V2 + V6 + (MF ^ 0x38D01377UL)); VE = SPH_ROTR32(VE ^ V2, 8); VA = (VA + VE); V6 = SPH_ROTR32(V6 ^ VA, 7);; V3 = (V3 + V7 + (MD ^ 0x082EFA98UL)); VF = SPH_ROTR32(VF ^ V3, 16); VB = (VB + VF); V7 = SPH_ROTR32(V7 ^ VB, 12); V3 = (V3 + V7 + (M6 ^ 0xC97C50DDUL)); VF = SPH_ROTR32(VF ^ V3, 8); VB = (VB + VF); V7 = SPH_ROTR32(V7 ^ VB, 7);; V0 = (V0 + V5 + (M1 ^ 0xC0AC29B7UL)); VF = SPH_ROTR32(VF ^ V0, 16); VA = (VA + VF); V5 = SPH_ROTR32(V5 ^ VA, 12); V0 = (V0 + V5 + (MC ^ 0x85A308D3UL)); VF = SPH_ROTR32(VF ^ V0, 8); VA = (VA + VF); V5 = SPH_ROTR32(V5 ^ VA, 7);; V1 = (V1 + V6 + (M0 ^ 0x13198A2EUL)); VC = SPH_ROTR32(VC ^ V1, 16); VB = (VB + VC); V6 = SPH_ROTR32(V6 ^ VB, 12); V1 = (V1 + V6 + (M2 ^ 0x243F6A88UL)); VC = SPH_ROTR32(VC ^ V1, 8); VB = (VB + VC); V6 = SPH_ROTR32(V6 ^ VB, 7);; V2 = (V2 + V7 + (MB ^ 0xEC4E6C89UL)); VD = SPH_ROTR32(VD ^ V2, 16); V8 = (V8 + VD); V7 = SPH_ROTR32(V7 ^ V8, 12); V2 = (V2 + V7 + (M7 ^ 0x34E90C6CUL)); VD = SPH_ROTR32(VD ^ V2, 8); V8 = (V8 + VD); V7 = SPH_ROTR32(V7 ^ V8, 7);; V3 = (V3 + V4 + (M5 ^ 0x03707344UL)); VE = SPH_ROTR32(VE ^ V3, 16); V9 = (V9 + VE); V4 = SPH_ROTR32(V4 ^ V9, 12); V3 = (V3 + V4 + (M3 ^ 0x299F31D0UL)); VE = SPH_ROTR32(VE ^ V3, 8); V9 = (V9 + VE); V4 = SPH_ROTR32(V4 ^ V9, 7);
|
||||
V0 = (V0 + V4 + (MB ^ 0x452821E6UL)); VC = SPH_ROTR32(VC ^ V0, 16); V8 = (V8 + VC); V4 = SPH_ROTR32(V4 ^ V8, 12); V0 = (V0 + V4 + (M8 ^ 0x34E90C6CUL)); VC = SPH_ROTR32(VC ^ V0, 8); V8 = (V8 + VC); V4 = SPH_ROTR32(V4 ^ V8, 7);; V1 = (V1 + V5 + (MC ^ 0x243F6A88UL)); VD = SPH_ROTR32(VD ^ V1, 16); V9 = (V9 + VD); V5 = SPH_ROTR32(V5 ^ V9, 12); V1 = (V1 + V5 + (M0 ^ 0xC0AC29B7UL)); VD = SPH_ROTR32(VD ^ V1, 8); V9 = (V9 + VD); V5 = SPH_ROTR32(V5 ^ V9, 7);; V2 = (V2 + V6 + (M5 ^ 0x13198A2EUL)); VE = SPH_ROTR32(VE ^ V2, 16); VA = (VA + VE); V6 = SPH_ROTR32(V6 ^ VA, 12); V2 = (V2 + V6 + (M2 ^ 0x299F31D0UL)); VE = SPH_ROTR32(VE ^ V2, 8); VA = (VA + VE); V6 = SPH_ROTR32(V6 ^ VA, 7);; V3 = (V3 + V7 + (MF ^ 0xC97C50DDUL)); VF = SPH_ROTR32(VF ^ V3, 16); VB = (VB + VF); V7 = SPH_ROTR32(V7 ^ VB, 12); V3 = (V3 + V7 + (MD ^ 0xB5470917UL)); VF = SPH_ROTR32(VF ^ V3, 8); VB = (VB + VF); V7 = SPH_ROTR32(V7 ^ VB, 7);; V0 = (V0 + V5 + (MA ^ 0x3F84D5B5UL)); VF = SPH_ROTR32(VF ^ V0, 16); VA = (VA + VF); V5 = SPH_ROTR32(V5 ^ VA, 12); V0 = (V0 + V5 + (ME ^ 0xBE5466CFUL)); VF = SPH_ROTR32(VF ^ V0, 8); VA = (VA + VF); V5 = SPH_ROTR32(V5 ^ VA, 7);; V1 = (V1 + V6 + (M3 ^ 0x082EFA98UL)); VC = SPH_ROTR32(VC ^ V1, 16); VB = (VB + VC); V6 = SPH_ROTR32(V6 ^ VB, 12); V1 = (V1 + V6 + (M6 ^ 0x03707344UL)); VC = SPH_ROTR32(VC ^ V1, 8); VB = (VB + VC); V6 = SPH_ROTR32(V6 ^ VB, 7);; V2 = (V2 + V7 + (M7 ^ 0x85A308D3UL)); VD = SPH_ROTR32(VD ^ V2, 16); V8 = (V8 + VD); V7 = SPH_ROTR32(V7 ^ V8, 12); V2 = (V2 + V7 + (M1 ^ 0xEC4E6C89UL)); VD = SPH_ROTR32(VD ^ V2, 8); V8 = (V8 + VD); V7 = SPH_ROTR32(V7 ^ V8, 7);; V3 = (V3 + V4 + (M9 ^ 0xA4093822UL)); VE = SPH_ROTR32(VE ^ V3, 16); V9 = (V9 + VE); V4 = SPH_ROTR32(V4 ^ V9, 12); V3 = (V3 + V4 + (M4 ^ 0x38D01377UL)); VE = SPH_ROTR32(VE ^ V3, 8); V9 = (V9 + VE); V4 = SPH_ROTR32(V4 ^ V9, 7);
|
||||
V0 = (V0 + V4 + (M7 ^ 0x38D01377UL)); VC = SPH_ROTR32(VC ^ V0, 16); V8 = (V8 + VC); V4 = SPH_ROTR32(V4 ^ V8, 12); V0 = (V0 + V4 + (M9 ^ 0xEC4E6C89UL)); VC = SPH_ROTR32(VC ^ V0, 8); V8 = (V8 + VC); V4 = SPH_ROTR32(V4 ^ V8, 7);; V1 = (V1 + V5 + (M3 ^ 0x85A308D3UL)); VD = SPH_ROTR32(VD ^ V1, 16); V9 = (V9 + VD); V5 = SPH_ROTR32(V5 ^ V9, 12); V1 = (V1 + V5 + (M1 ^ 0x03707344UL)); VD = SPH_ROTR32(VD ^ V1, 8); V9 = (V9 + VD); V5 = SPH_ROTR32(V5 ^ V9, 7);; V2 = (V2 + V6 + (MD ^ 0xC0AC29B7UL)); VE = SPH_ROTR32(VE ^ V2, 16); VA = (VA + VE); V6 = SPH_ROTR32(V6 ^ VA, 12); V2 = (V2 + V6 + (MC ^ 0xC97C50DDUL)); VE = SPH_ROTR32(VE ^ V2, 8); VA = (VA + VE); V6 = SPH_ROTR32(V6 ^ VA, 7);; V3 = (V3 + V7 + (MB ^ 0x3F84D5B5UL)); VF = SPH_ROTR32(VF ^ V3, 16); VB = (VB + VF); V7 = SPH_ROTR32(V7 ^ VB, 12); V3 = (V3 + V7 + (ME ^ 0x34E90C6CUL)); VF = SPH_ROTR32(VF ^ V3, 8); VB = (VB + VF); V7 = SPH_ROTR32(V7 ^ VB, 7);; V0 = (V0 + V5 + (M2 ^ 0x082EFA98UL)); VF = SPH_ROTR32(VF ^ V0, 16); VA = (VA + VF); V5 = SPH_ROTR32(V5 ^ VA, 12); V0 = (V0 + V5 + (M6 ^ 0x13198A2EUL)); VF = SPH_ROTR32(VF ^ V0, 8); VA = (VA + VF); V5 = SPH_ROTR32(V5 ^ VA, 7);; V1 = (V1 + V6 + (M5 ^ 0xBE5466CFUL)); VC = SPH_ROTR32(VC ^ V1, 16); VB = (VB + VC); V6 = SPH_ROTR32(V6 ^ VB, 12); V1 = (V1 + V6 + (MA ^ 0x299F31D0UL)); VC = SPH_ROTR32(VC ^ V1, 8); VB = (VB + VC); V6 = SPH_ROTR32(V6 ^ VB, 7);; V2 = (V2 + V7 + (M4 ^ 0x243F6A88UL)); VD = SPH_ROTR32(VD ^ V2, 16); V8 = (V8 + VD); V7 = SPH_ROTR32(V7 ^ V8, 12); V2 = (V2 + V7 + (M0 ^ 0xA4093822UL)); VD = SPH_ROTR32(VD ^ V2, 8); V8 = (V8 + VD); V7 = SPH_ROTR32(V7 ^ V8, 7);; V3 = (V3 + V4 + (MF ^ 0x452821E6UL)); VE = SPH_ROTR32(VE ^ V3, 16); V9 = (V9 + VE); V4 = SPH_ROTR32(V4 ^ V9, 12); V3 = (V3 + V4 + (M8 ^ 0xB5470917UL)); VE = SPH_ROTR32(VE ^ V3, 8); V9 = (V9 + VE); V4 = SPH_ROTR32(V4 ^ V9, 7);
|
||||
|
||||
if(pre7 ^ V7 ^ VF)
|
||||
return;
|
||||
|
||||
output[0]++;
|
||||
output[output[0] + 1] = nonce;
|
||||
}
|
||||
+378
@@ -0,0 +1,378 @@
|
||||
/**
|
||||
* 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>
|
||||
|
||||
#include "sph/sph_types.h"
|
||||
#include "sph/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;
|
||||
}
|
||||
|
||||
static 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, inlen );
|
||||
S->buflen += 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(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
|
||||
+146
@@ -0,0 +1,146 @@
|
||||
/**
|
||||
* 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)
|
||||
#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 */
|
||||
|
||||
#if defined(__cplusplus)
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
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)
|
||||
|
||||
// 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
|
||||
Reference in new issue
Block a user