v23.8

AUTHORS

@@ -16,4 +16,23 @@ LucasJones
 
 tpruvot@github
 
+elmad
+
+djm34
+
+palmd
+
+ig0tik3d
+
+Wolf0
+
+Optiminer
+
 Jay D Dee
+
+xcouiz@gmail.com
+
+Cryply
+
+Colin Percival
+Alexander Peslyak

INSTALL_LINUX

@@ -0,0 +1,164 @@
+
+These instructions may be out of date, see the Wiki for the latest...
+https://github.com/JayDDee/cpuminer-opt/wiki/Compiling-from-source
+
+1. Requirements:
+---------------
+
+Intel Core2 or newer, or AMD Steamroller or newer CPU. ARM CPUs are not
+supported.
+64 bit Linux operating system. Apple is not supported.
+
+2. Building on linux prerequisites:
+-----------------------------------
+
+It is assumed users know how to install packages on their system and
+be able to compile standard source packages. This is basic Linux and
+beyond the scope of cpuminer-opt. Regardless compiling is trivial if you
+follow the instructions.
+
+Make sure you have the basic development packages installed.
+Here is a good start:
+
+http://askubuntu.com/questions/457526/how-to-install-cpuminer-in-ubuntu
+
+Install any additional dependencies needed by cpuminer-opt. The list below
+are some of the ones that may not be in the default install and need to
+be installed manually. There may be others, read the compiler error messages,
+they will give a clue as to the missing package.
+
+The following command should install everything you need on Debian based
+distributions such as Ubuntu. Fedora and other distributions may have similar
+but different package names. 
+
+$ sudo apt-get install build-essential automake libssl-dev libcurl4-openssl-dev libjansson-dev libgmp-dev zlib1g-dev git
+
+SHA support on AMD Ryzen CPUs requires gcc version 5 or higher and
+openssl 1.1.0e or higher.
+
+znver1 and znver2 should be recognized on most recent version of GCC and
+znver3 is available with GCC 11. GCC 11 also includes rocketlake support.
+In the meantime here are some suggestions to compile with new CPUs:
+
+"-march=native" is usually the best choice, used by build.sh.
+
+"-march=znver2 -mvaes" can be used for Ryzen 5000 if znver3 is not recongized.
+
+"-mcascadelake -msha" or
+"-mcometlake -mavx512 -msha" can be used for Rocket Lake.
+
+Features can also be added individually:
+
+"-msha" adds support for HW accelerated sha256.
+
+"-mavx512" adds support for 512 bit vectors
+
+"-mvaes" add support for parallel AES
+
+Additional instructions for static compilalation can be found here:
+https://lxadm.com/Static_compilation_of_cpuminer
+Static builds should only considered in a homogeneous HW and SW environment.
+Local builds will always have the best performance and compatibility.
+
+3. Download cpuminer-opt
+------------------------
+
+Download the source code for the latest realease from the official repository.
+
+https://github.com/JayDDee/cpuminer-opt/releases
+
+Extract the source code.
+
+$ tar xvzf cpuminer-opt-x.y.z.tar.gz
+
+
+Alternatively it can be cloned from git.
+
+$ git clone https://github.com/JayDDee/cpuminer-opt.git
+ 
+4. Build cpuminer-opt
+---------------------
+
+It is recomended to Build with default options, this will usuallly
+produce the best results.
+
+$ ./build.sh to build on Linux or execute the following commands.
+
+or 
+
+$ ./autogen.sh
+$ CFLAGS="-O3 -march=native -Wall" ./configure --with-curl
+$ make -j n
+
+n is the number of threads.
+
+5. Start mining.
+----------------
+
+$ ./cpuminer -a algo -o url -u username -p password
+
+
+Windows
+-------
+
+See also INSTAL_WINDOWS
+
+The following procedure is obsolete and uses an old compiler.
+
+Precompiled Windows binaries are built on a Linux host using Mingw
+with a more recent compiler than the following Windows hosted procedure.
+
+Building on Windows prerequisites:
+
+msys
+mingw_w64
+Visual C++ redistributable 2008 X64
+openssl
+
+Install msys and mingw_w64, only needed once.
+
+Unpack msys into C:\msys or your preferred directory.
+
+Install mingw_w64 from win-builds.
+Follow instructions, check "msys or cygwin" and "x86_64" and accept default
+existing msys instalation.
+
+Open a msys shell by double clicking on msys.bat.
+Note that msys shell uses linux syntax for file specifications, "C:\" is
+mounted at "/c/".
+
+Add mingw bin directory to PATH variable
+PATH="/c/msys/opt/windows_64/bin/:$PATH"
+
+Instalation complete, compile cpuminer-opt.
+
+Unpack cpuminer-opt source files using tar from msys shell, or using 7zip
+or similar Windows program.
+
+In msys shell cd to miner directory.
+cd /c/path/to/cpuminer-opt
+
+Run build.sh to build on Windows or execute the following commands.
+
+./autogen.sh
+CFLAGS="-O3 -march=native -Wall" ./configure --with-curl
+make
+
+Start mining
+
+cpuminer.exe -a algo -o url -u user -p password
+
+The following tips may be useful for older AMD CPUs.
+
+AMD CPUs older than Steamroller, including Athlon x2 and Phenom II x4, are
+not supported by cpuminer-opt due to an incompatible implementation of SSE2
+on these CPUs. Some algos may crash the miner with an invalid instruction.
+Users are recommended to use an unoptimized miner such as cpuminer-multi.
+
+Some users with AMD CPUs without AES_NI have reported problems compiling
+with build.sh or "-march=native". Problems have included compile errors
+and poor performance. These users are recommended to compile manually
+specifying "-march=btver1" on the configure command line.
+
+Support for even older x86_64 without AES_NI or SSE2 is not availble.
+

INSTALL_WINDOWS

@@ -0,0 +1,4 @@
+Please consult the wiki for Windows compile instructions.
+
+https://github.com/JayDDee/cpuminer-opt/wiki/Compiling-from-source
+

Makefile.am

@@ -18,73 +18,67 @@ dist_man_MANS	= cpuminer.1
 cpuminer_SOURCES = \
   cpu-miner.c \
   util.c \
-  uint256.cpp \
   api.c \
   sysinfos.c \
   algo-gate-api.c\
-  crypto/blake2s.c \
-  crypto/oaes_lib.c \
-  crypto/c_keccak.c \
-  crypto/c_groestl.c \
-  crypto/c_blake256.c \
-  crypto/c_jh.c \
-  crypto/c_skein.c \
-  crypto/hash.c \
-  crypto/aesb.c \
-  crypto/magimath.cpp \
-  algo/argon2/argon2a.c \
-  algo/argon2/ar2/argon2.c \
-  algo/argon2/ar2/opt.c \
-  algo/argon2/ar2/cores.c \
-  algo/argon2/ar2/ar2-scrypt-jane.c \
-  algo/argon2/ar2/blake2b.c \
-  algo/axiom.c \
+  malloc-huge.c \
+  algo/argon2d/argon2d-gate.c \
+  algo/argon2d/blake2/blake2b.c \
+  algo/argon2d/argon2d/argon2.c \
+  algo/argon2d/argon2d/core.c \
+  algo/argon2d/argon2d/opt.c \
+  algo/argon2d/argon2d/argon2d_thread.c \
+  algo/argon2d/argon2d/encoding.c \
   algo/blake/sph_blake.c \
-  algo/blake/blake-hash-4way.c \
+  algo/blake/blake256-hash.c \
+  algo/blake/blake512-hash.c \
   algo/blake/blake-gate.c \
   algo/blake/blake.c \
   algo/blake/blake-4way.c \
   algo/blake/sph_blake2b.c \
-  algo/blake/blake2b.c \
+  algo/blake/sph-blake2s.c \
+  algo/blake/blake2s-hash.c \
   algo/blake/blake2s.c \
+  algo/blake/blake2b-hash.c \
+  algo/blake/blake2b.c \
+  algo/blake/blakecoin-gate.c \
   algo/blake/mod_blakecoin.c \
   algo/blake/blakecoin.c \
-  algo/blake/decred-gate.c \
-  algo/blake/decred.c \
-  algo/blake/decred-4way.c \
+  algo/blake/blakecoin-4way.c \
   algo/blake/pentablake-gate.c \
   algo/blake/pentablake-4way.c \
   algo/blake/pentablake.c \
   algo/bmw/sph_bmw.c \
+  algo/bmw/bmw256-hash-4way.c \
+  algo/bmw/bmw512-hash-4way.c \
   algo/bmw/bmw256.c \
-  algo/cryptonight/cryptolight.c \
-  algo/cryptonight/cryptonight-common.c\
-  algo/cryptonight/cryptonight-aesni.c\
-  algo/cryptonight/cryptonight.c\
+  algo/bmw/bmw512-gate.c \
+  algo/bmw/bmw512.c \
+  algo/bmw/bmw512-4way.c \
+  algo/cubehash/cubehash_sse2.c\
+  algo/cubehash/cube-hash-2way.c \
   algo/cubehash/sph_cubehash.c \
-  algo/cubehash/sse2/cubehash_sse2.c\
-  algo/drop.c \
   algo/echo/sph_echo.c \
+  algo/echo/echo-hash-4way.c \
   algo/echo/aes_ni/hash.c\
-  algo/fresh.c \
   algo/gost/sph_gost.c \
+  algo/groestl/groestl-gate.c \
+  algo/groestl/groestl512-hash-4way.c \
+  algo/groestl/groestl256-hash-4way.c \
   algo/groestl/sph_groestl.c \
   algo/groestl/groestl.c \
+  algo/groestl/groestl-4way.c \
+  algo/groestl/myrgr-gate.c \
+  algo/groestl/myrgr-4way.c \
   algo/groestl/myr-groestl.c \
   algo/groestl/aes_ni/hash-groestl.c \
   algo/groestl/aes_ni/hash-groestl256.c \
   algo/fugue/sph_fugue.c \
+  algo/fugue/fugue-aesni.c \
   algo/hamsi/sph_hamsi.c \
-  algo/haval/haval.c\
-  algo/heavy/sph_hefty1.c \
-  algo/heavy/heavy.c \
-  algo/heavy/bastion.c \
-  algo/hmq1725.c \
-  algo/hodl/aes.c \
-  algo/hodl/hodl-gate.c \
-  algo/hodl/hodl-wolf.c \
-  algo/hodl/sha512_avx.c \
-  algo/hodl/sha512_avx2.c \
+  algo/hamsi/hamsi-hash-4way.c \
+  algo/haval/haval.c \
+  algo/haval/haval-hash-4way.c \
   algo/jh/sph_jh.c \
   algo/jh/jh-hash-4way.c \
   algo/jh/jha-gate.c \
@@ -95,94 +89,196 @@ cpuminer_SOURCES = \
   algo/keccak/keccak-hash-4way.c \
   algo/keccak/keccak-4way.c\
   algo/keccak/keccak-gate.c \
-  algo/keccak/sse2/keccak.c \
-  algo/lbry.c \
+  algo/keccak/sha3d-4way.c \
+  algo/keccak/sha3d.c \
+  algo/lanehash/lane.c \
+  algo/luffa/luffa_for_sse2.c \
+  algo/luffa/luffa-hash-2way.c \
   algo/luffa/sph_luffa.c \
-  algo/luffa/luffa.c \
-  algo/luffa/sse2/luffa_for_sse2.c \
   algo/lyra2/lyra2.c \
   algo/lyra2/sponge.c \
+  algo/lyra2/sponge-2way.c \
+  algo/lyra2/lyra2-hash-2way.c \
+  algo/lyra2/lyra2-gate.c \
   algo/lyra2/lyra2rev2.c \
+  algo/lyra2/lyra2rev2-4way.c \
+  algo/lyra2/lyra2rev3.c \
+  algo/lyra2/lyra2rev3-4way.c \
   algo/lyra2/lyra2re.c \
-  algo/lyra2/zcoin.c \
+  algo/lyra2/lyra2z-4way.c \
   algo/lyra2/lyra2z330.c \
-  algo/m7m.c \
-  algo/neoscrypt.c \
+  algo/lyra2/lyra2h.c \
+  algo/lyra2/lyra2h-4way.c \
+  algo/lyra2/allium-4way.c \
+  algo/lyra2/phi2-4way.c \
+  algo/lyra2/phi2.c \
+  algo/m7m/m7m.c \
+  algo/m7m/magimath.cpp \
   algo/nist5/nist5-gate.c \
   algo/nist5/nist5-4way.c \
   algo/nist5/nist5.c \
-  algo/pluck.c \
-  algo/polytimos/polytimos-gate.c \
-  algo/polytimos/polytimos.c \
+  algo/nist5/zr5.c \
+  algo/panama/panama-hash-4way.c \
+  algo/panama/sph_panama.c \
+  algo/quark/quark-gate.c \
   algo/quark/quark.c \
+  algo/quark/quark-4way.c \
+  algo/quark/anime-gate.c \
+  algo/quark/anime.c \
+  algo/quark/anime-4way.c \
+  algo/quark/hmq1725-gate.c \
+  algo/quark/hmq1725-4way.c \
+  algo/quark/hmq1725.c \
+  algo/qubit/qubit-gate.c \
   algo/qubit/qubit.c \
+  algo/qubit/qubit-2way.c \
+  algo/qubit/deep-gate.c \
+  algo/qubit/deep-2way.c \
   algo/qubit/deep.c \
   algo/ripemd/sph_ripemd.c \
-  algo/scrypt.c \
-  algo/scryptjane/scrypt-jane.c \
+  algo/ripemd/ripemd-hash-4way.c \
+  algo/ripemd/lbry-gate.c \
+  algo/ripemd/lbry.c \
+  algo/ripemd/lbry-4way.c \
+  algo/scrypt/scrypt.c \
+  algo/scrypt/scrypt-core-4way.c \
+  algo/scrypt/neoscrypt.c \
+  algo/sha/sha1.c \
+  algo/sha/sha1-hash.c \
+  algo/sha/sha256-hash.c \
   algo/sha/sph_sha2.c \
   algo/sha/sph_sha2big.c \
-  algo/sha/sha2.c \
-  algo/sha/sha256t.c \
+  algo/sha/sha256-hash-4way.c \
+  algo/sha/sha512-hash-4way.c \
+  algo/sha/hmac-sha256-hash.c \
+  algo/sha/hmac-sha256-hash-4way.c \
+  algo/sha/sha256d.c \
+  algo/sha/sha256d-4way.c \
+  algo/sha/sha256t-gate.c \
+  algo/sha/sha256t-4way.c \
+  algo/sha/sha256q-4way.c \
+  algo/sha/sha256q.c \
+  algo/sha/sha512256d-4way.c \
+  algo/sha/sha256dt.c \
   algo/shabal/sph_shabal.c \
+  algo/shabal/shabal-hash-4way.c \
   algo/shavite/sph_shavite.c \
+  algo/shavite/sph-shavite-aesni.c \
+  algo/shavite/shavite-hash-2way.c \
+  algo/shavite/shavite-hash-4way.c \
   algo/shavite/shavite.c \
+  algo/simd/nist.c \
+  algo/simd/vector.c \
   algo/simd/sph_simd.c \
-  algo/simd/sse2/nist.c \
-  algo/simd/sse2/vector.c \
+  algo/simd/simd-hash-2way.c \
   algo/skein/sph_skein.c \
   algo/skein/skein-hash-4way.c \
   algo/skein/skein.c \
   algo/skein/skein-4way.c \
-  algo/skein/skein-gate.c \  
+  algo/skein/skein-gate.c \
   algo/skein/skein2.c \
   algo/skein/skein2-4way.c \
-  algo/skein/skein2-gate.c \
-  algo/skunk.c \
   algo/sm3/sm3.c \
+  algo/sm3/sm3-hash-4way.c \
+  algo/swifftx/swifftx.c \
   algo/tiger/sph_tiger.c \
-  algo/timetravel.c \
-  algo/timetravel10.c \
-  algo/tribus/tribus-gate.c \
-  algo/tribus/tribus.c \
-  algo/tribus/tribus-4way.c \
-  algo/veltor.c \
+  algo/verthash/verthash-gate.c \
+  algo/verthash/Verthash.c \
+  algo/verthash/fopen_utf8.c \
+  algo/verthash/tiny_sha3/sha3.c \
+  algo/verthash/tiny_sha3/sha3-4way.c \
   algo/whirlpool/sph_whirlpool.c \
-  algo/whirlpool/whirlpool-hash-4way.c \
   algo/whirlpool/whirlpool-gate.c \
-  algo/whirlpool/whirlpool-4way.c \
   algo/whirlpool/whirlpool.c \
   algo/whirlpool/whirlpoolx.c \
-  algo/x11/phi1612.c \
+  algo/x11/x11-gate.c \
   algo/x11/x11.c \
-  algo/x11/x11evo.c \
+  algo/x11/x11-4way.c \
+  algo/x11/x11gost-gate.c \
   algo/x11/x11gost.c \
+  algo/x11/x11gost-4way.c \
+  algo/x11/c11-gate.c \
   algo/x11/c11.c \
+  algo/x11/c11-4way.c \
+  algo/x11/tribus-gate.c \
+  algo/x11/tribus.c \
+  algo/x11/tribus-4way.c \
+  algo/x11/timetravel-gate.c \
+  algo/x11/timetravel.c \
+  algo/x11/timetravel-4way.c \
+  algo/x11/timetravel10-gate.c \
+  algo/x11/timetravel10.c \
+  algo/x11/timetravel10-4way.c \
+  algo/x11/x11evo.c \
+  algo/x11/x11evo-4way.c \
+  algo/x11/x11evo-gate.c \
+  algo/x12/x12-gate.c \
+  algo/x12/x12.c \
+  algo/x12/x12-4way.c \
+  algo/x13/x13-gate.c \
   algo/x13/x13.c \
+  algo/x13/x13-4way.c \
+  algo/x13/x13sm3-gate.c \
   algo/x13/x13sm3.c \
+  algo/x13/x13sm3-4way.c \
+  algo/x13/phi1612-gate.c \
+  algo/x13/phi1612.c \
+  algo/x13/phi1612-4way.c \
+  algo/x13/skunk-gate.c \
+  algo/x13/skunk-4way.c \
+  algo/x13/skunk.c \
+  algo/x13/x13bcd-4way.c \
+  algo/x13/x13bcd.c \
+  algo/x14/x14-gate.c \
   algo/x14/x14.c \
+  algo/x14/x14-4way.c \
+  algo/x14/veltor-gate.c \
+  algo/x14/veltor.c \
+  algo/x14/veltor-4way.c \
+  algo/x14/polytimos-gate.c \
+  algo/x14/polytimos.c \
+  algo/x14/polytimos-4way.c \
+  algo/x14/axiom.c \
+  algo/x15/x15-gate.c \
   algo/x15/x15.c \
+  algo/x15/x15-4way.c \
+  algo/x16/x16r-gate.c \
+  algo/x16/x16r.c \
+  algo/x16/x16r-4way.c \
+  algo/x16/x16rv2.c \
+  algo/x16/x16rv2-4way.c \
+  algo/x16/x16rt.c \
+  algo/x16/x16rt-4way.c \
+  algo/x16/hex.c \
+  algo/x16/x21s-4way.c \
+  algo/x16/x21s.c \
+  algo/x16/minotaur.c \
+  algo/x17/x17-gate.c \
   algo/x17/x17.c \
-  algo/xevan.c \
-  algo/yescrypt/yescrypt.c \
-  algo/yescrypt/sha256_Y.c\
-  algo/yescrypt/yescrypt-simd.c\
-  algo/zr5.c
-
-
+  algo/x17/x17-4way.c \
+  algo/x17/xevan-gate.c \
+  algo/x17/xevan.c \
+  algo/x17/xevan-4way.c \
+  algo/x17/sonoa-gate.c \
+  algo/x17/sonoa-4way.c \
+  algo/x17/sonoa.c \
+  algo/x22/x22i-4way.c \
+  algo/x22/x22i.c \
+  algo/x22/x22i-gate.c \
+  algo/x22/x25x.c \
+  algo/x22/x25x-4way.c \
+  algo/yespower/yespower-gate.c \
+  algo/yespower/yespower-blake2b.c \
+  algo/yespower/crypto/hmac-blake2b.c \
+  algo/yespower/yescrypt-r8g.c \
+  algo/yespower/yespower-opt.c \
+  algo/yespower/yespower-ref.c \
+  algo/yespower/yespower-blake2b-ref.c
+  
 disable_flags =
 
 if USE_ASM
    cpuminer_SOURCES += asm/neoscrypt_asm.S
-if ARCH_x86
-   cpuminer_SOURCES += asm/sha2-x86.S asm/scrypt-x86.S asm/aesb-x86.S
-endif
-if ARCH_x86_64
-   cpuminer_SOURCES += asm/sha2-x64.S asm/scrypt-x64.S asm/aesb-x64.S
-endif
-if ARCH_ARM
-   cpuminer_SOURCES += asm/sha2-arm.S asm/scrypt-arm.S
-endif
 else
    disable_flags += -DNOASM
 endif
@@ -192,7 +288,7 @@ if HAVE_WINDOWS
 endif
 
 cpuminer_LDFLAGS	= @LDFLAGS@
-cpuminer_LDADD	= @LIBCURL@ @JANSSON_LIBS@ @PTHREAD_LIBS@ @WS2_LIBS@ -lssl -lcrypto -lgmp
+cpuminer_LDADD	= @LIBCURL@ @JANSSON_LIBS@ @PTHREAD_LIBS@ @WS2_LIBS@  -lgmp
 cpuminer_CPPFLAGS = @LIBCURL_CPPFLAGS@ $(ALL_INCLUDES)
 cpuminer_CFLAGS   = -Wno-pointer-sign -Wno-pointer-to-int-cast $(disable_flags)
 

README.md

@@ -7,104 +7,189 @@ All of the code is believed to be open and free. If anyone has a
 claim to any of it post your case in the cpuminer-opt Bitcoin Talk forum
 or by email.
 
+Miner programs are often flagged as malware by antivirus programs. This is
+a false positive, they are flagged simply because they are cryptocurrency 
+miners. The source code is open for anyone to inspect. If you don't trust 
+the software, don't use it.
+
+
+New thread:
+
+https://bitcointalk.org/index.php?topic=5226770.msg53865575#msg53865575
+
+Old thread:
+
 https://bitcointalk.org/index.php?topic=1326803.0
 
 mailto://jayddee246@gmail.com
 
-See file RELEASE_NOTES for change log and compile instructions.
+This note is to confirm that bitcointalk users JayDDee and joblo are the
+same person.
 
-Supported Algorithms
---------------------
+I created a new BCT user JayDDee to match my github user id.
+The old thread has been locked but still contains useful information for
+reading.
 
-                          argon2
-                          axiom        Shabal-256 MemoHash
-                          bastion
-                          blake        Blake-256 (SFR)
-                          blakecoin    blake256r8
-                          blake2s      Blake-2 S
-                          bmw          BMW 256
-                          c11          Chaincoin
-                          cryptolight  Cryptonight-light
-                          cryptonight  cryptonote, Monero (XMR)
-                          decred
-                          deep         Deepcoin (DCN)
-                          dmd-gr       Diamond-Groestl
-                          drop         Dropcoin
-                          fresh        Fresh
-                          groestl      Groestl coin
-                          heavy        Heavy
-                          hmq1725      Espers
-                          hodl         Hodlcoin
-                          jha          jackpotcoin
-                          keccak       Keccak
-                          lbry         LBC, LBRY Credits
-                          luffa        Luffa
-                          lyra2re      lyra2
-                          lyra2rev2    lyra2v2, Vertcoin
-                          lyra2z       Zcoin (XZC)
-                          lyra2z330    Lyra2 330 rows, Zoin (ZOI)
-                          m7m          Magi (XMG)
-                          myr-gr       Myriad-Groestl
-                          neoscrypt    NeoScrypt(128, 2, 1)
-                          nist5        Nist5
-                          pentablake   Pentablake
-                          phi1612      phi, LUX coin
-                          pluck        Pluck:128 (Supcoin)
-                          polytimos
-                          quark        Quark
-                          qubit        Qubit
-                          scrypt       scrypt(1024, 1, 1) (default)
-                          scrypt:N     scrypt(N, 1, 1)
-                          scryptjane:nf
-                          sha256d      Double SHA-256
-                          sha256t      Triple SHA-256, Onecoin (OC)
-                          shavite3     Shavite3
-                          skein        Skein+Sha (Skeincoin)
-                          skein2       Double Skein (Woodcoin)
-                          skunk        Signatum (SIGT)
-                          timetravel   Machinecoin (MAC)
-                          timetravel10 Bitcore
-                          tribus       Denarius (DNR)
-                          vanilla      blake256r8vnl (VCash)
-                          veltor
-                          whirlpool
-                          whirlpoolx
-                          x11          Dash
-                          x11evo       Revolvercoin
-                          x11gost      sib (SibCoin)
-                          x13          X13
-                          x13sm3       hsr (Hshare)
-                          x14          X14
-                          x15          X15
-                          x17
-                          xevan        Bitsend
-                          yescrypt     Globalboost-Y (BSTY)
-                          yescryptr16  Yenten (YTN)
-                          zr5          Ziftr
+See file RELEASE_NOTES for change log and INSTALL_LINUX or INSTALL_WINDOWS
+for compile instructions.
 
 Requirements
 ------------
 
 1. A x86_64 architecture CPU with a minimum of SSE2 support. This includes
-Intel Core2 and newer and AMD equivalents. In order to take advantage of AES_NI
-optimizations a CPU with AES_NI is required. This includes Intel Westbridge
-and newer and AMD equivalents. Further optimizations are available on some
-algoritms for CPUs with AVX and AVX2, Sandybridge and Haswell respectively.
+Intel Core2 and newer and AMD equivalents. Further optimizations are available
+on some algoritms for CPUs with AES, AVX, AVX2, SHA, AVX512 and VAES.
 
-Older CPUs are supported by cpuminer-multi by TPruvot but at reduced
-performance.
+32 bit CPUs are not supported.
+Other CPU architectures such as ARM, Raspberry Pi, RISC-V, Xeon Phi, etc,
+are not supported.
 
-2. 64 bit Linux OS. Ubuntu and Fedora based distributions, including Mint and
-Centos are known to work and have all dependencies in their repositories.
-Others may work but may require more effort.
-64 bit Windows OS is supported with mingw_w64 and msys or pre-built binaries.
+Mobile CPUs like laptop computers are not recommended because they aren't
+designed for extreme heat of operating at full load for extended periods of
+time.
 
-3. Stratum pool, cpuminer-opt only supports stratum minning. Some algos
-may work wallet mining but there are no guarantees.
+Older CPUs and ARM architecture may be supported by cpuminer-multi by TPruvot.
+
+2. 64 bit Linux or Windows OS. Ubuntu and Fedora based distributions,
+including Mint and Centos, are known to work and have all dependencies
+in their repositories. Others may work but may require more effort. Older
+versions such as Centos 6 don't work due to missing features. 
+
+Windows 7 or newer is supported with mingw_w64 and msys or using the pre-built
+binaries. WindowsXP 64 bit is YMMV.
+
+FreeBSD is not actively tested but should work, YMMV.
+MacOS, OSx and Android are not supported.
+
+3. Stratum pool supporting stratum+tcp:// or stratum+ssl:// protocols or
+RPC getwork using http:// or https://.
+GBT is YMMV.
+
+Supported Algorithms
+--------------------
+
+                          allium        Garlicoin
+                          anime         Animecoin
+                          argon2        Argon2 coin (AR2)
+                          argon2d250    argon2d-crds, Credits (CRDS)
+                          argon2d500    argon2d-dyn,  Dynamic (DYN)
+                          argon2d4096   argon2d-uis, Unitus, (UIS)
+                          blake         Blake-256
+                          blake2b       Blake2-512
+                          blake2s       Blake2-256
+                          blakecoin     blake256r8
+                          bmw           BMW 256
+                          bmw512        BMW 512
+                          c11           
+                          decred
+                          deep          Deepcoin (DCN)
+                          dmd-gr        Diamond-Groestl
+                          groestl       Groestl coin
+                          hex           x16r-hex
+                          hmq1725       
+                          hodl          Hodlcoin
+                          jha           Jackpotcoin
+                          keccak        Maxcoin
+                          keccakc       Creative coin
+                          lbry          LBC, LBRY Credits
+                          lyra2h        
+                          lyra2re       lyra2
+                          lyra2rev2     lyra2v2
+                          lyra2rev3     lyrav2v3
+                          lyra2z        
+                          lyra2z330     
+                          m7m           
+                          minotaur 
+                          minotaurx
+                          myr-gr        Myriad-Groestl
+                          neoscrypt     NeoScrypt(128, 2, 1)
+                          nist5         Nist5
+                          pentablake    Pentablake
+                          phi1612       phi
+                          phi2          
+                          polytimos     Ninja
+                          power2b       MicroBitcoin (MBC)
+                          quark         Quark
+                          qubit         Qubit
+                          scrypt        scrypt(1024, 1, 1) (default)
+                          scrypt:N      scrypt(N, 1, 1)
+                          scryptn2      scrypt(1048576, 1, 1)
+                          sha256d       Double SHA-256
+                          sha256q       Quad SHA-256
+                          sha256t       Triple SHA-256
+                          sha3d         Double keccak256 (BSHA3)
+                          skein         Skein+Sha (Skeincoin)
+                          skein2        Double Skein (Woodcoin)
+                          skunk         Signatum (SIGT)
+                          sonoa         Sono
+                          timetravel    Machinecoin (MAC)
+                          timetravel10  Bitcore
+                          tribus        Denarius (DNR)
+                          vanilla       blake256r8vnl (VCash)
+                          veltor        (VLT)
+                          verthash      Vertcoin
+                          whirlpool
+                          whirlpoolx
+                          x11           Dash
+                          x11evo        Revolvercoin
+                          x11gost       sib (SibCoin)
+                          x12           
+                          x13           
+                          x13bcd        bcd
+                          x13sm3        hsr (Hshare)
+                          x14           
+                          x15           
+                          x16r          
+                          x16rv2        
+                          x16rt         
+                          x16rt-veil    veil
+                          x16s          
+                          x17
+                          x21s
+                          x22i
+                          x25x
+                          xevan         Bitsend (BSD)
+                          yescrypt      Globalboost-Y (BSTY)
+                          yescryptr8    BitZeny (ZNY)
+                          yescryptr8g   Koto (KOTO)
+                          yescryptr16   Eli
+                          yescryptr32   WAVI
+                          yespower      Cryply
+                          yespowerr16   Yenten (YTN)
+                          yespower-b2b  generic yespower + blake2b
+                          zr5           Ziftr
+
+Many variations of scrypt based algos can be mine by specifying their
+parameters:
+
+scryptn2: --algo scrypt --param-n 1048576
+
+cpupower: --algo yespower --param-key "CPUpower: The number of CPU working or available for proof-of-work mining"
+
+power2b: --algo yespower-b2b --param-n 2048 --param-r 32 --param-key "Now I am become Death, the destroyer of worlds"
+
+sugarchain: --algo yespower --param-n 2048 -param-r 32 --param-key "Satoshi Nakamoto 31/Oct/2008 Proof-of-work is essentially one-CPU-one-vote"
+
+yespoweriots: --algo yespower --param-n 2048 --param-key "Iots is committed to the development of IOT"
+
+yespowerlitb: --algo yespower --param-n 2048 --param-r 32 --param-key "LITBpower: The number of LITB working or available for proof-of-work mini"
+
+yespoweric: --algo yespower --param-n 2048 --param-r 32 --param-key "IsotopeC" 
+
+yespowerurx: --algo yespower --param-n 2048 --param-r 32 --param-key "UraniumX"
+
+yespowerltncg: --algo yespower --param-n 2048 --param-r 32 --param-key "LTNCGYES"
 
 Errata
 ------
 
+Old algorithms that are no longer used frequently will not have the latest
+optimizations.
+
+Cryptonight and variants are no longer supported, use another miner.
+
+Neoscrypt crashes on Windows, use legacy version.
+
 AMD CPUs older than Piledriver, including Athlon x2 and Phenom II x4, are not
 supported by cpuminer-opt due to an incompatible implementation of SSE2 on
 these CPUs. Some algos may crash the miner with an invalid instruction.
@@ -118,22 +203,24 @@ Benchmark testing does not work for x11evo.
 Bugs
 ----
 
-Users are encouraged to post their bug reports on the Bitcoin Talk
-forum at:
+Users are encouraged to post their bug reports using git issues or on the
+Bitcoin Talk forum or opening an issue in git:
 
 https://bitcointalk.org/index.php?topic=1326803.0
 
-All problem reports must be accompanied by a proper definition.
+https://github.com/JayDDee/cpuminer-opt/issues
+
+All problem reports must be accompanied by a proper problem definition.
 This should include how the problem occurred, the command line and
-output from the miner showing the startup and any errors.
+output from the miner showing the startup messages and any errors.
+A history is also useful, ie did it work before.
 
 Donations
 ---------
 
-I do not do this for money but I have a donation address if users
-are so inclined.
+cpuminer-opt has no fees of any kind but donations are accepted.
 
-bitcoin:12tdvfF7KmAsihBXQXynT6E6th2c2pByTT?label=donations
+ BTC: 12tdvfF7KmAsihBXQXynT6E6th2c2pByTT
 
 Happy mining!
 

README.txt

@@ -1,33 +1,80 @@
 This file is included in the Windows binary package. Compile instructions
 for Linux and Windows can be found in RELEASE_NOTES.
 
-cpuminer is a console program that is executed from a DOS command prompt.
-There is no GUI and no mouse support.
+cpuminer-opt is open source and free of any fees. Many forks exist that are
+closed source and contain usage fees. support open source free software.
+
+This package is officially avalaible only from:
+
+ https://github.com/JayDDee/cpuminer-opt
+
+No other sources should be trusted.
+
+cpuminer is a console program that is executed from a DOS or Powershell
+command prompt. There is no GUI and no mouse support.
+
+New users are encouraged to consult the cpuminer-opt Wiki for detailed
+information on usage:
+
+https://github.com/JayDDee/cpuminer-opt/wiki
+
+Miner programs are often flagged as malware by antivirus programs. This is
+a false positive, they are flagged simply because they are cryptocurrency 
+miners. The source code is open for anyone to inspect. If you don't trust
+the software, don't use it.
 
 Choose the exe that best matches you CPU's features or use trial and
-error to find the fastest one that doesn't crash. Pay attention to
+error to find the fastest one that works. Pay attention to
 the features listed at cpuminer startup to ensure you are mining at
-optimum speed using all the available features.
+optimum speed using the best available features.
 
-Architecture names and compile options used are only provided for Intel
-Core series. Pentium and Celeron often have fewer features.
+Architecture names and compile options used are only provided for 
+mainstream desktop CPUs. Budget CPUs like Pentium and Celeron are often
+missing some features. Check your CPU.
 
-AMD CPUs older than Piledriver, including Athlon x2 and Phenom II x4, are not
-supported by cpuminer-opt due to an incompatible implementation of SSE2 on
-these CPUs. Some algos may crash the miner with an invalid instruction.
-Users are recommended to use an unoptimized miner such as cpuminer-multi.
+Support for AMD CPUs older than Ryzen is incomplete and without specific 
+recommendations. Find the best fit. CPUs older than Piledriver, including
+Athlon x2 and Phenom II x4, are not supported by cpuminer-opt due to an
+incompatible implementation of SSE2 on these CPUs. 
 
-Exe name                  Compile opts         Arch name
+More information for Intel and AMD CPU architectures and their features
+can be found on Wikipedia.
 
-cpuminer-sse2.exe         -march=core2         Core2   
-cpuminer-sse42.exe        -march=corei7        Nehalem
-cpuminer-aes-sse42.exe    -maes -msse4.2"      Westmere
-cpuminer-aes-avx.exe      -march=corei7-avx"   Sandybridge, Ivybridge
-cpuminer-aes-avx2.exe     "-march=core-avx2"   Haswell, Broadwell, Skylake, Kabylake
-cpuminer-4way.exe         "-march=core-avx2 -DFOUR_WAY"
+https://en.wikipedia.org/wiki/List_of_Intel_CPU_microarchitectures
+
+https://en.wikipedia.org/wiki/List_of_AMD_CPU_microarchitectures
+
+File name                      Architecture name
+
+cpuminer-sse2.exe              Core2, Nehalem, generic x86_64 with SSE2   
+cpuminer-aes-sse42.exe         Westmere
+cpuminer-avx.exe               Sandybridge, Ivybridge
+cpuminer-avx2.exe              Haswell, Skylake, Kabylake, Coffeelake, Cometlake
+cpuminer-avx2-sha.exe          AMD Zen1, Zen2
+cpuminer-avx2-sha-vaes.exe     Intel Alderlake*, AMD Zen3
+cpuminer-avx512.exe            Intel HEDT Skylake-X, Cascadelake
+cpuminer-avx512-sha-vaes.exe   AMD Zen4, Intel Rocketlake, Icelake
+
+* Alderlake is a hybrid architecture with a mix of E-cores & P-cores. Although
+  the P-cores can support AVX512 the E-cores can't so Intel decided to disable
+  AVX512 on the the P-cores.
+
+Notes about included DLL files:
+
+Downloading DLL files from alternative sources presents an inherent
+security risk if their source is unknown. All DLL files included have
+been copied from the Ubuntu-20.04 installation or compiled by me from
+source code obtained from the author's official repository. The exact
+procedure is documented in the build instructions for Windows:
+https://github.com/JayDDee/cpuminer-opt/wiki/Compiling-from-source
+
+Some included DLL files may already be installed on the system by Windows or
+third party packages. They often will work and may be used instead of the
+included version of the files.
+
+
+If you like this software feel free to donate:
+
+BTC: 12tdvfF7KmAsihBXQXynT6E6th2c2pByTT
 
-4way requires a CPU with AES and AVX2. It is still under development and
-only a few algos are supported. See change log in RELEASE_NOTES in source
-package for supported algos.
 
-There is no binary support available for SHA on AMD Ryzen CPUs.

aclocal.m4

@@ -1,6 +1,6 @@
-# generated automatically by aclocal 1.14.1 -*- Autoconf -*-
+# generated automatically by aclocal 1.16.5 -*- Autoconf -*-
 
-# Copyright (C) 1996-2013 Free Software Foundation, Inc.
+# Copyright (C) 1996-2021 Free Software Foundation, Inc.
 
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -14,13 +14,13 @@
 m4_ifndef([AC_CONFIG_MACRO_DIRS], [m4_defun([_AM_CONFIG_MACRO_DIRS], [])m4_defun([AC_CONFIG_MACRO_DIRS], [_AM_CONFIG_MACRO_DIRS($@)])])
 m4_ifndef([AC_AUTOCONF_VERSION],
   [m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl
-m4_if(m4_defn([AC_AUTOCONF_VERSION]), [2.69],,
-[m4_warning([this file was generated for autoconf 2.69.
+m4_if(m4_defn([AC_AUTOCONF_VERSION]), [2.71],,
+[m4_warning([this file was generated for autoconf 2.71.
 You have another version of autoconf.  It may work, but is not guaranteed to.
 If you have problems, you may need to regenerate the build system entirely.
 To do so, use the procedure documented by the package, typically 'autoreconf'.])])
 
-# Copyright (C) 2002-2013 Free Software Foundation, Inc.
+# Copyright (C) 2002-2021 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -32,10 +32,10 @@ To do so, use the procedure documented by the package, typically 'autoreconf'.])
 # generated from the m4 files accompanying Automake X.Y.
 # (This private macro should not be called outside this file.)
 AC_DEFUN([AM_AUTOMAKE_VERSION],
-[am__api_version='1.14'
+[am__api_version='1.16'
 dnl Some users find AM_AUTOMAKE_VERSION and mistake it for a way to
 dnl require some minimum version.  Point them to the right macro.
-m4_if([$1], [1.14.1], [],
+m4_if([$1], [1.16.5], [],
       [AC_FATAL([Do not call $0, use AM_INIT_AUTOMAKE([$1]).])])dnl
 ])
 
@@ -51,14 +51,14 @@ m4_define([_AM_AUTOCONF_VERSION], [])
 # Call AM_AUTOMAKE_VERSION and AM_AUTOMAKE_VERSION so they can be traced.
 # This function is AC_REQUIREd by AM_INIT_AUTOMAKE.
 AC_DEFUN([AM_SET_CURRENT_AUTOMAKE_VERSION],
-[AM_AUTOMAKE_VERSION([1.14.1])dnl
+[AM_AUTOMAKE_VERSION([1.16.5])dnl
 m4_ifndef([AC_AUTOCONF_VERSION],
   [m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl
 _AM_AUTOCONF_VERSION(m4_defn([AC_AUTOCONF_VERSION]))])
 
 # Figure out how to run the assembler.                      -*- Autoconf -*-
 
-# Copyright (C) 2001-2013 Free Software Foundation, Inc.
+# Copyright (C) 2001-2021 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -78,7 +78,7 @@ _AM_IF_OPTION([no-dependencies],, [_AM_DEPENDENCIES([CCAS])])dnl
 
 # AM_AUX_DIR_EXPAND                                         -*- Autoconf -*-
 
-# Copyright (C) 2001-2013 Free Software Foundation, Inc.
+# Copyright (C) 2001-2021 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -123,15 +123,14 @@ _AM_IF_OPTION([no-dependencies],, [_AM_DEPENDENCIES([CCAS])])dnl
 # configured tree to be moved without reconfiguration.
 
 AC_DEFUN([AM_AUX_DIR_EXPAND],
-[dnl Rely on autoconf to set up CDPATH properly.
-AC_PREREQ([2.50])dnl
-# expand $ac_aux_dir to an absolute path
-am_aux_dir=`cd $ac_aux_dir && pwd`
+[AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT])dnl
+# Expand $ac_aux_dir to an absolute path.
+am_aux_dir=`cd "$ac_aux_dir" && pwd`
 ])
 
 # AM_CONDITIONAL                                            -*- Autoconf -*-
 
-# Copyright (C) 1997-2013 Free Software Foundation, Inc.
+# Copyright (C) 1997-2021 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -162,7 +161,7 @@ AC_CONFIG_COMMANDS_PRE(
 Usually this means the macro was only invoked conditionally.]])
 fi])])
 
-# Copyright (C) 1999-2013 Free Software Foundation, Inc.
+# Copyright (C) 1999-2021 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -353,13 +352,12 @@ _AM_SUBST_NOTMAKE([am__nodep])dnl
 
 # Generate code to set up dependency tracking.              -*- Autoconf -*-
 
-# Copyright (C) 1999-2013 Free Software Foundation, Inc.
+# Copyright (C) 1999-2021 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
 # with or without modifications, as long as this notice is preserved.
 
-
 # _AM_OUTPUT_DEPENDENCY_COMMANDS
 # ------------------------------
 AC_DEFUN([_AM_OUTPUT_DEPENDENCY_COMMANDS],
@@ -367,49 +365,43 @@ AC_DEFUN([_AM_OUTPUT_DEPENDENCY_COMMANDS],
   # Older Autoconf quotes --file arguments for eval, but not when files
   # are listed without --file.  Let's play safe and only enable the eval
   # if we detect the quoting.
-  case $CONFIG_FILES in
-  *\'*) eval set x "$CONFIG_FILES" ;;
-  *)   set x $CONFIG_FILES ;;
-  esac
+  # TODO: see whether this extra hack can be removed once we start
+  # requiring Autoconf 2.70 or later.
+  AS_CASE([$CONFIG_FILES],
+          [*\'*], [eval set x "$CONFIG_FILES"],
+          [*], [set x $CONFIG_FILES])
   shift
-  for mf
+  # Used to flag and report bootstrapping failures.
+  am_rc=0
+  for am_mf
   do
     # Strip MF so we end up with the name of the file.
-    mf=`echo "$mf" | sed -e 's/:.*$//'`
-    # Check whether this is an Automake generated Makefile or not.
-    # We used to match only the files named 'Makefile.in', but
-    # some people rename them; so instead we look at the file content.
-    # Grep'ing the first line is not enough: some people post-process
-    # each Makefile.in and add a new line on top of each file to say so.
-    # Grep'ing the whole file is not good either: AIX grep has a line
+    am_mf=`AS_ECHO(["$am_mf"]) | sed -e 's/:.*$//'`
+    # Check whether this is an Automake generated Makefile which includes
+    # dependency-tracking related rules and includes.
+    # Grep'ing the whole file directly is not great: AIX grep has a line
     # limit of 2048, but all sed's we know have understand at least 4000.
-    if sed -n 's,^#.*generated by automake.*,X,p' "$mf" | grep X >/dev/null 2>&1; then
-      dirpart=`AS_DIRNAME("$mf")`
-    else
-      continue
-    fi
-    # Extract the definition of DEPDIR, am__include, and am__quote
-    # from the Makefile without running 'make'.
-    DEPDIR=`sed -n 's/^DEPDIR = //p' < "$mf"`
-    test -z "$DEPDIR" && continue
-    am__include=`sed -n 's/^am__include = //p' < "$mf"`
-    test -z "$am__include" && continue
-    am__quote=`sed -n 's/^am__quote = //p' < "$mf"`
-    # Find all dependency output files, they are included files with
-    # $(DEPDIR) in their names.  We invoke sed twice because it is the
-    # simplest approach to changing $(DEPDIR) to its actual value in the
-    # expansion.
-    for file in `sed -n "
-      s/^$am__include $am__quote\(.*(DEPDIR).*\)$am__quote"'$/\1/p' <"$mf" | \
-	 sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g'`; do
-      # Make sure the directory exists.
-      test -f "$dirpart/$file" && continue
-      fdir=`AS_DIRNAME(["$file"])`
-      AS_MKDIR_P([$dirpart/$fdir])
-      # echo "creating $dirpart/$file"
-      echo '# dummy' > "$dirpart/$file"
-    done
+    sed -n 's,^am--depfiles:.*,X,p' "$am_mf" | grep X >/dev/null 2>&1 \
+      || continue
+    am_dirpart=`AS_DIRNAME(["$am_mf"])`
+    am_filepart=`AS_BASENAME(["$am_mf"])`
+    AM_RUN_LOG([cd "$am_dirpart" \
+      && sed -e '/# am--include-marker/d' "$am_filepart" \
+        | $MAKE -f - am--depfiles]) || am_rc=$?
   done
+  if test $am_rc -ne 0; then
+    AC_MSG_FAILURE([Something went wrong bootstrapping makefile fragments
+    for automatic dependency tracking.  If GNU make was not used, consider
+    re-running the configure script with MAKE="gmake" (or whatever is
+    necessary).  You can also try re-running configure with the
+    '--disable-dependency-tracking' option to at least be able to build
+    the package (albeit without support for automatic dependency tracking).])
+  fi
+  AS_UNSET([am_dirpart])
+  AS_UNSET([am_filepart])
+  AS_UNSET([am_mf])
+  AS_UNSET([am_rc])
+  rm -f conftest-deps.mk
 }
 ])# _AM_OUTPUT_DEPENDENCY_COMMANDS
 
@@ -418,18 +410,17 @@ AC_DEFUN([_AM_OUTPUT_DEPENDENCY_COMMANDS],
 # -----------------------------
 # This macro should only be invoked once -- use via AC_REQUIRE.
 #
-# This code is only required when automatic dependency tracking
-# is enabled.  FIXME.  This creates each '.P' file that we will
-# need in order to bootstrap the dependency handling code.
+# This code is only required when automatic dependency tracking is enabled.
+# This creates each '.Po' and '.Plo' makefile fragment that we'll need in
+# order to bootstrap the dependency handling code.
 AC_DEFUN([AM_OUTPUT_DEPENDENCY_COMMANDS],
 [AC_CONFIG_COMMANDS([depfiles],
      [test x"$AMDEP_TRUE" != x"" || _AM_OUTPUT_DEPENDENCY_COMMANDS],
-     [AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir"])
-])
+     [AMDEP_TRUE="$AMDEP_TRUE" MAKE="${MAKE-make}"])])
 
 # Do all the work for Automake.                             -*- Autoconf -*-
 
-# Copyright (C) 1996-2013 Free Software Foundation, Inc.
+# Copyright (C) 1996-2021 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -457,6 +448,10 @@ m4_defn([AC_PROG_CC])
 # release and drop the old call support.
 AC_DEFUN([AM_INIT_AUTOMAKE],
 [AC_PREREQ([2.65])dnl
+m4_ifdef([_$0_ALREADY_INIT],
+  [m4_fatal([$0 expanded multiple times
+]m4_defn([_$0_ALREADY_INIT]))],
+  [m4_define([_$0_ALREADY_INIT], m4_expansion_stack)])dnl
 dnl Autoconf wants to disallow AM_ names.  We explicitly allow
 dnl the ones we care about.
 m4_pattern_allow([^AM_[A-Z]+FLAGS$])dnl
@@ -493,7 +488,7 @@ m4_ifval([$3], [_AM_SET_OPTION([no-define])])dnl
 [_AM_SET_OPTIONS([$1])dnl
 dnl Diagnose old-style AC_INIT with new-style AM_AUTOMAKE_INIT.
 m4_if(
-  m4_ifdef([AC_PACKAGE_NAME], [ok]):m4_ifdef([AC_PACKAGE_VERSION], [ok]),
+  m4_ifset([AC_PACKAGE_NAME], [ok]):m4_ifset([AC_PACKAGE_VERSION], [ok]),
   [ok:ok],,
   [m4_fatal([AC_INIT should be called with package and version arguments])])dnl
  AC_SUBST([PACKAGE], ['AC_PACKAGE_TARNAME'])dnl
@@ -516,11 +511,11 @@ AC_REQUIRE([AM_PROG_INSTALL_STRIP])dnl
 AC_REQUIRE([AC_PROG_MKDIR_P])dnl
 # For better backward compatibility.  To be removed once Automake 1.9.x
 # dies out for good.  For more background, see:
-# <http://lists.gnu.org/archive/html/automake/2012-07/msg00001.html>
-# <http://lists.gnu.org/archive/html/automake/2012-07/msg00014.html>
+# <https://lists.gnu.org/archive/html/automake/2012-07/msg00001.html>
+# <https://lists.gnu.org/archive/html/automake/2012-07/msg00014.html>
 AC_SUBST([mkdir_p], ['$(MKDIR_P)'])
-# We need awk for the "check" target.  The system "awk" is bad on
-# some platforms.
+# We need awk for the "check" target (and possibly the TAP driver).  The
+# system "awk" is bad on some platforms.
 AC_REQUIRE([AC_PROG_AWK])dnl
 AC_REQUIRE([AC_PROG_MAKE_SET])dnl
 AC_REQUIRE([AM_SET_LEADING_DOT])dnl
@@ -545,6 +540,20 @@ AC_PROVIDE_IFELSE([AC_PROG_OBJCXX],
 		  [m4_define([AC_PROG_OBJCXX],
 			     m4_defn([AC_PROG_OBJCXX])[_AM_DEPENDENCIES([OBJCXX])])])dnl
 ])
+# Variables for tags utilities; see am/tags.am
+if test -z "$CTAGS"; then
+  CTAGS=ctags
+fi
+AC_SUBST([CTAGS])
+if test -z "$ETAGS"; then
+  ETAGS=etags
+fi
+AC_SUBST([ETAGS])
+if test -z "$CSCOPE"; then
+  CSCOPE=cscope
+fi
+AC_SUBST([CSCOPE])
+
 AC_REQUIRE([AM_SILENT_RULES])dnl
 dnl The testsuite driver may need to know about EXEEXT, so add the
 dnl 'am__EXEEXT' conditional if _AM_COMPILER_EXEEXT was seen.  This
@@ -584,7 +593,7 @@ END
 Aborting the configuration process, to ensure you take notice of the issue.
 
 You can download and install GNU coreutils to get an 'rm' implementation
-that behaves properly: <http://www.gnu.org/software/coreutils/>.
+that behaves properly: <https://www.gnu.org/software/coreutils/>.
 
 If you want to complete the configuration process using your problematic
 'rm' anyway, export the environment variable ACCEPT_INFERIOR_RM_PROGRAM
@@ -593,7 +602,11 @@ to "yes", and re-run configure.
 END
     AC_MSG_ERROR([Your 'rm' program is bad, sorry.])
   fi
-fi])
+fi
+dnl The trailing newline in this macro's definition is deliberate, for
+dnl backward compatibility and to allow trailing 'dnl'-style comments
+dnl after the AM_INIT_AUTOMAKE invocation. See automake bug#16841.
+])
 
 dnl Hook into '_AC_COMPILER_EXEEXT' early to learn its expansion.  Do not
 dnl add the conditional right here, as _AC_COMPILER_EXEEXT may be further
@@ -622,7 +635,7 @@ for _am_header in $config_headers :; do
 done
 echo "timestamp for $_am_arg" >`AS_DIRNAME(["$_am_arg"])`/stamp-h[]$_am_stamp_count])
 
-# Copyright (C) 2001-2013 Free Software Foundation, Inc.
+# Copyright (C) 2001-2021 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -633,7 +646,7 @@ echo "timestamp for $_am_arg" >`AS_DIRNAME(["$_am_arg"])`/stamp-h[]$_am_stamp_co
 # Define $install_sh.
 AC_DEFUN([AM_PROG_INSTALL_SH],
 [AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
-if test x"${install_sh}" != xset; then
+if test x"${install_sh+set}" != xset; then
   case $am_aux_dir in
   *\ * | *\	*)
     install_sh="\${SHELL} '$am_aux_dir/install-sh'" ;;
@@ -643,7 +656,7 @@ if test x"${install_sh}" != xset; then
 fi
 AC_SUBST([install_sh])])
 
-# Copyright (C) 2003-2013 Free Software Foundation, Inc.
+# Copyright (C) 2003-2021 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -665,7 +678,7 @@ AC_SUBST([am__leading_dot])])
 # Add --enable-maintainer-mode option to configure.         -*- Autoconf -*-
 # From Jim Meyering
 
-# Copyright (C) 1996-2013 Free Software Foundation, Inc.
+# Copyright (C) 1996-2021 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -700,7 +713,7 @@ AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
 
 # Check to see how 'make' treats includes.	            -*- Autoconf -*-
 
-# Copyright (C) 2001-2013 Free Software Foundation, Inc.
+# Copyright (C) 2001-2021 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -708,49 +721,42 @@ AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
 
 # AM_MAKE_INCLUDE()
 # -----------------
-# Check to see how make treats includes.
+# Check whether make has an 'include' directive that can support all
+# the idioms we need for our automatic dependency tracking code.
 AC_DEFUN([AM_MAKE_INCLUDE],
-[am_make=${MAKE-make}
-cat > confinc << 'END'
+[AC_MSG_CHECKING([whether ${MAKE-make} supports the include directive])
+cat > confinc.mk << 'END'
 am__doit:
-	@echo this is the am__doit target
+	@echo this is the am__doit target >confinc.out
 .PHONY: am__doit
 END
-# If we don't find an include directive, just comment out the code.
-AC_MSG_CHECKING([for style of include used by $am_make])
 am__include="#"
 am__quote=
-_am_result=none
-# First try GNU make style include.
-echo "include confinc" > confmf
-# Ignore all kinds of additional output from 'make'.
-case `$am_make -s -f confmf 2> /dev/null` in #(
-*the\ am__doit\ target*)
-  am__include=include
-  am__quote=
-  _am_result=GNU
-  ;;
-esac
-# Now try BSD make style include.
-if test "$am__include" = "#"; then
-   echo '.include "confinc"' > confmf
-   case `$am_make -s -f confmf 2> /dev/null` in #(
-   *the\ am__doit\ target*)
-     am__include=.include
-     am__quote="\""
-     _am_result=BSD
-     ;;
-   esac
-fi
-AC_SUBST([am__include])
-AC_SUBST([am__quote])
-AC_MSG_RESULT([$_am_result])
-rm -f confinc confmf
-])
+# BSD make does it like this.
+echo '.include "confinc.mk" # ignored' > confmf.BSD
+# Other make implementations (GNU, Solaris 10, AIX) do it like this.
+echo 'include confinc.mk # ignored' > confmf.GNU
+_am_result=no
+for s in GNU BSD; do
+  AM_RUN_LOG([${MAKE-make} -f confmf.$s && cat confinc.out])
+  AS_CASE([$?:`cat confinc.out 2>/dev/null`],
+      ['0:this is the am__doit target'],
+      [AS_CASE([$s],
+          [BSD], [am__include='.include' am__quote='"'],
+          [am__include='include' am__quote=''])])
+  if test "$am__include" != "#"; then
+    _am_result="yes ($s style)"
+    break
+  fi
+done
+rm -f confinc.* confmf.*
+AC_MSG_RESULT([${_am_result}])
+AC_SUBST([am__include])])
+AC_SUBST([am__quote])])
 
 # Fake the existence of programs that GNU maintainers use.  -*- Autoconf -*-
 
-# Copyright (C) 1997-2013 Free Software Foundation, Inc.
+# Copyright (C) 1997-2021 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -771,12 +777,7 @@ AC_DEFUN([AM_MISSING_HAS_RUN],
 [AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
 AC_REQUIRE_AUX_FILE([missing])dnl
 if test x"${MISSING+set}" != xset; then
-  case $am_aux_dir in
-  *\ * | *\	*)
-    MISSING="\${SHELL} \"$am_aux_dir/missing\"" ;;
-  *)
-    MISSING="\${SHELL} $am_aux_dir/missing" ;;
-  esac
+  MISSING="\${SHELL} '$am_aux_dir/missing'"
 fi
 # Use eval to expand $SHELL
 if eval "$MISSING --is-lightweight"; then
@@ -789,7 +790,7 @@ fi
 
 # Helper functions for option handling.                     -*- Autoconf -*-
 
-# Copyright (C) 2001-2013 Free Software Foundation, Inc.
+# Copyright (C) 2001-2021 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -818,7 +819,7 @@ AC_DEFUN([_AM_SET_OPTIONS],
 AC_DEFUN([_AM_IF_OPTION],
 [m4_ifset(_AM_MANGLE_OPTION([$1]), [$2], [$3])])
 
-# Copyright (C) 1999-2013 Free Software Foundation, Inc.
+# Copyright (C) 1999-2021 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -865,7 +866,7 @@ AC_LANG_POP([C])])
 # For backward compatibility.
 AC_DEFUN_ONCE([AM_PROG_CC_C_O], [AC_REQUIRE([AC_PROG_CC])])
 
-# Copyright (C) 2001-2013 Free Software Foundation, Inc.
+# Copyright (C) 2001-2021 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -884,7 +885,7 @@ AC_DEFUN([AM_RUN_LOG],
 
 # Check to make sure that the build environment is sane.    -*- Autoconf -*-
 
-# Copyright (C) 1996-2013 Free Software Foundation, Inc.
+# Copyright (C) 1996-2021 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -965,7 +966,7 @@ AC_CONFIG_COMMANDS_PRE(
 rm -f conftest.file
 ])
 
-# Copyright (C) 2009-2013 Free Software Foundation, Inc.
+# Copyright (C) 2009-2021 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -1025,7 +1026,7 @@ AC_SUBST([AM_BACKSLASH])dnl
 _AM_SUBST_NOTMAKE([AM_BACKSLASH])dnl
 ])
 
-# Copyright (C) 2001-2013 Free Software Foundation, Inc.
+# Copyright (C) 2001-2021 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -1053,7 +1054,7 @@ fi
 INSTALL_STRIP_PROGRAM="\$(install_sh) -c -s"
 AC_SUBST([INSTALL_STRIP_PROGRAM])])
 
-# Copyright (C) 2006-2013 Free Software Foundation, Inc.
+# Copyright (C) 2006-2021 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -1072,7 +1073,7 @@ AC_DEFUN([AM_SUBST_NOTMAKE], [_AM_SUBST_NOTMAKE($@)])
 
 # Check how to create a tarball.                            -*- Autoconf -*-
 
-# Copyright (C) 2004-2013 Free Software Foundation, Inc.
+# Copyright (C) 2004-2021 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,

algo-gate-api.c

@@ -15,8 +15,6 @@
 #include <stdbool.h>
 #include <memory.h>
 #include <unistd.h>
-#include <openssl/sha.h>
-#include "miner.h"
 #include "algo-gate-api.h"
 
 // Define null and standard functions.
@@ -77,181 +75,328 @@ void algo_not_tested()
   applog(LOG_WARNING,"and bad things may happen. Use at your own risk.");
 }
 
+void four_way_not_tested()
+{
+  applog( LOG_WARNING,"Algo %s has not been tested using 4way. It may not", algo_names[opt_algo] );
+  applog( LOG_WARNING,"work or may be slower. Please report your results.");
+}
+
 void algo_not_implemented()
 {
   applog(LOG_ERR,"Algo %s has not been Implemented.",algo_names[opt_algo]);
 }
 
 // default null functions
-
+// deprecated, use generic as default
 int null_scanhash()
 {
    applog(LOG_WARNING,"SWERR: undefined scanhash function in algo_gate");
    return 0;
 }
 
-void null_hash()
+// Default generic scanhash can be used in many cases. Not to be used when
+// prehashing can be done or when byte swapping the data can be avoided.
+int scanhash_generic( struct work *work, uint32_t max_nonce,
+                      uint64_t *hashes_done, struct thr_info *mythr )
+{
+   uint32_t edata[20] __attribute__((aligned(64)));
+   uint32_t hash[8] __attribute__((aligned(64)));
+   uint32_t *pdata = work->data;
+   uint32_t *ptarget = work->target;
+   const uint32_t first_nonce = pdata[19];
+   const uint32_t last_nonce = max_nonce - 1;
+   uint32_t n = first_nonce;
+   const int thr_id = mythr->id;
+   const bool bench = opt_benchmark;
+
+   v128_bswap32_80( edata, pdata );
+   do
+   {
+      edata[19] = n;
+      if ( likely( algo_gate.hash( hash, edata, thr_id ) ) )
+      if ( unlikely( valid_hash( hash, ptarget ) && !bench ) )
+      {
+         pdata[19] = bswap_32( n );
+         submit_solution( work, hash, mythr );
+      }
+      n++;
+   } while ( n < last_nonce && !work_restart[thr_id].restart );
+   *hashes_done = n - first_nonce;
+   pdata[19] = n;
+   return 0;
+}
+
+#if defined(__AVX2__)
+
+//int scanhash_4way_64_64( struct work *work, uint32_t max_nonce,
+//                      uint64_t *hashes_done, struct thr_info *mythr )
+
+//int scanhash_4way_64_640( struct work *work, uint32_t max_nonce,
+//                      uint64_t *hashes_done, struct thr_info *mythr )
+
+int scanhash_4way_64in_32out( struct work *work, uint32_t max_nonce,
+                      uint64_t *hashes_done, struct thr_info *mythr )
+{
+   uint32_t hash32[8*4] __attribute__ ((aligned (64)));
+   uint32_t vdata[20*4] __attribute__ ((aligned (64)));
+   uint32_t lane_hash[8] __attribute__ ((aligned (64)));
+   uint32_t *hash32_d7 = &(hash32[ 7*4 ]);
+   uint32_t *pdata = work->data;
+   const uint32_t *ptarget = work->target;
+   const uint32_t first_nonce = pdata[19];
+   const uint32_t last_nonce = max_nonce - 4;
+   __m256i  *noncev = (__m256i*)vdata + 9;
+   uint32_t n = first_nonce;
+   const int thr_id = mythr->id;
+   const uint32_t targ32_d7 = ptarget[7];
+   const bool bench = opt_benchmark;
+
+   mm256_bswap32_intrlv80_4x64( vdata, pdata );
+   // overwrite byte swapped nonce with original byte order for proper
+   // incrementing. The nonce only needs to byte swapped if it is to be
+   // sumbitted.
+   *noncev = mm256_intrlv_blend_32(
+                   _mm256_set_epi32( n+3, 0, n+2, 0, n+1, 0, n, 0 ), *noncev );
+   do
+   {
+      if ( likely( algo_gate.hash( hash32, vdata, thr_id ) ) )
+      for ( int lane = 0; lane < 4; lane++ )
+      if ( unlikely( hash32_d7[ lane ] <= targ32_d7 && !bench ) )
+      {
+         extr_lane_4x32( lane_hash, hash32, lane, 256 );
+         if ( valid_hash( lane_hash, ptarget ) )
+         {
+            pdata[19] = bswap_32( n + lane );
+            submit_solution( work, lane_hash, mythr );
+         }
+      }
+      *noncev = _mm256_add_epi32( *noncev,
+                                  _mm256_set1_epi64x( 0x0000000400000000 ) );
+      n += 4;
+   } while ( likely( ( n <= last_nonce ) && !work_restart[thr_id].restart ) );
+   pdata[19] = n;
+   *hashes_done = n - first_nonce;
+   return 0;
+}
+
+//int scanhash_8way_32_32( struct work *work, uint32_t max_nonce,
+//                      uint64_t *hashes_done, struct thr_info *mythr )
+
+#endif
+
+#if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
+
+//int scanhash_8way_64_64( struct work *work, uint32_t max_nonce,
+//                      uint64_t *hashes_done, struct thr_info *mythr )
+
+//int scanhash_8way_64_640( struct work *work, uint32_t max_nonce,
+//                      uint64_t *hashes_done, struct thr_info *mythr )
+
+int scanhash_8way_64in_32out( struct work *work, uint32_t max_nonce,
+                      uint64_t *hashes_done, struct thr_info *mythr )
+{
+   uint32_t hash32[8*8] __attribute__ ((aligned (128)));
+   uint32_t vdata[20*8] __attribute__ ((aligned (64)));
+   uint32_t lane_hash[8] __attribute__ ((aligned (64)));
+   uint32_t *hash32_d7 = &(hash32[7*8]);
+   uint32_t *pdata = work->data;
+   const uint32_t *ptarget = work->target;
+   const uint32_t first_nonce = pdata[19];
+   const uint32_t last_nonce = max_nonce - 8;
+   __m512i  *noncev = (__m512i*)vdata + 9;
+   uint32_t n = first_nonce;
+   const int thr_id = mythr->id;
+   const uint32_t targ32_d7 = ptarget[7];
+   const bool bench = opt_benchmark;
+
+   mm512_bswap32_intrlv80_8x64( vdata, pdata );
+   *noncev = mm512_intrlv_blend_32(
+              _mm512_set_epi32( n+7, 0, n+6, 0, n+5, 0, n+4, 0,
+                                n+3, 0, n+2, 0, n+1, 0, n,   0 ), *noncev );
+   do
+   {
+      if ( likely( algo_gate.hash( hash32, vdata, thr_id ) ) )
+      for ( int lane = 0; lane < 8; lane++ )
+      if ( unlikely( ( hash32_d7[ lane ] <= targ32_d7 ) && !bench ) )
+      {
+         extr_lane_8x32( lane_hash, hash32, lane, 256 );
+         if ( likely( valid_hash( lane_hash, ptarget ) ) )
+         {
+            pdata[19] = bswap_32( n + lane );
+            submit_solution( work, lane_hash, mythr );
+         }
+      }
+      *noncev = _mm512_add_epi32( *noncev,
+                                  _mm512_set1_epi64( 0x0000000800000000 ) );
+      n += 8;
+   } while ( likely( ( n < last_nonce ) && !work_restart[thr_id].restart ) );
+   pdata[19] = n;
+   *hashes_done = n - first_nonce;
+   return 0;
+}
+
+//int scanhash_16way_32_32( struct work *work, uint32_t max_nonce,
+//                      uint64_t *hashes_done, struct thr_info *mythr )
+
+#endif
+
+
+
+int null_hash()
 {
    applog(LOG_WARNING,"SWERR: null_hash unsafe null function");
-};
-void null_hash_suw()
-{
-  applog(LOG_WARNING,"SWERR: null_hash_suw unsafe null function");
+   return 0;
 };
 
-void init_algo_gate( algo_gate_t* gate )
+static void init_algo_gate( algo_gate_t* gate )
 {
    gate->miner_thread_init       = (void*)&return_true;
-   gate->scanhash                = (void*)&null_scanhash;
+   gate->scanhash                = (void*)&scanhash_generic;
    gate->hash                    = (void*)&null_hash;
-   gate->hash_suw                = (void*)&null_hash_suw;
    gate->get_new_work            = (void*)&std_get_new_work;
-   gate->get_nonceptr            = (void*)&std_get_nonceptr;
-   gate->display_extra_data      = (void*)&do_nothing;
-   gate->wait_for_diff           = (void*)&std_wait_for_diff;
-   gate->get_max64               = (void*)&get_max64_0x1fffffLL;
-   gate->gen_merkle_root         = (void*)&sha256d_gen_merkle_root;
-   gate->stratum_gen_work        = (void*)&std_stratum_gen_work;
-   gate->build_stratum_request   = (void*)&std_le_build_stratum_request;
-   gate->set_target              = (void*)&std_set_target;
    gate->work_decode             = (void*)&std_le_work_decode;
+   gate->decode_extra_data       = (void*)&do_nothing;
+   gate->gen_merkle_root         = (void*)&sha256d_gen_merkle_root;
+   gate->build_stratum_request   = (void*)&std_le_build_stratum_request;
+   gate->malloc_txs_request      = (void*)&std_malloc_txs_request;
    gate->submit_getwork_result   = (void*)&std_le_submit_getwork_result;
+   gate->build_block_header      = (void*)&std_build_block_header;
    gate->build_extraheader       = (void*)&std_build_extraheader;
    gate->set_work_data_endian    = (void*)&do_nothing;
-   gate->calc_network_diff       = (void*)&std_calc_network_diff;
-   gate->ready_to_mine           = (void*)&std_ready_to_mine;
    gate->resync_threads          = (void*)&do_nothing;
    gate->do_this_thread          = (void*)&return_true;
    gate->longpoll_rpc_call       = (void*)&std_longpoll_rpc_call;
-   gate->stratum_handle_response = (void*)&std_stratum_handle_response;
-   gate->optimizations           = SSE2_OPT;
+   gate->get_work_data_size      = (void*)&std_get_work_data_size;
+   gate->optimizations           = EMPTY_SET;
    gate->ntime_index             = STD_NTIME_INDEX;
    gate->nbits_index             = STD_NBITS_INDEX;
    gate->nonce_index             = STD_NONCE_INDEX;
-   gate->work_data_size          = STD_WORK_DATA_SIZE;
    gate->work_cmp_size           = STD_WORK_CMP_SIZE;
 }
 
-// called by each thread that uses the gate
-bool register_algo_gate( int algo, algo_gate_t *gate )
-{
-   if ( NULL == gate )
-   {
-     applog(LOG_ERR,"FAIL: algo_gate registration failed, NULL gate\n");
-     return false;
-   }
-
-   init_algo_gate( gate );
-
-   switch (algo)
-   {
-
-// Ignore warnings for not yet defined register fucntions
+// Ignore warnings for not yet defined register functions
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wimplicit-function-declaration"
 
-     case ALGO_ARGON2:       register_argon2_algo      ( gate ); break;
-     case ALGO_AXIOM:        register_axiom_algo       ( gate ); break;
-     case ALGO_BASTION:      register_bastion_algo     ( gate ); break;
-     case ALGO_BLAKE:        register_blake_algo       ( gate ); break;
-     case ALGO_BLAKECOIN:    register_blakecoin_algo   ( gate ); break;
-//     case ALGO_BLAKE2B:      register_blake2b_algo    ( gate ); break;
-     case ALGO_BLAKE2S:      register_blake2s_algo     ( gate ); break;
-     case ALGO_C11:          register_c11_algo         ( gate ); break;
-     case ALGO_CRYPTOLIGHT:  register_cryptolight_algo ( gate ); break;
-     case ALGO_CRYPTONIGHT:  register_cryptonight_algo ( gate ); break;
-     case ALGO_DECRED:       register_decred_algo      ( gate ); break;
-     case ALGO_DEEP:         register_deep_algo        ( gate ); break;
-     case ALGO_DMD_GR:       register_dmd_gr_algo      ( gate ); break;
-     case ALGO_DROP:         register_drop_algo        ( gate ); break;
-     case ALGO_FRESH:        register_fresh_algo       ( gate ); break;
-     case ALGO_GROESTL:      register_groestl_algo     ( gate ); break;
-     case ALGO_HEAVY:        register_heavy_algo       ( gate ); break;
-     case ALGO_HMQ1725:      register_hmq1725_algo     ( gate ); break;
-     case ALGO_HODL:         register_hodl_algo        ( gate ); break;
-     case ALGO_JHA:          register_jha_algo         ( gate ); break;
-     case ALGO_KECCAK:       register_keccak_algo      ( gate ); break;
-     case ALGO_LBRY:         register_lbry_algo        ( gate ); break;
-     case ALGO_LUFFA:        register_luffa_algo       ( gate ); break;
-     case ALGO_LYRA2RE:      register_lyra2re_algo     ( gate ); break;
-     case ALGO_LYRA2REV2:    register_lyra2rev2_algo   ( gate ); break;
-     case ALGO_LYRA2Z:       register_zcoin_algo       ( gate ); break;
-     case ALGO_LYRA2Z330:    register_lyra2z330_algo   ( gate ); break;
-     case ALGO_M7M:          register_m7m_algo         ( gate ); break;
-     case ALGO_MYR_GR:       register_myriad_algo      ( gate ); break;
-     case ALGO_NEOSCRYPT:    register_neoscrypt_algo   ( gate ); break;
-     case ALGO_NIST5:        register_nist5_algo       ( gate ); break;
-     case ALGO_PENTABLAKE:   register_pentablake_algo  ( gate ); break;
-     case ALGO_PHI1612:      register_phi1612_algo     ( gate ); break;
-     case ALGO_PLUCK:        register_pluck_algo       ( gate ); break;
-     case ALGO_POLYTIMOS:    register_polytimos_algo   ( gate ); break;
-     case ALGO_QUARK:        register_quark_algo       ( gate ); break;
-     case ALGO_QUBIT:        register_qubit_algo       ( gate ); break;
-     case ALGO_SCRYPT:       register_scrypt_algo      ( gate ); break;
-     case ALGO_SCRYPTJANE:   register_scryptjane_algo  ( gate ); break;
-     case ALGO_SHA256D:      register_sha256d_algo     ( gate ); break;
-     case ALGO_SHA256T:      register_sha256t_algo     ( gate ); break;
-     case ALGO_SHAVITE3:     register_shavite_algo     ( gate ); break;
-     case ALGO_SKEIN:        register_skein_algo       ( gate ); break;
-     case ALGO_SKEIN2:       register_skein2_algo      ( gate ); break;
-     case ALGO_SKUNK:        register_skunk_algo       ( gate ); break;
-     case ALGO_TIMETRAVEL:   register_timetravel_algo  ( gate ); break;
-     case ALGO_TIMETRAVEL10: register_timetravel10_algo( gate ); break;
-     case ALGO_TRIBUS:       register_tribus_algo      ( gate ); break;
-     case ALGO_VANILLA:      register_vanilla_algo     ( gate ); break;
-     case ALGO_VELTOR:       register_veltor_algo      ( gate ); break;
-     case ALGO_WHIRLPOOL:    register_whirlpool_algo   ( gate ); break;
-     case ALGO_WHIRLPOOLX:   register_whirlpoolx_algo  ( gate ); break;
-     case ALGO_X11:          register_x11_algo         ( gate ); break;
-     case ALGO_X11EVO:       register_x11evo_algo      ( gate ); break;
-     case ALGO_X11GOST:      register_sib_algo         ( gate ); break;
-     case ALGO_X13:          register_x13_algo         ( gate ); break;
-     case ALGO_X13SM3:       register_x13sm3_algo      ( gate ); break;
-     case ALGO_X14:          register_x14_algo         ( gate ); break;
-     case ALGO_X15:          register_x15_algo         ( gate ); break;
-     case ALGO_X17:          register_x17_algo         ( gate ); break;
-     case ALGO_XEVAN:        register_xevan_algo       ( gate ); break;
-     case ALGO_YESCRYPT:     register_yescrypt_algo    ( gate ); break;
-     case ALGO_YESCRYPTR16:  register_yescryptr16_algo ( gate ); break;
-     case ALGO_ZR5:          register_zr5_algo         ( gate ); break;
+// Called once by main
+bool register_algo_gate( int algo, algo_gate_t *gate )
+{
+  bool rc = false;
 
-// restore warnings
-#pragma GCC diagnostic pop
-
-    default:
-        applog(LOG_ERR,"FAIL: algo_gate registration failed, unknown algo %s.\n", algo_names[opt_algo] );
-        return false;
-   } // switch
-
-  // ensure required functions were defined.
-  if (  gate->scanhash == (void*)&null_scanhash )
+  if ( NULL == gate )
   {
-    applog(LOG_ERR, "FAIL: Required algo_gate functions undefined\n");
+    applog(LOG_ERR,"FAIL: algo_gate registration failed, NULL gate\n");
+    return false;
+  }
+
+  init_algo_gate( gate );
+
+  switch ( algo )
+  {
+    case ALGO_ALLIUM:       rc = register_allium_algo        ( gate ); break;
+    case ALGO_ANIME:        rc = register_anime_algo         ( gate ); break;
+    case ALGO_ARGON2D250:   rc = register_argon2d_crds_algo  ( gate ); break;
+    case ALGO_ARGON2D500:   rc = register_argon2d_dyn_algo   ( gate ); break;
+    case ALGO_ARGON2D4096:  rc = register_argon2d4096_algo   ( gate ); break;
+    case ALGO_AXIOM:        rc = register_axiom_algo         ( gate ); break;
+    case ALGO_BLAKE:        rc = register_blake_algo         ( gate ); break;
+    case ALGO_BLAKE2B:      rc = register_blake2b_algo       ( gate ); break;
+    case ALGO_BLAKE2S:      rc = register_blake2s_algo       ( gate ); break;
+    case ALGO_BLAKECOIN:    rc = register_blakecoin_algo     ( gate ); break;
+    case ALGO_BMW512:       rc = register_bmw512_algo        ( gate ); break;
+    case ALGO_C11:          rc = register_c11_algo           ( gate ); break;
+    case ALGO_DEEP:         rc = register_deep_algo          ( gate ); break;
+    case ALGO_DMD_GR:       rc = register_dmd_gr_algo        ( gate ); break;
+    case ALGO_GROESTL:      rc = register_groestl_algo       ( gate ); break;
+    case ALGO_HEX:          rc = register_hex_algo           ( gate ); break;
+    case ALGO_HMQ1725:      rc = register_hmq1725_algo       ( gate ); break;
+    case ALGO_JHA:          rc = register_jha_algo           ( gate ); break;
+    case ALGO_KECCAK:       rc = register_keccak_algo        ( gate ); break;
+    case ALGO_KECCAKC:      rc = register_keccakc_algo       ( gate ); break;
+    case ALGO_LBRY:         rc = register_lbry_algo          ( gate ); break;
+    case ALGO_LYRA2H:       rc = register_lyra2h_algo        ( gate ); break;
+    case ALGO_LYRA2RE:      rc = register_lyra2re_algo       ( gate ); break;
+    case ALGO_LYRA2REV2:    rc = register_lyra2rev2_algo     ( gate ); break;
+    case ALGO_LYRA2REV3:    rc = register_lyra2rev3_algo     ( gate ); break;
+    case ALGO_LYRA2Z:       rc = register_lyra2z_algo        ( gate ); break;
+    case ALGO_LYRA2Z330:    rc = register_lyra2z330_algo     ( gate ); break;
+    case ALGO_M7M:          rc = register_m7m_algo           ( gate ); break;
+    case ALGO_MINOTAUR:     rc = register_minotaur_algo      ( gate ); break;
+    case ALGO_MINOTAURX:    rc = register_minotaur_algo      ( gate ); break;
+    case ALGO_MYR_GR:       rc = register_myriad_algo        ( gate ); break;
+    case ALGO_NEOSCRYPT:    rc = register_neoscrypt_algo     ( gate ); break;
+    case ALGO_NIST5:        rc = register_nist5_algo         ( gate ); break;
+    case ALGO_PENTABLAKE:   rc = register_pentablake_algo    ( gate ); break;
+    case ALGO_PHI1612:      rc = register_phi1612_algo       ( gate ); break;
+    case ALGO_PHI2:         rc = register_phi2_algo          ( gate ); break;
+    case ALGO_POLYTIMOS:    rc = register_polytimos_algo     ( gate ); break;
+    case ALGO_POWER2B:      rc = register_power2b_algo       ( gate ); break;
+    case ALGO_QUARK:        rc = register_quark_algo         ( gate ); break;
+    case ALGO_QUBIT:        rc = register_qubit_algo         ( gate ); break;
+    case ALGO_SCRYPT:       rc = register_scrypt_algo        ( gate ); break;
+    case ALGO_SHA256D:      rc = register_sha256d_algo       ( gate ); break;
+    case ALGO_SHA256DT:     rc = register_sha256dt_algo      ( gate ); break;
+    case ALGO_SHA256Q:      rc = register_sha256q_algo       ( gate ); break;
+    case ALGO_SHA256T:      rc = register_sha256t_algo       ( gate ); break;
+    case ALGO_SHA3D:        rc = register_sha3d_algo         ( gate ); break;
+    case ALGO_SHA512256D:   rc = register_sha512256d_algo    ( gate ); break;
+    case ALGO_SHAVITE3:     rc = register_shavite_algo       ( gate ); break;
+    case ALGO_SKEIN:        rc = register_skein_algo         ( gate ); break;
+    case ALGO_SKEIN2:       rc = register_skein2_algo        ( gate ); break;
+    case ALGO_SKUNK:        rc = register_skunk_algo         ( gate ); break;
+    case ALGO_SONOA:        rc = register_sonoa_algo         ( gate ); break;
+    case ALGO_TIMETRAVEL:   rc = register_timetravel_algo    ( gate ); break;
+    case ALGO_TIMETRAVEL10: rc = register_timetravel10_algo  ( gate ); break;
+    case ALGO_TRIBUS:       rc = register_tribus_algo        ( gate ); break;
+    case ALGO_VANILLA:      rc = register_vanilla_algo       ( gate ); break;
+    case ALGO_VELTOR:       rc = register_veltor_algo        ( gate ); break;
+    case ALGO_VERTHASH:     rc = register_verthash_algo      ( gate ); break;
+    case ALGO_WHIRLPOOL:    rc = register_whirlpool_algo     ( gate ); break;
+    case ALGO_WHIRLPOOLX:   rc = register_whirlpoolx_algo    ( gate ); break;
+    case ALGO_X11:          rc = register_x11_algo           ( gate ); break;
+    case ALGO_X11EVO:       rc = register_x11evo_algo        ( gate ); break;
+    case ALGO_X11GOST:      rc = register_x11gost_algo       ( gate ); break;
+    case ALGO_X12:          rc = register_x12_algo           ( gate ); break;
+    case ALGO_X13:          rc = register_x13_algo           ( gate ); break;
+    case ALGO_X13BCD:       rc = register_x13bcd_algo        ( gate ); break;
+    case ALGO_X13SM3:       rc = register_x13sm3_algo        ( gate ); break;
+    case ALGO_X14:          rc = register_x14_algo           ( gate ); break;
+    case ALGO_X15:          rc = register_x15_algo           ( gate ); break;
+    case ALGO_X16R:         rc = register_x16r_algo          ( gate ); break;
+    case ALGO_X16RV2:       rc = register_x16rv2_algo        ( gate ); break;
+    case ALGO_X16RT:        rc = register_x16rt_algo         ( gate ); break;
+    case ALGO_X16RT_VEIL:   rc = register_x16rt_veil_algo    ( gate ); break;
+    case ALGO_X16S:         rc = register_x16s_algo          ( gate ); break;
+    case ALGO_X17:          rc = register_x17_algo           ( gate ); break;
+    case ALGO_X21S:         rc = register_x21s_algo          ( gate ); break;
+    case ALGO_X22I:         rc = register_x22i_algo          ( gate ); break;
+    case ALGO_X25X:         rc = register_x25x_algo          ( gate ); break;
+    case ALGO_XEVAN:        rc = register_xevan_algo         ( gate ); break;
+    case ALGO_YESCRYPT:     rc = register_yescrypt_algo      ( gate ); break;
+    case ALGO_YESCRYPTR8:   rc = register_yescryptr8_algo    ( gate ); break;
+    case ALGO_YESCRYPTR8G:  rc = register_yescryptr8g_algo   ( gate ); break;
+    case ALGO_YESCRYPTR16:  rc = register_yescryptr16_algo   ( gate ); break;
+    case ALGO_YESCRYPTR32:  rc = register_yescryptr32_algo   ( gate ); break;
+    case ALGO_YESPOWER:     rc = register_yespower_algo      ( gate ); break;
+    case ALGO_YESPOWERR16:  rc = register_yespowerr16_algo   ( gate ); break;
+    case ALGO_YESPOWER_B2B: rc = register_yespower_b2b_algo  ( gate ); break;
+    case ALGO_ZR5:          rc = register_zr5_algo           ( gate ); break;
+   default:
+      applog(LOG_ERR,"BUG: unregistered algorithm %s.\n", algo_names[opt_algo] );
+      return false;
+  } // switch
+
+  if ( !rc )
+  {
+    applog(LOG_ERR, "FAIL: %s algorithm failed to initialize\n", algo_names[opt_algo] );
     return false;
   }
   return true;
 }
 
-// override std defaults with jr2 defaults
-bool register_json_rpc2( algo_gate_t *gate )
-{
-  gate->wait_for_diff           = (void*)&do_nothing;
-  gate->get_new_work            = (void*)&jr2_get_new_work;
-  gate->get_nonceptr            = (void*)&jr2_get_nonceptr;
-  gate->stratum_gen_work        = (void*)&jr2_stratum_gen_work;
-  gate->build_stratum_request   = (void*)&jr2_build_stratum_request;
-  gate->submit_getwork_result   = (void*)&jr2_submit_getwork_result;
-  gate->longpoll_rpc_call       = (void*)&jr2_longpoll_rpc_call;
-  gate->work_decode             = (void*)&jr2_work_decode;
-  gate->stratum_handle_response = (void*)&jr2_stratum_handle_response;
-  gate->nonce_index             = JR2_NONCE_INDEX;
-  jsonrpc_2 = true;   // still needed
-  opt_extranonce = false;
-//  have_gbt = false;
-  return true;
- }
+// restore warnings
+#pragma GCC diagnostic pop
 
-// run the alternate hash function for a specific algo
 void exec_hash_function( int algo, void *output, const void *pdata )
 {
   algo_gate_t gate;   
@@ -271,41 +416,39 @@ void exec_hash_function( int algo, void *output, const void *pdata )
 const char* const algo_alias_map[][2] =
 {
 //   alias                proper
-  { "bitcore",           "timetravel10" },
-  { "blake256r8",        "blakecoin"    },
-  { "blake256r8vnl",     "vanilla"      },
-  { "blake256r14",       "blake"        },
-  { "blake256r14dcr",    "decred"       },
-  { "cryptonote",        "cryptonight"  },
-  { "cryptonight-light", "cryptolight"  },
-  { "diamond",           "dmd-gr"       },
-  { "droplp",            "drop"         },
-  { "espers",            "hmq1725"      },
-  { "flax",              "c11"          },
-  { "hsr",               "x13sm3"       },
-  { "jackpot",           "jha"          },
-  { "jane",              "scryptjane"   }, 
-  { "lyra2",             "lyra2re"      },
-  { "lyra2v2",           "lyra2rev2"    },
-  { "lyra2zoin",         "lyra2z330"    },
-  { "myriad",            "myr-gr"       },
-  { "neo",               "neoscrypt"    },
-  { "phi",               "phi1612"      },
-//  { "sia",               "blake2b"      },
-  { "sib",               "x11gost"      },
-  { "timetravel8",       "timetravel"   },
-  { "yes",               "yescrypt"     },
-  { "ziftr",             "zr5"          },
-  { "yenten",            "yescryptr16"  },
-  { "yescryptr8",        "yescrypt"     },
-  { "zcoin",             "lyra2z"       },
-  { "zoin",              "lyra2z330"    },
-  { NULL,                NULL           }   
+  { "argon2d-dyn",       "argon2d500"     },
+  { "argon2d-uis",       "argon2d4096"    },
+  { "bcd",               "x13bcd"         },
+  { "bitcore",           "timetravel10"   },
+  { "bitzeny",           "yescryptr8"     },
+  { "blake256r8",        "blakecoin"      },
+  { "blake256r8vnl",     "vanilla"        },
+  { "blake256r14",       "blake"          },
+  { "diamond",           "dmd-gr"         },
+  { "espers",            "hmq1725"        },
+  { "flax",              "c11"            },
+  { "hsr",               "x13sm3"         },
+  { "jackpot",           "jha"            },
+  { "lyra2",             "lyra2re"        },
+  { "lyra2v2",           "lyra2rev2"      },
+  { "lyra2v3",           "lyra2rev3"      },
+  { "myrgr",             "myr-gr"         },
+  { "myriad",            "myr-gr"         },
+  { "neo",               "neoscrypt"      },
+  { "phi",               "phi1612"        },
+  { "scryptn2",          "scrypt:1048576" },
+  { "sib",               "x11gost"        },
+  { "timetravel8",       "timetravel"     },
+  { "veil",              "x16rt-veil"     },
+  { "x16r-hex",          "hex"            },
+  { "yenten",            "yescryptr16"    },
+  { "ziftr",             "zr5"            },
+  { NULL,                NULL             }   
 };
 
-// if arg is a valid alias for a known algo it is updated with the proper name.
-// No validation of the algo or alias is done, It is the responsinility of the
-// calling function to validate the algo after return.
+// if arg is a valid alias for a known algo it is updated with the proper
+// name. No validation of the algo or alias is done, It is the responsinility
+// of the calling function to validate the algo after return.
 void get_algo_alias( char** algo_or_alias )
 {
   int i;
@@ -313,8 +456,11 @@ void get_algo_alias( char** algo_or_alias )
     if ( !strcasecmp( *algo_or_alias, algo_alias_map[i][ ALIAS ] ) )
     {
       // found valid alias, return proper name
-      *algo_or_alias = (char* const)( algo_alias_map[i][ PROPER ] );
+      *algo_or_alias = (char*)( algo_alias_map[i][ PROPER ] );
       return;
     }
 }
 
+#undef ALIAS
+#undef PROPER
+

algo-gate-api.h

@@ -1,8 +1,11 @@
+#ifndef __ALGO_GATE_API_H__
+#define __ALGO_GATE_API_H__ 1
+
 #include <stdlib.h>
 #include <stdbool.h>
 #include <stdint.h>
-
 #include "miner.h"
+#include "simd-utils.h"
 
 /////////////////////////////
 ////
@@ -35,7 +38,7 @@
 //    6. Determine if other non existant functions are required.
 //    That is determined by the need to add code in cpu-miner.c
 //    that applies only to the new algo. That is forbidden. All
-//    algo specific code must be in theh algo's file.
+//    algo specific code must be in the algo's file.
 //
 //    7. If new functions need to be added to the gate add the type
 //    to the structure, declare a null instance in this file and define
@@ -48,10 +51,10 @@
 //    instances as they are defined by default, or unsafe functions that
 //    are not needed by the algo.
 //
-//    9. Add an case entry to the switch/case in function register_gate
+//    9. Add a case entry to the switch/case in function register_gate
 //    in file algo-gate-api.c for the new algo.
 //
-//    10 If a new function type was defined add an entry to ini talgo_gate
+//    10 If a new function type was defined add an entry to init algo_gate
 //    to initialize the new function to its null instance described in step 7.
 //
 //    11. If the new algo has aliases add them to the alias array in
@@ -75,7 +78,7 @@
 
 // my hack at creating a set data type using bit masks. Set inclusion,
 // exclusion union and intersection operations are provided for convenience. In // some cases it may be desireable to use boolean algebra directly on the
-// data to perfomr set operations. Sets can be represented as single
+// data to perform set operations. Sets can be represented as single
 // elements, a bitwise OR of multiple elements, a bitwise OR of multiple
 // set variables or constants, or combinations of the above.
 // Examples:
@@ -85,12 +88,23 @@
 
 typedef  uint32_t set_t;
 
-#define EMPTY_SET 0
-#define SSE2_OPT  1
-#define AES_OPT   2
-#define AVX_OPT   4
-#define AVX2_OPT  8
-#define SHA_OPT  16
+#define EMPTY_SET        0
+#define SSE2_OPT         1         // parity with NEON
+#define SSSE3_OPT        1 <<  1   // Intel Core2
+#define SSE41_OPT        1 <<  2
+#define SSE42_OPT        1 <<  3
+#define AVX_OPT          1 <<  4   // Intel Sandybridge
+#define AVX2_OPT         1 <<  5   // Intel Haswell, AMD Zen1
+#define AVX512_OPT       1 <<  6   // Skylake-X, Zen4 (AVX512[F,VL,DQ,BW])
+#define AES_OPT          1 <<  7   // Intel Westmere, AArch64
+#define VAES_OPT         1 <<  8   // Icelake, Zen3
+#define SHA_OPT          1 <<  9   // Zen1, Icelake, AArch64 
+#define SHA512_OPT       1 << 10   // AArch64 
+#define NEON_OPT         1 << 11   // AArch64 
+
+// AVX10 does not have explicit algo features:
+//  AVX10_512 is compatible with AVX512 + VAES
+//  AVX10_256 is compatible with AVX2 + VAES
 
 // return set containing all elements from sets a & b
 inline set_t set_union ( set_t a, set_t b ) { return a | b; }
@@ -106,42 +120,62 @@ inline bool set_excl ( set_t a, set_t b ) { return (a & b) == 0; }
 
 typedef struct
 {
-// mandatory functions, must be overwritten
-int ( *scanhash ) ( int, struct work*, uint32_t, uint64_t* );
+// Mandatory functions, one of these is mandatory. If a generic scanhash
+// is used a custom target hash function must be registered, with a custom
+// scanhash the target hash function can be called directly and doesn't need
+// to be registered with the gate. 
+int ( *scanhash ) ( struct work*, uint32_t, uint64_t*, struct thr_info* );
 
-// optional unsafe, must be overwritten if algo uses function
-void ( *hash )     ( void*, const void*, uint32_t ) ;
-void ( *hash_suw ) ( void*, const void* );
+int ( *hash )     ( void*, const void*, int );
 
 //optional, safe to use default in most cases
-bool ( *miner_thread_init )      ( int );
-void ( *stratum_gen_work )       ( struct stratum_ctx*, struct work* );
-void ( *get_new_work )           ( struct work*, struct work*, int, uint32_t*,
-                                   bool );
-uint32_t *( *get_nonceptr )      ( uint32_t* );
-void ( *display_extra_data )     ( struct work*, uint64_t* );
-void ( *wait_for_diff )          ( struct stratum_ctx* );
-int64_t ( *get_max64 )           ();
-bool ( *work_decode )            ( const json_t*, struct work* );
-void ( *set_target)              ( struct work*, double );
-bool ( *submit_getwork_result )  ( CURL*, struct work* );
-void ( *gen_merkle_root )        ( char*, struct stratum_ctx* );
-void ( *build_extraheader )      ( struct work*, struct stratum_ctx* );
-void ( *build_stratum_request )  ( char*, struct work*, struct stratum_ctx* );
-void ( *set_work_data_endian )   ( struct work* );
-double ( *calc_network_diff )    ( struct work* );
-bool ( *ready_to_mine )          ( struct work*, struct stratum_ctx*, int );
-void ( *resync_threads )         ( struct work* );
-bool ( *do_this_thread )         ( int );
-json_t* (*longpoll_rpc_call)     ( CURL*, int*, char* );
-bool ( *stratum_handle_response )( json_t* );
+
+// Called once by each miner thread to allocate thread local buffers and
+// other initialization specific to miner threads.
+bool ( *miner_thread_init )     ( int );
+
+// Get thread local copy of blockheader with unique nonce.
+void ( *get_new_work )          ( struct work*, struct work*, int, uint32_t* );
+
+// Decode getwork blockheader
+bool ( *work_decode )           ( struct work* );
+
+// Extra getwork data
+void ( *decode_extra_data )     ( struct work*, uint64_t* );
+
+bool ( *submit_getwork_result ) ( CURL*, struct work* );
+
+void ( *gen_merkle_root )       ( char*, struct stratum_ctx* );
+
+// Increment extranonce
+void ( *build_extraheader )     ( struct work*, struct stratum_ctx* );
+
+void ( *build_block_header )    ( struct work*, uint32_t, uint32_t*,
+	                                uint32_t*,   uint32_t, uint32_t,
+                                   unsigned char* );
+
+// Build mining.submit message
+void ( *build_stratum_request ) ( char*, struct work*, struct stratum_ctx* );
+
+char* ( *malloc_txs_request )   ( struct work* );
+
+// Big endian or little endian
+void ( *set_work_data_endian )  ( struct work* );
+
+// Diverge mining threads
+bool ( *do_this_thread )        ( int );
+
+// After do_this_thread
+void ( *resync_threads )        ( int, struct work* );
+
+json_t* ( *longpoll_rpc_call )  ( CURL*, int*, char* );
+
 set_t optimizations;
+int  ( *get_work_data_size )     ();
 int  ntime_index;
 int  nbits_index;
 int  nonce_index;            // use with caution, see warning below
-int  work_data_size;
 int  work_cmp_size;
-
 } algo_gate_t;
 
 extern algo_gate_t algo_gate;
@@ -156,7 +190,7 @@ bool return_false();
 void *return_null();
 void algo_not_tested();
 void algo_not_implemented();
-
+void four_way_not_tested();
 
 // Warning: algo_gate.nonce_index should only be used in targetted code
 // due to different behaviours by different targets. The JR2 index uses an
@@ -173,75 +207,98 @@ void algo_not_implemented();
 #define STD_WORK_DATA_SIZE 128
 #define STD_WORK_CMP_SIZE 76
 
-#define JR2_NONCE_INDEX 39  // 8 bit offset
+//#define JR2_NONCE_INDEX 39  // 8 bit offset
 
 // These indexes are only used with JSON RPC2 and are not gated.
-#define JR2_WORK_CMP_INDEX_2 43
-#define JR2_WORK_CMP_SIZE_2 33
+//#define JR2_WORK_CMP_INDEX_2 43
+//#define JR2_WORK_CMP_SIZE_2 33
 
-// allways returns failure
+// deprecated, use generic instead
 int null_scanhash();
 
+// Default generic, may be used in many cases.
+// N-way is more complicated, requires many different implementations
+// depending on architecture, input format, and output format.
+// Naming convention is scanhash_[N]way_[input format]in_[output format]out
+// N = number of lanes
+// input/output format:
+//    32: 32 bit interleaved parallel lanes
+//    64: 64 bit interleaved parallel lanes
+//    640: input only, not interleaved, contiguous serial 640 bit lanes.
+//    256: output only, not interleaved, contiguous serial 256 bit lanes.
+
+int scanhash_generic( struct work *work, uint32_t max_nonce,
+                      uint64_t *hashes_done, struct thr_info *mythr );
+
+#if defined(__AVX2__)
+
+//int scanhash_4way_64in_64out( struct work *work, uint32_t max_nonce,
+//                      uint64_t *hashes_done, struct thr_info *mythr );
+
+//int scanhash_4way_64in_256out( struct work *work, uint32_t max_nonce,
+//                      uint64_t *hashes_done, struct thr_info *mythr );
+
+int scanhash_4way_64in_32out( struct work *work, uint32_t max_nonce,
+                      uint64_t *hashes_done, struct thr_info *mythr );
+
+//int scanhash_8way_32in_32out( struct work *work, uint32_t max_nonce,
+//                      uint64_t *hashes_done, struct thr_info *mythr );
+
+#endif
+
+#if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
+
+//int scanhash_8way_64in_64out( struct work *work, uint32_t max_nonce,
+//                      uint64_t *hashes_done, struct thr_info *mythr );
+
+//int scanhash_8way_64in_256out( struct work *work, uint32_t max_nonce,
+//                      uint64_t *hashes_done, struct thr_info *mythr );
+
+int scanhash_8way_64in_32out( struct work *work, uint32_t max_nonce,
+                      uint64_t *hashes_done, struct thr_info *mythr );
+
+//int scanhash_16way_32in_32out( struct work *work, uint32_t max_nonce,
+//                      uint64_t *hashes_done, struct thr_info *mythr );
+
+#endif
+
 // displays warning
-void null_hash    ();
-void null_hash_suw();
+int null_hash();
 
 // optional safe targets, default listed first unless noted.
 
-void std_wait_for_diff();
-
-uint32_t *std_get_nonceptr( uint32_t *work_data );
-uint32_t *jr2_get_nonceptr( uint32_t *work_data );
-
 void std_get_new_work( struct work *work, struct work *g_work, int thr_id,
-                       uint32_t* end_nonce_ptr, bool clean_job );
-void jr2_get_new_work( struct work *work, struct work *g_work, int thr_id,
                        uint32_t* end_nonce_ptr );
 
-void std_stratum_gen_work( struct stratum_ctx *sctx, struct work *work );
-void jr2_stratum_gen_work( struct stratum_ctx *sctx, struct work *work );
-
 void sha256d_gen_merkle_root( char *merkle_root, struct stratum_ctx *sctx );
-void SHA256_gen_merkle_root ( char *merkle_root, struct stratum_ctx *sctx );
+void sha256_gen_merkle_root ( char *merkle_root, struct stratum_ctx *sctx );
+// OpenSSL sha256 deprecated
+//void SHA256_gen_merkle_root ( char *merkle_root, struct stratum_ctx *sctx );
 
-// pick your favorite or define your own
-int64_t get_max64_0x1fffffLL(); // default
-int64_t get_max64_0x40LL();
-int64_t get_max64_0x3ffff();
-int64_t get_max64_0x3fffffLL();
-int64_t get_max64_0x1ffff();
-int64_t get_max64_0xffffLL();
-
-void std_set_target   ( struct work *work, double job_diff );
-void scrypt_set_target( struct work *work, double job_diff );
-
-bool std_le_work_decode( const json_t *val, struct work *work );
-bool std_be_work_decode( const json_t *val, struct work *work );
-bool jr2_work_decode( const json_t *val, struct work *work );
+bool std_le_work_decode( struct work *work );
+bool std_be_work_decode( struct work *work );
 
 bool std_le_submit_getwork_result( CURL *curl, struct work *work );
 bool std_be_submit_getwork_result( CURL *curl, struct work *work );
-bool jr2_submit_getwork_result( CURL *curl, struct work *work );
 
 void std_le_build_stratum_request( char *req, struct work *work );
 void std_be_build_stratum_request( char *req, struct work *work );
-void jr2_build_stratum_request   ( char *req, struct work *work );
 
-// Default is do_nothing (assumed LE)
+char* std_malloc_txs_request( struct work *work );
+
+// Default is do_nothing, little endian is assumed
 void set_work_data_big_endian( struct work *work );
 
-double std_calc_network_diff( struct work *work );
+void std_build_block_header( struct work* g_work, uint32_t version,
+	                          uint32_t *prevhash,  uint32_t *merkle_root,
+   	                       uint32_t ntime,      uint32_t nbits,
+                             unsigned char *final_sapling_hash );
 
 void std_build_extraheader( struct work *work, struct stratum_ctx *sctx );
 
 json_t* std_longpoll_rpc_call( CURL *curl, int *err, char *lp_url );
-json_t* jr2_longpoll_rpc_call( CURL *curl, int *err );
 
-bool std_stratum_handle_response( json_t *val );
-bool jr2_stratum_handle_response( json_t *val );
-
-bool std_ready_to_mine( struct work* work, struct stratum_ctx* stratum,
-                        int thr_id );
+int std_get_work_data_size();
 
 // Gate admin functions
 
@@ -249,19 +306,17 @@ bool std_ready_to_mine( struct work* work, struct stratum_ctx* stratum,
 // by calling the algo's register function.
 bool register_algo_gate( int algo, algo_gate_t *gate );
 
-// Override any default gate functions that are applicable and do any other
-// algo-specific initialization.
+// Called by algos to verride any default gate functions that are applicable
+// and do any other algo-specific initialization.
 // The register functions for all the algos can be declared here to reduce
 // compiler warnings but that's just more work for devs adding new algos.
 bool register_algo( algo_gate_t *gate );
 
-// Overrides a common set of functions used by RPC2 and other RPC2-specific
-// init. Called by algo's register function before initializing algo-specific
-// functions and data.
-bool register_json_rpc2( algo_gate_t *gate );
-
 // use this to call the hash function of an algo directly, ie util.c test.
 void exec_hash_function( int algo, void *output, const void *pdata );
 
-void get_algo_alias( char** algo_or_alias );
+// Validate a string as a known algo and alias, updates arg to proper
+// algo name if valid alias, NULL if invalid alias or algo.
+void get_algo_alias( char **algo_or_alias );
 
+#endif

algo/argon2/ar2/ar2-scrypt-jane.c

@@ -1,249 +0,0 @@
-/*
-	scrypt-jane by Andrew M, https://github.com/floodyberry/scrypt-jane
-
-	Public Domain or MIT License, whichever is easier
-*/
-
-#include <string.h>
-
-#if defined( _WINDOWS )
-#if !defined( QT_GUI )
-extern "C" {
-#endif
-#endif
-
-#include "ar2-scrypt-jane.h"
-
-#include "sj/scrypt-jane-portable.h"
-#include "sj/scrypt-jane-hash.h"
-#include "sj/scrypt-jane-romix.h"
-#include "sj/scrypt-jane-test-vectors.h"
-
-#define scrypt_maxNfactor 30  /* (1 << (30 + 1)) = ~2 billion */
-#if (SCRYPT_BLOCK_BYTES == 64)
-#define scrypt_r_32kb 8 /* (1 << 8) = 256 * 2 blocks in a chunk * 64 bytes = Max of 32kb in a chunk */
-#elif (SCRYPT_BLOCK_BYTES == 128)
-#define scrypt_r_32kb 7 /* (1 << 7) = 128 * 2 blocks in a chunk * 128 bytes = Max of 32kb in a chunk */
-#elif (SCRYPT_BLOCK_BYTES == 256)
-#define scrypt_r_32kb 6 /* (1 << 6) = 64 * 2 blocks in a chunk * 256 bytes = Max of 32kb in a chunk */
-#elif (SCRYPT_BLOCK_BYTES == 512)
-#define scrypt_r_32kb 5 /* (1 << 5) = 32 * 2 blocks in a chunk * 512 bytes = Max of 32kb in a chunk */
-#endif
-#define scrypt_maxrfactor scrypt_r_32kb /* 32kb */
-#define scrypt_maxpfactor 25  /* (1 << 25) = ~33 million */
-
-#include <stdio.h>
-//#include <malloc.h>
-
-static void NORETURN
-scrypt_fatal_error_default(const char *msg) {
-	fprintf(stderr, "%s\n", msg);
-	exit(1);
-}
-
-static scrypt_fatal_errorfn scrypt_fatal_error = scrypt_fatal_error_default;
-
-void scrypt_set_fatal_error(scrypt_fatal_errorfn fn) {
-	scrypt_fatal_error = fn;
-}
-
-static int scrypt_power_on_self_test(void)
-{
-	const scrypt_test_setting *t;
-	uint8_t test_digest[64];
-	uint32_t i;
-	int res = 7, scrypt_valid;
-
-	if (!scrypt_test_mix()) {
-#if !defined(SCRYPT_TEST)
-		scrypt_fatal_error("scrypt: mix function power-on-self-test failed");
-#endif
-		res &= ~1;
-	}
-
-	if (!scrypt_test_hash()) {
-#if !defined(SCRYPT_TEST)
-		scrypt_fatal_error("scrypt: hash function power-on-self-test failed");
-#endif
-		res &= ~2;
-	}
-
-	for (i = 0, scrypt_valid = 1; post_settings[i].pw; i++) {
-		t = post_settings + i;
-		scrypt((uint8_t *)t->pw, strlen(t->pw), (uint8_t *)t->salt, strlen(t->salt), t->Nfactor, t->rfactor, t->pfactor, test_digest, sizeof(test_digest));
-		scrypt_valid &= scrypt_verify(post_vectors[i], test_digest, sizeof(test_digest));
-	}
-
-	if (!scrypt_valid) {
-#if !defined(SCRYPT_TEST)
-		scrypt_fatal_error("scrypt: scrypt power-on-self-test failed");
-#endif
-		res &= ~4;
-	}
-
-	return res;
-}
-
-typedef struct scrypt_aligned_alloc_t {
-	uint8_t *mem, *ptr;
-} scrypt_aligned_alloc;
-
-#ifdef SCRYPT_TEST_SPEED
-
-static uint8_t *mem_base = (uint8_t *)0;
-static size_t mem_bump = 0;
-
-/* allocations are assumed to be multiples of 64 bytes and total allocations not to exceed ~1.01gb */
-static scrypt_aligned_alloc scrypt_alloc(uint64_t size)
-{
-	scrypt_aligned_alloc aa;
-	if (!mem_base) {
-		mem_base = (uint8_t *)malloc((1024 * 1024 * 1024) + (1024 * 1024) + (SCRYPT_BLOCK_BYTES - 1));
-		if (!mem_base)
-			scrypt_fatal_error("scrypt: out of memory");
-		mem_base = (uint8_t *)(((size_t)mem_base + (SCRYPT_BLOCK_BYTES - 1)) & ~(SCRYPT_BLOCK_BYTES - 1));
-	}
-	aa.mem = mem_base + mem_bump;
-	aa.ptr = aa.mem;
-	mem_bump += (size_t)size;
-	return aa;
-}
-
-static void scrypt_free(scrypt_aligned_alloc *aa) {
-	mem_bump = 0;
-}
-
-#else
-
-static scrypt_aligned_alloc scrypt_alloc(uint64_t size)
-{
-	static const size_t max_alloc = (size_t)-1;
-	scrypt_aligned_alloc aa;
-	size += (SCRYPT_BLOCK_BYTES - 1);
-	if (size > max_alloc)
-		scrypt_fatal_error("scrypt: not enough address space on this CPU to allocate required memory");
-	aa.mem = (uint8_t *)malloc((size_t)size);
-	aa.ptr = (uint8_t *)(((size_t)aa.mem + (SCRYPT_BLOCK_BYTES - 1)) & ~(SCRYPT_BLOCK_BYTES - 1));
-	if (!aa.mem)
-		scrypt_fatal_error("scrypt: out of memory");
-	return aa;
-}
-
-static void scrypt_free(scrypt_aligned_alloc *aa)
-{
-	free(aa->mem);
-}
-
-#endif /* SCRYPT_TEST_SPEED */
-
-
-void scrypt(const uint8_t *password, size_t password_len, const uint8_t *salt, size_t salt_len,
-	uint8_t Nfactor, uint8_t rfactor, uint8_t pfactor, uint8_t *out, size_t bytes)
-{
-	scrypt_aligned_alloc YX, V;
-	uint8_t *X, *Y;
-	uint32_t N, r, p, chunk_bytes, i;
-
-#if !defined(SCRYPT_CHOOSE_COMPILETIME)
-	scrypt_ROMixfn scrypt_ROMix = scrypt_getROMix();
-#endif
-
-#if !defined(SCRYPT_TEST)
-	static int power_on_self_test = 0;
-	if (!power_on_self_test) {
-		power_on_self_test = 1;
-		if (!scrypt_power_on_self_test())
-			scrypt_fatal_error("scrypt: power on self test failed");
-	}
-#endif
-
-	if (Nfactor > scrypt_maxNfactor)
-		scrypt_fatal_error("scrypt: N out of range");
-	if (rfactor > scrypt_maxrfactor)
-		scrypt_fatal_error("scrypt: r out of range");
-	if (pfactor > scrypt_maxpfactor)
-		scrypt_fatal_error("scrypt: p out of range");
-
-	N = (1 << (Nfactor + 1));
-	r = (1 << rfactor);
-	p = (1 << pfactor);
-
-	chunk_bytes = SCRYPT_BLOCK_BYTES * r * 2;
-	V = scrypt_alloc((uint64_t)N * chunk_bytes);
-	YX = scrypt_alloc((p + 1) * chunk_bytes);
-
-	/* 1: X = PBKDF2(password, salt) */
-	Y = YX.ptr;
-	X = Y + chunk_bytes;
-	scrypt_pbkdf2(password, password_len, salt, salt_len, 1, X, chunk_bytes * p);
-
-	/* 2: X = ROMix(X) */
-	for (i = 0; i < p; i++)
-		scrypt_ROMix((scrypt_mix_word_t *)(X + (chunk_bytes * i)), (scrypt_mix_word_t *)Y, (scrypt_mix_word_t *)V.ptr, N, r);
-
-	/* 3: Out = PBKDF2(password, X) */
-	scrypt_pbkdf2(password, password_len, X, chunk_bytes * p, 1, out, bytes);
-
-	scrypt_ensure_zero(YX.ptr, (p + 1) * chunk_bytes);
-
-	scrypt_free(&V);
-	scrypt_free(&YX);
-}
-
-#define Nfactor 8
-#define rfactor 0
-#define pfactor 0
-#if (SCRYPT_BLOCK_BYTES == 64)
-#define chunk_bytes 128
-#elif (SCRYPT_BLOCK_BYTES == 128)
-#define chunk_bytes 256
-#elif (SCRYPT_BLOCK_BYTES == 256)
-#define chunk_bytes 512
-#elif (SCRYPT_BLOCK_BYTES == 512)
-#define chunk_bytes 1024
-#endif
-
-void my_scrypt(const uint8_t *password, size_t password_len, const uint8_t *salt, size_t salt_len, uint8_t *out)
-{
-	scrypt_aligned_alloc YX, V;
-	uint8_t *X, *Y;
-
-#if !defined(SCRYPT_CHOOSE_COMPILETIME)
-	scrypt_ROMixfn scrypt_ROMix = scrypt_getROMix();
-#endif
-
-/*
-#if !defined(SCRYPT_TEST)
-	static int power_on_self_test = 0;
-	if (!power_on_self_test) {
-		power_on_self_test = 1;
-		if (!scrypt_power_on_self_test())
-			scrypt_fatal_error("scrypt: power on self test failed");
-	}
-#endif
-*/
-	V = scrypt_alloc((uint64_t)512 * chunk_bytes);
-	YX = scrypt_alloc(2 * chunk_bytes);
-
-	/* 1: X = PBKDF2(password, salt) */
-	Y = YX.ptr;
-	X = Y + chunk_bytes;
-	scrypt_pbkdf2(password, password_len, salt, salt_len, 1, X, chunk_bytes);
-
-	/* 2: X = ROMix(X) */
-	scrypt_ROMix((scrypt_mix_word_t *)X, (scrypt_mix_word_t *)Y, (scrypt_mix_word_t *)V.ptr, 512, 1);
-
-	/* 3: Out = PBKDF2(password, X) */
-	scrypt_pbkdf2(password, password_len, X, chunk_bytes, 1, out, 32);
-
-	scrypt_ensure_zero(YX.ptr, 2 * chunk_bytes);
-
-	scrypt_free(&V);
-	scrypt_free(&YX);
-}
-
-#if defined( _WINDOWS )
-#if !defined( QT_GUI )
-} /* extern "C" */
-#endif
-#endif

algo/argon2/ar2/ar2-scrypt-jane.h

@@ -1,35 +0,0 @@
-#ifndef AR2_SCRYPT_JANE_H
-#define AR2_SCRYPT_JANE_H
-
-#ifdef _MSC_VER
-#undef SCRYPT_CHOOSE_COMPILETIME
-#endif
-//#define SCRYPT_TEST
-#define SCRYPT_SKEIN512
-#define SCRYPT_SALSA64
-
-/*
-	Nfactor: Increases CPU & Memory Hardness
-	N = (1 << (Nfactor + 1)): How many times to mix a chunk and how many temporary chunks are used
-
-	rfactor: Increases Memory Hardness
-	r = (1 << rfactor): How large a chunk is
-
-	pfactor: Increases CPU Hardness
-	p = (1 << pfactor): Number of times to mix the main chunk
-
-	A block is the basic mixing unit (salsa/chacha block = 64 bytes)
-	A chunk is (2 * r) blocks
-
-	~Memory used = (N + 2) * ((2 * r) * block size)
-*/
-
-#include <stdlib.h>
-#include <stdint.h>
-
-typedef void (*scrypt_fatal_errorfn)(const char *msg);
-void scrypt_set_fatal_error(scrypt_fatal_errorfn fn);
-
-void scrypt(const unsigned char *password, size_t password_len, const unsigned char *salt, size_t salt_len, unsigned char Nfactor, unsigned char rfactor, unsigned char pfactor, unsigned char *out, size_t bytes);
-void my_scrypt(const uint8_t *password, size_t password_len, const uint8_t *salt, size_t salt_len, uint8_t *out);
-#endif /* AR2_SCRYPT_JANE_H */

algo/argon2/ar2/argon2.c

@@ -1,284 +0,0 @@
-/*
- * Argon2 source code package
- *
- * Written by Daniel Dinu and Dmitry Khovratovich, 2015
- *
- * This work is licensed under a Creative Commons CC0 1.0 License/Waiver.
- *
- * 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 <limits.h>
-
-#include "argon2.h"
-#include "cores.h"
-
-/* Error messages */
-static const char *Argon2_ErrorMessage[] = {
-	/*{ARGON2_OK, */ "OK",
-	/*},
-
-	{ARGON2_OUTPUT_PTR_NULL, */ "Output pointer is NULL",
-	/*},
-
-{ARGON2_OUTPUT_TOO_SHORT, */ "Output is too short",
-	/*},
-{ARGON2_OUTPUT_TOO_LONG, */ "Output is too long",
-	/*},
-
-{ARGON2_PWD_TOO_SHORT, */ "Password is too short",
-	/*},
-{ARGON2_PWD_TOO_LONG, */ "Password is too long",
-	/*},
-
-{ARGON2_SALT_TOO_SHORT, */ "Salt is too short",
-	/*},
-{ARGON2_SALT_TOO_LONG, */ "Salt is too long",
-	/*},
-
-{ARGON2_AD_TOO_SHORT, */ "Associated data is too short",
-	/*},
-{ARGON2_AD_TOO_LONG, */ "Associated date is too long",
-	/*},
-
-{ARGON2_SECRET_TOO_SHORT, */ "Secret is too short",
-	/*},
-{ARGON2_SECRET_TOO_LONG, */ "Secret is too long",
-	/*},
-
-{ARGON2_TIME_TOO_SMALL, */ "Time cost is too small",
-	/*},
-{ARGON2_TIME_TOO_LARGE, */ "Time cost is too large",
-	/*},
-
-{ARGON2_MEMORY_TOO_LITTLE, */ "Memory cost is too small",
-	/*},
-{ARGON2_MEMORY_TOO_MUCH, */ "Memory cost is too large",
-	/*},
-
-{ARGON2_LANES_TOO_FEW, */ "Too few lanes",
-	/*},
-{ARGON2_LANES_TOO_MANY, */ "Too many lanes",
-	/*},
-
-{ARGON2_PWD_PTR_MISMATCH, */ "Password pointer is NULL, but password length is not 0",
-	/*},
-{ARGON2_SALT_PTR_MISMATCH, */ "Salt pointer is NULL, but salt length is not 0",
-	/*},
-{ARGON2_SECRET_PTR_MISMATCH, */ "Secret pointer is NULL, but secret length is not 0",
-	/*},
-{ARGON2_AD_PTR_MISMATCH, */ "Associated data pointer is NULL, but ad length is not 0",
-	/*},
-
-{ARGON2_MEMORY_ALLOCATION_ERROR, */ "Memory allocation error",
-	/*},
-
-{ARGON2_FREE_MEMORY_CBK_NULL, */ "The free memory callback is NULL",
-	/*},
-{ARGON2_ALLOCATE_MEMORY_CBK_NULL, */ "The allocate memory callback is NULL",
-	/*},
-
-{ARGON2_INCORRECT_PARAMETER, */ "Argon2_Context context is NULL",
-	/*},
-{ARGON2_INCORRECT_TYPE, */ "There is no such version of Argon2",
-	/*},
-
-{ARGON2_OUT_PTR_MISMATCH, */ "Output pointer mismatch",
-	/*},
-
-{ARGON2_THREADS_TOO_FEW, */ "Not enough threads",
-	/*},
-{ARGON2_THREADS_TOO_MANY, */ "Too many threads",
-	/*},
-{ARGON2_MISSING_ARGS, */ "Missing arguments", /*},*/
-};
-
-int argon2d(argon2_context *context) { return argon2_core(context, Argon2_d); }
-
-int argon2i(argon2_context *context) { return argon2_core(context, Argon2_i); }
-
-int verify_d(argon2_context *context, const char *hash)
-{
-	int result;
-	/*if (0 == context->outlen || NULL == hash) {
-		return ARGON2_OUT_PTR_MISMATCH;
-	}*/
-
-	result = argon2_core(context, Argon2_d);
-
-	if (ARGON2_OK != result) {
-		return result;
-	}
-
-	return 0 == memcmp(hash, context->out, 32);
-}
-
-const char *error_message(int error_code)
-{
-	enum {
-		/* Make sure---at compile time---that the enum size matches the array
-		   size */
-		ERROR_STRING_CHECK =
-			1 /
-			!!((sizeof(Argon2_ErrorMessage) / sizeof(Argon2_ErrorMessage[0])) ==
-			   ARGON2_ERROR_CODES_LENGTH)
-	};
-	if (error_code < ARGON2_ERROR_CODES_LENGTH) {
-		return Argon2_ErrorMessage[(argon2_error_codes)error_code];
-	}
-	return "Unknown error code.";
-}
-
-/* encoding/decoding helpers */
-
-/*
- * Some macros for constant-time comparisons. These work over values in
- * the 0..255 range. Returned value is 0x00 on "false", 0xFF on "true".
- */
-#define EQ(x, y) ((((0U - ((unsigned)(x) ^ (unsigned)(y))) >> 8) & 0xFF) ^ 0xFF)
-#define GT(x, y) ((((unsigned)(y) - (unsigned)(x)) >> 8) & 0xFF)
-#define GE(x, y) (GT(y, x) ^ 0xFF)
-#define LT(x, y) GT(y, x)
-#define LE(x, y) GE(y, x)
-
-/*
- * Convert value x (0..63) to corresponding Base64 character.
- */
-static int b64_byte_to_char(unsigned x) {
-//static inline int b64_byte_to_char(unsigned x) {
-	return (LT(x, 26) & (x + 'A')) |
-		   (GE(x, 26) & LT(x, 52) & (x + ('a' - 26))) |
-		   (GE(x, 52) & LT(x, 62) & (x + ('0' - 52))) | (EQ(x, 62) & '+') |
-		   (EQ(x, 63) & '/');
-}
-
-/*
- * Convert some bytes to Base64. 'dst_len' is the length (in characters)
- * of the output buffer 'dst'; if that buffer is not large enough to
- * receive the result (including the terminating 0), then (size_t)-1
- * is returned. Otherwise, the zero-terminated Base64 string is written
- * in the buffer, and the output length (counted WITHOUT the terminating
- * zero) is returned.
- */
-static size_t to_base64(char *dst, size_t dst_len, const void *src)
-{
-	size_t olen;
-	const unsigned char *buf;
-	unsigned acc, acc_len;
-
-	olen = 43;
-	/*switch (32 % 3) {
-	case 2:
-		olen++;*/
-	/* fall through */
-	/*case 1:
-		olen += 2;
-		break;
-	}*/
-	if (dst_len <= olen) {
-		return (size_t)-1;
-	}
-	acc = 0;
-	acc_len = 0;
-	buf = (const unsigned char *)src;
-	size_t src_len = 32;
-	while (src_len-- > 0) {
-		acc = (acc << 8) + (*buf++);
-		acc_len += 8;
-		while (acc_len >= 6) {
-			acc_len -= 6;
-			*dst++ = b64_byte_to_char((acc >> acc_len) & 0x3F);
-		}
-	}
-	if (acc_len > 0) {
-		*dst++ = b64_byte_to_char((acc << (6 - acc_len)) & 0x3F);
-	}
-	*dst++ = 0;
-	return olen;
-}
-
-/* ==================================================================== */
-/*
- * Code specific to Argon2i.
- *
- * The code below applies the following format:
- *
- *  $argon2i$m=<num>,t=<num>,p=<num>[,keyid=<bin>][,data=<bin>][$<bin>[$<bin>]]
- *
- * where <num> is a decimal integer (positive, fits in an 'unsigned long')
- * and <bin> is Base64-encoded data (no '=' padding characters, no newline
- * or whitespace). The "keyid" is a binary identifier for a key (up to 8
- * bytes); "data" is associated data (up to 32 bytes). When the 'keyid'
- * (resp. the 'data') is empty, then it is ommitted from the output.
- *
- * The last two binary chunks (encoded in Base64) are, in that order,
- * the salt and the output. Both are optional, but you cannot have an
- * output without a salt. The binary salt length is between 8 and 48 bytes.
- * The output length is always exactly 32 bytes.
- */
-
-int encode_string(char *dst, size_t dst_len, argon2_context *ctx)
-{
-#define SS(str)                                                                \
-	do {                                                                       \
-		size_t pp_len = strlen(str);                                           \
-		if (pp_len >= dst_len) {                                               \
-			return 0;                                                          \
-		}                                                                      \
-		memcpy(dst, str, pp_len + 1);                                          \
-		dst += pp_len;                                                         \
-		dst_len -= pp_len;                                                     \
-	} while (0)
-
-#define SX(x)                                                                  \
-	do {                                                                       \
-		char tmp[30];                                                          \
-		sprintf(tmp, "%lu", (unsigned long)(x));                               \
-		SS(tmp);                                                               \
-	} while (0);
-
-#define SB(buf)                                                                \
-	do {                                                                       \
-		size_t sb_len = to_base64(dst, dst_len, buf);                          \
-		if (sb_len == (size_t)-1) {                                            \
-			return 0;                                                          \
-		}                                                                      \
-		dst += sb_len;                                                         \
-		dst_len -= sb_len;                                                     \
-	} while (0);
-
-	SS("$argon2i$m=");
-	SX(16);
-	SS(",t=");
-	SX(2);
-	SS(",p=");
-	SX(1);
-
-	/*if (ctx->adlen > 0) {
-		SS(",data=");
-		SB(ctx->ad, ctx->adlen);
-	}*/
-
-	/*if (ctx->saltlen == 0)
-		return 1;*/
-
-	SS("$");
-	SB(ctx->salt);
-
-	/*if (ctx->outlen32 == 0)
-		return 1;*/
-
-	SS("$");
-	SB(ctx->out);
-	return 1;
-
-#undef SS
-#undef SX
-#undef SB
-}

algo/argon2/ar2/argon2.h

@@ -1,292 +0,0 @@
-/*
- * Argon2 source code package
- *
- * Written by Daniel Dinu and Dmitry Khovratovich, 2015
- *
- * This work is licensed under a Creative Commons CC0 1.0 License/Waiver.
- *
- * 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/>.
- */
-#ifndef ARGON2_H
-#define ARGON2_H
-
-#include <stdint.h>
-#include <stddef.h>
-#include <limits.h>
-
-#if defined(__cplusplus)
-extern "C" {
-#endif
-
-/*************************Argon2 input parameter
- * restrictions**************************************************/
-
-/* Minimum and maximum number of lanes (degree of parallelism) */
-#define ARGON2_MIN_LANES UINT32_C(1)
-#define ARGON2_MAX_LANES UINT32_C(0xFFFFFF)
-
-/* Minimum and maximum number of threads */
-#define ARGON2_MIN_THREADS UINT32_C(1)
-#define ARGON2_MAX_THREADS UINT32_C(0xFFFFFF)
-
-/* Number of synchronization points between lanes per pass */
-#define ARGON2_SYNC_POINTS UINT32_C(4)
-
-/* Minimum and maximum digest size in bytes */
-#define ARGON2_MIN_OUTLEN UINT32_C(4)
-#define ARGON2_MAX_OUTLEN UINT32_C(0xFFFFFFFF)
-
-/* Minimum and maximum number of memory blocks (each of BLOCK_SIZE bytes) */
-#define ARGON2_MIN_MEMORY (2 * ARGON2_SYNC_POINTS) /* 2 blocks per slice */
-
-#define ARGON2_MIN(a, b) ((a) < (b) ? (a) : (b))
-/* Max memory size is half the addressing space, topping at 2^32 blocks (4 TB)
- */
-#define ARGON2_MAX_MEMORY_BITS                                                 \
-    ARGON2_MIN(UINT32_C(32), (sizeof(void *) * CHAR_BIT - 10 - 1))
-#define ARGON2_MAX_MEMORY                                                      \
-    ARGON2_MIN(UINT32_C(0xFFFFFFFF), UINT64_C(1) << ARGON2_MAX_MEMORY_BITS)
-
-/* Minimum and maximum number of passes */
-#define ARGON2_MIN_TIME UINT32_C(1)
-#define ARGON2_MAX_TIME UINT32_C(0xFFFFFFFF)
-
-/* Minimum and maximum password length in bytes */
-#define ARGON2_MIN_PWD_LENGTH UINT32_C(0)
-#define ARGON2_MAX_PWD_LENGTH UINT32_C(0xFFFFFFFF)
-
-/* Minimum and maximum associated data length in bytes */
-#define ARGON2_MIN_AD_LENGTH UINT32_C(0)
-#define ARGON2_MAX_AD_LENGTH UINT32_C(0xFFFFFFFF)
-
-/* Minimum and maximum salt length in bytes */
-#define ARGON2_MIN_SALT_LENGTH UINT32_C(8)
-#define ARGON2_MAX_SALT_LENGTH UINT32_C(0xFFFFFFFF)
-
-/* Minimum and maximum key length in bytes */
-#define ARGON2_MIN_SECRET UINT32_C(0)
-#define ARGON2_MAX_SECRET UINT32_C(0xFFFFFFFF)
-
-#define ARGON2_FLAG_CLEAR_PASSWORD (UINT32_C(1) << 0)
-#define ARGON2_FLAG_CLEAR_SECRET (UINT32_C(1) << 1)
-#define ARGON2_FLAG_CLEAR_MEMORY (UINT32_C(1) << 2)
-#define ARGON2_DEFAULT_FLAGS                                                   \
-    (ARGON2_FLAG_CLEAR_PASSWORD | ARGON2_FLAG_CLEAR_MEMORY)
-
-/* Error codes */
-typedef enum Argon2_ErrorCodes {
-    ARGON2_OK = 0,
-
-    ARGON2_OUTPUT_PTR_NULL = 1,
-
-    ARGON2_OUTPUT_TOO_SHORT = 2,
-    ARGON2_OUTPUT_TOO_LONG = 3,
-
-    ARGON2_PWD_TOO_SHORT = 4,
-    ARGON2_PWD_TOO_LONG = 5,
-
-    ARGON2_SALT_TOO_SHORT = 6,
-    ARGON2_SALT_TOO_LONG = 7,
-
-    ARGON2_AD_TOO_SHORT = 8,
-    ARGON2_AD_TOO_LONG = 9,
-
-    ARGON2_SECRET_TOO_SHORT = 10,
-    ARGON2_SECRET_TOO_LONG = 11,
-
-    ARGON2_TIME_TOO_SMALL = 12,
-    ARGON2_TIME_TOO_LARGE = 13,
-
-    ARGON2_MEMORY_TOO_LITTLE = 14,
-    ARGON2_MEMORY_TOO_MUCH = 15,
-
-    ARGON2_LANES_TOO_FEW = 16,
-    ARGON2_LANES_TOO_MANY = 17,
-
-    ARGON2_PWD_PTR_MISMATCH = 18,    /* NULL ptr with non-zero length */
-    ARGON2_SALT_PTR_MISMATCH = 19,   /* NULL ptr with non-zero length */
-    ARGON2_SECRET_PTR_MISMATCH = 20, /* NULL ptr with non-zero length */
-    ARGON2_AD_PTR_MISMATCH = 21,     /* NULL ptr with non-zero length */
-
-    ARGON2_MEMORY_ALLOCATION_ERROR = 22,
-
-    ARGON2_FREE_MEMORY_CBK_NULL = 23,
-    ARGON2_ALLOCATE_MEMORY_CBK_NULL = 24,
-
-    ARGON2_INCORRECT_PARAMETER = 25,
-    ARGON2_INCORRECT_TYPE = 26,
-
-    ARGON2_OUT_PTR_MISMATCH = 27,
-
-    ARGON2_THREADS_TOO_FEW = 28,
-    ARGON2_THREADS_TOO_MANY = 29,
-
-    ARGON2_MISSING_ARGS = 30,
-
-    ARGON2_ERROR_CODES_LENGTH /* Do NOT remove; Do NOT add error codes after
-                                 this
-                                 error code */
-} argon2_error_codes;
-
-/* Memory allocator types --- for external allocation */
-typedef int (*allocate_fptr)(uint8_t **memory, size_t bytes_to_allocate);
-typedef void (*deallocate_fptr)(uint8_t *memory, size_t bytes_to_allocate);
-
-/* Argon2 external data structures */
-
-/*
- *****Context: structure to hold Argon2 inputs:
- * output array and its length,
- * password and its length,
- * salt and its length,
- * secret and its length,
- * associated data and its length,
- * number of passes, amount of used memory (in KBytes, can be rounded up a bit)
- * number of parallel threads that will be run.
- * All the parameters above affect the output hash value.
- * Additionally, two function pointers can be provided to allocate and
- deallocate the memory (if NULL, memory will be allocated internally).
- * Also, three flags indicate whether to erase password, secret as soon as they
- are pre-hashed (and thus not needed anymore), and the entire memory
- ****************************
- Simplest situation: you have output array out[8], password is stored in
- pwd[32], salt is stored in salt[16], you do not have keys nor associated data.
- You need to spend 1 GB of RAM and you run 5 passes of Argon2d with 4 parallel
- lanes.
- You want to erase the password, but you're OK with last pass not being erased.
- You want to use the default memory allocator.
- */
-typedef struct Argon2_Context {
-    uint8_t *out;    /* output array */
-    uint8_t *pwd;    /* password array */
-    uint8_t *salt;    /* salt array */
-    /*uint8_t *secret;*/    /* key array */
-    /*uint8_t *ad;*/   /* associated data array */
-
-    allocate_fptr allocate_cbk; /* pointer to memory allocator */
-    deallocate_fptr free_cbk;   /* pointer to memory deallocator */
-
-    /*uint32_t outlen;*/ /* digest length */
-    uint32_t pwdlen;  /* password length */
-    /*uint32_t saltlen;*/ /* salt length */
-    /*uint32_t secretlen;*/ /* key length */
-    /*uint32_t adlen;*/ /* associated data length */
-    /*uint32_t t_cost;*/  /* number of passes */
-    /*uint32_t m_cost;*/  /* amount of memory requested (KB) */
-    /*uint32_t lanes;*/   /* number of lanes */
-    /*uint32_t threads;*/ /* maximum number of threads */
-    /*uint32_t flags;*/ /* array of bool options */
-
-} argon2_context;
-
-/**
- * Function to hash the inputs in the memory-hard fashion (uses Argon2i)
- * @param  out  Pointer to the memory where the hash digest will be written
- * @param  outlen Digest length in bytes
- * @param  in Pointer to the input (password)
- * @param  inlen Input length in bytes
- * @param  salt Pointer to the salt
- * @param  saltlen Salt length in bytes
- * @pre    @a out must have at least @a outlen bytes allocated
- * @pre    @a in must be at least @inlen bytes long
- * @pre    @a saltlen must be at least @saltlen bytes long
- * @return Zero if successful, 1 otherwise.
- */
-/*int hash_argon2i(void *out, size_t outlen, const void *in, size_t inlen,
-                 const void *salt, size_t saltlen, unsigned int t_cost,
-                 unsigned int m_cost);*/
-
-/* same for argon2d */
-/*int hash_argon2d(void *out, size_t outlen, const void *in, size_t inlen,
-                 const void *salt, size_t saltlen, unsigned int t_cost,
-                 unsigned int m_cost);*/
-
-/*
- * **************Argon2d: Version of Argon2 that picks memory blocks depending
- * on the password and salt. Only for side-channel-free
- * environment!!***************
- * @param  context  Pointer to current Argon2 context
- * @return  Zero if successful, a non zero error code otherwise
- */
-int argon2d(argon2_context *context);
-
-/*
- *  * **************Argon2i: Version of Argon2 that picks memory blocks
- *independent on the password and salt. Good for side-channels,
- ******************* but worse w.r.t. tradeoff attacks if
- *******************only one pass is used***************
- * @param  context  Pointer to current Argon2 context
- * @return  Zero if successful, a non zero error code otherwise
- */
-int argon2i(argon2_context *context);
-
-/*
- *   * **************Argon2di: Reserved name***************
- * @param  context  Pointer to current Argon2 context
- * @return  Zero if successful, a non zero error code otherwise
- */
-int argon2di(argon2_context *context);
-
-/*
- *   * **************Argon2ds: Argon2d hardened against GPU attacks, 20%
- * slower***************
- * @param  context  Pointer to current Argon2 context
- * @return  Zero if successful, a non zero error code otherwise
- */
-int argon2ds(argon2_context *context);
-
-/*
- *   * **************Argon2id: First half-pass over memory is
- *password-independent, the rest are password-dependent
- ********************OK against side channels: they reduce to 1/2-pass
- *Argon2i***************
- * @param  context  Pointer to current Argon2 context
- * @return  Zero if successful, a non zero error code otherwise
- */
-int argon2id(argon2_context *context);
-
-/*
- * Verify if a given password is correct for Argon2d hashing
- * @param  context  Pointer to current Argon2 context
- * @param  hash  The password hash to verify. The length of the hash is
- * specified by the context outlen member
- * @return  Zero if successful, a non zero error code otherwise
- */
-int verify_d(argon2_context *context, const char *hash);
-
-/*
- * Get the associated error message for given error code
- * @return  The error message associated with the given error code
- */
-const char *error_message(int error_code);
-
-/* ==================================================================== */
-/*
- * Code specific to Argon2i.
- *
- * The code below applies the following format:
- *
- *  $argon2i$m=<num>,t=<num>,p=<num>[,keyid=<bin>][,data=<bin>][$<bin>[$<bin>]]
- *
- * where <num> is a decimal integer (positive, fits in an 'unsigned long')
- * and <bin> is Base64-encoded data (no '=' padding characters, no newline
- * or whitespace). The "keyid" is a binary identifier for a key (up to 8
- * bytes); "data" is associated data (up to 32 bytes). When the 'keyid'
- * (resp. the 'data') is empty, then it is ommitted from the output.
- *
- * The last two binary chunks (encoded in Base64) are, in that order,
- * the salt and the output. Both are optional, but you cannot have an
- * output without a salt. The binary salt length is between 8 and 48 bytes.
- * The output length is always exactly 32 bytes.
- */
-
-int encode_string(char *dst, size_t dst_len, argon2_context *ctx);
-
-#if defined(__cplusplus)
-}
-#endif
-
-#endif

algo/argon2/ar2/bench.c

@@ -1,114 +0,0 @@
-#include <stdio.h>
-#include <stdint.h>
-#include <stdlib.h>
-#include <string.h>
-#include <time.h>
-#ifdef _MSC_VER
-#include <intrin.h>
-#endif
-
-#include "argon2.h"
-
-static uint64_t rdtsc(void)
-{
-#ifdef _MSC_VER
-	return __rdtsc();
-#else
-#if defined(__amd64__) || defined(__x86_64__)
-	uint64_t rax, rdx;
-	__asm__ __volatile__("rdtsc" : "=a"(rax), "=d"(rdx) : :);
-	return (rdx << 32) | rax;
-#elif defined(__i386__) || defined(__i386) || defined(__X86__)
-	uint64_t rax;
-	__asm__ __volatile__("rdtsc" : "=A"(rax) : :);
-	return rax;
-#else
-#error "Not implemented!"
-#endif
-#endif
-}
-
-/*
- * Benchmarks Argon2 with salt length 16, password length 16, t_cost 1,
-   and different m_cost and threads
- */
-static void benchmark()
-{
-#define BENCH_OUTLEN 16
-#define BENCH_INLEN 16
-	const uint32_t inlen = BENCH_INLEN;
-	const unsigned outlen = BENCH_OUTLEN;
-	unsigned char out[BENCH_OUTLEN];
-	unsigned char pwd_array[BENCH_INLEN];
-	unsigned char salt_array[BENCH_INLEN];
-#undef BENCH_INLEN
-#undef BENCH_OUTLEN
-
-	uint32_t t_cost = 1;
-	uint32_t m_cost;
-	uint32_t thread_test[6] = {1, 2, 4, 6, 8, 16};
-
-	memset(pwd_array, 0, inlen);
-	memset(salt_array, 1, inlen);
-
-	for (m_cost = (uint32_t)1 << 10; m_cost <= (uint32_t)1 << 22; m_cost *= 2) {
-		unsigned i;
-		for (i = 0; i < 6; ++i) {
-			argon2_context context;
-			uint32_t thread_n = thread_test[i];
-			uint64_t stop_cycles, stop_cycles_i;
-			clock_t stop_time;
-			uint64_t delta_d, delta_i;
-			double mcycles_d, mcycles_i, run_time;
-
-			clock_t start_time = clock();
-			uint64_t start_cycles = rdtsc();
-
-			context.out = out;
-			context.outlen = outlen;
-			context.pwd = pwd_array;
-			context.pwdlen = inlen;
-			context.salt = salt_array;
-			context.saltlen = inlen;
-			context.secret = NULL;
-			context.secretlen = 0;
-			context.ad = NULL;
-			context.adlen = 0;
-			context.t_cost = t_cost;
-			context.m_cost = m_cost;
-			context.lanes = thread_n;
-			context.threads = thread_n;
-			context.allocate_cbk = NULL;
-			context.free_cbk = NULL;
-			context.flags = 0;
-
-			argon2d(&context);
-			stop_cycles = rdtsc();
-			argon2i(&context);
-			stop_cycles_i = rdtsc();
-			stop_time = clock();
-
-			delta_d = (stop_cycles - start_cycles) / (m_cost);
-			delta_i = (stop_cycles_i - stop_cycles) / (m_cost);
-			mcycles_d = (double)(stop_cycles - start_cycles) / (1UL << 20);
-			mcycles_i = (double)(stop_cycles_i - stop_cycles) / (1UL << 20);
-			printf("Argon2d %d iterations  %d MiB %d threads:  %2.2f cpb %2.2f "
-				   "Mcycles \n",
-				   t_cost, m_cost >> 10, thread_n, (float)delta_d / 1024,
-				   mcycles_d);
-			printf("Argon2i %d iterations  %d MiB %d threads:  %2.2f cpb %2.2f "
-				   "Mcycles \n",
-				   t_cost, m_cost >> 10, thread_n, (float)delta_i / 1024,
-				   mcycles_i);
-
-			run_time = ((double)stop_time - start_time) / (CLOCKS_PER_SEC);
-			printf("%2.4f seconds\n\n", run_time);
-		}
-	}
-}
-
-int main()
-{
-	benchmark();
-	return ARGON2_OK;
-}

algo/argon2/ar2/blake2/blake2-impl.h

@@ -1,143 +0,0 @@
-#ifndef PORTABLE_BLAKE2_IMPL_H
-#define PORTABLE_BLAKE2_IMPL_H
-
-#include <stdint.h>
-#include <string.h>
-
-#if defined(_MSC_VER)
-#define BLAKE2_INLINE __inline
-#elif defined(__GNUC__) || defined(__clang__)
-#define BLAKE2_INLINE __inline__
-#else
-#define BLAKE2_INLINE
-#endif
-
-/* Argon2 Team - Begin Code */
-/*
-   Not an exhaustive list, but should cover the majority of modern platforms
-   Additionally, the code will always be correct---this is only a performance
-   tweak.
-*/
-#if (defined(__BYTE_ORDER__) &&                                                \
-	 (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)) ||                           \
-	defined(__LITTLE_ENDIAN__) || defined(__ARMEL__) || defined(__MIPSEL__) || \
-	defined(__AARCH64EL__) || defined(__amd64__) || defined(__i386__) ||       \
-	defined(_M_IX86) || defined(_M_X64) || defined(_M_AMD64) ||                \
-	defined(_M_ARM)
-#define NATIVE_LITTLE_ENDIAN
-#endif
-/* Argon2 Team - End Code */
-
-static BLAKE2_INLINE uint32_t load32(const void *src) {
-#if defined(NATIVE_LITTLE_ENDIAN)
-	uint32_t w;
-	memcpy(&w, src, sizeof w);
-	return w;
-#else
-	const uint8_t *p = (const 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 BLAKE2_INLINE uint64_t load64(const void *src) {
-#if defined(NATIVE_LITTLE_ENDIAN)
-	uint64_t w;
-	memcpy(&w, src, sizeof w);
-	return w;
-#else
-	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;
-	w |= (uint64_t)(*p++) << 48;
-	w |= (uint64_t)(*p++) << 56;
-	return w;
-#endif
-}
-
-static BLAKE2_INLINE void store32(void *dst, uint32_t w) {
-#if defined(NATIVE_LITTLE_ENDIAN)
-	memcpy(dst, &w, sizeof 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 BLAKE2_INLINE void store64(void *dst, uint64_t w) {
-#if defined(NATIVE_LITTLE_ENDIAN)
-	memcpy(dst, &w, sizeof 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;
-	w >>= 8;
-	*p++ = (uint8_t)w;
-	w >>= 8;
-	*p++ = (uint8_t)w;
-	w >>= 8;
-	*p++ = (uint8_t)w;
-	w >>= 8;
-	*p++ = (uint8_t)w;
-#endif
-}
-
-static BLAKE2_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 BLAKE2_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;
-}
-
-static BLAKE2_INLINE uint32_t rotr32(const uint32_t w, const unsigned c) {
-	return (w >> c) | (w << (32 - c));
-}
-
-static BLAKE2_INLINE uint64_t rotr64(const uint64_t w, const unsigned c) {
-	return (w >> c) | (w << (64 - c));
-}
-
-/* prevents compiler optimizing out memset() */
-static BLAKE2_INLINE void burn(void *v, size_t n) {
-	static void *(*const volatile memset_v)(void *, int, size_t) = &memset;
-	memset_v(v, 0, n);
-}
-
-#endif

algo/argon2/ar2/blake2/blake2.h

@@ -1,76 +0,0 @@
-#ifndef PORTABLE_BLAKE2_H
-#define PORTABLE_BLAKE2_H
-
-#include <stddef.h>
-#include <stdint.h>
-#include <limits.h>
-
-#if defined(__cplusplus)
-extern "C" {
-#endif
-
-enum blake2b_constant {
-	BLAKE2B_BLOCKBYTES = 128,
-	BLAKE2B_OUTBYTES = 64,
-	BLAKE2B_KEYBYTES = 64,
-	BLAKE2B_SALTBYTES = 16,
-	BLAKE2B_PERSONALBYTES = 16
-};
-
-#pragma pack(push, 1)
-typedef struct __blake2b_param {
-	uint8_t digest_length;                   /* 1 */
-	uint8_t key_length;                      /* 2 */
-	uint8_t fanout;                          /* 3 */
-	uint8_t depth;                           /* 4 */
-	uint32_t leaf_length;                    /* 8 */
-	uint64_t node_offset;                    /* 16 */
-	uint8_t node_depth;                      /* 17 */
-	uint8_t inner_length;                    /* 18 */
-	uint8_t reserved[14];                    /* 32 */
-	uint8_t salt[BLAKE2B_SALTBYTES];         /* 48 */
-	uint8_t personal[BLAKE2B_PERSONALBYTES]; /* 64 */
-} blake2b_param;
-#pragma pack(pop)
-
-typedef struct __blake2b_state {
-	uint64_t h[8];
-	uint64_t t[2];
-	uint64_t f[2];
-	unsigned buflen;
-	unsigned outlen;
-	uint8_t last_node;
-	uint8_t buf[BLAKE2B_BLOCKBYTES];
-} blake2b_state;
-
-/* Ensure param structs have not been wrongly padded */
-/* Poor man's static_assert */
-enum {
-	blake2_size_check_0 = 1 / !!(CHAR_BIT == 8),
-	blake2_size_check_2 =
-		1 / !!(sizeof(blake2b_param) == sizeof(uint64_t) * CHAR_BIT)
-};
-
-/* Streaming API */
-int blake2b_init(blake2b_state *S, size_t outlen);
-int blake2b_init_key(blake2b_state *S, size_t outlen, const void *key,
-					 size_t keylen);
-int blake2b_init_param(blake2b_state *S, const blake2b_param *P);
-int blake2b_update(blake2b_state *S, const void *in, size_t inlen);
-void my_blake2b_update(blake2b_state *S, const void *in, size_t inlen);
-int blake2b_final(blake2b_state *S, void *out, size_t outlen);
-
-/* Simple API */
-int blake2b(void *out, const void *in, const void *key, size_t keylen);
-
-/* Argon2 Team - Begin Code */
-int blake2b_long(void *out, const void *in);
-/* Argon2 Team - End Code */
-/* Miouyouyou */
-void blake2b_too(void *out, const void *in);
-
-#if defined(__cplusplus)
-}
-#endif
-
-#endif

algo/argon2/ar2/blake2/blamka-round-opt.h

@@ -1,162 +0,0 @@
-#ifndef BLAKE_ROUND_MKA_OPT_H
-#define BLAKE_ROUND_MKA_OPT_H
-
-#include "blake2-impl.h"
-
-#if defined(_MSC_VER)
-#include <intrin.h>
-#endif
-
-#include <immintrin.h>
-#if defined(__XOP__) && (defined(__GNUC__) || defined(__clang__))
-#include <x86intrin.h>
-#endif
-
-#if !defined(__XOP__)
-#if defined(__SSSE3__)
-#define r16                                                                    \
-    (_mm_setr_epi8(2, 3, 4, 5, 6, 7, 0, 1, 10, 11, 12, 13, 14, 15, 8, 9))
-#define r24                                                                    \
-    (_mm_setr_epi8(3, 4, 5, 6, 7, 0, 1, 2, 11, 12, 13, 14, 15, 8, 9, 10))
-#define _mm_roti_epi64(x, c)                                                   \
-    (-(c) == 32)                                                               \
-        ? _mm_shuffle_epi32((x), _MM_SHUFFLE(2, 3, 0, 1))                      \
-        : (-(c) == 24)                                                         \
-              ? _mm_shuffle_epi8((x), r24)                                     \
-              : (-(c) == 16)                                                   \
-                    ? _mm_shuffle_epi8((x), r16)                               \
-                    : (-(c) == 63)                                             \
-                          ? _mm_xor_si128(_mm_srli_epi64((x), -(c)),           \
-                                          _mm_add_epi64((x), (x)))             \
-                          : _mm_xor_si128(_mm_srli_epi64((x), -(c)),           \
-                                          _mm_slli_epi64((x), 64 - (-(c))))
-#else /* defined(__SSE2__) */
-#define _mm_roti_epi64(r, c)                                                   \
-    _mm_xor_si128(_mm_srli_epi64((r), -(c)), _mm_slli_epi64((r), 64 - (-(c))))
-#endif
-#else
-#endif
-
-static BLAKE2_INLINE __m128i fBlaMka(__m128i x, __m128i y) {
-    const __m128i z = _mm_mul_epu32(x, y);
-    return _mm_add_epi64(_mm_add_epi64(x, y), _mm_add_epi64(z, z));
-}
-
-#define G1(A0, B0, C0, D0, A1, B1, C1, D1)                                     \
-    do {                                                                       \
-        A0 = fBlaMka(A0, B0);                                                  \
-        A1 = fBlaMka(A1, B1);                                                  \
-                                                                               \
-        D0 = _mm_xor_si128(D0, A0);                                            \
-        D1 = _mm_xor_si128(D1, A1);                                            \
-                                                                               \
-        D0 = _mm_roti_epi64(D0, -32);                                          \
-        D1 = _mm_roti_epi64(D1, -32);                                          \
-                                                                               \
-        C0 = fBlaMka(C0, D0);                                                  \
-        C1 = fBlaMka(C1, D1);                                                  \
-                                                                               \
-        B0 = _mm_xor_si128(B0, C0);                                            \
-        B1 = _mm_xor_si128(B1, C1);                                            \
-                                                                               \
-        B0 = _mm_roti_epi64(B0, -24);                                          \
-        B1 = _mm_roti_epi64(B1, -24);                                          \
-    } while ((void)0, 0)
-
-#define G2(A0, B0, C0, D0, A1, B1, C1, D1)                                     \
-    do {                                                                       \
-        A0 = fBlaMka(A0, B0);                                                  \
-        A1 = fBlaMka(A1, B1);                                                  \
-                                                                               \
-        D0 = _mm_xor_si128(D0, A0);                                            \
-        D1 = _mm_xor_si128(D1, A1);                                            \
-                                                                               \
-        D0 = _mm_roti_epi64(D0, -16);                                          \
-        D1 = _mm_roti_epi64(D1, -16);                                          \
-                                                                               \
-        C0 = fBlaMka(C0, D0);                                                  \
-        C1 = fBlaMka(C1, D1);                                                  \
-                                                                               \
-        B0 = _mm_xor_si128(B0, C0);                                            \
-        B1 = _mm_xor_si128(B1, C1);                                            \
-                                                                               \
-        B0 = _mm_roti_epi64(B0, -63);                                          \
-        B1 = _mm_roti_epi64(B1, -63);                                          \
-    } while ((void)0, 0)
-
-#if defined(__SSSE3__)
-#define DIAGONALIZE(A0, B0, C0, D0, A1, B1, C1, D1)                            \
-    do {                                                                       \
-        __m128i t0 = _mm_alignr_epi8(B1, B0, 8);                               \
-        __m128i t1 = _mm_alignr_epi8(B0, B1, 8);                               \
-        B0 = t0;                                                               \
-        B1 = t1;                                                               \
-                                                                               \
-        t0 = C0;                                                               \
-        C0 = C1;                                                               \
-        C1 = t0;                                                               \
-                                                                               \
-        t0 = _mm_alignr_epi8(D1, D0, 8);                                       \
-        t1 = _mm_alignr_epi8(D0, D1, 8);                                       \
-        D0 = t1;                                                               \
-        D1 = t0;                                                               \
-    } while ((void)0, 0)
-
-#define UNDIAGONALIZE(A0, B0, C0, D0, A1, B1, C1, D1)                          \
-    do {                                                                       \
-        __m128i t0 = _mm_alignr_epi8(B0, B1, 8);                               \
-        __m128i t1 = _mm_alignr_epi8(B1, B0, 8);                               \
-        B0 = t0;                                                               \
-        B1 = t1;                                                               \
-                                                                               \
-        t0 = C0;                                                               \
-        C0 = C1;                                                               \
-        C1 = t0;                                                               \
-                                                                               \
-        t0 = _mm_alignr_epi8(D0, D1, 8);                                       \
-        t1 = _mm_alignr_epi8(D1, D0, 8);                                       \
-        D0 = t1;                                                               \
-        D1 = t0;                                                               \
-    } while ((void)0, 0)
-#else /* SSE2 */
-#define DIAGONALIZE(A0, B0, C0, D0, A1, B1, C1, D1)                            \
-    do {                                                                       \
-        __m128i t0 = D0;                                                       \
-        __m128i t1 = B0;                                                       \
-        D0 = C0;                                                               \
-        C0 = C1;                                                               \
-        C1 = D0;                                                               \
-        D0 = _mm_unpackhi_epi64(D1, _mm_unpacklo_epi64(t0, t0));               \
-        D1 = _mm_unpackhi_epi64(t0, _mm_unpacklo_epi64(D1, D1));               \
-        B0 = _mm_unpackhi_epi64(B0, _mm_unpacklo_epi64(B1, B1));               \
-        B1 = _mm_unpackhi_epi64(B1, _mm_unpacklo_epi64(t1, t1));               \
-    } while ((void)0, 0)
-
-#define UNDIAGONALIZE(A0, B0, C0, D0, A1, B1, C1, D1)                          \
-    do {                                                                       \
-        __m128i t0 = C0;                                                       \
-        C0 = C1;                                                               \
-        C1 = t0;                                                               \
-        t0 = B0;                                                               \
-        __m128i t1 = D0;                                                       \
-        B0 = _mm_unpackhi_epi64(B1, _mm_unpacklo_epi64(B0, B0));               \
-        B1 = _mm_unpackhi_epi64(t0, _mm_unpacklo_epi64(B1, B1));               \
-        D0 = _mm_unpackhi_epi64(D0, _mm_unpacklo_epi64(D1, D1));               \
-        D1 = _mm_unpackhi_epi64(D1, _mm_unpacklo_epi64(t1, t1));               \
-    } while ((void)0, 0)
-#endif
-
-#define BLAKE2_ROUND(A0, A1, B0, B1, C0, C1, D0, D1)                           \
-    do {                                                                       \
-        G1(A0, B0, C0, D0, A1, B1, C1, D1);                                    \
-        G2(A0, B0, C0, D0, A1, B1, C1, D1);                                    \
-                                                                               \
-        DIAGONALIZE(A0, B0, C0, D0, A1, B1, C1, D1);                           \
-                                                                               \
-        G1(A0, B0, C0, D0, A1, B1, C1, D1);                                    \
-        G2(A0, B0, C0, D0, A1, B1, C1, D1);                                    \
-                                                                               \
-        UNDIAGONALIZE(A0, B0, C0, D0, A1, B1, C1, D1);                         \
-    } while ((void)0, 0)
-
-#endif

algo/argon2/ar2/blake2b.c

@@ -1,316 +0,0 @@
-#include <stdint.h>
-#include <string.h>
-#include <stdio.h>
-#include <inttypes.h>
-
-#include "blake2/blake2.h"
-#include "blake2/blake2-impl.h"
-
-#if defined(_MSC_VER)
-// i know there is a trick but nvm :p
-#define PRIu64 "%llu"
-#define PRIx64 "%llx"
-#endif
-
-static const uint64_t blake2b_IV[8] = {
-	UINT64_C(0x6a09e667f3bcc908), UINT64_C(0xbb67ae8584caa73b),
-	UINT64_C(0x3c6ef372fe94f82b), UINT64_C(0xa54ff53a5f1d36f1),
-	UINT64_C(0x510e527fade682d1), UINT64_C(0x9b05688c2b3e6c1f),
-	UINT64_C(0x1f83d9abfb41bd6b), UINT64_C(0x5be0cd19137e2179)
-};
-
-static const unsigned int blake2b_sigma[12][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},
-	{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},
-};
-
-static BLAKE2_INLINE void blake2b_set_lastnode(blake2b_state *S) {
-	S->f[1] = (uint64_t)-1;
-}
-
-static BLAKE2_INLINE void blake2b_set_lastblock(blake2b_state *S) {
-	if (S->last_node) {
-		blake2b_set_lastnode(S);
-	}
-	S->f[0] = (uint64_t)-1;
-}
-
-static BLAKE2_INLINE void blake2b_increment_counter(blake2b_state *S, uint64_t inc) {
-	S->t[0] += inc;
-	S->t[1] += (S->t[0] < inc);
-}
-
-static BLAKE2_INLINE void blake2b_invalidate_state(blake2b_state *S) {
-	burn(S, sizeof(*S));      /* wipe */
-	blake2b_set_lastblock(S); /* invalidate for further use */
-}
-
-static BLAKE2_INLINE void blake2b_init0(blake2b_state *S) {
-	memset(S, 0, sizeof(*S));
-	memcpy(S->h, blake2b_IV, sizeof(S->h));
-}
-
-/*
-void print_state(blake2b_state BlakeHash)
-{
-	printf(".h = {UINT64_C(%" PRIu64 "), UINT64_C(%" PRIu64 "),\n"
-				"UINT64_C(%" PRIu64 "), UINT64_C(%" PRIu64 "),\n"
-				"UINT64_C(%" PRIu64 "), UINT64_C(%" PRIu64 "),\n"
-				"UINT64_C(%" PRIu64 "), UINT64_C(%" PRIu64 ")},\n"
-		".t = {UINT64_C(%" PRIu64 "), UINT64_C(%" PRIu64 ")},\n"
-		".f = {UINT64_C(%" PRIu64 "), UINT64_C(%" PRIu64 ")}\n",
-		BlakeHash.h[0], BlakeHash.h[1], BlakeHash.h[2], BlakeHash.h[3],
-		BlakeHash.h[4], BlakeHash.h[5], BlakeHash.h[6], BlakeHash.h[7],
-		BlakeHash.t[0], BlakeHash.t[1],
-		BlakeHash.f[0], BlakeHash.f[1]);
-	printf(".buf = {");
-	for (register uint8_t i = 0; i < BLAKE2B_BLOCKBYTES; i++)
-		printf("%" PRIu8 ", ", BlakeHash.buf[i]);
-	puts("\n");
-	printf("}\n.buflen = %d\n.outlen = %d\n",
-		  BlakeHash.buflen, BlakeHash.outlen);
-	printf(".last_node = %" PRIu8 "\n", BlakeHash.last_node);
-	fflush(stdout);
-}
-*/
-
-static const blake2b_state miou = {
-	.h = {
-		UINT64_C(7640891576939301128), UINT64_C(13503953896175478587),
-		UINT64_C(4354685564936845355), UINT64_C(11912009170470909681),
-		UINT64_C(5840696475078001361), UINT64_C(11170449401992604703),
-		UINT64_C(2270897969802886507), UINT64_C(6620516959819538809)
-	},
-	.t = {UINT64_C(0), UINT64_C(0)},
-	.f = {UINT64_C(0), UINT64_C(0)},
-	.buf = {
-		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
-	},
-	.buflen = 0,
-	.outlen = 64,
-	.last_node = 0
-};
-
-
-int blake2b_init_param(blake2b_state *S, const blake2b_param *P)
-{
-	const unsigned char *p = (const unsigned char *)P;
-	unsigned int i;
-
-	if (NULL == P || NULL == S) {
-		return -1;
-	}
-
-	blake2b_init0(S);
-	/* IV XOR Parameter Block */
-	for (i = 0; i < 8; ++i) {
-		S->h[i] ^= load64(&p[i * sizeof(S->h[i])]);
-	}
-	S->outlen = P->digest_length;
-	return 0;
-}
-
-void compare_buffs(uint64_t *h, size_t outlen)
-{
-	// printf("CMP : %d", memcmp(h, miou.h, 8*(sizeof(uint64_t))));
-	printf("miou : %" PRIu64 " - h : %" PRIu64 " - outlen : %ld\n", miou.h[0], h[0], outlen);
-	fflush(stdout);
-}
-
-/* Sequential blake2b initialization */
-int blake2b_init(blake2b_state *S, size_t outlen)
-{
-	memcpy(S, &miou, sizeof(*S));
-	S->h[0] += outlen;
-	return 0;
-}
-
-void print64(const char *name, const uint64_t *array, uint16_t size)
-{
-	printf("%s = {", name);
-	for (uint8_t i = 0; i < size; i++) printf("UINT64_C(%" PRIu64 "), ", array[i]);
-	printf("};\n");
-}
-
-int blake2b_init_key(blake2b_state *S, size_t outlen, const void *key, size_t keylen)
-{
-	return 0;
-}
-
-static void blake2b_compress(blake2b_state *S, const uint8_t *block)
-{
-	uint64_t m[16];
-	uint64_t v[16];
-	unsigned int i, r;
-
-	for (i = 0; i < 16; ++i) {
-		m[i] = load64(block + i * 8);
-	}
-
-	for (i = 0; i < 8; ++i) {
-		v[i] = S->h[i];
-	}
-
-	v[8] = blake2b_IV[0];
-	v[9] = blake2b_IV[1];
-	v[10] = blake2b_IV[2];
-	v[11] = blake2b_IV[3];
-	v[12] = blake2b_IV[4] ^ S->t[0];
-	v[13] = blake2b_IV[5]/* ^ S->t[1]*/;
-	v[14] = blake2b_IV[6] ^ S->f[0];
-	v[15] = blake2b_IV[7]/* ^ S->f[1]*/;
-
-#define G(r, i, a, b, c, d)                                                    \
-	do {                                                                       \
-		a = a + b + m[blake2b_sigma[r][2 * i + 0]];                            \
-		d = rotr64(d ^ a, 32);                                                 \
-		c = c + d;                                                             \
-		b = rotr64(b ^ c, 24);                                                 \
-		a = a + b + m[blake2b_sigma[r][2 * i + 1]];                            \
-		d = rotr64(d ^ a, 16);                                                 \
-		c = c + d;                                                             \
-		b = rotr64(b ^ c, 63);                                                 \
-	} while ((void)0, 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 ((void)0, 0)
-
-	for (r = 0; r < 12; ++r) ROUND(r);
-
-	for (i = 0; i < 8; ++i) S->h[i] = S->h[i] ^ v[i] ^ v[i + 8];
-
-#undef G
-#undef ROUND
-}
-
-int blake2b_update(blake2b_state *S, const void *in, size_t inlen)
-{
-	const uint8_t *pin = (const uint8_t *)in;
-	/* Complete current block */
-	memcpy(&S->buf[4], pin, 124);
-	blake2b_increment_counter(S, BLAKE2B_BLOCKBYTES);
-	blake2b_compress(S, S->buf);
-	S->buflen = 0;
-	pin += 124;
-
-	register int8_t i = 7;
-	/* Avoid buffer copies when possible */
-	while (i--) {
-	  blake2b_increment_counter(S, BLAKE2B_BLOCKBYTES);
-	  blake2b_compress(S, pin);
-	  pin += BLAKE2B_BLOCKBYTES;
-	}
-	memcpy(&S->buf[S->buflen], pin, 4);
-	S->buflen += 4;
-	return 0;
-}
-
-void my_blake2b_update(blake2b_state *S, const void *in, size_t inlen)
-{
-	memcpy(&S->buf[S->buflen], in, inlen);
-	S->buflen += (unsigned int)inlen;
-}
-
-int blake2b_final(blake2b_state *S, void *out, size_t outlen)
-{
-	uint8_t buffer[BLAKE2B_OUTBYTES] = {0};
-	unsigned int i;
-
-	blake2b_increment_counter(S, S->buflen);
-	blake2b_set_lastblock(S);
-	memset(&S->buf[S->buflen], 0, BLAKE2B_BLOCKBYTES - S->buflen); /* Padding */
-	blake2b_compress(S, S->buf);
-
-	for (i = 0; i < 8; ++i) { /* Output full hash to temp buffer */
-		store64(buffer + sizeof(S->h[i]) * i, S->h[i]);
-	}
-
-	memcpy(out, buffer, S->outlen);
-
-	burn(buffer, sizeof(buffer));
-	burn(S->buf, sizeof(S->buf));
-	burn(S->h, sizeof(S->h));
-	return 0;
-}
-
-int blake2b(void *out, const void *in, const void *key, size_t keylen)
-{
-	blake2b_state S;
-
-	blake2b_init(&S, 64);
-	my_blake2b_update(&S, in, 64);
-	blake2b_final(&S, out, 64);
-	burn(&S, sizeof(S));
-	return 0;
-}
-
-void blake2b_too(void *pout, const void *in)
-{
-	uint8_t *out = (uint8_t *)pout;
-	uint8_t out_buffer[64];
-	uint8_t in_buffer[64];
-
-	blake2b_state blake_state;
-	blake2b_init(&blake_state, 64);
-	blake_state.buflen = blake_state.buf[1] = 4;
-	my_blake2b_update(&blake_state, in, 72);
-	blake2b_final(&blake_state, out_buffer, 64);
-	memcpy(out, out_buffer, 32);
-	out += 32;
-
-	register uint8_t i = 29;
-	while (i--) {
-		memcpy(in_buffer, out_buffer, 64);
-		blake2b(out_buffer, in_buffer, NULL, 0);
-		memcpy(out, out_buffer, 32);
-		out += 32;
-	}
-
-	memcpy(in_buffer, out_buffer, 64);
-	blake2b(out_buffer, in_buffer, NULL, 0);
-	memcpy(out, out_buffer, 64);
-
-	burn(&blake_state, sizeof(blake_state));
-}
-
-/* Argon2 Team - Begin Code */
-int blake2b_long(void *pout, const void *in)
-{
-	uint8_t *out = (uint8_t *)pout;
-	blake2b_state blake_state;
-	uint8_t outlen_bytes[sizeof(uint32_t)] = {0};
-
-	store32(outlen_bytes, 32);
-
-	blake2b_init(&blake_state, 32);
-	my_blake2b_update(&blake_state, outlen_bytes, sizeof(outlen_bytes));
-	blake2b_update(&blake_state, in, 1024);
-	blake2b_final(&blake_state, out, 32);
-	burn(&blake_state, sizeof(blake_state));
-	return 0;
-}
-/* Argon2 Team - End Code */

algo/argon2/ar2/cores.c

@@ -1,349 +0,0 @@
-/*
- * Argon2 source code package
- *
- * Written by Daniel Dinu and Dmitry Khovratovich, 2015
- *
- * This work is licensed under a Creative Commons CC0 1.0 License/Waiver.
- *
- * 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/>.
- */
-
-/*For memory wiping*/
-#ifdef _MSC_VER
-#include <windows.h>
-#include <winbase.h> /* For SecureZeroMemory */
-#endif
-#if defined __STDC_LIB_EXT1__
-#define __STDC_WANT_LIB_EXT1__ 1
-#endif
-#define VC_GE_2005(version) (version >= 1400)
-
-#include <inttypes.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "argon2.h"
-#include "cores.h"
-#include "blake2/blake2.h"
-#include "blake2/blake2-impl.h"
-
-#ifdef GENKAT
-#include "genkat.h"
-#endif
-
-#if defined(__clang__)
-#if __has_attribute(optnone)
-#define NOT_OPTIMIZED __attribute__((optnone))
-#endif
-#elif defined(__GNUC__)
-#define GCC_VERSION                                                            \
-    (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
-#if GCC_VERSION >= 40400
-#define NOT_OPTIMIZED __attribute__((optimize("O0")))
-#endif
-#endif
-#ifndef NOT_OPTIMIZED
-#define NOT_OPTIMIZED
-#endif
-
-/***************Instance and Position constructors**********/
-void init_block_value(block *b, uint8_t in) { memset(b->v, in, sizeof(b->v)); }
-//inline void init_block_value(block *b, uint8_t in) { memset(b->v, in, sizeof(b->v)); }
-
-void copy_block(block *dst, const block *src) {
-//inline void copy_block(block *dst, const block *src) {
-    memcpy(dst->v, src->v, sizeof(uint64_t) * ARGON2_WORDS_IN_BLOCK);
-}
-
-void xor_block(block *dst, const block *src) {
-//inline void xor_block(block *dst, const block *src) {
-    int i;
-    for (i = 0; i < ARGON2_WORDS_IN_BLOCK; ++i) {
-        dst->v[i] ^= src->v[i];
-    }
-}
-
-static void load_block(block *dst, const void *input) {
-//static inline void load_block(block *dst, const void *input) {
-    unsigned i;
-    for (i = 0; i < ARGON2_WORDS_IN_BLOCK; ++i) {
-        dst->v[i] = load64((const uint8_t *)input + i * sizeof(dst->v[i]));
-    }
-}
-
-static void store_block(void *output, const block *src) {
-//static inline void store_block(void *output, const block *src) {
-    unsigned i;
-    for (i = 0; i < ARGON2_WORDS_IN_BLOCK; ++i) {
-        store64((uint8_t *)output + i * sizeof(src->v[i]), src->v[i]);
-    }
-}
-
-/***************Memory allocators*****************/
-int allocate_memory(block **memory, uint32_t m_cost) {
-    if (memory != NULL) {
-        size_t memory_size = sizeof(block) * m_cost;
-        if (m_cost != 0 &&
-            memory_size / m_cost !=
-                sizeof(block)) { /*1. Check for multiplication overflow*/
-            return ARGON2_MEMORY_ALLOCATION_ERROR;
-        }
-
-        *memory = (block *)malloc(memory_size); /*2. Try to allocate*/
-
-        if (!*memory) {
-            return ARGON2_MEMORY_ALLOCATION_ERROR;
-        }
-
-        return ARGON2_OK;
-    } else {
-        return ARGON2_MEMORY_ALLOCATION_ERROR;
-    }
-}
-
-void secure_wipe_memory(void *v, size_t n) { memset(v, 0, n); }
-//inline void secure_wipe_memory(void *v, size_t n) { memset(v, 0, n); }
-
-/*********Memory functions*/
-
-void clear_memory(argon2_instance_t *instance, int clear) {
-//inline void clear_memory(argon2_instance_t *instance, int clear) {
-    if (instance->memory != NULL && clear) {
-        secure_wipe_memory(instance->memory,
-                           sizeof(block) * /*instance->memory_blocks*/16);
-    }
-}
-
-void free_memory(block *memory) { free(memory); }
-//inline void free_memory(block *memory) { free(memory); }
-
-void finalize(const argon2_context *context, argon2_instance_t *instance) {
-    if (context != NULL && instance != NULL) {
-        block blockhash;
-        copy_block(&blockhash, instance->memory + 15);
-
-        /* Hash the result */
-        {
-            uint8_t blockhash_bytes[ARGON2_BLOCK_SIZE];
-            store_block(blockhash_bytes, &blockhash);
-            blake2b_long(context->out, blockhash_bytes);
-            secure_wipe_memory(blockhash.v, ARGON2_BLOCK_SIZE);
-            secure_wipe_memory(blockhash_bytes, ARGON2_BLOCK_SIZE); /* clear blockhash_bytes */
-        }
-
-#ifdef GENKAT
-        print_tag(context->out, context->outlen);
-#endif
-
-        /* Clear memory */
-        // clear_memory(instance, 1);
-
-        free_memory(instance->memory);
-    }
-}
-
-uint32_t index_alpha(const argon2_instance_t *instance,
-                     const argon2_position_t *position, uint32_t pseudo_rand,
-                     int same_lane) {
-    /*
-     * Pass 0:
-     *      This lane : all already finished segments plus already constructed
-     * blocks in this segment
-     *      Other lanes : all already finished segments
-     * Pass 1+:
-     *      This lane : (SYNC_POINTS - 1) last segments plus already constructed
-     * blocks in this segment
-     *      Other lanes : (SYNC_POINTS - 1) last segments
-     */
-    uint32_t reference_area_size;
-    uint64_t relative_position;
-    uint32_t start_position, absolute_position;
-
-    if (0 == position->pass) {
-        /* First pass */
-        if (0 == position->slice) {
-            /* First slice */
-            reference_area_size =
-                position->index - 1; /* all but the previous */
-        } else {
-            if (same_lane) {
-                /* The same lane => add current segment */
-                reference_area_size =
-                    position->slice * 4 +
-                    position->index - 1;
-            } else {
-                reference_area_size =
-                    position->slice * 4 +
-                    ((position->index == 0) ? (-1) : 0);
-            }
-        }
-    } else {
-        /* Second pass */
-        if (same_lane) {reference_area_size = 11 + position->index;}
-        else {reference_area_size = 12 - (position->index == 0);}
-    }
-
-    /* 1.2.4. Mapping pseudo_rand to 0..<reference_area_size-1> and produce
-     * relative position */
-    relative_position = pseudo_rand;
-    relative_position = relative_position * relative_position >> 32;
-    relative_position = reference_area_size - 1 -
-                        (reference_area_size * relative_position >> 32);
-
-    /* 1.2.5 Computing starting position */
-    start_position = 0;
-
-    if (0 != position->pass) {
-        start_position = (position->slice == ARGON2_SYNC_POINTS - 1)
-                             ? 0 : (position->slice + 1) * 4;
-    }
-
-    /* 1.2.6. Computing absolute position */
-    absolute_position = (start_position + relative_position) % 16;
-    return absolute_position;
-}
-
-void fill_memory_blocks(argon2_instance_t *instance) {
-    uint32_t r, s;
-
-    for (r = 0; r < 2; ++r) {
-        for (s = 0; s < ARGON2_SYNC_POINTS; ++s) {
-
-            argon2_position_t position;
-            position.pass = r;
-            position.lane = 0;
-            position.slice = (uint8_t)s;
-            position.index = 0;
-            fill_segment(instance, position);
-        }
-
-#ifdef GENKAT
-        internal_kat(instance, r); /* Print all memory blocks */
-#endif
-    }
-}
-
-void fill_first_blocks(uint8_t *blockhash, const argon2_instance_t *instance) {
-    /* Make the first and second block in each lane as G(H0||i||0) or
-       G(H0||i||1) */
-    uint8_t blockhash_bytes[ARGON2_BLOCK_SIZE];
-    store32(blockhash + ARGON2_PREHASH_DIGEST_LENGTH, 0);
-    store32(blockhash + ARGON2_PREHASH_DIGEST_LENGTH + 4, 0);
-    blake2b_too(blockhash_bytes, blockhash);
-    load_block(&instance->memory[0], blockhash_bytes);
-
-    store32(blockhash + ARGON2_PREHASH_DIGEST_LENGTH, 1);
-    blake2b_too(blockhash_bytes, blockhash);
-    load_block(&instance->memory[1], blockhash_bytes);
-    secure_wipe_memory(blockhash_bytes, ARGON2_BLOCK_SIZE);
-}
-
-
-static const blake2b_state base_hash = {
- .h = {
-  UINT64_C(7640891576939301192), UINT64_C(13503953896175478587),
-  UINT64_C(4354685564936845355), UINT64_C(11912009170470909681),
-  UINT64_C(5840696475078001361), UINT64_C(11170449401992604703),
-  UINT64_C(2270897969802886507), UINT64_C(6620516959819538809)
- },
- .t = {UINT64_C(0),UINT64_C(0)},
- .f = {UINT64_C(0),UINT64_C(0)},
- .buf = {
-  1, 0, 0, 0, 32, 0, 0, 0, 16, 0, 0, 0, 2, 0, 0, 0, 16, 0, 0, 0, 1, 0,
-  0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
- .buflen = 28,
- .outlen = 64,
- .last_node = 0
-};
-
-#define PWDLEN 32
-#define SALTLEN 32
-#define SECRETLEN 0
-#define ADLEN 0
-void initial_hash(uint8_t *blockhash, argon2_context *context,
-                  argon2_type type) {
-
-    uint8_t value[sizeof(uint32_t)];
-
-    /* Is it generating cache invalidation between cores ? */
-    blake2b_state BlakeHash = base_hash;
-    BlakeHash.buf[20] = (uint8_t) type;
-    my_blake2b_update(&BlakeHash, (const uint8_t *)context->pwd,
-                   PWDLEN);
-
-
-    secure_wipe_memory(context->pwd, PWDLEN);
-    context->pwdlen = 0;
-
-    store32(&value, SALTLEN);
-    my_blake2b_update(&BlakeHash, (const uint8_t *)&value, sizeof(value));
-
-    my_blake2b_update(&BlakeHash, (const uint8_t *)context->salt,
-                   SALTLEN);
-
-    store32(&value, SECRETLEN);
-    my_blake2b_update(&BlakeHash, (const uint8_t *)&value, sizeof(value));
-
-    store32(&value, ADLEN);
-    my_blake2b_update(&BlakeHash, (const uint8_t *)&value, sizeof(value));
-
-    blake2b_final(&BlakeHash, blockhash, ARGON2_PREHASH_DIGEST_LENGTH);
-}
-
-int initialize(argon2_instance_t *instance, argon2_context *context) {
-    /* 1. Memory allocation */
-
-
-    allocate_memory(&(instance->memory), 16);
-
-    /* 2. Initial hashing */
-    /* H_0 + 8 extra bytes to produce the first blocks */
-    /* Hashing all inputs */
-    uint8_t blockhash[ARGON2_PREHASH_SEED_LENGTH];
-    initial_hash(blockhash, context, instance->type);
-    /* Zeroing 8 extra bytes */
-    secure_wipe_memory(blockhash + ARGON2_PREHASH_DIGEST_LENGTH,
-                       ARGON2_PREHASH_SEED_LENGTH -
-                           ARGON2_PREHASH_DIGEST_LENGTH);
-
-#ifdef GENKAT
-    initial_kat(blockhash, context, instance->type);
-#endif
-
-    /* 3. Creating first blocks, we always have at least two blocks in a slice
-     */
-    fill_first_blocks(blockhash, instance);
-    /* Clearing the hash */
-    secure_wipe_memory(blockhash, ARGON2_PREHASH_SEED_LENGTH);
-
-    return ARGON2_OK;
-}
-
-int argon2_core(argon2_context *context, argon2_type type) {
-    argon2_instance_t instance;
-    instance.memory = NULL;
-    instance.type = type;
-
-    /* 3. Initialization: Hashing inputs, allocating memory, filling first
-     * blocks
-     */
-
-    int result = initialize(&instance, context);
-    if (ARGON2_OK != result) return result;
-
-    /* 4. Filling memory */
-    fill_memory_blocks(&instance);
-
-    /* 5. Finalization */
-    finalize(context, &instance);
-
-    return ARGON2_OK;
-}

algo/argon2/ar2/genkat.c

@@ -1,186 +0,0 @@
-#include <inttypes.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "argon2.h"
-#include "cores.h"
-
-void initial_kat(const uint8_t *blockhash, const argon2_context *context,
-                 argon2_type type)
-{
-    unsigned i;
-
-    if (blockhash != NULL && context != NULL) {
-        printf("=======================================");
-
-        switch (type) {
-        case Argon2_d:
-            printf("Argon2d\n");
-            break;
-
-        case Argon2_i:
-            printf("Argon2i\n");
-            break;
-
-        default:
-            break;
-        }
-
-        printf("Memory: %u KiB, Iterations: %u, Parallelism: %u lanes, Tag "
-               "length: %u bytes\n",
-               context->m_cost, context->t_cost, context->lanes,
-               context->outlen);
-
-        printf("Password[%u]: ", context->pwdlen);
-
-        if (context->flags & ARGON2_FLAG_CLEAR_PASSWORD) {
-            printf("CLEARED\n");
-        } else {
-            for (i = 0; i < context->pwdlen; ++i) {
-                printf("%2.2x ", ((unsigned char *)context->pwd)[i]);
-            }
-
-            printf("\n");
-        }
-
-        printf("Salt[%u]: ", context->saltlen);
-
-        for (i = 0; i < context->saltlen; ++i) {
-            printf("%2.2x ", ((unsigned char *)context->salt)[i]);
-        }
-
-        printf("\n");
-
-        printf("Secret[%u]: ", context->secretlen);
-
-        if (context->flags & ARGON2_FLAG_CLEAR_SECRET) {
-            printf("CLEARED\n");
-        } else {
-            for (i = 0; i < context->secretlen; ++i) {
-                printf("%2.2x ", ((unsigned char *)context->secret)[i]);
-            }
-
-            printf("\n");
-        }
-
-        printf("Associated data[%u]: ", context->adlen);
-
-        for (i = 0; i < context->adlen; ++i) {
-            printf("%2.2x ", ((unsigned char *)context->ad)[i]);
-        }
-
-        printf("\n");
-
-        printf("Pre-hashing digest: ");
-
-        for (i = 0; i < ARGON2_PREHASH_DIGEST_LENGTH; ++i) {
-            printf("%2.2x ", ((unsigned char *)blockhash)[i]);
-        }
-
-        printf("\n");
-    }
-}
-
-void print_tag(const void *out, uint32_t outlen)
-{
-    unsigned i;
-    if (out != NULL) {
-        printf("Tag: ");
-
-        for (i = 0; i < outlen; ++i) {
-            printf("%2.2x ", ((uint8_t *)out)[i]);
-        }
-
-        printf("\n");
-    }
-}
-
-void internal_kat(const argon2_instance_t *instance, uint32_t pass)
-{
-    if (instance != NULL) {
-        uint32_t i, j;
-        printf("\n After pass %u:\n", pass);
-
-        for (i = 0; i < instance->memory_blocks; ++i) {
-            uint32_t how_many_words =
-                (instance->memory_blocks > ARGON2_WORDS_IN_BLOCK)
-                    ? 1
-                    : ARGON2_WORDS_IN_BLOCK;
-
-            for (j = 0; j < how_many_words; ++j)
-                printf("Block %.4u [%3u]: %016" PRIx64 "\n", i, j,
-                       instance->memory[i].v[j]);
-        }
-    }
-}
-
-static void fatal(const char *error) {
-    fprintf(stderr, "Error: %s\n", error);
-    exit(1);
-}
-
-static void generate_testvectors(const char *type)
-{
-#define TEST_OUTLEN 32
-#define TEST_PWDLEN 32
-#define TEST_SALTLEN 16
-#define TEST_SECRETLEN 8
-#define TEST_ADLEN 12
-    argon2_context context;
-
-    unsigned char out[TEST_OUTLEN];
-    unsigned char pwd[TEST_PWDLEN];
-    unsigned char salt[TEST_SALTLEN];
-    unsigned char secret[TEST_SECRETLEN];
-    unsigned char ad[TEST_ADLEN];
-    const allocate_fptr myown_allocator = NULL;
-    const deallocate_fptr myown_deallocator = NULL;
-
-    unsigned t_cost = 3;
-    unsigned m_cost = 16;
-    unsigned lanes = 4;
-
-    memset(pwd, 1, TEST_OUTLEN);
-    memset(salt, 2, TEST_SALTLEN);
-    memset(secret, 3, TEST_SECRETLEN);
-    memset(ad, 4, TEST_ADLEN);
-
-    context.out = out;
-    context.outlen = TEST_OUTLEN;
-    context.pwd = pwd;
-    context.pwdlen = TEST_PWDLEN;
-    context.salt = salt;
-    context.saltlen = TEST_SALTLEN;
-    context.secret = secret;
-    context.secretlen = TEST_SECRETLEN;
-    context.ad = ad;
-    context.adlen = TEST_ADLEN;
-    context.t_cost = t_cost;
-    context.m_cost = m_cost;
-    context.lanes = lanes;
-    context.threads = lanes;
-    context.allocate_cbk = myown_allocator;
-    context.free_cbk = myown_deallocator;
-    context.flags = 0;
-
-#undef TEST_OUTLEN
-#undef TEST_PWDLEN
-#undef TEST_SALTLEN
-#undef TEST_SECRETLEN
-#undef TEST_ADLEN
-
-    if (!strcmp(type, "d")) {
-        argon2d(&context);
-    } else if (!strcmp(type, "i")) {
-        argon2i(&context);
-    } else
-        fatal("wrong Argon2 type");
-}
-
-int main(int argc, char *argv[])
-{
-    const char *type = (argc > 1) ? argv[1] : "i";
-    generate_testvectors(type);
-    return ARGON2_OK;
-}

algo/argon2/ar2/genkat.h

@@ -1,45 +0,0 @@
-/*
- * Argon2 source code package
- *
- * Written by Daniel Dinu and Dmitry Khovratovich, 2015
- *
- * This work is licensed under a Creative Commons CC0 1.0 License/Waiver.
- *
- * 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/>.
- */
-
-#ifndef ARGON2_KAT_H
-#define ARGON2_KAT_H
-
-/*
- * Initial KAT function that prints the inputs to the file
- * @param  blockhash  Array that contains pre-hashing digest
- * @param  context Holds inputs
- * @param  type Argon2 type
- * @pre blockhash must point to INPUT_INITIAL_HASH_LENGTH bytes
- * @pre context member pointers must point to allocated memory of size according
- * to the length values
- */
-void initial_kat(const uint8_t *blockhash, const argon2_context *context,
-                 argon2_type type);
-
-/*
- * Function that prints the output tag
- * @param  out  output array pointer
- * @param  outlen digest length
- * @pre out must point to @a outlen bytes
- **/
-void print_tag(const void *out, uint32_t outlen);
-
-/*
- * Function that prints the internal state at given moment
- * @param  instance pointer to the current instance
- * @param  pass current pass number
- * @pre instance must have necessary memory allocated
- **/
-void internal_kat(const argon2_instance_t *instance, uint32_t pass);
-
-#endif

algo/argon2/ar2/opt.c

@@ -1,185 +0,0 @@
-/*
- * Argon2 source code package
- *
- * Written by Daniel Dinu and Dmitry Khovratovich, 2015
- *
- * This work is licensed under a Creative Commons CC0 1.0 License/Waiver.
- *
- * 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 <stdlib.h>
-#include <stdio.h>
-#include <inttypes.h>
-
-#include <immintrin.h>
-
-#include "argon2.h"
-#include "cores.h"
-#include "opt.h"
-
-#include "blake2/blake2.h"
-#include "blake2/blamka-round-opt.h"
-
-void fill_block(__m128i *state, __m128i const *ref_block, __m128i *next_block)
-{
-    __m128i ALIGN(16) block_XY[ARGON2_QWORDS_IN_BLOCK];
-    uint32_t i;
-    for (i = 0; i < ARGON2_QWORDS_IN_BLOCK; i++) {
-        block_XY[i] = state[i] = _mm_xor_si128(
-            state[i], _mm_load_si128(&ref_block[i]));
-    }
-
-    BLAKE2_ROUND(state[0], state[1], state[2], state[3], state[4], state[5], state[6], state[7]);
-    BLAKE2_ROUND(state[8], state[9], state[10], state[11], state[12], state[13], state[14], state[15]);
-    BLAKE2_ROUND(state[16], state[17], state[18], state[19], state[20], state[21], state[22], state[23]);
-    BLAKE2_ROUND(state[24], state[25], state[26], state[27], state[28], state[29], state[30], state[31]);
-    BLAKE2_ROUND(state[32], state[33], state[34], state[35], state[36], state[37], state[38], state[39]);
-    BLAKE2_ROUND(state[40], state[41], state[42], state[43], state[44], state[45], state[46], state[47]);
-    BLAKE2_ROUND(state[48], state[49], state[50], state[51], state[52], state[53], state[54], state[55]);
-    BLAKE2_ROUND(state[56], state[57], state[58], state[59], state[60], state[61], state[62], state[63]);
-    /*for (i = 0; i < 8; ++i) {
-        BLAKE2_ROUND(state[8 * i + 0], state[8 * i + 1], state[8 * i + 2],
-                     state[8 * i + 3], state[8 * i + 4], state[8 * i + 5],
-                     state[8 * i + 6], state[8 * i + 7]);
-    }*/
-
-    BLAKE2_ROUND(state[0], state[8], state[16], state[24], state[32], state[40], state[48], state[56]);
-    BLAKE2_ROUND(state[1], state[9], state[17], state[25], state[33], state[41], state[49], state[57]);
-    BLAKE2_ROUND(state[2], state[10], state[18], state[26], state[34], state[42], state[50], state[58]);
-    BLAKE2_ROUND(state[3], state[11], state[19], state[27], state[35], state[43], state[51], state[59]);
-    BLAKE2_ROUND(state[4], state[12], state[20], state[28], state[36], state[44], state[52], state[60]);
-    BLAKE2_ROUND(state[5], state[13], state[21], state[29], state[37], state[45], state[53], state[61]);
-    BLAKE2_ROUND(state[6], state[14], state[22], state[30], state[38], state[46], state[54], state[62]);
-    BLAKE2_ROUND(state[7], state[15], state[23], state[31], state[39], state[47], state[55], state[63]);
-    /*for (i = 0; i < 8; ++i) {
-        BLAKE2_ROUND(state[8 * 0 + i], state[8 * 1 + i], state[8 * 2 + i],
-                     state[8 * 3 + i], state[8 * 4 + i], state[8 * 5 + i],
-                     state[8 * 6 + i], state[8 * 7 + i]);
-    }*/
-
-    for (i = 0; i < ARGON2_QWORDS_IN_BLOCK; i++) {
-        state[i] = _mm_xor_si128(state[i], block_XY[i]);
-        _mm_storeu_si128(&next_block[i], state[i]);
-    }
-}
-
-static const uint64_t bad_rands[32] = {
-    UINT64_C(17023632018251376180), UINT64_C(4911461131397773491),
-    UINT64_C(15927076453364631751), UINT64_C(7860239898779391109),
-
-    UINT64_C(11820267568857244377), UINT64_C(12188179869468676617),
-    UINT64_C(3732913385414474778),  UINT64_C(7651458777762572084),
-
-    UINT64_C(3062274162574341415),  UINT64_C(17922653540258786897),
-    UINT64_C(17393848266100524980), UINT64_C(8539695715554563839),
-
-    UINT64_C(13824538050656654359), UINT64_C(12078939433126460936),
-    UINT64_C(15331979418564540430), UINT64_C(12058346794217174273),
-
-    UINT64_C(13593922096015221049), UINT64_C(18356682276374416500),
-    UINT64_C(4968040514092703824),  UINT64_C(11202790346130235567),
-
-    UINT64_C(2276229735041314644), UINT64_C(220837743321691382),
-    UINT64_C(4861211596230784273), UINT64_C(6330592584132590331),
-
-    UINT64_C(3515580430960296763), UINT64_C(9869356316971855173),
-    UINT64_C(485533243489193056),  UINT64_C(14596447761048148032),
-
-    UINT64_C(16531790085730132900), UINT64_C(17328824500878824371),
-    UINT64_C(8548260058287621283),  UINT64_C(8641748798041936364)
-};
-
-void generate_addresses(const argon2_instance_t *instance,
-                        const argon2_position_t *position,
-                        uint64_t *pseudo_rands)
-{
-    uint8_t offset = position->pass * 16 + position->slice * 4;
-    pseudo_rands[0] = bad_rands[offset++];
-    pseudo_rands[1] = bad_rands[offset++];
-    pseudo_rands[2] = bad_rands[offset++];
-    pseudo_rands[3] = bad_rands[offset++];
-
-    /*if ((position->pass == 1 && position->slice == 3))
-      print64("pseudo_rands", pseudo_rands, 4);*/
-}
-
-#define SEGMENT_LENGTH 4
-#define LANE_LENGTH 16
-#define POS_LANE 0
-
-void fill_segment(const argon2_instance_t *instance,
-                  argon2_position_t position)
-{
-    block *ref_block = NULL, *curr_block = NULL;
-    uint64_t pseudo_rand, ref_index;
-    uint32_t prev_offset, curr_offset;
-    uint8_t i;
-    __m128i state[64];
-    int data_independent_addressing = (instance->type == Argon2_i);
-
-    /* Pseudo-random values that determine the reference block position */
-    uint64_t *pseudo_rands = NULL;
-
-    pseudo_rands = (uint64_t *)malloc(/*sizeof(uint64_t) * 4*/32);
-
-    if (data_independent_addressing) {
-        generate_addresses(instance, &position, pseudo_rands);
-    }
-
-    i = 0;
-
-    if ((0 == position.pass) && (0 == position.slice)) {
-        i = 2; /* we have already generated the first two blocks */
-    }
-
-    /*printf("Position.lane = %d\nPosition.slice = %d\nStarting index : %d\n", position.lane, position.slice, starting_index);*/
-    /* Offset of the current block */
-    curr_offset = position.slice * 4 + i;
-
-    if (0 == curr_offset % 16) {
-        /* Last block in this lane */
-        prev_offset = curr_offset + /*instance->lane_length - 1*/15;
-    } else {
-        /* Previous block */
-        prev_offset = curr_offset - 1;
-    }
-
-    memcpy(state, ((instance->memory + prev_offset)->v), ARGON2_BLOCK_SIZE);
-
-    for (; i < SEGMENT_LENGTH;
-         ++i, ++curr_offset, ++prev_offset) {
-        /*1.1 Rotating prev_offset if needed */
-        if (curr_offset % LANE_LENGTH == 1) {
-            prev_offset = curr_offset - 1;
-        }
-
-        /* 1.2 Computing the index of the reference block */
-        /* 1.2.1 Taking pseudo-random value from the previous block */
-        if (data_independent_addressing) {
-            pseudo_rand = pseudo_rands[i];
-        } else {
-            pseudo_rand = instance->memory[prev_offset].v[0];
-        }
-
-        /* 1.2.2 Computing the lane of the reference block */
-
-        /* 1.2.3 Computing the number of possible reference block within the
-         * lane.
-         */
-        position.index = i;
-        ref_index = index_alpha(instance, &position, pseudo_rand & 0xFFFFFFFF,1);
-
-        /* 2 Creating a new block */
-        ref_block = instance->memory + ref_index;
-        curr_block = instance->memory + curr_offset;
-        fill_block(state, (__m128i const *)ref_block->v, (__m128i *)curr_block->v);
-    }
-
-    free(pseudo_rands);
-}

algo/argon2/ar2/opt.h

@@ -1,49 +0,0 @@
-/*
- * Argon2 source code package
- *
- * Written by Daniel Dinu and Dmitry Khovratovich, 2015
- *
- * This work is licensed under a Creative Commons CC0 1.0 License/Waiver.
- *
- * 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/>.
- */
-
-#ifndef ARGON2_OPT_H
-#define ARGON2_OPT_H
-
-/*
- * Function fills a new memory block. Differs from the
- * @param state Pointer to the just produced block. Content will be updated(!)
- * @param ref_block Pointer to the reference block
- * @param next_block Pointer to the block to be constructed
- * @pre all block pointers must be valid
- */
-void fill_block(__m128i *state, __m128i const *ref_block, __m128i *next_block);
-
-/*
- * Generate pseudo-random values to reference blocks in the segment and puts
- * them into the array
- * @param instance Pointer to the current instance
- * @param position Pointer to the current position
- * @param pseudo_rands Pointer to the array of 64-bit values
- * @pre pseudo_rands must point to @a instance->segment_length allocated values
- */
-void generate_addresses(const argon2_instance_t *instance,
-                        const argon2_position_t *position,
-                        uint64_t *pseudo_rands);
-
-/*
- * Function that fills the segment using previous segments also from other
- * threads.
- * Identical to the reference code except that it calls optimized FillBlock()
- * @param instance Pointer to the current instance
- * @param position Current position
- * @pre all block pointers must be valid
- */
-void fill_segment(const argon2_instance_t *instance,
-                  argon2_position_t position);
-
-#endif /* ARGON2_OPT_H */

algo/argon2/ar2/ref.c

@@ -1,174 +0,0 @@
-/*
- * Argon2 source code package
- *
- * Written by Daniel Dinu and Dmitry Khovratovich, 2015
- *
- * This work is licensed under a Creative Commons CC0 1.0 License/Waiver.
- *
- * 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 <stdlib.h>
-
-#include "argon2.h"
-#include "cores.h"
-#include "ref.h"
-
-#include "blake2/blamka-round-ref.h"
-#include "blake2/blake2-impl.h"
-#include "blake2/blake2.h"
-
-void fill_block(const block *prev_block, const block *ref_block,
-                block *next_block) {
-    block blockR, block_tmp;
-    unsigned i;
-
-    copy_block(&blockR, ref_block);
-    xor_block(&blockR, prev_block);
-    copy_block(&block_tmp, &blockR);
-
-    /* Apply Blake2 on columns of 64-bit words: (0,1,...,15) , then
-       (16,17,..31)... finally (112,113,...127) */
-    for (i = 0; i < 8; ++i) {
-        BLAKE2_ROUND_NOMSG(
-            blockR.v[16 * i], blockR.v[16 * i + 1], blockR.v[16 * i + 2],
-            blockR.v[16 * i + 3], blockR.v[16 * i + 4], blockR.v[16 * i + 5],
-            blockR.v[16 * i + 6], blockR.v[16 * i + 7], blockR.v[16 * i + 8],
-            blockR.v[16 * i + 9], blockR.v[16 * i + 10], blockR.v[16 * i + 11],
-            blockR.v[16 * i + 12], blockR.v[16 * i + 13], blockR.v[16 * i + 14],
-            blockR.v[16 * i + 15]);
-    }
-
-    /* Apply Blake2 on rows of 64-bit words: (0,1,16,17,...112,113), then
-       (2,3,18,19,...,114,115).. finally (14,15,30,31,...,126,127) */
-    for (i = 0; i < 8; i++) {
-        BLAKE2_ROUND_NOMSG(
-            blockR.v[2 * i], blockR.v[2 * i + 1], blockR.v[2 * i + 16],
-            blockR.v[2 * i + 17], blockR.v[2 * i + 32], blockR.v[2 * i + 33],
-            blockR.v[2 * i + 48], blockR.v[2 * i + 49], blockR.v[2 * i + 64],
-            blockR.v[2 * i + 65], blockR.v[2 * i + 80], blockR.v[2 * i + 81],
-            blockR.v[2 * i + 96], blockR.v[2 * i + 97], blockR.v[2 * i + 112],
-            blockR.v[2 * i + 113]);
-    }
-
-    copy_block(next_block, &block_tmp);
-    xor_block(next_block, &blockR);
-}
-
-void generate_addresses(const argon2_instance_t *instance,
-                        const argon2_position_t *position,
-                        uint64_t *pseudo_rands) {
-    block zero_block, input_block, address_block;
-    uint32_t i;
-
-    init_block_value(&zero_block, 0);
-    init_block_value(&input_block, 0);
-    init_block_value(&address_block, 0);
-
-    if (instance != NULL && position != NULL) {
-        input_block.v[0] = position->pass;
-        input_block.v[1] = position->lane;
-        input_block.v[2] = position->slice;
-        input_block.v[3] = 16;
-        input_block.v[4] = 2;
-        input_block.v[5] = instance->type;
-
-        for (i = 0; i < 4; ++i) {
-            if (i % ARGON2_ADDRESSES_IN_BLOCK == 0) {
-                input_block.v[6]++;
-                fill_block(&zero_block, &input_block, &address_block);
-                fill_block(&zero_block, &address_block, &address_block);
-            }
-
-            pseudo_rands[i] = address_block.v[i % ARGON2_ADDRESSES_IN_BLOCK];
-        }
-    }
-}
-
-void fill_segment(const argon2_instance_t *instance,
-                  argon2_position_t position) {
-    block *ref_block = NULL, *curr_block = NULL;
-    uint64_t pseudo_rand, ref_index, ref_lane;
-    uint32_t prev_offset, curr_offset;
-    uint32_t starting_index;
-    uint32_t i;
-    int data_independent_addressing = (instance->type == Argon2_i);
-    /* Pseudo-random values that determine the reference block position */
-    uint64_t *pseudo_rands = NULL;
-
-    if (instance == NULL) {
-        return;
-    }
-
-    pseudo_rands =
-        (uint64_t *)malloc(sizeof(uint64_t) * 4);
-
-    if (pseudo_rands == NULL) {
-        return;
-    }
-
-    if (data_independent_addressing) {
-        generate_addresses(instance, &position, pseudo_rands);
-    }
-
-    starting_index = 0;
-
-    if ((0 == position.pass) && (0 == position.slice)) {
-        starting_index = 2; /* we have already generated the first two blocks */
-    }
-
-    /* Offset of the current block */
-    curr_offset = position.lane * 16 +
-                  position.slice * 4 + starting_index;
-
-    if (0 == curr_offset % 16) {
-        /* Last block in this lane */
-        prev_offset = curr_offset + 16 - 1;
-    } else {
-        /* Previous block */
-        prev_offset = curr_offset - 1;
-    }
-
-    for (i = starting_index; i < 4; ++i, ++curr_offset, ++prev_offset) {
-        /*1.1 Rotating prev_offset if needed */
-        if (curr_offset % 16 == 1) {
-            prev_offset = curr_offset - 1;
-        }
-
-        /* 1.2 Computing the index of the reference block */
-        /* 1.2.1 Taking pseudo-random value from the previous block */
-        if (data_independent_addressing) {
-            pseudo_rand = pseudo_rands[i];
-        } else {
-            pseudo_rand = instance->memory[prev_offset].v[0];
-        }
-
-        /* 1.2.2 Computing the lane of the reference block */
-        ref_lane = ((pseudo_rand >> 32)) % 1;
-
-        if ((position.pass == 0) && (position.slice == 0)) {
-            /* Can not reference other lanes yet */
-            ref_lane = position.lane;
-        }
-
-        /* 1.2.3 Computing the number of possible reference block within the
-         * lane.
-         */
-        position.index = i;
-        ref_index = index_alpha(instance, &position, pseudo_rand & 0xFFFFFFFF,
-                                ref_lane == position.lane);
-
-        /* 2 Creating a new block */
-        ref_block =
-            instance->memory + 16 * ref_lane + ref_index;
-        curr_block = instance->memory + curr_offset;
-        fill_block(instance->memory + prev_offset, ref_block, curr_block);
-    }
-
-    free(pseudo_rands);
-}

algo/argon2/ar2/ref.h

@@ -1,49 +0,0 @@
-/*
- * Argon2 source code package
- *
- * Written by Daniel Dinu and Dmitry Khovratovich, 2015
- *
- * This work is licensed under a Creative Commons CC0 1.0 License/Waiver.
- *
- * 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/>.
- */
-
-#ifndef ARGON2_REF_H
-#define ARGON2_REF_H
-
-/*
- * Function fills a new memory block
- * @param prev_block Pointer to the previous block
- * @param ref_block Pointer to the reference block
- * @param next_block Pointer to the block to be constructed
- * @pre all block pointers must be valid
- */
-void fill_block(const block *prev_block, const block *ref_block,
-                block *next_block);
-
-/*
- * Generate pseudo-random values to reference blocks in the segment and puts
- * them into the array
- * @param instance Pointer to the current instance
- * @param position Pointer to the current position
- * @param pseudo_rands Pointer to the array of 64-bit values
- * @pre pseudo_rands must point to @a instance->segment_length allocated values
- */
-void generate_addresses(const argon2_instance_t *instance,
-                        const argon2_position_t *position,
-                        uint64_t *pseudo_rands);
-
-/*
- * Function that fills the segment using previous segments also from other
- * threads
- * @param instance Pointer to the current instance
- * @param position Current position
- * @pre all block pointers must be valid
- */
-void fill_segment(const argon2_instance_t *instance,
-                  argon2_position_t position);
-
-#endif /* ARGON2_REF_H */

algo/argon2/ar2/run.c

@@ -1,223 +0,0 @@
-/*
- * Argon2 source code package
- *
- * Written by Daniel Dinu and Dmitry Khovratovich, 2015
- *
- * This work is licensed under a Creative Commons CC0 1.0 License/Waiver.
- *
- * 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 <stdio.h>
-#include <stdint.h>
-#include <inttypes.h>
-#include <stdlib.h>
-#include <string.h>
-#include <time.h>
-
-#include "argon2.h"
-#include "cores.h"
-
-#define T_COST_DEF 3
-#define LOG_M_COST_DEF 12 /* 2^12 = 4 MiB */
-#define LANES_DEF 1
-#define THREADS_DEF 1
-#define OUT_LEN 32
-#define SALT_LEN 16
-
-#define UNUSED_PARAMETER(x) (void)(x)
-
-static void usage(const char *cmd) {
-    printf("Usage:  %s pwd salt [-y version] [-t iterations] [-m memory] [-p "
-           "parallelism]\n",
-           cmd);
-
-    printf("Parameters:\n");
-    printf("\tpwd\t\tThe password to hash\n");
-    printf("\tsalt\t\tThe salt to use, at most 16 characters\n");
-    printf("\t-d\t\tUse Argon2d instead of Argon2i (which is the default)\n");
-    printf("\t-t N\t\tSets the number of iterations to N (default = %d)\n",
-           T_COST_DEF);
-    printf("\t-m N\t\tSets the memory usage of 2^N KiB (default %d)\n",
-           LOG_M_COST_DEF);
-    printf("\t-p N\t\tSets parallelism to N threads (default %d)\n",
-           THREADS_DEF);
-}
-
-static void fatal(const char *error) {
-    fprintf(stderr, "Error: %s\n", error);
-    exit(1);
-}
-
-/*
-Runs Argon2 with certain inputs and parameters, inputs not cleared. Prints the
-Base64-encoded hash string
-@out output array with at least 32 bytes allocated
-@pwd NULL-terminated string, presumably from argv[]
-@salt salt array with at least SALTLEN_DEF bytes allocated
-@t_cost number of iterations
-@m_cost amount of requested memory in KB
-@lanes amount of requested parallelism
-@threads actual parallelism
-@type String, only "d" and "i" are accepted
-*/
-static void run(uint8_t *out, char *pwd, uint8_t *salt, uint32_t t_cost,
-                uint32_t m_cost, uint32_t lanes, uint32_t threads,
-                const char *type) {
-    clock_t start_time, stop_time;
-    unsigned pwd_length;
-    argon2_context context;
-    int i;
-
-    start_time = clock();
-
-    if (!pwd) {
-        fatal("password missing");
-    }
-
-    if (!salt) {
-        secure_wipe_memory(pwd, strlen(pwd));
-        fatal("salt missing");
-    }
-
-    pwd_length = strlen(pwd);
-
-    UNUSED_PARAMETER(threads);
-
-    context.out = out;
-    context.outlen = OUT_LEN;
-    context.pwd = (uint8_t *)pwd;
-    context.pwdlen = pwd_length;
-    context.salt = salt;
-    context.saltlen = SALT_LEN;
-    context.secret = NULL;
-    context.secretlen = 0;
-    context.ad = NULL;
-    context.adlen = 0;
-    context.t_cost = t_cost;
-    context.m_cost = m_cost;
-    context.lanes = lanes;
-    context.threads = lanes;
-    context.allocate_cbk = NULL;
-    context.free_cbk = NULL;
-    context.flags = ARGON2_FLAG_CLEAR_PASSWORD;
-
-    if (!strcmp(type, "d")) {
-        int result = argon2d(&context);
-        if (result != ARGON2_OK)
-            fatal(error_message(result));
-    } else if (!strcmp(type, "i")) {
-        int result = argon2i(&context);
-        if (result != ARGON2_OK)
-            fatal(error_message(result));
-    } else {
-        secure_wipe_memory(pwd, strlen(pwd));
-        fatal("wrong Argon2 type");
-    }
-
-    stop_time = clock();
-
-    /* add back when proper decoding */
-    /*
-    char encoded[300];
-    encode_string(encoded, sizeof encoded, &context);
-    printf("%s\n", encoded);
-    */
-    printf("Hash:\t\t");
-    for (i = 0; i < context.outlen; ++i) {
-        printf("%02x", context.out[i]);
-    }
-    printf("\n");
-
-    printf("%2.3f seconds\n",
-           ((double)stop_time - start_time) / (CLOCKS_PER_SEC));
-}
-
-int main(int argc, char *argv[]) {
-    unsigned char out[OUT_LEN];
-    uint32_t m_cost = 1 << LOG_M_COST_DEF;
-    uint32_t t_cost = T_COST_DEF;
-    uint32_t lanes = LANES_DEF;
-    uint32_t threads = THREADS_DEF;
-    char *pwd = NULL;
-    uint8_t salt[SALT_LEN];
-    const char *type = "i";
-    int i;
-
-    if (argc < 3) {
-        usage(argv[0]);
-        return ARGON2_MISSING_ARGS;
-    }
-
-    /* get password and salt from command line */
-    pwd = argv[1];
-    if (strlen(argv[2]) > SALT_LEN) {
-        fatal("salt too long");
-    }
-    memset(salt, 0x00, SALT_LEN); /* pad with null bytes */
-    memcpy(salt, argv[2], strlen(argv[2]));
-
-    /* parse options */
-    for (i = 3; i < argc; i++) {
-        const char *a = argv[i];
-        unsigned long input = 0;
-        if (!strcmp(a, "-m")) {
-            if (i < argc - 1) {
-                i++;
-                input = strtoul(argv[i], NULL, 10);
-                if (input == 0 || input == ULONG_MAX ||
-                    input > ARGON2_MAX_MEMORY_BITS) {
-                    fatal("bad numeric input for -m");
-                }
-                m_cost = ARGON2_MIN(UINT64_C(1) << input, UINT32_C(0xFFFFFFFF));
-                if (m_cost > ARGON2_MAX_MEMORY) {
-                    fatal("m_cost overflow");
-                }
-                continue;
-            } else {
-                fatal("missing -m argument");
-            }
-        } else if (!strcmp(a, "-t")) {
-            if (i < argc - 1) {
-                i++;
-                input = strtoul(argv[i], NULL, 10);
-                if (input == 0 || input == ULONG_MAX ||
-                    input > ARGON2_MAX_TIME) {
-                    fatal("bad numeric input for -t");
-                }
-                t_cost = input;
-                continue;
-            } else {
-                fatal("missing -t argument");
-            }
-        } else if (!strcmp(a, "-p")) {
-            if (i < argc - 1) {
-                i++;
-                input = strtoul(argv[i], NULL, 10);
-                if (input == 0 || input == ULONG_MAX ||
-                    input > ARGON2_MAX_THREADS || input > ARGON2_MAX_LANES) {
-                    fatal("bad numeric input for -p");
-                }
-                threads = input;
-                lanes = threads;
-                continue;
-            } else {
-                fatal("missing -p argument");
-            }
-        } else if (!strcmp(a, "-d")) {
-            type = "d";
-        } else {
-            fatal("unknown argument");
-        }
-    }
-    printf("Type:\t\tArgon2%c\n", type[0]);
-    printf("Iterations:\t%" PRIu32 " \n", t_cost);
-    printf("Memory:\t\t%" PRIu32 " KiB\n", m_cost);
-    printf("Parallelism:\t%" PRIu32 " \n", lanes);
-    run(out, pwd, salt, t_cost, m_cost, lanes, threads, type);
-
-    return ARGON2_OK;
-}

algo/argon2/ar2/sj/scrypt-jane-hash.h

@@ -1,38 +0,0 @@
-#if defined(SCRYPT_SKEIN512)
-#include "scrypt-jane-hash_skein512.h"
-#else
-	#define SCRYPT_HASH "ERROR"
-	#define SCRYPT_HASH_BLOCK_SIZE 64
-	#define SCRYPT_HASH_DIGEST_SIZE 64
-	typedef struct scrypt_hash_state_t { size_t dummy; } scrypt_hash_state;
-	typedef uint8_t scrypt_hash_digest[SCRYPT_HASH_DIGEST_SIZE];
-	static void scrypt_hash_init(scrypt_hash_state *S) {}
-	static void scrypt_hash_update(scrypt_hash_state *S, const uint8_t *in, size_t inlen) {}
-	static void scrypt_hash_finish(scrypt_hash_state *S, uint8_t *hash) {}
-	static const uint8_t scrypt_test_hash_expected[SCRYPT_HASH_DIGEST_SIZE] = {0};
-	#error must define a hash function!
-#endif
-
-#include "scrypt-jane-pbkdf2.h"
-
-#define SCRYPT_TEST_HASH_LEN 257 /* (2 * largest block size) + 1 */
-
-static int
-scrypt_test_hash(void) {
-	scrypt_hash_state st;
-	scrypt_hash_digest hash, final;
-	uint8_t msg[SCRYPT_TEST_HASH_LEN];
-	size_t i;
-
-	for (i = 0; i < SCRYPT_TEST_HASH_LEN; i++)
-		msg[i] = (uint8_t)i;
-
-	scrypt_hash_init(&st);
-	for (i = 0; i < SCRYPT_TEST_HASH_LEN + 1; i++) {
-		scrypt_hash(hash, msg, i);
-		scrypt_hash_update(&st, hash, sizeof(hash));
-	}
-	scrypt_hash_finish(&st, final);
-	return scrypt_verify(final, scrypt_test_hash_expected, SCRYPT_HASH_DIGEST_SIZE);
-}
-

algo/argon2/ar2/sj/scrypt-jane-hash_skein512.h

@@ -1,188 +0,0 @@
-#define SCRYPT_HASH "Skein-512"
-#define SCRYPT_HASH_BLOCK_SIZE 64
-#define SCRYPT_HASH_DIGEST_SIZE 64
-
-typedef uint8_t scrypt_hash_digest[SCRYPT_HASH_DIGEST_SIZE];
-
-typedef struct scrypt_hash_state_t {
-	uint64_t X[8], T[2];
-	uint32_t leftover;
-	uint8_t buffer[SCRYPT_HASH_BLOCK_SIZE];
-} scrypt_hash_state;
-
-#include <stdio.h>
-
-static void
-skein512_blocks(scrypt_hash_state *S, const uint8_t *in, size_t blocks, size_t add) {
-	uint64_t X[8], key[8], Xt[9+18], T[3+1];
-	size_t r;
-
-	while (blocks--) {
-		T[0] = S->T[0] + add;
-		T[1] = S->T[1];
-		T[2] = T[0] ^ T[1];
-		key[0] = U8TO64_LE(in +  0); Xt[0] = S->X[0]; X[0] = key[0] + Xt[0];
-		key[1] = U8TO64_LE(in +  8); Xt[1] = S->X[1]; X[1] = key[1] + Xt[1];
-		key[2] = U8TO64_LE(in + 16); Xt[2] = S->X[2]; X[2] = key[2] + Xt[2];
-		key[3] = U8TO64_LE(in + 24); Xt[3] = S->X[3]; X[3] = key[3] + Xt[3];
-		key[4] = U8TO64_LE(in + 32); Xt[4] = S->X[4]; X[4] = key[4] + Xt[4];
-		key[5] = U8TO64_LE(in + 40); Xt[5] = S->X[5]; X[5] = key[5] + Xt[5] + T[0];
-		key[6] = U8TO64_LE(in + 48); Xt[6] = S->X[6]; X[6] = key[6] + Xt[6] + T[1];
-		key[7] = U8TO64_LE(in + 56); Xt[7] = S->X[7]; X[7] = key[7] + Xt[7];
-		Xt[8] = 0x1BD11BDAA9FC1A22ull ^ Xt[0] ^ Xt[1] ^ Xt[2] ^ Xt[3] ^ Xt[4] ^ Xt[5] ^ Xt[6] ^ Xt[7];
-		in += SCRYPT_HASH_BLOCK_SIZE;
-
-		for (r = 0; r < 18; r++)
-			Xt[r + 9] = Xt[r + 0];
-
-		for (r = 0; r < 18; r += 2) {
-			X[0] += X[1]; X[1] = ROTL64(X[1], 46) ^ X[0];
-			X[2] += X[3]; X[3] = ROTL64(X[3], 36) ^ X[2];
-			X[4] += X[5]; X[5] = ROTL64(X[5], 19) ^ X[4];
-			X[6] += X[7]; X[7] = ROTL64(X[7], 37) ^ X[6];
-			X[2] += X[1]; X[1] = ROTL64(X[1], 33) ^ X[2];
-			X[0] += X[3]; X[3] = ROTL64(X[3], 42) ^ X[0];
-			X[6] += X[5]; X[5] = ROTL64(X[5], 14) ^ X[6];
-			X[4] += X[7]; X[7] = ROTL64(X[7], 27) ^ X[4];
-			X[4] += X[1]; X[1] = ROTL64(X[1], 17) ^ X[4];
-			X[6] += X[3]; X[3] = ROTL64(X[3], 49) ^ X[6];
-			X[0] += X[5]; X[5] = ROTL64(X[5], 36) ^ X[0];
-			X[2] += X[7]; X[7] = ROTL64(X[7], 39) ^ X[2];
-			X[6] += X[1]; X[1] = ROTL64(X[1], 44) ^ X[6];
-			X[4] += X[3]; X[3] = ROTL64(X[3], 56) ^ X[4];
-			X[2] += X[5]; X[5] = ROTL64(X[5], 54) ^ X[2];
-			X[0] += X[7]; X[7] = ROTL64(X[7],  9) ^ X[0];
-
-			X[0] += Xt[r + 1];
-			X[1] += Xt[r + 2];
-			X[2] += Xt[r + 3];
-			X[3] += Xt[r + 4];
-			X[4] += Xt[r + 5];
-			X[5] += Xt[r + 6] + T[1];
-			X[6] += Xt[r + 7] + T[2];
-			X[7] += Xt[r + 8] + r + 1;
-
-			T[3] = T[0];
-			T[0] = T[1];
-			T[1] = T[2];
-			T[2] = T[3];
-
-			X[0] += X[1]; X[1] = ROTL64(X[1], 39) ^ X[0];
-			X[2] += X[3]; X[3] = ROTL64(X[3], 30) ^ X[2];
-			X[4] += X[5]; X[5] = ROTL64(X[5], 34) ^ X[4];
-			X[6] += X[7]; X[7] = ROTL64(X[7], 24) ^ X[6];
-			X[2] += X[1]; X[1] = ROTL64(X[1], 13) ^ X[2];
-			X[0] += X[3]; X[3] = ROTL64(X[3], 17) ^ X[0];
-			X[6] += X[5]; X[5] = ROTL64(X[5], 10) ^ X[6];
-			X[4] += X[7]; X[7] = ROTL64(X[7], 50) ^ X[4];
-			X[4] += X[1]; X[1] = ROTL64(X[1], 25) ^ X[4];
-			X[6] += X[3]; X[3] = ROTL64(X[3], 29) ^ X[6];
-			X[0] += X[5]; X[5] = ROTL64(X[5], 39) ^ X[0];
-			X[2] += X[7]; X[7] = ROTL64(X[7], 43) ^ X[2];
-			X[6] += X[1]; X[1] = ROTL64(X[1],  8) ^ X[6];
-			X[4] += X[3]; X[3] = ROTL64(X[3], 22) ^ X[4];
-			X[2] += X[5]; X[5] = ROTL64(X[5], 56) ^ X[2];
-			X[0] += X[7]; X[7] = ROTL64(X[7], 35) ^ X[0];
-
-			X[0] += Xt[r + 2];
-			X[1] += Xt[r + 3];
-			X[2] += Xt[r + 4];
-			X[3] += Xt[r + 5];
-			X[4] += Xt[r + 6];
-			X[5] += Xt[r + 7] + T[1];
-			X[6] += Xt[r + 8] + T[2];
-			X[7] += Xt[r + 9] + r + 2;
-
-			T[3] = T[0];
-			T[0] = T[1];
-			T[1] = T[2];
-			T[2] = T[3];
-		}
-
-		S->X[0] = key[0] ^ X[0];
-		S->X[1] = key[1] ^ X[1];
-		S->X[2] = key[2] ^ X[2];
-		S->X[3] = key[3] ^ X[3];
-		S->X[4] = key[4] ^ X[4];
-		S->X[5] = key[5] ^ X[5];
-		S->X[6] = key[6] ^ X[6];
-		S->X[7] = key[7] ^ X[7];
-
-		S->T[0] = T[0];
-		S->T[1] = T[1] & ~0x4000000000000000ull;
-	}
-}
-
-static void
-scrypt_hash_init(scrypt_hash_state *S) {
-	S->X[0] = 0x4903ADFF749C51CEull;
-	S->X[1] = 0x0D95DE399746DF03ull;
-	S->X[2] = 0x8FD1934127C79BCEull;
-	S->X[3] = 0x9A255629FF352CB1ull;
-	S->X[4] = 0x5DB62599DF6CA7B0ull;
-	S->X[5] = 0xEABE394CA9D5C3F4ull;
-	S->X[6] = 0x991112C71A75B523ull;
-	S->X[7] = 0xAE18A40B660FCC33ull;
-	S->T[0] = 0x0000000000000000ull;
-	S->T[1] = 0x7000000000000000ull;
-	S->leftover = 0;
-}
-
-static void
-scrypt_hash_update(scrypt_hash_state *S, const uint8_t *in, size_t inlen) {
-	size_t blocks, want;
-
-	/* skein processes the final <=64 bytes raw, so we can only update if there are at least 64+1 bytes available */
-	if ((S->leftover + inlen) > SCRYPT_HASH_BLOCK_SIZE) {
-		/* handle the previous data, we know there is enough for at least one block */
-		if (S->leftover) {
-			want = (SCRYPT_HASH_BLOCK_SIZE - S->leftover);
-			memcpy(S->buffer + S->leftover, in, want);
-			in += want;
-			inlen -= want;
-			S->leftover = 0;
-			skein512_blocks(S, S->buffer, 1, SCRYPT_HASH_BLOCK_SIZE);
-		}
-
-		/* handle the current data if there's more than one block */
-		if (inlen > SCRYPT_HASH_BLOCK_SIZE) {
-			blocks = ((inlen - 1) & ~(SCRYPT_HASH_BLOCK_SIZE - 1));
-			skein512_blocks(S, in, blocks / SCRYPT_HASH_BLOCK_SIZE, SCRYPT_HASH_BLOCK_SIZE);
-			inlen -= blocks;
-			in += blocks;
-		}
-	}
-
-	/* handle leftover data */
-	memcpy(S->buffer + S->leftover, in, inlen);
-	S->leftover += (int) inlen;
-}
-
-static void
-scrypt_hash_finish(scrypt_hash_state *S, uint8_t *hash) {
-	memset(S->buffer + S->leftover, 0, SCRYPT_HASH_BLOCK_SIZE - S->leftover);
-	S->T[1] |= 0x8000000000000000ull;
-	skein512_blocks(S, S->buffer, 1, S->leftover);
-
-	memset(S->buffer, 0, SCRYPT_HASH_BLOCK_SIZE);
-	S->T[0] = 0;
-	S->T[1] = 0xff00000000000000ull;
-	skein512_blocks(S, S->buffer, 1, 8);
-
-	U64TO8_LE(&hash[ 0], S->X[0]);
-	U64TO8_LE(&hash[ 8], S->X[1]);
-	U64TO8_LE(&hash[16], S->X[2]);
-	U64TO8_LE(&hash[24], S->X[3]);
-	U64TO8_LE(&hash[32], S->X[4]);
-	U64TO8_LE(&hash[40], S->X[5]);
-	U64TO8_LE(&hash[48], S->X[6]);
-	U64TO8_LE(&hash[56], S->X[7]);
-}
-
-
-static const uint8_t scrypt_test_hash_expected[SCRYPT_HASH_DIGEST_SIZE] = {
-	0x4d,0x52,0x29,0xff,0x10,0xbc,0xd2,0x62,0xd1,0x61,0x83,0xc8,0xe6,0xf0,0x83,0xc4,
-	0x9f,0xf5,0x6a,0x42,0x75,0x2a,0x26,0x4e,0xf0,0x28,0x72,0x28,0x47,0xe8,0x23,0xdf,
-	0x1e,0x64,0xf1,0x51,0x38,0x35,0x9d,0xc2,0x83,0xfc,0x35,0x4e,0xc0,0x52,0x5f,0x41,
-	0x6a,0x0b,0x7d,0xf5,0xce,0x98,0xde,0x6f,0x36,0xd8,0x51,0x15,0x78,0x78,0x93,0x67,
-};

algo/argon2/ar2/sj/scrypt-jane-mix_salsa64-avx.h

@@ -1,367 +0,0 @@
-/* x64 */
-#if defined(X86_64ASM_AVX) && (!defined(SCRYPT_CHOOSE_COMPILETIME) || !defined(SCRYPT_SALSA64_INCLUDED)) && !defined(CPU_X86_FORCE_INTRINSICS)
-
-#define SCRYPT_SALSA64_AVX
-
-asm_naked_fn_proto(void, scrypt_ChunkMix_avx)(uint64_t *Bout/*[chunkBytes]*/, uint64_t *Bin/*[chunkBytes]*/, uint64_t *Bxor/*[chunkBytes]*/, uint32_t r)
-asm_naked_fn(scrypt_ChunkMix_avx)
-	a1(push rbp)
-	a2(mov rbp, rsp)
-	a2(and rsp, ~63)
-	a2(sub rsp, 128)
-	a2(lea rcx,[ecx*2]) /* zero extend uint32_t by using ecx, win64 can leave garbage in the top half */
-	a2(shl rcx,7)
-	a2(lea r9,[rcx-128])
-	a2(lea rax,[rsi+r9])
-	a2(lea r9,[rdx+r9])
-	a2(and rdx, rdx)
-	a2(vmovdqa xmm0,[rax+0])
-	a2(vmovdqa xmm1,[rax+16])
-	a2(vmovdqa xmm2,[rax+32])
-	a2(vmovdqa xmm3,[rax+48])
-	a2(vmovdqa xmm4,[rax+64])
-	a2(vmovdqa xmm5,[rax+80])
-	a2(vmovdqa xmm6,[rax+96])
-	a2(vmovdqa xmm7,[rax+112])
-	aj(jz scrypt_ChunkMix_avx_no_xor1)
-	a3(vpxor xmm0,xmm0,[r9+0])
-	a3(vpxor xmm1,xmm1,[r9+16])
-	a3(vpxor xmm2,xmm2,[r9+32])
-	a3(vpxor xmm3,xmm3,[r9+48])
-	a3(vpxor xmm4,xmm4,[r9+64])
-	a3(vpxor xmm5,xmm5,[r9+80])
-	a3(vpxor xmm6,xmm6,[r9+96])
-	a3(vpxor xmm7,xmm7,[r9+112])
-	a1(scrypt_ChunkMix_avx_no_xor1:)
-	a2(xor r9,r9)
-	a2(xor r8,r8)
-	a1(scrypt_ChunkMix_avx_loop:)
-		a2(and rdx, rdx)
-		a3(vpxor xmm0,xmm0,[rsi+r9+0])
-		a3(vpxor xmm1,xmm1,[rsi+r9+16])
-		a3(vpxor xmm2,xmm2,[rsi+r9+32])
-		a3(vpxor xmm3,xmm3,[rsi+r9+48])
-		a3(vpxor xmm4,xmm4,[rsi+r9+64])
-		a3(vpxor xmm5,xmm5,[rsi+r9+80])
-		a3(vpxor xmm6,xmm6,[rsi+r9+96])
-		a3(vpxor xmm7,xmm7,[rsi+r9+112])
-		aj(jz scrypt_ChunkMix_avx_no_xor2)
-		a3(vpxor xmm0,xmm0,[rdx+r9+0])
-		a3(vpxor xmm1,xmm1,[rdx+r9+16])
-		a3(vpxor xmm2,xmm2,[rdx+r9+32])
-		a3(vpxor xmm3,xmm3,[rdx+r9+48])
-		a3(vpxor xmm4,xmm4,[rdx+r9+64])
-		a3(vpxor xmm5,xmm5,[rdx+r9+80])
-		a3(vpxor xmm6,xmm6,[rdx+r9+96])
-		a3(vpxor xmm7,xmm7,[rdx+r9+112])
-		a1(scrypt_ChunkMix_avx_no_xor2:)
-		a2(vmovdqa [rsp+0],xmm0)
-		a2(vmovdqa [rsp+16],xmm1)
-		a2(vmovdqa [rsp+32],xmm2)
-		a2(vmovdqa [rsp+48],xmm3)
-		a2(vmovdqa [rsp+64],xmm4)
-		a2(vmovdqa [rsp+80],xmm5)
-		a2(vmovdqa [rsp+96],xmm6)
-		a2(vmovdqa [rsp+112],xmm7)
-		a2(mov rax,8)
-		a1(scrypt_salsa64_avx_loop: )
-			a3(vpaddq xmm8, xmm0, xmm2)
-			a3(vpaddq xmm9, xmm1, xmm3)
-			a3(vpshufd xmm8, xmm8, 0xb1)
-			a3(vpshufd xmm9, xmm9, 0xb1)
-			a3(vpxor xmm6, xmm6, xmm8)
-			a3(vpxor xmm7, xmm7, xmm9)
-			a3(vpaddq xmm10, xmm0, xmm6)
-			a3(vpaddq xmm11, xmm1, xmm7)
-			a3(vpsrlq xmm8, xmm10, 51)
-			a3(vpsrlq xmm9, xmm11, 51)
-			a3(vpsllq xmm10, xmm10, 13)
-			a3(vpsllq xmm11, xmm11, 13)
-			a3(vpxor xmm4, xmm4, xmm8)
-			a3(vpxor xmm5, xmm5, xmm9)
-			a3(vpxor xmm4, xmm4, xmm10)
-			a3(vpxor xmm5, xmm5, xmm11)
-			a3(vpaddq xmm8, xmm6, xmm4)
-			a3(vpaddq xmm9, xmm7, xmm5)
-			a3(vpsrlq xmm10, xmm8, 25)
-			a3(vpsrlq xmm11, xmm9, 25)
-			a3(vpsllq xmm8, xmm8, 39)
-			a3(vpsllq xmm9, xmm9, 39)
-			a3(vpxor xmm2, xmm2, xmm10)
-			a3(vpxor xmm3, xmm3, xmm11)
-			a3(vpxor xmm2, xmm2, xmm8)
-			a3(vpxor xmm3, xmm3, xmm9)
-			a3(vpaddq xmm10, xmm4, xmm2)
-			a3(vpaddq xmm11, xmm5, xmm3)
-			a3(vpshufd xmm10, xmm10, 0xb1)
-			a3(vpshufd xmm11, xmm11, 0xb1)
-			a3(vpxor xmm0, xmm0, xmm10)
-			a3(vpxor xmm1, xmm1, xmm11)
-			a2(vmovdqa xmm8, xmm2)
-			a2(vmovdqa xmm9, xmm3)
-			a4(vpalignr xmm2, xmm6, xmm7, 8)
-			a4(vpalignr xmm3, xmm7, xmm6, 8)
-			a4(vpalignr xmm6, xmm9, xmm8, 8)
-			a4(vpalignr xmm7, xmm8, xmm9, 8)
-			a3(vpaddq xmm10, xmm0, xmm2)
-			a3(vpaddq xmm11, xmm1, xmm3)
-			a3(vpshufd xmm10, xmm10, 0xb1)
-			a3(vpshufd xmm11, xmm11, 0xb1)
-			a3(vpxor xmm6, xmm6, xmm10)
-			a3(vpxor xmm7, xmm7, xmm11)
-			a3(vpaddq xmm8, xmm0, xmm6)
-			a3(vpaddq xmm9, xmm1, xmm7)
-			a3(vpsrlq xmm10, xmm8, 51)
-			a3(vpsrlq xmm11, xmm9, 51)
-			a3(vpsllq xmm8, xmm8, 13)
-			a3(vpsllq xmm9, xmm9, 13)
-			a3(vpxor xmm5, xmm5, xmm10)
-			a3(vpxor xmm4, xmm4, xmm11)
-			a3(vpxor xmm5, xmm5, xmm8)
-			a3(vpxor xmm4, xmm4, xmm9)
-			a3(vpaddq xmm10, xmm6, xmm5)
-			a3(vpaddq xmm11, xmm7, xmm4)
-			a3(vpsrlq xmm8, xmm10, 25)
-			a3(vpsrlq xmm9, xmm11, 25)
-			a3(vpsllq xmm10, xmm10, 39)
-			a3(vpsllq xmm11, xmm11, 39)
-			a3(vpxor xmm2, xmm2, xmm8)
-			a3(vpxor xmm3, xmm3, xmm9)
-			a3(vpxor xmm2, xmm2, xmm10)
-			a3(vpxor xmm3, xmm3, xmm11)
-			a3(vpaddq xmm8, xmm5, xmm2)
-			a3(vpaddq xmm9, xmm4, xmm3)
-			a3(vpshufd xmm8, xmm8, 0xb1)
-			a3(vpshufd xmm9, xmm9, 0xb1)
-			a3(vpxor xmm0, xmm0, xmm8)
-			a3(vpxor xmm1, xmm1, xmm9)
-			a2(vmovdqa xmm10, xmm2)
-			a2(vmovdqa xmm11, xmm3)
-			a4(vpalignr xmm2, xmm6, xmm7, 8)
-			a4(vpalignr xmm3, xmm7, xmm6, 8)
-			a4(vpalignr xmm6, xmm11, xmm10, 8)
-			a4(vpalignr xmm7, xmm10, xmm11, 8)
-			a2(sub rax, 2)
-			aj(ja scrypt_salsa64_avx_loop)
-		a3(vpaddq xmm0,xmm0,[rsp+0])
-		a3(vpaddq xmm1,xmm1,[rsp+16])
-		a3(vpaddq xmm2,xmm2,[rsp+32])
-		a3(vpaddq xmm3,xmm3,[rsp+48])
-		a3(vpaddq xmm4,xmm4,[rsp+64])
-		a3(vpaddq xmm5,xmm5,[rsp+80])
-		a3(vpaddq xmm6,xmm6,[rsp+96])
-		a3(vpaddq xmm7,xmm7,[rsp+112])
-		a2(lea rax,[r8+r9])
-		a2(xor r8,rcx)
-		a2(and rax,~0xff)
-		a2(add r9,128)
-		a2(shr rax,1)
-		a2(add rax, rdi)
-		a2(cmp r9,rcx)
-		a2(vmovdqa [rax+0],xmm0)
-		a2(vmovdqa [rax+16],xmm1)
-		a2(vmovdqa [rax+32],xmm2)
-		a2(vmovdqa [rax+48],xmm3)
-		a2(vmovdqa [rax+64],xmm4)
-		a2(vmovdqa [rax+80],xmm5)
-		a2(vmovdqa [rax+96],xmm6)
-		a2(vmovdqa [rax+112],xmm7)
-		aj(jne scrypt_ChunkMix_avx_loop)
-	a2(mov rsp, rbp)
-	a1(pop rbp)
-	a1(ret)
-asm_naked_fn_end(scrypt_ChunkMix_avx)
-
-#endif
-
-
-/* intrinsic */
-#if defined(X86_INTRINSIC_AVX) && (!defined(SCRYPT_CHOOSE_COMPILETIME) || !defined(SCRYPT_SALSA64_INCLUDED))
-
-#define SCRYPT_SALSA64_AVX
-
-static void asm_calling_convention
-scrypt_ChunkMix_avx(uint64_t *Bout/*[chunkBytes]*/, uint64_t *Bin/*[chunkBytes]*/, uint64_t *Bxor/*[chunkBytes]*/, uint32_t r) {
-	uint32_t i, blocksPerChunk = r * 2, half = 0;
-	xmmi *xmmp,x0,x1,x2,x3,x4,x5,x6,x7,t0,t1,t2,t3,t4,t5,t6,t7,z0,z1,z2,z3;
-	size_t rounds;
-
-	/* 1: X = B_{2r - 1} */
-	xmmp = (xmmi *)scrypt_block(Bin, blocksPerChunk - 1);
-	x0 = xmmp[0];
-	x1 = xmmp[1];
-	x2 = xmmp[2];
-	x3 = xmmp[3];
-	x4 = xmmp[4];
-	x5 = xmmp[5];
-	x6 = xmmp[6];
-	x7 = xmmp[7];
-
-	if (Bxor) {
-		xmmp = (xmmi *)scrypt_block(Bxor, blocksPerChunk - 1);
-		x0 = _mm_xor_si128(x0, xmmp[0]);
-		x1 = _mm_xor_si128(x1, xmmp[1]);
-		x2 = _mm_xor_si128(x2, xmmp[2]);
-		x3 = _mm_xor_si128(x3, xmmp[3]);
-		x4 = _mm_xor_si128(x4, xmmp[4]);
-		x5 = _mm_xor_si128(x5, xmmp[5]);
-		x6 = _mm_xor_si128(x6, xmmp[6]);
-		x7 = _mm_xor_si128(x7, xmmp[7]);
-	}
-
-	/* 2: for i = 0 to 2r - 1 do */
-	for (i = 0; i < blocksPerChunk; i++, half ^= r) {
-		/* 3: X = H(X ^ B_i) */
-		xmmp = (xmmi *)scrypt_block(Bin, i);
-		x0 = _mm_xor_si128(x0, xmmp[0]);
-		x1 = _mm_xor_si128(x1, xmmp[1]);
-		x2 = _mm_xor_si128(x2, xmmp[2]);
-		x3 = _mm_xor_si128(x3, xmmp[3]);
-		x4 = _mm_xor_si128(x4, xmmp[4]);
-		x5 = _mm_xor_si128(x5, xmmp[5]);
-		x6 = _mm_xor_si128(x6, xmmp[6]);
-		x7 = _mm_xor_si128(x7, xmmp[7]);
-
-		if (Bxor) {
-			xmmp = (xmmi *)scrypt_block(Bxor, i);
-			x0 = _mm_xor_si128(x0, xmmp[0]);
-			x1 = _mm_xor_si128(x1, xmmp[1]);
-			x2 = _mm_xor_si128(x2, xmmp[2]);
-			x3 = _mm_xor_si128(x3, xmmp[3]);
-			x4 = _mm_xor_si128(x4, xmmp[4]);
-			x5 = _mm_xor_si128(x5, xmmp[5]);
-			x6 = _mm_xor_si128(x6, xmmp[6]);
-			x7 = _mm_xor_si128(x7, xmmp[7]);
-		}
-
-		t0 = x0;
-		t1 = x1;
-		t2 = x2;
-		t3 = x3;
-		t4 = x4;
-		t5 = x5;
-		t6 = x6;
-		t7 = x7;
-
-		for (rounds = 8; rounds; rounds -= 2) {
-			z0 = _mm_add_epi64(x0, x2);
-			z1 = _mm_add_epi64(x1, x3);
-			z0 = _mm_shuffle_epi32(z0, _MM_SHUFFLE(2,3,0,1));
-			z1 = _mm_shuffle_epi32(z1, _MM_SHUFFLE(2,3,0,1));
-			x6 = _mm_xor_si128(x6, z0);
-			x7 = _mm_xor_si128(x7, z1);
-
-			z0 = _mm_add_epi64(x6, x0);
-			z1 = _mm_add_epi64(x7, x1);
-			z2 = _mm_srli_epi64(z0, 64-13);
-			z3 = _mm_srli_epi64(z1, 64-13);
-			z0 = _mm_slli_epi64(z0, 13);
-			z1 = _mm_slli_epi64(z1, 13);
-			x4 = _mm_xor_si128(x4, z2);
-			x5 = _mm_xor_si128(x5, z3);
-			x4 = _mm_xor_si128(x4, z0);
-			x5 = _mm_xor_si128(x5, z1);
-
-			z0 = _mm_add_epi64(x4, x6);
-			z1 = _mm_add_epi64(x5, x7);
-			z2 = _mm_srli_epi64(z0, 64-39);
-			z3 = _mm_srli_epi64(z1, 64-39);
-			z0 = _mm_slli_epi64(z0, 39);
-			z1 = _mm_slli_epi64(z1, 39);
-			x2 = _mm_xor_si128(x2, z2);
-			x3 = _mm_xor_si128(x3, z3);
-			x2 = _mm_xor_si128(x2, z0);
-			x3 = _mm_xor_si128(x3, z1);
-
-			z0 = _mm_add_epi64(x2, x4);
-			z1 = _mm_add_epi64(x3, x5);
-			z0 = _mm_shuffle_epi32(z0, _MM_SHUFFLE(2,3,0,1));
-			z1 = _mm_shuffle_epi32(z1, _MM_SHUFFLE(2,3,0,1));
-			x0 = _mm_xor_si128(x0, z0);
-			x1 = _mm_xor_si128(x1, z1);
-
-			z0 = x2;
-			z1 = x3;
-			x2 = _mm_alignr_epi8(x6, x7, 8);
-			x3 = _mm_alignr_epi8(x7, x6, 8);
-			x6 = _mm_alignr_epi8(z1, z0, 8);
-			x7 = _mm_alignr_epi8(z0, z1, 8);
-
-			z0 = _mm_add_epi64(x0, x2);
-			z1 = _mm_add_epi64(x1, x3);
-			z0 = _mm_shuffle_epi32(z0, _MM_SHUFFLE(2,3,0,1));
-			z1 = _mm_shuffle_epi32(z1, _MM_SHUFFLE(2,3,0,1));
-			x6 = _mm_xor_si128(x6, z0);
-			x7 = _mm_xor_si128(x7, z1);
-
-			z0 = _mm_add_epi64(x6, x0);
-			z1 = _mm_add_epi64(x7, x1);
-			z2 = _mm_srli_epi64(z0, 64-13);
-			z3 = _mm_srli_epi64(z1, 64-13);
-			z0 = _mm_slli_epi64(z0, 13);
-			z1 = _mm_slli_epi64(z1, 13);
-			x5 = _mm_xor_si128(x5, z2);
-			x4 = _mm_xor_si128(x4, z3);
-			x5 = _mm_xor_si128(x5, z0);
-			x4 = _mm_xor_si128(x4, z1);
-
-			z0 = _mm_add_epi64(x5, x6);
-			z1 = _mm_add_epi64(x4, x7);
-			z2 = _mm_srli_epi64(z0, 64-39);
-			z3 = _mm_srli_epi64(z1, 64-39);
-			z0 = _mm_slli_epi64(z0, 39);
-			z1 = _mm_slli_epi64(z1, 39);
-			x2 = _mm_xor_si128(x2, z2);
-			x3 = _mm_xor_si128(x3, z3);
-			x2 = _mm_xor_si128(x2, z0);
-			x3 = _mm_xor_si128(x3, z1);
-
-			z0 = _mm_add_epi64(x2, x5);
-			z1 = _mm_add_epi64(x3, x4);
-			z0 = _mm_shuffle_epi32(z0, _MM_SHUFFLE(2,3,0,1));
-			z1 = _mm_shuffle_epi32(z1, _MM_SHUFFLE(2,3,0,1));
-			x0 = _mm_xor_si128(x0, z0);
-			x1 = _mm_xor_si128(x1, z1);
-
-			z0 = x2;
-			z1 = x3;
-			x2 = _mm_alignr_epi8(x6, x7, 8);
-			x3 = _mm_alignr_epi8(x7, x6, 8);
-			x6 = _mm_alignr_epi8(z1, z0, 8);
-			x7 = _mm_alignr_epi8(z0, z1, 8);
-		}
-
-		x0 = _mm_add_epi64(x0, t0);
-		x1 = _mm_add_epi64(x1, t1);
-		x2 = _mm_add_epi64(x2, t2);
-		x3 = _mm_add_epi64(x3, t3);
-		x4 = _mm_add_epi64(x4, t4);
-		x5 = _mm_add_epi64(x5, t5);
-		x6 = _mm_add_epi64(x6, t6);
-		x7 = _mm_add_epi64(x7, t7);
-
-		/* 4: Y_i = X */
-		/* 6: B'[0..r-1] = Y_even */
-		/* 6: B'[r..2r-1] = Y_odd */
-		xmmp = (xmmi *)scrypt_block(Bout, (i / 2) + half);
-		xmmp[0] = x0;
-		xmmp[1] = x1;
-		xmmp[2] = x2;
-		xmmp[3] = x3;
-		xmmp[4] = x4;
-		xmmp[5] = x5;
-		xmmp[6] = x6;
-		xmmp[7] = x7;
-	}
-}
-
-#endif
-
-#if defined(SCRYPT_SALSA64_AVX)
-	/* uses salsa64_core_tangle_sse2 */
-
-	#undef SCRYPT_MIX
-	#define SCRYPT_MIX "Salsa64/8-AVX"
-	#undef SCRYPT_SALSA64_INCLUDED
-	#define SCRYPT_SALSA64_INCLUDED
-#endif

algo/argon2/ar2/sj/scrypt-jane-mix_salsa64-avx2.h

@@ -1,221 +0,0 @@
-/* x64 */
-#if defined(X86_64ASM_AVX2) && (!defined(SCRYPT_CHOOSE_COMPILETIME) || !defined(SCRYPT_SALSA64_INCLUDED)) && !defined(CPU_X86_FORCE_INTRINSICS)
-
-#define SCRYPT_SALSA64_AVX2
-
-asm_naked_fn_proto(void, scrypt_ChunkMix_avx2)(uint64_t *Bout/*[chunkBytes]*/, uint64_t *Bin/*[chunkBytes]*/, uint64_t *Bxor/*[chunkBytes]*/, uint32_t r)
-asm_naked_fn(scrypt_ChunkMix_avx2)
-	a2(lea rcx,[ecx*2]) /* zero extend uint32_t by using ecx, win64 can leave garbage in the top half */
-	a2(shl rcx,7)
-	a2(lea r9,[rcx-128])
-	a2(lea rax,[rsi+r9])
-	a2(lea r9,[rdx+r9])
-	a2(and rdx, rdx)
-	a2(vmovdqa ymm0,[rax+0])
-	a2(vmovdqa ymm1,[rax+32])
-	a2(vmovdqa ymm2,[rax+64])
-	a2(vmovdqa ymm3,[rax+96])
-	aj(jz scrypt_ChunkMix_avx2_no_xor1)
-	a3(vpxor ymm0,ymm0,[r9+0])
-	a3(vpxor ymm1,ymm1,[r9+32])
-	a3(vpxor ymm2,ymm2,[r9+64])
-	a3(vpxor ymm3,ymm3,[r9+96])
-	a1(scrypt_ChunkMix_avx2_no_xor1:)
-	a2(xor r9,r9)
-	a2(xor r8,r8)
-	a1(scrypt_ChunkMix_avx2_loop:)
-		a2(and rdx, rdx)
-		a3(vpxor ymm0,ymm0,[rsi+r9+0])
-		a3(vpxor ymm1,ymm1,[rsi+r9+32])
-		a3(vpxor ymm2,ymm2,[rsi+r9+64])
-		a3(vpxor ymm3,ymm3,[rsi+r9+96])
-		aj(jz scrypt_ChunkMix_avx2_no_xor2)
-		a3(vpxor ymm0,ymm0,[rdx+r9+0])
-		a3(vpxor ymm1,ymm1,[rdx+r9+32])
-		a3(vpxor ymm2,ymm2,[rdx+r9+64])
-		a3(vpxor ymm3,ymm3,[rdx+r9+96])
-		a1(scrypt_ChunkMix_avx2_no_xor2:)
-		a2(vmovdqa ymm6,ymm0)
-		a2(vmovdqa ymm7,ymm1)
-		a2(vmovdqa ymm8,ymm2)
-		a2(vmovdqa ymm9,ymm3)
-		a2(mov rax,4)
-		a1(scrypt_salsa64_avx2_loop: )
-			a3(vpaddq ymm4, ymm1, ymm0)
-			a3(vpshufd ymm4, ymm4, 0xb1)
-			a3(vpxor ymm3, ymm3, ymm4)
-			a3(vpaddq ymm4, ymm0, ymm3)
-			a3(vpsrlq ymm5, ymm4, 51)
-			a3(vpxor ymm2, ymm2, ymm5)
-			a3(vpsllq ymm4, ymm4, 13)
-			a3(vpxor ymm2, ymm2, ymm4)
-			a3(vpaddq ymm4, ymm3, ymm2)
-			a3(vpsrlq ymm5, ymm4, 25)
-			a3(vpxor ymm1, ymm1, ymm5)
-			a3(vpsllq ymm4, ymm4, 39)
-			a3(vpxor ymm1, ymm1, ymm4)
-			a3(vpaddq ymm4, ymm2, ymm1)
-			a3(vpshufd ymm4, ymm4, 0xb1)
-			a3(vpermq ymm1, ymm1, 0x39)
-			a3(vpermq ymm10, ymm2, 0x4e)
-			a3(vpxor ymm0, ymm0, ymm4)
-			a3(vpermq ymm3, ymm3, 0x93)
-			a3(vpaddq ymm4, ymm3, ymm0)
-			a3(vpshufd ymm4, ymm4, 0xb1)
-			a3(vpxor ymm1, ymm1, ymm4)
-			a3(vpaddq ymm4, ymm0, ymm1)
-			a3(vpsrlq ymm5, ymm4, 51)
-			a3(vpxor ymm10, ymm10, ymm5)
-			a3(vpsllq ymm4, ymm4, 13)
-			a3(vpxor ymm10, ymm10, ymm4)
-			a3(vpaddq ymm4, ymm1, ymm10)
-			a3(vpsrlq ymm5, ymm4, 25)
-			a3(vpxor ymm3, ymm3, ymm5)
-			a3(vpsllq ymm4, ymm4, 39)
-			a3(vpermq ymm1, ymm1, 0x93)
-			a3(vpxor ymm3, ymm3, ymm4)
-			a3(vpermq ymm2, ymm10, 0x4e)
-			a3(vpaddq ymm4, ymm10, ymm3)
-			a3(vpshufd ymm4, ymm4, 0xb1)
-			a3(vpermq ymm3, ymm3, 0x39)
-			a3(vpxor ymm0, ymm0, ymm4)
-			a1(dec rax)
-			aj(jnz scrypt_salsa64_avx2_loop)
-		a3(vpaddq ymm0,ymm0,ymm6)
-		a3(vpaddq ymm1,ymm1,ymm7)
-		a3(vpaddq ymm2,ymm2,ymm8)
-		a3(vpaddq ymm3,ymm3,ymm9)
-		a2(lea rax,[r8+r9])
-		a2(xor r8,rcx)
-		a2(and rax,~0xff)
-		a2(add r9,128)
-		a2(shr rax,1)
-		a2(add rax, rdi)
-		a2(cmp r9,rcx)
-		a2(vmovdqa [rax+0],ymm0)
-		a2(vmovdqa [rax+32],ymm1)
-		a2(vmovdqa [rax+64],ymm2)
-		a2(vmovdqa [rax+96],ymm3)
-		aj(jne scrypt_ChunkMix_avx2_loop)
-	a1(vzeroupper)
-	a1(ret)
-asm_naked_fn_end(scrypt_ChunkMix_avx2)
-
-#endif
-
-
-/* intrinsic */
-#if defined(X86_INTRINSIC_AVX2) && (!defined(SCRYPT_CHOOSE_COMPILETIME) || !defined(SCRYPT_SALSA64_INCLUDED))
-
-#define SCRYPT_SALSA64_AVX2
-
-static void asm_calling_convention
-scrypt_ChunkMix_avx2(uint64_t *Bout/*[chunkBytes]*/, uint64_t *Bin/*[chunkBytes]*/, uint64_t *Bxor/*[chunkBytes]*/, uint32_t r) {
-	uint32_t i, blocksPerChunk = r * 2, half = 0;
-	ymmi *ymmp,y0,y1,y2,y3,t0,t1,t2,t3,z0,z1;
-	size_t rounds;
-
-	/* 1: X = B_{2r - 1} */
-	ymmp = (ymmi *)scrypt_block(Bin, blocksPerChunk - 1);
-	y0 = ymmp[0];
-	y1 = ymmp[1];
-	y2 = ymmp[2];
-	y3 = ymmp[3];
-
-	if (Bxor) {
-		ymmp = (ymmi *)scrypt_block(Bxor, blocksPerChunk - 1);
-		y0 = _mm256_xor_si256(y0, ymmp[0]);
-		y1 = _mm256_xor_si256(y1, ymmp[1]);
-		y2 = _mm256_xor_si256(y2, ymmp[2]);
-		y3 = _mm256_xor_si256(y3, ymmp[3]);
-	}
-
-	/* 2: for i = 0 to 2r - 1 do */
-	for (i = 0; i < blocksPerChunk; i++, half ^= r) {
-		/* 3: X = H(X ^ B_i) */
-		ymmp = (ymmi *)scrypt_block(Bin, i);
-		y0 = _mm256_xor_si256(y0, ymmp[0]);
-		y1 = _mm256_xor_si256(y1, ymmp[1]);
-		y2 = _mm256_xor_si256(y2, ymmp[2]);
-		y3 = _mm256_xor_si256(y3, ymmp[3]);
-
-		if (Bxor) {
-			ymmp = (ymmi *)scrypt_block(Bxor, i);
-			y0 = _mm256_xor_si256(y0, ymmp[0]);
-			y1 = _mm256_xor_si256(y1, ymmp[1]);
-			y2 = _mm256_xor_si256(y2, ymmp[2]);
-			y3 = _mm256_xor_si256(y3, ymmp[3]);
-		}
-
-		t0 = y0;
-		t1 = y1;
-		t2 = y2;
-		t3 = y3;
-
-		for (rounds = 8; rounds; rounds -= 2) {
-			z0 = _mm256_add_epi64(y0, y1);
-			z0 = _mm256_shuffle_epi32(z0, _MM_SHUFFLE(2,3,0,1));
-			y3 = _mm256_xor_si256(y3, z0);
-			z0 = _mm256_add_epi64(y3, y0);
-			z1 = _mm256_srli_epi64(z0, 64-13);
-			y2 = _mm256_xor_si256(y2, z1);
-			z0 = _mm256_slli_epi64(z0, 13);
-			y2 = _mm256_xor_si256(y2, z0);
-			z0 = _mm256_add_epi64(y2, y3);
-			z1 = _mm256_srli_epi64(z0, 64-39);
-			y1 = _mm256_xor_si256(y1, z1);
-			z0 = _mm256_slli_epi64(z0, 39);
-			y1 = _mm256_xor_si256(y1, z0);
-			y1 = _mm256_permute4x64_epi64(y1, _MM_SHUFFLE(0,3,2,1));
-			y2 = _mm256_permute4x64_epi64(y2, _MM_SHUFFLE(1,0,3,2));
-			y3 = _mm256_permute4x64_epi64(y3, _MM_SHUFFLE(2,1,0,3));
-			z0 = _mm256_add_epi64(y1, y2);
-			z0 = _mm256_shuffle_epi32(z0, _MM_SHUFFLE(2,3,0,1));
-			y0 = _mm256_xor_si256(y0, z0);
-			z0 = _mm256_add_epi64(y0, y3);
-			z0 = _mm256_shuffle_epi32(z0, _MM_SHUFFLE(2,3,0,1));
-			y1 = _mm256_xor_si256(y1, z0);
-			z0 = _mm256_add_epi64(y1, y0);
-			z1 = _mm256_srli_epi64(z0, 64-13);
-			y2 = _mm256_xor_si256(y2, z1);
-			z0 = _mm256_slli_epi64(z0, 13);
-			y2 = _mm256_xor_si256(y2, z0);
-			z0 = _mm256_add_epi64(y2, y1);
-			z1 = _mm256_srli_epi64(z0, 64-39);
-			y3 = _mm256_xor_si256(y3, z1);
-			z0 = _mm256_slli_epi64(z0, 39);
-			y3 = _mm256_xor_si256(y3, z0);
-			z0 = _mm256_add_epi64(y3, y2);
-			z0 = _mm256_shuffle_epi32(z0, _MM_SHUFFLE(2,3,0,1));
-			y0 = _mm256_xor_si256(y0, z0);
-			y1 = _mm256_permute4x64_epi64(y1, _MM_SHUFFLE(2,1,0,3));
-			y2 = _mm256_permute4x64_epi64(y2, _MM_SHUFFLE(1,0,3,2));
-			y3 = _mm256_permute4x64_epi64(y3, _MM_SHUFFLE(0,3,2,1));
-		}
-
-		y0 = _mm256_add_epi64(y0, t0);
-		y1 = _mm256_add_epi64(y1, t1);
-		y2 = _mm256_add_epi64(y2, t2);
-		y3 = _mm256_add_epi64(y3, t3);
-
-		/* 4: Y_i = X */
-		/* 6: B'[0..r-1] = Y_even */
-		/* 6: B'[r..2r-1] = Y_odd */
-		ymmp = (ymmi *)scrypt_block(Bout, (i / 2) + half);
-		ymmp[0] = y0;
-		ymmp[1] = y1;
-		ymmp[2] = y2;
-		ymmp[3] = y3;
-	}
-}
-
-#endif
-
-#if defined(SCRYPT_SALSA64_AVX2)
-	/* uses salsa64_core_tangle_sse2 */
-
-	#undef SCRYPT_MIX
-	#define SCRYPT_MIX "Salsa64/8-AVX2"
-	#undef SCRYPT_SALSA64_INCLUDED
-	#define SCRYPT_SALSA64_INCLUDED
-#endif

algo/argon2/ar2/sj/scrypt-jane-mix_salsa64-sse2.h

@@ -1,449 +0,0 @@
-/* x64 */
-#if defined(X86_64ASM_SSE2) && (!defined(SCRYPT_CHOOSE_COMPILETIME) || !defined(SCRYPT_SALSA64_INCLUDED)) && !defined(CPU_X86_FORCE_INTRINSICS)
-
-#define SCRYPT_SALSA64_SSE2
-
-asm_naked_fn_proto(void, scrypt_ChunkMix_sse2)(uint64_t *Bout/*[chunkBytes]*/, uint64_t *Bin/*[chunkBytes]*/, uint64_t *Bxor/*[chunkBytes]*/, uint32_t r)
-asm_naked_fn(scrypt_ChunkMix_sse2)
-	a1(push rbp)
-	a2(mov rbp, rsp)
-	a2(and rsp, ~63)
-	a2(sub rsp, 128)
-	a2(lea rcx,[ecx*2]) /* zero extend uint32_t by using ecx, win64 can leave garbage in the top half */
-	a2(shl rcx,7)
-	a2(lea r9,[rcx-128])
-	a2(lea rax,[rsi+r9])
-	a2(lea r9,[rdx+r9])
-	a2(and rdx, rdx)
-	a2(movdqa xmm0,[rax+0])
-	a2(movdqa xmm1,[rax+16])
-	a2(movdqa xmm2,[rax+32])
-	a2(movdqa xmm3,[rax+48])
-	a2(movdqa xmm4,[rax+64])
-	a2(movdqa xmm5,[rax+80])
-	a2(movdqa xmm6,[rax+96])
-	a2(movdqa xmm7,[rax+112])
-	aj(jz scrypt_ChunkMix_sse2_no_xor1)
-	a2(pxor xmm0,[r9+0])
-	a2(pxor xmm1,[r9+16])
-	a2(pxor xmm2,[r9+32])
-	a2(pxor xmm3,[r9+48])
-	a2(pxor xmm4,[r9+64])
-	a2(pxor xmm5,[r9+80])
-	a2(pxor xmm6,[r9+96])
-	a2(pxor xmm7,[r9+112])
-	a1(scrypt_ChunkMix_sse2_no_xor1:)
-	a2(xor r9,r9)
-	a2(xor r8,r8)
-	a1(scrypt_ChunkMix_sse2_loop:)
-		a2(and rdx, rdx)
-		a2(pxor xmm0,[rsi+r9+0])
-		a2(pxor xmm1,[rsi+r9+16])
-		a2(pxor xmm2,[rsi+r9+32])
-		a2(pxor xmm3,[rsi+r9+48])
-		a2(pxor xmm4,[rsi+r9+64])
-		a2(pxor xmm5,[rsi+r9+80])
-		a2(pxor xmm6,[rsi+r9+96])
-		a2(pxor xmm7,[rsi+r9+112])
-		aj(jz scrypt_ChunkMix_sse2_no_xor2)
-		a2(pxor xmm0,[rdx+r9+0])
-		a2(pxor xmm1,[rdx+r9+16])
-		a2(pxor xmm2,[rdx+r9+32])
-		a2(pxor xmm3,[rdx+r9+48])
-		a2(pxor xmm4,[rdx+r9+64])
-		a2(pxor xmm5,[rdx+r9+80])
-		a2(pxor xmm6,[rdx+r9+96])
-		a2(pxor xmm7,[rdx+r9+112])
-		a1(scrypt_ChunkMix_sse2_no_xor2:)
-		a2(movdqa [rsp+0],xmm0)
-		a2(movdqa [rsp+16],xmm1)
-		a2(movdqa [rsp+32],xmm2)
-		a2(movdqa [rsp+48],xmm3)
-		a2(movdqa [rsp+64],xmm4)
-		a2(movdqa [rsp+80],xmm5)
-		a2(movdqa [rsp+96],xmm6)
-		a2(movdqa [rsp+112],xmm7)
-		a2(mov rax,8)
-		a1(scrypt_salsa64_sse2_loop: )
-			a2(movdqa xmm8, xmm0)
-			a2(movdqa xmm9, xmm1)
-			a2(paddq xmm8, xmm2)
-			a2(paddq xmm9, xmm3)
-			a3(pshufd xmm8, xmm8, 0xb1)
-			a3(pshufd xmm9, xmm9, 0xb1)
-			a2(pxor xmm6, xmm8)
-			a2(pxor xmm7, xmm9)
-			a2(movdqa xmm10, xmm0)
-			a2(movdqa xmm11, xmm1)
-			a2(paddq xmm10, xmm6)
-			a2(paddq xmm11, xmm7)
-			a2(movdqa xmm8, xmm10)
-			a2(movdqa xmm9, xmm11)
-			a2(psrlq xmm10, 51)
-			a2(psrlq xmm11, 51)
-			a2(psllq xmm8, 13)
-			a2(psllq xmm9, 13)
-			a2(pxor xmm4, xmm10)
-			a2(pxor xmm5, xmm11)
-			a2(pxor xmm4, xmm8)
-			a2(pxor xmm5, xmm9)
-			a2(movdqa xmm10, xmm6)
-			a2(movdqa xmm11, xmm7)
-			a2(paddq xmm10, xmm4)
-			a2(paddq xmm11, xmm5)
-			a2(movdqa xmm8, xmm10)
-			a2(movdqa xmm9, xmm11)
-			a2(psrlq xmm10, 25)
-			a2(psrlq xmm11, 25)
-			a2(psllq xmm8, 39)
-			a2(psllq xmm9, 39)
-			a2(pxor xmm2, xmm10)
-			a2(pxor xmm3, xmm11)
-			a2(pxor xmm2, xmm8)
-			a2(pxor xmm3, xmm9)
-			a2(movdqa xmm8, xmm4)
-			a2(movdqa xmm9, xmm5)
-			a2(paddq xmm8, xmm2)
-			a2(paddq xmm9, xmm3)
-			a3(pshufd xmm8, xmm8, 0xb1)
-			a3(pshufd xmm9, xmm9, 0xb1)
-			a2(pxor xmm0, xmm8)
-			a2(pxor xmm1, xmm9)
-			a2(movdqa xmm8, xmm2)
-			a2(movdqa xmm9, xmm3)
-			a2(movdqa xmm10, xmm6)
-			a2(movdqa xmm11, xmm7)
-			a2(movdqa xmm2, xmm7)
-			a2(movdqa xmm3, xmm6)
-			a2(punpcklqdq xmm10, xmm6)
-			a2(punpcklqdq xmm11, xmm7)
-			a2(movdqa xmm6, xmm8)
-			a2(movdqa xmm7, xmm9)
-			a2(punpcklqdq xmm9, xmm9)
-			a2(punpcklqdq xmm8, xmm8)
-			a2(punpckhqdq xmm2, xmm10)
-			a2(punpckhqdq xmm3, xmm11)
-			a2(punpckhqdq xmm6, xmm9)
-			a2(punpckhqdq xmm7, xmm8)
-			a2(sub rax, 2)
-			a2(movdqa xmm8, xmm0)
-			a2(movdqa xmm9, xmm1)
-			a2(paddq xmm8, xmm2)
-			a2(paddq xmm9, xmm3)
-			a3(pshufd xmm8, xmm8, 0xb1)
-			a3(pshufd xmm9, xmm9, 0xb1)
-			a2(pxor xmm6, xmm8)
-			a2(pxor xmm7, xmm9)
-			a2(movdqa xmm10, xmm0)
-			a2(movdqa xmm11, xmm1)
-			a2(paddq xmm10, xmm6)
-			a2(paddq xmm11, xmm7)
-			a2(movdqa xmm8, xmm10)
-			a2(movdqa xmm9, xmm11)
-			a2(psrlq xmm10, 51)
-			a2(psrlq xmm11, 51)
-			a2(psllq xmm8, 13)
-			a2(psllq xmm9, 13)
-			a2(pxor xmm5, xmm10)
-			a2(pxor xmm4, xmm11)
-			a2(pxor xmm5, xmm8)
-			a2(pxor xmm4, xmm9)
-			a2(movdqa xmm10, xmm6)
-			a2(movdqa xmm11, xmm7)
-			a2(paddq xmm10, xmm5)
-			a2(paddq xmm11, xmm4)
-			a2(movdqa xmm8, xmm10)
-			a2(movdqa xmm9, xmm11)
-			a2(psrlq xmm10, 25)
-			a2(psrlq xmm11, 25)
-			a2(psllq xmm8, 39)
-			a2(psllq xmm9, 39)
-			a2(pxor xmm2, xmm10)
-			a2(pxor xmm3, xmm11)
-			a2(pxor xmm2, xmm8)
-			a2(pxor xmm3, xmm9)
-			a2(movdqa xmm8, xmm5)
-			a2(movdqa xmm9, xmm4)
-			a2(paddq xmm8, xmm2)
-			a2(paddq xmm9, xmm3)
-			a3(pshufd xmm8, xmm8, 0xb1)
-			a3(pshufd xmm9, xmm9, 0xb1)
-			a2(pxor xmm0, xmm8)
-			a2(pxor xmm1, xmm9)
-			a2(movdqa xmm8, xmm2)
-			a2(movdqa xmm9, xmm3)
-			a2(movdqa xmm10, xmm6)
-			a2(movdqa xmm11, xmm7)
-			a2(movdqa xmm2, xmm7)
-			a2(movdqa xmm3, xmm6)
-			a2(punpcklqdq xmm10, xmm6)
-			a2(punpcklqdq xmm11, xmm7)
-			a2(movdqa xmm6, xmm8)
-			a2(movdqa xmm7, xmm9)
-			a2(punpcklqdq xmm9, xmm9)
-			a2(punpcklqdq xmm8, xmm8)
-			a2(punpckhqdq xmm2, xmm10)
-			a2(punpckhqdq xmm3, xmm11)
-			a2(punpckhqdq xmm6, xmm9)
-			a2(punpckhqdq xmm7, xmm8)
-			aj(ja scrypt_salsa64_sse2_loop)
-		a2(paddq xmm0,[rsp+0])
-		a2(paddq xmm1,[rsp+16])
-		a2(paddq xmm2,[rsp+32])
-		a2(paddq xmm3,[rsp+48])
-		a2(paddq xmm4,[rsp+64])
-		a2(paddq xmm5,[rsp+80])
-		a2(paddq xmm6,[rsp+96])
-		a2(paddq xmm7,[rsp+112])
-		a2(lea rax,[r8+r9])
-		a2(xor r8,rcx)
-		a2(and rax,~0xff)
-		a2(add r9,128)
-		a2(shr rax,1)
-		a2(add rax, rdi)
-		a2(cmp r9,rcx)
-		a2(movdqa [rax+0],xmm0)
-		a2(movdqa [rax+16],xmm1)
-		a2(movdqa [rax+32],xmm2)
-		a2(movdqa [rax+48],xmm3)
-		a2(movdqa [rax+64],xmm4)
-		a2(movdqa [rax+80],xmm5)
-		a2(movdqa [rax+96],xmm6)
-		a2(movdqa [rax+112],xmm7)
-		aj(jne scrypt_ChunkMix_sse2_loop)
-	a2(mov rsp, rbp)
-	a1(pop rbp)
-	a1(ret)
-asm_naked_fn_end(scrypt_ChunkMix_sse2)
-
-#endif
-
-
-/* intrinsic */
-#if defined(X86_INTRINSIC_SSE2) && (!defined(SCRYPT_CHOOSE_COMPILETIME) || !defined(SCRYPT_SALSA64_INCLUDED))
-
-#define SCRYPT_SALSA64_SSE2
-
-static void asm_calling_convention
-scrypt_ChunkMix_sse2(uint64_t *Bout/*[chunkBytes]*/, uint64_t *Bin/*[chunkBytes]*/, uint64_t *Bxor/*[chunkBytes]*/, uint32_t r) {
-	uint32_t i, blocksPerChunk = r * 2, half = 0;
-	xmmi *xmmp,x0,x1,x2,x3,x4,x5,x6,x7,t0,t1,t2,t3,t4,t5,t6,t7,z0,z1,z2,z3;
-	size_t rounds;
-
-	/* 1: X = B_{2r - 1} */
-	xmmp = (xmmi *)scrypt_block(Bin, blocksPerChunk - 1);
-	x0 = xmmp[0];
-	x1 = xmmp[1];
-	x2 = xmmp[2];
-	x3 = xmmp[3];
-	x4 = xmmp[4];
-	x5 = xmmp[5];
-	x6 = xmmp[6];
-	x7 = xmmp[7];
-
-	if (Bxor) {
-		xmmp = (xmmi *)scrypt_block(Bxor, blocksPerChunk - 1);
-		x0 = _mm_xor_si128(x0, xmmp[0]);
-		x1 = _mm_xor_si128(x1, xmmp[1]);
-		x2 = _mm_xor_si128(x2, xmmp[2]);
-		x3 = _mm_xor_si128(x3, xmmp[3]);
-		x4 = _mm_xor_si128(x4, xmmp[4]);
-		x5 = _mm_xor_si128(x5, xmmp[5]);
-		x6 = _mm_xor_si128(x6, xmmp[6]);
-		x7 = _mm_xor_si128(x7, xmmp[7]);
-	}
-
-	/* 2: for i = 0 to 2r - 1 do */
-	for (i = 0; i < blocksPerChunk; i++, half ^= r) {
-		/* 3: X = H(X ^ B_i) */
-		xmmp = (xmmi *)scrypt_block(Bin, i);
-		x0 = _mm_xor_si128(x0, xmmp[0]);
-		x1 = _mm_xor_si128(x1, xmmp[1]);
-		x2 = _mm_xor_si128(x2, xmmp[2]);
-		x3 = _mm_xor_si128(x3, xmmp[3]);
-		x4 = _mm_xor_si128(x4, xmmp[4]);
-		x5 = _mm_xor_si128(x5, xmmp[5]);
-		x6 = _mm_xor_si128(x6, xmmp[6]);
-		x7 = _mm_xor_si128(x7, xmmp[7]);
-
-		if (Bxor) {
-			xmmp = (xmmi *)scrypt_block(Bxor, i);
-			x0 = _mm_xor_si128(x0, xmmp[0]);
-			x1 = _mm_xor_si128(x1, xmmp[1]);
-			x2 = _mm_xor_si128(x2, xmmp[2]);
-			x3 = _mm_xor_si128(x3, xmmp[3]);
-			x4 = _mm_xor_si128(x4, xmmp[4]);
-			x5 = _mm_xor_si128(x5, xmmp[5]);
-			x6 = _mm_xor_si128(x6, xmmp[6]);
-			x7 = _mm_xor_si128(x7, xmmp[7]);
-		}
-
-		t0 = x0;
-		t1 = x1;
-		t2 = x2;
-		t3 = x3;
-		t4 = x4;
-		t5 = x5;
-		t6 = x6;
-		t7 = x7;
-
-		for (rounds = 8; rounds; rounds -= 2) {
-			z0 = _mm_add_epi64(x0, x2);
-			z1 = _mm_add_epi64(x1, x3);
-			z0 = _mm_shuffle_epi32(z0, _MM_SHUFFLE(2,3,0,1));
-			z1 = _mm_shuffle_epi32(z1, _MM_SHUFFLE(2,3,0,1));
-			x6 = _mm_xor_si128(x6, z0);
-			x7 = _mm_xor_si128(x7, z1);
-
-			z0 = _mm_add_epi64(x6, x0);
-			z1 = _mm_add_epi64(x7, x1);
-			z2 = _mm_srli_epi64(z0, 64-13);
-			z3 = _mm_srli_epi64(z1, 64-13);
-			z0 = _mm_slli_epi64(z0, 13);
-			z1 = _mm_slli_epi64(z1, 13);
-			x4 = _mm_xor_si128(x4, z2);
-			x5 = _mm_xor_si128(x5, z3);
-			x4 = _mm_xor_si128(x4, z0);
-			x5 = _mm_xor_si128(x5, z1);
-
-			z0 = _mm_add_epi64(x4, x6);
-			z1 = _mm_add_epi64(x5, x7);
-			z2 = _mm_srli_epi64(z0, 64-39);
-			z3 = _mm_srli_epi64(z1, 64-39);
-			z0 = _mm_slli_epi64(z0, 39);
-			z1 = _mm_slli_epi64(z1, 39);
-			x2 = _mm_xor_si128(x2, z2);
-			x3 = _mm_xor_si128(x3, z3);
-			x2 = _mm_xor_si128(x2, z0);
-			x3 = _mm_xor_si128(x3, z1);
-
-			z0 = _mm_add_epi64(x2, x4);
-			z1 = _mm_add_epi64(x3, x5);
-			z0 = _mm_shuffle_epi32(z0, _MM_SHUFFLE(2,3,0,1));
-			z1 = _mm_shuffle_epi32(z1, _MM_SHUFFLE(2,3,0,1));
-			x0 = _mm_xor_si128(x0, z0);
-			x1 = _mm_xor_si128(x1, z1);
-
-			z0 = x4;
-			z1 = x5;
-			z2 = x2;
-			z3 = x3;
-			x4 = z1;
-			x5 = z0;
-			x2 = _mm_unpackhi_epi64(x7, _mm_unpacklo_epi64(x6, x6));
-			x3 = _mm_unpackhi_epi64(x6, _mm_unpacklo_epi64(x7, x7));
-			x6 = _mm_unpackhi_epi64(z2, _mm_unpacklo_epi64(z3, z3));
-			x7 = _mm_unpackhi_epi64(z3, _mm_unpacklo_epi64(z2, z2));
-
-			z0 = _mm_add_epi64(x0, x2);
-			z1 = _mm_add_epi64(x1, x3);
-			z0 = _mm_shuffle_epi32(z0, _MM_SHUFFLE(2,3,0,1));
-			z1 = _mm_shuffle_epi32(z1, _MM_SHUFFLE(2,3,0,1));
-			x6 = _mm_xor_si128(x6, z0);
-			x7 = _mm_xor_si128(x7, z1);
-
-			z0 = _mm_add_epi64(x6, x0);
-			z1 = _mm_add_epi64(x7, x1);
-			z2 = _mm_srli_epi64(z0, 64-13);
-			z3 = _mm_srli_epi64(z1, 64-13);
-			z0 = _mm_slli_epi64(z0, 13);
-			z1 = _mm_slli_epi64(z1, 13);
-			x4 = _mm_xor_si128(x4, z2);
-			x5 = _mm_xor_si128(x5, z3);
-			x4 = _mm_xor_si128(x4, z0);
-			x5 = _mm_xor_si128(x5, z1);
-
-			z0 = _mm_add_epi64(x4, x6);
-			z1 = _mm_add_epi64(x5, x7);
-			z2 = _mm_srli_epi64(z0, 64-39);
-			z3 = _mm_srli_epi64(z1, 64-39);
-			z0 = _mm_slli_epi64(z0, 39);
-			z1 = _mm_slli_epi64(z1, 39);
-			x2 = _mm_xor_si128(x2, z2);
-			x3 = _mm_xor_si128(x3, z3);
-			x2 = _mm_xor_si128(x2, z0);
-			x3 = _mm_xor_si128(x3, z1);
-
-			z0 = _mm_add_epi64(x2, x4);
-			z1 = _mm_add_epi64(x3, x5);
-			z0 = _mm_shuffle_epi32(z0, _MM_SHUFFLE(2,3,0,1));
-			z1 = _mm_shuffle_epi32(z1, _MM_SHUFFLE(2,3,0,1));
-			x0 = _mm_xor_si128(x0, z0);
-			x1 = _mm_xor_si128(x1, z1);
-
-			z0 = x4;
-			z1 = x5;
-			z2 = x2;
-			z3 = x3;
-			x4 = z1;
-			x5 = z0;
-			x2 = _mm_unpackhi_epi64(x7, _mm_unpacklo_epi64(x6, x6));
-			x3 = _mm_unpackhi_epi64(x6, _mm_unpacklo_epi64(x7, x7));
-			x6 = _mm_unpackhi_epi64(z2, _mm_unpacklo_epi64(z3, z3));
-			x7 = _mm_unpackhi_epi64(z3, _mm_unpacklo_epi64(z2, z2));
-		}
-
-		x0 = _mm_add_epi64(x0, t0);
-		x1 = _mm_add_epi64(x1, t1);
-		x2 = _mm_add_epi64(x2, t2);
-		x3 = _mm_add_epi64(x3, t3);
-		x4 = _mm_add_epi64(x4, t4);
-		x5 = _mm_add_epi64(x5, t5);
-		x6 = _mm_add_epi64(x6, t6);
-		x7 = _mm_add_epi64(x7, t7);
-
-		/* 4: Y_i = X */
-		/* 6: B'[0..r-1] = Y_even */
-		/* 6: B'[r..2r-1] = Y_odd */
-		xmmp = (xmmi *)scrypt_block(Bout, (i / 2) + half);
-		xmmp[0] = x0;
-		xmmp[1] = x1;
-		xmmp[2] = x2;
-		xmmp[3] = x3;
-		xmmp[4] = x4;
-		xmmp[5] = x5;
-		xmmp[6] = x6;
-		xmmp[7] = x7;
-	}
-}
-
-#endif
-
-#if defined(SCRYPT_SALSA64_SSE2)
-	#undef SCRYPT_MIX
-	#define SCRYPT_MIX "Salsa64/8-SSE2"
-	#undef SCRYPT_SALSA64_INCLUDED
-	#define SCRYPT_SALSA64_INCLUDED
-#endif
-
-/* sse3/avx use this as well */
-#if defined(SCRYPT_SALSA64_INCLUDED)
-	/*
-		Default layout:
-		 0  1  2  3
-		 4  5  6  7
-		 8  9 10 11
-		12 13 14 15
-
-		SSE2 layout:
-		 0  5 10 15
-		12  1  6 11
-		 8 13  2  7
-		 4  9 14  3
-	*/
-
-
-	static void asm_calling_convention
-	salsa64_core_tangle_sse2(uint64_t *blocks, size_t count) {
-		uint64_t t;
-		while (count--) {
-			t = blocks[1]; blocks[1] = blocks[5]; blocks[5] = t;
-			t = blocks[2]; blocks[2] = blocks[10]; blocks[10] = t;
-			t = blocks[3]; blocks[3] = blocks[15]; blocks[15] = t;
-			t = blocks[4]; blocks[4] = blocks[12]; blocks[12] = t;
-			t = blocks[7]; blocks[7] = blocks[11]; blocks[11] = t;
-			t = blocks[9]; blocks[9] = blocks[13]; blocks[13] = t;
-			blocks += 16;
-		}
-	}
-#endif

algo/argon2/ar2/sj/scrypt-jane-mix_salsa64-ssse3.h

@@ -1,399 +0,0 @@
-/* x64 */
-#if defined(X86_64ASM_SSSE3) && (!defined(SCRYPT_CHOOSE_COMPILETIME) || !defined(SCRYPT_SALSA64_INCLUDED)) && !defined(CPU_X86_FORCE_INTRINSICS)
-
-#define SCRYPT_SALSA64_SSSE3
-
-asm_naked_fn_proto(void, scrypt_ChunkMix_ssse3)(uint64_t *Bout/*[chunkBytes]*/, uint64_t *Bin/*[chunkBytes]*/, uint64_t *Bxor/*[chunkBytes]*/, uint32_t r)
-asm_naked_fn(scrypt_ChunkMix_ssse3)
-	a1(push rbp)
-	a2(mov rbp, rsp)
-	a2(and rsp, ~63)
-	a2(sub rsp, 128)
-	a2(lea rcx,[ecx*2]) /* zero extend uint32_t by using ecx, win64 can leave garbage in the top half */
-	a2(shl rcx,7)
-	a2(lea r9,[rcx-128])
-	a2(lea rax,[rsi+r9])
-	a2(lea r9,[rdx+r9])
-	a2(and rdx, rdx)
-	a2(movdqa xmm0,[rax+0])
-	a2(movdqa xmm1,[rax+16])
-	a2(movdqa xmm2,[rax+32])
-	a2(movdqa xmm3,[rax+48])
-	a2(movdqa xmm4,[rax+64])
-	a2(movdqa xmm5,[rax+80])
-	a2(movdqa xmm6,[rax+96])
-	a2(movdqa xmm7,[rax+112])
-	aj(jz scrypt_ChunkMix_ssse3_no_xor1)
-	a2(pxor xmm0,[r9+0])
-	a2(pxor xmm1,[r9+16])
-	a2(pxor xmm2,[r9+32])
-	a2(pxor xmm3,[r9+48])
-	a2(pxor xmm4,[r9+64])
-	a2(pxor xmm5,[r9+80])
-	a2(pxor xmm6,[r9+96])
-	a2(pxor xmm7,[r9+112])
-	a1(scrypt_ChunkMix_ssse3_no_xor1:)
-	a2(xor r9,r9)
-	a2(xor r8,r8)
-	a1(scrypt_ChunkMix_ssse3_loop:)
-		a2(and rdx, rdx)
-		a2(pxor xmm0,[rsi+r9+0])
-		a2(pxor xmm1,[rsi+r9+16])
-		a2(pxor xmm2,[rsi+r9+32])
-		a2(pxor xmm3,[rsi+r9+48])
-		a2(pxor xmm4,[rsi+r9+64])
-		a2(pxor xmm5,[rsi+r9+80])
-		a2(pxor xmm6,[rsi+r9+96])
-		a2(pxor xmm7,[rsi+r9+112])
-		aj(jz scrypt_ChunkMix_ssse3_no_xor2)
-		a2(pxor xmm0,[rdx+r9+0])
-		a2(pxor xmm1,[rdx+r9+16])
-		a2(pxor xmm2,[rdx+r9+32])
-		a2(pxor xmm3,[rdx+r9+48])
-		a2(pxor xmm4,[rdx+r9+64])
-		a2(pxor xmm5,[rdx+r9+80])
-		a2(pxor xmm6,[rdx+r9+96])
-		a2(pxor xmm7,[rdx+r9+112])
-		a1(scrypt_ChunkMix_ssse3_no_xor2:)
-		a2(movdqa [rsp+0],xmm0)
-		a2(movdqa [rsp+16],xmm1)
-		a2(movdqa [rsp+32],xmm2)
-		a2(movdqa [rsp+48],xmm3)
-		a2(movdqa [rsp+64],xmm4)
-		a2(movdqa [rsp+80],xmm5)
-		a2(movdqa [rsp+96],xmm6)
-		a2(movdqa [rsp+112],xmm7)
-		a2(mov rax,8)
-		a1(scrypt_salsa64_ssse3_loop: )
-			a2(movdqa xmm8, xmm0)
-			a2(movdqa xmm9, xmm1)
-			a2(paddq xmm8, xmm2)
-			a2(paddq xmm9, xmm3)
-			a3(pshufd xmm8, xmm8, 0xb1)
-			a3(pshufd xmm9, xmm9, 0xb1)
-			a2(pxor xmm6, xmm8)
-			a2(pxor xmm7, xmm9)
-			a2(movdqa xmm10, xmm0)
-			a2(movdqa xmm11, xmm1)
-			a2(paddq xmm10, xmm6)
-			a2(paddq xmm11, xmm7)
-			a2(movdqa xmm8, xmm10)
-			a2(movdqa xmm9, xmm11)
-			a2(psrlq xmm10, 51)
-			a2(psrlq xmm11, 51)
-			a2(psllq xmm8, 13)
-			a2(psllq xmm9, 13)
-			a2(pxor xmm4, xmm10)
-			a2(pxor xmm5, xmm11)
-			a2(pxor xmm4, xmm8)
-			a2(pxor xmm5, xmm9)
-			a2(movdqa xmm10, xmm6)
-			a2(movdqa xmm11, xmm7)
-			a2(paddq xmm10, xmm4)
-			a2(paddq xmm11, xmm5)
-			a2(movdqa xmm8, xmm10)
-			a2(movdqa xmm9, xmm11)
-			a2(psrlq xmm10, 25)
-			a2(psrlq xmm11, 25)
-			a2(psllq xmm8, 39)
-			a2(psllq xmm9, 39)
-			a2(pxor xmm2, xmm10)
-			a2(pxor xmm3, xmm11)
-			a2(pxor xmm2, xmm8)
-			a2(pxor xmm3, xmm9)
-			a2(movdqa xmm8, xmm4)
-			a2(movdqa xmm9, xmm5)
-			a2(paddq xmm8, xmm2)
-			a2(paddq xmm9, xmm3)
-			a3(pshufd xmm8, xmm8, 0xb1)
-			a3(pshufd xmm9, xmm9, 0xb1)
-			a2(pxor xmm0, xmm8)
-			a2(pxor xmm1, xmm9)
-			a2(movdqa xmm10, xmm2)
-			a2(movdqa xmm11, xmm3)
-			a2(movdqa xmm2, xmm6)
-			a2(movdqa xmm3, xmm7)
-			a3(palignr xmm2, xmm7, 8)
-			a3(palignr xmm3, xmm6, 8)
-			a2(movdqa xmm6, xmm11)
-			a2(movdqa xmm7, xmm10)
-			a3(palignr xmm6, xmm10, 8)
-			a3(palignr xmm7, xmm11, 8)
-			a2(sub rax, 2)
-			a2(movdqa xmm8, xmm0)
-			a2(movdqa xmm9, xmm1)
-			a2(paddq xmm8, xmm2)
-			a2(paddq xmm9, xmm3)
-			a3(pshufd xmm8, xmm8, 0xb1)
-			a3(pshufd xmm9, xmm9, 0xb1)
-			a2(pxor xmm6, xmm8)
-			a2(pxor xmm7, xmm9)
-			a2(movdqa xmm10, xmm0)
-			a2(movdqa xmm11, xmm1)
-			a2(paddq xmm10, xmm6)
-			a2(paddq xmm11, xmm7)
-			a2(movdqa xmm8, xmm10)
-			a2(movdqa xmm9, xmm11)
-			a2(psrlq xmm10, 51)
-			a2(psrlq xmm11, 51)
-			a2(psllq xmm8, 13)
-			a2(psllq xmm9, 13)
-			a2(pxor xmm5, xmm10)
-			a2(pxor xmm4, xmm11)
-			a2(pxor xmm5, xmm8)
-			a2(pxor xmm4, xmm9)
-			a2(movdqa xmm10, xmm6)
-			a2(movdqa xmm11, xmm7)
-			a2(paddq xmm10, xmm5)
-			a2(paddq xmm11, xmm4)
-			a2(movdqa xmm8, xmm10)
-			a2(movdqa xmm9, xmm11)
-			a2(psrlq xmm10, 25)
-			a2(psrlq xmm11, 25)
-			a2(psllq xmm8, 39)
-			a2(psllq xmm9, 39)
-			a2(pxor xmm2, xmm10)
-			a2(pxor xmm3, xmm11)
-			a2(pxor xmm2, xmm8)
-			a2(pxor xmm3, xmm9)
-			a2(movdqa xmm8, xmm5)
-			a2(movdqa xmm9, xmm4)
-			a2(paddq xmm8, xmm2)
-			a2(paddq xmm9, xmm3)
-			a3(pshufd xmm8, xmm8, 0xb1)
-			a3(pshufd xmm9, xmm9, 0xb1)
-			a2(pxor xmm0, xmm8)
-			a2(pxor xmm1, xmm9)
-			a2(movdqa xmm10, xmm2)
-			a2(movdqa xmm11, xmm3)
-			a2(movdqa xmm2, xmm6)
-			a2(movdqa xmm3, xmm7)
-			a3(palignr xmm2, xmm7, 8)
-			a3(palignr xmm3, xmm6, 8)
-			a2(movdqa xmm6, xmm11)
-			a2(movdqa xmm7, xmm10)
-			a3(palignr xmm6, xmm10, 8)
-			a3(palignr xmm7, xmm11, 8)
-			aj(ja scrypt_salsa64_ssse3_loop)
-		a2(paddq xmm0,[rsp+0])
-		a2(paddq xmm1,[rsp+16])
-		a2(paddq xmm2,[rsp+32])
-		a2(paddq xmm3,[rsp+48])
-		a2(paddq xmm4,[rsp+64])
-		a2(paddq xmm5,[rsp+80])
-		a2(paddq xmm6,[rsp+96])
-		a2(paddq xmm7,[rsp+112])
-		a2(lea rax,[r8+r9])
-		a2(xor r8,rcx)
-		a2(and rax,~0xff)
-		a2(add r9,128)
-		a2(shr rax,1)
-		a2(add rax, rdi)
-		a2(cmp r9,rcx)
-		a2(movdqa [rax+0],xmm0)
-		a2(movdqa [rax+16],xmm1)
-		a2(movdqa [rax+32],xmm2)
-		a2(movdqa [rax+48],xmm3)
-		a2(movdqa [rax+64],xmm4)
-		a2(movdqa [rax+80],xmm5)
-		a2(movdqa [rax+96],xmm6)
-		a2(movdqa [rax+112],xmm7)
-		aj(jne scrypt_ChunkMix_ssse3_loop)
-	a2(mov rsp, rbp)
-	a1(pop rbp)
-	a1(ret)
-asm_naked_fn_end(scrypt_ChunkMix_ssse3)
-
-#endif
-
-
-/* intrinsic */
-#if defined(X86_INTRINSIC_SSSE3) && (!defined(SCRYPT_CHOOSE_COMPILETIME) || !defined(SCRYPT_SALSA64_INCLUDED))
-
-#define SCRYPT_SALSA64_SSSE3
-
-static void asm_calling_convention
-scrypt_ChunkMix_ssse3(uint64_t *Bout/*[chunkBytes]*/, uint64_t *Bin/*[chunkBytes]*/, uint64_t *Bxor/*[chunkBytes]*/, uint32_t r) {
-	uint32_t i, blocksPerChunk = r * 2, half = 0;
-	xmmi *xmmp,x0,x1,x2,x3,x4,x5,x6,x7,t0,t1,t2,t3,t4,t5,t6,t7,z0,z1,z2,z3;
-	size_t rounds;
-
-	/* 1: X = B_{2r - 1} */
-	xmmp = (xmmi *)scrypt_block(Bin, blocksPerChunk - 1);
-	x0 = xmmp[0];
-	x1 = xmmp[1];
-	x2 = xmmp[2];
-	x3 = xmmp[3];
-	x4 = xmmp[4];
-	x5 = xmmp[5];
-	x6 = xmmp[6];
-	x7 = xmmp[7];
-
-	if (Bxor) {
-		xmmp = (xmmi *)scrypt_block(Bxor, blocksPerChunk - 1);
-		x0 = _mm_xor_si128(x0, xmmp[0]);
-		x1 = _mm_xor_si128(x1, xmmp[1]);
-		x2 = _mm_xor_si128(x2, xmmp[2]);
-		x3 = _mm_xor_si128(x3, xmmp[3]);
-		x4 = _mm_xor_si128(x4, xmmp[4]);
-		x5 = _mm_xor_si128(x5, xmmp[5]);
-		x6 = _mm_xor_si128(x6, xmmp[6]);
-		x7 = _mm_xor_si128(x7, xmmp[7]);
-	}
-
-	/* 2: for i = 0 to 2r - 1 do */
-	for (i = 0; i < blocksPerChunk; i++, half ^= r) {
-		/* 3: X = H(X ^ B_i) */
-		xmmp = (xmmi *)scrypt_block(Bin, i);
-		x0 = _mm_xor_si128(x0, xmmp[0]);
-		x1 = _mm_xor_si128(x1, xmmp[1]);
-		x2 = _mm_xor_si128(x2, xmmp[2]);
-		x3 = _mm_xor_si128(x3, xmmp[3]);
-		x4 = _mm_xor_si128(x4, xmmp[4]);
-		x5 = _mm_xor_si128(x5, xmmp[5]);
-		x6 = _mm_xor_si128(x6, xmmp[6]);
-		x7 = _mm_xor_si128(x7, xmmp[7]);
-
-		if (Bxor) {
-			xmmp = (xmmi *)scrypt_block(Bxor, i);
-			x0 = _mm_xor_si128(x0, xmmp[0]);
-			x1 = _mm_xor_si128(x1, xmmp[1]);
-			x2 = _mm_xor_si128(x2, xmmp[2]);
-			x3 = _mm_xor_si128(x3, xmmp[3]);
-			x4 = _mm_xor_si128(x4, xmmp[4]);
-			x5 = _mm_xor_si128(x5, xmmp[5]);
-			x6 = _mm_xor_si128(x6, xmmp[6]);
-			x7 = _mm_xor_si128(x7, xmmp[7]);
-		}
-
-		t0 = x0;
-		t1 = x1;
-		t2 = x2;
-		t3 = x3;
-		t4 = x4;
-		t5 = x5;
-		t6 = x6;
-		t7 = x7;
-
-		for (rounds = 8; rounds; rounds -= 2) {
-			z0 = _mm_add_epi64(x0, x2);
-			z1 = _mm_add_epi64(x1, x3);
-			z0 = _mm_shuffle_epi32(z0, _MM_SHUFFLE(2,3,0,1));
-			z1 = _mm_shuffle_epi32(z1, _MM_SHUFFLE(2,3,0,1));
-			x6 = _mm_xor_si128(x6, z0);
-			x7 = _mm_xor_si128(x7, z1);
-
-			z0 = _mm_add_epi64(x6, x0);
-			z1 = _mm_add_epi64(x7, x1);
-			z2 = _mm_srli_epi64(z0, 64-13);
-			z3 = _mm_srli_epi64(z1, 64-13);
-			z0 = _mm_slli_epi64(z0, 13);
-			z1 = _mm_slli_epi64(z1, 13);
-			x4 = _mm_xor_si128(x4, z2);
-			x5 = _mm_xor_si128(x5, z3);
-			x4 = _mm_xor_si128(x4, z0);
-			x5 = _mm_xor_si128(x5, z1);
-
-			z0 = _mm_add_epi64(x4, x6);
-			z1 = _mm_add_epi64(x5, x7);
-			z2 = _mm_srli_epi64(z0, 64-39);
-			z3 = _mm_srli_epi64(z1, 64-39);
-			z0 = _mm_slli_epi64(z0, 39);
-			z1 = _mm_slli_epi64(z1, 39);
-			x2 = _mm_xor_si128(x2, z2);
-			x3 = _mm_xor_si128(x3, z3);
-			x2 = _mm_xor_si128(x2, z0);
-			x3 = _mm_xor_si128(x3, z1);
-
-			z0 = _mm_add_epi64(x2, x4);
-			z1 = _mm_add_epi64(x3, x5);
-			z0 = _mm_shuffle_epi32(z0, _MM_SHUFFLE(2,3,0,1));
-			z1 = _mm_shuffle_epi32(z1, _MM_SHUFFLE(2,3,0,1));
-			x0 = _mm_xor_si128(x0, z0);
-			x1 = _mm_xor_si128(x1, z1);
-
-			z0 = x2;
-			z1 = x3;
-			x2 = _mm_alignr_epi8(x6, x7, 8);
-			x3 = _mm_alignr_epi8(x7, x6, 8);
-			x6 = _mm_alignr_epi8(z1, z0, 8);
-			x7 = _mm_alignr_epi8(z0, z1, 8);
-
-			z0 = _mm_add_epi64(x0, x2);
-			z1 = _mm_add_epi64(x1, x3);
-			z0 = _mm_shuffle_epi32(z0, _MM_SHUFFLE(2,3,0,1));
-			z1 = _mm_shuffle_epi32(z1, _MM_SHUFFLE(2,3,0,1));
-			x6 = _mm_xor_si128(x6, z0);
-			x7 = _mm_xor_si128(x7, z1);
-
-			z0 = _mm_add_epi64(x6, x0);
-			z1 = _mm_add_epi64(x7, x1);
-			z2 = _mm_srli_epi64(z0, 64-13);
-			z3 = _mm_srli_epi64(z1, 64-13);
-			z0 = _mm_slli_epi64(z0, 13);
-			z1 = _mm_slli_epi64(z1, 13);
-			x5 = _mm_xor_si128(x5, z2);
-			x4 = _mm_xor_si128(x4, z3);
-			x5 = _mm_xor_si128(x5, z0);
-			x4 = _mm_xor_si128(x4, z1);
-
-			z0 = _mm_add_epi64(x5, x6);
-			z1 = _mm_add_epi64(x4, x7);
-			z2 = _mm_srli_epi64(z0, 64-39);
-			z3 = _mm_srli_epi64(z1, 64-39);
-			z0 = _mm_slli_epi64(z0, 39);
-			z1 = _mm_slli_epi64(z1, 39);
-			x2 = _mm_xor_si128(x2, z2);
-			x3 = _mm_xor_si128(x3, z3);
-			x2 = _mm_xor_si128(x2, z0);
-			x3 = _mm_xor_si128(x3, z1);
-
-			z0 = _mm_add_epi64(x2, x5);
-			z1 = _mm_add_epi64(x3, x4);
-			z0 = _mm_shuffle_epi32(z0, _MM_SHUFFLE(2,3,0,1));
-			z1 = _mm_shuffle_epi32(z1, _MM_SHUFFLE(2,3,0,1));
-			x0 = _mm_xor_si128(x0, z0);
-			x1 = _mm_xor_si128(x1, z1);
-
-			z0 = x2;
-			z1 = x3;
-			x2 = _mm_alignr_epi8(x6, x7, 8);
-			x3 = _mm_alignr_epi8(x7, x6, 8);
-			x6 = _mm_alignr_epi8(z1, z0, 8);
-			x7 = _mm_alignr_epi8(z0, z1, 8);
-		}
-
-		x0 = _mm_add_epi64(x0, t0);
-		x1 = _mm_add_epi64(x1, t1);
-		x2 = _mm_add_epi64(x2, t2);
-		x3 = _mm_add_epi64(x3, t3);
-		x4 = _mm_add_epi64(x4, t4);
-		x5 = _mm_add_epi64(x5, t5);
-		x6 = _mm_add_epi64(x6, t6);
-		x7 = _mm_add_epi64(x7, t7);
-
-		/* 4: Y_i = X */
-		/* 6: B'[0..r-1] = Y_even */
-		/* 6: B'[r..2r-1] = Y_odd */
-		xmmp = (xmmi *)scrypt_block(Bout, (i / 2) + half);
-		xmmp[0] = x0;
-		xmmp[1] = x1;
-		xmmp[2] = x2;
-		xmmp[3] = x3;
-		xmmp[4] = x4;
-		xmmp[5] = x5;
-		xmmp[6] = x6;
-		xmmp[7] = x7;
-	}
-}
-
-#endif
-
-#if defined(SCRYPT_SALSA64_SSSE3)
-	/* uses salsa64_core_tangle_sse2 */
-
-	#undef SCRYPT_MIX
-	#define SCRYPT_MIX "Salsa64/8-SSSE3"
-	#undef SCRYPT_SALSA64_INCLUDED
-	#define SCRYPT_SALSA64_INCLUDED
-#endif

algo/argon2/ar2/sj/scrypt-jane-mix_salsa64-xop.h

@@ -1,335 +0,0 @@
-/* x64 */
-#if defined(X86_64ASM_XOP) && (!defined(SCRYPT_CHOOSE_COMPILETIME) || !defined(SCRYPT_SALSA64_INCLUDED)) && !defined(CPU_X86_FORCE_INTRINSICS)
-
-#define SCRYPT_SALSA64_XOP
-
-asm_naked_fn_proto(void, scrypt_ChunkMix_xop)(uint64_t *Bout/*[chunkBytes]*/, uint64_t *Bin/*[chunkBytes]*/, uint64_t *Bxor/*[chunkBytes]*/, uint32_t r)
-asm_naked_fn(scrypt_ChunkMix_xop)
-	a1(push rbp)
-	a2(mov rbp, rsp)
-	a2(and rsp, ~63)
-	a2(sub rsp, 128)
-	a2(lea rcx,[ecx*2]) /* zero extend uint32_t by using ecx, win64 can leave garbage in the top half */
-	a2(shl rcx,7)
-	a2(lea r9,[rcx-128])
-	a2(lea rax,[rsi+r9])
-	a2(lea r9,[rdx+r9])
-	a2(and rdx, rdx)
-	a2(vmovdqa xmm0,[rax+0])
-	a2(vmovdqa xmm1,[rax+16])
-	a2(vmovdqa xmm2,[rax+32])
-	a2(vmovdqa xmm3,[rax+48])
-	a2(vmovdqa xmm4,[rax+64])
-	a2(vmovdqa xmm5,[rax+80])
-	a2(vmovdqa xmm6,[rax+96])
-	a2(vmovdqa xmm7,[rax+112])
-	aj(jz scrypt_ChunkMix_xop_no_xor1)
-	a3(vpxor xmm0,xmm0,[r9+0])
-	a3(vpxor xmm1,xmm1,[r9+16])
-	a3(vpxor xmm2,xmm2,[r9+32])
-	a3(vpxor xmm3,xmm3,[r9+48])
-	a3(vpxor xmm4,xmm4,[r9+64])
-	a3(vpxor xmm5,xmm5,[r9+80])
-	a3(vpxor xmm6,xmm6,[r9+96])
-	a3(vpxor xmm7,xmm7,[r9+112])
-	a1(scrypt_ChunkMix_xop_no_xor1:)
-	a2(xor r9,r9)
-	a2(xor r8,r8)
-	a1(scrypt_ChunkMix_xop_loop:)
-		a2(and rdx, rdx)
-		a3(vpxor xmm0,xmm0,[rsi+r9+0])
-		a3(vpxor xmm1,xmm1,[rsi+r9+16])
-		a3(vpxor xmm2,xmm2,[rsi+r9+32])
-		a3(vpxor xmm3,xmm3,[rsi+r9+48])
-		a3(vpxor xmm4,xmm4,[rsi+r9+64])
-		a3(vpxor xmm5,xmm5,[rsi+r9+80])
-		a3(vpxor xmm6,xmm6,[rsi+r9+96])
-		a3(vpxor xmm7,xmm7,[rsi+r9+112])
-		aj(jz scrypt_ChunkMix_xop_no_xor2)
-		a3(vpxor xmm0,xmm0,[rdx+r9+0])
-		a3(vpxor xmm1,xmm1,[rdx+r9+16])
-		a3(vpxor xmm2,xmm2,[rdx+r9+32])
-		a3(vpxor xmm3,xmm3,[rdx+r9+48])
-		a3(vpxor xmm4,xmm4,[rdx+r9+64])
-		a3(vpxor xmm5,xmm5,[rdx+r9+80])
-		a3(vpxor xmm6,xmm6,[rdx+r9+96])
-		a3(vpxor xmm7,xmm7,[rdx+r9+112])
-		a1(scrypt_ChunkMix_xop_no_xor2:)
-		a2(vmovdqa [rsp+0],xmm0)
-		a2(vmovdqa [rsp+16],xmm1)
-		a2(vmovdqa [rsp+32],xmm2)
-		a2(vmovdqa [rsp+48],xmm3)
-		a2(vmovdqa [rsp+64],xmm4)
-		a2(vmovdqa [rsp+80],xmm5)
-		a2(vmovdqa [rsp+96],xmm6)
-		a2(vmovdqa [rsp+112],xmm7)
-		a2(mov rax,8)
-		a1(scrypt_salsa64_xop_loop: )
-			a3(vpaddq xmm8, xmm0, xmm2)
-			a3(vpaddq xmm9, xmm1, xmm3)
-			a3(vpshufd xmm8, xmm8, 0xb1)
-			a3(vpshufd xmm9, xmm9, 0xb1)
-			a3(vpxor xmm6, xmm6, xmm8)
-			a3(vpxor xmm7, xmm7, xmm9)
-			a3(vpaddq xmm10, xmm0, xmm6)
-			a3(vpaddq xmm11, xmm1, xmm7)
-			a3(vprotq xmm10, xmm10, 13)
-			a3(vprotq xmm11, xmm11, 13)
-			a3(vpxor xmm4, xmm4, xmm10)
-			a3(vpxor xmm5, xmm5, xmm11)
-			a3(vpaddq xmm8, xmm6, xmm4)
-			a3(vpaddq xmm9, xmm7, xmm5)
-			a3(vprotq xmm8, xmm8, 39)
-			a3(vprotq xmm9, xmm9, 39)
-			a3(vpxor xmm2, xmm2, xmm8)
-			a3(vpxor xmm3, xmm3, xmm9)
-			a3(vpaddq xmm10, xmm4, xmm2)
-			a3(vpaddq xmm11, xmm5, xmm3)
-			a3(vpshufd xmm10, xmm10, 0xb1)
-			a3(vpshufd xmm11, xmm11, 0xb1)
-			a3(vpxor xmm0, xmm0, xmm10)
-			a3(vpxor xmm1, xmm1, xmm11)
-			a2(vmovdqa xmm8, xmm2)
-			a2(vmovdqa xmm9, xmm3)
-			a4(vpalignr xmm2, xmm6, xmm7, 8)
-			a4(vpalignr xmm3, xmm7, xmm6, 8)
-			a4(vpalignr xmm6, xmm9, xmm8, 8)
-			a4(vpalignr xmm7, xmm8, xmm9, 8)
-			a3(vpaddq xmm10, xmm0, xmm2)
-			a3(vpaddq xmm11, xmm1, xmm3)
-			a3(vpshufd xmm10, xmm10, 0xb1)
-			a3(vpshufd xmm11, xmm11, 0xb1)
-			a3(vpxor xmm6, xmm6, xmm10)
-			a3(vpxor xmm7, xmm7, xmm11)
-			a3(vpaddq xmm8, xmm0, xmm6)
-			a3(vpaddq xmm9, xmm1, xmm7)
-			a3(vprotq xmm8, xmm8, 13)
-			a3(vprotq xmm9, xmm9, 13)
-			a3(vpxor xmm5, xmm5, xmm8)
-			a3(vpxor xmm4, xmm4, xmm9)
-			a3(vpaddq xmm10, xmm6, xmm5)
-			a3(vpaddq xmm11, xmm7, xmm4)
-			a3(vprotq xmm10, xmm10, 39)
-			a3(vprotq xmm11, xmm11, 39)
-			a3(vpxor xmm2, xmm2, xmm10)
-			a3(vpxor xmm3, xmm3, xmm11)
-			a3(vpaddq xmm8, xmm5, xmm2)
-			a3(vpaddq xmm9, xmm4, xmm3)
-			a3(vpshufd xmm8, xmm8, 0xb1)
-			a3(vpshufd xmm9, xmm9, 0xb1)
-			a3(vpxor xmm0, xmm0, xmm8)
-			a3(vpxor xmm1, xmm1, xmm9)
-			a2(vmovdqa xmm10, xmm2)
-			a2(vmovdqa xmm11, xmm3)
-			a4(vpalignr xmm2, xmm6, xmm7, 8)
-			a4(vpalignr xmm3, xmm7, xmm6, 8)
-			a4(vpalignr xmm6, xmm11, xmm10, 8)
-			a4(vpalignr xmm7, xmm10, xmm11, 8)
-			a2(sub rax, 2)
-			aj(ja scrypt_salsa64_xop_loop)
-		a3(vpaddq xmm0,xmm0,[rsp+0])
-		a3(vpaddq xmm1,xmm1,[rsp+16])
-		a3(vpaddq xmm2,xmm2,[rsp+32])
-		a3(vpaddq xmm3,xmm3,[rsp+48])
-		a3(vpaddq xmm4,xmm4,[rsp+64])
-		a3(vpaddq xmm5,xmm5,[rsp+80])
-		a3(vpaddq xmm6,xmm6,[rsp+96])
-		a3(vpaddq xmm7,xmm7,[rsp+112])
-		a2(lea rax,[r8+r9])
-		a2(xor r8,rcx)
-		a2(and rax,~0xff)
-		a2(add r9,128)
-		a2(shr rax,1)
-		a2(add rax, rdi)
-		a2(cmp r9,rcx)
-		a2(vmovdqa [rax+0],xmm0)
-		a2(vmovdqa [rax+16],xmm1)
-		a2(vmovdqa [rax+32],xmm2)
-		a2(vmovdqa [rax+48],xmm3)
-		a2(vmovdqa [rax+64],xmm4)
-		a2(vmovdqa [rax+80],xmm5)
-		a2(vmovdqa [rax+96],xmm6)
-		a2(vmovdqa [rax+112],xmm7)
-		aj(jne scrypt_ChunkMix_xop_loop)
-	a2(mov rsp, rbp)
-	a1(pop rbp)
-	a1(ret)
-asm_naked_fn_end(scrypt_ChunkMix_xop)
-
-#endif
-
-
-/* intrinsic */
-#if defined(X86_INTRINSIC_XOP) && (!defined(SCRYPT_CHOOSE_COMPILETIME) || !defined(SCRYPT_SALSA64_INCLUDED))
-
-#define SCRYPT_SALSA64_XOP
-
-static void asm_calling_convention
-scrypt_ChunkMix_xop(uint64_t *Bout/*[chunkBytes]*/, uint64_t *Bin/*[chunkBytes]*/, uint64_t *Bxor/*[chunkBytes]*/, uint32_t r) {
-	uint32_t i, blocksPerChunk = r * 2, half = 0;
-	xmmi *xmmp,x0,x1,x2,x3,x4,x5,x6,x7,t0,t1,t2,t3,t4,t5,t6,t7,z0,z1;
-	size_t rounds;
-
-	/* 1: X = B_{2r - 1} */
-	xmmp = (xmmi *)scrypt_block(Bin, blocksPerChunk - 1);
-	x0 = xmmp[0];
-	x1 = xmmp[1];
-	x2 = xmmp[2];
-	x3 = xmmp[3];
-	x4 = xmmp[4];
-	x5 = xmmp[5];
-	x6 = xmmp[6];
-	x7 = xmmp[7];
-
-	if (Bxor) {
-		xmmp = (xmmi *)scrypt_block(Bxor, blocksPerChunk - 1);
-		x0 = _mm_xor_si128(x0, xmmp[0]);
-		x1 = _mm_xor_si128(x1, xmmp[1]);
-		x2 = _mm_xor_si128(x2, xmmp[2]);
-		x3 = _mm_xor_si128(x3, xmmp[3]);
-		x4 = _mm_xor_si128(x4, xmmp[4]);
-		x5 = _mm_xor_si128(x5, xmmp[5]);
-		x6 = _mm_xor_si128(x6, xmmp[6]);
-		x7 = _mm_xor_si128(x7, xmmp[7]);
-	}
-
-	/* 2: for i = 0 to 2r - 1 do */
-	for (i = 0; i < blocksPerChunk; i++, half ^= r) {
-		/* 3: X = H(X ^ B_i) */
-		xmmp = (xmmi *)scrypt_block(Bin, i);
-		x0 = _mm_xor_si128(x0, xmmp[0]);
-		x1 = _mm_xor_si128(x1, xmmp[1]);
-		x2 = _mm_xor_si128(x2, xmmp[2]);
-		x3 = _mm_xor_si128(x3, xmmp[3]);
-		x4 = _mm_xor_si128(x4, xmmp[4]);
-		x5 = _mm_xor_si128(x5, xmmp[5]);
-		x6 = _mm_xor_si128(x6, xmmp[6]);
-		x7 = _mm_xor_si128(x7, xmmp[7]);
-
-		if (Bxor) {
-			xmmp = (xmmi *)scrypt_block(Bxor, i);
-			x0 = _mm_xor_si128(x0, xmmp[0]);
-			x1 = _mm_xor_si128(x1, xmmp[1]);
-			x2 = _mm_xor_si128(x2, xmmp[2]);
-			x3 = _mm_xor_si128(x3, xmmp[3]);
-			x4 = _mm_xor_si128(x4, xmmp[4]);
-			x5 = _mm_xor_si128(x5, xmmp[5]);
-			x6 = _mm_xor_si128(x6, xmmp[6]);
-			x7 = _mm_xor_si128(x7, xmmp[7]);
-		}
-
-		t0 = x0;
-		t1 = x1;
-		t2 = x2;
-		t3 = x3;
-		t4 = x4;
-		t5 = x5;
-		t6 = x6;
-		t7 = x7;
-
-		for (rounds = 8; rounds; rounds -= 2) {
-			z0 = _mm_add_epi64(x0, x2);
-			z1 = _mm_add_epi64(x1, x3);
-			z0 = _mm_shuffle_epi32(z0, _MM_SHUFFLE(2,3,0,1));
-			z1 = _mm_shuffle_epi32(z1, _MM_SHUFFLE(2,3,0,1));
-			x6 = _mm_xor_si128(x6, z0);
-			x7 = _mm_xor_si128(x7, z1);
-
-			z0 = _mm_add_epi64(x6, x0);
-			z1 = _mm_add_epi64(x7, x1);
-			z0 = _mm_roti_epi64(z0, 13);
-			z1 = _mm_roti_epi64(z1, 13);
-			x4 = _mm_xor_si128(x4, z0);
-			x5 = _mm_xor_si128(x5, z1);
-
-			z0 = _mm_add_epi64(x4, x6);
-			z1 = _mm_add_epi64(x5, x7);
-			z0 = _mm_roti_epi64(z0, 39);
-			z1 = _mm_roti_epi64(z1, 39);
-			x2 = _mm_xor_si128(x2, z0);
-			x3 = _mm_xor_si128(x3, z1);
-
-			z0 = _mm_add_epi64(x2, x4);
-			z1 = _mm_add_epi64(x3, x5);
-			z0 = _mm_shuffle_epi32(z0, _MM_SHUFFLE(2,3,0,1));
-			z1 = _mm_shuffle_epi32(z1, _MM_SHUFFLE(2,3,0,1));
-			x0 = _mm_xor_si128(x0, z0);
-			x1 = _mm_xor_si128(x1, z1);
-
-			z0 = x2;
-			z1 = x3;
-			x2 = _mm_alignr_epi8(x6, x7, 8);
-			x3 = _mm_alignr_epi8(x7, x6, 8);
-			x6 = _mm_alignr_epi8(z1, z0, 8);
-			x7 = _mm_alignr_epi8(z0, z1, 8);
-
-			z0 = _mm_add_epi64(x0, x2);
-			z1 = _mm_add_epi64(x1, x3);
-			z0 = _mm_shuffle_epi32(z0, _MM_SHUFFLE(2,3,0,1));
-			z1 = _mm_shuffle_epi32(z1, _MM_SHUFFLE(2,3,0,1));
-			x6 = _mm_xor_si128(x6, z0);
-			x7 = _mm_xor_si128(x7, z1);
-
-			z0 = _mm_add_epi64(x6, x0);
-			z1 = _mm_add_epi64(x7, x1);
-			z0 = _mm_roti_epi64(z0, 13);
-			z1 = _mm_roti_epi64(z1, 13);
-			x5 = _mm_xor_si128(x5, z0);
-			x4 = _mm_xor_si128(x4, z1);
-
-			z0 = _mm_add_epi64(x5, x6);
-			z1 = _mm_add_epi64(x4, x7);
-			z0 = _mm_roti_epi64(z0, 39);
-			z1 = _mm_roti_epi64(z1, 39);
-			x2 = _mm_xor_si128(x2, z0);
-			x3 = _mm_xor_si128(x3, z1);
-
-			z0 = _mm_add_epi64(x2, x5);
-			z1 = _mm_add_epi64(x3, x4);
-			z0 = _mm_shuffle_epi32(z0, _MM_SHUFFLE(2,3,0,1));
-			z1 = _mm_shuffle_epi32(z1, _MM_SHUFFLE(2,3,0,1));
-			x0 = _mm_xor_si128(x0, z0);
-			x1 = _mm_xor_si128(x1, z1);
-
-			z0 = x2;
-			z1 = x3;
-			x2 = _mm_alignr_epi8(x6, x7, 8);
-			x3 = _mm_alignr_epi8(x7, x6, 8);
-			x6 = _mm_alignr_epi8(z1, z0, 8);
-			x7 = _mm_alignr_epi8(z0, z1, 8);
-		}
-
-		x0 = _mm_add_epi64(x0, t0);
-		x1 = _mm_add_epi64(x1, t1);
-		x2 = _mm_add_epi64(x2, t2);
-		x3 = _mm_add_epi64(x3, t3);
-		x4 = _mm_add_epi64(x4, t4);
-		x5 = _mm_add_epi64(x5, t5);
-		x6 = _mm_add_epi64(x6, t6);
-		x7 = _mm_add_epi64(x7, t7);
-
-		/* 4: Y_i = X */
-		/* 6: B'[0..r-1] = Y_even */
-		/* 6: B'[r..2r-1] = Y_odd */
-		xmmp = (xmmi *)scrypt_block(Bout, (i / 2) + half);
-		xmmp[0] = x0;
-		xmmp[1] = x1;
-		xmmp[2] = x2;
-		xmmp[3] = x3;
-		xmmp[4] = x4;
-		xmmp[5] = x5;
-		xmmp[6] = x6;
-		xmmp[7] = x7;
-	}
-}
-
-#endif
-
-#if defined(SCRYPT_SALSA64_XOP)
-	/* uses salsa64_core_tangle_sse2 */
-
-	#undef SCRYPT_MIX
-	#define SCRYPT_MIX "Salsa64/8-XOP"
-	#undef SCRYPT_SALSA64_INCLUDED
-	#define SCRYPT_SALSA64_INCLUDED
-#endif

algo/argon2/ar2/sj/scrypt-jane-mix_salsa64.h

@@ -1,41 +0,0 @@
-#if !defined(SCRYPT_CHOOSE_COMPILETIME) || !defined(SCRYPT_SALSA64_INCLUDED)
-
-#undef SCRYPT_MIX
-#define SCRYPT_MIX "Salsa64/8 Ref"
-
-#undef SCRYPT_SALSA64_INCLUDED
-#define SCRYPT_SALSA64_INCLUDED
-#define SCRYPT_SALSA64_BASIC
-
-static void
-salsa64_core_basic(uint64_t state[16]) {
-	const size_t rounds = 8;
-	uint64_t v[16], t;
-	size_t i;
-
-	for (i = 0; i < 16; i++) v[i] = state[i];
-
-	#define G(a,b,c,d) \
-		t = v[a]+v[d]; t = ROTL64(t, 32); v[b] ^= t; \
-		t = v[b]+v[a]; t = ROTL64(t, 13); v[c] ^= t; \
-		t = v[c]+v[b]; t = ROTL64(t, 39); v[d] ^= t; \
-		t = v[d]+v[c]; t = ROTL64(t, 32); v[a] ^= t; \
-
-	for (i = 0; i < rounds; i += 2) {
-		G( 0, 4, 8,12);
-		G( 5, 9,13, 1);
-		G(10,14, 2, 6);
-		G(15, 3, 7,11);
-		G( 0, 1, 2, 3);
-		G( 5, 6, 7, 4);
-		G(10,11, 8, 9);
-		G(15,12,13,14);
-	}
-
-	for (i = 0; i < 16; i++) state[i] += v[i];
-
-	#undef G
-}
-
-#endif
-

algo/argon2/ar2/sj/scrypt-jane-pbkdf2.h

@@ -1,112 +0,0 @@
-typedef struct scrypt_hmac_state_t {
-	scrypt_hash_state inner, outer;
-} scrypt_hmac_state;
-
-
-static void
-scrypt_hash(scrypt_hash_digest hash, const uint8_t *m, size_t mlen) {
-	scrypt_hash_state st;
-	scrypt_hash_init(&st);
-	scrypt_hash_update(&st, m, mlen);
-	scrypt_hash_finish(&st, hash);
-}
-
-/* hmac */
-static void
-scrypt_hmac_init(scrypt_hmac_state *st, const uint8_t *key, size_t keylen) {
-	uint8_t pad[SCRYPT_HASH_BLOCK_SIZE] = {0};
-	size_t i;
-
-	scrypt_hash_init(&st->inner);
-	scrypt_hash_init(&st->outer);
-
-	if (keylen <= SCRYPT_HASH_BLOCK_SIZE) {
-		/* use the key directly if it's <= blocksize bytes */
-		memcpy(pad, key, keylen);
-	} else {
-		/* if it's > blocksize bytes, hash it */
-		scrypt_hash(pad, key, keylen);
-	}
-
-	/* inner = (key ^ 0x36) */
-	/* h(inner || ...) */
-	for (i = 0; i < SCRYPT_HASH_BLOCK_SIZE; i++)
-		pad[i] ^= 0x36;
-	scrypt_hash_update(&st->inner, pad, SCRYPT_HASH_BLOCK_SIZE);
-
-	/* outer = (key ^ 0x5c) */
-	/* h(outer || ...) */
-	for (i = 0; i < SCRYPT_HASH_BLOCK_SIZE; i++)
-		pad[i] ^= (0x5c ^ 0x36);
-	scrypt_hash_update(&st->outer, pad, SCRYPT_HASH_BLOCK_SIZE);
-
-	scrypt_ensure_zero(pad, sizeof(pad));
-}
-
-static void
-scrypt_hmac_update(scrypt_hmac_state *st, const uint8_t *m, size_t mlen) {
-	/* h(inner || m...) */
-	scrypt_hash_update(&st->inner, m, mlen);
-}
-
-static void
-scrypt_hmac_finish(scrypt_hmac_state *st, scrypt_hash_digest mac) {
-	/* h(inner || m) */
-	scrypt_hash_digest innerhash;
-	scrypt_hash_finish(&st->inner, innerhash);
-
-	/* h(outer || h(inner || m)) */
-	scrypt_hash_update(&st->outer, innerhash, sizeof(innerhash));
-	scrypt_hash_finish(&st->outer, mac);
-
-	scrypt_ensure_zero(st, sizeof(*st));
-}
-
-static void
-scrypt_pbkdf2(const uint8_t *password, size_t password_len, const uint8_t *salt, size_t salt_len, uint64_t N, uint8_t *out, size_t bytes) {
-	scrypt_hmac_state hmac_pw, hmac_pw_salt, work;
-	scrypt_hash_digest ti, u;
-	uint8_t be[4];
-	uint32_t i, j, blocks;
-	uint64_t c;
-
-	/* bytes must be <= (0xffffffff - (SCRYPT_HASH_DIGEST_SIZE - 1)), which they will always be under scrypt */
-
-	/* hmac(password, ...) */
-	scrypt_hmac_init(&hmac_pw, password, password_len);
-
-	/* hmac(password, salt...) */
-	hmac_pw_salt = hmac_pw;
-	scrypt_hmac_update(&hmac_pw_salt, salt, salt_len);
-
-	blocks = ((uint32_t)bytes + (SCRYPT_HASH_DIGEST_SIZE - 1)) / SCRYPT_HASH_DIGEST_SIZE;
-	for (i = 1; i <= blocks; i++) {
-		/* U1 = hmac(password, salt || be(i)) */
-		U32TO8_BE(be, i);
-		work = hmac_pw_salt;
-		scrypt_hmac_update(&work, be, 4);
-		scrypt_hmac_finish(&work, ti);
-		memcpy(u, ti, sizeof(u));
-
-		/* T[i] = U1 ^ U2 ^ U3... */
-		for (c = 0; c < N - 1; c++) {
-			/* UX = hmac(password, U{X-1}) */
-			work = hmac_pw;
-			scrypt_hmac_update(&work, u, SCRYPT_HASH_DIGEST_SIZE);
-			scrypt_hmac_finish(&work, u);
-
-			/* T[i] ^= UX */
-			for (j = 0; j < sizeof(u); j++)
-				ti[j] ^= u[j];
-		}
-
-		memcpy(out, ti, (bytes > SCRYPT_HASH_DIGEST_SIZE) ? SCRYPT_HASH_DIGEST_SIZE : bytes);
-		out += SCRYPT_HASH_DIGEST_SIZE;
-		bytes -= SCRYPT_HASH_DIGEST_SIZE;
-	}
-
-	scrypt_ensure_zero(ti, sizeof(ti));
-	scrypt_ensure_zero(u, sizeof(u));
-	scrypt_ensure_zero(&hmac_pw, sizeof(hmac_pw));
-	scrypt_ensure_zero(&hmac_pw_salt, sizeof(hmac_pw_salt));
-}

algo/argon2/ar2/sj/scrypt-jane-portable-x86.h

@@ -1,463 +0,0 @@
-#if defined(CPU_X86) && (defined(COMPILER_MSVC) || defined(COMPILER_GCC))
-	#define X86ASM
-
-	/* gcc 2.95 royally screws up stack alignments on variables */
-	#if ((defined(COMPILER_MSVC) && (COMPILER_MSVC >= COMPILER_MSVC_VS6PP)) || (defined(COMPILER_GCC) && (COMPILER_GCC >= 30000)))
-		#define X86ASM_SSE
-		#define X86ASM_SSE2
-	#endif
-	#if ((defined(COMPILER_MSVC) && (COMPILER_MSVC >= COMPILER_MSVC_VS2005)) || (defined(COMPILER_GCC) && (COMPILER_GCC >= 40102)))
-		#define X86ASM_SSSE3
-	#endif
-	#if ((defined(COMPILER_MSVC) && (COMPILER_MSVC >= COMPILER_MSVC_VS2010SP1)) || (defined(COMPILER_GCC) && (COMPILER_GCC >= 40400)))
-		#define X86ASM_AVX
-		#define X86ASM_XOP
-	#endif
-	#if ((defined(COMPILER_MSVC) && (COMPILER_MSVC >= COMPILER_MSVC_VS2012)) || (defined(COMPILER_GCC) && (COMPILER_GCC >= 40700)))
-		#define X86ASM_AVX2
-	#endif
-#endif
-
-#if defined(CPU_X86_64) && defined(COMPILER_GCC)
-	#define X86_64ASM
-	#define X86_64ASM_SSE2
-	#if (COMPILER_GCC >= 40102)
-		#define X86_64ASM_SSSE3
-	#endif
-	#if (COMPILER_GCC >= 40400)
-		#define X86_64ASM_AVX
-		#define X86_64ASM_XOP
-	#endif
-	#if (COMPILER_GCC >= 40700)
-		#define X86_64ASM_AVX2
-	#endif
-#endif
-
-#if defined(COMPILER_MSVC) && (defined(CPU_X86_FORCE_INTRINSICS) || defined(CPU_X86_64))
-	#define X86_INTRINSIC
-	#if defined(CPU_X86_64) || defined(X86ASM_SSE)
-		#define X86_INTRINSIC_SSE
-	#endif
-	#if defined(CPU_X86_64) || defined(X86ASM_SSE2)
-		#define X86_INTRINSIC_SSE2
-	#endif
-	#if (COMPILER_MSVC >= COMPILER_MSVC_VS2005)
-		#define X86_INTRINSIC_SSSE3
-	#endif
-	#if (COMPILER_MSVC >= COMPILER_MSVC_VS2010SP1)
-		#define X86_INTRINSIC_AVX
-		#define X86_INTRINSIC_XOP
-	#endif
-	#if (COMPILER_MSVC >= COMPILER_MSVC_VS2012)
-		#define X86_INTRINSIC_AVX2
-	#endif
-#endif
-
-#if defined(COMPILER_GCC) && defined(CPU_X86_FORCE_INTRINSICS)
-	#define X86_INTRINSIC
-	#if defined(__SSE__)
-		#define X86_INTRINSIC_SSE
-	#endif
-	#if defined(__SSE2__)
-		#define X86_INTRINSIC_SSE2
-	#endif
-	#if defined(__SSSE3__)
-		#define X86_INTRINSIC_SSSE3
-	#endif
-	#if defined(__AVX__)
-		#define X86_INTRINSIC_AVX
-	#endif
-	#if defined(__XOP__)
-		#define X86_INTRINSIC_XOP
-	#endif
-	#if defined(__AVX2__)
-		#define X86_INTRINSIC_AVX2
-	#endif
-#endif
-
-/* only use simd on windows (or SSE2 on gcc)! */
-#if defined(CPU_X86_FORCE_INTRINSICS) || defined(X86_INTRINSIC)
-	#if defined(X86_INTRINSIC_SSE)
-		#include <mmintrin.h>
-		#include <xmmintrin.h>
-		typedef __m64 qmm;
-		typedef __m128 xmm;
-		typedef __m128d xmmd;
-	#endif
-	#if defined(X86_INTRINSIC_SSE2)
-		#include <emmintrin.h>
-		typedef __m128i xmmi;
-	#endif
-	#if defined(X86_INTRINSIC_SSSE3)
-		#include <tmmintrin.h>
-	#endif
-	#if defined(X86_INTRINSIC_AVX)
-		#include <immintrin.h>
-	#endif
-	#if defined(X86_INTRINSIC_XOP)
-		#if defined(COMPILER_MSVC)
-			#include <intrin.h>
-		#else
-			#include <x86intrin.h>
-		#endif
-	#endif
-	#if defined(X86_INTRINSIC_AVX2)
-		typedef __m256i ymmi;
-	#endif
-#endif
-
-#if defined(X86_INTRINSIC_SSE2)
-	typedef union packedelem8_t {
-		uint8_t u[16];
-		xmmi v;
-	} packedelem8;
-
-	typedef union packedelem32_t {
-		uint32_t u[4];
-		xmmi v;
-	} packedelem32;
-
-	typedef union packedelem64_t {
-		uint64_t u[2];
-		xmmi v;
-	} packedelem64;
-#else
-	typedef union packedelem8_t {
-		uint8_t u[16];
-		uint32_t dw[4];
-	} packedelem8;
-
-	typedef union packedelem32_t {
-		uint32_t u[4];
-		uint8_t b[16];
-	} packedelem32;
-
-	typedef union packedelem64_t {
-		uint64_t u[2];
-		uint8_t b[16];
-	} packedelem64;
-#endif
-
-#if defined(X86_INTRINSIC_SSSE3)
-	static const packedelem8 ALIGN(16) ssse3_rotl16_32bit      = {{2,3,0,1,6,7,4,5,10,11,8,9,14,15,12,13}};
-	static const packedelem8 ALIGN(16) ssse3_rotl8_32bit       = {{3,0,1,2,7,4,5,6,11,8,9,10,15,12,13,14}};
-#endif
-
-/*
-	x86 inline asm for gcc/msvc. usage:
-
-	asm_naked_fn_proto(return_type, name) (type parm1, type parm2..)
-	asm_naked_fn(name)
-		a1(..)
-		a2(.., ..)
-		a3(.., .., ..)
-		64bit OR 0 paramters: a1(ret)
-		32bit AND n parameters: aret(4n), eg aret(16) for 4 parameters
-	asm_naked_fn_end(name)
-*/
-
-#if defined(X86ASM) || defined(X86_64ASM)
-
-#if defined(COMPILER_MSVC)
-	#pragma warning(disable : 4731) /* frame pointer modified by inline assembly */
-	#define a1(x) __asm {x}
-	#define a2(x, y) __asm {x, y}
-	#define a3(x, y, z) __asm {x, y, z}
-	#define a4(x, y, z, w) __asm {x, y, z, w}
-	#define aj(x) __asm {x}
-	#define asm_align8 a1(ALIGN 8)
-	#define asm_align16 a1(ALIGN 16)
-
-	#define asm_calling_convention STDCALL
-	#define aret(n) a1(ret n)
-	#define asm_naked_fn_proto(type, fn) static NAKED type asm_calling_convention fn
-	#define asm_naked_fn(fn) {
-	#define asm_naked_fn_end(fn) }
-#elif defined(COMPILER_GCC)
-	#define GNU_AS1(x) #x ";\n"
-	#define GNU_AS2(x, y) #x ", " #y ";\n"
-	#define GNU_AS3(x, y, z) #x ", " #y ", " #z ";\n"
-	#define GNU_AS4(x, y, z, w) #x ", " #y ", " #z ", " #w ";\n"
-	#define GNU_ASFN(x) "\n_" #x ":\n" #x ":\n"
-	#define GNU_ASJ(x) ".att_syntax prefix\n" #x "\n.intel_syntax noprefix\n"
-
-	#define a1(x) GNU_AS1(x)
-	#define a2(x, y) GNU_AS2(x, y)
-	#define a3(x, y, z) GNU_AS3(x, y, z)
-	#define a4(x, y, z, w) GNU_AS4(x, y, z, w)
-	#define aj(x) GNU_ASJ(x)
-	#define asm_align8 ".p2align 3,,7"
-	#define asm_align16 ".p2align 4,,15"
-
-	#if defined(OS_WINDOWS)
-		#define asm_calling_convention CDECL
-		#define aret(n) a1(ret)
-
-		#if defined(X86_64ASM)
-			#define asm_naked_fn(fn) ; __asm__ ( \
-				".text\n"                        \
-				asm_align16 GNU_ASFN(fn)         \
-				"subq $136, %rsp;"               \
-			 	"movdqa %xmm6, 0(%rsp);"         \
-				"movdqa %xmm7, 16(%rsp);"        \
-			 	"movdqa %xmm8, 32(%rsp);"        \
-				"movdqa %xmm9, 48(%rsp);"        \
-			 	"movdqa %xmm10, 64(%rsp);"       \
-				"movdqa %xmm11, 80(%rsp);"       \
-				"movdqa %xmm12, 96(%rsp);"       \
-				"movq %rdi, 112(%rsp);"          \
-				"movq %rsi, 120(%rsp);"          \
-				"movq %rcx, %rdi;"               \
-				"movq %rdx, %rsi;"               \
-				"movq %r8, %rdx;"                \
-				"movq %r9, %rcx;"                \
-				"call 1f;"                       \
-				"movdqa 0(%rsp), %xmm6;"         \
-				"movdqa 16(%rsp), %xmm7;"        \
-				"movdqa 32(%rsp), %xmm8;"        \
-				"movdqa 48(%rsp), %xmm9;"        \
-				"movdqa 64(%rsp), %xmm10;"       \
-				"movdqa 80(%rsp), %xmm11;"       \
-				"movdqa 96(%rsp), %xmm12;"       \
-				"movq 112(%rsp), %rdi;"          \
-				"movq 120(%rsp), %rsi;"          \
-				"addq $136, %rsp;"               \
-				"ret;"                           \
-				".intel_syntax noprefix;"        \
-				".p2align 4,,15;"                \
-				"1:;"
-		#else
-			#define asm_naked_fn(fn) ; __asm__ (".intel_syntax noprefix;\n.text\n" asm_align16 GNU_ASFN(fn)
-		#endif
-	#else
-		#define asm_calling_convention STDCALL
-		#define aret(n) a1(ret n)
-		#define asm_naked_fn(fn) ; __asm__ (".intel_syntax noprefix;\n.text\n" asm_align16 GNU_ASFN(fn)
-	#endif
-
-	#define asm_naked_fn_proto(type, fn) extern type asm_calling_convention fn
-	#define asm_naked_fn_end(fn) ".att_syntax prefix;\n" );
-
-	#define asm_gcc() __asm__ __volatile__(".intel_syntax noprefix;\n"
-	#define asm_gcc_parms() ".att_syntax prefix;"
-	#define asm_gcc_trashed() __asm__ __volatile__("" :::
-	#define asm_gcc_end() );
-#else
-	need x86 asm
-#endif
-
-#endif /* X86ASM || X86_64ASM */
-
-
-#if defined(CPU_X86) || defined(CPU_X86_64)
-
-typedef enum cpu_flags_x86_t {
-	cpu_mmx = 1 << 0,
-	cpu_sse = 1 << 1,
-	cpu_sse2 = 1 << 2,
-	cpu_sse3 = 1 << 3,
-	cpu_ssse3 = 1 << 4,
-	cpu_sse4_1 = 1 << 5,
-	cpu_sse4_2 = 1 << 6,
-	cpu_avx = 1 << 7,
-	cpu_xop = 1 << 8,
-	cpu_avx2 = 1 << 9
-} cpu_flags_x86;
-
-typedef enum cpu_vendors_x86_t {
-	cpu_nobody,
-	cpu_intel,
-	cpu_amd
-} cpu_vendors_x86;
-
-typedef struct x86_regs_t {
-	uint32_t eax, ebx, ecx, edx;
-} x86_regs;
-
-#if defined(X86ASM)
-asm_naked_fn_proto(int, has_cpuid)(void)
-asm_naked_fn(has_cpuid)
-	a1(pushfd)
-	a1(pop eax)
-	a2(mov ecx, eax)
-	a2(xor eax, 0x200000)
-	a1(push eax)
-	a1(popfd)
-	a1(pushfd)
-	a1(pop eax)
-	a2(xor eax, ecx)
-	a2(shr eax, 21)
-	a2(and eax, 1)
-	a1(push ecx)
-	a1(popfd)
-	a1(ret)
-asm_naked_fn_end(has_cpuid)
-#endif /* X86ASM */
-
-
-static void NOINLINE
-get_cpuid(x86_regs *regs, uint32_t flags) {
-#if defined(COMPILER_MSVC)
-	__cpuid((int *)regs, (int)flags);
-#else
-	#if defined(CPU_X86_64)
-		#define cpuid_bx rbx
-	#else
-		#define cpuid_bx ebx
-	#endif
-
-	asm_gcc()
-		a1(push cpuid_bx)
-		a2(xor ecx, ecx)
-		a1(cpuid)
-		a2(mov [%1 + 0], eax)
-		a2(mov [%1 + 4], ebx)
-		a2(mov [%1 + 8], ecx)
-		a2(mov [%1 + 12], edx)
-		a1(pop cpuid_bx)
-		asm_gcc_parms() : "+a"(flags) : "S"(regs)  : "%ecx", "%edx", "cc"
-	asm_gcc_end()
-#endif
-}
-
-#if defined(X86ASM_AVX) || defined(X86_64ASM_AVX)
-static uint64_t NOINLINE
-get_xgetbv(uint32_t flags) {
-#if defined(COMPILER_MSVC)
-	return _xgetbv(flags);
-#else
-	uint32_t lo, hi;
-	asm_gcc()
-		a1(xgetbv)
-		asm_gcc_parms() : "+c"(flags), "=a" (lo), "=d" (hi)
-	asm_gcc_end()
-	return ((uint64_t)lo | ((uint64_t)hi << 32));
-#endif
-}
-#endif // AVX support
-
-#if defined(SCRYPT_TEST_SPEED)
-size_t cpu_detect_mask = (size_t)-1;
-#endif
-
-static size_t
-detect_cpu(void) {
-	//union { uint8_t s[12]; uint32_t i[3]; } vendor_string;
-	//cpu_vendors_x86 vendor = cpu_nobody;
-	x86_regs regs;
-	uint32_t max_level, max_ext_level;
-	size_t cpu_flags = 0;
-#if defined(X86ASM_AVX) || defined(X86_64ASM_AVX)
-	uint64_t xgetbv_flags;
-#endif
-
-#if defined(CPU_X86)
-	if (!has_cpuid())
-		return cpu_flags;
-#endif
-
-	get_cpuid(&regs, 0);
-	max_level = regs.eax;
-#if 0
-	vendor_string.i[0] = regs.ebx;
-	vendor_string.i[1] = regs.edx;
-	vendor_string.i[2] = regs.ecx;
-
-	if (scrypt_verify(vendor_string.s, (const uint8_t *)"GenuineIntel", 12))
-		vendor = cpu_intel;
-	else if (scrypt_verify(vendor_string.s, (const uint8_t *)"AuthenticAMD", 12))
-		vendor = cpu_amd;
-#endif
-	if (max_level & 0x00000500) {
-		/* "Intel P5 pre-B0" */
-		cpu_flags |= cpu_mmx;
-		return cpu_flags;
-	}
-
-	if (max_level < 1)
-		return cpu_flags;
-
-	get_cpuid(&regs, 1);
-#if defined(X86ASM_AVX) || defined(X86_64ASM_AVX)
-	/* xsave/xrestore */
-	if (regs.ecx & (1 << 27)) {
-		xgetbv_flags = get_xgetbv(0);
-		if ((regs.ecx & (1 << 28)) && (xgetbv_flags & 0x6)) cpu_flags |= cpu_avx;
-	}
-#endif
-	if (regs.ecx & (1 << 20)) cpu_flags |= cpu_sse4_2;
-	if (regs.ecx & (1 << 19)) cpu_flags |= cpu_sse4_2;
-	if (regs.ecx & (1 <<  9)) cpu_flags |= cpu_ssse3;
-	if (regs.ecx & (1      )) cpu_flags |= cpu_sse3;
-	if (regs.edx & (1 << 26)) cpu_flags |= cpu_sse2;
-	if (regs.edx & (1 << 25)) cpu_flags |= cpu_sse;
-	if (regs.edx & (1 << 23)) cpu_flags |= cpu_mmx;
-
-	if (cpu_flags & cpu_avx) {
-		if (max_level >= 7) {
-			get_cpuid(&regs, 7);
-			if (regs.ebx & (1 << 5)) cpu_flags |= cpu_avx2;
-		}
-
-		get_cpuid(&regs, 0x80000000);
-		max_ext_level = regs.eax;
-		if (max_ext_level >= 0x80000001) {
-			get_cpuid(&regs, 0x80000001);
-			if (regs.ecx & (1 << 11)) cpu_flags |= cpu_xop;
-		}
-	}
-
-
-#if defined(SCRYPT_TEST_SPEED)
-	cpu_flags &= cpu_detect_mask;
-#endif
-
-	return cpu_flags;
-}
-
-#if defined(SCRYPT_TEST_SPEED)
-static const char *
-get_top_cpuflag_desc(size_t flag) {
-	if (flag & cpu_avx2) return "AVX2";
-	else if (flag & cpu_xop) return "XOP";
-	else if (flag & cpu_avx) return "AVX";
-	else if (flag & cpu_sse4_2) return "SSE4.2";
-	else if (flag & cpu_sse4_1) return "SSE4.1";
-	else if (flag & cpu_ssse3) return "SSSE3";
-	else if (flag & cpu_sse2) return "SSE2";
-	else if (flag & cpu_sse) return "SSE";
-	else if (flag & cpu_mmx) return "MMX";
-	else return "Basic";
-}
-#endif
-
-/* enable the highest system-wide option */
-#if defined(SCRYPT_CHOOSE_COMPILETIME)
-	#if !defined(__AVX2__)
-		#undef X86_64ASM_AVX2
-		#undef X86ASM_AVX2
-		#undef X86_INTRINSIC_AVX2
-	#endif
-	#if !defined(__XOP__)
-		#undef X86_64ASM_XOP
-		#undef X86ASM_XOP
-		#undef X86_INTRINSIC_XOP
-	#endif
-	#if !defined(__AVX__)
-		#undef X86_64ASM_AVX
-		#undef X86ASM_AVX
-		#undef X86_INTRINSIC_AVX
-	#endif
-	#if !defined(__SSSE3__)
-		#undef X86_64ASM_SSSE3
-		#undef X86ASM_SSSE3
-		#undef X86_INTRINSIC_SSSE3
-	#endif
-	#if !defined(__SSE2__)
-		#undef X86_64ASM_SSE2
-		#undef X86ASM_SSE2
-		#undef X86_INTRINSIC_SSE2
-	#endif
-#endif
-
-#endif /* defined(CPU_X86) || defined(CPU_X86_64) */

algo/argon2/ar2/sj/scrypt-jane-portable.h

@@ -1,310 +0,0 @@
-/* determine os */
-#if defined(_WIN32)	|| defined(_WIN64) || defined(__TOS_WIN__) || defined(__WINDOWS__)
-	#include <windows.h>
-	#include <wincrypt.h>
-	#define OS_WINDOWS
-#elif defined(sun) || defined(__sun) || defined(__SVR4) || defined(__svr4__)
-	#include <sys/mman.h>
-	#include <sys/time.h>
-	#include <fcntl.h>
-
-	#define OS_SOLARIS
-#else
-	#include <sys/mman.h>
-	#include <sys/time.h>
-	#include <sys/param.h> /* need this to define BSD */
-	#include <unistd.h>
-	#include <fcntl.h>
-
-	#define OS_NIX
-	#if defined(__linux__)
-		#include <endian.h>
-		#define OS_LINUX
-	#elif defined(BSD)
-		#define OS_BSD
-
-		#if defined(MACOS_X) || (defined(__APPLE__) & defined(__MACH__))
-			#define OS_OSX
-		#elif defined(macintosh) || defined(Macintosh)
-			#define OS_MAC
-		#elif defined(__OpenBSD__)
-			#define OS_OPENBSD
-		#endif
-	#endif
-#endif
-
-
-/* determine compiler */
-#if defined(_MSC_VER)
-	#define COMPILER_MSVC_VS6       120000000
-	#define COMPILER_MSVC_VS6PP     121000000
-	#define COMPILER_MSVC_VS2002    130000000
-	#define COMPILER_MSVC_VS2003    131000000
-	#define COMPILER_MSVC_VS2005    140050727
-	#define COMPILER_MSVC_VS2008    150000000
-	#define COMPILER_MSVC_VS2008SP1 150030729
-	#define COMPILER_MSVC_VS2010    160000000
-	#define COMPILER_MSVC_VS2010SP1 160040219
-	#define COMPILER_MSVC_VS2012RC  170000000
-	#define COMPILER_MSVC_VS2012    170050727
-
-	#if _MSC_FULL_VER > 100000000
-		#define COMPILER_MSVC (_MSC_FULL_VER)
-	#else
-		#define COMPILER_MSVC (_MSC_FULL_VER * 10)
-	#endif
-
-	#if ((_MSC_VER == 1200) && defined(_mm_free))
-		#undef COMPILER_MSVC
-		#define COMPILER_MSVC COMPILER_MSVC_VS6PP
-	#endif
-
-	#pragma warning(disable : 4127) /* conditional expression is constant */
-	#pragma warning(disable : 4100) /* unreferenced formal parameter */
-
-	#ifndef _CRT_SECURE_NO_WARNINGS
-	#define _CRT_SECURE_NO_WARNINGS
-	#endif
-
-	#include <float.h>
-	#include <stdlib.h> /* _rotl */
-	#include <intrin.h>
-
-	typedef unsigned char uint8_t;
-	typedef unsigned short uint16_t;
-	typedef unsigned int uint32_t;
-	typedef signed int int32_t;
-	typedef unsigned __int64 uint64_t;
-	typedef signed __int64 int64_t;
-
-	#define ROTL32(a,b) _rotl(a,b)
-	#define ROTR32(a,b) _rotr(a,b)
-	#define ROTL64(a,b) _rotl64(a,b)
-	#define ROTR64(a,b) _rotr64(a,b)
-	#undef NOINLINE
-	#define NOINLINE __declspec(noinline)
-	#undef NORETURN
-	#define NORETURN
-	#undef INLINE
-	#define INLINE __forceinline
-	#undef FASTCALL
-	#define FASTCALL __fastcall
-	#undef CDECL
-	#define CDECL __cdecl
-	#undef STDCALL
-	#define STDCALL __stdcall
-	#undef NAKED
-	#define NAKED __declspec(naked)
-	#define ALIGN(n) __declspec(align(n))
-#endif
-#if defined(__ICC)
-	#define COMPILER_INTEL
-#endif
-#if defined(__GNUC__)
-	#if (__GNUC__ >= 3)
-		#define COMPILER_GCC_PATCHLEVEL __GNUC_PATCHLEVEL__
-	#else
-		#define COMPILER_GCC_PATCHLEVEL 0
-	#endif
-	#define COMPILER_GCC (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + COMPILER_GCC_PATCHLEVEL)
-	#define ROTL32(a,b) (((a) << (b)) | ((a) >> (32 - b)))
-	#define ROTR32(a,b) (((a) >> (b)) | ((a) << (32 - b)))
-	#define ROTL64(a,b) (((a) << (b)) | ((a) >> (64 - b)))
-	#define ROTR64(a,b) (((a) >> (b)) | ((a) << (64 - b)))
-	#undef NOINLINE
-	#if (COMPILER_GCC >= 30000)
-		#define NOINLINE __attribute__((noinline))
-	#else
-		#define NOINLINE
-	#endif
-	#undef NORETURN
-	#if (COMPILER_GCC >= 30000)
-		#define NORETURN __attribute__((noreturn))
-	#else
-		#define NORETURN
-	#endif
-	#undef INLINE
-	#if (COMPILER_GCC >= 30000)
-		#define INLINE __attribute__((always_inline))
-	#else
-		#define INLINE inline
-	#endif
-	#undef FASTCALL
-	#if (COMPILER_GCC >= 30400)
-		#define FASTCALL __attribute__((fastcall))
-	#else
-		#define FASTCALL
-	#endif
-	#undef CDECL
-	#define CDECL __attribute__((cdecl))
-	#undef STDCALL
-	#define STDCALL __attribute__((stdcall))
-	#define ALIGN(n) __attribute__((aligned(n)))
-	#include <stdint.h>
-#endif
-#if defined(__MINGW32__) || defined(__MINGW64__)
-	#define COMPILER_MINGW
-#endif
-#if defined(__PATHCC__)
-	#define COMPILER_PATHCC
-#endif
-
-#define OPTIONAL_INLINE
-#if defined(OPTIONAL_INLINE)
-	#undef OPTIONAL_INLINE
-	#define OPTIONAL_INLINE INLINE
-#else
-	#define OPTIONAL_INLINE
-#endif
-
-#define CRYPTO_FN NOINLINE STDCALL
-
-/* determine cpu */
-#if defined(__amd64__) || defined(__amd64) || defined(__x86_64__ ) || defined(_M_X64)
-	#define CPU_X86_64
-#elif defined(__i586__) || defined(__i686__) || (defined(_M_IX86) && (_M_IX86 >= 500))
-	#define CPU_X86 500
-#elif defined(__i486__) || (defined(_M_IX86) && (_M_IX86 >= 400))
-	#define CPU_X86 400
-#elif defined(__i386__) || (defined(_M_IX86) && (_M_IX86 >= 300)) || defined(__X86__) || defined(_X86_) || defined(__I86__)
-	#define CPU_X86 300
-#elif defined(__ia64__) || defined(_IA64) || defined(__IA64__) || defined(_M_IA64) || defined(__ia64)
-	#define CPU_IA64
-#endif
-
-#if defined(__sparc__) || defined(__sparc) || defined(__sparcv9)
-	#define CPU_SPARC
-	#if defined(__sparcv9)
-		#define CPU_SPARC64
-	#endif
-#endif
-
-#if defined(CPU_X86_64) || defined(CPU_IA64) || defined(CPU_SPARC64) || defined(__64BIT__) || defined(__LP64__) || defined(_LP64) || (defined(_MIPS_SZLONG) && (_MIPS_SZLONG == 64))
-	#define CPU_64BITS
-	#undef FASTCALL
-	#define FASTCALL
-	#undef CDECL
-	#define CDECL
-	#undef STDCALL
-	#define STDCALL
-#endif
-
-#if defined(powerpc) || defined(__PPC__) || defined(__ppc__) || defined(_ARCH_PPC) || defined(__powerpc__) || defined(__powerpc) || defined(POWERPC) || defined(_M_PPC)
-	#define CPU_PPC
-	#if defined(_ARCH_PWR7)
-		#define CPU_POWER7
-	#elif defined(__64BIT__)
-		#define CPU_PPC64
-	#else
-		#define CPU_PPC32
-	#endif
-#endif
-
-#if defined(__hppa__) || defined(__hppa)
-	#define CPU_HPPA
-#endif
-
-#if defined(__alpha__) || defined(__alpha) || defined(_M_ALPHA)
-	#define CPU_ALPHA
-#endif
-
-/* endian */
-
-#if ((defined(__BYTE_ORDER) && defined(__LITTLE_ENDIAN) && (__BYTE_ORDER == __LITTLE_ENDIAN)) || \
-	 (defined(BYTE_ORDER) && defined(LITTLE_ENDIAN) && (BYTE_ORDER == LITTLE_ENDIAN)) || \
-	 (defined(CPU_X86) || defined(CPU_X86_64)) || \
-	 (defined(vax) || defined(MIPSEL) || defined(_MIPSEL)))
-#define CPU_LE
-#elif ((defined(__BYTE_ORDER) && defined(__BIG_ENDIAN) && (__BYTE_ORDER == __BIG_ENDIAN)) || \
-	   (defined(BYTE_ORDER) && defined(BIG_ENDIAN) && (BYTE_ORDER == BIG_ENDIAN)) || \
-	   (defined(CPU_SPARC) || defined(CPU_PPC) || defined(mc68000) || defined(sel)) || defined(_MIPSEB))
-#define CPU_BE
-#else
-	/* unknown endian! */
-#endif
-
-
-#define U8TO32_BE(p)                                            \
-	(((uint32_t)((p)[0]) << 24) | ((uint32_t)((p)[1]) << 16) |  \
-	 ((uint32_t)((p)[2]) <<  8) | ((uint32_t)((p)[3])      ))
-
-#define U8TO32_LE(p)                                            \
-	(((uint32_t)((p)[0])      ) | ((uint32_t)((p)[1]) <<  8) |  \
-	 ((uint32_t)((p)[2]) << 16) | ((uint32_t)((p)[3]) << 24))
-
-#define U32TO8_BE(p, v)                                           \
-	(p)[0] = (uint8_t)((v) >> 24); (p)[1] = (uint8_t)((v) >> 16); \
-	(p)[2] = (uint8_t)((v) >>  8); (p)[3] = (uint8_t)((v)      );
-
-#define U32TO8_LE(p, v)                                           \
-	(p)[0] = (uint8_t)((v)      ); (p)[1] = (uint8_t)((v) >>  8); \
-	(p)[2] = (uint8_t)((v) >> 16); (p)[3] = (uint8_t)((v) >> 24);
-
-#define U8TO64_BE(p)                                                  \
-	(((uint64_t)U8TO32_BE(p) << 32) | (uint64_t)U8TO32_BE((p) + 4))
-
-#define U8TO64_LE(p)                                                  \
-	(((uint64_t)U8TO32_LE(p)) | ((uint64_t)U8TO32_LE((p) + 4) << 32))
-
-#define U64TO8_BE(p, v)                        \
-	U32TO8_BE((p),     (uint32_t)((v) >> 32)); \
-	U32TO8_BE((p) + 4, (uint32_t)((v)      ));
-
-#define U64TO8_LE(p, v)                        \
-	U32TO8_LE((p),     (uint32_t)((v)      )); \
-	U32TO8_LE((p) + 4, (uint32_t)((v) >> 32));
-
-#define U32_SWAP(v) {                                             \
-	(v) = (((v) << 8) & 0xFF00FF00 ) | (((v) >> 8) & 0xFF00FF );  \
-    (v) = ((v) << 16) | ((v) >> 16);                              \
-}
-
-#define U64_SWAP(v) {                                                                       \
-	(v) = (((v) <<  8) & 0xFF00FF00FF00FF00ull ) | (((v) >>  8) & 0x00FF00FF00FF00FFull );  \
-	(v) = (((v) << 16) & 0xFFFF0000FFFF0000ull ) | (((v) >> 16) & 0x0000FFFF0000FFFFull );  \
-    (v) = ((v) << 32) | ((v) >> 32);                                                        \
-}
-
-static int
-scrypt_verify(const uint8_t *x, const uint8_t *y, size_t len) {
-	uint32_t differentbits = 0;
-	while (len--)
-		differentbits |= (*x++ ^ *y++);
-	return (1 & ((differentbits - 1) >> 8));
-}
-
-static void
-scrypt_ensure_zero(void *p, size_t len) {
-#if ((defined(CPU_X86) || defined(CPU_X86_64)) && defined(COMPILER_MSVC))
-		__stosb((unsigned char *)p, 0, len);
-#elif (defined(CPU_X86) && defined(COMPILER_GCC))
-	__asm__ __volatile__(
-		"pushl %%edi;\n"
-		"pushl %%ecx;\n"
-		"rep stosb;\n"
-		"popl %%ecx;\n"
-		"popl %%edi;\n"
-		:: "a"(0), "D"(p), "c"(len) : "cc", "memory"
-	);
-#elif (defined(CPU_X86_64) && defined(COMPILER_GCC))
-	__asm__ __volatile__(
-		"pushq %%rdi;\n"
-		"pushq %%rcx;\n"
-		"rep stosb;\n"
-		"popq %%rcx;\n"
-		"popq %%rdi;\n"
-		:: "a"(0), "D"(p), "c"(len) : "cc", "memory"
-	);
-#else
-	volatile uint8_t *b = (volatile uint8_t *)p;
-	size_t i;
-	for (i = 0; i < len; i++)
-		b[i] = 0;
-#endif
-}
-
-#include "scrypt-jane-portable-x86.h"
-
-#if !defined(asm_calling_convention)
-#define asm_calling_convention
-#endif

algo/argon2/ar2/sj/scrypt-jane-romix-basic.h

@@ -1,74 +0,0 @@
-#if !defined(SCRYPT_CHOOSE_COMPILETIME)
-/* function type returned by scrypt_getROMix, used with cpu detection */
-typedef void (FASTCALL *scrypt_ROMixfn)(scrypt_mix_word_t *X/*[chunkWords]*/, scrypt_mix_word_t *Y/*[chunkWords]*/, scrypt_mix_word_t *V/*[chunkWords * N]*/, uint32_t N, uint32_t r);
-#endif
-
-/* romix pre/post nop function */
-static void asm_calling_convention
-scrypt_romix_nop(scrypt_mix_word_t *blocks, size_t nblocks) {
-	(void)blocks; (void)nblocks;
-}
-
-/* romix pre/post endian conversion function */
-static void asm_calling_convention
-scrypt_romix_convert_endian(scrypt_mix_word_t *blocks, size_t nblocks) {
-#if !defined(CPU_LE)
-	static const union { uint8_t b[2]; uint16_t w; } endian_test = {{1,0}};
-	size_t i;
-	if (endian_test.w == 0x100) {
-		nblocks *= SCRYPT_BLOCK_WORDS;
-		for (i = 0; i < nblocks; i++) {
-			SCRYPT_WORD_ENDIAN_SWAP(blocks[i]);
-		}
-	}
-#else
-	(void)blocks; (void)nblocks;
-#endif
-}
-
-/* chunkmix test function */
-typedef void (asm_calling_convention *chunkmixfn)(scrypt_mix_word_t *Bout/*[chunkWords]*/, scrypt_mix_word_t *Bin/*[chunkWords]*/, scrypt_mix_word_t *Bxor/*[chunkWords]*/, uint32_t r);
-typedef void (asm_calling_convention *blockfixfn)(scrypt_mix_word_t *blocks, size_t nblocks);
-
-static int
-scrypt_test_mix_instance(chunkmixfn mixfn, blockfixfn prefn, blockfixfn postfn, const uint8_t expected[16]) {
-	/* r = 2, (2 * r) = 4 blocks in a chunk, 4 * SCRYPT_BLOCK_WORDS total */
-	const uint32_t r = 2, blocks = 2 * r, words = blocks * SCRYPT_BLOCK_WORDS;
-#if (defined(X86ASM_AVX2) || defined(X86_64ASM_AVX2) || defined(X86_INTRINSIC_AVX2))
-	scrypt_mix_word_t ALIGN(32) chunk[2][4 * SCRYPT_BLOCK_WORDS], v;
-#else
-	scrypt_mix_word_t ALIGN(16) chunk[2][4 * SCRYPT_BLOCK_WORDS], v;
-#endif
-	uint8_t final[16];
-	size_t i;
-
-	for (i = 0; i < words; i++) {
-		v = (scrypt_mix_word_t)i;
-		v = (v << 8) | v;
-		v = (v << 16) | v;
-		chunk[0][i] = v;
-	}
-
-	prefn(chunk[0], blocks);
-	mixfn(chunk[1], chunk[0], NULL, r);
-	postfn(chunk[1], blocks);
-
-	/* grab the last 16 bytes of the final block */
-	for (i = 0; i < 16; i += sizeof(scrypt_mix_word_t)) {
-		SCRYPT_WORDTO8_LE(final + i, chunk[1][words - (16 / sizeof(scrypt_mix_word_t)) + (i / sizeof(scrypt_mix_word_t))]);
-	}
-
-	return scrypt_verify(expected, final, 16);
-}
-
-/* returns a pointer to item i, where item is len scrypt_mix_word_t's long */
-static scrypt_mix_word_t *
-scrypt_item(scrypt_mix_word_t *base, scrypt_mix_word_t i, scrypt_mix_word_t len) {
-	return base + (i * len);
-}
-
-/* returns a pointer to block i */
-static scrypt_mix_word_t *
-scrypt_block(scrypt_mix_word_t *base, scrypt_mix_word_t i) {
-	return base + (i * SCRYPT_BLOCK_WORDS);
-}

algo/argon2/ar2/sj/scrypt-jane-romix-template.h

@@ -1,122 +0,0 @@
-#if !defined(SCRYPT_CHOOSE_COMPILETIME) || !defined(SCRYPT_HAVE_ROMIX)
-
-#if defined(SCRYPT_CHOOSE_COMPILETIME)
-#undef SCRYPT_ROMIX_FN
-#define SCRYPT_ROMIX_FN scrypt_ROMix
-#endif
-
-#undef SCRYPT_HAVE_ROMIX
-#define SCRYPT_HAVE_ROMIX
-
-#if !defined(SCRYPT_CHUNKMIX_FN)
-
-#define SCRYPT_CHUNKMIX_FN scrypt_ChunkMix_basic
-
-/*
-	Bout = ChunkMix(Bin)
-
-	2*r: number of blocks in the chunk
-*/
-static void asm_calling_convention
-SCRYPT_CHUNKMIX_FN(scrypt_mix_word_t *Bout/*[chunkWords]*/, scrypt_mix_word_t *Bin/*[chunkWords]*/, scrypt_mix_word_t *Bxor/*[chunkWords]*/, uint32_t r) {
-#if (defined(X86ASM_AVX2) || defined(X86_64ASM_AVX2) || defined(X86_INTRINSIC_AVX2))
-	scrypt_mix_word_t ALIGN(32) X[SCRYPT_BLOCK_WORDS], *block;
-#else
-	scrypt_mix_word_t ALIGN(16) X[SCRYPT_BLOCK_WORDS], *block;
-#endif
-	uint32_t i, j, blocksPerChunk = /*r * 2*/2, half = 0;
-
-	/* 1: X = B_{2r - 1} */
-	block = scrypt_block(Bin, blocksPerChunk - 1);
-	for (i = 0; i < SCRYPT_BLOCK_WORDS; i++)
-		X[i] = block[i];
-
-	if (Bxor) {
-		block = scrypt_block(Bxor, blocksPerChunk - 1);
-		for (i = 0; i < SCRYPT_BLOCK_WORDS; i++)
-			X[i] ^= block[i];
-	}
-
-	/* 2: for i = 0 to 2r - 1 do */
-	for (i = 0; i < blocksPerChunk; i++, half ^= /*r*/1) {
-		/* 3: X = H(X ^ B_i) */
-		block = scrypt_block(Bin, i);
-		for (j = 0; j < SCRYPT_BLOCK_WORDS; j++)
-			X[j] ^= block[j];
-
-		if (Bxor) {
-			block = scrypt_block(Bxor, i);
-			for (j = 0; j < SCRYPT_BLOCK_WORDS; j++)
-				X[j] ^= block[j];
-		}
-		SCRYPT_MIX_FN(X);
-
-		/* 4: Y_i = X */
-		/* 6: B'[0..r-1] = Y_even */
-		/* 6: B'[r..2r-1] = Y_odd */
-		block = scrypt_block(Bout, (i / 2) + half);
-		for (j = 0; j < SCRYPT_BLOCK_WORDS; j++)
-			block[j] = X[j];
-	}
-}
-#endif
-
-/*
-	X = ROMix(X)
-
-	X: chunk to mix
-	Y: scratch chunk
-	N: number of rounds
-	V[N]: array of chunks to randomly index in to
-	2*r: number of blocks in a chunk
-*/
-
-static void NOINLINE FASTCALL
-SCRYPT_ROMIX_FN(scrypt_mix_word_t *X/*[chunkWords]*/, scrypt_mix_word_t *Y/*[chunkWords]*/, scrypt_mix_word_t *V/*[N * chunkWords]*/, uint32_t N, uint32_t r) {
-	uint32_t i, j, chunkWords = (uint32_t)(SCRYPT_BLOCK_WORDS * 2);
-	scrypt_mix_word_t *block = V;
-
-	SCRYPT_ROMIX_TANGLE_FN(X, 2);
-
-	/* 1: X = B */
-	/* implicit */
-
-	/* 2: for i = 0 to N - 1 do */
-	memcpy(block, X, chunkWords * sizeof(scrypt_mix_word_t));
-	for (i = 0; i < /*N - 1*/511; i++, block += chunkWords) {
-		/* 3: V_i = X */
-		/* 4: X = H(X) */
-		SCRYPT_CHUNKMIX_FN(block + chunkWords, block, NULL, /*r*/1);
-	}
-	SCRYPT_CHUNKMIX_FN(X, block, NULL, 1);
-
-	/* 6: for i = 0 to N - 1 do */
-	for (i = 0; i < /*N*/512; i += 2) {
-		/* 7: j = Integerify(X) % N */
-		j = X[chunkWords - SCRYPT_BLOCK_WORDS] & /*(N - 1)*/511;
-
-		/* 8: X = H(Y ^ V_j) */
-		SCRYPT_CHUNKMIX_FN(Y, X, scrypt_item(V, j, chunkWords), 1);
-
-		/* 7: j = Integerify(Y) % N */
-		j = Y[chunkWords - SCRYPT_BLOCK_WORDS] & /*(N - 1)*/511;
-
-		/* 8: X = H(Y ^ V_j) */
-		SCRYPT_CHUNKMIX_FN(X, Y, scrypt_item(V, j, chunkWords), 1);
-	}
-
-	/* 10: B' = X */
-	/* implicit */
-
-	SCRYPT_ROMIX_UNTANGLE_FN(X, 2);
-}
-
-#endif /* !defined(SCRYPT_CHOOSE_COMPILETIME) || !defined(SCRYPT_HAVE_ROMIX) */
-
-
-#undef SCRYPT_CHUNKMIX_FN
-#undef SCRYPT_ROMIX_FN
-#undef SCRYPT_MIX_FN
-#undef SCRYPT_ROMIX_TANGLE_FN
-#undef SCRYPT_ROMIX_UNTANGLE_FN
-

algo/argon2/ar2/sj/scrypt-jane-romix.h

@@ -1,23 +0,0 @@
-#if defined(SCRYPT_SALSA64)
-#include "scrypt-jane-salsa64.h"
-#else
-	#define SCRYPT_MIX_BASE "ERROR"
-	typedef uint32_t scrypt_mix_word_t;
-	#define SCRYPT_WORDTO8_LE U32TO8_LE
-	#define SCRYPT_WORD_ENDIAN_SWAP U32_SWAP
-	#define SCRYPT_BLOCK_BYTES 64
-	#define SCRYPT_BLOCK_WORDS (SCRYPT_BLOCK_BYTES / sizeof(scrypt_mix_word_t))
-	#if !defined(SCRYPT_CHOOSE_COMPILETIME)
-		static void FASTCALL scrypt_ROMix_error(scrypt_mix_word_t *X/*[chunkWords]*/, scrypt_mix_word_t *Y/*[chunkWords]*/, scrypt_mix_word_t *V/*[chunkWords * N]*/, uint32_t N, uint32_t r) {}
-		static scrypt_ROMixfn scrypt_getROMix(void) { return scrypt_ROMix_error; }
-	#else
-		static void FASTCALL scrypt_ROMix(scrypt_mix_word_t *X, scrypt_mix_word_t *Y, scrypt_mix_word_t *V, uint32_t N, uint32_t r) {}
-	#endif
-	static int scrypt_test_mix(void) { return 0; }
-	#error must define a mix function!
-#endif
-
-#if !defined(SCRYPT_CHOOSE_COMPILETIME)
-#undef SCRYPT_MIX
-#define SCRYPT_MIX SCRYPT_MIX_BASE
-#endif

algo/argon2/ar2/sj/scrypt-jane-salsa64.h

@@ -1,183 +0,0 @@
-#define SCRYPT_MIX_BASE "Salsa64/8"
-
-typedef uint64_t scrypt_mix_word_t;
-
-#define SCRYPT_WORDTO8_LE U64TO8_LE
-#define SCRYPT_WORD_ENDIAN_SWAP U64_SWAP
-
-#define SCRYPT_BLOCK_BYTES 128
-#define SCRYPT_BLOCK_WORDS (SCRYPT_BLOCK_BYTES / sizeof(scrypt_mix_word_t))
-
-/* must have these here in case block bytes is ever != 64 */
-#include "scrypt-jane-romix-basic.h"
-
-#include "scrypt-jane-mix_salsa64-avx2.h"
-#include "scrypt-jane-mix_salsa64-xop.h"
-#include "scrypt-jane-mix_salsa64-avx.h"
-#include "scrypt-jane-mix_salsa64-ssse3.h"
-#include "scrypt-jane-mix_salsa64-sse2.h"
-#include "scrypt-jane-mix_salsa64.h"
-
-#if defined(SCRYPT_SALSA64_AVX2)
-	#define SCRYPT_CHUNKMIX_FN scrypt_ChunkMix_avx2
-	#define SCRYPT_ROMIX_FN scrypt_ROMix_avx2
-	#define SCRYPT_ROMIX_TANGLE_FN salsa64_core_tangle_sse2
-	#define SCRYPT_ROMIX_UNTANGLE_FN salsa64_core_tangle_sse2
-	#include "scrypt-jane-romix-template.h"
-#endif
-
-#if defined(SCRYPT_SALSA64_XOP)
-	#define SCRYPT_CHUNKMIX_FN scrypt_ChunkMix_xop
-	#define SCRYPT_ROMIX_FN scrypt_ROMix_xop
-	#define SCRYPT_ROMIX_TANGLE_FN salsa64_core_tangle_sse2
-	#define SCRYPT_ROMIX_UNTANGLE_FN salsa64_core_tangle_sse2
-	#include "scrypt-jane-romix-template.h"
-#endif
-
-#if defined(SCRYPT_SALSA64_AVX)
-	#define SCRYPT_CHUNKMIX_FN scrypt_ChunkMix_avx
-	#define SCRYPT_ROMIX_FN scrypt_ROMix_avx
-	#define SCRYPT_ROMIX_TANGLE_FN salsa64_core_tangle_sse2
-	#define SCRYPT_ROMIX_UNTANGLE_FN salsa64_core_tangle_sse2
-	#include "scrypt-jane-romix-template.h"
-#endif
-
-#if defined(SCRYPT_SALSA64_SSSE3)
-	#define SCRYPT_CHUNKMIX_FN scrypt_ChunkMix_ssse3
-	#define SCRYPT_ROMIX_FN scrypt_ROMix_ssse3
-	#define SCRYPT_ROMIX_TANGLE_FN salsa64_core_tangle_sse2
-	#define SCRYPT_ROMIX_UNTANGLE_FN salsa64_core_tangle_sse2
-	#include "scrypt-jane-romix-template.h"
-#endif
-
-#if defined(SCRYPT_SALSA64_SSE2)
-	#define SCRYPT_CHUNKMIX_FN scrypt_ChunkMix_sse2
-	#define SCRYPT_ROMIX_FN scrypt_ROMix_sse2
-	#define SCRYPT_ROMIX_TANGLE_FN salsa64_core_tangle_sse2
-	#define SCRYPT_ROMIX_UNTANGLE_FN salsa64_core_tangle_sse2
-	#include "scrypt-jane-romix-template.h"
-#endif
-
-/* cpu agnostic */
-#define SCRYPT_ROMIX_FN scrypt_ROMix_basic
-#define SCRYPT_MIX_FN salsa64_core_basic
-#define SCRYPT_ROMIX_TANGLE_FN scrypt_romix_convert_endian
-#define SCRYPT_ROMIX_UNTANGLE_FN scrypt_romix_convert_endian
-#include "scrypt-jane-romix-template.h"
-
-#if !defined(SCRYPT_CHOOSE_COMPILETIME)
-static scrypt_ROMixfn
-scrypt_getROMix(void) {
-	size_t cpuflags = detect_cpu();
-
-#if defined(SCRYPT_SALSA64_AVX2)
-	if (cpuflags & cpu_avx2)
-		return scrypt_ROMix_avx2;
-	else
-#endif
-
-#if defined(SCRYPT_SALSA64_XOP)
-	if (cpuflags & cpu_xop)
-		return scrypt_ROMix_xop;
-	else
-#endif
-
-#if defined(SCRYPT_SALSA64_AVX)
-	if (cpuflags & cpu_avx)
-		return scrypt_ROMix_avx;
-	else
-#endif
-
-#if defined(SCRYPT_SALSA64_SSSE3)
-	if (cpuflags & cpu_ssse3)
-		return scrypt_ROMix_ssse3;
-	else
-#endif
-
-#if defined(SCRYPT_SALSA64_SSE2)
-	if (cpuflags & cpu_sse2)
-		return scrypt_ROMix_sse2;
-	else
-#endif
-
-	return scrypt_ROMix_basic;
-}
-#endif
-
-
-#if defined(SCRYPT_TEST_SPEED)
-static size_t
-available_implementations(void) {
-	size_t cpuflags = detect_cpu();
-	size_t flags = 0;
-
-#if defined(SCRYPT_SALSA64_AVX2)
-	if (cpuflags & cpu_avx2)
-		flags |= cpu_avx2;
-#endif
-
-#if defined(SCRYPT_SALSA64_XOP)
-	if (cpuflags & cpu_xop)
-		flags |= cpu_xop;
-#endif
-
-#if defined(SCRYPT_SALSA64_AVX)
-	if (cpuflags & cpu_avx)
-		flags |= cpu_avx;
-#endif
-
-#if defined(SCRYPT_SALSA64_SSSE3)
-	if (cpuflags & cpu_ssse3)
-		flags |= cpu_ssse3;
-#endif
-
-#if defined(SCRYPT_SALSA64_SSE2)
-	if (cpuflags & cpu_sse2)
-		flags |= cpu_sse2;
-#endif
-
-	return flags;
-}
-#endif
-
-static int
-scrypt_test_mix(void) {
-	static const uint8_t expected[16] = {
-		0xf8,0x92,0x9b,0xf8,0xcc,0x1d,0xce,0x2e,0x13,0x82,0xac,0x96,0xb2,0x6c,0xee,0x2c,
-	};
-
-	int ret = 1;
-	size_t cpuflags = detect_cpu();
-
-#if defined(SCRYPT_SALSA64_AVX2)
-	if (cpuflags & cpu_avx2)
-		ret &= scrypt_test_mix_instance(scrypt_ChunkMix_avx2, salsa64_core_tangle_sse2, salsa64_core_tangle_sse2, expected);
-#endif
-
-#if defined(SCRYPT_SALSA64_XOP)
-	if (cpuflags & cpu_xop)
-		ret &= scrypt_test_mix_instance(scrypt_ChunkMix_xop, salsa64_core_tangle_sse2, salsa64_core_tangle_sse2, expected);
-#endif
-
-#if defined(SCRYPT_SALSA64_AVX)
-	if (cpuflags & cpu_avx)
-		ret &= scrypt_test_mix_instance(scrypt_ChunkMix_avx, salsa64_core_tangle_sse2, salsa64_core_tangle_sse2, expected);
-#endif
-
-#if defined(SCRYPT_SALSA64_SSSE3)
-	if (cpuflags & cpu_ssse3)
-		ret &= scrypt_test_mix_instance(scrypt_ChunkMix_ssse3, salsa64_core_tangle_sse2, salsa64_core_tangle_sse2, expected);
-#endif
-
-#if defined(SCRYPT_SALSA64_SSE2)
-	if (cpuflags & cpu_sse2)
-		ret &= scrypt_test_mix_instance(scrypt_ChunkMix_sse2, salsa64_core_tangle_sse2, salsa64_core_tangle_sse2, expected);
-#endif
-
-#if defined(SCRYPT_SALSA64_BASIC)
-	ret &= scrypt_test_mix_instance(scrypt_ChunkMix_basic, scrypt_romix_convert_endian, scrypt_romix_convert_endian, expected);
-#endif
-
-	return ret;
-}
-

algo/argon2/ar2/sj/scrypt-jane-test-vectors.h

@@ -1,28 +0,0 @@
-typedef struct scrypt_test_setting_t {
-	const char *pw, *salt;
-	uint8_t Nfactor, rfactor, pfactor;
-} scrypt_test_setting;
-
-static const scrypt_test_setting post_settings[] = {
-	{"", "", 3, 0, 0},
-	{"password", "NaCl", 9, 3, 4},
-	{0, 0, 0, 0, 0}
-};
-
-#if defined(SCRYPT_SKEIN512)
-	#if defined(SCRYPT_SALSA64)
-		static const uint8_t post_vectors[][64] = {
-			{0xd2,0xad,0x32,0x05,0xee,0x80,0xe3,0x44,0x70,0xc6,0x34,0xde,0x05,0xb6,0xcf,0x60,
-			 0x89,0x98,0x70,0xc0,0xb8,0xf5,0x54,0xf1,0xa6,0xb2,0xc8,0x76,0x34,0xec,0xc4,0x59,
-			 0x8e,0x64,0x42,0xd0,0xa9,0xed,0xe7,0x19,0xb2,0x8a,0x11,0xc6,0xa6,0xbf,0xa7,0xa9,
-			 0x4e,0x44,0x32,0x7e,0x12,0x91,0x9d,0xfe,0x52,0x48,0xa8,0x27,0xb3,0xfc,0xb1,0x89},
-			{0xd6,0x67,0xd2,0x3e,0x30,0x1e,0x9d,0xe2,0x55,0x68,0x17,0x3d,0x2b,0x75,0x5a,0xe5,
-			 0x04,0xfb,0x3d,0x0e,0x86,0xe0,0xaa,0x1d,0xd4,0x72,0xda,0xb0,0x79,0x41,0xb7,0x99,
-			 0x68,0xe5,0xd9,0x55,0x79,0x7d,0xc3,0xd1,0xa6,0x56,0xc1,0xbe,0x0b,0x6c,0x62,0x23,
-			 0x66,0x67,0x91,0x47,0x99,0x13,0x6b,0xe3,0xda,0x59,0x55,0x18,0x67,0x8f,0x2e,0x3b}
-		};
-	#endif
-#else
-	static const uint8_t post_vectors[][64] = {{0}};
-#endif
-

algo/argon2/argon2a.c

@@ -1,90 +0,0 @@
-#include <stdlib.h>
-#include <stdint.h>
-#include <string.h>
-#include <stdio.h>
-#include <openssl/sha.h>
-#include "ar2/argon2.h"
-#include "ar2/cores.h"
-#include "ar2/ar2-scrypt-jane.h"
-#include "algo-gate-api.h"
-
-#define T_COSTS 2
-#define M_COSTS 16
-#define MASK 8
-#define ZERO 0
-
-inline void argon_call(void *out, void *in, void *salt, int type)
-{
-	argon2_context context;
-
-	context.out = (uint8_t *)out;
-	context.pwd = (uint8_t *)in;
-	context.salt = (uint8_t*)salt;
-	context.pwdlen = 0;
-	context.allocate_cbk = NULL;
-	context.free_cbk = NULL;
-
-	argon2_core(&context, type);
-}
-
-void argon2hash(void *output, const void *input)
-{
-	uint32_t _ALIGN(64) hashA[8], hashB[8];
-
-	my_scrypt((const unsigned char *)input, 80,
-		(const unsigned char *)input, 80,
-		(unsigned char *)hashA);
-
-	argon_call(hashB, hashA, hashA, (hashA[0] & MASK) == ZERO);
-
-	my_scrypt((const unsigned char *)hashB, 32,
-		(const unsigned char *)hashB, 32,
-		(unsigned char *)output);
-}
-
-int scanhash_argon2(int thr_id, struct work* work, uint32_t max_nonce, uint64_t *hashes_done)
-{
-	uint32_t _ALIGN(64) endiandata[20];
-	uint32_t _ALIGN(64) hash[8];
-	uint32_t *pdata = work->data;
-	uint32_t *ptarget = work->target;
-
-	const uint32_t first_nonce = pdata[19];
-	const uint32_t Htarg = ptarget[7];
-	uint32_t nonce = first_nonce;
-
-        swab32_array( endiandata, pdata, 20 );
-
-	do {
-		be32enc(&endiandata[19], nonce);
-		argon2hash(hash, endiandata);
-		if (hash[7] <= Htarg && fulltest(hash, ptarget)) {
-			pdata[19] = nonce;
-			*hashes_done = pdata[19] - first_nonce;
-			work_set_target_ratio(work, hash);
-			return 1;
-		}
-		nonce++;
-	} while (nonce < max_nonce && !work_restart[thr_id].restart);
-
-	pdata[19] = nonce;
-	*hashes_done = pdata[19] - first_nonce + 1;
-	return 0;
-}
-
-int64_t argon2_get_max64 ()
-{
-  return 0x1ffLL;
-}
-
-bool register_argon2_algo( algo_gate_t* gate )
-{
-  gate->optimizations = SSE2_OPT | AES_OPT | AVX_OPT | AVX2_OPT;
-  gate->scanhash        = (void*)&scanhash_argon2;
-  gate->hash            = (void*)&argon2hash;
-  gate->gen_merkle_root = (void*)&SHA256_gen_merkle_root;
-  gate->set_target      = (void*)&scrypt_set_target;
-  gate->get_max64       = (void*)&argon2_get_max64;
-  return true;
-};
-

algo/argon2d/argon2d-gate.c

@@ -0,0 +1,189 @@
+#include "argon2d-gate.h"
+#include "simd-utils.h"
+#include "argon2d/argon2.h"
+
+static const size_t INPUT_BYTES = 80;  // Lenth of a block header in bytes. Input Length = Salt Length (salt = input)
+static const size_t OUTPUT_BYTES = 32; // Length of output needed for a 256-bit hash
+static const unsigned int DEFAULT_ARGON2_FLAG = 2; //Same as ARGON2_DEFAULT_FLAGS
+
+// Credits
+
+void argon2d_crds_hash( void *output, const void *input )
+{
+	argon2_context context;
+	context.out = (uint8_t *)output;
+	context.outlen = (uint32_t)OUTPUT_BYTES;
+	context.pwd = (uint8_t *)input;
+	context.pwdlen = (uint32_t)INPUT_BYTES;
+	context.salt = (uint8_t *)input; //salt = input
+	context.saltlen = (uint32_t)INPUT_BYTES;
+	context.secret = NULL;
+	context.secretlen = 0;
+	context.ad = NULL;
+	context.adlen = 0;
+	context.allocate_cbk = NULL;
+	context.free_cbk = NULL;
+	context.flags = DEFAULT_ARGON2_FLAG; // = ARGON2_DEFAULT_FLAGS
+	// main configurable Argon2 hash parameters
+	context.m_cost = 250; // Memory in KiB (~256KB)
+	context.lanes = 4;    // Degree of Parallelism
+	context.threads = 1;  // Threads
+	context.t_cost = 1;   // Iterations
+        context.version = ARGON2_VERSION_10;
+
+	argon2_ctx( &context, Argon2_d );
+}
+
+int scanhash_argon2d_crds( struct work *work, uint32_t max_nonce,
+                      uint64_t *hashes_done, struct thr_info *mythr )
+{
+   uint32_t _ALIGN(64) edata[20];
+   uint32_t _ALIGN(64) hash[8];
+   uint32_t *pdata = work->data;
+   uint32_t *ptarget = work->target;
+   int thr_id = mythr->id;  // thr_id arg is deprecated
+   const uint32_t first_nonce = pdata[19];
+   const uint32_t Htarg = ptarget[7];
+   uint32_t nonce = first_nonce;
+
+   swab32_array( edata, pdata, 20 );
+
+   do {
+      be32enc(&edata[19], nonce);
+      argon2d_crds_hash( hash, edata );
+      if ( hash[7] <= Htarg && fulltest( hash, ptarget ) && !opt_benchmark )
+      {
+          pdata[19] = nonce;
+          submit_solution( work, hash, mythr );
+      }
+      nonce++;
+   } while (nonce < max_nonce && !work_restart[thr_id].restart);
+
+   pdata[19] = nonce;
+   *hashes_done = pdata[19] - first_nonce + 1;
+   return 0;
+}
+
+bool register_argon2d_crds_algo( algo_gate_t* gate )
+{
+        gate->scanhash = (void*)&scanhash_argon2d_crds;
+        gate->hash = (void*)&argon2d_crds_hash;
+        gate->optimizations = SSE2_OPT | AVX2_OPT | AVX512_OPT | NEON_OPT;
+        opt_target_factor = 65536.0;
+        return true;
+}
+
+// Dynamic
+
+void argon2d_dyn_hash( void *output, const void *input )
+{
+    argon2_context context;
+    context.out = (uint8_t *)output;
+    context.outlen = (uint32_t)OUTPUT_BYTES;
+    context.pwd = (uint8_t *)input;
+    context.pwdlen = (uint32_t)INPUT_BYTES;
+    context.salt = (uint8_t *)input; //salt = input
+    context.saltlen = (uint32_t)INPUT_BYTES;
+    context.secret = NULL;
+    context.secretlen = 0;
+    context.ad = NULL;
+    context.adlen = 0;
+    context.allocate_cbk = NULL;
+    context.free_cbk = NULL;
+    context.flags = DEFAULT_ARGON2_FLAG; // = ARGON2_DEFAULT_FLAGS
+    // main configurable Argon2 hash parameters
+    context.m_cost = 500;  // Memory in KiB (512KB)
+    context.lanes = 8;     // Degree of Parallelism
+    context.threads = 1;   // Threads
+    context.t_cost = 2;    // Iterations
+    context.version = ARGON2_VERSION_10;
+
+    argon2_ctx( &context, Argon2_d );
+}
+
+int scanhash_argon2d_dyn( struct work *work, uint32_t max_nonce,
+                      uint64_t *hashes_done, struct thr_info *mythr )
+{
+   uint32_t _ALIGN(64) edata[20];
+   uint32_t _ALIGN(64) hash[8];
+   uint32_t *pdata = work->data;
+   uint32_t *ptarget = work->target;
+   const int thr_id = mythr->id; 
+   const uint32_t first_nonce = (const uint32_t)pdata[19];
+   const uint32_t last_nonce = (const uint32_t)max_nonce;
+   uint32_t nonce = first_nonce;
+   const bool bench = opt_benchmark;
+
+   v128_bswap32_80( edata, pdata );
+   do
+   {
+      edata[19] = nonce;
+      argon2d_dyn_hash( hash, edata );
+      if ( unlikely( valid_hash( (uint64_t*)hash, (uint64_t*)ptarget )
+           && !bench ) )
+      {
+          pdata[19] = bswap_32( nonce );;
+          submit_solution( work, hash, mythr );
+      }
+      nonce++;
+  } while ( likely( nonce < last_nonce && !work_restart[thr_id].restart ) );
+
+   pdata[19] = nonce;
+   *hashes_done = pdata[19] - first_nonce;
+   return 0;
+}
+
+bool register_argon2d_dyn_algo( algo_gate_t* gate )
+{
+        gate->scanhash = (void*)&scanhash_argon2d_dyn;
+        gate->hash = (void*)&argon2d_dyn_hash;
+        gate->optimizations = SSE2_OPT | AVX2_OPT | AVX512_OPT | NEON_OPT;
+        opt_target_factor = 65536.0;
+        return true;
+}
+
+// Unitus
+
+int scanhash_argon2d4096( struct work *work, uint32_t max_nonce,
+                           uint64_t *hashes_done, struct thr_info *mythr )
+{
+   uint32_t _ALIGN(64) vhash[8];
+   uint32_t _ALIGN(64) edata[20];
+   uint32_t *pdata = work->data;
+   uint32_t *ptarget = work->target;
+   const uint32_t first_nonce = pdata[19];
+   const uint32_t last_nonce = (const uint32_t)max_nonce;
+   uint32_t n = first_nonce;
+   const int thr_id = mythr->id;  // thr_id arg is deprecated
+   uint32_t t_cost = 1; // 1 iteration
+   uint32_t m_cost = 4096; // use 4MB
+   uint32_t parallelism = 1; // 1 thread, 2 lanes
+   const bool bench = opt_benchmark;
+
+   v128_bswap32_80( edata, pdata );
+
+   do {
+      edata[19] = n;
+      argon2d_hash_raw( t_cost, m_cost, parallelism, (char*) edata, 80,
+                 (char*) edata, 80, (char*) vhash, 32, ARGON2_VERSION_13 );
+      if ( unlikely( valid_hash( vhash, ptarget ) && !bench ) )
+      {
+         be32enc( &pdata[19], n );
+         submit_solution( work, vhash, mythr );
+      }
+      n++;
+   } while ( likely( n < last_nonce && !work_restart[thr_id].restart ) );
+
+   *hashes_done = n - first_nonce;
+   pdata[19] = n;
+   return 0;
+}
+
+bool register_argon2d4096_algo( algo_gate_t* gate )
+{
+        gate->scanhash = (void*)&scanhash_argon2d4096;
+        gate->optimizations = SSE2_OPT | AVX2_OPT | AVX512_OPT |NEON_OPT;
+        opt_target_factor = 65536.0;
+        return true;
+}
+

algo/argon2d/argon2d-gate.h

@@ -0,0 +1,31 @@
+#ifndef ARGON2D_GATE_H__
+#define ARGON2D_GATE_H__
+
+#include "algo-gate-api.h"
+#include <stdint.h>
+
+// Credits: version = 0x10, m_cost = 250.
+bool register_argon2d_crds_algo( algo_gate_t* gate );
+
+void argon2d_crds_hash( void *state, const void *input );
+
+int scanhash_argon2d_crds( struct work *work, uint32_t max_nonce,
+                    uint64_t *hashes_done, struct thr_info *mythr );
+
+// Dynamic: version = 0x10, m_cost = 500.
+bool register_argon2d_dyn_algo( algo_gate_t* gate );
+
+void argon2d_dyn_hash( void *state, const void *input );
+
+int scanhash_argon2d_dyn( struct work *work, uint32_t max_nonce,
+                    uint64_t *hashes_done, struct thr_info *mythr );
+
+
+// Unitus: version = 0x13, m_cost = 4096.
+bool register_argon2d4096_algo( algo_gate_t* gate );
+
+int scanhash_argon2d4096( struct work *work, uint32_t max_nonce,
+                    uint64_t *hashes_done, struct thr_info *mythr );
+
+#endif
+

algo/argon2d/argon2d/argon2.c

@@ -0,0 +1,458 @@
+/*
+ * Argon2 reference source code package - reference C implementations
+ *
+ * Copyright 2015
+ * Daniel Dinu, Dmitry Khovratovich, Jean-Philippe Aumasson, and Samuel Neves
+ *
+ * You may use this work under the terms of a Creative Commons CC0 1.0
+ * License/Waiver or the Apache Public License 2.0, at your option. The terms of
+ * these licenses can be found at:
+ *
+ * - CC0 1.0 Universal : http://creativecommons.org/publicdomain/zero/1.0
+ * - Apache 2.0        : http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * You should have received a copy of both of these licenses along with this
+ * software. If not, they may be obtained at the above URLs.
+ */
+
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "argon2.h"
+#include "encoding.h"
+#include "core.h"
+
+const char *argon2_type2string(argon2_type type, int uppercase) {
+    switch (type) {
+        case Argon2_d:
+            return uppercase ? "Argon2d" : "argon2d";
+        case Argon2_i:
+            return uppercase ? "Argon2i" : "argon2i";
+        case Argon2_id:
+            return uppercase ? "Argon2id" : "argon2id";
+    }
+
+    return NULL;
+}
+
+int argon2_ctx(argon2_context *context, argon2_type type) {
+    /* 1. Validate all inputs */
+    int result = validate_inputs(context);
+    uint32_t memory_blocks, segment_length;
+    argon2_instance_t instance;
+
+    if (ARGON2_OK != result) {
+        return result;
+    }
+
+    if (Argon2_d != type && Argon2_i != type && Argon2_id != type) {
+        return ARGON2_INCORRECT_TYPE;
+    }
+
+    /* 2. Align memory size */
+    /* Minimum memory_blocks = 8L blocks, where L is the number of lanes */
+    memory_blocks = context->m_cost;
+
+    if (memory_blocks < 2 * ARGON2_SYNC_POINTS * context->lanes) {
+        memory_blocks = 2 * ARGON2_SYNC_POINTS * context->lanes;
+    }
+
+    segment_length = memory_blocks / (context->lanes * ARGON2_SYNC_POINTS);
+    /* Ensure that all segments have equal length */
+    memory_blocks = segment_length * (context->lanes * ARGON2_SYNC_POINTS);
+
+    instance.version = context->version;
+    instance.memory = NULL;
+    instance.passes = context->t_cost;
+    instance.memory_blocks = memory_blocks;
+    instance.segment_length = segment_length;
+    instance.lane_length = segment_length * ARGON2_SYNC_POINTS;
+    instance.lanes = context->lanes;
+    instance.threads = context->threads;
+    instance.type = type;
+
+    if (instance.threads > instance.lanes) {
+        instance.threads = instance.lanes;
+    }
+
+    /* 3. Initialization: Hashing inputs, allocating memory, filling first
+     * blocks
+     */
+    result = initialize(&instance, context);
+
+    if (ARGON2_OK != result) {
+        return result;
+    }
+
+    /* 4. Filling memory */
+    result = fill_memory_blocks(&instance);
+
+    if (ARGON2_OK != result) {
+        return result;
+    }
+    /* 5. Finalization */
+    finalize(context, &instance);
+
+    return ARGON2_OK;
+}
+
+int argon2_hash(const uint32_t t_cost, const uint32_t m_cost,
+                const uint32_t parallelism, const void *pwd,
+                const size_t pwdlen, const void *salt, const size_t saltlen,
+                void *hash, const size_t hashlen, char *encoded,
+                const size_t encodedlen, argon2_type type,
+                const uint32_t version){
+
+    argon2_context context;
+    int result;
+    uint8_t *out;
+
+    if (pwdlen > ARGON2_MAX_PWD_LENGTH) {
+        return ARGON2_PWD_TOO_LONG;
+    }
+
+    if (saltlen > ARGON2_MAX_SALT_LENGTH) {
+        return ARGON2_SALT_TOO_LONG;
+    }
+
+    if (hashlen > ARGON2_MAX_OUTLEN) {
+        return ARGON2_OUTPUT_TOO_LONG;
+    }
+
+    if (hashlen < ARGON2_MIN_OUTLEN) {
+        return ARGON2_OUTPUT_TOO_SHORT;
+    }
+
+    out = malloc(hashlen);
+    if (!out) {
+        return ARGON2_MEMORY_ALLOCATION_ERROR;
+    }
+
+    context.out = (uint8_t *)out;
+    context.outlen = (uint32_t)hashlen;
+    context.pwd = CONST_CAST(uint8_t *)pwd;
+    context.pwdlen = (uint32_t)pwdlen;
+    context.salt = CONST_CAST(uint8_t *)salt;
+    context.saltlen = (uint32_t)saltlen;
+    context.secret = NULL;
+    context.secretlen = 0;
+    context.ad = NULL;
+    context.adlen = 0;
+    context.t_cost = t_cost;
+    context.m_cost = m_cost;
+    context.lanes = parallelism;
+    context.threads = parallelism;
+    context.allocate_cbk = NULL;
+    context.free_cbk = NULL;
+    context.flags = ARGON2_DEFAULT_FLAGS;
+    context.version = version;
+
+    result = argon2_ctx(&context, type);
+
+    if (result != ARGON2_OK) {
+        clear_internal_memory(out, hashlen);
+        free(out);
+        return result;
+    }
+
+    /* if raw hash requested, write it */
+    if (hash) {
+        memcpy(hash, out, hashlen);
+    }
+
+    /* if encoding requested, write it */
+    if (encoded && encodedlen) {
+        if (encode_string(encoded, encodedlen, &context, type) != ARGON2_OK) {
+            clear_internal_memory(out, hashlen); /* wipe buffers if error */
+            clear_internal_memory(encoded, encodedlen);
+            free(out);
+            return ARGON2_ENCODING_FAIL;
+        }
+    }
+    clear_internal_memory(out, hashlen);
+    free(out);
+
+    return ARGON2_OK;
+}
+
+int argon2i_hash_encoded(const uint32_t t_cost, const uint32_t m_cost,
+                         const uint32_t parallelism, const void *pwd,
+                         const size_t pwdlen, const void *salt,
+                         const size_t saltlen, const size_t hashlen,
+                         char *encoded, const size_t encodedlen,
+                         const uint32_t version) {
+
+    return argon2_hash(t_cost, m_cost, parallelism, pwd, pwdlen, salt, saltlen,
+                       NULL, hashlen, encoded, encodedlen, Argon2_i,
+                       version );
+}
+
+int argon2i_hash_raw(const uint32_t t_cost, const uint32_t m_cost,
+                     const uint32_t parallelism, const void *pwd,
+                     const size_t pwdlen, const void *salt,
+                     const size_t saltlen, void *hash, const size_t hashlen,
+                     const uint32_t version ) {
+
+    return argon2_hash(t_cost, m_cost, parallelism, pwd, pwdlen, salt, saltlen,
+                       hash, hashlen, NULL, 0, Argon2_i, version );
+}
+
+int argon2d_hash_encoded(const uint32_t t_cost, const uint32_t m_cost,
+                         const uint32_t parallelism, const void *pwd,
+                         const size_t pwdlen, const void *salt,
+                         const size_t saltlen, const size_t hashlen,
+                         char *encoded, const size_t encodedlen,
+                         const uint32_t version ) {
+
+    return argon2_hash(t_cost, m_cost, parallelism, pwd, pwdlen, salt, saltlen,
+                       NULL, hashlen, encoded, encodedlen, Argon2_d,
+                       version );
+}
+
+int argon2d_hash_raw(const uint32_t t_cost, const uint32_t m_cost,
+                     const uint32_t parallelism, const void *pwd,
+                     const size_t pwdlen, const void *salt,
+                     const size_t saltlen, void *hash, const size_t hashlen,
+                     const uint32_t version ) {
+
+    return argon2_hash(t_cost, m_cost, parallelism, pwd, pwdlen, salt, saltlen,
+                       hash, hashlen, NULL, 0, Argon2_d, version );
+}
+
+int argon2id_hash_encoded(const uint32_t t_cost, const uint32_t m_cost,
+                          const uint32_t parallelism, const void *pwd,
+                          const size_t pwdlen, const void *salt,
+                          const size_t saltlen, const size_t hashlen,
+                          char *encoded, const size_t encodedlen,
+                          const uint32_t version ) {
+
+    return argon2_hash(t_cost, m_cost, parallelism, pwd, pwdlen, salt, saltlen,
+                       NULL, hashlen, encoded, encodedlen, Argon2_id,
+                       version);
+}
+
+int argon2id_hash_raw(const uint32_t t_cost, const uint32_t m_cost,
+                      const uint32_t parallelism, const void *pwd,
+                      const size_t pwdlen, const void *salt,
+                      const size_t saltlen, void *hash, const size_t hashlen,
+                      const uint32_t version ) {
+    return argon2_hash(t_cost, m_cost, parallelism, pwd, pwdlen, salt, saltlen,
+                       hash, hashlen, NULL, 0, Argon2_id, version );
+}
+
+static int argon2_compare(const uint8_t *b1, const uint8_t *b2, size_t len) {
+    size_t i;
+    uint8_t d = 0U;
+
+    for (i = 0U; i < len; i++) {
+        d |= b1[i] ^ b2[i];
+    }
+    return (int)((1 & ((d - 1) >> 8)) - 1);
+}
+
+int argon2_verify(const char *encoded, const void *pwd, const size_t pwdlen,
+                  argon2_type type) {
+
+    argon2_context ctx;
+    uint8_t *desired_result = NULL;
+
+    int ret = ARGON2_OK;
+
+    size_t encoded_len;
+    uint32_t max_field_len;
+
+    if (pwdlen > ARGON2_MAX_PWD_LENGTH) {
+        return ARGON2_PWD_TOO_LONG;
+    }
+
+    if (encoded == NULL) {
+        return ARGON2_DECODING_FAIL;
+    }
+
+    encoded_len = strlen(encoded);
+    if (encoded_len > UINT32_MAX) {
+        return ARGON2_DECODING_FAIL;
+    }
+
+    /* No field can be longer than the encoded length */
+    max_field_len = (uint32_t)encoded_len;
+
+    ctx.saltlen = max_field_len;
+    ctx.outlen = max_field_len;
+
+    ctx.salt = malloc(ctx.saltlen);
+    ctx.out = malloc(ctx.outlen);
+    if (!ctx.salt || !ctx.out) {
+        ret = ARGON2_MEMORY_ALLOCATION_ERROR;
+        goto fail;
+    }
+
+    ctx.pwd = (uint8_t *)pwd;
+    ctx.pwdlen = (uint32_t)pwdlen;
+
+    ret = decode_string(&ctx, encoded, type);
+    if (ret != ARGON2_OK) {
+        goto fail;
+    }
+
+    /* Set aside the desired result, and get a new buffer. */
+    desired_result = ctx.out;
+    ctx.out = malloc(ctx.outlen);
+    if (!ctx.out) {
+        ret = ARGON2_MEMORY_ALLOCATION_ERROR;
+        goto fail;
+    }
+
+    ret = argon2_verify_ctx(&ctx, (char *)desired_result, type);
+    if (ret != ARGON2_OK) {
+        goto fail;
+    }
+
+fail:
+    free(ctx.salt);
+    free(ctx.out);
+    free(desired_result);
+
+    return ret;
+}
+
+int argon2i_verify(const char *encoded, const void *pwd, const size_t pwdlen) {
+
+    return argon2_verify(encoded, pwd, pwdlen, Argon2_i);
+}
+
+int argon2d_verify(const char *encoded, const void *pwd, const size_t pwdlen) {
+
+    return argon2_verify(encoded, pwd, pwdlen, Argon2_d);
+}
+
+int argon2id_verify(const char *encoded, const void *pwd, const size_t pwdlen) {
+
+    return argon2_verify(encoded, pwd, pwdlen, Argon2_id);
+}
+
+int argon2d_ctx(argon2_context *context) {
+    return argon2_ctx(context, Argon2_d);
+}
+
+int argon2i_ctx(argon2_context *context) {
+    return argon2_ctx(context, Argon2_i);
+}
+
+int argon2id_ctx(argon2_context *context) {
+    return argon2_ctx(context, Argon2_id);
+}
+
+int argon2_verify_ctx(argon2_context *context, const char *hash,
+                      argon2_type type) {
+    int ret = argon2_ctx(context, type);
+    if (ret != ARGON2_OK) {
+        return ret;
+    }
+
+    if (argon2_compare((uint8_t *)hash, context->out, context->outlen)) {
+        return ARGON2_VERIFY_MISMATCH;
+    }
+
+    return ARGON2_OK;
+}
+
+int argon2d_verify_ctx(argon2_context *context, const char *hash) {
+    return argon2_verify_ctx(context, hash, Argon2_d);
+}
+
+int argon2i_verify_ctx(argon2_context *context, const char *hash) {
+    return argon2_verify_ctx(context, hash, Argon2_i);
+}
+
+int argon2id_verify_ctx(argon2_context *context, const char *hash) {
+    return argon2_verify_ctx(context, hash, Argon2_id);
+}
+
+const char *argon2_error_message(int error_code) {
+    switch (error_code) {
+    case ARGON2_OK:
+        return "OK";
+    case ARGON2_OUTPUT_PTR_NULL:
+        return "Output pointer is NULL";
+    case ARGON2_OUTPUT_TOO_SHORT:
+        return "Output is too short";
+    case ARGON2_OUTPUT_TOO_LONG:
+        return "Output is too long";
+    case ARGON2_PWD_TOO_SHORT:
+        return "Password is too short";
+    case ARGON2_PWD_TOO_LONG:
+        return "Password is too long";
+    case ARGON2_SALT_TOO_SHORT:
+        return "Salt is too short";
+    case ARGON2_SALT_TOO_LONG:
+        return "Salt is too long";
+    case ARGON2_AD_TOO_SHORT:
+        return "Associated data is too short";
+    case ARGON2_AD_TOO_LONG:
+        return "Associated data is too long";
+    case ARGON2_SECRET_TOO_SHORT:
+        return "Secret is too short";
+    case ARGON2_SECRET_TOO_LONG:
+        return "Secret is too long";
+    case ARGON2_TIME_TOO_SMALL:
+        return "Time cost is too small";
+    case ARGON2_TIME_TOO_LARGE:
+        return "Time cost is too large";
+    case ARGON2_MEMORY_TOO_LITTLE:
+        return "Memory cost is too small";
+    case ARGON2_MEMORY_TOO_MUCH:
+        return "Memory cost is too large";
+    case ARGON2_LANES_TOO_FEW:
+        return "Too few lanes";
+    case ARGON2_LANES_TOO_MANY:
+        return "Too many lanes";
+    case ARGON2_PWD_PTR_MISMATCH:
+        return "Password pointer is NULL, but password length is not 0";
+    case ARGON2_SALT_PTR_MISMATCH:
+        return "Salt pointer is NULL, but salt length is not 0";
+    case ARGON2_SECRET_PTR_MISMATCH:
+        return "Secret pointer is NULL, but secret length is not 0";
+    case ARGON2_AD_PTR_MISMATCH:
+        return "Associated data pointer is NULL, but ad length is not 0";
+    case ARGON2_MEMORY_ALLOCATION_ERROR:
+        return "Memory allocation error";
+    case ARGON2_FREE_MEMORY_CBK_NULL:
+        return "The free memory callback is NULL";
+    case ARGON2_ALLOCATE_MEMORY_CBK_NULL:
+        return "The allocate memory callback is NULL";
+    case ARGON2_INCORRECT_PARAMETER:
+        return "Argon2_Context context is NULL";
+    case ARGON2_INCORRECT_TYPE:
+        return "There is no such version of Argon2";
+    case ARGON2_OUT_PTR_MISMATCH:
+        return "Output pointer mismatch";
+    case ARGON2_THREADS_TOO_FEW:
+        return "Not enough threads";
+    case ARGON2_THREADS_TOO_MANY:
+        return "Too many threads";
+    case ARGON2_MISSING_ARGS:
+        return "Missing arguments";
+    case ARGON2_ENCODING_FAIL:
+        return "Encoding failed";
+    case ARGON2_DECODING_FAIL:
+        return "Decoding failed";
+    case ARGON2_THREAD_FAIL:
+        return "Threading failure";
+    case ARGON2_DECODING_LENGTH_FAIL:
+        return "Some of encoded parameters are too long or too short";
+    case ARGON2_VERIFY_MISMATCH:
+        return "The password does not match the supplied hash";
+    default:
+        return "Unknown error code";
+    }
+}
+/*
+size_t argon2_encodedlen(uint32_t t_cost, uint32_t m_cost, uint32_t parallelism,
+                         uint32_t saltlen, uint32_t hashlen, argon2_type type) {
+  return strlen("$$v=$m=,t=,p=$$") + strlen(argon2_type2string(type, 0)) +
+         numlen(t_cost) + numlen(m_cost) + numlen(parallelism) +
+         b64len(saltlen) + b64len(hashlen) + numlen(ARGON2_VERSION_NUMBER) + 1;
+}
+*/

algo/argon2d/argon2d/argon2.h

@@ -0,0 +1,440 @@
+/*
+ * Argon2 reference source code package - reference C implementations
+ *
+ * Copyright 2015
+ * Daniel Dinu, Dmitry Khovratovich, Jean-Philippe Aumasson, and Samuel Neves
+ *
+ * You may use this work under the terms of a Creative Commons CC0 1.0
+ * License/Waiver or the Apache Public License 2.0, at your option. The terms of
+ * these licenses can be found at:
+ *
+ * - CC0 1.0 Universal : http://creativecommons.org/publicdomain/zero/1.0
+ * - Apache 2.0        : http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * You should have received a copy of both of these licenses along with this
+ * software. If not, they may be obtained at the above URLs.
+ */
+
+#ifndef ARGON2_H
+#define ARGON2_H
+
+#include <stdint.h>
+#include <stddef.h>
+#include <limits.h>
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+/* Symbols visibility control */
+#ifdef A2_VISCTL
+#define ARGON2_PUBLIC __attribute__((visibility("default")))
+#define ARGON2_LOCAL __attribute__ ((visibility ("hidden")))
+#elif _MSC_VER
+#define ARGON2_PUBLIC __declspec(dllexport)
+#define ARGON2_LOCAL
+#else
+#define ARGON2_PUBLIC
+#define ARGON2_LOCAL
+#endif
+
+/*
+ * Argon2 input parameter restrictions
+ */
+
+/* Minimum and maximum number of lanes (degree of parallelism) */
+#define ARGON2_MIN_LANES UINT32_C(1)
+#define ARGON2_MAX_LANES UINT32_C(0xFFFFFF)
+
+/* Minimum and maximum number of threads */
+#define ARGON2_MIN_THREADS UINT32_C(1)
+#define ARGON2_MAX_THREADS UINT32_C(0xFFFFFF)
+
+/* Number of synchronization points between lanes per pass */
+#define ARGON2_SYNC_POINTS UINT32_C(4)
+
+/* Minimum and maximum digest size in bytes */
+#define ARGON2_MIN_OUTLEN UINT32_C(4)
+#define ARGON2_MAX_OUTLEN UINT32_C(0xFFFFFFFF)
+
+/* Minimum and maximum number of memory blocks (each of BLOCK_SIZE bytes) */
+#define ARGON2_MIN_MEMORY (2 * ARGON2_SYNC_POINTS) /* 2 blocks per slice */
+
+#define ARGON2_MIN(a, b) ((a) < (b) ? (a) : (b))
+/* Max memory size is addressing-space/2, topping at 2^32 blocks (4 TB) */
+#define ARGON2_MAX_MEMORY_BITS                                                 \
+    ARGON2_MIN(UINT32_C(32), (sizeof(void *) * CHAR_BIT - 10 - 1))
+#define ARGON2_MAX_MEMORY                                                      \
+    ARGON2_MIN(UINT32_C(0xFFFFFFFF), UINT64_C(1) << ARGON2_MAX_MEMORY_BITS)
+
+/* Minimum and maximum number of passes */
+#define ARGON2_MIN_TIME UINT32_C(1)
+#define ARGON2_MAX_TIME UINT32_C(0xFFFFFFFF)
+
+/* Minimum and maximum password length in bytes */
+#define ARGON2_MIN_PWD_LENGTH UINT32_C(0)
+#define ARGON2_MAX_PWD_LENGTH UINT32_C(0xFFFFFFFF)
+
+/* Minimum and maximum associated data length in bytes */
+#define ARGON2_MIN_AD_LENGTH UINT32_C(0)
+#define ARGON2_MAX_AD_LENGTH UINT32_C(0xFFFFFFFF)
+
+/* Minimum and maximum salt length in bytes */
+#define ARGON2_MIN_SALT_LENGTH UINT32_C(8)
+#define ARGON2_MAX_SALT_LENGTH UINT32_C(0xFFFFFFFF)
+
+/* Minimum and maximum key length in bytes */
+#define ARGON2_MIN_SECRET UINT32_C(0)
+#define ARGON2_MAX_SECRET UINT32_C(0xFFFFFFFF)
+
+/* Flags to determine which fields are securely wiped (default = no wipe). */
+#define ARGON2_DEFAULT_FLAGS UINT32_C(0)
+#define ARGON2_FLAG_CLEAR_PASSWORD (UINT32_C(1) << 0)
+#define ARGON2_FLAG_CLEAR_SECRET (UINT32_C(1) << 1)
+
+/* Global flag to determine if we are wiping internal memory buffers. This flag
+ * is defined in core.c and deafults to 1 (wipe internal memory). */
+extern int FLAG_clear_internal_memory;
+
+/* Error codes */
+typedef enum Argon2_ErrorCodes {
+    ARGON2_OK = 0,
+
+    ARGON2_OUTPUT_PTR_NULL = -1,
+
+    ARGON2_OUTPUT_TOO_SHORT = -2,
+    ARGON2_OUTPUT_TOO_LONG = -3,
+
+    ARGON2_PWD_TOO_SHORT = -4,
+    ARGON2_PWD_TOO_LONG = -5,
+
+    ARGON2_SALT_TOO_SHORT = -6,
+    ARGON2_SALT_TOO_LONG = -7,
+
+    ARGON2_AD_TOO_SHORT = -8,
+    ARGON2_AD_TOO_LONG = -9,
+
+    ARGON2_SECRET_TOO_SHORT = -10,
+    ARGON2_SECRET_TOO_LONG = -11,
+
+    ARGON2_TIME_TOO_SMALL = -12,
+    ARGON2_TIME_TOO_LARGE = -13,
+
+    ARGON2_MEMORY_TOO_LITTLE = -14,
+    ARGON2_MEMORY_TOO_MUCH = -15,
+
+    ARGON2_LANES_TOO_FEW = -16,
+    ARGON2_LANES_TOO_MANY = -17,
+
+    ARGON2_PWD_PTR_MISMATCH = -18,    /* NULL ptr with non-zero length */
+    ARGON2_SALT_PTR_MISMATCH = -19,   /* NULL ptr with non-zero length */
+    ARGON2_SECRET_PTR_MISMATCH = -20, /* NULL ptr with non-zero length */
+    ARGON2_AD_PTR_MISMATCH = -21,     /* NULL ptr with non-zero length */
+
+    ARGON2_MEMORY_ALLOCATION_ERROR = -22,
+
+    ARGON2_FREE_MEMORY_CBK_NULL = -23,
+    ARGON2_ALLOCATE_MEMORY_CBK_NULL = -24,
+
+    ARGON2_INCORRECT_PARAMETER = -25,
+    ARGON2_INCORRECT_TYPE = -26,
+
+    ARGON2_OUT_PTR_MISMATCH = -27,
+
+    ARGON2_THREADS_TOO_FEW = -28,
+    ARGON2_THREADS_TOO_MANY = -29,
+
+    ARGON2_MISSING_ARGS = -30,
+
+    ARGON2_ENCODING_FAIL = -31,
+
+    ARGON2_DECODING_FAIL = -32,
+
+    ARGON2_THREAD_FAIL = -33,
+
+    ARGON2_DECODING_LENGTH_FAIL = -34,
+
+    ARGON2_VERIFY_MISMATCH = -35
+} argon2_error_codes;
+
+/* Memory allocator types --- for external allocation */
+typedef int (*allocate_fptr)(uint8_t **memory, size_t bytes_to_allocate);
+typedef void (*deallocate_fptr)(uint8_t *memory, size_t bytes_to_allocate);
+
+/* Argon2 external data structures */
+
+/*
+ *****
+ * Context: structure to hold Argon2 inputs:
+ *  output array and its length,
+ *  password and its length,
+ *  salt and its length,
+ *  secret and its length,
+ *  associated data and its length,
+ *  number of passes, amount of used memory (in KBytes, can be rounded up a bit)
+ *  number of parallel threads that will be run.
+ * All the parameters above affect the output hash value.
+ * Additionally, two function pointers can be provided to allocate and
+ * deallocate the memory (if NULL, memory will be allocated internally).
+ * Also, three flags indicate whether to erase password, secret as soon as they
+ * are pre-hashed (and thus not needed anymore), and the entire memory
+ *****
+ * Simplest situation: you have output array out[8], password is stored in
+ * pwd[32], salt is stored in salt[16], you do not have keys nor associated
+ * data. You need to spend 1 GB of RAM and you run 5 passes of Argon2d with
+ * 4 parallel lanes.
+ * You want to erase the password, but you're OK with last pass not being
+ * erased. You want to use the default memory allocator.
+ * Then you initialize:
+ Argon2_Context(out,8,pwd,32,salt,16,NULL,0,NULL,0,5,1<<20,4,4,NULL,NULL,true,false,false,false)
+ */
+typedef struct Argon2_Context {
+    uint8_t *out;    /* output array */
+    uint32_t outlen; /* digest length */
+
+    uint8_t *pwd;    /* password array */
+    uint32_t pwdlen; /* password length */
+
+    uint8_t *salt;    /* salt array */
+    uint32_t saltlen; /* salt length */
+
+    uint8_t *secret;    /* key array */
+    uint32_t secretlen; /* key length */
+
+    uint8_t *ad;    /* associated data array */
+    uint32_t adlen; /* associated data length */
+
+    uint32_t t_cost;  /* number of passes */
+    uint32_t m_cost;  /* amount of memory requested (KB) */
+    uint32_t lanes;   /* number of lanes */
+    uint32_t threads; /* maximum number of threads */
+
+    uint32_t version; /* version number */
+
+    allocate_fptr allocate_cbk; /* pointer to memory allocator */
+    deallocate_fptr free_cbk;   /* pointer to memory deallocator */
+
+    uint32_t flags; /* array of bool options */
+} argon2_context;
+
+/* Argon2 primitive type */
+typedef enum Argon2_type {
+  Argon2_d = 0,
+  Argon2_i = 1,
+  Argon2_id = 2
+} argon2_type;
+
+/* Version of the algorithm */
+#define ARGON2_VERSION_10 0x10
+#define ARGON2_VERSION_13 0x13
+
+/*
+ * Function that gives the string representation of an argon2_type.
+ * @param type The argon2_type that we want the string for
+ * @param uppercase Whether the string should have the first letter uppercase
+ * @return NULL if invalid type, otherwise the string representation.
+ */
+ARGON2_PUBLIC const char *argon2_type2string(argon2_type type, int uppercase);
+
+/*
+ * Function that performs memory-hard hashing with certain degree of parallelism
+ * @param  context  Pointer to the Argon2 internal structure
+ * @return Error code if smth is wrong, ARGON2_OK otherwise
+ */
+ARGON2_PUBLIC int argon2_ctx(argon2_context *context, argon2_type type);
+
+/**
+ * Hashes a password with Argon2i, producing an encoded hash
+ * @param t_cost Number of iterations
+ * @param m_cost Sets memory usage to m_cost kibibytes
+ * @param parallelism Number of threads and compute lanes
+ * @param pwd Pointer to password
+ * @param pwdlen Password size in bytes
+ * @param salt Pointer to salt
+ * @param saltlen Salt size in bytes
+ * @param hashlen Desired length of the hash in bytes
+ * @param encoded Buffer where to write the encoded hash
+ * @param encodedlen Size of the buffer (thus max size of the encoded hash)
+ * @pre   Different parallelism levels will give different results
+ * @pre   Returns ARGON2_OK if successful
+ */
+ARGON2_PUBLIC int argon2i_hash_encoded(const uint32_t t_cost,
+                                       const uint32_t m_cost,
+                                       const uint32_t parallelism,
+                                       const void *pwd, const size_t pwdlen,
+                                       const void *salt, const size_t saltlen,
+                                       const size_t hashlen, char *encoded,
+                                       const size_t encodedlen,
+                                       const uint32_t version );
+
+/**
+ * Hashes a password with Argon2i, producing a raw hash at @hash
+ * @param t_cost Number of iterations
+ * @param m_cost Sets memory usage to m_cost kibibytes
+ * @param parallelism Number of threads and compute lanes
+ * @param pwd Pointer to password
+ * @param pwdlen Password size in bytes
+ * @param salt Pointer to salt
+ * @param saltlen Salt size in bytes
+ * @param hash Buffer where to write the raw hash - updated by the function
+ * @param hashlen Desired length of the hash in bytes
+ * @pre   Different parallelism levels will give different results
+ * @pre   Returns ARGON2_OK if successful
+ */
+ARGON2_PUBLIC int argon2i_hash_raw(const uint32_t t_cost, const uint32_t m_cost,
+                                   const uint32_t parallelism, const void *pwd,
+                                   const size_t pwdlen, const void *salt,
+                                   const size_t saltlen, void *hash,
+                                   const size_t hashlen,
+                                   const uint32_t version );
+
+ARGON2_PUBLIC int argon2d_hash_encoded(const uint32_t t_cost,
+                                       const uint32_t m_cost,
+                                       const uint32_t parallelism,
+                                       const void *pwd, const size_t pwdlen,
+                                       const void *salt, const size_t saltlen,
+                                       const size_t hashlen, char *encoded,
+                                       const size_t encodedlen,
+                                       const uint32_t version );
+
+ARGON2_PUBLIC int argon2d_hash_raw(const uint32_t t_cost, const uint32_t m_cost,
+                                   const uint32_t parallelism, const void *pwd,
+                                   const size_t pwdlen, const void *salt,
+                                   const size_t saltlen, void *hash,
+                                   const size_t hashlen,
+                                   const uint32_t version );
+
+ARGON2_PUBLIC int argon2id_hash_encoded(const uint32_t t_cost,
+                                        const uint32_t m_cost,
+                                        const uint32_t parallelism,
+                                        const void *pwd, const size_t pwdlen,
+                                        const void *salt, const size_t saltlen,
+                                        const size_t hashlen, char *encoded,
+                                        const size_t encodedlen,
+                                        const uint32_t version );
+
+ARGON2_PUBLIC int argon2id_hash_raw(const uint32_t t_cost,
+                                    const uint32_t m_cost,
+                                    const uint32_t parallelism, const void *pwd,
+                                    const size_t pwdlen, const void *salt,
+                                    const size_t saltlen, void *hash,
+                                    const size_t hashlen,
+                                    const uint32_t version );
+
+/* generic function underlying the above ones */
+ARGON2_PUBLIC int argon2_hash(const uint32_t t_cost, const uint32_t m_cost,
+                              const uint32_t parallelism, const void *pwd,
+                              const size_t pwdlen, const void *salt,
+                              const size_t saltlen, void *hash,
+                              const size_t hashlen, char *encoded,
+                              const size_t encodedlen, argon2_type type,
+                              const uint32_t version );
+
+/**
+ * Verifies a password against an encoded string
+ * Encoded string is restricted as in validate_inputs()
+ * @param encoded String encoding parameters, salt, hash
+ * @param pwd Pointer to password
+ * @pre   Returns ARGON2_OK if successful
+ */
+ARGON2_PUBLIC int argon2i_verify(const char *encoded, const void *pwd,
+                                 const size_t pwdlen);
+
+ARGON2_PUBLIC int argon2d_verify(const char *encoded, const void *pwd,
+                                 const size_t pwdlen);
+
+ARGON2_PUBLIC int argon2id_verify(const char *encoded, const void *pwd,
+                                  const size_t pwdlen);
+
+/* generic function underlying the above ones */
+ARGON2_PUBLIC int argon2_verify(const char *encoded, const void *pwd,
+                                const size_t pwdlen, argon2_type type);
+
+/**
+ * Argon2d: Version of Argon2 that picks memory blocks depending
+ * on the password and salt. Only for side-channel-free
+ * environment!!
+ *****
+ * @param  context  Pointer to current Argon2 context
+ * @return  Zero if successful, a non zero error code otherwise
+ */
+ARGON2_PUBLIC int argon2d_ctx(argon2_context *context);
+
+/**
+ * Argon2i: Version of Argon2 that picks memory blocks
+ * independent on the password and salt. Good for side-channels,
+ * but worse w.r.t. tradeoff attacks if only one pass is used.
+ *****
+ * @param  context  Pointer to current Argon2 context
+ * @return  Zero if successful, a non zero error code otherwise
+ */
+ARGON2_PUBLIC int argon2i_ctx(argon2_context *context);
+
+/**
+ * Argon2id: Version of Argon2 where the first half-pass over memory is
+ * password-independent, the rest are password-dependent (on the password and
+ * salt). OK against side channels (they reduce to 1/2-pass Argon2i), and
+ * better with w.r.t. tradeoff attacks (similar to Argon2d).
+ *****
+ * @param  context  Pointer to current Argon2 context
+ * @return  Zero if successful, a non zero error code otherwise
+ */
+ARGON2_PUBLIC int argon2id_ctx(argon2_context *context);
+
+/**
+ * Verify if a given password is correct for Argon2d hashing
+ * @param  context  Pointer to current Argon2 context
+ * @param  hash  The password hash to verify. The length of the hash is
+ * specified by the context outlen member
+ * @return  Zero if successful, a non zero error code otherwise
+ */
+ARGON2_PUBLIC int argon2d_verify_ctx(argon2_context *context, const char *hash);
+
+/**
+ * Verify if a given password is correct for Argon2i hashing
+ * @param  context  Pointer to current Argon2 context
+ * @param  hash  The password hash to verify. The length of the hash is
+ * specified by the context outlen member
+ * @return  Zero if successful, a non zero error code otherwise
+ */
+ARGON2_PUBLIC int argon2i_verify_ctx(argon2_context *context, const char *hash);
+
+/**
+ * Verify if a given password is correct for Argon2id hashing
+ * @param  context  Pointer to current Argon2 context
+ * @param  hash  The password hash to verify. The length of the hash is
+ * specified by the context outlen member
+ * @return  Zero if successful, a non zero error code otherwise
+ */
+ARGON2_PUBLIC int argon2id_verify_ctx(argon2_context *context,
+                                      const char *hash);
+
+/* generic function underlying the above ones */
+ARGON2_PUBLIC int argon2_verify_ctx(argon2_context *context, const char *hash,
+                                    argon2_type type);
+
+/**
+ * Get the associated error message for given error code
+ * @return  The error message associated with the given error code
+ */
+ARGON2_PUBLIC const char *argon2_error_message(int error_code);
+
+/**
+ * Returns the encoded hash length for the given input parameters
+ * @param t_cost  Number of iterations
+ * @param m_cost  Memory usage in kibibytes
+ * @param parallelism  Number of threads; used to compute lanes
+ * @param saltlen  Salt size in bytes
+ * @param hashlen  Hash size in bytes
+ * @param type The argon2_type that we want the encoded length for
+ * @return  The encoded hash length in bytes
+ */
+ARGON2_PUBLIC size_t argon2_encodedlen(uint32_t t_cost, uint32_t m_cost,
+                                       uint32_t parallelism, uint32_t saltlen,
+                                       uint32_t hashlen, argon2_type type);
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif

algo/argon2d/argon2d/argon2d_thread.c

@@ -0,0 +1,57 @@
+/*
+ * Argon2 reference source code package - reference C implementations
+ *
+ * Copyright 2015
+ * Daniel Dinu, Dmitry Khovratovich, Jean-Philippe Aumasson, and Samuel Neves
+ *
+ * You may use this work under the terms of a Creative Commons CC0 1.0
+ * License/Waiver or the Apache Public License 2.0, at your option. The terms of
+ * these licenses can be found at:
+ *
+ * - CC0 1.0 Universal : http://creativecommons.org/publicdomain/zero/1.0
+ * - Apache 2.0        : http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * You should have received a copy of both of these licenses along with this
+ * software. If not, they may be obtained at the above URLs.
+ */
+
+#if !defined(ARGON2_NO_THREADS)
+
+#include "argon2d_thread.h"
+#if defined(_WIN32)
+#include <windows.h>
+#endif
+
+int argon2_thread_create(argon2_thread_handle_t *handle,
+                         argon2_thread_func_t func, void *args) {
+    if (NULL == handle || func == NULL) {
+        return -1;
+    }
+#if defined(_WIN32)
+    *handle = _beginthreadex(NULL, 0, func, args, 0, NULL);
+    return *handle != 0 ? 0 : -1;
+#else
+    return pthread_create(handle, NULL, func, args);
+#endif
+}
+
+int argon2_thread_join(argon2_thread_handle_t handle) {
+#if defined(_WIN32)
+    if (WaitForSingleObject((HANDLE)handle, INFINITE) == WAIT_OBJECT_0) {
+        return CloseHandle((HANDLE)handle) != 0 ? 0 : -1;
+    }
+    return -1;
+#else
+    return pthread_join(handle, NULL);
+#endif
+}
+
+void argon2_thread_exit(void) {
+#if defined(_WIN32)
+    _endthreadex(0);
+#else
+    pthread_exit(NULL);
+#endif
+}
+
+#endif /* ARGON2_NO_THREADS */

algo/argon2d/argon2d/argon2d_thread.h

@@ -0,0 +1,67 @@
+/*
+ * Argon2 reference source code package - reference C implementations
+ *
+ * Copyright 2015
+ * Daniel Dinu, Dmitry Khovratovich, Jean-Philippe Aumasson, and Samuel Neves
+ *
+ * You may use this work under the terms of a Creative Commons CC0 1.0
+ * License/Waiver or the Apache Public License 2.0, at your option. The terms of
+ * these licenses can be found at:
+ *
+ * - CC0 1.0 Universal : http://creativecommons.org/publicdomain/zero/1.0
+ * - Apache 2.0        : http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * You should have received a copy of both of these licenses along with this
+ * software. If not, they may be obtained at the above URLs.
+ */
+
+#ifndef ARGON2_THREAD_H
+#define ARGON2_THREAD_H
+
+#if !defined(ARGON2_NO_THREADS)
+
+/*
+        Here we implement an abstraction layer for the simpĺe requirements
+        of the Argon2 code. We only require 3 primitives---thread creation,
+        joining, and termination---so full emulation of the pthreads API
+        is unwarranted. Currently we wrap pthreads and Win32 threads.
+
+        The API defines 2 types: the function pointer type,
+   argon2_thread_func_t,
+        and the type of the thread handle---argon2_thread_handle_t.
+*/
+#if defined(_WIN32)
+#include <process.h>
+typedef unsigned(__stdcall *argon2_thread_func_t)(void *);
+typedef uintptr_t argon2_thread_handle_t;
+#else
+#include <pthread.h>
+typedef void *(*argon2_thread_func_t)(void *);
+typedef pthread_t argon2_thread_handle_t;
+#endif
+
+/* Creates a thread
+ * @param handle pointer to a thread handle, which is the output of this
+ * function. Must not be NULL.
+ * @param func A function pointer for the thread's entry point. Must not be
+ * NULL.
+ * @param args Pointer that is passed as an argument to @func. May be NULL.
+ * @return 0 if @handle and @func are valid pointers and a thread is successfully
+ * created.
+ */
+int argon2_thread_create(argon2_thread_handle_t *handle,
+                         argon2_thread_func_t func, void *args);
+
+/* Waits for a thread to terminate
+ * @param handle Handle to a thread created with argon2_thread_create.
+ * @return 0 if @handle is a valid handle, and joining completed successfully.
+*/
+int argon2_thread_join(argon2_thread_handle_t handle);
+
+/* Terminate the current thread. Must be run inside a thread created by
+ * argon2_thread_create.
+*/
+void argon2_thread_exit(void);
+
+#endif /* ARGON2_NO_THREADS */
+#endif

algo/argon2d/argon2d/core.c

@@ -0,0 +1,638 @@
+/*
+ * Argon2 reference source code package - reference C implementations
+ *
+ * Copyright 2015
+ * Daniel Dinu, Dmitry Khovratovich, Jean-Philippe Aumasson, and Samuel Neves
+ *
+ * You may use this work under the terms of a Creative Commons CC0 1.0
+ * License/Waiver or the Apache Public License 2.0, at your option. The terms of
+ * these licenses can be found at:
+ *
+ * - CC0 1.0 Universal : http://creativecommons.org/publicdomain/zero/1.0
+ * - Apache 2.0        : http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * You should have received a copy of both of these licenses along with this
+ * software. If not, they may be obtained at the above URLs.
+ */
+
+/*For memory wiping*/
+#ifdef _MSC_VER
+#include <windows.h>
+#include <winbase.h> /* For SecureZeroMemory */
+#endif
+#if defined __STDC_LIB_EXT1__
+#define __STDC_WANT_LIB_EXT1__ 1
+#endif
+#define VC_GE_2005(version) (version >= 1400)
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+//#include <mm_malloc.h>
+
+#include "core.h"
+#include "argon2d_thread.h"
+#include "../blake2/blake2.h"
+#include "../blake2/blake2-impl.h"
+
+#ifdef GENKAT
+#include "genkat.h"
+#endif
+
+#if defined(__clang__)
+#if __has_attribute(optnone)
+#define NOT_OPTIMIZED __attribute__((optnone))
+#endif
+#elif defined(__GNUC__)
+#define GCC_VERSION                                                            \
+    (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
+#if GCC_VERSION >= 40400
+#define NOT_OPTIMIZED __attribute__((optimize("O0")))
+#endif
+#endif
+#ifndef NOT_OPTIMIZED
+#define NOT_OPTIMIZED
+#endif
+
+/***************Instance and Position constructors**********/
+void init_block_value(block *b, uint8_t in) { memset(b->v, in, sizeof(b->v)); }
+
+void copy_block(block *dst, const block *src) {
+    memcpy(dst->v, src->v, sizeof(uint64_t) * ARGON2_QWORDS_IN_BLOCK);
+}
+
+void xor_block(block *dst, const block *src) {
+    int i;
+    for (i = 0; i < ARGON2_QWORDS_IN_BLOCK; ++i) {
+        dst->v[i] ^= src->v[i];
+    }
+}
+
+static void load_block(block *dst, const void *input) {
+    unsigned i;
+    for (i = 0; i < ARGON2_QWORDS_IN_BLOCK; ++i) {
+        dst->v[i] = load64((const uint8_t *)input + i * sizeof(dst->v[i]));
+    }
+}
+
+static void store_block(void *output, const block *src) {
+    unsigned i;
+    for (i = 0; i < ARGON2_QWORDS_IN_BLOCK; ++i) {
+        store64((uint8_t *)output + i * sizeof(src->v[i]), src->v[i]);
+    }
+}
+
+/***************Memory functions*****************/
+
+int allocate_memory(const argon2_context *context, uint8_t **memory,
+                    size_t num, size_t size) {
+    size_t memory_size = num*size;
+    if (memory == NULL) {
+        return ARGON2_MEMORY_ALLOCATION_ERROR;
+    }
+
+    /* 1. Check for multiplication overflow */
+    if (size != 0 && memory_size / size != num) {
+        return ARGON2_MEMORY_ALLOCATION_ERROR;
+    }
+
+    /* 2. Try to allocate with appropriate allocator */
+    if (context->allocate_cbk) {
+        (context->allocate_cbk)(memory, memory_size);
+    } else {
+        *memory = mm_malloc( memory_size, 64 );
+//        *memory = malloc(memory_size);
+    }
+
+    if (*memory == NULL) {
+        return ARGON2_MEMORY_ALLOCATION_ERROR;
+    }
+
+    return ARGON2_OK;
+}
+
+void free_memory(const argon2_context *context, uint8_t *memory,
+                 size_t num, size_t size) {
+    size_t memory_size = num*size;
+//    clear_internal_memory(memory, memory_size);
+    if (context->free_cbk) {
+        (context->free_cbk)(memory, memory_size);
+    } else {
+//        free(memory);
+        mm_free( memory );
+    }
+}
+
+void NOT_OPTIMIZED secure_wipe_memory(void *v, size_t n) {
+#if defined(_MSC_VER) && VC_GE_2005(_MSC_VER)
+    SecureZeroMemory(v, n);
+#elif defined memset_s
+    memset_s(v, n, 0, n);
+#elif defined(__OpenBSD__)
+    explicit_bzero(v, n);
+#else
+    static void *(*const volatile memset_sec)(void *, int, size_t) = &memset;
+    memset_sec(v, 0, n);
+#endif
+}
+
+/* Memory clear flag defaults to true. */
+int FLAG_clear_internal_memory = 0;
+void clear_internal_memory(void *v, size_t n) {
+  if (FLAG_clear_internal_memory && v) {
+//    secure_wipe_memory(v, n);
+  }
+}
+
+void finalize(const argon2_context *context, argon2_instance_t *instance) {
+    if (context != NULL && instance != NULL) {
+        block blockhash;
+        uint32_t l;
+
+        copy_block(&blockhash, instance->memory + instance->lane_length - 1);
+
+        /* XOR the last blocks */
+        for (l = 1; l < instance->lanes; ++l) {
+            uint32_t last_block_in_lane =
+                l * instance->lane_length + (instance->lane_length - 1);
+            xor_block(&blockhash, instance->memory + last_block_in_lane);
+        }
+
+        /* Hash the result */
+        {
+            uint8_t blockhash_bytes[ARGON2_BLOCK_SIZE];
+            store_block(blockhash_bytes, &blockhash);
+            blake2b_long(context->out, context->outlen, blockhash_bytes,
+                         ARGON2_BLOCK_SIZE);
+            /* clear blockhash and blockhash_bytes */
+            clear_internal_memory(blockhash.v, ARGON2_BLOCK_SIZE);
+            clear_internal_memory(blockhash_bytes, ARGON2_BLOCK_SIZE);
+        }
+
+#ifdef GENKAT
+        print_tag(context->out, context->outlen);
+#endif
+
+        free_memory(context, (uint8_t *)instance->memory,
+                    instance->memory_blocks, sizeof(block));
+    }
+}
+
+uint32_t index_alpha(const argon2_instance_t *instance,
+                     const argon2_position_t *position, uint32_t pseudo_rand,
+                     int same_lane) {
+    /*
+     * Pass 0:
+     *      This lane : all already finished segments plus already constructed
+     * blocks in this segment
+     *      Other lanes : all already finished segments
+     * Pass 1+:
+     *      This lane : (SYNC_POINTS - 1) last segments plus already constructed
+     * blocks in this segment
+     *      Other lanes : (SYNC_POINTS - 1) last segments
+     */
+    uint32_t reference_area_size;
+    uint64_t relative_position;
+    uint32_t start_position, absolute_position;
+
+    if (0 == position->pass) {
+        /* First pass */
+        if (0 == position->slice) {
+            /* First slice */
+            reference_area_size =
+                position->index - 1; /* all but the previous */
+        } else {
+            if (same_lane) {
+                /* The same lane => add current segment */
+                reference_area_size =
+                    position->slice * instance->segment_length +
+                    position->index - 1;
+            } else {
+                reference_area_size =
+                    position->slice * instance->segment_length +
+                    ((position->index == 0) ? (-1) : 0);
+            }
+        }
+    } else {
+        /* Second pass */
+        if (same_lane) {
+            reference_area_size = instance->lane_length -
+                                  instance->segment_length + position->index -
+                                  1;
+        } else {
+            reference_area_size = instance->lane_length -
+                                  instance->segment_length +
+                                  ((position->index == 0) ? (-1) : 0);
+        }
+    }
+
+    /* 1.2.4. Mapping pseudo_rand to 0..<reference_area_size-1> and produce
+     * relative position */
+    relative_position = pseudo_rand;
+    relative_position = relative_position * relative_position >> 32;
+    relative_position = reference_area_size - 1 -
+                        (reference_area_size * relative_position >> 32);
+
+    /* 1.2.5 Computing starting position */
+    start_position = 0;
+
+    if (0 != position->pass) {
+        start_position = (position->slice == ARGON2_SYNC_POINTS - 1)
+                             ? 0
+                             : (position->slice + 1) * instance->segment_length;
+    }
+
+    /* 1.2.6. Computing absolute position */
+    absolute_position = (start_position + relative_position) %
+                        instance->lane_length; /* absolute position */
+    return absolute_position;
+}
+
+/* Single-threaded version for p=1 case */
+static int fill_memory_blocks_st(argon2_instance_t *instance) {
+    uint32_t r, s, l;
+
+    for (r = 0; r < instance->passes; ++r) {
+        for (s = 0; s < ARGON2_SYNC_POINTS; ++s) {
+            for (l = 0; l < instance->lanes; ++l) {
+                argon2_position_t position = {r, l, (uint8_t)s, 0};
+                fill_segment(instance, position);
+            }
+        }
+#ifdef GENKAT
+        internal_kat(instance, r); /* Print all memory blocks */
+#endif
+    }
+    return ARGON2_OK;
+}
+
+#if !defined(ARGON2_NO_THREADS)
+
+#ifdef _WIN32
+static unsigned __stdcall fill_segment_thr(void *thread_data)
+#else
+static void *fill_segment_thr(void *thread_data)
+#endif
+{
+    argon2_thread_data *my_data = thread_data;
+    fill_segment(my_data->instance_ptr, my_data->pos);
+    argon2_thread_exit();
+    return 0;
+}
+
+/* Multi-threaded version for p > 1 case */
+static int fill_memory_blocks_mt(argon2_instance_t *instance) {
+    uint32_t r, s;
+    argon2_thread_handle_t *thread = NULL;
+    argon2_thread_data *thr_data = NULL;
+    int rc = ARGON2_OK;
+
+    /* 1. Allocating space for threads */
+    thread = calloc(instance->lanes, sizeof(argon2_thread_handle_t));
+    if (thread == NULL) {
+        rc = ARGON2_MEMORY_ALLOCATION_ERROR;
+        goto fail;
+    }
+
+    thr_data = calloc(instance->lanes, sizeof(argon2_thread_data));
+    if (thr_data == NULL) {
+        rc = ARGON2_MEMORY_ALLOCATION_ERROR;
+        goto fail;
+    }
+
+    for (r = 0; r < instance->passes; ++r) {
+        for (s = 0; s < ARGON2_SYNC_POINTS; ++s) {
+            uint32_t l;
+
+            /* 2. Calling threads */
+            for (l = 0; l < instance->lanes; ++l) {
+                argon2_position_t position;
+
+                /* 2.1 Join a thread if limit is exceeded */
+                if (l >= instance->threads) {
+                    if (argon2_thread_join(thread[l - instance->threads])) {
+                        rc = ARGON2_THREAD_FAIL;
+                        goto fail;
+                    }
+                }
+
+                /* 2.2 Create thread */
+                position.pass = r;
+                position.lane = l;
+                position.slice = (uint8_t)s;
+                position.index = 0;
+                thr_data[l].instance_ptr =
+                    instance; /* preparing the thread input */
+                memcpy(&(thr_data[l].pos), &position,
+                       sizeof(argon2_position_t));
+                if (argon2_thread_create(&thread[l], &fill_segment_thr,
+                                         (void *)&thr_data[l])) {
+                    rc = ARGON2_THREAD_FAIL;
+                    goto fail;
+                }
+
+                /* fill_segment(instance, position); */
+                /*Non-thread equivalent of the lines above */
+            }
+
+            /* 3. Joining remaining threads */
+            for (l = instance->lanes - instance->threads; l < instance->lanes;
+                 ++l) {
+                if (argon2_thread_join(thread[l])) {
+                    rc = ARGON2_THREAD_FAIL;
+                    goto fail;
+                }
+            }
+        }
+
+#ifdef GENKAT
+        internal_kat(instance, r); /* Print all memory blocks */
+#endif
+    }
+
+fail:
+    if (thread != NULL) {
+        free(thread);
+    }
+    if (thr_data != NULL) {
+        free(thr_data);
+    }
+    return rc;
+}
+
+#endif /* ARGON2_NO_THREADS */
+
+int fill_memory_blocks(argon2_instance_t *instance) {
+	if (instance == NULL || instance->lanes == 0) {
+	    return ARGON2_INCORRECT_PARAMETER;
+    }
+#if defined(ARGON2_NO_THREADS)
+    return fill_memory_blocks_st(instance);
+#else
+    return instance->threads == 1 ?
+			fill_memory_blocks_st(instance) : fill_memory_blocks_mt(instance);
+#endif
+}
+
+int validate_inputs(const argon2_context *context) {
+    if (NULL == context) {
+        return ARGON2_INCORRECT_PARAMETER;
+    }
+
+    if (NULL == context->out) {
+        return ARGON2_OUTPUT_PTR_NULL;
+    }
+
+    /* Validate output length */
+    if (ARGON2_MIN_OUTLEN > context->outlen) {
+        return ARGON2_OUTPUT_TOO_SHORT;
+    }
+
+    if (ARGON2_MAX_OUTLEN < context->outlen) {
+        return ARGON2_OUTPUT_TOO_LONG;
+    }
+
+    /* Validate password (required param) */
+    if (NULL == context->pwd) {
+        if (0 != context->pwdlen) {
+            return ARGON2_PWD_PTR_MISMATCH;
+        }
+    }
+
+    if (ARGON2_MIN_PWD_LENGTH > context->pwdlen) {
+      return ARGON2_PWD_TOO_SHORT;
+    }
+
+    if (ARGON2_MAX_PWD_LENGTH < context->pwdlen) {
+        return ARGON2_PWD_TOO_LONG;
+    }
+
+    /* Validate salt (required param) */
+    if (NULL == context->salt) {
+        if (0 != context->saltlen) {
+            return ARGON2_SALT_PTR_MISMATCH;
+        }
+    }
+
+    if (ARGON2_MIN_SALT_LENGTH > context->saltlen) {
+        return ARGON2_SALT_TOO_SHORT;
+    }
+
+    if (ARGON2_MAX_SALT_LENGTH < context->saltlen) {
+        return ARGON2_SALT_TOO_LONG;
+    }
+
+    /* Validate secret (optional param) */
+    if (NULL == context->secret) {
+        if (0 != context->secretlen) {
+            return ARGON2_SECRET_PTR_MISMATCH;
+        }
+    } else {
+        if (ARGON2_MIN_SECRET > context->secretlen) {
+            return ARGON2_SECRET_TOO_SHORT;
+        }
+        if (ARGON2_MAX_SECRET < context->secretlen) {
+            return ARGON2_SECRET_TOO_LONG;
+        }
+    }
+
+    /* Validate associated data (optional param) */
+    if (NULL == context->ad) {
+        if (0 != context->adlen) {
+            return ARGON2_AD_PTR_MISMATCH;
+        }
+    } else {
+        if (ARGON2_MIN_AD_LENGTH > context->adlen) {
+            return ARGON2_AD_TOO_SHORT;
+        }
+        if (ARGON2_MAX_AD_LENGTH < context->adlen) {
+            return ARGON2_AD_TOO_LONG;
+        }
+    }
+
+    /* Validate memory cost */
+    if (ARGON2_MIN_MEMORY > context->m_cost) {
+        return ARGON2_MEMORY_TOO_LITTLE;
+    }
+
+    if (ARGON2_MAX_MEMORY < context->m_cost) {
+        return ARGON2_MEMORY_TOO_MUCH;
+    }
+
+    if (context->m_cost < 8 * context->lanes) {
+        return ARGON2_MEMORY_TOO_LITTLE;
+    }
+
+    /* Validate time cost */
+    if (ARGON2_MIN_TIME > context->t_cost) {
+        return ARGON2_TIME_TOO_SMALL;
+    }
+
+    if (ARGON2_MAX_TIME < context->t_cost) {
+        return ARGON2_TIME_TOO_LARGE;
+    }
+
+    /* Validate lanes */
+    if (ARGON2_MIN_LANES > context->lanes) {
+        return ARGON2_LANES_TOO_FEW;
+    }
+
+    if (ARGON2_MAX_LANES < context->lanes) {
+        return ARGON2_LANES_TOO_MANY;
+    }
+
+    /* Validate threads */
+    if (ARGON2_MIN_THREADS > context->threads) {
+        return ARGON2_THREADS_TOO_FEW;
+    }
+
+    if (ARGON2_MAX_THREADS < context->threads) {
+        return ARGON2_THREADS_TOO_MANY;
+    }
+
+    if (NULL != context->allocate_cbk && NULL == context->free_cbk) {
+        return ARGON2_FREE_MEMORY_CBK_NULL;
+    }
+
+    if (NULL == context->allocate_cbk && NULL != context->free_cbk) {
+        return ARGON2_ALLOCATE_MEMORY_CBK_NULL;
+    }
+
+    return ARGON2_OK;
+}
+
+void fill_first_blocks(uint8_t *blockhash, const argon2_instance_t *instance) {
+    uint32_t l;
+    /* Make the first and second block in each lane as G(H0||0||i) or
+       G(H0||1||i) */
+    uint8_t blockhash_bytes[ARGON2_BLOCK_SIZE];
+    for (l = 0; l < instance->lanes; ++l) {
+
+        store32(blockhash + ARGON2_PREHASH_DIGEST_LENGTH, 0);
+        store32(blockhash + ARGON2_PREHASH_DIGEST_LENGTH + 4, l);
+        blake2b_long(blockhash_bytes, ARGON2_BLOCK_SIZE, blockhash,
+                     ARGON2_PREHASH_SEED_LENGTH);
+        load_block(&instance->memory[l * instance->lane_length + 0],
+                   blockhash_bytes);
+
+        store32(blockhash + ARGON2_PREHASH_DIGEST_LENGTH, 1);
+        blake2b_long(blockhash_bytes, ARGON2_BLOCK_SIZE, blockhash,
+                     ARGON2_PREHASH_SEED_LENGTH);
+        load_block(&instance->memory[l * instance->lane_length + 1],
+                   blockhash_bytes);
+    }
+    clear_internal_memory(blockhash_bytes, ARGON2_BLOCK_SIZE);
+}
+
+void initial_hash(uint8_t *blockhash, argon2_context *context,
+                  argon2_type type) {
+    blake2b_state BlakeHash;
+    uint8_t value[sizeof(uint32_t)];
+
+    if (NULL == context || NULL == blockhash) {
+        return;
+    }
+
+    blake2b_init(&BlakeHash, ARGON2_PREHASH_DIGEST_LENGTH);
+
+    store32(&value, context->lanes);
+    blake2b_update(&BlakeHash, (const uint8_t *)&value, sizeof(value));
+
+    store32(&value, context->outlen);
+    blake2b_update(&BlakeHash, (const uint8_t *)&value, sizeof(value));
+
+    store32(&value, context->m_cost);
+    blake2b_update(&BlakeHash, (const uint8_t *)&value, sizeof(value));
+
+    store32(&value, context->t_cost);
+    blake2b_update(&BlakeHash, (const uint8_t *)&value, sizeof(value));
+
+//    store32(&value, ARGON2_VERSION_NUMBER);
+    store32(&value, context->version);
+    blake2b_update(&BlakeHash, (const uint8_t *)&value, sizeof(value));
+
+    store32(&value, (uint32_t)type);
+    blake2b_update(&BlakeHash, (const uint8_t *)&value, sizeof(value));
+
+    store32(&value, context->pwdlen);
+    blake2b_update(&BlakeHash, (const uint8_t *)&value, sizeof(value));
+
+    if (context->pwd != NULL) {
+        blake2b_update(&BlakeHash, (const uint8_t *)context->pwd,
+                       context->pwdlen);
+
+        if (context->flags & ARGON2_FLAG_CLEAR_PASSWORD) {
+//            secure_wipe_memory(context->pwd, context->pwdlen);
+            context->pwdlen = 0;
+        }
+    }
+
+    store32(&value, context->saltlen);
+    blake2b_update(&BlakeHash, (const uint8_t *)&value, sizeof(value));
+
+    if (context->salt != NULL) {
+        blake2b_update(&BlakeHash, (const uint8_t *)context->salt,
+                       context->saltlen);
+    }
+
+    store32(&value, context->secretlen);
+    blake2b_update(&BlakeHash, (const uint8_t *)&value, sizeof(value));
+
+    if (context->secret != NULL) {
+        blake2b_update(&BlakeHash, (const uint8_t *)context->secret,
+                       context->secretlen);
+
+        if (context->flags & ARGON2_FLAG_CLEAR_SECRET) {
+//            secure_wipe_memory(context->secret, context->secretlen);
+            context->secretlen = 0;
+        }
+    }
+
+    store32(&value, context->adlen);
+    blake2b_update(&BlakeHash, (const uint8_t *)&value, sizeof(value));
+
+    if (context->ad != NULL) {
+        blake2b_update(&BlakeHash, (const uint8_t *)context->ad,
+                       context->adlen);
+    }
+
+    blake2b_final(&BlakeHash, blockhash, ARGON2_PREHASH_DIGEST_LENGTH);
+}
+
+int initialize(argon2_instance_t *instance, argon2_context *context) {
+    uint8_t blockhash[ARGON2_PREHASH_SEED_LENGTH];
+    int result = ARGON2_OK;
+
+    if (instance == NULL || context == NULL)
+        return ARGON2_INCORRECT_PARAMETER;
+    instance->context_ptr = context;
+
+    /* 1. Memory allocation */
+    result = allocate_memory(context, (uint8_t **)&(instance->memory),
+                             instance->memory_blocks, sizeof(block));
+    if (result != ARGON2_OK) {
+        return result;
+    }
+
+    /* 2. Initial hashing */
+    /* H_0 + 8 extra bytes to produce the first blocks */
+    /* uint8_t blockhash[ARGON2_PREHASH_SEED_LENGTH]; */
+    /* Hashing all inputs */
+    initial_hash(blockhash, context, instance->type);
+    /* Zeroing 8 extra bytes */
+    clear_internal_memory(blockhash + ARGON2_PREHASH_DIGEST_LENGTH,
+                          ARGON2_PREHASH_SEED_LENGTH -
+                              ARGON2_PREHASH_DIGEST_LENGTH);
+
+#ifdef GENKAT
+    initial_kat(blockhash, context, instance->type);
+#endif
+
+    /* 3. Creating first blocks, we always have at least two blocks in a slice
+     */
+    fill_first_blocks(blockhash, instance);
+    /* Clearing the hash */
+    clear_internal_memory(blockhash, ARGON2_PREHASH_SEED_LENGTH);
+
+    return ARGON2_OK;
+}

algo/argon2d/argon2d/core.h

@@ -1,40 +1,37 @@
 /*
- * Argon2 source code package
+ * Argon2 reference source code package - reference C implementations
  *
- * Written by Daniel Dinu and Dmitry Khovratovich, 2015
+ * Copyright 2015
+ * Daniel Dinu, Dmitry Khovratovich, Jean-Philippe Aumasson, and Samuel Neves
  *
- * This work is licensed under a Creative Commons CC0 1.0 License/Waiver.
+ * You may use this work under the terms of a Creative Commons CC0 1.0
+ * License/Waiver or the Apache Public License 2.0, at your option. The terms of
+ * these licenses can be found at:
  *
- * 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/>.
+ * - CC0 1.0 Universal : http://creativecommons.org/publicdomain/zero/1.0
+ * - Apache 2.0        : http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * You should have received a copy of both of these licenses along with this
+ * software. If not, they may be obtained at the above URLs.
  */
 
-#ifndef ARGON2_CORES_H
-#define ARGON2_CORES_H
+#ifndef ARGON2_CORE_H
+#define ARGON2_CORE_H
 
-#if defined(_MSC_VER)
-#include <Windows.h>
-#include <process.h>
-#define ALIGN(n) __declspec(align(n))
-#elif defined(__GNUC__) || defined(__clang)
-#define ALIGN(x) __attribute__((__aligned__(x)))
-#else
-#define ALIGN(x)
-#endif
+#include "miner.h"
+#include "argon2.h"
 
-/*************************Argon2 internal
- * constants**************************************************/
+#define CONST_CAST(x) (x)(uintptr_t)
+
+/**********************Argon2 internal constants*******************************/
 
 enum argon2_core_constants {
-    /* Version of the algorithm */
-    ARGON2_VERSION_NUMBER = 0x10,
-
     /* Memory block size in bytes */
     ARGON2_BLOCK_SIZE = 1024,
-    ARGON2_WORDS_IN_BLOCK = ARGON2_BLOCK_SIZE / 8,
-    ARGON2_QWORDS_IN_BLOCK = 64,
+    ARGON2_QWORDS_IN_BLOCK = ARGON2_BLOCK_SIZE / 8,
+    ARGON2_OWORDS_IN_BLOCK = ARGON2_BLOCK_SIZE / 16,
+    ARGON2_HWORDS_IN_BLOCK = ARGON2_BLOCK_SIZE / 32,
+    ARGON2_512BIT_WORDS_IN_BLOCK = ARGON2_BLOCK_SIZE / 64,
 
     /* Number of pseudo-random values generated by one call to Blake in Argon2i
        to
@@ -46,18 +43,14 @@ enum argon2_core_constants {
     ARGON2_PREHASH_SEED_LENGTH = 72
 };
 
-/* Argon2 primitive type */
-typedef enum Argon2_type { Argon2_d = 0, Argon2_i = 1 } argon2_type;
-
-/*************************Argon2 internal data
- * types**************************************************/
+/*************************Argon2 internal data types***********************/
 
 /*
  * Structure for the (1KB) memory block implemented as 128 64-bit words.
  * Memory blocks can be copied, XORed. Internal words can be accessed by [] (no
  * bounds checking).
  */
-typedef struct _block { uint64_t v[ARGON2_WORDS_IN_BLOCK]; } ALIGN(16) block;
+typedef struct block_ { uint64_t v[ARGON2_QWORDS_IN_BLOCK]; } block;
 
 /*****************Functions that work with the block******************/
 
@@ -78,8 +71,16 @@ void xor_block(block *dst, const block *src);
  */
 typedef struct Argon2_instance_t {
     block *memory;          /* Memory pointer */
+    uint32_t version;
+    uint32_t passes;        /* Number of passes */
+    uint32_t memory_blocks; /* Number of blocks in memory */
+    uint32_t segment_length;
+    uint32_t lane_length;
+    uint32_t lanes;
+    uint32_t threads;
     argon2_type type;
     int print_internals; /* whether to print the memory blocks */
+    argon2_context *context_ptr; /* points back to original context */
 } argon2_instance_t;
 
 /*
@@ -93,32 +94,49 @@ typedef struct Argon2_position_t {
     uint32_t index;
 } argon2_position_t;
 
-/*************************Argon2 core
- * functions**************************************************/
+/*Struct that holds the inputs for thread handling FillSegment*/
+typedef struct Argon2_thread_data {
+    argon2_instance_t *instance_ptr;
+    argon2_position_t pos;
+} argon2_thread_data;
 
-/* Allocates memory to the given pointer
+/*************************Argon2 core functions********************************/
+
+/* Allocates memory to the given pointer, uses the appropriate allocator as
+ * specified in the context. Total allocated memory is num*size.
+ * @param context argon2_context which specifies the allocator
  * @param memory pointer to the pointer to the memory
- * @param m_cost number of blocks to allocate in the memory
+ * @param size the size in bytes for each element to be allocated
+ * @param num the number of elements to be allocated
  * @return ARGON2_OK if @memory is a valid pointer and memory is allocated
  */
-int allocate_memory(block **memory, uint32_t m_cost);
+int allocate_memory(const argon2_context *context, uint8_t **memory,
+                    size_t num, size_t size);
 
-/* Function that securely cleans the memory
+/*
+ * Frees memory at the given pointer, uses the appropriate deallocator as
+ * specified in the context. Also cleans the memory using clear_internal_memory.
+ * @param context argon2_context which specifies the deallocator
+ * @param memory pointer to buffer to be freed
+ * @param size the size in bytes for each element to be deallocated
+ * @param num the number of elements to be deallocated
+ */
+void free_memory(const argon2_context *context, uint8_t *memory,
+                 size_t num, size_t size);
+
+/* Function that securely cleans the memory. This ignores any flags set
+ * regarding clearing memory. Usually one just calls clear_internal_memory.
  * @param mem Pointer to the memory
  * @param s Memory size in bytes
  */
 void secure_wipe_memory(void *v, size_t n);
 
-/* Clears memory
- * @param instance pointer to the current instance
- * @param clear_memory indicates if we clear the memory with zeros.
+/* Function that securely clears the memory if FLAG_clear_internal_memory is
+ * set. If the flag isn't set, this function does nothing.
+ * @param mem Pointer to the memory
+ * @param s Memory size in bytes
  */
-void clear_memory(argon2_instance_t *instance, int clear);
-
-/* Deallocates memory
- * @param memory pointer to the blocks
- */
-void free_memory(block *memory);
+void clear_internal_memory(void *v, size_t n);
 
 /*
  * Computes absolute position of reference block in the lane following a skewed
@@ -162,7 +180,7 @@ void initial_hash(uint8_t *blockhash, argon2_context *context,
  * @param blockhash Pointer to the pre-hashing digest
  * @pre blockhash must point to @a PREHASH_SEED_LENGTH allocated values
  */
-void fill_firsts_blocks(uint8_t *blockhash, const argon2_instance_t *instance);
+void fill_first_blocks(uint8_t *blockhash, const argon2_instance_t *instance);
 
 /*
  * Function allocates memory, hashes the inputs with Blake,  and creates first
@@ -192,6 +210,7 @@ void finalize(const argon2_context *context, argon2_instance_t *instance);
 /*
  * Function that fills the segment using previous segments also from other
  * threads
+ * @param context current context
  * @param instance Pointer to the current instance
  * @param position Current position
  * @pre all block pointers must be valid
@@ -203,14 +222,8 @@ void fill_segment(const argon2_instance_t *instance,
  * Function that fills the entire memory t_cost times based on the first two
  * blocks in each lane
  * @param instance Pointer to the current instance
+ * @return ARGON2_OK if successful, @context->state
  */
-void fill_memory_blocks(argon2_instance_t *instance);
-
-/*
- * Function that performs memory-hard hashing with certain degree of parallelism
- * @param  context  Pointer to the Argon2 internal structure
- * @return Error code if smth is wrong, ARGON2_OK otherwise
- */
-int argon2_core(argon2_context *context, argon2_type type);
+int fill_memory_blocks(argon2_instance_t *instance);
 
 #endif

algo/argon2d/argon2d/encoding.c

@@ -0,0 +1,463 @@
+/*
+ * Argon2 reference source code package - reference C implementations
+ *
+ * Copyright 2015
+ * Daniel Dinu, Dmitry Khovratovich, Jean-Philippe Aumasson, and Samuel Neves
+ *
+ * You may use this work under the terms of a Creative Commons CC0 1.0
+ * License/Waiver or the Apache Public License 2.0, at your option. The terms of
+ * these licenses can be found at:
+ *
+ * - CC0 1.0 Universal : http://creativecommons.org/publicdomain/zero/1.0
+ * - Apache 2.0        : http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * You should have received a copy of both of these licenses along with this
+ * software. If not, they may be obtained at the above URLs.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+#include "encoding.h"
+#include "core.h"
+
+/*
+ * Example code for a decoder and encoder of "hash strings", with Argon2
+ * parameters.
+ *
+ * This code comprises three sections:
+ *
+ *   -- The first section contains generic Base64 encoding and decoding
+ *   functions. It is conceptually applicable to any hash function
+ *   implementation that uses Base64 to encode and decode parameters,
+ *   salts and outputs. It could be made into a library, provided that
+ *   the relevant functions are made public (non-static) and be given
+ *   reasonable names to avoid collisions with other functions.
+ *
+ *   -- The second section is specific to Argon2. It encodes and decodes
+ *   the parameters, salts and outputs. It does not compute the hash
+ *   itself.
+ *
+ * The code was originally written by Thomas Pornin <pornin@bolet.org>,
+ * to whom comments and remarks may be sent. It is released under what
+ * should amount to Public Domain or its closest equivalent; the
+ * following mantra is supposed to incarnate that fact with all the
+ * proper legal rituals:
+ *
+ * ---------------------------------------------------------------------
+ * This file is provided under the terms of Creative Commons CC0 1.0
+ * Public Domain Dedication. To the extent possible under law, the
+ * author (Thomas Pornin) has waived all copyright and related or
+ * neighboring rights to this file. This work is published from: Canada.
+ * ---------------------------------------------------------------------
+ *
+ * Copyright (c) 2015 Thomas Pornin
+ */
+
+/* ==================================================================== */
+/*
+ * Common code; could be shared between different hash functions.
+ *
+ * Note: the Base64 functions below assume that uppercase letters (resp.
+ * lowercase letters) have consecutive numerical codes, that fit on 8
+ * bits. All modern systems use ASCII-compatible charsets, where these
+ * properties are true. If you are stuck with a dinosaur of a system
+ * that still defaults to EBCDIC then you already have much bigger
+ * interoperability issues to deal with.
+ */
+
+/*
+ * Some macros for constant-time comparisons. These work over values in
+ * the 0..255 range. Returned value is 0x00 on "false", 0xFF on "true".
+ */
+#define EQ(x, y) ((((0U - ((unsigned)(x) ^ (unsigned)(y))) >> 8) & 0xFF) ^ 0xFF)
+#define GT(x, y) ((((unsigned)(y) - (unsigned)(x)) >> 8) & 0xFF)
+#define GE(x, y) (GT(y, x) ^ 0xFF)
+#define LT(x, y) GT(y, x)
+#define LE(x, y) GE(y, x)
+
+/*
+ * Convert value x (0..63) to corresponding Base64 character.
+ */
+static int b64_byte_to_char(unsigned x) {
+    return (LT(x, 26) & (x + 'A')) |
+           (GE(x, 26) & LT(x, 52) & (x + ('a' - 26))) |
+           (GE(x, 52) & LT(x, 62) & (x + ('0' - 52))) | (EQ(x, 62) & '+') |
+           (EQ(x, 63) & '/');
+}
+
+/*
+ * Convert character c to the corresponding 6-bit value. If character c
+ * is not a Base64 character, then 0xFF (255) is returned.
+ */
+static unsigned b64_char_to_byte(int c) {
+    unsigned x;
+
+    x = (GE(c, 'A') & LE(c, 'Z') & (c - 'A')) |
+        (GE(c, 'a') & LE(c, 'z') & (c - ('a' - 26))) |
+        (GE(c, '0') & LE(c, '9') & (c - ('0' - 52))) | (EQ(c, '+') & 62) |
+        (EQ(c, '/') & 63);
+    return x | (EQ(x, 0) & (EQ(c, 'A') ^ 0xFF));
+}
+
+/*
+ * Convert some bytes to Base64. 'dst_len' is the length (in characters)
+ * of the output buffer 'dst'; if that buffer is not large enough to
+ * receive the result (including the terminating 0), then (size_t)-1
+ * is returned. Otherwise, the zero-terminated Base64 string is written
+ * in the buffer, and the output length (counted WITHOUT the terminating
+ * zero) is returned.
+ */
+static size_t to_base64(char *dst, size_t dst_len, const void *src,
+                        size_t src_len) {
+    size_t olen;
+    const unsigned char *buf;
+    unsigned acc, acc_len;
+
+    olen = (src_len / 3) << 2;
+    switch (src_len % 3) {
+    case 2:
+        olen++;
+    /* fall through */
+    case 1:
+        olen += 2;
+        break;
+    }
+    if (dst_len <= olen) {
+        return (size_t)-1;
+    }
+    acc = 0;
+    acc_len = 0;
+    buf = (const unsigned char *)src;
+    while (src_len-- > 0) {
+        acc = (acc << 8) + (*buf++);
+        acc_len += 8;
+        while (acc_len >= 6) {
+            acc_len -= 6;
+            *dst++ = (char)b64_byte_to_char((acc >> acc_len) & 0x3F);
+        }
+    }
+    if (acc_len > 0) {
+        *dst++ = (char)b64_byte_to_char((acc << (6 - acc_len)) & 0x3F);
+    }
+    *dst++ = 0;
+    return olen;
+}
+
+/*
+ * Decode Base64 chars into bytes. The '*dst_len' value must initially
+ * contain the length of the output buffer '*dst'; when the decoding
+ * ends, the actual number of decoded bytes is written back in
+ * '*dst_len'.
+ *
+ * Decoding stops when a non-Base64 character is encountered, or when
+ * the output buffer capacity is exceeded. If an error occurred (output
+ * buffer is too small, invalid last characters leading to unprocessed
+ * buffered bits), then NULL is returned; otherwise, the returned value
+ * points to the first non-Base64 character in the source stream, which
+ * may be the terminating zero.
+ */
+static const char *from_base64(void *dst, size_t *dst_len, const char *src) {
+    size_t len;
+    unsigned char *buf;
+    unsigned acc, acc_len;
+
+    buf = (unsigned char *)dst;
+    len = 0;
+    acc = 0;
+    acc_len = 0;
+    for (;;) {
+        unsigned d;
+
+        d = b64_char_to_byte(*src);
+        if (d == 0xFF) {
+            break;
+        }
+        src++;
+        acc = (acc << 6) + d;
+        acc_len += 6;
+        if (acc_len >= 8) {
+            acc_len -= 8;
+            if ((len++) >= *dst_len) {
+                return NULL;
+            }
+            *buf++ = (acc >> acc_len) & 0xFF;
+        }
+    }
+
+    /*
+     * If the input length is equal to 1 modulo 4 (which is
+     * invalid), then there will remain 6 unprocessed bits;
+     * otherwise, only 0, 2 or 4 bits are buffered. The buffered
+     * bits must also all be zero.
+     */
+    if (acc_len > 4 || (acc & (((unsigned)1 << acc_len) - 1)) != 0) {
+        return NULL;
+    }
+    *dst_len = len;
+    return src;
+}
+
+/*
+ * Decode decimal integer from 'str'; the value is written in '*v'.
+ * Returned value is a pointer to the next non-decimal character in the
+ * string. If there is no digit at all, or the value encoding is not
+ * minimal (extra leading zeros), or the value does not fit in an
+ * 'unsigned long', then NULL is returned.
+ */
+static const char *decode_decimal(const char *str, unsigned long *v) {
+    const char *orig;
+    unsigned long acc;
+
+    acc = 0;
+    for (orig = str;; str++) {
+        int c;
+
+        c = *str;
+        if (c < '0' || c > '9') {
+            break;
+        }
+        c -= '0';
+        if (acc > (ULONG_MAX / 10)) {
+            return NULL;
+        }
+        acc *= 10;
+        if ((unsigned long)c > (ULONG_MAX - acc)) {
+            return NULL;
+        }
+        acc += (unsigned long)c;
+    }
+    if (str == orig || (*orig == '0' && str != (orig + 1))) {
+        return NULL;
+    }
+    *v = acc;
+    return str;
+}
+
+/* ==================================================================== */
+/*
+ * Code specific to Argon2.
+ *
+ * The code below applies the following format:
+ *
+ *  $argon2<T>[$v=<num>]$m=<num>,t=<num>,p=<num>$<bin>$<bin>
+ *
+ * where <T> is either 'd', 'id', or 'i', <num> is a decimal integer (positive,
+ * fits in an 'unsigned long'), and <bin> is Base64-encoded data (no '=' padding
+ * characters, no newline or whitespace).
+ *
+ * The last two binary chunks (encoded in Base64) are, in that order,
+ * the salt and the output. Both are required. The binary salt length and the
+ * output length must be in the allowed ranges defined in argon2.h.
+ *
+ * The ctx struct must contain buffers large enough to hold the salt and pwd
+ * when it is fed into decode_string.
+ */
+
+int decode_string(argon2_context *ctx, const char *str, argon2_type type) {
+
+/* check for prefix */
+#define CC(prefix)                                                             \
+    do {                                                                       \
+        size_t cc_len = strlen(prefix);                                        \
+        if (strncmp(str, prefix, cc_len) != 0) {                               \
+            return ARGON2_DECODING_FAIL;                                       \
+        }                                                                      \
+        str += cc_len;                                                         \
+    } while ((void)0, 0)
+
+/* optional prefix checking with supplied code */
+#define CC_opt(prefix, code)                                                   \
+    do {                                                                       \
+        size_t cc_len = strlen(prefix);                                        \
+        if (strncmp(str, prefix, cc_len) == 0) {                               \
+            str += cc_len;                                                     \
+            { code; }                                                          \
+        }                                                                      \
+    } while ((void)0, 0)
+
+/* Decoding prefix into decimal */
+#define DECIMAL(x)                                                             \
+    do {                                                                       \
+        unsigned long dec_x;                                                   \
+        str = decode_decimal(str, &dec_x);                                     \
+        if (str == NULL) {                                                     \
+            return ARGON2_DECODING_FAIL;                                       \
+        }                                                                      \
+        (x) = dec_x;                                                           \
+    } while ((void)0, 0)
+
+
+/* Decoding prefix into uint32_t decimal */
+#define DECIMAL_U32(x)                                                         \
+    do {                                                                       \
+        unsigned long dec_x;                                                   \
+        str = decode_decimal(str, &dec_x);                                     \
+        if (str == NULL || dec_x > UINT32_MAX) {                               \
+            return ARGON2_DECODING_FAIL;                                       \
+        }                                                                      \
+        (x) = (uint32_t)dec_x;                                                 \
+    } while ((void)0, 0)
+
+
+/* Decoding base64 into a binary buffer */
+#define BIN(buf, max_len, len)                                                 \
+    do {                                                                       \
+        size_t bin_len = (max_len);                                            \
+        str = from_base64(buf, &bin_len, str);                                 \
+        if (str == NULL || bin_len > UINT32_MAX) {                             \
+            return ARGON2_DECODING_FAIL;                                       \
+        }                                                                      \
+        (len) = (uint32_t)bin_len;                                             \
+    } while ((void)0, 0)
+
+    size_t maxsaltlen = ctx->saltlen;
+    size_t maxoutlen = ctx->outlen;
+    int validation_result;
+    const char* type_string;
+
+    /* We should start with the argon2_type we are using */
+    type_string = argon2_type2string(type, 0);
+    if (!type_string) {
+        return ARGON2_INCORRECT_TYPE;
+    }
+
+    CC("$");
+    CC(type_string);
+
+    /* Reading the version number if the default is suppressed */
+    ctx->version = ARGON2_VERSION_10;
+    CC_opt("$v=", DECIMAL_U32(ctx->version));
+
+    CC("$m=");
+    DECIMAL_U32(ctx->m_cost);
+    CC(",t=");
+    DECIMAL_U32(ctx->t_cost);
+    CC(",p=");
+    DECIMAL_U32(ctx->lanes);
+    ctx->threads = ctx->lanes;
+
+    CC("$");
+    BIN(ctx->salt, maxsaltlen, ctx->saltlen);
+    CC("$");
+    BIN(ctx->out, maxoutlen, ctx->outlen);
+
+    /* The rest of the fields get the default values */
+    ctx->secret = NULL;
+    ctx->secretlen = 0;
+    ctx->ad = NULL;
+    ctx->adlen = 0;
+    ctx->allocate_cbk = NULL;
+    ctx->free_cbk = NULL;
+    ctx->flags = ARGON2_DEFAULT_FLAGS;
+
+    /* On return, must have valid context */
+    validation_result = validate_inputs(ctx);
+    if (validation_result != ARGON2_OK) {
+        return validation_result;
+    }
+
+    /* Can't have any additional characters */
+    if (*str == 0) {
+        return ARGON2_OK;
+    } else {
+        return ARGON2_DECODING_FAIL;
+    }
+#undef CC
+#undef CC_opt
+#undef DECIMAL
+#undef BIN
+}
+
+int encode_string(char *dst, size_t dst_len, argon2_context *ctx,
+                  argon2_type type) {
+#define SS(str)                                                                \
+    do {                                                                       \
+        size_t pp_len = strlen(str);                                           \
+        if (pp_len >= dst_len) {                                               \
+            return ARGON2_ENCODING_FAIL;                                       \
+        }                                                                      \
+        memcpy(dst, str, pp_len + 1);                                          \
+        dst += pp_len;                                                         \
+        dst_len -= pp_len;                                                     \
+    } while ((void)0, 0)
+
+#define SX(x)                                                                  \
+    do {                                                                       \
+        char tmp[30];                                                          \
+        sprintf(tmp, "%lu", (unsigned long)(x));                               \
+        SS(tmp);                                                               \
+    } while ((void)0, 0)
+
+#define SB(buf, len)                                                           \
+    do {                                                                       \
+        size_t sb_len = to_base64(dst, dst_len, buf, len);                     \
+        if (sb_len == (size_t)-1) {                                            \
+            return ARGON2_ENCODING_FAIL;                                       \
+        }                                                                      \
+        dst += sb_len;                                                         \
+        dst_len -= sb_len;                                                     \
+    } while ((void)0, 0)
+
+    const char* type_string = argon2_type2string(type, 0);
+    int validation_result = validate_inputs(ctx);
+
+    if (!type_string) {
+      return ARGON2_ENCODING_FAIL;
+    }
+
+    if (validation_result != ARGON2_OK) {
+      return validation_result;
+    }
+
+
+    SS("$");
+    SS(type_string);
+
+    SS("$v=");
+    SX(ctx->version);
+
+    SS("$m=");
+    SX(ctx->m_cost);
+    SS(",t=");
+    SX(ctx->t_cost);
+    SS(",p=");
+    SX(ctx->lanes);
+
+    SS("$");
+    SB(ctx->salt, ctx->saltlen);
+
+    SS("$");
+    SB(ctx->out, ctx->outlen);
+    return ARGON2_OK;
+
+#undef SS
+#undef SX
+#undef SB
+}
+
+size_t b64len(uint32_t len) {
+    size_t olen = ((size_t)len / 3) << 2;
+
+    switch (len % 3) {
+    case 2:
+        olen++;
+    /* fall through */
+    case 1:
+        olen += 2;
+        break;
+    }
+
+    return olen;
+}
+
+size_t numlen(uint32_t num) {
+    size_t len = 1;
+    while (num >= 10) {
+        ++len;
+        num = num / 10;
+    }
+    return len;
+}
+

algo/argon2d/argon2d/encoding.h

@@ -0,0 +1,57 @@
+/*
+ * Argon2 reference source code package - reference C implementations
+ *
+ * Copyright 2015
+ * Daniel Dinu, Dmitry Khovratovich, Jean-Philippe Aumasson, and Samuel Neves
+ *
+ * You may use this work under the terms of a Creative Commons CC0 1.0
+ * License/Waiver or the Apache Public License 2.0, at your option. The terms of
+ * these licenses can be found at:
+ *
+ * - CC0 1.0 Universal : http://creativecommons.org/publicdomain/zero/1.0
+ * - Apache 2.0        : http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * You should have received a copy of both of these licenses along with this
+ * software. If not, they may be obtained at the above URLs.
+ */
+
+#ifndef ENCODING_H
+#define ENCODING_H
+#include "argon2.h"
+
+#define ARGON2_MAX_DECODED_LANES UINT32_C(255)
+#define ARGON2_MIN_DECODED_SALT_LEN UINT32_C(8)
+#define ARGON2_MIN_DECODED_OUT_LEN UINT32_C(12)
+
+/*
+* encode an Argon2 hash string into the provided buffer. 'dst_len'
+* contains the size, in characters, of the 'dst' buffer; if 'dst_len'
+* is less than the number of required characters (including the
+* terminating 0), then this function returns ARGON2_ENCODING_ERROR.
+*
+* on success, ARGON2_OK is returned.
+*/
+int encode_string(char *dst, size_t dst_len, argon2_context *ctx,
+                  argon2_type type);
+
+/*
+* Decodes an Argon2 hash string into the provided structure 'ctx'.
+* The only fields that must be set prior to this call are ctx.saltlen and
+* ctx.outlen (which must be the maximal salt and out length values that are
+* allowed), ctx.salt and ctx.out (which must be buffers of the specified
+* length), and ctx.pwd and ctx.pwdlen which must hold a valid password.
+*
+* Invalid input string causes an error. On success, the ctx is valid and all
+* fields have been initialized.
+*
+* Returned value is ARGON2_OK on success, other ARGON2_ codes on error.
+*/
+int decode_string(argon2_context *ctx, const char *str, argon2_type type);
+
+/* Returns the length of the encoded byte stream with length len */
+size_t b64len(uint32_t len);
+
+/* Returns the length of the encoded number num */
+size_t numlen(uint32_t num);
+
+#endif

algo/argon2d/argon2d/opt.c

@@ -0,0 +1,342 @@
+/*
+ * Argon2 reference source code package - reference C implementations
+ *
+ * Copyright 2015
+ * Daniel Dinu, Dmitry Khovratovich, Jean-Philippe Aumasson, and Samuel Neves
+ *
+ * You may use this work under the terms of a Creative Commons CC0 1.0
+ * License/Waiver or the Apache Public License 2.0, at your option. The terms of
+ * these licenses can be found at:
+ *
+ * - CC0 1.0 Universal : http://creativecommons.org/publicdomain/zero/1.0
+ * - Apache 2.0        : http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * You should have received a copy of both of these licenses along with this
+ * software. If not, they may be obtained at the above URLs.
+ */
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include "argon2.h"
+#include "core.h"
+#include "simd-utils.h"
+#include "../blake2/blake2.h"
+#include "../blake2/blamka-round-opt.h"
+
+/*
+ * Function fills a new memory block and optionally XORs the old block over the new one.
+ * Memory must be initialized.
+ * @param state Pointer to the just produced block. Content will be updated(!)
+ * @param ref_block Pointer to the reference block
+ * @param next_block Pointer to the block to be XORed over. May coincide with @ref_block
+ * @param with_xor Whether to XOR into the new block (1) or just overwrite (0)
+ * @pre all block pointers must be valid
+ */
+
+#if defined(__AVX512F__)
+
+static inline __m512i blamka( __m512i x, __m512i y )
+{
+    __m512i xy = _mm512_mul_epu32( x, y );
+    return _mm512_add_epi64( _mm512_add_epi64( x, y ),
+                             _mm512_add_epi64( xy, xy ) );
+}
+
+static void fill_block( __m512i *state, const block *ref_block,
+                       block *next_block, int with_xor )
+{
+    __m512i block_XY[ARGON2_512BIT_WORDS_IN_BLOCK];
+    unsigned int i;
+
+    if ( with_xor )
+    {
+        for ( i = 0; i < ARGON2_512BIT_WORDS_IN_BLOCK; i++ )
+        {
+            state[i] = _mm512_xor_si512( state[i],
+                      _mm512_load_si512( (const __m512i*)ref_block->v + i ) );
+            block_XY[i] = _mm512_xor_si512( state[i],
+                      _mm512_load_si512( (const __m512i*)next_block->v + i ) );
+        }
+    }
+    else
+    {
+        for ( i = 0; i < ARGON2_512BIT_WORDS_IN_BLOCK; i++ )
+            block_XY[i] = state[i] = _mm512_xor_si512( state[i],
+                      _mm512_load_si512( (const __m512i*)ref_block->v + i ) );
+    }
+
+    BLAKE2_ROUND_1( state[ 0], state[ 1], state[ 2], state[ 3],
+                    state[ 4], state[ 5], state[ 6], state[ 7] );
+    BLAKE2_ROUND_1( state[ 8], state[ 9], state[10], state[11],
+                    state[12], state[13], state[14], state[15] );
+
+    BLAKE2_ROUND_2( state[ 0], state[ 2], state[ 4], state[ 6],
+                    state[ 8], state[10], state[12], state[14] );
+    BLAKE2_ROUND_2( state[ 1], state[ 3], state[ 5], state[ 7],
+                    state[ 9], state[11], state[13], state[15] );
+
+    for ( i = 0; i < ARGON2_512BIT_WORDS_IN_BLOCK; i++ )
+    {
+        state[i] = _mm512_xor_si512( state[i], block_XY[i] );
+        _mm512_store_si512( (__m512i*)next_block->v + i, state[i] );
+    }
+}
+
+#elif defined(__AVX2__)
+
+static void fill_block( __m256i *state, const block *ref_block,
+                       block *next_block, int with_xor )
+{
+    __m256i block_XY[ARGON2_HWORDS_IN_BLOCK];
+    unsigned int i;
+
+    if ( with_xor )
+    {
+        for ( i = 0; i < ARGON2_HWORDS_IN_BLOCK; i++ )
+        {
+            state[i] = _mm256_xor_si256( state[i],
+                       _mm256_load_si256( (const __m256i*)ref_block->v + i) );
+            block_XY[i] = _mm256_xor_si256( state[i],
+                       _mm256_load_si256( (const __m256i*)next_block->v + i) );
+        }
+    }
+    else
+    {
+        for ( i = 0; i < ARGON2_HWORDS_IN_BLOCK; i++ )
+            block_XY[i] = state[i] = _mm256_xor_si256( state[i],
+                        _mm256_load_si256( (const __m256i*)ref_block->v + i) );
+    }
+
+    BLAKE2_ROUND_1( state[ 0], state[ 4], state[ 1], state[ 5],
+                    state[ 2], state[ 6], state[ 3], state[ 7] );
+    BLAKE2_ROUND_1( state[ 8], state[12], state[ 9], state[13],
+                    state[10], state[14], state[11], state[15] );
+    BLAKE2_ROUND_1( state[16], state[20], state[17], state[21],
+                    state[18], state[22], state[19], state[23] );
+    BLAKE2_ROUND_1( state[24], state[28], state[25], state[29],
+                    state[26], state[30], state[27], state[31] );
+
+    BLAKE2_ROUND_2( state[ 0], state[ 4], state[ 8], state[12],
+                    state[16], state[20], state[24], state[28] );
+    BLAKE2_ROUND_2( state[ 1], state[ 5], state[ 9], state[13],
+                    state[17], state[21], state[25], state[29] );
+    BLAKE2_ROUND_2( state[ 2], state[ 6], state[10], state[14],
+                    state[18], state[22], state[26], state[30] );
+    BLAKE2_ROUND_2( state[ 3], state[ 7], state[11], state[15],
+                    state[19], state[23], state[27], state[31] );
+
+    for ( i = 0; i < ARGON2_HWORDS_IN_BLOCK; i++ )
+    {
+        state[i] = _mm256_xor_si256( state[i], block_XY[i] );
+        _mm256_store_si256( (__m256i*)next_block->v + i, state[i] );
+    }
+}
+
+#else  // SSE2
+
+static void fill_block( v128u64_t *state, const block *ref_block,
+                       block *next_block, int with_xor )
+{
+    v128u64_t block_XY[ARGON2_OWORDS_IN_BLOCK];
+    unsigned int i;
+
+    if ( with_xor )
+    {
+        for ( i = 0; i < ARGON2_OWORDS_IN_BLOCK; i++ )
+        {
+            state[i] = v128_xor( state[i],
+                              v128_load( (const v128_t*)ref_block->v + i) );
+            block_XY[i] = v128_xor( state[i],
+                              v128_load( (const v128_t*)next_block->v + i) );
+        }
+    }
+    else
+    {
+        for ( i = 0; i < ARGON2_OWORDS_IN_BLOCK; i++ )
+            block_XY[i] = state[i] = v128_xor( state[i],
+                              v128_load( (const v128_t*)ref_block->v + i) );
+    }
+
+    BLAKE2_ROUND( state[ 0], state[ 1], state[ 2], state[ 3],
+                  state[ 4], state[ 5], state[ 6], state[ 7] );
+    BLAKE2_ROUND( state[ 8], state[ 9], state[10], state[11], 
+                  state[12], state[13], state[14], state[15] );
+    BLAKE2_ROUND( state[16], state[17], state[18], state[19], 
+                  state[20], state[21], state[22], state[23] );
+    BLAKE2_ROUND( state[24], state[25], state[26], state[27], 
+                  state[28], state[29], state[30], state[31] );
+    BLAKE2_ROUND( state[32], state[33], state[34], state[35], 
+                  state[36], state[37], state[38], state[39] );
+    BLAKE2_ROUND( state[40], state[41], state[42], state[43], 
+                  state[44], state[45], state[46], state[47] );
+    BLAKE2_ROUND( state[48], state[49], state[50], state[51], 
+                  state[52], state[53], state[54], state[55] );
+    BLAKE2_ROUND( state[56], state[57], state[58], state[59], 
+                  state[60], state[61], state[62], state[63] );
+
+    BLAKE2_ROUND( state[ 0], state[ 8], state[16], state[24], 
+                  state[32], state[40], state[48], state[56] );
+    BLAKE2_ROUND( state[ 1], state[ 9], state[17], state[25],  
+                  state[33], state[41], state[49], state[57] );
+    BLAKE2_ROUND( state[ 2], state[10], state[18], state[26],  
+                  state[34], state[42], state[50], state[58] );
+    BLAKE2_ROUND( state[ 3], state[11], state[19], state[27],  
+                  state[35], state[43], state[51], state[59] );
+    BLAKE2_ROUND( state[ 4], state[12], state[20], state[28],  
+                  state[36], state[44], state[52], state[60] );
+    BLAKE2_ROUND( state[ 5], state[13], state[21], state[29],  
+                  state[37], state[45], state[53], state[61] );
+    BLAKE2_ROUND( state[ 6], state[14], state[22], state[30],  
+                  state[38], state[46], state[54], state[62] );
+    BLAKE2_ROUND( state[ 7], state[15], state[23], state[31],  
+                  state[39], state[47], state[55], state[63] );
+
+    for ( i = 0; i < ARGON2_OWORDS_IN_BLOCK; i++ )
+    {
+        state[i] = v128_xor( state[i], block_XY[i] );
+        v128_store( (v128_t*)next_block->v + i, state[i] );
+    }
+}
+
+#endif
+
+#if 0
+static void next_addresses(block *address_block, block *input_block) {
+    /*Temporary zero-initialized blocks*/
+#if defined(__AVX512F__)
+    __m512i zero_block[ARGON2_512BIT_WORDS_IN_BLOCK];
+    __m512i zero2_block[ARGON2_512BIT_WORDS_IN_BLOCK];
+#elif defined(__AVX2__)
+    __m256i zero_block[ARGON2_HWORDS_IN_BLOCK];
+    __m256i zero2_block[ARGON2_HWORDS_IN_BLOCK];
+#else
+    v128_t zero_block[ARGON2_OWORDS_IN_BLOCK];
+    v128_t zero2_block[ARGON2_OWORDS_IN_BLOCK];
+#endif
+
+    memset(zero_block, 0, sizeof(zero_block));
+    memset(zero2_block, 0, sizeof(zero2_block));
+
+    /*Increasing index counter*/
+    input_block->v[6]++;
+
+    /*First iteration of G*/
+    fill_block(zero_block, input_block, address_block, 0);
+
+    /*Second iteration of G*/
+    fill_block(zero2_block, address_block, address_block, 0);
+}
+#endif
+
+void fill_segment(const argon2_instance_t *instance,
+                  argon2_position_t position) {
+    block *ref_block = NULL, *curr_block = NULL;
+//    block address_block, input_block;
+    uint64_t pseudo_rand, ref_index, ref_lane;
+    uint32_t prev_offset, curr_offset;
+    uint32_t starting_index, i;
+#if defined(__AVX512F__)
+    __m512i state[ARGON2_512BIT_WORDS_IN_BLOCK];
+#elif defined(__AVX2__)
+    __m256i state[ARGON2_HWORDS_IN_BLOCK];
+#else
+    v128u64_t state[ARGON2_OWORDS_IN_BLOCK];
+#endif
+//    int data_independent_addressing;
+
+    if (instance == NULL) {
+        return;
+    }
+
+    // data_independent_addressing =
+    //     (instance->type == Argon2_i) ||
+    //     (instance->type == Argon2_id && (position.pass == 0) &&
+    //      (position.slice < ARGON2_SYNC_POINTS / 2));
+
+    // if (data_independent_addressing) {
+    //     init_block_value(&input_block, 0);
+
+    //     input_block.v[0] = position.pass;
+    //     input_block.v[1] = position.lane;
+    //     input_block.v[2] = position.slice;
+    //     input_block.v[3] = instance->memory_blocks;
+    //     input_block.v[4] = instance->passes;
+    //     input_block.v[5] = instance->type;
+    // }
+
+    starting_index = 0;
+
+    if ((0 == position.pass) && (0 == position.slice)) {
+        starting_index = 2; /* we have already generated the first two blocks */
+
+        /* Don't forget to generate the first block of addresses: */
+//        if (data_independent_addressing) {
+//            next_addresses(&address_block, &input_block);
+//        }
+    }
+
+    /* Offset of the current block */
+    curr_offset = position.lane * instance->lane_length +
+                  position.slice * instance->segment_length + starting_index;
+
+    if (0 == curr_offset % instance->lane_length) {
+        /* Last block in this lane */
+        prev_offset = curr_offset + instance->lane_length - 1;
+    } else {
+        /* Previous block */
+        prev_offset = curr_offset - 1;
+    }
+
+    memcpy(state, ((instance->memory + prev_offset)->v), ARGON2_BLOCK_SIZE);
+
+    for (i = starting_index; i < instance->segment_length;
+         ++i, ++curr_offset, ++prev_offset) {
+        /*1.1 Rotating prev_offset if needed */
+        if (curr_offset % instance->lane_length == 1) {
+            prev_offset = curr_offset - 1;
+        }
+
+        /* 1.2 Computing the index of the reference block */
+        /* 1.2.1 Taking pseudo-random value from the previous block */
+//        if (data_independent_addressing) {
+//            if (i % ARGON2_ADDRESSES_IN_BLOCK == 0) {
+//                next_addresses(&address_block, &input_block);
+//            }
+//            pseudo_rand = address_block.v[i % ARGON2_ADDRESSES_IN_BLOCK];
+//        } else {
+            pseudo_rand = instance->memory[prev_offset].v[0];
+//        }
+
+        /* 1.2.2 Computing the lane of the reference block */
+        ref_lane = ((pseudo_rand >> 32)) % instance->lanes;
+
+        if ((position.pass == 0) && (position.slice == 0)) {
+            /* Can not reference other lanes yet */
+            ref_lane = position.lane;
+        }
+
+        /* 1.2.3 Computing the number of possible reference block within the
+         * lane.
+         */
+        position.index = i;
+        ref_index = index_alpha(instance, &position, pseudo_rand & 0xFFFFFFFF,
+                                ref_lane == position.lane);
+
+        /* 2 Creating a new block */
+        ref_block =
+            instance->memory + instance->lane_length * ref_lane + ref_index;
+        curr_block = instance->memory + curr_offset;
+         if (ARGON2_VERSION_10 == instance->version) {
+             /* version 1.2.1 and earlier: overwrite, not XOR */
+             fill_block(state, ref_block, curr_block, 0);
+         } else {
+             if(0 == position.pass) {
+                fill_block(state, ref_block, curr_block, 0);
+             } else {
+                 fill_block(state, ref_block, curr_block, 1);
+             }
+         }
+    }
+}

algo/argon2d/blake2/blake2-impl.h

@@ -0,0 +1,156 @@
+/*
+ * Argon2 reference source code package - reference C implementations
+ *
+ * Copyright 2015
+ * Daniel Dinu, Dmitry Khovratovich, Jean-Philippe Aumasson, and Samuel Neves
+ *
+ * You may use this work under the terms of a Creative Commons CC0 1.0
+ * License/Waiver or the Apache Public License 2.0, at your option. The terms of
+ * these licenses can be found at:
+ *
+ * - CC0 1.0 Universal : http://creativecommons.org/publicdomain/zero/1.0
+ * - Apache 2.0        : http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * You should have received a copy of both of these licenses along with this
+ * software. If not, they may be obtained at the above URLs.
+ */
+
+#ifndef PORTABLE_BLAKE2_IMPL_H
+#define PORTABLE_BLAKE2_IMPL_H
+
+#include <stdint.h>
+#include <string.h>
+
+#if defined(_MSC_VER)
+#define BLAKE2_INLINE __inline
+#elif defined(__GNUC__) || defined(__clang__)
+#define BLAKE2_INLINE __inline__
+#else
+#define BLAKE2_INLINE
+#endif
+
+/* Argon2 Team - Begin Code */
+/*
+   Not an exhaustive list, but should cover the majority of modern platforms
+   Additionally, the code will always be correct---this is only a performance
+   tweak.
+*/
+#if (defined(__BYTE_ORDER__) &&                                                \
+     (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)) ||                           \
+    defined(__LITTLE_ENDIAN__) || defined(__ARMEL__) || defined(__MIPSEL__) || \
+    defined(__AARCH64EL__) || defined(__amd64__) || defined(__i386__) ||       \
+    defined(_M_IX86) || defined(_M_X64) || defined(_M_AMD64) ||                \
+    defined(_M_ARM)
+#define NATIVE_LITTLE_ENDIAN
+#endif
+/* Argon2 Team - End Code */
+
+static BLAKE2_INLINE uint32_t load32(const void *src) {
+#if defined(NATIVE_LITTLE_ENDIAN)
+    uint32_t w;
+    memcpy(&w, src, sizeof w);
+    return w;
+#else
+    const uint8_t *p = (const 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 BLAKE2_INLINE uint64_t load64(const void *src) {
+#if defined(NATIVE_LITTLE_ENDIAN)
+    uint64_t w;
+    memcpy(&w, src, sizeof w);
+    return w;
+#else
+    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;
+    w |= (uint64_t)(*p++) << 48;
+    w |= (uint64_t)(*p++) << 56;
+    return w;
+#endif
+}
+
+static BLAKE2_INLINE void store32(void *dst, uint32_t w) {
+#if defined(NATIVE_LITTLE_ENDIAN)
+    memcpy(dst, &w, sizeof 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 BLAKE2_INLINE void store64(void *dst, uint64_t w) {
+#if defined(NATIVE_LITTLE_ENDIAN)
+    memcpy(dst, &w, sizeof 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;
+    w >>= 8;
+    *p++ = (uint8_t)w;
+    w >>= 8;
+    *p++ = (uint8_t)w;
+    w >>= 8;
+    *p++ = (uint8_t)w;
+    w >>= 8;
+    *p++ = (uint8_t)w;
+#endif
+}
+
+static BLAKE2_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 BLAKE2_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;
+}
+
+static BLAKE2_INLINE uint32_t rotr32(const uint32_t w, const unsigned c) {
+    return (w >> c) | (w << (32 - c));
+}
+
+static BLAKE2_INLINE uint64_t rotr64(const uint64_t w, const unsigned c) {
+    return (w >> c) | (w << (64 - c));
+}
+
+void clear_internal_memory(void *v, size_t n);
+
+#endif

algo/argon2d/blake2/blake2.h

@@ -0,0 +1,91 @@
+/*
+ * Argon2 reference source code package - reference C implementations
+ *
+ * Copyright 2015
+ * Daniel Dinu, Dmitry Khovratovich, Jean-Philippe Aumasson, and Samuel Neves
+ *
+ * You may use this work under the terms of a Creative Commons CC0 1.0
+ * License/Waiver or the Apache Public License 2.0, at your option. The terms of
+ * these licenses can be found at:
+ *
+ * - CC0 1.0 Universal : http://creativecommons.org/publicdomain/zero/1.0
+ * - Apache 2.0        : http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * You should have received a copy of both of these licenses along with this
+ * software. If not, they may be obtained at the above URLs.
+ */
+
+#ifndef PORTABLE_BLAKE2_H
+#define PORTABLE_BLAKE2_H
+
+#include <stddef.h>
+#include <stdint.h>
+#include <limits.h>
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+enum blake2b_constant {
+    BLAKE2B_BLOCKBYTES = 128,
+    BLAKE2B_OUTBYTES = 64,
+    BLAKE2B_KEYBYTES = 64,
+    BLAKE2B_SALTBYTES = 16,
+    BLAKE2B_PERSONALBYTES = 16
+};
+
+#pragma pack(push, 1)
+typedef struct __blake2b_param {
+    uint8_t digest_length;                   /* 1 */
+    uint8_t key_length;                      /* 2 */
+    uint8_t fanout;                          /* 3 */
+    uint8_t depth;                           /* 4 */
+    uint32_t leaf_length;                    /* 8 */
+    uint64_t node_offset;                    /* 16 */
+    uint8_t node_depth;                      /* 17 */
+    uint8_t inner_length;                    /* 18 */
+    uint8_t reserved[14];                    /* 32 */
+    uint8_t salt[BLAKE2B_SALTBYTES];         /* 48 */
+    uint8_t personal[BLAKE2B_PERSONALBYTES]; /* 64 */
+} blake2b_param;
+#pragma pack(pop)
+
+typedef struct __blake2b_state {
+    uint64_t h[8];
+    uint64_t t[2];
+    uint64_t f[2];
+    uint8_t buf[BLAKE2B_BLOCKBYTES];
+    unsigned buflen;
+    unsigned outlen;
+    uint8_t last_node;
+} blake2b_state;
+
+/* Ensure param structs have not been wrongly padded */
+/* Poor man's static_assert */
+enum {
+    blake2_size_check_0 = 1 / !!(CHAR_BIT == 8),
+    blake2_size_check_2 =
+        1 / !!(sizeof(blake2b_param) == sizeof(uint64_t) * CHAR_BIT)
+};
+
+/* Streaming API */
+int blake2b_init(blake2b_state *S, size_t outlen);
+int blake2b_init_key(blake2b_state *S, size_t outlen, const void *key,
+                     size_t keylen);
+int blake2b_init_param(blake2b_state *S, const blake2b_param *P);
+int blake2b_update(blake2b_state *S, const void *in, size_t inlen);
+int blake2b_final(blake2b_state *S, void *out, size_t outlen);
+
+/* Simple API */
+int blake2b(void *out, size_t outlen, const void *in, size_t inlen,
+                         const void *key, size_t keylen);
+
+/* Argon2 Team - Begin Code */
+int blake2b_long(void *out, size_t outlen, const void *in, size_t inlen);
+/* Argon2 Team - End Code */
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif

algo/argon2d/blake2/blake2b.c

@@ -0,0 +1,390 @@
+/*
+ * Argon2 reference source code package - reference C implementations
+ *
+ * Copyright 2015
+ * Daniel Dinu, Dmitry Khovratovich, Jean-Philippe Aumasson, and Samuel Neves
+ *
+ * You may use this work under the terms of a Creative Commons CC0 1.0
+ * License/Waiver or the Apache Public License 2.0, at your option. The terms of
+ * these licenses can be found at:
+ *
+ * - CC0 1.0 Universal : http://creativecommons.org/publicdomain/zero/1.0
+ * - Apache 2.0        : http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * You should have received a copy of both of these licenses along with this
+ * software. If not, they may be obtained at the above URLs.
+ */
+
+#include <stdint.h>
+#include <string.h>
+#include <stdio.h>
+
+#include "blake2.h"
+#include "blake2-impl.h"
+
+static const uint64_t blake2b_IV[8] = {
+    UINT64_C(0x6a09e667f3bcc908), UINT64_C(0xbb67ae8584caa73b),
+    UINT64_C(0x3c6ef372fe94f82b), UINT64_C(0xa54ff53a5f1d36f1),
+    UINT64_C(0x510e527fade682d1), UINT64_C(0x9b05688c2b3e6c1f),
+    UINT64_C(0x1f83d9abfb41bd6b), UINT64_C(0x5be0cd19137e2179)};
+
+static const unsigned int blake2b_sigma[12][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},
+    {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},
+};
+
+static BLAKE2_INLINE void blake2b_set_lastnode(blake2b_state *S) {
+    S->f[1] = (uint64_t)-1;
+}
+
+static BLAKE2_INLINE void blake2b_set_lastblock(blake2b_state *S) {
+    if (S->last_node) {
+        blake2b_set_lastnode(S);
+    }
+    S->f[0] = (uint64_t)-1;
+}
+
+static BLAKE2_INLINE void blake2b_increment_counter(blake2b_state *S,
+                                                    uint64_t inc) {
+    S->t[0] += inc;
+    S->t[1] += (S->t[0] < inc);
+}
+
+static BLAKE2_INLINE void blake2b_invalidate_state(blake2b_state *S) {
+    clear_internal_memory(S, sizeof(*S));      /* wipe */
+    blake2b_set_lastblock(S); /* invalidate for further use */
+}
+
+static BLAKE2_INLINE void blake2b_init0(blake2b_state *S) {
+    memset(S, 0, sizeof(*S));
+    memcpy(S->h, blake2b_IV, sizeof(S->h));
+}
+
+int blake2b_init_param(blake2b_state *S, const blake2b_param *P) {
+    const unsigned char *p = (const unsigned char *)P;
+    unsigned int i;
+
+    if (NULL == P || NULL == S) {
+        return -1;
+    }
+
+    blake2b_init0(S);
+    /* IV XOR Parameter Block */
+    for (i = 0; i < 8; ++i) {
+        S->h[i] ^= load64(&p[i * sizeof(S->h[i])]);
+    }
+    S->outlen = P->digest_length;
+    return 0;
+}
+
+/* Sequential blake2b initialization */
+int blake2b_init(blake2b_state *S, size_t outlen) {
+    blake2b_param P;
+
+    if (S == NULL) {
+        return -1;
+    }
+
+    if ((outlen == 0) || (outlen > BLAKE2B_OUTBYTES)) {
+        blake2b_invalidate_state(S);
+        return -1;
+    }
+
+    /* Setup Parameter Block for unkeyed BLAKE2 */
+    P.digest_length = (uint8_t)outlen;
+    P.key_length = 0;
+    P.fanout = 1;
+    P.depth = 1;
+    P.leaf_length = 0;
+    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 blake2b_init_param(S, &P);
+}
+
+int blake2b_init_key(blake2b_state *S, size_t outlen, const void *key,
+                     size_t keylen) {
+    blake2b_param P;
+
+    if (S == NULL) {
+        return -1;
+    }
+
+    if ((outlen == 0) || (outlen > BLAKE2B_OUTBYTES)) {
+        blake2b_invalidate_state(S);
+        return -1;
+    }
+
+    if ((key == 0) || (keylen == 0) || (keylen > BLAKE2B_KEYBYTES)) {
+        blake2b_invalidate_state(S);
+        return -1;
+    }
+
+    /* Setup Parameter Block for keyed BLAKE2 */
+    P.digest_length = (uint8_t)outlen;
+    P.key_length = (uint8_t)keylen;
+    P.fanout = 1;
+    P.depth = 1;
+    P.leaf_length = 0;
+    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 (blake2b_init_param(S, &P) < 0) {
+        blake2b_invalidate_state(S);
+        return -1;
+    }
+
+    {
+        uint8_t block[BLAKE2B_BLOCKBYTES];
+        memset(block, 0, BLAKE2B_BLOCKBYTES);
+        memcpy(block, key, keylen);
+        blake2b_update(S, block, BLAKE2B_BLOCKBYTES);
+        /* Burn the key from stack */
+        clear_internal_memory(block, BLAKE2B_BLOCKBYTES);
+    }
+    return 0;
+}
+
+static void blake2b_compress(blake2b_state *S, const uint8_t *block) {
+    uint64_t m[16];
+    uint64_t v[16];
+    unsigned int i, r;
+
+    for (i = 0; i < 16; ++i) {
+        m[i] = load64(block + i * sizeof(m[i]));
+    }
+
+    for (i = 0; i < 8; ++i) {
+        v[i] = S->h[i];
+    }
+
+    v[8] = blake2b_IV[0];
+    v[9] = blake2b_IV[1];
+    v[10] = blake2b_IV[2];
+    v[11] = blake2b_IV[3];
+    v[12] = blake2b_IV[4] ^ S->t[0];
+    v[13] = blake2b_IV[5] ^ S->t[1];
+    v[14] = blake2b_IV[6] ^ S->f[0];
+    v[15] = blake2b_IV[7] ^ S->f[1];
+
+#define G(r, i, a, b, c, d)                                                    \
+    do {                                                                       \
+        a = a + b + m[blake2b_sigma[r][2 * i + 0]];                            \
+        d = rotr64(d ^ a, 32);                                                 \
+        c = c + d;                                                             \
+        b = rotr64(b ^ c, 24);                                                 \
+        a = a + b + m[blake2b_sigma[r][2 * i + 1]];                            \
+        d = rotr64(d ^ a, 16);                                                 \
+        c = c + d;                                                             \
+        b = rotr64(b ^ c, 63);                                                 \
+    } while ((void)0, 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 ((void)0, 0)
+
+    for (r = 0; r < 12; ++r) {
+        ROUND(r);
+    }
+
+    for (i = 0; i < 8; ++i) {
+        S->h[i] = S->h[i] ^ v[i] ^ v[i + 8];
+    }
+
+#undef G
+#undef ROUND
+}
+
+int blake2b_update(blake2b_state *S, const void *in, size_t inlen) {
+    const uint8_t *pin = (const uint8_t *)in;
+
+    if (inlen == 0) {
+        return 0;
+    }
+
+    /* Sanity check */
+    if (S == NULL || in == NULL) {
+        return -1;
+    }
+
+    /* Is this a reused state? */
+    if (S->f[0] != 0) {
+        return -1;
+    }
+
+    if (S->buflen + inlen > BLAKE2B_BLOCKBYTES) {
+        /* Complete current block */
+        size_t left = S->buflen;
+        size_t fill = BLAKE2B_BLOCKBYTES - left;
+        memcpy(&S->buf[left], pin, fill);
+        blake2b_increment_counter(S, BLAKE2B_BLOCKBYTES);
+        blake2b_compress(S, S->buf);
+        S->buflen = 0;
+        inlen -= fill;
+        pin += fill;
+        /* Avoid buffer copies when possible */
+        while (inlen > BLAKE2B_BLOCKBYTES) {
+            blake2b_increment_counter(S, BLAKE2B_BLOCKBYTES);
+            blake2b_compress(S, pin);
+            inlen -= BLAKE2B_BLOCKBYTES;
+            pin += BLAKE2B_BLOCKBYTES;
+        }
+    }
+    memcpy(&S->buf[S->buflen], pin, inlen);
+    S->buflen += (unsigned int)inlen;
+    return 0;
+}
+
+int blake2b_final(blake2b_state *S, void *out, size_t outlen) {
+    uint8_t buffer[BLAKE2B_OUTBYTES] = {0};
+    unsigned int i;
+
+    /* Sanity checks */
+    if (S == NULL || out == NULL || outlen < S->outlen) {
+        return -1;
+    }
+
+    /* Is this a reused state? */
+    if (S->f[0] != 0) {
+        return -1;
+    }
+
+    blake2b_increment_counter(S, S->buflen);
+    blake2b_set_lastblock(S);
+    memset(&S->buf[S->buflen], 0, BLAKE2B_BLOCKBYTES - S->buflen); /* Padding */
+    blake2b_compress(S, S->buf);
+
+    for (i = 0; i < 8; ++i) { /* Output full hash to temp buffer */
+        store64(buffer + sizeof(S->h[i]) * i, S->h[i]);
+    }
+
+    memcpy(out, buffer, S->outlen);
+    clear_internal_memory(buffer, sizeof(buffer));
+    clear_internal_memory(S->buf, sizeof(S->buf));
+    clear_internal_memory(S->h, sizeof(S->h));
+    return 0;
+}
+
+int blake2b(void *out, size_t outlen, const void *in, size_t inlen,
+            const void *key, size_t keylen) {
+    blake2b_state S;
+    int ret = -1;
+
+    /* Verify parameters */
+    if (NULL == in && inlen > 0) {
+        goto fail;
+    }
+
+    if (NULL == out || outlen == 0 || outlen > BLAKE2B_OUTBYTES) {
+        goto fail;
+    }
+
+    if ((NULL == key && keylen > 0) || keylen > BLAKE2B_KEYBYTES) {
+        goto fail;
+    }
+
+    if (keylen > 0) {
+        if (blake2b_init_key(&S, outlen, key, keylen) < 0) {
+            goto fail;
+        }
+    } else {
+        if (blake2b_init(&S, outlen) < 0) {
+            goto fail;
+        }
+    }
+
+    if (blake2b_update(&S, in, inlen) < 0) {
+        goto fail;
+    }
+    ret = blake2b_final(&S, out, outlen);
+
+fail:
+    clear_internal_memory(&S, sizeof(S));
+    return ret;
+}
+
+/* Argon2 Team - Begin Code */
+int blake2b_long(void *pout, size_t outlen, const void *in, size_t inlen) {
+    uint8_t *out = (uint8_t *)pout;
+    blake2b_state blake_state;
+    uint8_t outlen_bytes[sizeof(uint32_t)] = {0};
+    int ret = -1;
+
+    if (outlen > UINT32_MAX) {
+        goto fail;
+    }
+
+    /* Ensure little-endian byte order! */
+    store32(outlen_bytes, (uint32_t)outlen);
+
+#define TRY(statement)                                                         \
+    do {                                                                       \
+        ret = statement;                                                       \
+        if (ret < 0) {                                                         \
+            goto fail;                                                         \
+        }                                                                      \
+    } while ((void)0, 0)
+
+    if (outlen <= BLAKE2B_OUTBYTES) {
+        TRY(blake2b_init(&blake_state, outlen));
+        TRY(blake2b_update(&blake_state, outlen_bytes, sizeof(outlen_bytes)));
+        TRY(blake2b_update(&blake_state, in, inlen));
+        TRY(blake2b_final(&blake_state, out, outlen));
+    } else {
+        uint32_t toproduce;
+        uint8_t out_buffer[BLAKE2B_OUTBYTES];
+        uint8_t in_buffer[BLAKE2B_OUTBYTES];
+        TRY(blake2b_init(&blake_state, BLAKE2B_OUTBYTES));
+        TRY(blake2b_update(&blake_state, outlen_bytes, sizeof(outlen_bytes)));
+        TRY(blake2b_update(&blake_state, in, inlen));
+        TRY(blake2b_final(&blake_state, out_buffer, BLAKE2B_OUTBYTES));
+        memcpy(out, out_buffer, BLAKE2B_OUTBYTES / 2);
+        out += BLAKE2B_OUTBYTES / 2;
+        toproduce = (uint32_t)outlen - BLAKE2B_OUTBYTES / 2;
+
+        while (toproduce > BLAKE2B_OUTBYTES) {
+            memcpy(in_buffer, out_buffer, BLAKE2B_OUTBYTES);
+            TRY(blake2b(out_buffer, BLAKE2B_OUTBYTES, in_buffer,
+                        BLAKE2B_OUTBYTES, NULL, 0));
+            memcpy(out, out_buffer, BLAKE2B_OUTBYTES / 2);
+            out += BLAKE2B_OUTBYTES / 2;
+            toproduce -= BLAKE2B_OUTBYTES / 2;
+        }
+
+        memcpy(in_buffer, out_buffer, BLAKE2B_OUTBYTES);
+        TRY(blake2b(out_buffer, toproduce, in_buffer, BLAKE2B_OUTBYTES, NULL,
+                    0));
+        memcpy(out, out_buffer, toproduce);
+    }
+fail:
+    clear_internal_memory(&blake_state, sizeof(blake_state));
+    return ret;
+#undef TRY
+}
+/* Argon2 Team - End Code */

algo/argon2d/blake2/blamka-round-opt.h

@@ -0,0 +1,428 @@
+/*
+ * Argon2 reference source code package - reference C implementations
+ *
+ * Copyright 2015
+ * Daniel Dinu, Dmitry Khovratovich, Jean-Philippe Aumasson, and Samuel Neves
+ *
+ * You may use this work under the terms of a Creative Commons CC0 1.0
+ * License/Waiver or the Apache Public License 2.0, at your option. The terms of
+ * these licenses can be found at:
+ *
+ * - CC0 1.0 Universal : http://creativecommons.org/publicdomain/zero/1.0
+ * - Apache 2.0        : http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * You should have received a copy of both of these licenses along with this
+ * software. If not, they may be obtained at the above URLs.
+ */
+
+#ifndef BLAKE_ROUND_MKA_OPT_H
+#define BLAKE_ROUND_MKA_OPT_H
+
+#include "blake2-impl.h"
+#include "simd-utils.h"
+
+#if !defined(__AVX512F__)
+
+#if !defined(__AVX2__)
+
+static BLAKE2_INLINE v128_t fBlaMka(v128_t x, v128_t y)
+{
+    const v128u64_t z = v128_mulw32( x, y );
+    return (v128u32_t)v128_add64( v128_add64( (v128u64_t)x, (v128u64_t)y ),
+                                  v128_add64( z, z ) );
+}
+
+#define G1( A0, B0, C0, D0, A1, B1, C1, D1 ) \
+{ \
+   A0 = fBlaMka( A0, B0 ); \
+   A1 = fBlaMka( A1, B1 ); \
+   D0 = v128_xor( D0, A0 ); \
+   D1 = v128_xor( D1, A1 ); \
+   D0 = v128_ror64( D0, 32 ); \
+   D1 = v128_ror64( D1, 32 ); \
+   C0 = fBlaMka( C0, D0 ); \
+   C1 = fBlaMka( C1, D1 ); \
+   B0 = v128_xor( B0, C0 ); \
+   B1 = v128_xor( B1, C1 ); \
+   B0 = v128_ror64( B0, 24 ); \
+   B1 = v128_ror64( B1, 24 ); \
+} 
+
+#define G2( A0, B0, C0, D0, A1, B1, C1, D1 ) \
+{ \
+   A0 = fBlaMka( A0, B0 ); \
+   A1 = fBlaMka( A1, B1 ); \
+   D0 = v128_xor( D0, A0 ); \
+   D1 = v128_xor( D1, A1 ); \
+   D0 = v128_ror64( D0, 16 ); \
+   D1 = v128_ror64( D1, 16 ); \
+   C0 = fBlaMka( C0, D0 ); \
+   C1 = fBlaMka( C1, D1 ); \
+   B0 = v128_xor( B0, C0 ); \
+   B1 = v128_xor( B1, C1 ); \
+   B0 = v128_ror64( B0, 63 ); \
+   B1 = v128_ror64( B1, 63 ); \
+}
+
+#if defined(__SSSE3__)  || defined(__ARM_NEON)
+
+#define DIAGONALIZE(A0, B0, C0, D0, A1, B1, C1, D1)                            \
+    do {                                                                       \
+        v128_t t0 = v128_alignr8(B1, B0, 8);                               \
+        v128_t t1 = v128_alignr8(B0, B1, 8);                               \
+        B0 = t0;                                                               \
+        B1 = t1;                                                               \
+                                                                               \
+        t0 = C0;                                                               \
+        C0 = C1;                                                               \
+        C1 = t0;                                                               \
+                                                                               \
+        t0 = v128_alignr8(D1, D0, 8);                                       \
+        t1 = v128_alignr8(D0, D1, 8);                                       \
+        D0 = t1;                                                               \
+        D1 = t0;                                                               \
+    } while ((void)0, 0)
+
+#define UNDIAGONALIZE(A0, B0, C0, D0, A1, B1, C1, D1)                          \
+    do {                                                                       \
+        v128_t t0 = v128_alignr8(B0, B1, 8);                               \
+        v128_t t1 = v128_alignr8(B1, B0, 8);                               \
+        B0 = t0;                                                               \
+        B1 = t1;                                                               \
+                                                                               \
+        t0 = C0;                                                               \
+        C0 = C1;                                                               \
+        C1 = t0;                                                               \
+                                                                               \
+        t0 = v128_alignr8(D0, D1, 8);                                       \
+        t1 = v128_alignr8(D1, D0, 8);                                       \
+        D0 = t1;                                                               \
+        D1 = t0;                                                               \
+    } while ((void)0, 0)
+
+#else /* SSE2 */
+
+#define DIAGONALIZE(A0, B0, C0, D0, A1, B1, C1, D1)                            \
+    do {                                                                       \
+        v128_t t0 = D0;                                                       \
+        v128_t t1 = B0;                                                       \
+        D0 = C0;                                                               \
+        C0 = C1;                                                               \
+        C1 = D0;                                                               \
+        D0 = v128_unpackhi64(D1, v128_unpacklo64(t0, t0));               \
+        D1 = v128_unpackhi64(t0, v128_unpacklo64(D1, D1));               \
+        B0 = v128_unpackhi64(B0, v128_unpacklo64(B1, B1));               \
+        B1 = v128_unpackhi64(B1, v128_unpacklo64(t1, t1));               \
+    } while ((void)0, 0)
+
+#define UNDIAGONALIZE(A0, B0, C0, D0, A1, B1, C1, D1)                          \
+    do {                                                                       \
+        v128_t t0, t1;                                                        \
+        t0 = C0;                                                               \
+        C0 = C1;                                                               \
+        C1 = t0;                                                               \
+        t0 = B0;                                                               \
+        t1 = D0;                                                               \
+        B0 = v128_unpackhi64(B1, v128_unpacklo64(B0, B0));               \
+        B1 = v128_unpackhi64(t0, v128_unpacklo64(B1, B1));               \
+        D0 = v128_unpackhi64(D0, v128_unpacklo64(D1, D1));               \
+        D1 = v128_unpackhi64(D1, v128_unpacklo64(t1, t1));               \
+    } while ((void)0, 0)
+#endif
+
+#define BLAKE2_ROUND(A0, A1, B0, B1, C0, C1, D0, D1)                           \
+    do {                                                                       \
+        G1(A0, B0, C0, D0, A1, B1, C1, D1);                                    \
+        G2(A0, B0, C0, D0, A1, B1, C1, D1);                                    \
+                                                                               \
+        DIAGONALIZE(A0, B0, C0, D0, A1, B1, C1, D1);                           \
+                                                                               \
+        G1(A0, B0, C0, D0, A1, B1, C1, D1);                                    \
+        G2(A0, B0, C0, D0, A1, B1, C1, D1);                                    \
+                                                                               \
+        UNDIAGONALIZE(A0, B0, C0, D0, A1, B1, C1, D1);                         \
+    } while ((void)0, 0)
+#else /* __AVX2__ */
+
+#include <immintrin.h>
+
+#define  rotr32( x )  mm256_ror_64( x, 32 )
+#define  rotr24( x )  mm256_ror_64( x, 24 )
+#define  rotr16( x )  mm256_ror_64( x, 16 )
+#define  rotr63( x )  mm256_rol_64( x,  1 )
+
+//#define rotr32(x)   _mm256_shuffle_epi32(x, _MM_SHUFFLE(2, 3, 0, 1))
+//#define rotr24(x)   _mm256_shuffle_epi8(x, _mm256_setr_epi8(3, 4, 5, 6, 7, 0, 1, 2, 11, 12, 13, 14, 15, 8, 9, 10, 3, 4, 5, 6, 7, 0, 1, 2, 11, 12, 13, 14, 15, 8, 9, 10))
+//#define rotr16(x)   _mm256_shuffle_epi8(x, _mm256_setr_epi8(2, 3, 4, 5, 6, 7, 0, 1, 10, 11, 12, 13, 14, 15, 8, 9, 2, 3, 4, 5, 6, 7, 0, 1, 10, 11, 12, 13, 14, 15, 8, 9))
+//#define rotr63(x)   _mm256_xor_si256(_mm256_srli_epi64((x), 63), _mm256_add_epi64((x), (x)))
+
+#define G1_AVX2(A0, A1, B0, B1, C0, C1, D0, D1) \
+    do { \
+        __m256i ml0, ml1; \
+        ml0 = _mm256_mul_epu32(A0, B0); \
+        ml1 = _mm256_mul_epu32(A1, B1); \
+        ml0 = _mm256_add_epi64(ml0, ml0); \
+        ml1 = _mm256_add_epi64(ml1, ml1); \
+        A0 = _mm256_add_epi64(A0, _mm256_add_epi64(B0, ml0)); \
+        A1 = _mm256_add_epi64(A1, _mm256_add_epi64(B1, ml1)); \
+        D0 = _mm256_xor_si256(D0, A0); \
+        D1 = _mm256_xor_si256(D1, A1); \
+        D0 = rotr32(D0); \
+        D1 = rotr32(D1); \
+        ml0 = _mm256_mul_epu32(C0, D0); \
+        ml1 = _mm256_mul_epu32(C1, D1); \
+        ml0 = _mm256_add_epi64(ml0, ml0); \
+        ml1 = _mm256_add_epi64(ml1, ml1); \
+        C0 = _mm256_add_epi64(C0, _mm256_add_epi64(D0, ml0)); \
+        C1 = _mm256_add_epi64(C1, _mm256_add_epi64(D1, ml1)); \
+        B0 = _mm256_xor_si256(B0, C0); \
+        B1 = _mm256_xor_si256(B1, C1); \
+        B0 = rotr24(B0); \
+        B1 = rotr24(B1); \
+    } while((void)0, 0);
+
+#define G2_AVX2(A0, A1, B0, B1, C0, C1, D0, D1) \
+    do { \
+        __m256i ml0, ml1; \
+        ml0 = _mm256_mul_epu32(A0, B0); \
+        ml1 = _mm256_mul_epu32(A1, B1); \
+        ml0 = _mm256_add_epi64(ml0, ml0); \
+        ml1 = _mm256_add_epi64(ml1, ml1); \
+        A0 = _mm256_add_epi64(A0, _mm256_add_epi64(B0, ml0)); \
+        A1 = _mm256_add_epi64(A1, _mm256_add_epi64(B1, ml1)); \
+        D0 = _mm256_xor_si256(D0, A0); \
+        D1 = _mm256_xor_si256(D1, A1); \
+        D0 = rotr16(D0); \
+        D1 = rotr16(D1); \
+        ml0 = _mm256_mul_epu32(C0, D0); \
+        ml1 = _mm256_mul_epu32(C1, D1); \
+        ml0 = _mm256_add_epi64(ml0, ml0); \
+        ml1 = _mm256_add_epi64(ml1, ml1); \
+        C0 = _mm256_add_epi64(C0, _mm256_add_epi64(D0, ml0)); \
+        C1 = _mm256_add_epi64(C1, _mm256_add_epi64(D1, ml1)); \
+        B0 = _mm256_xor_si256(B0, C0); \
+        B1 = _mm256_xor_si256(B1, C1); \
+        B0 = rotr63(B0); \
+        B1 = rotr63(B1); \
+    } while((void)0, 0);
+
+#define DIAGONALIZE_1(A0, B0, C0, D0, A1, B1, C1, D1) \
+    do { \
+        B0 = _mm256_permute4x64_epi64(B0, _MM_SHUFFLE(0, 3, 2, 1)); \
+        C0 = _mm256_permute4x64_epi64(C0, _MM_SHUFFLE(1, 0, 3, 2)); \
+        D0 = _mm256_permute4x64_epi64(D0, _MM_SHUFFLE(2, 1, 0, 3)); \
+        \
+        B1 = _mm256_permute4x64_epi64(B1, _MM_SHUFFLE(0, 3, 2, 1)); \
+        C1 = _mm256_permute4x64_epi64(C1, _MM_SHUFFLE(1, 0, 3, 2)); \
+        D1 = _mm256_permute4x64_epi64(D1, _MM_SHUFFLE(2, 1, 0, 3)); \
+    } while((void)0, 0);
+
+#define DIAGONALIZE_2(A0, A1, B0, B1, C0, C1, D0, D1) \
+    do { \
+        __m256i tmp1 = _mm256_blend_epi32(B0, B1, 0xCC); \
+        __m256i tmp2 = _mm256_blend_epi32(B0, B1, 0x33); \
+        B1 = _mm256_permute4x64_epi64(tmp1, _MM_SHUFFLE(2,3,0,1)); \
+        tmp1 = C0; \
+        B0 = _mm256_permute4x64_epi64(tmp2, _MM_SHUFFLE(2,3,0,1)); \
+        C0 = C1; \
+        tmp2 = _mm256_blend_epi32(D0, D1, 0x33); \
+        C1 = tmp1; \
+        tmp1 = _mm256_blend_epi32(D0, D1, 0xCC); \
+        D1 = _mm256_permute4x64_epi64(tmp2, _MM_SHUFFLE(2,3,0,1)); \
+        D0 = _mm256_permute4x64_epi64(tmp1, _MM_SHUFFLE(2,3,0,1)); \
+    } while(0);
+
+#define UNDIAGONALIZE_1(A0, B0, C0, D0, A1, B1, C1, D1) \
+    do { \
+        B0 = _mm256_permute4x64_epi64(B0, _MM_SHUFFLE(2, 1, 0, 3)); \
+        C0 = _mm256_permute4x64_epi64(C0, _MM_SHUFFLE(1, 0, 3, 2)); \
+        D0 = _mm256_permute4x64_epi64(D0, _MM_SHUFFLE(0, 3, 2, 1)); \
+        \
+        B1 = _mm256_permute4x64_epi64(B1, _MM_SHUFFLE(2, 1, 0, 3)); \
+        C1 = _mm256_permute4x64_epi64(C1, _MM_SHUFFLE(1, 0, 3, 2)); \
+        D1 = _mm256_permute4x64_epi64(D1, _MM_SHUFFLE(0, 3, 2, 1)); \
+    } while((void)0, 0);
+
+#define UNDIAGONALIZE_2(A0, A1, B0, B1, C0, C1, D0, D1) \
+    do { \
+        __m256i tmp1 = _mm256_blend_epi32(B0, B1, 0xCC); \
+        __m256i tmp2 = _mm256_blend_epi32(B0, B1, 0x33); \
+        B0 = _mm256_permute4x64_epi64(tmp1, _MM_SHUFFLE(2,3,0,1)); \
+        tmp1 = C0; \
+        B1 = _mm256_permute4x64_epi64(tmp2, _MM_SHUFFLE(2,3,0,1)); \
+        C0 = C1; \
+        tmp2 = _mm256_blend_epi32(D0, D1, 0xCC); \
+        C1 = tmp1; \
+        tmp1 = _mm256_blend_epi32(D0, D1, 0x33); \
+        D1 = _mm256_permute4x64_epi64(tmp2, _MM_SHUFFLE(2,3,0,1)); \
+        D0 = _mm256_permute4x64_epi64(tmp1, _MM_SHUFFLE(2,3,0,1)); \
+    } while((void)0, 0);
+
+#define BLAKE2_ROUND_1(A0, A1, B0, B1, C0, C1, D0, D1) \
+    do{ \
+        G1_AVX2(A0, A1, B0, B1, C0, C1, D0, D1) \
+        G2_AVX2(A0, A1, B0, B1, C0, C1, D0, D1) \
+        \
+        DIAGONALIZE_1(A0, B0, C0, D0, A1, B1, C1, D1) \
+        \
+        G1_AVX2(A0, A1, B0, B1, C0, C1, D0, D1) \
+        G2_AVX2(A0, A1, B0, B1, C0, C1, D0, D1) \
+        \
+        UNDIAGONALIZE_1(A0, B0, C0, D0, A1, B1, C1, D1) \
+    } while((void)0, 0);
+
+#define BLAKE2_ROUND_2(A0, A1, B0, B1, C0, C1, D0, D1) \
+    do{ \
+        G1_AVX2(A0, A1, B0, B1, C0, C1, D0, D1) \
+        G2_AVX2(A0, A1, B0, B1, C0, C1, D0, D1) \
+        \
+        DIAGONALIZE_2(A0, A1, B0, B1, C0, C1, D0, D1) \
+        \
+        G1_AVX2(A0, A1, B0, B1, C0, C1, D0, D1) \
+        G2_AVX2(A0, A1, B0, B1, C0, C1, D0, D1) \
+        \
+        UNDIAGONALIZE_2(A0, A1, B0, B1, C0, C1, D0, D1) \
+    } while((void)0, 0);
+
+#endif /* __AVX2__ */
+
+#else /* __AVX512F__ */
+
+#include <immintrin.h>
+
+static inline __m512i muladd(__m512i x, __m512i y)
+{
+    __m512i z = _mm512_mul_epu32(x, y);
+    return _mm512_add_epi64(_mm512_add_epi64(x, y), _mm512_add_epi64(z, z));
+}
+
+#define G1(A0, B0, C0, D0, A1, B1, C1, D1) \
+    do { \
+        A0 = muladd(A0, B0); \
+        A1 = muladd(A1, B1); \
+\
+        D0 = _mm512_xor_si512(D0, A0); \
+        D1 = _mm512_xor_si512(D1, A1); \
+\
+        D0 = _mm512_ror_epi64(D0, 32); \
+        D1 = _mm512_ror_epi64(D1, 32); \
+\
+        C0 = muladd(C0, D0); \
+        C1 = muladd(C1, D1); \
+\
+        B0 = _mm512_xor_si512(B0, C0); \
+        B1 = _mm512_xor_si512(B1, C1); \
+\
+        B0 = _mm512_ror_epi64(B0, 24); \
+        B1 = _mm512_ror_epi64(B1, 24); \
+    } while ((void)0, 0)
+
+#define G2(A0, B0, C0, D0, A1, B1, C1, D1) \
+    do { \
+        A0 = muladd(A0, B0); \
+        A1 = muladd(A1, B1); \
+\
+        D0 = _mm512_xor_si512(D0, A0); \
+        D1 = _mm512_xor_si512(D1, A1); \
+\
+        D0 = _mm512_ror_epi64(D0, 16); \
+        D1 = _mm512_ror_epi64(D1, 16); \
+\
+        C0 = muladd(C0, D0); \
+        C1 = muladd(C1, D1); \
+\
+        B0 = _mm512_xor_si512(B0, C0); \
+        B1 = _mm512_xor_si512(B1, C1); \
+\
+        B0 = _mm512_ror_epi64(B0, 63); \
+        B1 = _mm512_ror_epi64(B1, 63); \
+    } while ((void)0, 0)
+
+#define DIAGONALIZE(A0, B0, C0, D0, A1, B1, C1, D1) \
+    do { \
+        B0 = _mm512_permutex_epi64(B0, _MM_SHUFFLE(0, 3, 2, 1)); \
+        B1 = _mm512_permutex_epi64(B1, _MM_SHUFFLE(0, 3, 2, 1)); \
+\
+        C0 = _mm512_permutex_epi64(C0, _MM_SHUFFLE(1, 0, 3, 2)); \
+        C1 = _mm512_permutex_epi64(C1, _MM_SHUFFLE(1, 0, 3, 2)); \
+\
+        D0 = _mm512_permutex_epi64(D0, _MM_SHUFFLE(2, 1, 0, 3)); \
+        D1 = _mm512_permutex_epi64(D1, _MM_SHUFFLE(2, 1, 0, 3)); \
+    } while ((void)0, 0)
+
+#define UNDIAGONALIZE(A0, B0, C0, D0, A1, B1, C1, D1) \
+    do { \
+        B0 = _mm512_permutex_epi64(B0, _MM_SHUFFLE(2, 1, 0, 3)); \
+        B1 = _mm512_permutex_epi64(B1, _MM_SHUFFLE(2, 1, 0, 3)); \
+\
+        C0 = _mm512_permutex_epi64(C0, _MM_SHUFFLE(1, 0, 3, 2)); \
+        C1 = _mm512_permutex_epi64(C1, _MM_SHUFFLE(1, 0, 3, 2)); \
+\
+        D0 = _mm512_permutex_epi64(D0, _MM_SHUFFLE(0, 3, 2, 1)); \
+        D1 = _mm512_permutex_epi64(D1, _MM_SHUFFLE(0, 3, 2, 1)); \
+    } while ((void)0, 0)
+
+#define BLAKE2_ROUND(A0, B0, C0, D0, A1, B1, C1, D1) \
+    do { \
+        G1(A0, B0, C0, D0, A1, B1, C1, D1); \
+        G2(A0, B0, C0, D0, A1, B1, C1, D1); \
+\
+        DIAGONALIZE(A0, B0, C0, D0, A1, B1, C1, D1); \
+\
+        G1(A0, B0, C0, D0, A1, B1, C1, D1); \
+        G2(A0, B0, C0, D0, A1, B1, C1, D1); \
+\
+        UNDIAGONALIZE(A0, B0, C0, D0, A1, B1, C1, D1); \
+    } while ((void)0, 0)
+
+#define SWAP_HALVES(A0, A1) \
+    do { \
+        __m512i t; \
+        t = _mm512_shuffle_i64x2(A0, A1, _MM_SHUFFLE(1, 0, 1, 0)); \
+        A1 = _mm512_shuffle_i64x2(A0, A1, _MM_SHUFFLE(3, 2, 3, 2)); \
+        A0 = t; \
+    } while((void)0, 0)
+
+#define SWAP_QUARTERS(A0, A1) \
+    do { \
+        SWAP_HALVES(A0, A1); \
+        A0 = _mm512_shuffle_i64x2( A0, A0, 0xd8 ); \
+        A1 = _mm512_shuffle_i64x2( A1, A1, 0xd8 ); \
+    } while((void)0, 0)
+
+#define UNSWAP_QUARTERS(A0, A1) \
+    do { \
+        A0 = _mm512_shuffle_i64x2( A0, A0, 0xd8 ); \
+        A1 = _mm512_shuffle_i64x2( A1, A1, 0xd8 ); \
+        SWAP_HALVES(A0, A1); \
+    } while((void)0, 0)
+
+#define BLAKE2_ROUND_1(A0, C0, B0, D0, A1, C1, B1, D1) \
+    do { \
+        SWAP_HALVES(A0, B0); \
+        SWAP_HALVES(C0, D0); \
+        SWAP_HALVES(A1, B1); \
+        SWAP_HALVES(C1, D1); \
+        BLAKE2_ROUND(A0, B0, C0, D0, A1, B1, C1, D1); \
+        SWAP_HALVES(A0, B0); \
+        SWAP_HALVES(C0, D0); \
+        SWAP_HALVES(A1, B1); \
+        SWAP_HALVES(C1, D1); \
+    } while ((void)0, 0)
+
+#define BLAKE2_ROUND_2(A0, A1, B0, B1, C0, C1, D0, D1) \
+    do { \
+        SWAP_QUARTERS(A0, A1); \
+        SWAP_QUARTERS(B0, B1); \
+        SWAP_QUARTERS(C0, C1); \
+        SWAP_QUARTERS(D0, D1); \
+        BLAKE2_ROUND(A0, B0, C0, D0, A1, B1, C1, D1); \
+        UNSWAP_QUARTERS(A0, A1); \
+        UNSWAP_QUARTERS(B0, B1); \
+        UNSWAP_QUARTERS(C0, C1); \
+        UNSWAP_QUARTERS(D0, D1); \
+    } while ((void)0, 0)
+
+#endif /* __AVX512F__ */
+
+#endif /* BLAKE_ROUND_MKA_OPT_H */

algo/argon2d/blake2/blamka-round-ref.h

@@ -1,10 +1,27 @@
+/*
+ * Argon2 reference source code package - reference C implementations
+ *
+ * Copyright 2015
+ * Daniel Dinu, Dmitry Khovratovich, Jean-Philippe Aumasson, and Samuel Neves
+ *
+ * You may use this work under the terms of a Creative Commons CC0 1.0
+ * License/Waiver or the Apache Public License 2.0, at your option. The terms of
+ * these licenses can be found at:
+ *
+ * - CC0 1.0 Universal : http://creativecommons.org/publicdomain/zero/1.0
+ * - Apache 2.0        : http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * You should have received a copy of both of these licenses along with this
+ * software. If not, they may be obtained at the above URLs.
+ */
+
 #ifndef BLAKE_ROUND_MKA_H
 #define BLAKE_ROUND_MKA_H
 
 #include "blake2.h"
 #include "blake2-impl.h"
 
-/*designed by the Lyra PHC team */
+/* designed by the Lyra PHC team */
 static BLAKE2_INLINE uint64_t fBlaMka(uint64_t x, uint64_t y) {
     const uint64_t m = UINT64_C(0xFFFFFFFF);
     const uint64_t xy = (x & m) * (y & m);

algo/blake/blake-4way.c

@@ -1,114 +1,120 @@
 #include "blake-gate.h"
-#include "sph_blake.h"
-#include "blake-hash-4way.h"
+#include "blake256-hash.h"
 #include <string.h>
 #include <stdint.h>
 #include <memory.h>
 
 #if defined (BLAKE_4WAY)
 
+blake256r14_4way_context blake_4w_ctx;
+
 void blakehash_4way(void *state, const void *input)
 {
-     uint32_t hash0[16] __attribute__ ((aligned (64)));
-     uint32_t hash1[16] __attribute__ ((aligned (64)));
-     uint32_t hash2[16] __attribute__ ((aligned (64)));
-     uint32_t hash3[16] __attribute__ ((aligned (64)));
-     uint32_t vhash[16*4] __attribute__ ((aligned (64)));
-     blake256_4way_context ctx;
-
-     blake256_4way_init( &ctx );
-     blake256_4way( &ctx, input, 16 );
-     blake256_4way_close( &ctx, vhash );
-
-     m128_deinterleave_4x32( hash0, hash1, hash2, hash3, vhash, 512 );
-
-     memcpy( state,    hash0, 32 );
-     memcpy( state+32, hash1, 32 );
-     memcpy( state+64, hash1, 32 );
-     memcpy( state+96, hash1, 32 );
+     uint32_t vhash[8*4] __attribute__ ((aligned (64)));
+     blake256r14_4way_context ctx;
+     memcpy( &ctx, &blake_4w_ctx, sizeof ctx );
+     blake256r14_4way_update( &ctx, input + (64<<2), 16 );
+     blake256r14_4way_close( &ctx, vhash );
+     dintrlv_4x32( state, state+32, state+64, state+96, vhash, 256 );
 }
 
-int scanhash_blake_4way( int thr_id, struct work *work, uint32_t max_nonce,
-                         uint64_t *hashes_done )
+int scanhash_blake_4way( struct work *work, uint32_t max_nonce,
+                         uint64_t *hashes_done, struct thr_info *mythr )
 {
    uint32_t vdata[20*4] __attribute__ ((aligned (64)));
-   uint32_t hash[4*8] __attribute__ ((aligned (64)));
+   uint32_t hash[8*4] __attribute__ ((aligned (32)));
    uint32_t *pdata = work->data;
    uint32_t *ptarget = work->target;
    const uint32_t first_nonce = pdata[19];
-//   uint32_t HTarget = ptarget[7];
-   uint32_t _ALIGN(32) endiandata[20];
+   uint32_t HTarget = ptarget[7];
+   __m128i  *noncev = (__m128i*)vdata + 19;   // aligned
    uint32_t n = first_nonce;
-   uint32_t *nonces = work->nonces;
-   bool *found = work->nfound;
-   int num_found = 0;
+   int thr_id = mythr->id;  // thr_id arg is deprecated
 
-//   if (opt_benchmark)
-//      HTarget = 0x7f;
+   if (opt_benchmark)
+      HTarget = 0x7f;
 
-   // we need big endian data...
-   swab32_array( endiandata, pdata, 20 );
+   v128_bswap32_intrlv80_4x32( vdata, pdata );
+   blake256r14_4way_init( &blake_4w_ctx );
+   blake256r14_4way_update( &blake_4w_ctx, vdata, 64 );
 
-   m128_interleave_4x32( vdata, endiandata, endiandata, endiandata,
-                         endiandata, 640 );
-
-   uint32_t *noncep = vdata + 76;   // 19*4
    do {
-      found[0] = found[1] = found[2] = found[3] = false;
-      be32enc( noncep,    n   );
-      be32enc( noncep +2, n+1 );
-      be32enc( noncep +4, n+2 );
-      be32enc( noncep +6, n+3 );
+      *noncev = mm128_bswap_32( _mm_set_epi32( n+3, n+2, n+1, n ) );
 
       blakehash_4way( hash, vdata );
 
-      if ( hash[7] == 0 )
+      for ( int i = 0; i < 4; i++ )
+      if ( (hash+(i<<3))[7] <= HTarget )
+      if ( fulltest( hash+(i<<3), ptarget ) && !opt_benchmark )
       {
-         if ( fulltest( hash, ptarget ) )
-         {
-             found[0] = true;
-             num_found++;
-             nonces[0] = n;
-             pdata[19] = n;
-         }
+          pdata[19] = n+i;
+          submit_solution( work, hash+(i<<3), mythr );
       }
-      if ( (hash+8)[7] == 0 ) 
-      {
-         if ( fulltest( hash, ptarget ) ) 
-         {
-             found[1] = true;
-             num_found++;
-             nonces[1] = n+1;
-         }
-      }
-      if ( (hash+16)[7] == 0 )
-      {
-          if ( fulltest( hash, ptarget ) )
-          {
-              found[2] = true;
-              num_found++;
-              nonces[2] = n+2;
-          }
-      }
-      if ( (hash+24)[7] == 0 )
-      {
-         if ( fulltest( hash, ptarget ) )
-         {
-              found[3] = true;
-              num_found++;
-              nonces[3] = n+3;
-         }
-      }
- 
       n += 4;
-      *hashes_done = n - first_nonce + 1;
-
-   } while ( (num_found == 0) && (n < max_nonce) 
-             && !work_restart[thr_id].restart );
 
+   } while ( (n < max_nonce) && !work_restart[thr_id].restart );
    *hashes_done = n - first_nonce + 1;
-   return num_found;
+   return 0;
 }
 
 #endif
 
+#if defined(BLAKE_8WAY)
+
+blake256r14_8way_context blake_8w_ctx;
+
+void blakehash_8way( void *state, const void *input )
+{
+     uint32_t vhash[8*8] __attribute__ ((aligned (64)));
+     blake256r14_8way_context ctx;
+     memcpy( &ctx, &blake_8w_ctx, sizeof ctx );
+     blake256r14_8way( &ctx, input + (64<<3), 16 );
+     blake256r14_8way_close( &ctx, vhash );
+     _dintrlv_8x32( state,     state+ 32, state+ 64, state+ 96,
+                    state+128, state+160, state+192, state+224,
+                    vhash, 256 );
+}
+
+int scanhash_blake_8way( struct work *work, uint32_t max_nonce,
+                         uint64_t *hashes_done, struct thr_info *mythr )
+{
+   uint32_t vdata[20*8] __attribute__ ((aligned (64)));
+   uint32_t hash[8*8] __attribute__ ((aligned (32)));
+   uint32_t *pdata = work->data;
+   uint32_t *ptarget = work->target;
+   const uint32_t first_nonce = pdata[19];
+   uint32_t HTarget = ptarget[7];
+   uint32_t n = first_nonce;
+   __m256i  *noncev = (__m256i*)vdata + 19;   // aligned
+   int thr_id = mythr->id;  // thr_id arg is deprecated
+
+   if (opt_benchmark)
+      HTarget = 0x7f;
+
+   mm256_bswap32_intrlv80_8x32( vdata, pdata );
+
+   blake256r14_8way_init( &blake_8w_ctx );
+   blake256r14_8way( &blake_8w_ctx, vdata, 64 );
+
+   do {
+      *noncev = mm256_bswap_32( _mm256_set_epi32( n+7, n+6, n+5, n+4,
+                                                  n+3, n+2, n+1, n ) );
+      pdata[19] = n;
+
+      blakehash_8way( hash, vdata );
+
+      for ( int i = 0; i < 8; i++ )
+      if ( (hash+i)[7] <= HTarget && fulltest( hash+i, ptarget ) )
+      {
+          pdata[19] = n+i;
+          submit_solution( work, hash+(i<<3), mythr );
+      }
+      n += 8;
+
+   } while ( (n < max_nonce) !work_restart[thr_id].restart );
+
+   *hashes_done = n - first_nonce + 1;
+   return 0;
+}
+
+#endif

algo/blake/blake-gate.c

@@ -1,23 +1,13 @@
 #include "blake-gate.h"
 
-int64_t blake_get_max64 ()
-{
-  return 0x7ffffLL;
-}
-
 bool register_blake_algo( algo_gate_t* gate )
 {
-  gate->get_max64 = (void*)&blake_get_max64;
-//#if defined (__AVX2__) && defined (FOUR_WAY)
-//   gate->optimizations = SSE2_OPT | AVX_OPT | AVX2_OPT;
-//  gate->scanhash  = (void*)&scanhash_blake_8way;
-//  gate->hash      = (void*)&blakehash_8way;
+  gate->optimizations = AVX2_OPT;
 #if defined(BLAKE_4WAY)
-  gate->optimizations = SSE2_OPT | AVX_OPT;
+  four_way_not_tested();
   gate->scanhash  = (void*)&scanhash_blake_4way;
   gate->hash      = (void*)&blakehash_4way;
 #else
-  gate->optimizations = SSE2_OPT;
   gate->scanhash  = (void*)&scanhash_blake;
   gate->hash      = (void*)&blakehash;
 #endif

algo/blake/blake-gate.h

@@ -4,18 +4,18 @@
 #include "algo-gate-api.h"
 #include <stdint.h>
 
-#if defined(FOUR_WAY) && defined(__AVX__)
+#if defined(__AVX2__)
   #define BLAKE_4WAY
 #endif
 
 #if defined (BLAKE_4WAY)
 void blakehash_4way(void *state, const void *input);
-int scanhash_blake_4way( int thr_id, struct work *work, uint32_t max_nonce,
-                         uint64_t *hashes_done );
+int scanhash_blake_4way( struct work *work, uint32_t max_nonce,
+                         uint64_t *hashes_done, struct thr_info *mythr );
 #endif
 
 void blakehash( void *state, const void *input );
-int scanhash_blake( int thr_id, struct work *work, uint32_t max_nonce,
-                      uint64_t *hashes_done );
+int scanhash_blake( struct work *work, uint32_t max_nonce,
+                      uint64_t *hashes_done, struct thr_info *mythr );
 
 #endif

algo/blake/blake-hash-4way.h

@@ -1,105 +0,0 @@
-/* $Id: sph_blake.h 252 2011-06-07 17:55:14Z tp $ */
-/**
- * BLAKE interface. BLAKE is a family of functions which differ by their
- * output size; this implementation defines BLAKE for output sizes 224,
- * 256, 384 and 512 bits. This implementation conforms to the "third
- * round" specification.
- *
- * ==========================(LICENSE BEGIN)============================
- *
- * Copyright (c) 2007-2010  Projet RNRT SAPHIR
- * 
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- * 
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
- * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- * ===========================(LICENSE END)=============================
- *
- * @file     sph_blake.h
- * @author   Thomas Pornin <thomas.pornin@cryptolog.com>
- */
-
-#ifndef __BLAKE_HASH_4WAY__
-#define __BLAKE_HASH_4WAY___
-
-#ifdef __cplusplus
-extern "C"{
-#endif
-
-#include <stddef.h>
-#include "algo/sha/sph_types.h"
-#include "avxdefs.h"
-
-/**
- * Output size (in bits) for BLAKE-256.
- */
-#define SPH_SIZE_blake256   256
-
-#if SPH_64
-
-/**
- * Output size (in bits) for BLAKE-512.
- */
-#define SPH_SIZE_blake512   512
-
-#endif
-
-#ifdef __AVX__
-typedef struct {
-        __m128i buf[16] __attribute__ ((aligned (64)));
-        __m128i H[8];
-        __m128i S[4];    
-        size_t ptr;
-	sph_u32 T0, T1;
-} blake_4way_small_context;
-
-typedef blake_4way_small_context blake256_4way_context;
-
-void blake256_4way_init(void *cc);
-void blake256_4way(void *cc, const void *data, size_t len);
-void blake256_4way_close(void *cc, void *dst);
-void blake256_4way_addbits_and_close(
-        void *cc, unsigned ub, unsigned n, void *dst);
-
-#endif
-
-#ifdef __AVX2__
-
-typedef struct {
-        __m256i buf[16] __attribute__ ((aligned (64)));
-        __m256i H[8];
-        __m256i S[4];   
-        size_t ptr;
-	sph_u64 T0, T1;
-} blake_4way_big_context;
-
-typedef blake_4way_big_context blake512_4way_context;
-
-void blake512_4way_init(void *cc);
-void blake512_4way(void *cc, const void *data, size_t len);
-void blake512_4way_close(void *cc, void *dst);
-void blake512_4way_addbits_and_close(
-	void *cc, unsigned ub, unsigned n, void *dst);
-
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

algo/blake/blake.c

@@ -39,8 +39,8 @@ void blakehash(void *state, const void *input)
 
 }
 
-int scanhash_blake( int thr_id, struct work *work, uint32_t max_nonce,
-                      uint64_t *hashes_done )
+int scanhash_blake( struct work *work, uint32_t max_nonce,
+                      uint64_t *hashes_done, struct thr_info *mythr )
 {
         uint32_t *pdata = work->data;
         uint32_t *ptarget = work->target;
@@ -49,6 +49,7 @@ int scanhash_blake( int thr_id, struct work *work, uint32_t max_nonce,
 	uint32_t _ALIGN(32) hash64[8];
 	uint32_t _ALIGN(32) endiandata[20];
 	uint32_t n = first_nonce;
+   int thr_id = mythr->id;  // thr_id arg is deprecated
 
 	ctx_midstate_done = false;
 

algo/blake/blake256-hash.h

@@ -0,0 +1,210 @@
+#ifndef BLAKE256_HASH__
+#define BLAKE256_HASH__ 1
+
+#include <stddef.h>
+#include "simd-utils.h"
+#include "sph_blake.h"
+
+////////////////////////////
+//
+//  Blake-256 1 way SSE2
+//
+
+//#define blake256_context    sph_blake256_context
+#define blake256_init       sph_blake256_init
+#define blake256_update     sph_blake256
+#define blake256_update_le  sph_blake256_update_le
+#define blake256_close      sph_blake256_close
+
+//TODO decouple from SPH
+
+typedef struct
+{
+   unsigned char buf[64];  
+   size_t ptr;
+   uint32_t H[8];
+   uint32_t S[4];
+   uint32_t T0, T1;
+} blake256_context __attribute__ ((aligned (32)));
+
+void blake256_transform_le( uint32_t *H, const uint32_t *buf,
+                            const uint32_t T0, const uint32_t T1, int rounds );
+/*
+void blake256_init( blake256_context *sc );
+void blake256_update( blake256_context *sc, const void *data, size_t len );
+void blake256_close( blake256_context *sc, void *dst );
+void blake256_full( blake256_context *sc, void *dst, const void *data,
+                    size_t len );
+*/
+
+//////////////////////////////////
+//
+//   Blake-256 4 way SSE2, NEON
+
+typedef struct
+{
+   unsigned char buf[64<<2];
+   uint32_t H[8<<2];
+   size_t ptr;
+   uint32_t T0, T1;
+   int rounds;   // 14 for blake, 8 for blakecoin & vanilla
+} blake_4x32_small_context __attribute__ ((aligned (64)));
+
+// Default, 14 rounds
+typedef blake_4x32_small_context blake256_4x32_context;
+void blake256_4x32_init(void *ctx);
+void blake256_4x32_update(void *ctx, const void *data, size_t len);
+void blake256_4x32_close(void *ctx, void *dst);
+
+// 14 rounds
+typedef blake_4x32_small_context blake256r14_4x32_context;
+void blake256r14_4x32_init(void *cc);
+void blake256r14_4x32_update(void *cc, const void *data, size_t len);
+void blake256r14_4x32_close(void *cc, void *dst);
+
+// 8 rounds, blakecoin, vanilla
+typedef blake_4x32_small_context blake256r8_4x32_context;
+void blake256r8_4x32_init(void *cc);
+void blake256r8_4x32_update(void *cc, const void *data, size_t len);
+void blake256r8_4x32_close(void *cc, void *dst);
+
+void blake256_4x32_round0_prehash_le( void *midstate, const void *midhash,
+                                      void *data );
+void blake256_4x32_final_rounds_le( void *final_hash, const void *midstate,
+                     const void *midhash, const void *data, const int rounds );
+
+#define blake_4way_small_context         blake256_4x32_context
+#define blake256_4way_context            blake256_4x32_context
+#define blake256_4way_init               blake256_4x32_init
+#define blake256_4way_update             blake256_4x32_update
+#define blake256_4way_close              blake256_4x32_close
+#define blake256_4way_update_le          blake256_4x32_update_le
+#define blake256_4way_close_le           blake256_4x32_close_le
+#define blake256_4way_round0_prehash_le  blake256_4x32_round0_prehash_le
+#define blake256_4way_final_rounds_le    blake256_4x32_final_rounds_le
+#define blake256r14_4way_context         blake256r14_4x32_context
+#define blake256r14_4way_init            blake256r14_4x32_init
+#define blake256r14_4way_update          blake256r14_4x32_update
+#define blake256r14_4way_close           blake256r14_4x32_close
+#define blake256r8_4way_context          blake256r14_4x32_context
+#define blake256r8_4way_init             blake256r14_4x32_init
+#define blake256r8_4way_update           blake256r14_4x32_update
+#define blake256r8_4way_close            blake256r14_4x32_close
+
+#ifdef __AVX2__
+
+//////////////////////////////
+//
+//   Blake-256 8 way AVX2
+
+typedef struct
+{
+   __m256i buf[16] __attribute__ ((aligned (64)));
+   __m256i H[8];
+   size_t ptr;
+   uint32_t T0, T1;
+   int rounds;   // 14 for blake, 8 for blakecoin & vanilla
+} blake_8way_small_context;
+
+// Default 14 rounds
+typedef blake_8way_small_context blake256_8way_context;
+void blake256_8way_init(void *cc);
+void blake256_8way_update(void *cc, const void *data, size_t len);
+void blake256_8way_close(void *cc, void *dst);
+void blake256_8way_update_le(void *cc, const void *data, size_t len);
+void blake256_8way_close_le(void *cc, void *dst);
+void blake256_8way_round0_prehash_le( void *midstate, const void *midhash,
+                                      void *data );
+void blake256_8way_final_rounds_le( void *final_hash, const void *midstate,
+                    const void *midhash, const void *data, const int rounds );
+
+// 14 rounds, blake, decred
+typedef blake_8way_small_context blake256r14_8way_context;
+void blake256r14_8way_init(void *cc);
+void blake256r14_8way_update(void *cc, const void *data, size_t len);
+void blake256r14_8way_close(void *cc, void *dst);
+
+// 8 rounds, blakecoin, vanilla
+typedef blake_8way_small_context blake256r8_8way_context;
+void blake256r8_8way_init(void *cc);
+void blake256r8_8way_update(void *cc, const void *data, size_t len);
+void blake256r8_8way_close(void *cc, void *dst);
+
+#define blake_8x32_small_context      blake256_8way_context
+#define blake_8x32_init               blake256_8way_init
+#define blake_8x32_update             blake256_8way_update
+#define blake_8x32_close              blake256_8way_close
+#define blake_8x32_update_le          blake256_8way_update_le
+#define blake_8x32_close_le           blake256_8way_close_le
+#define blake_8x32_round0_prehash_le  blake256_8way_round0_prehash
+#define blake_8x32_final_rounds_le    blake256_8way_final_rounds_le
+#define blake256r14_8x32_context      blake256r14_8way_context
+#define blake256r14_8x32_init         blake256r14_8way_init
+#define blake256r14_8x32_update       blake256r14_8way_update
+#define blake256r14_8x32_close        blake256r14_8way_close
+#define blake256r8_8x32_context       blake256r14_8way_context
+#define blake256r8_8x32_init          blake256r14_8way_init
+#define blake256r8_8x32_update        blake256r14_8way_update
+#define blake256r8_8x32_close         blake256r14_8way_close
+
+#if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
+
+///////////////////////////////////
+//
+//   Blake-256 16 way AVX512
+
+typedef struct
+{
+   __m512i buf[16];
+   __m512i H[8];
+   size_t ptr;
+   uint32_t T0, T1;
+   int rounds;   // 14 for blake, 8 for blakecoin & vanilla
+} blake_16way_small_context __attribute__ ((aligned (128)));
+
+// Default 14 rounds
+typedef blake_16way_small_context blake256_16way_context;
+void blake256_16way_init(void *cc);
+void blake256_16way_update(void *cc, const void *data, size_t len);
+void blake256_16way_close(void *cc, void *dst);
+// Expects data in little endian order, no byte swap needed
+void blake256_16way_update_le(void *cc, const void *data, size_t len);
+void blake256_16way_close_le(void *cc, void *dst);
+void blake256_16way_round0_prehash_le( void *midstate, const void *midhash,
+                                       void *data );
+void blake256_16way_final_rounds_le( void *final_hash, const void *midstate,
+                     const void *midhash, const void *data, const int rounds );
+
+// 14 rounds, blake, decred
+typedef blake_16way_small_context blake256r14_16way_context;
+void blake256r14_16way_init(void *cc);
+void blake256r14_16way_update(void *cc, const void *data, size_t len);
+void blake256r14_16way_close(void *cc, void *dst);
+
+// 8 rounds, blakecoin, vanilla
+typedef blake_16way_small_context blake256r8_16way_context;
+void blake256r8_16way_init(void *cc);
+void blake256r8_16way_update(void *cc, const void *data, size_t len);
+void blake256r8_16way_close(void *cc, void *dst);
+
+#define blake_16x32_small_context      blake256_16way_context
+#define blake_16x32_init               blake256_16way_init
+#define blake_16x32_update             blake256_16way_update
+#define blake_16x32_close              blake256_16way_close
+#define blake_16x32_update_le          blake256_16way_update_le
+#define blake_16x32_close_le           blake256_16way_close_le
+#define blake_16x32_round0_prehash_le  blake256_16way_round0_prehash
+#define blake_16x32_final_rounds_le    blake256_16way_final_rounds_le
+#define blake256r14_16x32_context      blake256r14_16way_context
+#define blake256r14_16x32_init         blake256r14_16way_init
+#define blake256r14_16x32_update       blake256r14_16way_update
+#define blake256r14_16x32_close        blake256r14_16way_close
+#define blake256r8_16x32_context       blake256r8_16way_context
+#define blake256r8_16x32_init          blake256r8_16way_init
+#define blake256r8_16x32_update        blake256r8_16way_update
+#define blake256r8_16x32_close         blake256r8_16way_close
+
+#endif  // AVX512
+#endif  // AVX2
+
+#endif  // BLAKE256_HASH_H__

algo/blake/blake2b-hash.c

@@ -0,0 +1,548 @@
+/*
+ * Copyright 2009 Colin Percival, 2014 savale
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * This file was originally written by Colin Percival as part of the Tarsnap
+ * online backup system.
+ */
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "blake2b-hash.h"
+
+#if defined(__AVX2__)
+
+static const uint8_t sigma[12][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 },
+      { 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 }
+};
+
+
+#define Z00   0
+#define Z01   1
+#define Z02   2
+#define Z03   3
+#define Z04   4
+#define Z05   5
+#define Z06   6
+#define Z07   7
+#define Z08   8
+#define Z09   9
+#define Z0A   A
+#define Z0B   B
+#define Z0C   C
+#define Z0D   D
+#define Z0E   E
+#define Z0F   F
+
+#define Z10   E
+#define Z11   A
+#define Z12   4
+#define Z13   8
+#define Z14   9
+#define Z15   F
+#define Z16   D
+#define Z17   6
+#define Z18   1
+#define Z19   C
+#define Z1A   0
+#define Z1B   2
+#define Z1C   B
+#define Z1D   7
+#define Z1E   5
+#define Z1F   3
+
+#define Z20   B
+#define Z21   8
+#define Z22   C
+#define Z23   0
+#define Z24   5
+#define Z25   2
+#define Z26   F
+#define Z27   D
+#define Z28   A
+#define Z29   E
+#define Z2A   3
+#define Z2B   6
+#define Z2C   7
+#define Z2D   1
+#define Z2E   9
+#define Z2F   4
+
+#define Z30   7
+#define Z31   9
+#define Z32   3
+#define Z33   1
+#define Z34   D
+#define Z35   C
+#define Z36   B
+#define Z37   E
+#define Z38   2
+#define Z39   6
+#define Z3A   5
+#define Z3B   A
+#define Z3C   4
+#define Z3D   0
+#define Z3E   F
+#define Z3F   8
+
+#define Z40   9
+#define Z41   0
+#define Z42   5
+#define Z43   7
+#define Z44   2
+#define Z45   4
+#define Z46   A
+#define Z47   F
+#define Z48   E
+#define Z49   1
+#define Z4A   B
+#define Z4B   C
+#define Z4C   6
+#define Z4D   8
+#define Z4E   3
+#define Z4F   D
+
+#define Z50   2
+#define Z51   C
+#define Z52   6
+#define Z53   A
+#define Z54   0
+#define Z55   B
+#define Z56   8
+#define Z57   3
+#define Z58   4
+#define Z59   D
+#define Z5A   7
+#define Z5B   5
+#define Z5C   F
+#define Z5D   E
+#define Z5E   1
+#define Z5F   9
+
+#define Z60   C
+#define Z61   5
+#define Z62   1
+#define Z63   F
+#define Z64   E
+#define Z65   D
+#define Z66   4
+#define Z67   A
+#define Z68   0
+#define Z69   7
+#define Z6A   6
+#define Z6B   3
+#define Z6C   9
+#define Z6D   2
+#define Z6E   8
+#define Z6F   B
+
+#define Z70   D
+#define Z71   B
+#define Z72   7
+#define Z73   E
+#define Z74   C
+#define Z75   1
+#define Z76   3
+#define Z77   9
+#define Z78   5
+#define Z79   0
+#define Z7A   F
+#define Z7B   4
+#define Z7C   8
+#define Z7D   6
+#define Z7E   2
+#define Z7F   A
+
+#define Z80   6
+#define Z81   F
+#define Z82   E
+#define Z83   9
+#define Z84   B
+#define Z85   3
+#define Z86   0
+#define Z87   8
+#define Z88   C
+#define Z89   2
+#define Z8A   D
+#define Z8B   7
+#define Z8C   1
+#define Z8D   4
+#define Z8E   A
+#define Z8F   5
+
+#define Z90   A
+#define Z91   2
+#define Z92   8
+#define Z93   4
+#define Z94   7
+#define Z95   6
+#define Z96   1
+#define Z97   5
+#define Z98   F
+#define Z99   B
+#define Z9A   9
+#define Z9B   E
+#define Z9C   3
+#define Z9D   C
+#define Z9E   D
+#define Z9F   0
+
+#define Mx(r, i)    Mx_(Z ## r ## i)
+#define Mx_(n)      Mx__(n)
+#define Mx__(n)     M ## n
+
+#if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
+
+#define B2B8W_G(a, b, c, d, x, y) \
+{ \
+   v[a] = _mm512_add_epi64( _mm512_add_epi64( v[a], v[b] ), x ); \
+   v[d] = mm512_ror_64( _mm512_xor_si512( v[d], v[a] ), 32 ); \
+   v[c] = _mm512_add_epi64( v[c], v[d] ); \
+   v[b] = mm512_ror_64( _mm512_xor_si512( v[b], v[c] ), 24 ); \
+   v[a] = _mm512_add_epi64( _mm512_add_epi64( v[a], v[b] ), y ); \
+   v[d] = mm512_ror_64( _mm512_xor_si512( v[d], v[a] ), 16 ); \
+   v[c] = _mm512_add_epi64( v[c], v[d] ); \
+   v[b] = mm512_ror_64( _mm512_xor_si512( v[b], v[c] ), 63 ); \
+}
+
+static void blake2b_8way_compress( blake2b_8way_ctx *ctx, int last )
+{  
+   __m512i v[16], m[16];
+
+   v[ 0] = ctx->h[0];
+   v[ 1] = ctx->h[1];
+   v[ 2] = ctx->h[2];
+   v[ 3] = ctx->h[3];
+   v[ 4] = ctx->h[4];
+   v[ 5] = ctx->h[5];
+   v[ 6] = ctx->h[6];
+   v[ 7] = ctx->h[7];
+   v[ 8] = v512_64( 0x6A09E667F3BCC908 );
+   v[ 9] = v512_64( 0xBB67AE8584CAA73B );
+   v[10] = v512_64( 0x3C6EF372FE94F82B );
+   v[11] = v512_64( 0xA54FF53A5F1D36F1 );
+   v[12] = v512_64( 0x510E527FADE682D1 );
+   v[13] = v512_64( 0x9B05688C2B3E6C1F );
+   v[14] = v512_64( 0x1F83D9ABFB41BD6B );
+   v[15] = v512_64( 0x5BE0CD19137E2179 );
+
+   v[12] = _mm512_xor_si512( v[12], v512_64( ctx->t[0] ) );
+   v[13] = _mm512_xor_si512( v[13], v512_64( ctx->t[1] ) );
+
+   if ( last )
+      v[14] = mm512_not( v[14] );
+
+   m[ 0] = ctx->b[ 0];
+   m[ 1] = ctx->b[ 1];
+   m[ 2] = ctx->b[ 2];
+   m[ 3] = ctx->b[ 3];
+   m[ 4] = ctx->b[ 4];
+   m[ 5] = ctx->b[ 5];
+   m[ 6] = ctx->b[ 6];
+   m[ 7] = ctx->b[ 7];
+   m[ 8] = ctx->b[ 8];
+   m[ 9] = ctx->b[ 9];
+   m[10] = ctx->b[10];
+   m[11] = ctx->b[11];
+   m[12] = ctx->b[12];
+   m[13] = ctx->b[13];
+   m[14] = ctx->b[14];
+   m[15] = ctx->b[15];
+
+   for ( int i = 0; i < 12; i++ )
+   {
+      B2B8W_G( 0, 4,  8, 12, m[ sigma[i][ 0] ], m[ sigma[i][ 1] ] );
+      B2B8W_G( 1, 5,  9, 13, m[ sigma[i][ 2] ], m[ sigma[i][ 3] ] );
+      B2B8W_G( 2, 6, 10, 14, m[ sigma[i][ 4] ], m[ sigma[i][ 5] ] );
+      B2B8W_G( 3, 7, 11, 15, m[ sigma[i][ 6] ], m[ sigma[i][ 7] ] );
+      B2B8W_G( 0, 5, 10, 15, m[ sigma[i][ 8] ], m[ sigma[i][ 9] ] );
+      B2B8W_G( 1, 6, 11, 12, m[ sigma[i][10] ], m[ sigma[i][11] ] );
+      B2B8W_G( 2, 7,  8, 13, m[ sigma[i][12] ], m[ sigma[i][13] ] );
+      B2B8W_G( 3, 4,  9, 14, m[ sigma[i][14] ], m[ sigma[i][15] ] );
+   }
+
+   ctx->h[0] = mm512_xor3( ctx->h[0], v[0], v[ 8] );
+   ctx->h[1] = mm512_xor3( ctx->h[1], v[1], v[ 9] );
+   ctx->h[2] = mm512_xor3( ctx->h[2], v[2], v[10] );
+   ctx->h[3] = mm512_xor3( ctx->h[3], v[3], v[11] );
+   ctx->h[4] = mm512_xor3( ctx->h[4], v[4], v[12] );
+   ctx->h[5] = mm512_xor3( ctx->h[5], v[5], v[13] );
+   ctx->h[6] = mm512_xor3( ctx->h[6], v[6], v[14] );
+   ctx->h[7] = mm512_xor3( ctx->h[7], v[7], v[15] );
+}
+
+int blake2b_8way_init( blake2b_8way_ctx *ctx )
+{
+   size_t i;
+
+   ctx->h[0] = v512_64( 0x6A09E667F3BCC908 );
+   ctx->h[1] = v512_64( 0xBB67AE8584CAA73B );
+   ctx->h[2] = v512_64( 0x3C6EF372FE94F82B );
+   ctx->h[3] = v512_64( 0xA54FF53A5F1D36F1 );
+   ctx->h[4] = v512_64( 0x510E527FADE682D1 );
+   ctx->h[5] = v512_64( 0x9B05688C2B3E6C1F );
+   ctx->h[6] = v512_64( 0x1F83D9ABFB41BD6B );
+   ctx->h[7] = v512_64( 0x5BE0CD19137E2179 );
+
+   ctx->h[0] = _mm512_xor_si512( ctx->h[0], v512_64( 0x01010020 ) );
+
+   ctx->t[0] = 0;
+   ctx->t[1] = 0;
+   ctx->c = 0;
+   ctx->outlen = 32;
+
+   for ( i = 0; i < 16; i++ )
+     ctx->b[i] = m512_zero;
+
+   return 0;
+}
+
+
+void blake2b_8way_update( blake2b_8way_ctx *ctx, const void *input,
+                          size_t inlen )
+{
+   __m512i* in =(__m512i*)input;
+
+   size_t i, c;
+   c = ctx->c >> 3;
+
+   for ( i = 0; i < (inlen >> 3); i++ )
+   {
+      if ( ctx->c == 128 )
+      {
+         ctx->t[0] += ctx->c;
+         if ( ctx->t[0] < ctx->c )
+            ctx->t[1]++;
+         blake2b_8way_compress( ctx, 0 );
+         ctx->c = 0;
+      }
+      ctx->b[ c++ ] = in[i];
+      ctx->c += 8;
+   }
+}
+
+void blake2b_8way_final( blake2b_8way_ctx *ctx, void *out )
+{
+   size_t c;
+   c = ctx->c >> 3;
+
+   ctx->t[0] += ctx->c;
+   if ( ctx->t[0] < ctx->c )
+      ctx->t[1]++;
+
+   while ( ctx->c < 128 )
+   {
+      ctx->b[c++] = m512_zero;
+      ctx->c += 8;
+   }
+
+   blake2b_8way_compress( ctx, 1 );           // final block flag = 1
+
+   casti_m512i( out, 0 ) = ctx->h[0];
+   casti_m512i( out, 1 ) = ctx->h[1];
+   casti_m512i( out, 2 ) = ctx->h[2];
+   casti_m512i( out, 3 ) = ctx->h[3];
+}
+
+#endif   // AVX512
+
+// AVX2
+
+// G Mixing function.
+
+#define B2B_G(a, b, c, d, x, y) \
+{ \
+   v[a] = _mm256_add_epi64( _mm256_add_epi64( v[a], v[b] ), x ); \
+	v[d] = mm256_ror_64( _mm256_xor_si256( v[d], v[a] ), 32 ); \
+	v[c] = _mm256_add_epi64( v[c], v[d] ); \
+	v[b] = mm256_ror_64( _mm256_xor_si256( v[b], v[c] ), 24 ); \
+	v[a] = _mm256_add_epi64( _mm256_add_epi64( v[a], v[b] ), y ); \
+	v[d] = mm256_ror_64( _mm256_xor_si256( v[d], v[a] ), 16 ); \
+	v[c] = _mm256_add_epi64( v[c], v[d] ); \
+	v[b] = mm256_ror_64( _mm256_xor_si256( v[b], v[c] ), 63 ); \
+}
+
+// Initialization Vector.
+/*
+static const uint64_t blake2b_iv[8] = {
+	0x6A09E667F3BCC908, 0xBB67AE8584CAA73B,
+	0x3C6EF372FE94F82B, 0xA54FF53A5F1D36F1,
+	0x510E527FADE682D1, 0x9B05688C2B3E6C1F,
+	0x1F83D9ABFB41BD6B, 0x5BE0CD19137E2179
+};
+*/
+
+static void blake2b_4way_compress( blake2b_4way_ctx *ctx, int last )
+{
+	__m256i v[16], m[16];
+
+   v[ 0] = ctx->h[0];
+   v[ 1] = ctx->h[1];
+   v[ 2] = ctx->h[2];
+   v[ 3] = ctx->h[3];
+   v[ 4] = ctx->h[4];
+   v[ 5] = ctx->h[5];
+   v[ 6] = ctx->h[6];
+   v[ 7] = ctx->h[7];
+   v[ 8] = v256_64( 0x6A09E667F3BCC908 );
+   v[ 9] = v256_64( 0xBB67AE8584CAA73B );
+   v[10] = v256_64( 0x3C6EF372FE94F82B );
+   v[11] = v256_64( 0xA54FF53A5F1D36F1 );
+   v[12] = v256_64( 0x510E527FADE682D1 );
+   v[13] = v256_64( 0x9B05688C2B3E6C1F );
+   v[14] = v256_64( 0x1F83D9ABFB41BD6B );
+   v[15] = v256_64( 0x5BE0CD19137E2179 );
+
+   v[12] = _mm256_xor_si256( v[12], v256_64( ctx->t[0] ) );
+   v[13] = _mm256_xor_si256( v[13], v256_64( ctx->t[1] ) );
+
+   if ( last )   
+		v[14] = mm256_not( v[14] );
+
+   m[ 0] = ctx->b[ 0];
+   m[ 1] = ctx->b[ 1];
+   m[ 2] = ctx->b[ 2];
+   m[ 3] = ctx->b[ 3];
+   m[ 4] = ctx->b[ 4];
+   m[ 5] = ctx->b[ 5];
+   m[ 6] = ctx->b[ 6];
+   m[ 7] = ctx->b[ 7];
+   m[ 8] = ctx->b[ 8];
+   m[ 9] = ctx->b[ 9];
+   m[10] = ctx->b[10];
+   m[11] = ctx->b[11];
+   m[12] = ctx->b[12];
+   m[13] = ctx->b[13];
+   m[14] = ctx->b[14];
+   m[15] = ctx->b[15];
+   
+	for ( int i = 0; i < 12; i++ )
+   { 
+		B2B_G( 0, 4,  8, 12, m[ sigma[i][ 0] ], m[ sigma[i][ 1] ] );
+		B2B_G( 1, 5,  9, 13, m[ sigma[i][ 2] ], m[ sigma[i][ 3] ] );
+		B2B_G( 2, 6, 10, 14, m[ sigma[i][ 4] ], m[ sigma[i][ 5] ] );
+		B2B_G( 3, 7, 11, 15, m[ sigma[i][ 6] ], m[ sigma[i][ 7] ] );
+		B2B_G( 0, 5, 10, 15, m[ sigma[i][ 8] ], m[ sigma[i][ 9] ] );
+		B2B_G( 1, 6, 11, 12, m[ sigma[i][10] ], m[ sigma[i][11] ] );
+		B2B_G( 2, 7,  8, 13, m[ sigma[i][12] ], m[ sigma[i][13] ] );
+		B2B_G( 3, 4,  9, 14, m[ sigma[i][14] ], m[ sigma[i][15] ] );
+	}
+
+   ctx->h[0] = _mm256_xor_si256( _mm256_xor_si256( ctx->h[0], v[0] ), v[ 8] );
+   ctx->h[1] = _mm256_xor_si256( _mm256_xor_si256( ctx->h[1], v[1] ), v[ 9] );
+   ctx->h[2] = _mm256_xor_si256( _mm256_xor_si256( ctx->h[2], v[2] ), v[10] );
+   ctx->h[3] = _mm256_xor_si256( _mm256_xor_si256( ctx->h[3], v[3] ), v[11] );
+   ctx->h[4] = _mm256_xor_si256( _mm256_xor_si256( ctx->h[4], v[4] ), v[12] );
+   ctx->h[5] = _mm256_xor_si256( _mm256_xor_si256( ctx->h[5], v[5] ), v[13] );
+   ctx->h[6] = _mm256_xor_si256( _mm256_xor_si256( ctx->h[6], v[6] ), v[14] );
+   ctx->h[7] = _mm256_xor_si256( _mm256_xor_si256( ctx->h[7], v[7] ), v[15] );
+}
+
+int blake2b_4way_init( blake2b_4way_ctx *ctx ) 
+{
+	size_t i;
+
+   ctx->h[0] = v256_64( 0x6A09E667F3BCC908 );
+   ctx->h[1] = v256_64( 0xBB67AE8584CAA73B );
+   ctx->h[2] = v256_64( 0x3C6EF372FE94F82B );
+   ctx->h[3] = v256_64( 0xA54FF53A5F1D36F1 );
+   ctx->h[4] = v256_64( 0x510E527FADE682D1 );
+   ctx->h[5] = v256_64( 0x9B05688C2B3E6C1F );
+   ctx->h[6] = v256_64( 0x1F83D9ABFB41BD6B );
+   ctx->h[7] = v256_64( 0x5BE0CD19137E2179 );
+
+   ctx->h[0] = _mm256_xor_si256( ctx->h[0], v256_64( 0x01010020 ) );
+
+	ctx->t[0] = 0;
+	ctx->t[1] = 0;
+	ctx->c = 0;
+	ctx->outlen = 32;
+
+   for ( i = 0; i < 16; i++ )
+     ctx->b[i] = m256_zero;
+
+	return 0;
+}
+
+void blake2b_4way_update( blake2b_4way_ctx *ctx, const void *input,
+                          size_t inlen ) 
+{
+   __m256i* in =(__m256i*)input;
+
+	size_t i, c;
+   c = ctx->c >> 3; 
+
+	for ( i = 0; i < (inlen >> 3); i++ )
+   {
+		if ( ctx->c == 128 )
+      { 
+			ctx->t[0] += ctx->c;
+			if ( ctx->t[0] < ctx->c )
+				ctx->t[1]++;
+			blake2b_4way_compress( ctx, 0 );
+			ctx->c = 0;
+		}
+      ctx->b[ c++ ] = in[i];
+      ctx->c += 8;
+   }
+}
+
+void blake2b_4way_final( blake2b_4way_ctx *ctx, void *out )
+{
+	size_t c;
+   c = ctx->c >> 3;
+
+	ctx->t[0] += ctx->c;
+	if ( ctx->t[0] < ctx->c )
+		ctx->t[1]++;
+
+	while ( ctx->c < 128 )
+   {
+      ctx->b[c++] = m256_zero;
+      ctx->c += 8;
+   }
+
+   blake2b_4way_compress( ctx, 1 );           // final block flag = 1
+
+   casti_m256i( out, 0 ) = ctx->h[0];
+   casti_m256i( out, 1 ) = ctx->h[1];
+   casti_m256i( out, 2 ) = ctx->h[2];
+   casti_m256i( out, 3 ) = ctx->h[3];
+}
+
+#endif  // AVX2

algo/blake/blake2b-hash.h

@@ -0,0 +1,53 @@
+#pragma once
+#ifndef __BLAKE2B_HASH_4WAY_H__
+#define __BLAKE2B_HASH_4WAY_H__
+
+#include "simd-utils.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
+
+
+#if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
+
+typedef struct ALIGN( 64 ) {
+   __m512i b[16]; // input buffer
+   __m512i h[8];  // chained state
+   uint64_t t[2];  // total number of bytes
+   size_t c;       // pointer for b[]
+   size_t outlen;  // digest size
+} blake2b_8way_ctx;
+
+int blake2b_8way_init( blake2b_8way_ctx *ctx );
+void blake2b_8way_update( blake2b_8way_ctx *ctx, const void *input,
+                          size_t inlen );
+void blake2b_8way_final( blake2b_8way_ctx *ctx, void *out );
+
+#endif
+
+#if defined(__AVX2__)
+
+// state context
+typedef struct ALIGN( 64 ) {
+	__m256i b[16]; // input buffer
+	__m256i h[8];  // chained state
+	uint64_t t[2];  // total number of bytes
+	size_t c;       // pointer for b[]
+	size_t outlen;  // digest size
+} blake2b_4way_ctx;
+
+int blake2b_4way_init( blake2b_4way_ctx *ctx );
+void blake2b_4way_update( blake2b_4way_ctx *ctx, const void *input,
+                          size_t inlen );
+void blake2b_4way_final( blake2b_4way_ctx *ctx, void *out );
+
+#endif
+
+#endif

algo/blake/blake2b.c

@@ -1,230 +1,175 @@
-/**
- * Blake2-B Implementation
- * tpruvot@github 2015-2016
- */
-
 #include "algo-gate-api.h"
 #include <string.h>
 #include <stdint.h>
-#include "algo/blake/sph_blake2b.h"
+#include "blake2b-hash.h"
 
-//static __thread sph_blake2b_ctx s_midstate;
-//static __thread sph_blake2b_ctx s_ctx;
-#define MIDLEN 76
-#define A 64
+#if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
+  #define BLAKE2B_8WAY
+#elif defined(__AVX2__)
+  #define BLAKE2B_4WAY
+#endif
 
-void blake2b_hash(void *output, const void *input)
+#if defined(BLAKE2B_8WAY)
+
+int scanhash_blake2b_8way( struct work *work, uint32_t max_nonce,
+                           uint64_t *hashes_done, struct thr_info *mythr )
 {
-	uint8_t _ALIGN(A) hash[32];
-	sph_blake2b_ctx ctx __attribute__ ((aligned (64)));
+   uint32_t hash[8*8] __attribute__ ((aligned (128)));;
+   uint32_t vdata[20*8] __attribute__ ((aligned (64)));;
+   uint32_t lane_hash[8] __attribute__ ((aligned (64)));
+   blake2b_8way_ctx ctx __attribute__ ((aligned (64)));
+   uint32_t *hash7 = &(hash[49]);   // 3*16+1
+   uint32_t *pdata = work->data;
+   uint32_t *ptarget = work->target;
+   int thr_id = mythr->id;
+   __m512i  *noncev = (__m512i*)vdata + 9;   // aligned
+   const uint32_t Htarg = ptarget[7];
+   const uint32_t first_nonce = pdata[19];
 
-	sph_blake2b_init(&ctx, 32, NULL, 0);
-	sph_blake2b_update(&ctx, input, 80);
-	sph_blake2b_final(&ctx, hash);
+   uint32_t n = first_nonce;
 
-	memcpy(output, hash, 32);
+   mm512_bswap32_intrlv80_8x64( vdata, pdata );
+
+   do {
+      *noncev = mm512_intrlv_blend_32( mm512_bswap_32(
+                _mm512_set_epi32( n+7, 0, n+6, 0, n+5, 0, n+4, 0,
+                                  n+3, 0, n+2, 0, n+1, 0, n  , 0 ) ), *noncev );
+
+      blake2b_8way_init( &ctx );
+      blake2b_8way_update( &ctx, vdata, 80 );
+      blake2b_8way_final( &ctx, hash );
+
+      for ( int lane = 0; lane < 8; lane++ )
+      if ( hash7[ lane<<1 ] <= Htarg )
+      {
+          extr_lane_8x64( lane_hash, hash, lane, 256 );
+          if ( fulltest( lane_hash, ptarget ) && !opt_benchmark )
+          {
+              pdata[19] = n + lane;
+              submit_solution( work, lane_hash, mythr );
+          }
+      }
+      n += 8;
+   } while ( (n < max_nonce-8) && !work_restart[thr_id].restart);
+
+   *hashes_done = n - first_nonce + 1;
+   return 0;
 }
 
-/*
-static void blake2b_hash_end(uint32_t *output, const uint32_t *input)
-{
-	s_ctx.outlen = MIDLEN;
-	memcpy(&s_ctx, &s_midstate, 32 + 16 + MIDLEN);
-	sph_blake2b_update(&s_ctx, (uint8_t*) &input[MIDLEN/4], 80 - MIDLEN);
-	sph_blake2b_final(&s_ctx, (uint8_t*) output);
-}
-*/
+#elif defined(BLAKE2B_4WAY)
 
-int scanhash_blake2b( int thr_id, struct work *work, uint32_t max_nonce,
-                      uint64_t *hashes_done )
+// Function not used, code inlined.
+void blake2b_4way_hash(void *output, const void *input)
 {
-	uint32_t _ALIGN(A) vhashcpu[8];
-	uint32_t _ALIGN(A) endiandata[20];
+    blake2b_4way_ctx ctx;
+    blake2b_4way_init( &ctx );
+    blake2b_4way_update( &ctx, input, 80 );
+    blake2b_4way_final( &ctx, output );
+}
+
+int scanhash_blake2b_4way( struct work *work, uint32_t max_nonce,
+                           uint64_t *hashes_done, struct thr_info *mythr )
+{
+	uint32_t hash[8*4] __attribute__ ((aligned (64)));;
+   uint32_t vdata[20*4] __attribute__ ((aligned (32)));;
+   uint32_t lane_hash[8] __attribute__ ((aligned (32)));
+   blake2b_4way_ctx ctx __attribute__ ((aligned (32)));
+   uint32_t *hash7 = &(hash[25]);   // 3*8+1
 	uint32_t *pdata = work->data;
 	uint32_t *ptarget = work->target;
-
+   int thr_id = mythr->id;
+   __m256i  *noncev = (__m256i*)vdata + 9;   // aligned
 	const uint32_t Htarg = ptarget[7];
-	const uint32_t first_nonce = pdata[8];
+	const uint32_t first_nonce = pdata[19];
 
 	uint32_t n = first_nonce;
 
-	for (int i=0; i < 19; i++) {
-		be32enc(&endiandata[i], pdata[i]);
-	}
-
-	// midstate (untested yet)
-	//blake2b_init(&s_midstate, 32, NULL, 0);
-	//blake2b_update(&s_midstate, (uint8_t*) endiandata, MIDLEN);
-	//memcpy(&s_ctx, &s_midstate, sizeof(blake2b_ctx));
+   mm256_bswap32_intrlv80_4x64( vdata, pdata );
 
 	do {
-		be32enc(&endiandata[8], n);
-		//blake2b_hash_end(vhashcpu, endiandata);
-		blake2b_hash(vhashcpu, endiandata);
+      *noncev = mm256_intrlv_blend_32( mm256_bswap_32(
+                _mm256_set_epi32( n+3, 0, n+2, 0, n+1, 0, n, 0 ) ), *noncev );
 
-		if (vhashcpu[7] < Htarg && fulltest(vhashcpu, ptarget)) {
-			work_set_target_ratio(work, vhashcpu);
-			*hashes_done = n - first_nonce + 1;
-			pdata[8] = n;
-			return 1;
-		}
-		n++;
+      blake2b_4way_init( &ctx ); 
+      blake2b_4way_update( &ctx, vdata, 80 );
+      blake2b_4way_final( &ctx, hash );
 
-	} while (n < max_nonce && !work_restart[thr_id].restart);
-	*hashes_done = n - first_nonce + 1;
-	pdata[8] = n;
+      for ( int lane = 0; lane < 4; lane++ )
+      if ( hash7[ lane<<1 ] <= Htarg )
+      {
+          extr_lane_4x64( lane_hash, hash, lane, 256 );
+          if ( fulltest( lane_hash, ptarget ) && !opt_benchmark )
+          {
+              pdata[19] = n + lane;
+              submit_solution( work, lane_hash, mythr );
+          }
+      }
+      n += 4;
+   } while ( (n < max_nonce-4) && !work_restart[thr_id].restart);
 
-	return 0;
+   *hashes_done = n - first_nonce + 1;
+   return 0;
 }
 
-static inline void swab256(void *dest_p, const void *src_p)
+#else
+
+#include "algo/blake/sph_blake2b.h"
+
+void blake2b_hash(void *output, const void *input)
 {
-	uint32_t *dest = (uint32_t *)dest_p;
-	const uint32_t *src = (uint32_t *)src_p;
+   uint8_t _ALIGN(32) hash[32];
+   sph_blake2b_ctx ctx __attribute__ ((aligned (32)));
 
-	dest[0] = swab32(src[7]);
-	dest[1] = swab32(src[6]);
-	dest[2] = swab32(src[5]);
-	dest[3] = swab32(src[4]);
-	dest[4] = swab32(src[3]);
-	dest[5] = swab32(src[2]);
-	dest[6] = swab32(src[1]);
-	dest[7] = swab32(src[0]);
+   sph_blake2b_init(&ctx, 32, NULL, 0);
+   sph_blake2b_update(&ctx, input, 80);
+   sph_blake2b_final(&ctx, hash);
+
+   memcpy(output, hash, 32);
 }
 
-/* compute nbits to get the network diff */
-void blake2b_calc_network_diff(struct work *work)
+int scanhash_blake2b( struct work *work, uint32_t max_nonce,
+                      uint64_t *hashes_done, struct thr_info *mythr )
 {
-        // sample for diff 43.281 : 1c05ea29
-        uint32_t nbits = work->data[11]; // unsure if correct
-        uint32_t bits = (nbits & 0xffffff);
-        int16_t shift = (swab32(nbits) & 0xff); // 0x1c = 28
+   uint32_t _ALIGN(32) hash64[8];
+   uint32_t _ALIGN(32) endiandata[20];
+   uint32_t *pdata = work->data;
+   uint32_t *ptarget = work->target;
+   int thr_id = mythr->id; 
+   const uint32_t first_nonce = pdata[19];
+   uint32_t n = first_nonce;
 
-        double d = (double)0x0000ffff / (double)bits;
-        for (int m=shift; m < 29; m++) d *= 256.0;
-        for (int m=29; m < shift; m++) d /= 256.0;
-        if (opt_debug_diff)
-                applog(LOG_DEBUG, "net diff: %f -> shift %u, bits %08x", d, shift, bits);
-        net_diff = d;
+   v128_bswap32_80( endiandata, pdata );
+
+   do {
+      endiandata[19] = n;
+      blake2b_hash( hash64, endiandata );
+      if ( unlikely( valid_hash( hash64, ptarget ) ) && !opt_benchmark )
+      {
+         pdata[19] = bswap_32( n );
+         submit_solution( work, hash64, mythr );
+      }
+      n++;
+   } while (n < max_nonce && !work_restart[thr_id].restart);
+   *hashes_done = n - first_nonce + 1;
+   pdata[19] = n;
+
+   return 0;
 }
 
-void blake2b_be_build_stratum_request( char *req, struct work *work )
-{
-   unsigned char *xnonce2str;
-   uint32_t ntime,       nonce;
-   char     ntimestr[9], noncestr[9];
-   be32enc( &ntime, work->data[ algo_gate.ntime_index ] );
-   be32enc( &nonce, work->data[ algo_gate.nonce_index ] );
-   bin2hex( ntimestr, (char*)(&ntime), sizeof(uint32_t) );
-   bin2hex( noncestr, (char*)(&nonce), sizeof(uint32_t) );
-   uint16_t high_nonce = swab32(work->data[9]) >> 16;
-   xnonce2str = abin2hex((unsigned char*)(&high_nonce), 2);
-   snprintf( req, JSON_BUF_LEN,
-        "{\"method\": \"mining.submit\", \"params\": [\"%s\", \"%s\", \"%s\", \"%s\", \"%s\"], \"id\":4}",
-         rpc_user, work->job_id, xnonce2str, ntimestr, noncestr );
-   free( xnonce2str );
-}
-
-#define min(a,b) (a>b ? (b) :(a))
-
-// merkle root handled here, no need for gen_merkle_root gate target
-void blake2b_build_extraheader( struct work* g_work, struct stratum_ctx* sctx )
-{
-    uchar merkle_root[64] = { 0 };
-    uint32_t extraheader[32] = { 0 };
-    int headersize = 0;
-    size_t t;
-    int i;
-
-    // merkle root
-    memcpy( merkle_root, sctx->job.coinbase, 32 );
-    headersize = min( (int)sctx->job.coinbase_size - 32, sizeof(extraheader) );
-    memcpy( extraheader, &sctx->job.coinbase[32], headersize );
-    // Increment extranonce2 
-    for ( t = 0; t < sctx->xnonce2_size && !( ++sctx->job.xnonce2[t] ); t++ );
-    // Assemble block header 
-    memset( g_work->data, 0, sizeof(g_work->data) );
-//    g_work->data[0] = le32dec( sctx->job.version );
-//    for ( i = 0; i < 8; i++ )
-//       g_work->data[1 + i] = le32dec( (uint32_t *) sctx->job.prevhash + i );
-    for ( i = 0; i < 8; i++ )
-       g_work->data[i] = ((uint32_t*)sctx->job.prevhash)[7-i];
-//    for ( i = 0; i < 8; i++ )
-//       g_work->data[9 + i] = be32dec( (uint32_t *) merkle_root + i );
-    g_work->data[8]  = 0; // nonce
-    g_work->data[9]  = swab32( extraheader[0] ) | ( rand() & 0xf0 );
-    g_work->data[10] = be32dec( sctx->job.ntime );
-    g_work->data[11] = be32dec( sctx->job.nbits );
-    for ( i = 0; i < 8; i++ )
-       g_work->data[12+i] = ( (uint32_t*)merkle_root )[i];
-}
-
-#undef min
-
-void blake2b_get_new_work( struct work* work, struct work* g_work, int thr_id,
-                           uint32_t* end_nonce_ptr, bool clean_job )
-{
-   const int wkcmp_sz = 32;  // bytes
-   const int wkcmp_off = 32 + 16; 
-   uint32_t *nonceptr = algo_gate.get_nonceptr( work->data );
-
-   if ( memcmp( &work->data[ wkcmp_off ], &g_work->data[ wkcmp_off ], wkcmp_sz )
-      && ( clean_job || ( *nonceptr >= *end_nonce_ptr ) 
-      || strcmp( work->job_id, g_work->job_id ) ) )
-   {
-      work_free( work );
-      work_copy( work, g_work );
-      *nonceptr = ( 0xffffffffU / opt_n_threads ) * thr_id;
-      if ( opt_randomize )
-         *nonceptr += ( (rand() *4 ) & UINT32_MAX ) / opt_n_threads;
-      *end_nonce_ptr = ( 0xffffffffU / opt_n_threads ) * (thr_id+1) - 0x20;
-   }
-   else
-       ++(*nonceptr);
-
-   // suprnova job_id check without data/target/height change...
-   // we just may have copied new g_wwork to work so why this test here?
-//   if (  have_stratum && strcmp( work->job_id, g_work->job_id ) )
-      // exit thread loop
-//      continue;
-//   else
-//   {
-//      nonceptr[1] += 0x10;
-//      nonceptr[1] |= thr_id;
-//   }
-}
-
-bool blake2b_ready_to_mine( struct work* work, struct stratum_ctx* stratum,
-                           int thr_id )
-{
-   if ( have_stratum && strcmp( stratum->job.job_id, work->job_id ) )
-      // need to regen g_work..
-      return false;
-   // extradata: prevent duplicates
-   work->data[ 8     ] += 0x10;
-   work->data[ 8 + 1 ] |= thr_id;
-   return true;
-}
-
-double blake2b_get_max64() { return 0x1fffffLL; }
+#endif
 
 bool register_blake2b_algo( algo_gate_t* gate )
 {
-  algo_not_tested();
-  gate->ntime_index   = 10;
-  gate->nbits_index   = 11;
-  gate->nonce_index   =  8;
-  gate->work_cmp_size = 32;
-  gate->scanhash              = (void*)&scanhash_blake2b;
-  gate->hash                  = (void*)&blake2b_hash;
-  gate->calc_network_diff     = (void*)&blake2b_calc_network_diff;
-  gate->build_stratum_request = (void*)&blake2b_be_build_stratum_request;
-  gate->work_decode           = (void*)&std_be_work_decode;
-  gate->submit_getwork_result = (void*)&std_be_submit_getwork_result;
-  gate->build_extraheader     = (void*)&blake2b_build_extraheader;
-  gate->get_new_work          = (void*)&blake2b_get_new_work;
-  gate->get_max64             = (void*)&blake2b_get_max64;
-  gate->ready_to_mine         = (void*)&blake2b_ready_to_mine;
-  have_gbt = false;
+#if defined(BLAKE2B_8WAY)
+  gate->scanhash  = (void*)&scanhash_blake2b_8way;
+#elif defined(BLAKE2B_4WAY)
+  gate->scanhash  = (void*)&scanhash_blake2b_4way;
+  gate->hash      = (void*)&blake2b_4way_hash;
+#else
+  gate->scanhash  = (void*)&scanhash_blake2b;
+  gate->hash      = (void*)&blake2b_hash;
+#endif
+  gate->optimizations =  AVX2_OPT | AVX512_OPT;
   return true;
-}
+};
+

algo/blake/blake2s-hash.c

@@ -0,0 +1,689 @@
+/**
+ * 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 "blake2s-hash.h"
+#include "simd-utils.h"
+#include <stdint.h>
+#include <string.h>
+#include <stdio.h>
+
+//#if defined(__SSE4_2__)
+#if defined(__SSE2__) || defined(__ARM_NEON)
+
+/*
+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 } ,
+};
+
+
+// define a constant for initial param.
+
+int blake2s_4way_init( blake2s_4way_state *S, const uint8_t outlen )
+{
+   blake2s_nway_param P[1];
+
+   P->digest_length = outlen;
+   P->key_length    = 0;
+   P->fanout        = 1;
+   P->depth         = 1;
+   P->leaf_length   = 0;    
+   *((uint64_t*)(P->node_offset)) = 0;
+   P->node_depth    = 0;
+   P->inner_length  = 0;
+   memset( P->salt,     0, sizeof( P->salt ) );
+   memset( P->personal, 0, sizeof( P->personal ) );
+
+   memset( S, 0, sizeof( blake2s_4way_state ) );
+
+   S->h[0] = v128_64( 0x6A09E6676A09E667ULL );
+   S->h[1] = v128_64( 0xBB67AE85BB67AE85ULL );
+   S->h[2] = v128_64( 0x3C6EF3723C6EF372ULL );
+   S->h[3] = v128_64( 0xA54FF53AA54FF53AULL );
+   S->h[4] = v128_64( 0x510E527F510E527FULL );
+   S->h[5] = v128_64( 0x9B05688C9B05688CULL );
+   S->h[6] = v128_64( 0x1F83D9AB1F83D9ABULL );
+   S->h[7] = v128_64( 0x5BE0CD195BE0CD19ULL );
+   
+//   for( int i = 0; i < 8; ++i )
+//      S->h[i] = v128_32( blake2s_IV[i] );
+
+   uint32_t *p = ( uint32_t * )( P );
+
+   /* IV XOR ParamBlock */
+   for ( size_t i = 0; i < 8; ++i )
+      S->h[i] = v128_xor( S->h[i], v128_32( p[i] ) );
+   return 0;
+}
+
+int blake2s_4way_compress( blake2s_4way_state *S, const v128_t* block )
+{
+   v128_t m[16];
+   v128_t v[16];
+
+   v128_memcpy( m, block, 16 );
+   v128_memcpy( v, S->h, 8 );
+
+   v[ 8] = v128_64( 0x6A09E6676A09E667ULL );
+   v[ 9] = v128_64( 0xBB67AE85BB67AE85ULL );
+   v[10] = v128_64( 0x3C6EF3723C6EF372ULL );
+   v[11] = v128_64( 0xA54FF53AA54FF53AULL );
+   v[12] = v128_xor( v128_32( S->t[0] ),
+                          v128_64( 0x510E527F510E527FULL ) );
+   v[13] = v128_xor( v128_32( S->t[1] ),
+                          v128_64( 0x9B05688C9B05688CULL ) );
+   v[14] = v128_xor( v128_32( S->f[0] ),
+                          v128_64( 0x1F83D9AB1F83D9ABULL ) );
+   v[15] = v128_xor( v128_32( S->f[1] ),
+                          v128_64( 0x5BE0CD195BE0CD19ULL ) );
+
+#define G4W( sigma0, sigma1, a, b, c, d ) \
+do { \
+   uint8_t s0 = sigma0; \
+   uint8_t s1 = sigma1; \
+   a = v128_add32( v128_add32( a, b ), m[ s0 ] ); \
+   d = v128_ror32( v128_xor( d, a ), 16 ); \
+   c = v128_add32( c, d ); \
+   b = v128_ror32( v128_xor( b, c ), 12 ); \
+   a = v128_add32( v128_add32( a, b ), m[ s1 ] ); \
+   d = v128_ror32( v128_xor( d, a ),  8 ); \
+   c = v128_add32( c, d ); \
+   b = v128_ror32( v128_xor( b, c ),  7 ); \
+} while(0)
+
+
+#define ROUND4W(r)  \
+do { \
+   uint8_t *sigma = (uint8_t*)&blake2s_sigma[r]; \
+   G4W( sigma[ 0], sigma[ 1], v[ 0], v[ 4], v[ 8], v[12] ); \
+   G4W( sigma[ 2], sigma[ 3], v[ 1], v[ 5], v[ 9], v[13] ); \
+   G4W( sigma[ 4], sigma[ 5], v[ 2], v[ 6], v[10], v[14] ); \
+   G4W( sigma[ 6], sigma[ 7], v[ 3], v[ 7], v[11], v[15] ); \
+   G4W( sigma[ 8], sigma[ 9], v[ 0], v[ 5], v[10], v[15] ); \
+   G4W( sigma[10], sigma[11], v[ 1], v[ 6], v[11], v[12] ); \
+   G4W( sigma[12], sigma[13], v[ 2], v[ 7], v[ 8], v[13] ); \
+   G4W( sigma[14], sigma[15], v[ 3], v[ 4], v[ 9], v[14] ); \
+} while(0)
+
+   ROUND4W( 0 );
+   ROUND4W( 1 );
+   ROUND4W( 2 );
+   ROUND4W( 3 );
+   ROUND4W( 4 );
+   ROUND4W( 5 );
+   ROUND4W( 6 );
+   ROUND4W( 7 );
+   ROUND4W( 8 );
+   ROUND4W( 9 );
+
+   for( size_t i = 0; i < 8; ++i )
+      S->h[i] = v128_xor( v128_xor( S->h[i], v[i] ), v[i + 8] );
+
+#undef G4W
+#undef ROUND4W
+   return 0;
+}
+
+// There is a problem that can't be resolved internally.
+// If the last block is a full 64 bytes it should not be compressed in
+// update but left for final. However, when streaming, it isn't known
+// which block is last. There may be a subsequent call to update to add
+// more data.
+//
+// The reference code handled this by juggling 2 blocks at a time at
+// a significant performance penalty.
+//
+// Instead a new function is introduced called full_blocks which combines
+// update and final and is to be used in non-streaming mode where the data
+// is a multiple of 64 bytes.
+// 
+// Supported:
+//    64 + 16 bytes  (blake2s with midstate optimization)
+//    80 bytes       (blake2s without midstate optimization)
+//    Any multiple of 64 bytes in one shot (x25x)
+//
+// Unsupported:
+//    Stream of full 64 byte blocks one at a time.   
+
+// use only when streaming more data or final block not full.
+int blake2s_4way_update( blake2s_4way_state *S, const void *in,
+                         uint64_t inlen )
+{
+   v128_t *input = (v128_t*)in;
+   v128_t *buf = (v128_t*)S->buf;
+
+   while( inlen > 0 )
+   {
+      size_t left = S->buflen;
+      if( inlen >= 64 - left )
+      {
+         v128_memcpy( buf + (left>>2), input, (64 - left) >> 2 );
+         S->buflen += 64 - left;
+         S->t[0] += 64;
+         S->t[1] += ( S->t[0] < 64 );
+         blake2s_4way_compress( S, buf ); 
+         S->buflen = 0;
+         input += ( 64 >> 2 );
+         inlen -= 64;
+      }
+      else
+      {
+          v128_memcpy( buf + ( left>>2 ), input, inlen>>2 );
+          S->buflen += (size_t) inlen; 
+          input += ( inlen>>2 );
+          inlen -= inlen;
+      }
+   }
+   return 0;
+}
+
+int blake2s_4way_final( blake2s_4way_state *S, void *out, uint8_t outlen )
+{
+   v128_t *buf = (v128_t*)S->buf;
+
+   S->t[0] += S->buflen;
+   S->t[1] += ( S->t[0] < S->buflen );
+   if ( S->last_node ) 
+      S->f[1] = ~0U;
+   S->f[0] = ~0U;
+
+   v128_memset_zero( buf + ( S->buflen>>2 ),
+                    ( 64 - S->buflen ) >> 2 );      
+   blake2s_4way_compress( S, buf );
+
+   for ( int i = 0; i < 8; ++i )
+      casti_v128( out, i ) = S->h[ i ];
+   return 0;
+}
+
+// Update and final when inlen is a multiple of 64 bytes
+int blake2s_4way_full_blocks( blake2s_4way_state *S, void *out,
+                              const void *input, uint64_t inlen )
+{
+    v128_t *in = (v128_t*)input;
+    v128_t *buf = (v128_t*)S->buf;
+
+    while( inlen > 64 )
+    {
+       v128_memcpy( buf, in, 64 >> 2 );
+       S->buflen = 64;
+       inlen -= 64;
+       S->t[0] += 64;
+       S->t[1] += ( S->t[0] < 64 );
+       blake2s_4way_compress( S, buf );
+       S->buflen = 0;
+       in += ( 64 >> 2 );
+    }
+
+    // last block
+    v128_memcpy( buf, in, 64 >> 2 );
+    S->buflen = 64;
+    S->t[0] += S->buflen;
+    S->t[1] += ( S->t[0] < S->buflen );
+    if ( S->last_node )  S->f[1] = ~0U;
+    S->f[0] = ~0U;
+    blake2s_4way_compress( S, buf );
+
+    for ( int i = 0; i < 8; ++i )
+      casti_v128( out, i ) = S->h[ i ];
+    return 0;
+}
+
+#if defined(__AVX2__)
+
+// The commented code below is slower on Intel but faster on
+// Zen1 AVX2. It's also faster than Zen1 AVX.
+// Ryzen gen2 is unknown at this time.
+ 
+int blake2s_8way_compress( blake2s_8way_state *S, const __m256i *block )
+{
+   __m256i m[16];
+   __m256i v[16];
+
+   memcpy_256( m, block, 16 );
+   memcpy_256( v, S->h, 8 );
+
+   v[ 8] = v256_64( 0x6A09E6676A09E667ULL );
+   v[ 9] = v256_64( 0xBB67AE85BB67AE85ULL );
+   v[10] = v256_64( 0x3C6EF3723C6EF372ULL );
+   v[11] = v256_64( 0xA54FF53AA54FF53AULL );
+   v[12] = _mm256_xor_si256( v256_32( S->t[0] ),
+                          v256_64( 0x510E527F510E527FULL ) );
+
+   v[13] = _mm256_xor_si256( v256_32( S->t[1] ),
+                          v256_64( 0x9B05688C9B05688CULL ) );
+
+   v[14] = _mm256_xor_si256( v256_32( S->f[0] ),
+                          v256_64( 0x1F83D9AB1F83D9ABULL ) );
+
+   v[15] = _mm256_xor_si256( v256_32( S->f[1] ),
+                          v256_64( 0x5BE0CD195BE0CD19ULL ) );
+
+/*
+   v[ 8] = v256_32( blake2s_IV[0] );
+   v[ 9] = v256_32( blake2s_IV[1] );
+   v[10] = v256_32( blake2s_IV[2] );
+   v[11] = v256_32( blake2s_IV[3] );
+   v[12] = _mm256_xor_si256( v256_32( S->t[0] ),
+                             v256_32( blake2s_IV[4] ) );
+   v[13] = _mm256_xor_si256( v256_32( S->t[1] ),
+                             v256_32( blake2s_IV[5] ) );
+   v[14] = _mm256_xor_si256( v256_32( S->f[0] ),
+                             v256_32( blake2s_IV[6] ) );
+   v[15] = _mm256_xor_si256( v256_32( S->f[1] ),
+                             v256_32( blake2s_IV[7] ) );
+
+
+#define G8W(r,i,a,b,c,d) \
+do { \
+   a = _mm256_add_epi32( _mm256_add_epi32( a, b ), \
+                          m[ blake2s_sigma[r][2*i+0] ] ); \
+   d = mm256_ror_32( _mm256_xor_si256( d, a ), 16 ); \
+   c = _mm256_add_epi32( c, d ); \
+   b = mm256_ror_32( _mm256_xor_si256( b, c ), 12 ); \
+   a = _mm256_add_epi32( _mm256_add_epi32( a, b ), \
+                         m[ blake2s_sigma[r][2*i+1] ] ); \
+   d = mm256_ror_32( _mm256_xor_si256( d, a ),  8 ); \
+   c = _mm256_add_epi32( c, d ); \
+   b = mm256_ror_32( _mm256_xor_si256( b, c ),  7 ); \
+} while(0)
+*/
+
+#define G8W( sigma0, sigma1, a, b, c, d) \
+do { \
+   uint8_t s0 = sigma0; \
+   uint8_t s1 = sigma1; \
+   a = _mm256_add_epi32( _mm256_add_epi32( a, b ), m[ s0 ] ); \
+   d = mm256_ror_32( _mm256_xor_si256( d, a ), 16 ); \
+   c = _mm256_add_epi32( c, d ); \
+   b = mm256_ror_32( _mm256_xor_si256( b, c ), 12 ); \
+   a = _mm256_add_epi32( _mm256_add_epi32( a, b ), m[ s1 ] ); \
+   d = mm256_ror_32( _mm256_xor_si256( d, a ), 8 ); \
+   c = _mm256_add_epi32( c, d ); \
+   b = mm256_ror_32( _mm256_xor_si256( b, c ), 7 ); \
+} while(0)
+
+#define ROUND8W(r)  \
+do { \
+   uint8_t *sigma = (uint8_t*)&blake2s_sigma[r]; \
+   G8W( sigma[ 0], sigma[ 1], v[ 0], v[ 4], v[ 8], v[12] ); \
+   G8W( sigma[ 2], sigma[ 3], v[ 1], v[ 5], v[ 9], v[13] ); \
+   G8W( sigma[ 4], sigma[ 5], v[ 2], v[ 6], v[10], v[14] ); \
+   G8W( sigma[ 6], sigma[ 7], v[ 3], v[ 7], v[11], v[15] ); \
+   G8W( sigma[ 8], sigma[ 9], v[ 0], v[ 5], v[10], v[15] ); \
+   G8W( sigma[10], sigma[11], v[ 1], v[ 6], v[11], v[12] ); \
+   G8W( sigma[12], sigma[13], v[ 2], v[ 7], v[ 8], v[13] ); \
+   G8W( sigma[14], sigma[15], v[ 3], v[ 4], v[ 9], v[14] ); \
+} while(0)
+
+/*
+#define ROUND8W(r)  \
+do { \
+   G8W( r, 0, v[ 0], v[ 4], v[ 8], v[12] ); \
+   G8W( r, 1, v[ 1], v[ 5], v[ 9], v[13] ); \
+   G8W( r, 2, v[ 2], v[ 6], v[10], v[14] ); \
+   G8W( r, 3, v[ 3], v[ 7], v[11], v[15] ); \
+   G8W( r, 4, v[ 0], v[ 5], v[10], v[15] ); \
+   G8W( r, 5, v[ 1], v[ 6], v[11], v[12] ); \
+   G8W( r, 6, v[ 2], v[ 7], v[ 8], v[13] ); \
+   G8W( r, 7, v[ 3], v[ 4], v[ 9], v[14] ); \
+} while(0)
+*/
+
+   ROUND8W( 0 );
+   ROUND8W( 1 );
+   ROUND8W( 2 );
+   ROUND8W( 3 );
+   ROUND8W( 4 );
+   ROUND8W( 5 );
+   ROUND8W( 6 );
+   ROUND8W( 7 );
+   ROUND8W( 8 );
+   ROUND8W( 9 );
+
+   for( size_t i = 0; i < 8; ++i )
+      S->h[i] = mm256_xor3( S->h[i], v[i], v[i + 8] );
+
+#undef G8W
+#undef ROUND8W
+   return 0;
+}
+
+int blake2s_8way_init( blake2s_8way_state *S, const uint8_t outlen )
+{
+   blake2s_nway_param P[1];
+
+   P->digest_length = outlen;
+   P->key_length    = 0;
+   P->fanout        = 1;
+   P->depth         = 1;
+   P->leaf_length   = 0;
+   *((uint64_t*)(P->node_offset)) = 0;
+   P->node_depth    = 0;
+   P->inner_length  = 0;
+   memset( P->salt,     0, sizeof( P->salt ) );
+   memset( P->personal, 0, sizeof( P->personal ) );
+
+   memset( S, 0, sizeof( blake2s_8way_state ) );
+   S->h[0] = v256_64( 0x6A09E6676A09E667ULL );
+   S->h[1] = v256_64( 0xBB67AE85BB67AE85ULL );
+   S->h[2] = v256_64( 0x3C6EF3723C6EF372ULL );
+   S->h[3] = v256_64( 0xA54FF53AA54FF53AULL );
+   S->h[4] = v256_64( 0x510E527F510E527FULL );
+   S->h[5] = v256_64( 0x9B05688C9B05688CULL );
+   S->h[6] = v256_64( 0x1F83D9AB1F83D9ABULL );
+   S->h[7] = v256_64( 0x5BE0CD195BE0CD19ULL );
+
+
+//   for( int i = 0; i < 8; ++i )
+//      S->h[i] = v256_32( blake2s_IV[i] );
+
+   uint32_t *p = ( uint32_t * )( P );
+
+   /* IV XOR ParamBlock */
+   for ( size_t i = 0; i < 8; ++i )
+      S->h[i] = _mm256_xor_si256( S->h[i], v256_32( p[i] ) );
+   return 0;
+}
+
+int blake2s_8way_update( blake2s_8way_state *S, const void *in,
+                         uint64_t inlen )
+{
+  __m256i *input = (__m256i*)in;
+  __m256i *buf = (__m256i*)S->buf;
+  const int bsize = 64;
+
+   while( inlen > 0 )
+   {
+      size_t left = S->buflen;
+      if( inlen >= bsize - left )
+      {
+         memcpy_256( buf + (left>>2), input, (bsize - left) >> 2 );
+         S->buflen += bsize - left;
+         S->t[0] += 64;
+         S->t[1] += ( S->t[0] < 64 );
+         blake2s_8way_compress( S, buf );
+         S->buflen = 0;
+         input += ( bsize >> 2 );
+         inlen -= bsize;
+      }
+      else
+      {
+          memcpy_256( buf + ( left>>2 ), input, inlen>>2 );
+          S->buflen += (size_t) inlen;
+          input += ( inlen>>2 );
+          inlen -= inlen;
+      }
+   }
+   return 0;
+}
+
+int blake2s_8way_final( blake2s_8way_state *S, void *out, uint8_t outlen )
+{
+   __m256i *buf = (__m256i*)S->buf;
+
+   S->t[0] += S->buflen;
+   S->t[1] += ( S->t[0] < S->buflen );
+   if ( S->last_node )
+      S->f[1] = ~0U;
+   S->f[0] = ~0U;
+
+   memset_zero_256( buf + ( S->buflen>>2 ),( 64 - S->buflen ) >> 2 );
+   blake2s_8way_compress( S, buf );
+
+   for ( int i = 0; i < 8; ++i )
+      casti_m256i( out, i ) = S->h[ i ];
+   return 0;
+}
+
+// Update and final when inlen is a multiple of 64 bytes
+int blake2s_8way_full_blocks( blake2s_8way_state *S, void *out,
+                              const void *input, uint64_t inlen )
+{
+    __m256i *in = (__m256i*)input;
+    __m256i *buf = (__m256i*)S->buf;
+
+    while( inlen > 64 )
+    {
+       memcpy_256( buf, in, 64 >> 2 );
+       S->buflen = 64;
+       inlen -= 64;
+       S->t[0] += 64;
+       S->t[1] += ( S->t[0] < 64 );
+       blake2s_8way_compress( S, buf );
+       S->buflen = 0;
+       in += ( 64 >> 2 );
+    }
+
+    // last block
+    memcpy_256( buf, in, 64 >> 2 );
+    S->buflen = 64;
+    S->t[0] += S->buflen;
+    S->t[1] += ( S->t[0] < S->buflen );
+    if ( S->last_node )  S->f[1] = ~0U;
+    S->f[0] = ~0U;
+    blake2s_8way_compress( S, buf );
+
+    for ( int i = 0; i < 8; ++i )
+      casti_m256i( out, i ) = S->h[ i ];
+    return 0;
+}
+
+#endif // __AVX2__
+
+#if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
+
+// Blake2s-256 16 way
+
+int blake2s_16way_compress( blake2s_16way_state *S, const __m512i *block )
+{
+   __m512i m[16];
+   __m512i v[16];
+
+   memcpy_512( m, block, 16 );
+   memcpy_512( v, S->h, 8 );
+
+   v[ 8] = v512_64( 0x6A09E6676A09E667ULL );
+   v[ 9] = v512_64( 0xBB67AE85BB67AE85ULL );
+   v[10] = v512_64( 0x3C6EF3723C6EF372ULL );
+   v[11] = v512_64( 0xA54FF53AA54FF53AULL );
+   v[12] = _mm512_xor_si512( v512_32( S->t[0] ),
+                          v512_64( 0x510E527F510E527FULL ) );
+
+   v[13] = _mm512_xor_si512( v512_32( S->t[1] ),
+                          v512_64( 0x9B05688C9B05688CULL ) );
+
+   v[14] = _mm512_xor_si512( v512_32( S->f[0] ),
+                          v512_64( 0x1F83D9AB1F83D9ABULL ) );
+
+   v[15] = _mm512_xor_si512( v512_32( S->f[1] ),
+                          v512_64( 0x5BE0CD195BE0CD19ULL ) );
+
+
+#define G16W( sigma0, sigma1, a, b, c, d) \
+do { \
+   uint8_t s0 = sigma0; \
+   uint8_t s1 = sigma1; \
+   a = _mm512_add_epi32( _mm512_add_epi32( a, b ), m[ s0 ] ); \
+   d = mm512_ror_32( _mm512_xor_si512( d, a ), 16 ); \
+   c = _mm512_add_epi32( c, d ); \
+   b = mm512_ror_32( _mm512_xor_si512( b, c ), 12 ); \
+   a = _mm512_add_epi32( _mm512_add_epi32( a, b ), m[ s1 ] ); \
+   d = mm512_ror_32( _mm512_xor_si512( d, a ),  8 ); \
+   c = _mm512_add_epi32( c, d ); \
+   b = mm512_ror_32( _mm512_xor_si512( b, c ),  7 ); \
+} while(0)
+
+#define ROUND16W(r)  \
+do { \
+   uint8_t *sigma = (uint8_t*)&blake2s_sigma[r]; \
+   G16W( sigma[ 0], sigma[ 1], v[ 0], v[ 4], v[ 8], v[12] ); \
+   G16W( sigma[ 2], sigma[ 3], v[ 1], v[ 5], v[ 9], v[13] ); \
+   G16W( sigma[ 4], sigma[ 5], v[ 2], v[ 6], v[10], v[14] ); \
+   G16W( sigma[ 6], sigma[ 7], v[ 3], v[ 7], v[11], v[15] ); \
+   G16W( sigma[ 8], sigma[ 9], v[ 0], v[ 5], v[10], v[15] ); \
+   G16W( sigma[10], sigma[11], v[ 1], v[ 6], v[11], v[12] ); \
+   G16W( sigma[12], sigma[13], v[ 2], v[ 7], v[ 8], v[13] ); \
+   G16W( sigma[14], sigma[15], v[ 3], v[ 4], v[ 9], v[14] ); \
+} while(0)
+
+   ROUND16W( 0 );
+   ROUND16W( 1 );
+   ROUND16W( 2 );
+   ROUND16W( 3 );
+   ROUND16W( 4 );
+   ROUND16W( 5 );
+   ROUND16W( 6 );
+   ROUND16W( 7 );
+   ROUND16W( 8 );
+   ROUND16W( 9 );
+
+   for( size_t i = 0; i < 8; ++i )
+      S->h[i] = mm512_xor3( S->h[i], v[i], v[i + 8] );
+
+#undef G16W
+#undef ROUND16W
+   return 0;
+}
+
+int blake2s_16way_init( blake2s_16way_state *S, const uint8_t outlen )
+{
+   blake2s_nway_param P[1];
+
+   P->digest_length = outlen;
+   P->key_length    = 0;
+   P->fanout        = 1;
+   P->depth         = 1;
+   P->leaf_length   = 0;
+   *((uint64_t*)(P->node_offset)) = 0;
+   P->node_depth    = 0;
+   P->inner_length  = 0;
+   memset( P->salt,     0, sizeof( P->salt ) );
+   memset( P->personal, 0, sizeof( P->personal ) );
+
+   memset( S, 0, sizeof( blake2s_16way_state ) );
+   S->h[0] = v512_64( 0x6A09E6676A09E667ULL );
+   S->h[1] = v512_64( 0xBB67AE85BB67AE85ULL );
+   S->h[2] = v512_64( 0x3C6EF3723C6EF372ULL );
+   S->h[3] = v512_64( 0xA54FF53AA54FF53AULL );
+   S->h[4] = v512_64( 0x510E527F510E527FULL );
+   S->h[5] = v512_64( 0x9B05688C9B05688CULL );
+   S->h[6] = v512_64( 0x1F83D9AB1F83D9ABULL );
+   S->h[7] = v512_64( 0x5BE0CD195BE0CD19ULL );
+
+   uint32_t *p = ( uint32_t * )( P );
+
+   /* IV XOR ParamBlock */
+   for ( size_t i = 0; i < 8; ++i )
+      S->h[i] = _mm512_xor_si512( S->h[i], v512_32( p[i] ) );
+   return 0;
+}
+
+int blake2s_16way_update( blake2s_16way_state *S, const void *in,
+                         uint64_t inlen )
+{
+  __m512i *input = (__m512i*)in;
+  __m512i *buf = (__m512i*)S->buf;
+  const int bsize = 64;
+
+   while( inlen > 0 )
+   {
+      size_t left = S->buflen;
+      if( inlen >= bsize - left )
+      {
+         memcpy_512( buf + (left>>2), input, (bsize - left) >> 2 );
+         S->buflen += bsize - left;
+         S->t[0] += 64;
+         S->t[1] += ( S->t[0] < 64 );
+         blake2s_16way_compress( S, buf );
+         S->buflen = 0;
+         input += ( bsize >> 2 );
+         inlen -= bsize;
+      }
+      else
+      {
+          memcpy_512( buf + ( left>>2 ), input, inlen>>2 );
+          S->buflen += (size_t) inlen;
+          input += ( inlen>>2 );
+          inlen -= inlen;
+      }
+   }
+   return 0;
+}
+
+int blake2s_16way_final( blake2s_16way_state *S, void *out, uint8_t outlen )
+{
+   __m512i *buf = (__m512i*)S->buf;
+
+   S->t[0] += S->buflen;
+   S->t[1] += ( S->t[0] < S->buflen );
+   if ( S->last_node )
+      S->f[1] = ~0U;
+   S->f[0] = ~0U;
+
+   memset_zero_512( buf + ( S->buflen>>2 ),
+                    ( 64 - S->buflen ) >> 2 );
+   blake2s_16way_compress( S, buf );
+
+   for ( int i = 0; i < 8; ++i )
+      casti_m512i( out, i ) = S->h[ i ];
+   return 0;
+}
+
+#endif   // AVX512
+
+
+#if 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;
+}
+#endif
+
+#endif // __SSE4_2__

algo/blake/blake2s-hash.h

@@ -0,0 +1,116 @@
+/**
+ * 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 __BLAKE2S_HASH_4WAY_H__
+#define __BLAKE2S_HASH_4WAY_H__ 1
+
+#if defined(__SSE2__) || defined(__ARM_NEON)
+
+#include "simd-utils.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
+
+   typedef struct __blake2s_nway_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[8]; // 24
+      uint8_t  personal[8];  // 32
+   } blake2s_nway_param;
+
+typedef struct ALIGN( 64 ) __blake2s_4way_state
+{
+   v128_t h[8];
+   uint8_t  buf[ 64 * 4 ];
+   uint32_t t[2];
+   uint32_t f[2];
+   size_t   buflen;
+   uint8_t  last_node;
+} blake2s_4way_state ;
+
+int blake2s_4way_init( blake2s_4way_state *S, const uint8_t outlen );
+int blake2s_4way_update( blake2s_4way_state *S, const void *in,
+                         uint64_t inlen );
+int blake2s_4way_final( blake2s_4way_state *S, void *out, uint8_t outlen );
+int blake2s_4way_full_blocks( blake2s_4way_state *S, void *out,
+                              const void *input, uint64_t inlen );
+
+
+#if defined(__AVX2__)
+
+typedef struct ALIGN( 64 ) __blake2s_8way_state
+{
+   __m256i h[8];
+   uint8_t  buf[ 32 * 8 ];
+   uint32_t t[2];
+   uint32_t f[2];
+   size_t   buflen;
+   uint8_t  last_node;
+} blake2s_8way_state ;
+
+int blake2s_8way_init( blake2s_8way_state *S, const uint8_t outlen );
+int blake2s_8way_update( blake2s_8way_state *S, const void *in,
+                         uint64_t inlen );
+int blake2s_8way_final( blake2s_8way_state *S, void *out, uint8_t outlen );
+int blake2s_8way_full_blocks( blake2s_8way_state *S, void *out,
+                              const void *input, uint64_t inlen );
+
+#endif
+
+#if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
+
+typedef struct ALIGN( 64 ) __blake2s_16way_state
+{
+   __m512i h[8];
+   uint8_t  buf[ 32 * 16 ];
+   uint32_t t[2];
+   uint32_t f[2];
+   size_t   buflen;
+   uint8_t  last_node;
+} blake2s_16way_state ;
+
+int blake2s_16way_init( blake2s_16way_state *S, const uint8_t outlen );
+int blake2s_16way_update( blake2s_16way_state *S, const void *in,
+                         uint64_t inlen );
+int blake2s_16way_final( blake2s_16way_state *S, void *out, uint8_t outlen );
+
+#endif
+
+#if 0
+	// 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)
+#endif
+
+#endif  // __SSE2__
+
+#endif

algo/blake/blake2s.c

@@ -1,84 +1,251 @@
 #include "algo-gate-api.h"
-
+#include "blake2s-hash.h"
 #include <string.h>
 #include <stdint.h>
 
-#include "crypto/blake2s.h"
+#if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
+  #define BLAKE2S_16WAY
+#elif defined(__AVX2__)
+  #define BLAKE2S_8WAY
+#elif defined(__SSE2__) || defined(__ARM_NEON)
+//  #define BLAKE2S_4WAY
+#endif
 
-static __thread blake2s_state s_midstate;
-static __thread blake2s_state s_ctx;
-#define MIDLEN 76
+#if defined(BLAKE2S_16WAY)
 
-void blake2s_hash(void *output, const void *input)
+static __thread blake2s_16way_state blake2s_16w_ctx;
+
+void blake2s_16way_hash( void *output, const void *input )
 {
-	unsigned char _ALIGN(64) hash[BLAKE2S_OUTBYTES];
-	blake2s_state blake2_ctx __attribute__ ((aligned (64)));
-
-	blake2s_init(&blake2_ctx, BLAKE2S_OUTBYTES);
-	blake2s_update(&blake2_ctx, input, 80);
-	blake2s_final(&blake2_ctx, hash, BLAKE2S_OUTBYTES);
-
-	memcpy(output, hash, 32);
+   blake2s_16way_state ctx;
+   memcpy( &ctx, &blake2s_16w_ctx, sizeof ctx );
+   blake2s_16way_update( &ctx, input + (64<<4), 16 );
+   blake2s_16way_final( &ctx, output, 32 );
 }
 
-static void blake2s_hash_end(uint32_t *output, const uint32_t *input)
+int scanhash_blake2s_16way( struct work *work, uint32_t max_nonce,
+                            uint64_t *hashes_done, struct thr_info *mythr )
 {
-	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);
+   uint32_t vdata[20*16] __attribute__ ((aligned (128)));
+   uint32_t hash[8*16] __attribute__ ((aligned (64)));
+   uint32_t lane_hash[8] __attribute__ ((aligned (64)));
+   uint32_t *hash7 = &(hash[7<<4]);
+   uint32_t *pdata = work->data;
+   uint32_t *ptarget = work->target;
+   const uint32_t Htarg = ptarget[7];
+   const uint32_t first_nonce = pdata[19];
+   __m512i  *noncev = (__m512i*)vdata + 19;   // aligned
+   uint32_t n = first_nonce;
+   int thr_id = mythr->id;  
+
+   mm512_bswap32_intrlv80_16x32( vdata, pdata );
+   blake2s_16way_init( &blake2s_16w_ctx, 32 );
+   blake2s_16way_update( &blake2s_16w_ctx, vdata, 64 );
+
+   do {
+      *noncev = mm512_bswap_32( _mm512_set_epi32(
+	                  n+15, n+14, n+13, n+12, n+11, n+10, n+ 9, n+ 8,
+	                  n+ 7, n+ 6, n+ 5, n+ 4, n+ 3, n+ 2, n+ 1, n ) );
+      pdata[19] = n;
+
+      blake2s_16way_hash( hash, vdata );
+
+      for ( int lane = 0; lane < 16; lane++ )
+      if ( unlikely( hash7[lane] <= Htarg ) )
+      {
+         extr_lane_16x32( lane_hash, hash, lane, 256 );
+         if ( likely( fulltest( lane_hash, ptarget ) && !opt_benchmark ) )
+         {
+              pdata[19] = n + lane;
+              submit_solution( work, lane_hash, mythr );
+         }
+      }
+      n += 16;
+   } while ( (n < max_nonce-16) && !work_restart[thr_id].restart );
+
+   *hashes_done = n - first_nonce + 1;
+   return 0;
 }
 
-int scanhash_blake2s(int thr_id, struct work *work,
-	uint32_t max_nonce, uint64_t *hashes_done)
+#elif defined(BLAKE2S_8WAY)
+
+static __thread blake2s_8way_state blake2s_8w_ctx;
+
+void blake2s_8way_hash( void *output, const void *input )
 {
-        uint32_t *pdata = work->data;
-        uint32_t *ptarget = work->target;
-
-	uint32_t _ALIGN(64) hash64[8];
-	uint32_t _ALIGN(64) endiandata[20];
-
-	const uint32_t Htarg = ptarget[7];
-	const uint32_t first_nonce = pdata[19];
-
-	uint32_t n = first_nonce;
-
-        swab32_array( endiandata, pdata, 20 );
-
-	// midstate
-	blake2s_init(&s_midstate, BLAKE2S_OUTBYTES);
-	blake2s_update(&s_midstate, (uint8_t*) endiandata, MIDLEN);
-	memcpy(&s_ctx, &s_midstate, sizeof(blake2s_state));
-
-	do {
-		be32enc(&endiandata[19], n);
-		blake2s_hash_end(hash64, endiandata);
-		if (hash64[7] < Htarg && fulltest(hash64, ptarget)) {
-			*hashes_done = n - first_nonce + 1;
-			pdata[19] = n;
-			return true;
-		}
-		n++;
-
-	} while (n < max_nonce && !work_restart[thr_id].restart);
-
-	*hashes_done = n - first_nonce + 1;
-	pdata[19] = n;
-
-	return 0;
+   blake2s_8way_state ctx;
+   memcpy( &ctx, &blake2s_8w_ctx, sizeof ctx );
+   blake2s_8way_update( &ctx, input + (64<<3), 16 );
+   blake2s_8way_final( &ctx, output, 32 );
 }
 
-// changed to get_max64_0x3fffffLL in cpuminer-multi-decred
-int64_t blake2s_get_max64 ()
+int scanhash_blake2s_8way( struct work *work, uint32_t max_nonce,
+                      uint64_t *hashes_done, struct thr_info *mythr )
 {
-   return 0x7ffffLL;
+   uint32_t vdata[20*8] __attribute__ ((aligned (64)));
+   uint32_t hash[8*8] __attribute__ ((aligned (32)));
+   uint32_t lane_hash[8] __attribute__ ((aligned (32)));
+   uint32_t *hash7 = &(hash[7<<3]);
+   uint32_t *pdata = work->data;
+   uint32_t *ptarget = work->target;
+   const uint32_t Htarg = ptarget[7];
+   const uint32_t first_nonce = pdata[19];
+   __m256i  *noncev = (__m256i*)vdata + 19;   // aligned
+   uint32_t n = first_nonce;
+   int thr_id = mythr->id; 
+
+   mm256_bswap32_intrlv80_8x32( vdata, pdata );
+   blake2s_8way_init( &blake2s_8w_ctx, 32 );
+   blake2s_8way_update( &blake2s_8w_ctx, vdata, 64 );
+
+   do {
+      *noncev = mm256_bswap_32( _mm256_set_epi32( n+7, n+6, n+5, n+4,
+                                                  n+3, n+2, n+1, n ) );
+      pdata[19] = n;
+
+      blake2s_8way_hash( hash, vdata );
+
+      for ( int lane = 0; lane < 8; lane++ )
+      if ( unlikely( hash7[lane] <= Htarg ) )
+      {
+         extr_lane_8x32( lane_hash, hash, lane, 256 );
+         if ( likely( fulltest( lane_hash, ptarget ) && !opt_benchmark ) )
+         {
+              pdata[19] = n + lane;
+              submit_solution( work, lane_hash, mythr );
+         }
+      }
+      n += 8;
+   } while ( (n < max_nonce) && !work_restart[thr_id].restart );
+
+   *hashes_done = n - first_nonce + 1;
+   return 0;
 }
 
+#elif defined(BLAKE2S_4WAY)
+
+static __thread blake2s_4way_state blake2s_4w_ctx;
+
+void blake2s_4way_hash( void *output, const void *input )
+{
+   blake2s_4way_state ctx;
+   memcpy( &ctx, &blake2s_4w_ctx, sizeof ctx );
+   blake2s_4way_update( &ctx, input + (64<<2), 16 );
+   blake2s_4way_final( &ctx, output, 32 );
+}
+
+int scanhash_blake2s_4way( struct work *work, uint32_t max_nonce,
+                      uint64_t *hashes_done, struct thr_info *mythr )
+{
+   uint32_t vdata[20*4] __attribute__ ((aligned (64)));
+   uint32_t hash[8*4] __attribute__ ((aligned (32)));
+   uint32_t lane_hash[8] __attribute__ ((aligned (32)));
+   uint32_t *hash7 = &(hash[7<<2]);
+   uint32_t *pdata = work->data;
+   uint32_t *ptarget = work->target;
+   const uint32_t Htarg = ptarget[7];
+   const uint32_t first_nonce = pdata[19];
+   v128_t  *noncev = (v128_t*)vdata + 19;   // aligned
+   uint32_t n = first_nonce;
+   int thr_id = mythr->id; 
+
+   v128_bswap32_intrlv80_4x32( vdata, pdata );
+   blake2s_4way_init( &blake2s_4w_ctx, 32 );
+   blake2s_4way_update( &blake2s_4w_ctx, vdata, 64 );
+
+   do {
+      *noncev = v128_bswap32( v128_set32( n+3, n+2, n+1, n ) );
+      pdata[19] = n;
+
+      blake2s_4way_hash( hash, vdata );
+
+      for ( int lane = 0; lane < 4; lane++ ) if ( hash7[lane] <= Htarg )
+      {
+         extr_lane_4x32( lane_hash, hash, lane, 256 );
+         if ( fulltest( lane_hash, ptarget ) && !opt_benchmark )
+         {
+              pdata[19] = n + lane;
+              submit_solution( work, lane_hash, mythr );
+              }
+      }
+      n += 4;
+   } while ( (n < max_nonce) && !work_restart[thr_id].restart );
+
+   *hashes_done = n - first_nonce + 1;
+   return 0;
+}
+
+#else
+
+#include "sph-blake2s.h"
+
+static __thread blake2s_state blake2s_ctx;
+
+void blake2s_hash( void *output, const void *input )
+{
+   unsigned char _ALIGN(32) hash[32];
+   blake2s_state ctx __attribute__ ((aligned (32)));
+
+   memcpy( &ctx, &blake2s_ctx, sizeof ctx );
+   blake2s_update( &ctx, input+64, 16 );
+   blake2s_final( &ctx, hash, 32 );
+
+   memcpy(output, hash, 32);
+}
+
+int scanhash_blake2s( struct work *work,uint32_t max_nonce,
+                      uint64_t *hashes_done, struct thr_info *mythr )
+{
+   uint32_t *pdata = work->data;
+   const uint32_t *ptarget = work->target;
+   uint32_t _ALIGN(32) hash32[8];
+   uint32_t _ALIGN(32) endiandata[20];
+   const int thr_id = mythr->id;
+   const uint32_t first_nonce = pdata[19];
+   uint32_t n = first_nonce;
+
+   v128_bswap32_80( endiandata, pdata );
+
+   // midstate
+   blake2s_init( &blake2s_ctx, 32 );
+   blake2s_update( &blake2s_ctx, (uint8_t*) endiandata, 64 );
+
+   do
+   {
+      endiandata[19] = n;
+      blake2s_hash( hash32, endiandata );
+      if ( unlikely( valid_hash( hash32, ptarget ) ) && !opt_benchmark )
+      {
+         pdata[19] = bswap_32( n );
+         submit_solution( work, hash32, mythr );
+      }
+      n++;
+   } while (n < max_nonce && !work_restart[thr_id].restart);
+
+   *hashes_done = n - first_nonce + 1;
+   pdata[19] = n;
+
+   return 0;
+}
+
+#endif
+
 bool register_blake2s_algo( algo_gate_t* gate )
 {
+#if defined(BLAKE2S_16WAY)
+  gate->scanhash  = (void*)&scanhash_blake2s_16way;
+  gate->hash      = (void*)&blake2s_16way_hash;
+#elif defined(BLAKE2S_8WAY)
+  gate->scanhash  = (void*)&scanhash_blake2s_8way;
+  gate->hash      = (void*)&blake2s_8way_hash;
+#elif defined(BLAKE2S_4WAY)
+  gate->scanhash  = (void*)&scanhash_blake2s_4way;
+  gate->hash      = (void*)&blake2s_4way_hash;
+#else
   gate->scanhash  = (void*)&scanhash_blake2s;
   gate->hash      = (void*)&blake2s_hash;
-  gate->get_max64 = (void*)&blake2s_get_max64;
+#endif
+  gate->optimizations = SSE2_OPT | AVX2_OPT | AVX512_OPT | NEON_OPT;
   return true;
 };
 

algo/blake/blake512-hash.h

@@ -0,0 +1,138 @@
+#ifndef BLAKE512_HASH__
+#define BLAKE512_HASH__ 1
+
+#include <stddef.h>
+#include "simd-utils.h"
+
+#if defined(__SSE2__) || defined(__ARM_NEON)
+
+/////////////////////////
+//
+//  Blake-512 1 way SSE2, AVX2, NEON
+
+typedef struct
+{
+   unsigned char buf[128];    /* first field, for alignment */
+   uint64_t H[8];
+   uint64_t T0, T1;
+   size_t ptr;
+} blake512_context __attribute__ ((aligned (32)));
+
+void  blake512_transform( uint64_t *H, const uint64_t *buf,
+                          const uint64_t T0, const uint64_t T1 );
+void blake512_init( blake512_context *sc );
+void blake512_update( blake512_context *sc, const void *data, size_t len );
+void blake512_close( blake512_context *sc, void *dst );
+void blake512_full( blake512_context *sc, void *dst, const void *data,
+                    size_t len );
+
+/////////////////////////
+//
+//  Blake-512 2 way SSE2 & NEON
+
+typedef struct
+{
+   v128u64_t buf[16];
+   v128u64_t H[8];
+   v128u64_t S[4];
+   size_t ptr;
+   uint64_t T0, T1;
+} blake_2x64_big_context __attribute__ ((aligned (32)));
+
+typedef blake_2x64_big_context blake512_2x64_context;
+
+void blake512_2x64_init( blake_2x64_big_context *sc );
+void blake512_2x64_update( void *cc, const void *data, size_t len );
+void blake512_2x64_close( void *cc, void *dst );
+void blake512_2x64_full( blake_2x64_big_context *sc, void * dst,
+                         const void *data, size_t len );
+void blake512_2x64_full_le( blake_2x64_big_context *sc, void * dst,
+                            const void *data, size_t len );
+void blake512_2x64_prehash_part1_le( blake_2x64_big_context *sc,
+                                     v128u64_t *midstate, const void *data );
+void blake512_2x64_prehash_part2_le( blake_2x64_big_context *sc,
+              void *hash, const v128u64_t nonce, const v128u64_t *midstate );
+
+#ifdef __AVX2__
+
+/////////////////////////
+//
+// Blake-512 4 way AVX2
+
+typedef struct
+{
+   __m256i buf[16];
+   __m256i H[8];
+   __m256i S[4];   
+   size_t ptr;
+   uint64_t T0, T1;
+} blake_4x64_big_context __attribute__ ((aligned (64)));
+
+typedef blake_4x64_big_context blake512_4x64_context;
+
+void blake512_4x64_init( blake_4x64_big_context *sc );
+void blake512_4x64_update( void *cc, const void *data, size_t len );
+void blake512_4x64_close( void *cc, void *dst );
+void blake512_4x64_full( blake_4x64_big_context *sc, void * dst,
+                         const void *data, size_t len );
+void blake512_4x64_full_le( blake_4x64_big_context *sc, void * dst,
+                            const void *data, size_t len );
+void blake512_4x64_prehash_le( blake_4x64_big_context *sc, __m256i *midstate,
+                               const void *data );
+void blake512_4x64_final_le( blake_4x64_big_context *sc, void *hash,
+                             const __m256i nonce, const __m256i *midstate );
+
+#define blake_4way_big_context    blake_4x64_big_context
+#define blake512_4way_context     blake512_4x64_context
+#define blake512_4way_init        blake512_4x64_init
+#define blake512_4way_update      blake512_4x64_update
+#define blake512_4way_close       blake512_4x64_close 
+#define blake512_4way_full        blake512_4x64_full
+#define blake512_4way_full_le     blake512_4x64_full_le
+#define blake512_4way_prehash_le  blake512_4x64_prehash_le
+#define blake512_4way_final_le    blake512_4x64_final_le
+
+#if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
+
+////////////////////////////
+//
+//   Blake-512 8 way AVX512
+
+typedef struct
+{
+   __m512i buf[16];
+   __m512i H[8];
+   __m512i S[4];
+   size_t ptr;
+   uint64_t T0, T1;
+} blake_8x64_big_context __attribute__ ((aligned (128)));
+
+typedef blake_8x64_big_context blake512_8x64_context;
+
+void blake512_8x64_init( blake_8x64_big_context *sc );
+void blake512_8x64_update( void *cc, const void *data, size_t len );
+void blake512_8x64_close( void *cc, void *dst );
+void blake512_8x64_full( blake_8x64_big_context *sc, void * dst,
+                        const void *data, size_t len );
+void blake512_8x64_full_le( blake_8x64_big_context *sc, void * dst,
+                            const void *data, size_t len );
+void blake512_8x64_prehash_le( blake_8x64_big_context *sc, __m512i *midstate,
+                               const void *data );
+void blake512_8x64_final_le( blake_8x64_big_context *sc, void *hash,
+                             const __m512i nonce, const __m512i *midstate );
+
+#define blake_8way_big_context      blake_8x64_big_context
+#define blake512_8way_context       blake512_8x64_context
+#define blake512_8way_init          blake512_8x64_init
+#define blake512_8way_update        blake512_8x64_update
+#define blake512_8way_close         blake512_8x64_close
+#define blake512_8way_full          blake512_8x64_full  
+#define blake512_8way_full_le       blake512_8x64_full_le
+#define blake512_8way_prehash_le    blake512_8x64_prehash_le
+#define blake512_8way_final_le      blake512_8x64_final_le
+
+#endif  // AVX512
+#endif  // AVX2
+#endif  // SSE2 or NEON
+
+#endif  // BLAKE512_HASH_H__

algo/blake/blakecoin-4way.c

@@ -0,0 +1,205 @@
+#include "blakecoin-gate.h"
+#include "blake256-hash.h"
+#include <string.h>
+#include <stdint.h>
+#include <memory.h>
+
+#define rounds 8
+
+#if defined (BLAKECOIN_16WAY)
+
+int scanhash_blakecoin_16way( struct work *work, uint32_t max_nonce,
+                         uint64_t *hashes_done, struct thr_info *mythr )
+{
+   uint32_t hash32[8*16] __attribute__ ((aligned (64)));
+   uint32_t midstate_vars[16*16] __attribute__ ((aligned (64)));
+   __m512i block0_hash[8] __attribute__ ((aligned (64)));
+   __m512i block_buf[16] __attribute__ ((aligned (64)));
+   uint32_t lane_hash[8] __attribute__ ((aligned (32)));
+   uint32_t *hash32_d7 =  (uint32_t*)&( ((__m512i*)hash32)[7] );
+   uint32_t *pdata = work->data;
+   const uint32_t *ptarget = work->target;
+   const uint32_t targ32_d7 = ptarget[7];
+   uint32_t phash[8] __attribute__ ((aligned (64))) =
+   {
+      0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A,
+      0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19
+   };
+   uint32_t n = pdata[19];
+   const uint32_t first_nonce = (const uint32_t) n;
+   const uint32_t last_nonce = max_nonce - 16;
+   const int thr_id = mythr->id;
+   const bool bench = opt_benchmark;
+   const __m512i sixteen = v512_32( 16 );
+
+   // Prehash first block
+   blake256_transform_le( phash, pdata, 512, 0, rounds );
+
+   block0_hash[0] = v512_32( phash[0] );
+   block0_hash[1] = v512_32( phash[1] );
+   block0_hash[2] = v512_32( phash[2] );
+   block0_hash[3] = v512_32( phash[3] );
+   block0_hash[4] = v512_32( phash[4] );
+   block0_hash[5] = v512_32( phash[5] );
+   block0_hash[6] = v512_32( phash[6] );
+   block0_hash[7] = v512_32( phash[7] );
+
+   // Build vectored second block, interleave last 16 bytes of data using
+   // unique nonces.
+   block_buf[0] = v512_32( pdata[16] );
+   block_buf[1] = v512_32( pdata[17] );
+   block_buf[2] = v512_32( pdata[18] );
+   block_buf[3] =
+             _mm512_set_epi32( n+15, n+14, n+13, n+12, n+11, n+10, n+ 9, n+ 8,
+                               n+ 7, n+ 6, n+ 5, n+ 4, n+ 3, n+ 2, n +1, n );
+
+   // Partialy prehash second block without touching nonces in block_buf[3].
+   blake256_16way_round0_prehash_le( midstate_vars, block0_hash, block_buf );
+
+   do {
+      blake256_16way_final_rounds_le( hash32, midstate_vars, block0_hash,
+                                      block_buf, rounds );
+      for ( int lane = 0; lane < 16; lane++ )
+      if ( unlikely( hash32_d7[ lane ] <= targ32_d7 ) )
+      {
+         extr_lane_16x32( lane_hash, hash32, lane, 256 );
+         if ( likely( valid_hash( lane_hash, ptarget ) && !bench ) )
+         {
+            pdata[19] = n + lane;
+            submit_solution( work, lane_hash, mythr );
+         }
+      }
+      block_buf[3] = _mm512_add_epi32( block_buf[3], sixteen );
+      n += 16;
+   } while ( likely( (n < last_nonce) && !work_restart[thr_id].restart) );
+   pdata[19] = n;
+   *hashes_done = n - first_nonce;
+   return 0;
+}
+
+#elif defined (BLAKECOIN_8WAY)
+
+int scanhash_blakecoin_8way( struct work *work, uint32_t max_nonce,
+                         uint64_t *hashes_done, struct thr_info *mythr )
+{
+   uint32_t hash32[8*8] __attribute__ ((aligned (64)));
+   uint32_t midstate_vars[16*8] __attribute__ ((aligned (32)));
+   __m256i block0_hash[8] __attribute__ ((aligned (32)));
+   __m256i block_buf[16] __attribute__ ((aligned (32)));
+   uint32_t lane_hash[8] __attribute__ ((aligned (32)));
+   uint32_t *hash32_d7 =  (uint32_t*)&( ((__m256i*)hash32)[7] );
+   uint32_t *pdata = work->data;
+   const uint32_t *ptarget = work->target;
+   const uint32_t targ32_d7 = ptarget[7];
+   uint32_t phash[8] __attribute__ ((aligned (32))) =
+   {
+      0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A,
+      0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19
+   };
+   uint32_t n = pdata[19];
+   const uint32_t first_nonce = (const uint32_t) n;
+   const uint32_t last_nonce = max_nonce - 8;
+   const int thr_id = mythr->id;
+   const bool bench = opt_benchmark;
+   const __m256i eight = v256_32( 8 );
+
+   // Prehash first block
+   blake256_transform_le( phash, pdata, 512, 0, rounds );
+
+   block0_hash[0] = v256_32( phash[0] );
+   block0_hash[1] = v256_32( phash[1] );
+   block0_hash[2] = v256_32( phash[2] );
+   block0_hash[3] = v256_32( phash[3] );
+   block0_hash[4] = v256_32( phash[4] );
+   block0_hash[5] = v256_32( phash[5] );
+   block0_hash[6] = v256_32( phash[6] );
+   block0_hash[7] = v256_32( phash[7] );
+
+   // Build vectored second block, interleave last 16 bytes of data using
+   // unique nonces.
+   block_buf[0] = v256_32( pdata[16] );
+   block_buf[1] = v256_32( pdata[17] );
+   block_buf[2] = v256_32( pdata[18] );
+   block_buf[3] = _mm256_set_epi32( n+7, n+6, n+5, n+4, n+3, n+2, n+1, n );
+
+   // Partialy prehash second block without touching nonces in block_buf[3].
+   blake256_8way_round0_prehash_le( midstate_vars, block0_hash, block_buf );
+
+   do {
+      blake256_8way_final_rounds_le( hash32, midstate_vars, block0_hash,
+                                     block_buf, rounds );
+      for ( int lane = 0; lane < 8; lane++ )
+      if ( unlikely( hash32_d7[ lane ] <= targ32_d7 ) )
+      {
+         extr_lane_8x32( lane_hash, hash32, lane, 256 );
+         if ( likely( valid_hash( lane_hash, ptarget ) && !bench ) )
+         {
+            pdata[19] = n + lane;
+            submit_solution( work, lane_hash, mythr );
+         }
+      }
+      block_buf[3] = _mm256_add_epi32( block_buf[3], eight );
+      n += 8;
+   } while ( likely( (n < last_nonce) && !work_restart[thr_id].restart) );
+   pdata[19] = n;
+   *hashes_done = n - first_nonce;
+   return 0;
+}
+   
+#elif defined (BLAKECOIN_4WAY)
+
+blake256r8_4way_context blakecoin_4w_ctx;
+
+void blakecoin_4way_hash(void *state, const void *input)
+{
+     uint32_t vhash[8*4] __attribute__ ((aligned (64)));
+     blake256r8_4way_context ctx;
+
+     memcpy( &ctx, &blakecoin_4w_ctx, sizeof ctx );
+     blake256r8_4way_update( &ctx, input + (64<<2), 16 );
+     blake256r8_4way_close( &ctx, vhash );
+
+     dintrlv_4x32( state, state+32, state+64, state+96, vhash, 256 );
+}
+
+int scanhash_blakecoin_4way( struct work *work, uint32_t max_nonce,
+                         uint64_t *hashes_done, struct thr_info *mythr )
+{
+   uint32_t vdata[20*4] __attribute__ ((aligned (64)));
+   uint32_t hash[8*4] __attribute__ ((aligned (32)));
+   uint32_t *pdata = work->data;
+   uint32_t *ptarget = work->target;
+   const uint32_t first_nonce = pdata[19];
+   uint32_t HTarget = ptarget[7];
+   uint32_t n = first_nonce;
+   __m128i  *noncev = (__m128i*)vdata + 19;   // aligned
+   int thr_id = mythr->id;  // thr_id arg is deprecated
+   if ( opt_benchmark )
+      HTarget = 0x7f;
+
+   v128_bswap32_intrlv80_4x32( vdata, pdata );
+   blake256r8_4way_init( &blakecoin_4w_ctx );
+   blake256r8_4way_update( &blakecoin_4w_ctx, vdata, 64 );
+
+   do {
+      *noncev = mm128_bswap_32( _mm_set_epi32( n+3, n+2, n+1, n ) );
+      pdata[19] = n;
+      blakecoin_4way_hash( hash, vdata );
+
+      for ( int i = 0; i < 4; i++ )
+      if (  (hash+(i<<3))[7] <= HTarget && fulltest( hash+(i<<3), ptarget )
+           && !opt_benchmark )
+      {
+          pdata[19] = n+i;
+          submit_solution( work, hash+(i<<3), mythr );
+      }
+      n += 4;
+
+   } while ( (n < max_nonce) && !work_restart[thr_id].restart );
+
+   *hashes_done = n - first_nonce + 1;
+   return 0;
+}
+
+#endif
+

algo/blake/blakecoin-gate.c

@@ -0,0 +1,28 @@
+#include "blakecoin-gate.h"
+#include <memory.h>
+
+// vanilla uses default gen merkle root, otherwise identical to blakecoin
+bool register_vanilla_algo( algo_gate_t* gate )
+{
+#if defined(BLAKECOIN_16WAY)
+  gate->scanhash  = (void*)&scanhash_blakecoin_16way;
+#elif defined(BLAKECOIN_8WAY)
+  gate->scanhash  = (void*)&scanhash_blakecoin_8way;
+#elif defined(BLAKECOIN_4WAY)
+  gate->scanhash  = (void*)&scanhash_blakecoin_4way;
+  gate->hash      = (void*)&blakecoin_4way_hash;
+#else
+  gate->scanhash = (void*)&scanhash_blakecoin;
+  gate->hash     = (void*)&blakecoinhash;
+#endif
+  gate->optimizations = SSE2_OPT | AVX2_OPT | AVX512_OPT;
+  return true;
+}
+
+bool register_blakecoin_algo( algo_gate_t* gate )
+{
+  register_vanilla_algo( gate );
+  gate->gen_merkle_root = (void*)&sha256_gen_merkle_root;
+  return true;
+}
+

algo/blake/blakecoin-gate.h

@@ -0,0 +1,36 @@
+#ifndef BLAKECOIN_GATE_H__
+#define BLAKECOIN_GATE_H__ 1
+
+#include "algo-gate-api.h"
+#include <stdint.h>
+
+#if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
+  #define BLAKECOIN_16WAY
+#elif defined(__AVX2__)
+  #define BLAKECOIN_8WAY
+#elif defined(__SSE2__)  // always true
+  #define BLAKECOIN_4WAY
+#endif
+
+#if defined (BLAKECOIN_16WAY)
+int scanhash_blakecoin_16way( struct work *work, uint32_t max_nonce,
+                         uint64_t *hashes_done, struct thr_info *mythr );
+
+#elif defined (BLAKECOIN_8WAY)
+//void blakecoin_8way_hash(void *state, const void *input);
+int scanhash_blakecoin_8way( struct work *work, uint32_t max_nonce,
+                         uint64_t *hashes_done, struct thr_info *mythr );
+
+#elif defined (BLAKECOIN_4WAY)
+void blakecoin_4way_hash(void *state, const void *input);
+int scanhash_blakecoin_4way( struct work *work, uint32_t max_nonce,
+                         uint64_t *hashes_done, struct thr_info *mythr );
+#else  // never used
+
+void blakecoinhash( void *state, const void *input );
+int scanhash_blakecoin( struct work *work, uint32_t max_nonce,
+                      uint64_t *hashes_done, struct thr_info *mythr );
+
+#endif
+
+#endif

algo/blake/blakecoin.c

@@ -1,4 +1,7 @@
-#include "algo-gate-api.h"
+#include "blakecoin-gate.h"
+
+#if !defined(BLAKECOIN_16WAY) && !defined(BLAKECOIN_8WAY) && !defined(BLAKECOIN_4WAY)
+
 #define BLAKE32_ROUNDS 8
 #include "sph_blake.h"
 
@@ -9,7 +12,6 @@ void blakecoin_close(void *cc, void *dst);
 #include <string.h>
 #include <stdint.h>
 #include <memory.h>
-#include <openssl/sha.h>
 
 // context management is staged for efficiency.
 // 1. global initial ctx cached on startup
@@ -32,20 +34,21 @@ void blakecoinhash( void *state, const void *input )
 	uint8_t hash[64] __attribute__ ((aligned (32)));
 	uint8_t *ending = (uint8_t*) input + 64;
 
-        // copy cached midstate
-        memcpy( &ctx, &blake_mid_ctx, sizeof ctx );
+   // copy cached midstate
+   memcpy( &ctx, &blake_mid_ctx, sizeof ctx );
 	blakecoin( &ctx, ending, 16 );
 	blakecoin_close( &ctx, hash );
 	memcpy( state, hash, 32 );
 }
 
-int scanhash_blakecoin( int thr_id, struct work *work, uint32_t max_nonce,
-                        uint64_t *hashes_done )
+int scanhash_blakecoin( struct work *work, uint32_t max_nonce,
+                        uint64_t *hashes_done, struct thr_info *mythr )
 {
-        uint32_t *pdata = work->data;
-        uint32_t *ptarget = work->target;
+   uint32_t *pdata = work->data;
+   uint32_t *ptarget = work->target;
 	const uint32_t first_nonce = pdata[19];
 	uint32_t HTarget = ptarget[7];
+   int thr_id = mythr->id;  // thr_id arg is deprecated
 
 	uint32_t _ALIGN(32) hash64[8];
 	uint32_t _ALIGN(32) endiandata[20];
@@ -56,10 +59,10 @@ int scanhash_blakecoin( int thr_id, struct work *work, uint32_t max_nonce,
 		HTarget = 0x7f;
 
 	// we need big endian data...
-        for (int kk=0; kk < 19; kk++) 
-                be32enc(&endiandata[kk], ((uint32_t*)pdata)[kk]);
+   for (int kk=0; kk < 19; kk++) 
+      be32enc(&endiandata[kk], ((uint32_t*)pdata)[kk]);
 
-        blake_midstate_init( endiandata );
+   blake_midstate_init( endiandata );
 
 #ifdef DEBUG_ALGO
 	applog(LOG_DEBUG,"[%d] Target=%08x %08x", thr_id, ptarget[6], ptarget[7]);
@@ -92,33 +95,4 @@ int scanhash_blakecoin( int thr_id, struct work *work, uint32_t max_nonce,
 	return 0;
 }
 
-/*
-void blakecoin_gen_merkle_root ( char* merkle_root, struct stratum_ctx* sctx )
-{
- SHA256( sctx->job.coinbase, (int)sctx->job.coinbase_size, merkle_root );
-}
-*/
-
-// changed to get_max64_0x3fffffLL in cpuminer-multi-decred
-int64_t blakecoin_get_max64 ()
-{
-  return 0x7ffffLL;
-}
-
-// vanilla uses default gen merkle root, otherwise identical to blakecoin
-bool register_vanilla_algo( algo_gate_t* gate )
-{
-    gate->scanhash = (void*)&scanhash_blakecoin;
-    gate->hash     = (void*)&blakecoinhash;
-    gate->get_max64 = (void*)&blakecoin_get_max64;
-    blakecoin_init( &blake_init_ctx );
-    return true;
-}
-
-bool register_blakecoin_algo( algo_gate_t* gate )
-{
-  register_vanilla_algo( gate );
-  gate->gen_merkle_root = (void*)&SHA256_gen_merkle_root;
-  return true;
-}
-
+#endif

algo/blake/decred-4way.c

@@ -1,153 +0,0 @@
-#include "decred-gate.h"
-#include "sph_blake.h"
-#include "blake-hash-4way.h"
-#include <string.h>
-#include <stdint.h>
-#include <memory.h>
-#include <unistd.h>
-
-#if defined (DECRED_4WAY)
-
-static __thread blake256_4way_context blake_mid;
-static __thread bool ctx_midstate_done = false;
-
-void decred_hash_4way( void *state, const void *input )
-{
-     uint32_t hash0[16] __attribute__ ((aligned (64)));
-     uint32_t hash1[16] __attribute__ ((aligned (64)));
-     uint32_t hash2[16] __attribute__ ((aligned (64)));
-     uint32_t hash3[16] __attribute__ ((aligned (64)));
-     uint32_t vhash[16*4] __attribute__ ((aligned (64)));
-     blake256_4way_context ctx __attribute__ ((aligned (64)));
-
-     sph_blake256_context ctx2 __attribute__ ((aligned (64)));
-     uint32_t hash[16] __attribute__ ((aligned (64)));
-     uint32_t sin0[45], sin1[45], sin2[45], sin3[45];
-     m128_deinterleave_4x32( sin0, sin1, sin2, sin3, (uint32_t*)input, 180*8 );
-
-     void *tail = input + DECRED_MIDSTATE_LEN;
-     int tail_len = 180 - DECRED_MIDSTATE_LEN; 
-//     #define MIDSTATE_LEN 128
-/*
-        uint8_t *ending = (uint8_t*) input;
-        ending += MIDSTATE_LEN;
-
-     if ( !ctx_midstate_done )
-     {
-          blake256_4way_init( &blake_mid );
-          blake256_4way( &blake_mid, input, DECRED_MIDSTATE_LEN );
-          ctx_midstate_done = true;
-     }
-     memcpy( &ctx, &blake_mid, sizeof(blake_mid) );
-
-     blake256_4way( &ctx, tail, tail_len );
-     blake256_4way_close( &ctx, vhash );
-*/
-
-
-     sph_blake256_init( &ctx2 );
-     sph_blake256( &ctx2, sin0, 180 );
-     sph_blake256_close( &ctx2, hash );
-
-     blake256_4way_init( &ctx );
-     blake256_4way( &ctx, input, 180 );
-     blake256_4way_close( &ctx, vhash );
-
-     m128_deinterleave_4x32( hash0, hash1, hash2, hash3, vhash, 512 );
-/*
-        for ( int i = 0; i < 8; i++ )
-          if ( hash[i] != hash0[i] )
-            printf(" hash mismatch, i = %u\n",i);
-
-printf("hash:  %08lx %08lx %08lx %08lx\n", *hash, *(hash+1),
-                             *(hash+2), *(hash+3) );
-printf("hash0: %08lx %08lx %08lx %08lx\n", *hash0, *(hash0+1),
-                             *(hash0+2), *(hash0+3) );
-printf("\n");
-*/
-
-//     memcpy( state,    hash0, 32 );
-//     memcpy( state+32, hash1, 32 );
-//     memcpy( state+64, hash1, 32 );
-//     memcpy( state+96, hash1, 32 );
-
-     memcpy( state, hash, 32 );
-
-}
-
-int scanhash_decred_4way( int thr_id, struct work *work, uint32_t max_nonce,
-                          uint64_t *hashes_done)
-{
-   uint32_t vdata[45*4] __attribute__ ((aligned (64)));
-   uint32_t hash[4*8] __attribute__ ((aligned (64)));
-        uint32_t _ALIGN(64) endiandata[48];
-//        uint32_t _ALIGN(64) hash32[8];
-        uint32_t *pdata = work->data;
-        uint32_t *ptarget = work->target;
-        const uint32_t first_nonce = pdata[DECRED_NONCE_INDEX];
-        uint32_t n = first_nonce;
-        const uint32_t HTarget = opt_benchmark ? 0x7f : ptarget[7];
-   uint32_t *nonces = work->nonces;
-   bool *found = work->nfound;
-   int num_found = 0;
-
-//        #define DCR_NONCE_OFT32 35
-
-        ctx_midstate_done = false;
-
-//        memcpy(endiandata, pdata, 180);
-
-   m128_interleave_4x32( vdata, pdata, pdata, pdata, pdata, 180*8 );
-
-   uint32_t *noncep = vdata + DECRED_NONCE_INDEX * 4;
-   do {
-      found[0] = found[1] = found[2] = found[3] = false;
-      * noncep    = n;
-      *(noncep+2) = n+1;
-      *(noncep+4) = n+2;
-      *(noncep+6) = n+3;
-
-      decred_hash_4way( hash, vdata );
-
-//                endiandata[DCR_NONCE_OFT32] = n;
-//                decred_hash(hash32, endiandata);
-
-      if ( hash[7] <= HTarget && fulltest( hash, ptarget ) )
-      {
-          work_set_target_ratio( work, hash );
-          found[0] = true;
-          num_found++;
-          nonces[0] = n;
-          pdata[DECRED_NONCE_INDEX] = n;
-      }
-/*      if ( (hash+8)[7] <= HTarget && fulltest( hash+8, ptarget ) )
-      {
-          work_set_target_ratio( work, hash+8 );
-          found[1] = true;
-          num_found++;
-          nonces[1] = n;
-      }
-      if ( (hash+16)[7] <= HTarget && fulltest( hash+16, ptarget ) )
-      {
-          work_set_target_ratio( work, hash+16 );
-          found[2] = true;
-          num_found++;
-          nonces[2] = n;
-      }
-      if ( (hash+24)[7] <= HTarget && fulltest( hash+24, ptarget ) )
-      {
-          work_set_target_ratio( work, hash+24 );
-          found[3] = true;
-          num_found++;
-          nonces[3] = n;
-      }
-*/
-      n += 4;
-  } while ( (num_found == 0) && (n < max_nonce) 
-            && !work_restart[thr_id].restart );
-
-  *hashes_done = n - first_nonce + 1;
-  return num_found;
-}
-
-#endif

algo/blake/decred-gate.c

@@ -1,176 +0,0 @@
-#include "decred-gate.h"
-#include <unistd.h>
-#include <memory.h>
-#include <string.h>
-
-uint32_t *decred_get_nonceptr( uint32_t *work_data )
-{
-   return &work_data[ DECRED_NONCE_INDEX ];
-}
-
-double decred_calc_network_diff( struct work* work )
-{
-   // sample for diff 43.281 : 1c05ea29
-   // todo: endian reversed on longpoll could be zr5 specific...
-   uint32_t nbits = work->data[ DECRED_NBITS_INDEX ];
-   uint32_t bits = ( nbits & 0xffffff );
-   int16_t shift = ( swab32(nbits) & 0xff ); // 0x1c = 28
-   int m;
-   double d = (double)0x0000ffff / (double)bits;
-
-   for ( m = shift; m < 29; m++ )
-       d *= 256.0;
-   for ( m = 29; m < shift; m++ )
-       d /= 256.0;
-   if ( shift == 28 )
-       d *= 256.0; // testnet
-   if ( opt_debug_diff )
-       applog( LOG_DEBUG, "net diff: %f -> shift %u, bits %08x", d,
-                           shift, bits );
-   return net_diff;
-}
-
-void decred_decode_extradata( struct work* work, uint64_t* net_blocks )
-{
-   // some random extradata to make the work unique
-   work->data[ DECRED_XNONCE_INDEX ] = (rand()*4);
-   work->height = work->data[32];
-   if (!have_longpoll && work->height > *net_blocks + 1)
-   {
-      char netinfo[64] = { 0 };
-      if (opt_showdiff && net_diff > 0.)
-      {
-         if (net_diff != work->targetdiff)
-            sprintf(netinfo, ", diff %.3f, target %.1f", net_diff,
-                   work->targetdiff);
-         else
-             sprintf(netinfo, ", diff %.3f", net_diff);
-       }
-       applog(LOG_BLUE, "%s block %d%s", algo_names[opt_algo], work->height,
-                       netinfo);
-       *net_blocks = work->height - 1;
-   }
-}
-
-void decred_be_build_stratum_request( char *req, struct work *work,
-                                      struct stratum_ctx *sctx )
-{
-   unsigned char *xnonce2str;
-   uint32_t ntime, nonce;
-   char ntimestr[9], noncestr[9];
-
-   be32enc( &ntime, work->data[ DECRED_NTIME_INDEX ] );
-   be32enc( &nonce, work->data[ DECRED_NONCE_INDEX ] );
-   bin2hex( ntimestr, (char*)(&ntime), sizeof(uint32_t) );
-   bin2hex( noncestr, (char*)(&nonce), sizeof(uint32_t) );
-   xnonce2str = abin2hex( (char*)( &work->data[ DECRED_XNONCE_INDEX ] ),
-                                     sctx->xnonce1_size );
-   snprintf( req, JSON_BUF_LEN,
-        "{\"method\": \"mining.submit\", \"params\": [\"%s\", \"%s\", \"%s\", \"%s\", \"%s\"], \"id\":4}",
-         rpc_user, work->job_id, xnonce2str, ntimestr, noncestr );
-   free(xnonce2str);
-}
-#define min(a,b) (a>b ? (b) :(a))
-
-void decred_build_extraheader( struct work* g_work, struct stratum_ctx* sctx )
-{
-   uchar merkle_root[64] = { 0 };
-   uint32_t extraheader[32] = { 0 };
-   int headersize = 0;
-   uint32_t* extradata = (uint32_t*) sctx->xnonce1;
-   size_t t;
-   int i;
-
-   // getwork over stratum, getwork merkle + header passed in coinb1
-   memcpy(merkle_root, sctx->job.coinbase, 32);
-   headersize = min((int)sctx->job.coinbase_size - 32,
-                  sizeof(extraheader) );
-   memcpy( extraheader, &sctx->job.coinbase[32], headersize );
-
-   // Increment extranonce2 
-   for ( t = 0; t < sctx->xnonce2_size && !( ++sctx->job.xnonce2[t] ); t++ );
-
-   // Assemble block header 
-   memset( g_work->data, 0, sizeof(g_work->data) );
-   g_work->data[0] = le32dec( sctx->job.version );
-   for ( i = 0; i < 8; i++ )
-      g_work->data[1 + i] = swab32(
-                              le32dec( (uint32_t *) sctx->job.prevhash + i ) );
-   for ( i = 0; i < 8; i++ )
-      g_work->data[9 + i] = swab32( be32dec( (uint32_t *) merkle_root + i ) );
-
-//   for ( i = 0; i < 8; i++ ) // prevhash
-//      g_work->data[1 + i] = swab32( g_work->data[1 + i] );
-//   for ( i = 0; i < 8; i++ ) // merkle
-//      g_work->data[9 + i] = swab32( g_work->data[9 + i] );
-
-   for ( i = 0; i < headersize/4; i++ ) // header
-      g_work->data[17 + i] = extraheader[i];
-   // extradata
-
-   for ( i = 0; i < sctx->xnonce1_size/4; i++ )
-      g_work->data[ DECRED_XNONCE_INDEX + i ] = extradata[i];
-   for ( i = DECRED_XNONCE_INDEX + sctx->xnonce1_size/4; i < 45; i++ )
-      g_work->data[i] = 0;
-   g_work->data[37] = (rand()*4) << 8;
-   // block header suffix from coinb2 (stake version)
-   memcpy( &g_work->data[44],
-           &sctx->job.coinbase[ sctx->job.coinbase_size-4 ], 4 );
-   sctx->bloc_height = g_work->data[32];
-   //applog_hex(work->data, 180);
-   //applog_hex(&work->data[36], 36);
-}
-
-#undef min
-
-bool decred_ready_to_mine( struct work* work, struct stratum_ctx* stratum,
-                           int thr_id )
-{
-   if ( have_stratum && strcmp(stratum->job.job_id, work->job_id)  )
-      // need to regen g_work..
-      return false;
-   if ( have_stratum && !work->data[0] && !opt_benchmark )
-   {
-      sleep(1);
-      return false;
-   }
-   // extradata: prevent duplicates
-   work->data[ DECRED_XNONCE_INDEX     ] += 1;
-   work->data[ DECRED_XNONCE_INDEX + 1 ] |= thr_id;
-   return true;
-}
-
-
-bool register_decred_algo( algo_gate_t* gate )
-{
-#if defined(DECRED_4WAY)
-  gate->optimizations = SSE2_OPT | AVX_OPT;
-  gate->scanhash  = (void*)&scanhash_decred_4way;
-  gate->hash      = (void*)&decred_hash_4way;
-#else
-  gate->optimizations = SSE2_OPT;
-  gate->scanhash  = (void*)&scanhash_decred;
-  gate->hash      = (void*)&decred_hash;
-#endif
-
-//  gate->optimizations         = SSE2_OPT;
-//  gate->scanhash              = (void*)&scanhash_decred;
-//  gate->hash                  = (void*)&decred_hash;
-  gate->get_nonceptr          = (void*)&decred_get_nonceptr;
-  gate->get_max64             = (void*)&get_max64_0x3fffffLL;
-  gate->display_extra_data    = (void*)&decred_decode_extradata;
-  gate->build_stratum_request = (void*)&decred_be_build_stratum_request;
-  gate->work_decode           = (void*)&std_be_work_decode;
-  gate->submit_getwork_result = (void*)&std_be_submit_getwork_result;
-  gate->build_extraheader     = (void*)&decred_build_extraheader;
-  gate->ready_to_mine         = (void*)&decred_ready_to_mine;
-  gate->nbits_index           = DECRED_NBITS_INDEX;
-  gate->ntime_index           = DECRED_NTIME_INDEX;
-  gate->nonce_index           = DECRED_NONCE_INDEX;
-  gate->work_data_size        = DECRED_DATA_SIZE;
-  gate->work_cmp_size         = DECRED_WORK_COMPARE_SIZE;
-  allow_mininginfo            = false;
-  have_gbt                    = false;
-  return true;
-}
-

algo/blake/decred-gate.h

@@ -1,36 +0,0 @@
-#ifndef __DECRED_GATE_H__
-#define __DECRED_GATE_H__
-
-#include "algo-gate-api.h"
-#include <stdint.h>
-
-#define DECRED_NBITS_INDEX 29
-#define DECRED_NTIME_INDEX 34
-#define DECRED_NONCE_INDEX 35
-#define DECRED_XNONCE_INDEX 36
-#define DECRED_DATA_SIZE 192
-#define DECRED_WORK_COMPARE_SIZE 140
-#define DECRED_MIDSTATE_LEN 128
-
-#if defined (__AVX2__) 
-//void blakehash_84way(void *state, const void *input);
-//int scanhash_blake_8way( int thr_id, struct work *work, uint32_t max_nonce,
-//                         uint64_t *hashes_done );
-#endif
-
-#if defined(FOUR_WAY) && defined(__AVX__)
-  #define DECRED_4WAY
-#endif
-
-#if defined (DECRED_4WAY)
-void decred_hash_4way(void *state, const void *input);
-int scanhash_decred_4way( int thr_id, struct work *work, uint32_t max_nonce,
-                          uint64_t *hashes_done );
-#endif
-
-void decred_hash( void *state, const void *input );
-int scanhash_decred( int thr_id, struct work *work, uint32_t max_nonce,
-                     uint64_t *hashes_done );
-
-#endif
-

algo/blake/decred.c

@@ -1,286 +0,0 @@
-#include "decred-gate.h"
-#include "sph_blake.h"
-
-#include <string.h>
-#include <stdint.h>
-#include <memory.h>
-#include <unistd.h>
-
-/*
-#ifndef min
-#define min(a,b) (a>b ? b : a)
-#endif
-#ifndef max 
-#define max(a,b) (a<b ? b : a)
-#endif
-*/
-/*
-#define DECRED_NBITS_INDEX 29
-#define DECRED_NTIME_INDEX 34
-#define DECRED_NONCE_INDEX 35
-#define DECRED_XNONCE_INDEX 36
-#define DECRED_DATA_SIZE 192
-#define DECRED_WORK_COMPARE_SIZE 140
-*/
-static __thread sph_blake256_context blake_mid;
-static __thread bool ctx_midstate_done = false;
-
-void decred_hash(void *state, const void *input)
-{
-//        #define MIDSTATE_LEN 128
-        sph_blake256_context ctx __attribute__ ((aligned (64)));
-
-        uint8_t *ending = (uint8_t*) input;
-        ending += DECRED_MIDSTATE_LEN;
-
-        if (!ctx_midstate_done) {
-                sph_blake256_init(&blake_mid);
-                sph_blake256(&blake_mid, input, DECRED_MIDSTATE_LEN);
-                ctx_midstate_done = true;
-        }
-        memcpy(&ctx, &blake_mid, sizeof(blake_mid));
-
-        sph_blake256(&ctx, ending, (180 - DECRED_MIDSTATE_LEN));
-        sph_blake256_close(&ctx, state);
-}
-
-void decred_hash_simple(void *state, const void *input)
-{
-        sph_blake256_context ctx;
-        sph_blake256_init(&ctx);
-        sph_blake256(&ctx, input, 180);
-        sph_blake256_close(&ctx, state);
-}
-
-int scanhash_decred(int thr_id, struct work *work, uint32_t max_nonce, uint64_t *hashes_done)
-{
-        uint32_t _ALIGN(64) endiandata[48];
-        uint32_t _ALIGN(64) hash32[8];
-        uint32_t *pdata = work->data;
-        uint32_t *ptarget = work->target;
-
-//        #define DCR_NONCE_OFT32 35
-
-        const uint32_t first_nonce = pdata[DECRED_NONCE_INDEX];
-        const uint32_t HTarget = opt_benchmark ? 0x7f : ptarget[7];
-
-        uint32_t n = first_nonce;
-
-        ctx_midstate_done = false;
-
-#if 1
-        memcpy(endiandata, pdata, 180);
-#else
-        for (int k=0; k < (180/4); k++)
-                be32enc(&endiandata[k], pdata[k]);
-#endif
-
-#ifdef DEBUG_ALGO
-        if (!thr_id) applog(LOG_DEBUG,"[%d] Target=%08x %08x", thr_id, ptarget[6], ptarget[7]);
-#endif
-
-        do {
-                //be32enc(&endiandata[DCR_NONCE_OFT32], n);
-                endiandata[DECRED_NONCE_INDEX] = n;
-                decred_hash(hash32, endiandata);
-
-                if (hash32[7] <= HTarget && fulltest(hash32, ptarget)) {
-                        work_set_target_ratio(work, hash32);
-                        *hashes_done = n - first_nonce + 1;
-#ifdef DEBUG_ALGO
-                        applog(LOG_BLUE, "Nonce : %08x %08x", n, swab32(n));
-                        applog_hash(ptarget);
-                        applog_compare_hash(hash32, ptarget);
-#endif
-                        pdata[DECRED_NONCE_INDEX] = n;
-                        return 1;
-                }
-
-                n++;
-
-        } while (n < max_nonce && !work_restart[thr_id].restart);
-
-        *hashes_done = n - first_nonce + 1;
-        pdata[DECRED_NONCE_INDEX] = n;
-        return 0;
-}
-
-/*
-uint32_t *decred_get_nonceptr( uint32_t *work_data )
-{
-   return &work_data[ DECRED_NONCE_INDEX ];
-}
-
-double decred_calc_network_diff( struct work* work )
-{
-   // sample for diff 43.281 : 1c05ea29
-   // todo: endian reversed on longpoll could be zr5 specific...
-   uint32_t nbits = work->data[ DECRED_NBITS_INDEX ];
-   uint32_t bits = ( nbits & 0xffffff );
-   int16_t shift = ( swab32(nbits) & 0xff ); // 0x1c = 28
-   int m;
-   double d = (double)0x0000ffff / (double)bits;
-
-   for ( m = shift; m < 29; m++ )
-       d *= 256.0;
-   for ( m = 29; m < shift; m++ )
-       d /= 256.0;
-   if ( shift == 28 )
-       d *= 256.0; // testnet
-   if ( opt_debug_diff )
-       applog( LOG_DEBUG, "net diff: %f -> shift %u, bits %08x", d,
-                           shift, bits );
-   return net_diff;
-}
-
-void decred_decode_extradata( struct work* work, uint64_t* net_blocks )
-{
-   // some random extradata to make the work unique
-   work->data[ DECRED_XNONCE_INDEX ] = (rand()*4);
-   work->height = work->data[32];
-   if (!have_longpoll && work->height > *net_blocks + 1)
-   {
-      char netinfo[64] = { 0 };
-      if (opt_showdiff && net_diff > 0.)
-      {
-         if (net_diff != work->targetdiff)
-	    sprintf(netinfo, ", diff %.3f, target %.1f", net_diff,
-                   work->targetdiff);
-	 else
-	     sprintf(netinfo, ", diff %.3f", net_diff);
-       }
-       applog(LOG_BLUE, "%s block %d%s", algo_names[opt_algo], work->height,
-                       netinfo);
-       *net_blocks = work->height - 1;
-   }
-}
-
-void decred_be_build_stratum_request( char *req, struct work *work,
-                                      struct stratum_ctx *sctx )
-{
-   unsigned char *xnonce2str;
-   uint32_t ntime, nonce;
-   char ntimestr[9], noncestr[9];
-
-   be32enc( &ntime, work->data[ DECRED_NTIME_INDEX ] );
-   be32enc( &nonce, work->data[ DECRED_NONCE_INDEX ] );
-   bin2hex( ntimestr, (char*)(&ntime), sizeof(uint32_t) );
-   bin2hex( noncestr, (char*)(&nonce), sizeof(uint32_t) );
-   xnonce2str = abin2hex( (char*)( &work->data[ DECRED_XNONCE_INDEX ] ),
-                                     sctx->xnonce1_size );
-   snprintf( req, JSON_BUF_LEN,
-        "{\"method\": \"mining.submit\", \"params\": [\"%s\", \"%s\", \"%s\", \"%s\", \"%s\"], \"id\":4}",
-         rpc_user, work->job_id, xnonce2str, ntimestr, noncestr );
-   free(xnonce2str);
-}
-*/
-/*
-// data shared between gen_merkle_root and build_extraheader.
-__thread uint32_t decred_extraheader[32] = { 0 };
-__thread int decred_headersize = 0;
-
-void decred_gen_merkle_root( char* merkle_root, struct stratum_ctx* sctx )
-{
-   // getwork over stratum, getwork merkle + header passed in coinb1
-   memcpy(merkle_root, sctx->job.coinbase, 32);
-   decred_headersize = min((int)sctx->job.coinbase_size - 32, 
-                  sizeof(decred_extraheader) );
-   memcpy( decred_extraheader, &sctx->job.coinbase[32], decred_headersize);
-}
-*/
-
-/*
-#define min(a,b) (a>b ? (b) :(a))
-
-void decred_build_extraheader( struct work* g_work, struct stratum_ctx* sctx )
-{
-   uchar merkle_root[64] = { 0 };
-   uint32_t extraheader[32] = { 0 };
-   int headersize = 0;
-   uint32_t* extradata = (uint32_t*) sctx->xnonce1;
-   size_t t;
-   int i;
-
-   // getwork over stratum, getwork merkle + header passed in coinb1
-   memcpy(merkle_root, sctx->job.coinbase, 32);
-   headersize = min((int)sctx->job.coinbase_size - 32,
-                  sizeof(extraheader) );
-   memcpy( extraheader, &sctx->job.coinbase[32], headersize );
-
-   // Increment extranonce2 
-   for ( t = 0; t < sctx->xnonce2_size && !( ++sctx->job.xnonce2[t] ); t++ );
-
-   // Assemble block header 
-   memset( g_work->data, 0, sizeof(g_work->data) );
-   g_work->data[0] = le32dec( sctx->job.version );
-   for ( i = 0; i < 8; i++ )
-      g_work->data[1 + i] = swab32(
-                              le32dec( (uint32_t *) sctx->job.prevhash + i ) );
-   for ( i = 0; i < 8; i++ )
-      g_work->data[9 + i] = swab32( be32dec( (uint32_t *) merkle_root + i ) );
-
-//   for ( i = 0; i < 8; i++ ) // prevhash
-//      g_work->data[1 + i] = swab32( g_work->data[1 + i] );
-//   for ( i = 0; i < 8; i++ ) // merkle
-//      g_work->data[9 + i] = swab32( g_work->data[9 + i] );
-
-   for ( i = 0; i < headersize/4; i++ ) // header
-      g_work->data[17 + i] = extraheader[i];
-   // extradata
-
-   for ( i = 0; i < sctx->xnonce1_size/4; i++ )
-      g_work->data[ DECRED_XNONCE_INDEX + i ] = extradata[i];
-   for ( i = DECRED_XNONCE_INDEX + sctx->xnonce1_size/4; i < 45; i++ )
-      g_work->data[i] = 0;
-   g_work->data[37] = (rand()*4) << 8;
-   // block header suffix from coinb2 (stake version)
-   memcpy( &g_work->data[44],
-           &sctx->job.coinbase[ sctx->job.coinbase_size-4 ], 4 );
-   sctx->bloc_height = g_work->data[32];
-   //applog_hex(work->data, 180);
-   //applog_hex(&work->data[36], 36);
-}
-
-#undef min
-
-bool decred_ready_to_mine( struct work* work, struct stratum_ctx* stratum,
-                           int thr_id )
-{
-   if ( have_stratum && strcmp(stratum->job.job_id, work->job_id)  )
-      // need to regen g_work..
-      return false;
-   if ( have_stratum && !work->data[0] && !opt_benchmark )
-   {
-      sleep(1);
-      return false;
-   }      
-   // extradata: prevent duplicates
-   work->data[ DECRED_XNONCE_INDEX     ] += 1;
-   work->data[ DECRED_XNONCE_INDEX + 1 ] |= thr_id;
-   return true;
-}
-
-
-bool register_decred_algo( algo_gate_t* gate )
-{
-  gate->optimizations         = SSE2_OPT;
-  gate->scanhash              = (void*)&scanhash_decred;
-  gate->hash                  = (void*)&decred_hash;
-  gate->get_nonceptr          = (void*)&decred_get_nonceptr;
-  gate->get_max64             = (void*)&get_max64_0x3fffffLL;
-  gate->display_extra_data    = (void*)&decred_decode_extradata;
-  gate->build_stratum_request = (void*)&decred_be_build_stratum_request;
-  gate->work_decode           = (void*)&std_be_work_decode;
-  gate->submit_getwork_result = (void*)&std_be_submit_getwork_result;
-  gate->build_extraheader     = (void*)&decred_build_extraheader;
-  gate->ready_to_mine         = (void*)&decred_ready_to_mine;
-  gate->nbits_index           = DECRED_NBITS_INDEX;
-  gate->ntime_index           = DECRED_NTIME_INDEX;
-  gate->nonce_index           = DECRED_NONCE_INDEX;
-  gate->work_data_size        = DECRED_DATA_SIZE;
-  gate->work_cmp_size         = DECRED_WORK_COMPARE_SIZE; 
-  allow_mininginfo            = false;
-  have_gbt                    = false;
-  return true;
-}
-*/

algo/blake/pentablake-4way.c

@@ -1,21 +1,15 @@
 #include "pentablake-gate.h"
+
+#if defined(PENTABLAKE_4WAY)
+
 #include <stdlib.h>
 #include <stdint.h>
 #include <string.h>
 #include <stdio.h>
-
-#include "blake-hash-4way.h"
-#include "sph_blake.h"
-
-//#define DEBUG_ALGO
-
-#ifdef PENTABLAKE_4WAY
+#include "blake512-hash.h"
 
 extern void pentablakehash_4way( void *output, const void *input )
 {
-	unsigned char _ALIGN(32) hash[128];
-//	// same as uint32_t hashA[16], hashB[16];
-//	#define hashB hash+64
 
      uint64_t hash0[8] __attribute__ ((aligned (64)));
      uint64_t hash1[8] __attribute__ ((aligned (64)));
@@ -26,80 +20,33 @@ extern void pentablakehash_4way( void *output, const void *input )
 
 
      blake512_4way_init( &ctx );
-     blake512_4way( &ctx, input, 80 );
-     blake512_4way_close( &ctx, vhash );
-
-uint64_t sin0[10], sin1[10], sin2[10], sin3[10];
-m256_deinterleave_4x64( sin0, sin1, sin2, sin3, input, 640 );
-sph_blake512_context ctx2_blake;
-sph_blake512_init(&ctx2_blake);
-sph_blake512(&ctx2_blake, sin0, 80);
-sph_blake512_close(&ctx2_blake, (void*) hash);
-
-m256_deinterleave_4x64( hash0, hash1, hash2, hash3, vhash, 512 );
-uint64_t* hash64 = (uint64_t*)hash;
-for( int i = 0; i < 8; i++ )
-{
-   if ( hash0[i] != hash64[i] )
-      printf("hash mismatch %u\n",i);
-}
-
-     blake512_4way_init( &ctx );
-     blake512_4way( &ctx, vhash, 64 );
+     blake512_4way_update( &ctx, input, 80 );
      blake512_4way_close( &ctx, vhash );
 
      blake512_4way_init( &ctx );
-     blake512_4way( &ctx, vhash, 64 );
+     blake512_4way_update( &ctx, vhash, 64 );
      blake512_4way_close( &ctx, vhash );
 
      blake512_4way_init( &ctx );
-     blake512_4way( &ctx, vhash, 64 );
+     blake512_4way_update( &ctx, vhash, 64 );
      blake512_4way_close( &ctx, vhash );
 
      blake512_4way_init( &ctx );
-     blake512_4way( &ctx, vhash, 64 );
+     blake512_4way_update( &ctx, vhash, 64 );
+     blake512_4way_close( &ctx, vhash );
+
+     blake512_4way_init( &ctx );
+     blake512_4way_update( &ctx, vhash, 64 );
      blake512_4way_close( &ctx, vhash );
 
-     m256_deinterleave_4x64( hash0, hash1, hash2, hash3, vhash, 512 );
      memcpy( output,    hash0, 32 );
      memcpy( output+32, hash1, 32 );
      memcpy( output+64, hash2, 32 );
      memcpy( output+96, hash3, 32 );
-
-/*
-     uint64_t sin0[10] __attribute__ ((aligned (64)));
-     uint64_t sin1[10] __attribute__ ((aligned (64)));
-     uint64_t sin2[10] __attribute__ ((aligned (64)));
-     uint64_t sin3[10] __attribute__ ((aligned (64)));
-
-	sph_blake512_context     ctx_blake;
-
-	sph_blake512_init(&ctx_blake);
-	sph_blake512(&ctx_blake, input, 80);
-	sph_blake512_close(&ctx_blake, hash);
-
-        sph_blake512_init(&ctx_blake);
-	sph_blake512(&ctx_blake, hash, 64);
-	sph_blake512_close(&ctx_blake, hash);
-
-        sph_blake512_init(&ctx_blake);
-	sph_blake512(&ctx_blake, hash, 64);
-	sph_blake512_close(&ctx_blake, hash);
-
-        sph_blake512_init(&ctx_blake);
-	sph_blake512(&ctx_blake, hash, 64);
-	sph_blake512_close(&ctx_blake, hash);
-
-        sph_blake512_init(&ctx_blake);
-	sph_blake512(&ctx_blake, hash, 64);
-	sph_blake512_close(&ctx_blake, hash);
-
-	memcpy(output, hash, 32);
-*/
 }
 
-int scanhash_pentablake_4way( int thr_id, struct work *work,
-                              uint32_t max_nonce, uint64_t *hashes_done )
+int scanhash_pentablake_4way( struct work *work,
+      uint32_t max_nonce, uint64_t *hashes_done, struct thr_info *mythr )
 {
     uint32_t hash[4*8] __attribute__ ((aligned (64)));
     uint32_t vdata[20*4] __attribute__ ((aligned (64)));
@@ -109,13 +56,8 @@ int scanhash_pentablake_4way( int thr_id, struct work *work,
     uint32_t n = pdata[19] - 1;
     const uint32_t first_nonce = pdata[19];
     const uint32_t Htarg = ptarget[7];
-    uint32_t *nonces = work->nonces;
-    bool *found = work->nfound;
-    int num_found = 0;
-    uint32_t *noncep0 = vdata + 73;   // 9*8 + 1
-    uint32_t *noncep1 = vdata + 75;
-    uint32_t *noncep2 = vdata + 77;
-    uint32_t *noncep3 = vdata + 79;
+    uint32_t *noncep = vdata + 73;   // 9*8 + 1
+    int thr_id = mythr->id;  // thr_id arg is deprecated
 
 //    uint32_t _ALIGN(32) hash64[8];
 //    uint32_t _ALIGN(32) endiandata[32];
@@ -141,7 +83,7 @@ int scanhash_pentablake_4way( int thr_id, struct work *work,
     swab32_array( endiandata, pdata, 20 );
 
     uint64_t *edata = (uint64_t*)endiandata;
-    m256_interleave_4x64( (uint64_t*)vdata, edata, edata, edata, edata, 640 );
+    intrlv_4x64( (uint64_t*)vdata, edata, edata, edata, edata, 640 );
 
     for ( int m=0; m < 6; m++ )
     {
@@ -149,47 +91,19 @@ int scanhash_pentablake_4way( int thr_id, struct work *work,
         {
            uint32_t mask = masks[m];
            do {
-              found[0] = found[1] = found[2] = found[3] = false;
-              be32enc( noncep0, n   );
-              be32enc( noncep1, n+1 );
-              be32enc( noncep2, n+2 );
-              be32enc( noncep3, n+3 );
+              be32enc( noncep,   n   );
+              be32enc( noncep+2, n+1 );
+              be32enc( noncep+4, n+2 );
+              be32enc( noncep+6, n+3 );
 
               pentablakehash_4way( hash, vdata );
 
-              // return immediately on nonce found, only one submit
-              if ( ( !(hash[7] & mask) ) && fulltest( hash, ptarget ) )
+              for ( int i = 0; i < 4; i++ )
+              if ( !( (hash+(i<<3))[7] & mask )
+                  && fulltest( hash+(i<<3), ptarget ) && !opt_benchmark )
               {
-                  found[0] = true;
-                  num_found++;
-                  nonces[0] = n;
-                  pdata[19] = n;
-                  *hashes_done = n - first_nonce + 1;
-                  return 1;
-              }
-              if ( (! ((hash+8)[7] & mask) ) && fulltest( hash+8, ptarget ) )
-              {
-                  found[1] = true;
-                  num_found++;
-                  nonces[1] = n;
-                  *hashes_done = n - first_nonce + 1;
-                  return 1;
-              }
-              if ( ( !((hash+16)[7] & mask) ) && fulltest( hash+16, ptarget ) )
-              {
-                  found[2] = true;
-                  num_found++;
-                  nonces[2] = n;
-                  *hashes_done = n - first_nonce + 1;
-                  return 1;
-              }
-              if ( ( !((hash+24)[7] & mask) ) && fulltest( hash+24, ptarget ) )
-              {
-                  found[3] = true;
-                  num_found++;
-                  nonces[3] = n;
-                  *hashes_done = n - first_nonce + 1;
-                  return 1;
+                 pdata[19] = n + i;
+                 submit_solution( work, hash+(i<<3), mythr );
               }
               n += 4;
 

algo/blake/pentablake-gate.c

@@ -3,14 +3,13 @@
 bool register_pentablake_algo( algo_gate_t* gate )
 {
 #if defined (PENTABLAKE_4WAY)
-    gate->optimizations = SSE2_OPT | AVX2_OPT;
     gate->scanhash  = (void*)&scanhash_pentablake_4way;
     gate->hash      = (void*)&pentablakehash_4way;
 #else
     gate->scanhash  = (void*)&scanhash_pentablake;
     gate->hash      = (void*)&pentablakehash;
 #endif
-    gate->get_max64 = (void*)&get_max64_0x3ffff;
+    gate->optimizations = AVX2_OPT;
     return true;
 };
 

algo/blake/pentablake-gate.h

@@ -4,18 +4,19 @@
 #include "algo-gate-api.h"
 #include <stdint.h>
 
-#if defined(FOUR_WAY) && defined(__AVX__)
-  #define PENTABLAKE_4WAY
-#endif
+// 4way is broken
+//#if defined(__AVX2__)
+//  #define PENTABLAKE_4WAY
+//#endif
 
 #if defined(PENTABLAKE_4WAY)
 void pentablakehash_4way( void *state, const void *input );
-int scanhash_pentablake_4way( int thr_id, struct work *work,
-                              uint32_t max_nonce, uint64_t *hashes_done );
+int scanhash_pentablake_4way( struct work *work,
+           uint32_t max_nonce, uint64_t *hashes_done, struct thr_info *mythr );
 #endif
 
 void pentablakehash( void *state, const void *input );
-int scanhash_pentablake( int thr_id, struct work *work, uint32_t max_nonce,
-                         uint64_t *hashes_done );
+int scanhash_pentablake( struct work *work, uint32_t max_nonce,
+            uint64_t *hashes_done, struct thr_info *mythr );
 #endif
 

algo/blake/pentablake.c

@@ -1,4 +1,7 @@
 #include "pentablake-gate.h"
+
+#if !defined(PENTABLAKE_8WAY) && !defined(PENTABLAKE_4WAY)
+
 #include <stdlib.h>
 #include <stdint.h>
 #include <string.h>
@@ -40,8 +43,8 @@ extern void pentablakehash(void *output, const void *input)
 
 }
 
-int scanhash_pentablake(int thr_id, struct work *work, uint32_t max_nonce,
-      uint64_t *hashes_done)
+int scanhash_pentablake( struct work *work, uint32_t max_nonce,
+      uint64_t *hashes_done, struct thr_info *mythr )
 {
         uint32_t *pdata = work->data;
         uint32_t *ptarget = work->target;
@@ -49,6 +52,7 @@ int scanhash_pentablake(int thr_id, struct work *work, uint32_t max_nonce,
 	uint32_t n = pdata[19] - 1;
 	const uint32_t first_nonce = pdata[19];
 	const uint32_t Htarg = ptarget[7];
+   int thr_id = mythr->id;  // thr_id arg is deprecated
 
 	uint32_t _ALIGN(32) hash64[8];
 	uint32_t _ALIGN(32) endiandata[32];
@@ -110,3 +114,4 @@ int scanhash_pentablake(int thr_id, struct work *work, uint32_t max_nonce,
 	return 0;
 } 
 
+#endif

algo/blake/sph-blake2s.c

@@ -14,9 +14,10 @@
 #include <stdint.h>
 #include <string.h>
 #include <stdio.h>
-
-#include "algo/sha/sph_types.h"
-#include "crypto/blake2s.h"
+#include "simd-utils.h"
+#include "compat/sph_types.h"
+#include "compat.h"
+#include "sph-blake2s.h"
 
 static const uint32_t blake2s_IV[8] =
 {
@@ -117,15 +118,15 @@ static inline int blake2s_param_set_inner_length( blake2s_param *P, const uint8_
 	return 0;
 }
 
-static inline int blake2s_param_set_salt( blake2s_param *P, const uint8_t salt[BLAKE2S_SALTBYTES] )
+static inline int blake2s_param_set_salt( blake2s_param *P, const uint8_t salt[8] )
 {
-	memcpy( P->salt, salt, BLAKE2S_SALTBYTES );
+	memcpy( P->salt, salt, 8 );
 	return 0;
 }
 
-static inline int blake2s_param_set_personal( blake2s_param *P, const uint8_t personal[BLAKE2S_PERSONALBYTES] )
+static inline int blake2s_param_set_personal( blake2s_param *P, const uint8_t personal[8] )
 {
-	memcpy( P->personal, personal, BLAKE2S_PERSONALBYTES );
+	memcpy( P->personal, personal, 8 );
 	return 0;
 }
 
@@ -158,7 +159,7 @@ 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;
+	if ( ( !outlen ) || ( outlen > 32 ) ) return -1;
 
 	P->digest_length = outlen;
 	P->key_length    = 0;
@@ -178,9 +179,9 @@ int blake2s_init_key( blake2s_state *S, const uint8_t outlen, const void *key, c
 {
 	blake2s_param P[1];
 
-	if ( ( !outlen ) || ( outlen > BLAKE2S_OUTBYTES ) ) return -1;
+	if ( ( !outlen ) || ( outlen > 32 ) ) return -1;
 
-	if ( !key || !keylen || keylen > BLAKE2S_KEYBYTES ) return -1;
+	if ( !key || !keylen || keylen > 8 ) return -1;
 
 	P->digest_length = outlen;
 	P->key_length    = keylen;
@@ -197,19 +198,19 @@ int blake2s_init_key( blake2s_state *S, const uint8_t outlen, const void *key, c
 	if( blake2s_init_param( S, P ) < 0 ) return -1;
 
 	{
-		uint8_t block[BLAKE2S_BLOCKBYTES];
-		memset( block, 0, BLAKE2S_BLOCKBYTES );
+		uint8_t block[64];
+		memset( block, 0, 64 );
 		memcpy( block, key, keylen );
-		blake2s_update( S, block, BLAKE2S_BLOCKBYTES );
-		secure_zero_memory( block, BLAKE2S_BLOCKBYTES ); /* Burn the key from stack */
+		blake2s_update( S, block, 64 );
+		secure_zero_memory( block, 64 ); /* Burn the key from stack */
 	}
 	return 0;
 }
 
-int blake2s_compress( blake2s_state *S, const uint8_t block[BLAKE2S_BLOCKBYTES] )
+int blake2s_compress( blake2s_state *S, const uint8_t block[64] )
 {
-	uint32_t m[16];
-	uint32_t v[16];
+	uint32_t _ALIGN(32) m[16];
+	uint32_t _ALIGN(32) v[16];
 
 	for( size_t i = 0; i < 16; ++i )
 		m[i] = load32( block + i * sizeof( m[i] ) );
@@ -225,6 +226,58 @@ int blake2s_compress( blake2s_state *S, const uint8_t block[BLAKE2S_BLOCKBYTES]
 	v[13] = S->t[1] ^ blake2s_IV[5];
 	v[14] = S->f[0] ^ blake2s_IV[6];
 	v[15] = S->f[1] ^ blake2s_IV[7];
+
+#if defined(__SSE2__)
+
+   v128_t *V = (v128_t*)v;
+
+#define BLAKE2S_ROUND( r ) \
+   V[0] = v128_add32( V[0], v128_add32( V[1], v128_set32( \
+                  m[blake2s_sigma[r][ 6]], m[blake2s_sigma[r][ 4]], \
+                  m[blake2s_sigma[r][ 2]], m[blake2s_sigma[r][ 0]] ) ) ); \
+   V[3] = v128_ror32( v128_xor( V[3], V[0] ), 16 ); \
+   V[2] = v128_add32( V[2], V[3] ); \
+   V[1] = v128_ror32( v128_xor( V[1], V[2] ), 12 ); \
+   V[0] = v128_add32( V[0], v128_add32( V[1], v128_set32( \
+                   m[blake2s_sigma[r][ 7]], m[blake2s_sigma[r][ 5]], \
+                   m[blake2s_sigma[r][ 3]], m[blake2s_sigma[r][ 1]] ) ) ); \
+   V[3] = v128_ror32( v128_xor( V[3], V[0] ), 8 ); \
+   V[2] = v128_add32( V[2], V[3] ); \
+   V[1] = v128_ror32( v128_xor( V[1], V[2] ), 7 ); \
+   V[0] = v128_shufll32( V[0] ); \
+   V[3] = v128_swap64( V[3] ); \
+   V[2] = v128_shuflr32( V[2] ); \
+   V[0] = v128_add32( V[0], v128_add32( V[1], v128_set32( \
+                    m[blake2s_sigma[r][12]], m[blake2s_sigma[r][10]], \
+                    m[blake2s_sigma[r][ 8]], m[blake2s_sigma[r][14]] ) ) ); \
+   V[3] = v128_ror32( v128_xor( V[3], V[0] ), 16 ); \
+   V[2] = v128_add32( V[2], V[3] ); \
+   V[1] = v128_ror32( v128_xor( V[1], V[2] ), 12 ); \
+   V[0] = v128_add32( V[0], v128_add32( V[1], v128_set32( \
+                    m[blake2s_sigma[r][13]], m[blake2s_sigma[r][11]], \
+                    m[blake2s_sigma[r][ 9]], m[blake2s_sigma[r][15]] ) ) ); \
+   V[3] = v128_ror32( v128_xor( V[3], V[0] ), 8 ); \
+   V[2] = v128_add32( V[2], V[3] ); \
+   V[1] = v128_ror32( v128_xor( V[1], V[2] ), 7 ); \
+   V[0] = v128_shuflr32( V[0] ); \
+   V[3] = v128_swap64( V[3] ); \
+   V[2] = v128_shufll32( V[2] )
+
+   BLAKE2S_ROUND(0);
+   BLAKE2S_ROUND(1);
+   BLAKE2S_ROUND(2);
+   BLAKE2S_ROUND(3);
+   BLAKE2S_ROUND(4);
+   BLAKE2S_ROUND(5);
+   BLAKE2S_ROUND(6);
+   BLAKE2S_ROUND(7);
+   BLAKE2S_ROUND(8);
+   BLAKE2S_ROUND(9);
+   
+#undef BLAKE2S_ROUND
+
+#else
+
 #define G(r,i,a,b,c,d) \
 	do { \
 		a = a + b + m[blake2s_sigma[r][2*i+0]]; \
@@ -236,6 +289,7 @@ int blake2s_compress( blake2s_state *S, const uint8_t block[BLAKE2S_BLOCKBYTES]
 		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]); \
@@ -247,7 +301,8 @@ int blake2s_compress( blake2s_state *S, const uint8_t block[BLAKE2S_BLOCKBYTES]
 		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( 0 );
 	ROUND( 1 );
 	ROUND( 2 );
 	ROUND( 3 );
@@ -258,6 +313,8 @@ int blake2s_compress( blake2s_state *S, const uint8_t block[BLAKE2S_BLOCKBYTES]
 	ROUND( 8 );
 	ROUND( 9 );
 
+#endif
+
 	for( size_t i = 0; i < 8; ++i )
 		S->h[i] = S->h[i] ^ v[i] ^ v[i + 8];
 
@@ -272,16 +329,16 @@ 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;
+		size_t fill = 2 * 64 - left;
 
 		if( inlen > fill )
 		{
 			memcpy( S->buf + left, in, fill ); // Fill buffer
 			S->buflen += fill;
-			blake2s_increment_counter( S, BLAKE2S_BLOCKBYTES );
+			blake2s_increment_counter( S, 64 );
 			blake2s_compress( S, S->buf ); // Compress
-			memcpy( S->buf, S->buf + BLAKE2S_BLOCKBYTES, BLAKE2S_BLOCKBYTES ); // Shift buffer left
-			S->buflen -= BLAKE2S_BLOCKBYTES;
+			memcpy( S->buf, S->buf + 64, 64 ); // Shift buffer left
+			S->buflen -= 64;
 			in += fill;
 			inlen -= fill;
 		}
@@ -299,19 +356,19 @@ 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 )
 {
-	uint8_t buffer[BLAKE2S_OUTBYTES];
+	uint8_t buffer[32];
 
-	if( S->buflen > BLAKE2S_BLOCKBYTES )
+	if( S->buflen > 64 )
 	{
-		blake2s_increment_counter( S, BLAKE2S_BLOCKBYTES );
+		blake2s_increment_counter( S, 64 );
 		blake2s_compress( S, S->buf );
-		S->buflen -= BLAKE2S_BLOCKBYTES;
-		memcpy( S->buf, S->buf + BLAKE2S_BLOCKBYTES, S->buflen );
+		S->buflen -= 64;
+		memcpy( S->buf, S->buf + 64, 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 */
+	memset( S->buf + S->buflen, 0, 2 * 64 - S->buflen ); /* Padding */
 	blake2s_compress( S, S->buf );
 
 	for( int i = 0; i < 8; ++i ) /* Output full hash to temp buffer */
@@ -323,7 +380,7 @@ int blake2s_final( blake2s_state *S, uint8_t *out, uint8_t outlen )
 
 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];
+	blake2s_state S;
 
 	/* Verify parameters */
 	if ( NULL == in ) return -1;
@@ -334,15 +391,15 @@ int blake2s( uint8_t *out, const void *in, const void *key, const uint8_t outlen
 
 	if( keylen > 0 )
 	{
-		if( blake2s_init_key( S, outlen, key, keylen ) < 0 ) return -1;
+		if( blake2s_init_key( &S, outlen, key, keylen ) < 0 ) return -1;
 	}
 	else
 	{
-		if( blake2s_init( S, outlen ) < 0 ) return -1;
+		if( blake2s_init( &S, outlen ) < 0 ) return -1;
 	}
 
-	blake2s_update( S, ( uint8_t * )in, inlen );
-	blake2s_final( S, out, outlen );
+	blake2s_update( &S, ( uint8_t * )in, inlen );
+	blake2s_final( &S, out, outlen );
 	return 0;
 }
 
@@ -351,10 +408,10 @@ int blake2s( uint8_t *out, const void *in, const void *key, const uint8_t outlen
 #include "blake2-kat.h" /* test data not included */
 int main( int argc, char **argv )
 {
-	uint8_t key[BLAKE2S_KEYBYTES];
+	uint8_t key[8];
 	uint8_t buf[KAT_LENGTH];
 
-	for( size_t i = 0; i < BLAKE2S_KEYBYTES; ++i )
+	for( size_t i = 0; i < 8; ++i )
 		key[i] = ( uint8_t )i;
 
 	for( size_t i = 0; i < KAT_LENGTH; ++i )
@@ -362,10 +419,10 @@ int main( int argc, char **argv )
 
 	for( size_t i = 0; i < KAT_LENGTH; ++i )
 	{
-		uint8_t hash[BLAKE2S_OUTBYTES];
-		blake2s( hash, buf, key, BLAKE2S_OUTBYTES, i, BLAKE2S_KEYBYTES );
+		uint8_t hash[32];
+		blake2s( hash, buf, key, 32, i, );
 
-		if( 0 != memcmp( hash, blake2s_keyed_kat[i], BLAKE2S_OUTBYTES ) )
+		if( 0 != memcmp( hash, blake2s_keyed_kat[i], 32 ) )
 		{
 			puts( "error" );
 			return -1;

algo/blake/sph-blake2s.h

@@ -87,19 +87,6 @@ static inline void secure_zero_memory(void *v, size_t n)
 
 /* 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
 	{
@@ -112,22 +99,22 @@ extern "C" {
 		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
+		uint8_t  salt[8]; // 24
+		uint8_t  personal[8];  // 32
 	} blake2s_param;
 
-	ALIGN( 64 ) typedef struct __blake2s_state
+	typedef struct ALIGN( 64 ) __blake2s_state
 	{
 		uint32_t h[8];
 		uint32_t t[2];
 		uint32_t f[2];
-		uint8_t  buf[2 * BLAKE2S_BLOCKBYTES];
+		uint8_t  buf[2 * 64];
 		size_t   buflen;
 		uint8_t  last_node;
 	} blake2s_state ;
 #pragma pack(pop)
 
-	int blake2s_compress( blake2s_state *S, const uint8_t block[BLAKE2S_BLOCKBYTES] );
+	int blake2s_compress( blake2s_state *S, const uint8_t block[64] );
 
 	// Streaming API
 	int blake2s_init( blake2s_state *S, const uint8_t outlen );

algo/blake/sph_blake.c

@@ -630,6 +630,69 @@ static const sph_u64 CB[16] = {
 		H7 ^= S3 ^ V7 ^ VF; \
 	} while (0)
 
+#define COMPRESS32_LE   do { \
+      sph_u32 M0, M1, M2, M3, M4, M5, M6, M7; \
+      sph_u32 M8, M9, MA, MB, MC, MD, ME, MF; \
+      sph_u32 V0, V1, V2, V3, V4, V5, V6, V7; \
+      sph_u32 V8, V9, VA, VB, VC, VD, VE, VF; \
+      V0 = H0; \
+      V1 = H1; \
+      V2 = H2; \
+      V3 = H3; \
+      V4 = H4; \
+      V5 = H5; \
+      V6 = H6; \
+      V7 = H7; \
+      V8 = S0 ^ CS0; \
+      V9 = S1 ^ CS1; \
+      VA = S2 ^ CS2; \
+      VB = S3 ^ CS3; \
+      VC = T0 ^ CS4; \
+      VD = T0 ^ CS5; \
+      VE = T1 ^ CS6; \
+      VF = T1 ^ CS7; \
+      M0 = *((uint32_t*)(buf +  0)); \
+      M1 = *((uint32_t*)(buf +  4)); \
+      M2 = *((uint32_t*)(buf +  8)); \
+      M3 = *((uint32_t*)(buf + 12)); \
+      M4 = *((uint32_t*)(buf + 16)); \
+      M5 = *((uint32_t*)(buf + 20)); \
+      M6 = *((uint32_t*)(buf + 24)); \
+      M7 = *((uint32_t*)(buf + 28)); \
+      M8 = *((uint32_t*)(buf + 32)); \
+      M9 = *((uint32_t*)(buf + 36)); \
+      MA = *((uint32_t*)(buf + 40)); \
+      MB = *((uint32_t*)(buf + 44)); \
+      MC = *((uint32_t*)(buf + 48)); \
+      MD = *((uint32_t*)(buf + 52)); \
+      ME = *((uint32_t*)(buf + 56)); \
+      MF = *((uint32_t*)(buf + 60)); \
+      ROUND_S(0); \
+      ROUND_S(1); \
+      ROUND_S(2); \
+      ROUND_S(3); \
+      ROUND_S(4); \
+      ROUND_S(5); \
+      ROUND_S(6); \
+      ROUND_S(7); \
+      if (BLAKE32_ROUNDS == 14) { \
+      ROUND_S(8); \
+      ROUND_S(9); \
+      ROUND_S(0); \
+      ROUND_S(1); \
+      ROUND_S(2); \
+      ROUND_S(3); \
+      } \
+      H0 ^= S0 ^ V0 ^ V8; \
+      H1 ^= S1 ^ V1 ^ V9; \
+      H2 ^= S2 ^ V2 ^ VA; \
+      H3 ^= S3 ^ V3 ^ VB; \
+      H4 ^= S0 ^ V4 ^ VC; \
+      H5 ^= S1 ^ V5 ^ VD; \
+      H6 ^= S2 ^ V6 ^ VE; \
+      H7 ^= S3 ^ V7 ^ VF; \
+   } while (0)
+
 #endif
 
 #if SPH_64
@@ -843,6 +906,45 @@ blake32(sph_blake_small_context *sc, const void *data, size_t len)
 	sc->ptr = ptr;
 }
 
+static void
+blake32_le(sph_blake_small_context *sc, const void *data, size_t len)
+{
+   unsigned char *buf;
+   size_t ptr;
+   DECL_STATE32
+
+   buf = sc->buf;
+   ptr = sc->ptr;
+
+   if (len < (sizeof sc->buf) - ptr) {
+      memcpy(buf + ptr, data, len);
+      ptr += len;
+      sc->ptr = ptr;
+      return;
+   }
+
+   READ_STATE32(sc);
+   while (len > 0) {
+      size_t clen;
+
+      clen = (sizeof sc->buf) - ptr;
+      if (clen > len)
+         clen = len;
+      memcpy(buf + ptr, data, clen);
+      ptr += clen;
+      data = (const unsigned char *)data + clen;
+      len -= clen;
+      if (ptr == sizeof sc->buf) {
+         if ((T0 = SPH_T32(T0 + 512)) < 512)
+            T1 = SPH_T32(T1 + 1);
+         COMPRESS32_LE;
+         ptr = 0;
+      }
+   }
+   WRITE_STATE32(sc);
+   sc->ptr = ptr;
+}
+
 static void
 blake32_close(sph_blake_small_context *sc,
 	unsigned ub, unsigned n, void *dst, size_t out_size_w32)
@@ -872,6 +974,7 @@ blake32_close(sph_blake_small_context *sc,
 	} else {
 		sc->T0 -= 512 - bit_len;
 	}
+
 	if (bit_len <= 446) {
 		memset(u.buf + ptr + 1, 0, 55 - ptr);
 		if (out_size_w32 == 8)
@@ -1049,6 +1152,12 @@ sph_blake256(void *cc, const void *data, size_t len)
 	blake32(cc, data, len);
 }
 
+void
+sph_blake256_update_le(void *cc, const void *data, size_t len)
+{
+   blake32_le(cc, data, len);
+}
+
 /* see sph_blake.h */
 void
 sph_blake256_close(void *cc, void *dst)

algo/blake/sph_blake.h

@@ -42,7 +42,7 @@ extern "C"{
 #endif
 
 #include <stddef.h>
-#include "algo/sha/sph_types.h"
+#include "compat/sph_types.h"
 
 /**
  * Output size (in bits) for BLAKE-224.
@@ -82,9 +82,9 @@ typedef struct {
 #ifndef DOXYGEN_IGNORE
 	unsigned char buf[64];    /* first field, for alignment */
 	size_t ptr;
-	sph_u32 H[8];
-	sph_u32 S[4];
-	sph_u32 T0, T1;
+	uint32_t H[8];
+	uint32_t S[4];
+	uint32_t T0, T1;
 #endif
 } sph_blake_small_context;
 
@@ -198,6 +198,7 @@ void sph_blake256_init(void *cc);
  * @param len    the input data length (in bytes)
  */
 void sph_blake256(void *cc, const void *data, size_t len);
+void sph_blake256_update_le(void *cc, const void *data, size_t len);
 
 /**
  * Terminate the current BLAKE-256 computation and output the result into

algo/blake/sph_blake2b.c

@@ -30,18 +30,11 @@
 #include <stdlib.h>
 #include <stdint.h>
 #include <string.h>
-
-#include "algo/sha/sph_types.h"
+#include "simd-utils.h"
+#include "compat/sph_types.h"
 #include "sph_blake2b.h"
 
-// Cyclic right rotation.
-
-#ifndef ROTR64
-#define ROTR64(x, y)  (((x) >> (y)) ^ ((x) << (64 - (y))))
-#endif
-
 // Little-endian byte access.
-
 #define B2B_GET64(p)                            \
 	(((uint64_t) ((uint8_t *) (p))[0]) ^        \
 	(((uint64_t) ((uint8_t *) (p))[1]) << 8) ^  \
@@ -52,47 +45,198 @@
 	(((uint64_t) ((uint8_t *) (p))[6]) << 48) ^ \
 	(((uint64_t) ((uint8_t *) (p))[7]) << 56))
 
-// G Mixing function.
+#if defined(__AVX2__)
 
-#define B2B_G(a, b, c, d, x, y) {   \
-	v[a] = v[a] + v[b] + x;         \
-	v[d] = ROTR64(v[d] ^ v[a], 32); \
-	v[c] = v[c] + v[d];             \
-	v[b] = ROTR64(v[b] ^ v[c], 24); \
-	v[a] = v[a] + v[b] + y;         \
-	v[d] = ROTR64(v[d] ^ v[a], 16); \
-	v[c] = v[c] + v[d];             \
-	v[b] = ROTR64(v[b] ^ v[c], 63); }
+#define BLAKE2B_G( Sa, Sb, Sc, Sd, Se, Sf, Sg, Sh ) \
+{ \
+  V[0] = _mm256_add_epi64( V[0], _mm256_add_epi64( V[1], \
+              _mm256_set_epi64x( m[ sigmaR[ Sg ] ], m[ sigmaR[ Se ] ], \
+                                 m[ sigmaR[ Sc ] ], m[ sigmaR[ Sa ] ] ) ) ); \
+  V[3] = mm256_ror_64( _mm256_xor_si256( V[3], V[0] ), 32 ); \
+  V[2] = _mm256_add_epi64( V[2], V[3] ); \
+  V[1] = mm256_ror_64( _mm256_xor_si256( V[1], V[2] ), 24 ); \
+\
+  V[0] = _mm256_add_epi64( V[0], _mm256_add_epi64( V[1], \
+              _mm256_set_epi64x( m[ sigmaR[ Sh ] ], m[ sigmaR[ Sf ] ], \
+                                 m[ sigmaR[ Sd ] ], m[ sigmaR[ Sb ] ] ) ) ); \
+  V[3] = mm256_ror_64( _mm256_xor_si256( V[3], V[0] ), 16 ); \
+  V[2] = _mm256_add_epi64( V[2], V[3] ); \
+  V[1] = mm256_ror_64( _mm256_xor_si256( V[1], V[2] ), 63 ); \
+}
+
+// Pivot about V[1] instead of V[0] reduces latency.
+#define BLAKE2B_ROUND( R ) \
+{ \
+  __m256i *V = (__m256i*)v; \
+  const uint8_t *sigmaR = sigma[R]; \
+  BLAKE2B_G(  0,  1,  2,  3,  4,  5,  6,  7 ); \
+  V[0] = mm256_shufll_64( V[0] ); \
+  V[3] = mm256_swap_128( V[3] ); \
+  V[2] = mm256_shuflr_64( V[2] ); \
+  BLAKE2B_G( 14, 15,  8,  9, 10, 11, 12, 13 ); \
+  V[0] = mm256_shuflr_64( V[0] ); \
+  V[3] = mm256_swap_128( V[3] ); \
+  V[2] = mm256_shufll_64( V[2] ); \
+}
+
+/*
+#define BLAKE2B_ROUND( R ) \
+{ \
+  __m256i *V = (__m256i*)v; \
+  const uint8_t *sigmaR = sigma[R]; \
+  BLAKE2B_G(  0,  1,  2,  3,  4,  5,  6,  7 ); \
+  V[3] = mm256_shufll_64( V[3] ); \
+  V[2] = mm256_swap_128( V[2] ); \
+  V[1] = mm256_shuflr_64( V[1] ); \
+  BLAKE2B_G(  8,  9, 10, 11, 12, 13, 14, 15 ); \
+  V[3] = mm256_shuflr_64( V[3] ); \
+  V[2] = mm256_swap_128( V[2] ); \
+  V[1] = mm256_shufll_64( V[1] ); \
+}
+*/
+
+#elif defined(__SSE2__) || defined(__ARM_NEON)
+
+#define BLAKE2B_G( Va, Vb, Vc, Vd, Sa, Sb, Sc, Sd ) \
+{ \
+   Va = v128_add64( Va, v128_add64( Vb, \
+                 v128_set64( m[ sigmaR[ Sc ] ], m[ sigmaR[ Sa ] ] ) ) ); \
+   Vd = v128_ror64( v128_xor( Vd, Va ), 32 ); \
+   Vc = v128_add64( Vc, Vd ); \
+   Vb = v128_ror64( v128_xor( Vb, Vc ), 24 ); \
+\
+   Va = v128_add64( Va, v128_add64( Vb, \
+                 v128_set64( m[ sigmaR[ Sd ] ], m[ sigmaR[ Sb ] ] ) ) ); \
+   Vd = v128_ror64( v128_xor( Vd, Va ), 16 ); \
+   Vc = v128_add64( Vc, Vd ); \
+   Vb = v128_ror64( v128_xor( Vb, Vc ), 63 ); \
+}
+
+#define BLAKE2B_ROUND( R ) \
+{ \
+   v128_t *V = (v128_t*)v; \
+   v128_t V2, V3, V6, V7; \
+   const uint8_t *sigmaR = sigma[R]; \
+   BLAKE2B_G( V[0], V[2], V[4], V[6], 0, 1, 2, 3 ); \
+   BLAKE2B_G( V[1], V[3], V[5], V[7], 4, 5, 6, 7 ); \
+   V2 = v128_alignr64( V[3], V[2], 1 ); \
+   V3 = v128_alignr64( V[2], V[3], 1 ); \
+   V6 = v128_alignr64( V[6], V[7], 1 ); \
+   V7 = v128_alignr64( V[7], V[6], 1 ); \
+   BLAKE2B_G( V[0], V2, V[5], V6,  8,  9, 10, 11 ); \
+   BLAKE2B_G( V[1], V3, V[4], V7, 12, 13, 14, 15 ); \
+   V[2] = v128_alignr64( V2, V3, 1 ); \
+   V[3] = v128_alignr64( V3, V2, 1 ); \
+   V[6] = v128_alignr64( V7, V6, 1 ); \
+   V[7] = v128_alignr64( V6, V7, 1 ); \
+}
+
+/*
+#elif defined(__SSE2__)
+// always true
+
+#define BLAKE2B_G( Va, Vb, Vc, Vd, Sa, Sb, Sc, Sd ) \
+{ \
+   Va = _mm_add_epi64( Va, _mm_add_epi64( Vb, \
+                 _mm_set_epi64x( m[ sigmaR[ Sc ] ], m[ sigmaR[ Sa ] ] ) ) ); \
+   Vd = mm128_swap64_32( _mm_xor_si128( Vd, Va ) ); \
+   Vc = _mm_add_epi64( Vc, Vd ); \
+   Vb = mm128_shuflr64_24( _mm_xor_si128( Vb, Vc ) ); \
+\
+   Va = _mm_add_epi64( Va, _mm_add_epi64( Vb, \
+                 _mm_set_epi64x( m[ sigmaR[ Sd ] ], m[ sigmaR[ Sb ] ] ) ) ); \
+   Vd = mm128_shuflr64_16( _mm_xor_si128( Vd, Va ) ); \
+   Vc = _mm_add_epi64( Vc, Vd ); \
+   Vb = mm128_ror_64( _mm_xor_si128( Vb, Vc ), 63 ); \
+}
+
+#define BLAKE2B_ROUND( R ) \
+{ \
+   v128_t *V = (v128_t*)v; \
+   v128_t V2, V3, V6, V7; \
+   const uint8_t *sigmaR = sigma[R]; \
+   BLAKE2B_G( V[0], V[2], V[4], V[6], 0, 1, 2, 3 ); \
+   BLAKE2B_G( V[1], V[3], V[5], V[7], 4, 5, 6, 7 ); \
+   V2 = mm128_alignr_64( V[3], V[2], 1 ); \
+   V3 = mm128_alignr_64( V[2], V[3], 1 ); \
+   V6 = mm128_alignr_64( V[6], V[7], 1 ); \
+   V7 = mm128_alignr_64( V[7], V[6], 1 ); \
+   BLAKE2B_G( V[0], V2, V[5], V6,  8,  9, 10, 11 ); \
+   BLAKE2B_G( V[1], V3, V[4], V7, 12, 13, 14, 15 ); \
+   V[2] = mm128_alignr_64( V2, V3, 1 ); \
+   V[3] = mm128_alignr_64( V3, V2, 1 ); \
+   V[6] = mm128_alignr_64( V7, V6, 1 ); \
+   V[7] = mm128_alignr_64( V6, V7, 1 ); \
+}
+*/
+
+#else
+// never used, SSE2 is always available
+
+#ifndef ROTR64
+#define ROTR64(x, y)  (((x) >> (y)) ^ ((x) << (64 - (y))))
+#endif
+
+#define BLAKE2B_G( R, Va, Vb, Vc, Vd, Sa, Sb ) \
+{ \
+   Va = Va + Vb + m[ sigma[R][Sa] ]; \
+   Vd = ROTR64( Vd ^ Va, 32 ); \
+   Vc = Vc + Vd; \
+   Vb = ROTR64( Vb ^ Vc, 24 ); \
+\
+   Va = Va + Vb + m[ sigma[R][Sb] ]; \
+   Vd = ROTR64( Vd ^ Va, 16 ); \
+   Vc = Vc + Vd; \
+   Vb = ROTR64( Vb ^ Vc, 63 ); \
+}
+
+#define BLAKE2B_ROUND( R ) \
+{ \
+   BLAKE2B_G( R, v[ 0], v[ 4], v[ 8], v[12],  0,  1 ); \
+   BLAKE2B_G( R, v[ 1], v[ 5], v[ 9], v[13],  2,  3 ); \
+   BLAKE2B_G( R, v[ 2], v[ 6], v[10], v[14],  4,  5 ); \
+   BLAKE2B_G( R, v[ 3], v[ 7], v[11], v[15],  6,  7 ); \
+   BLAKE2B_G( R, v[ 0], v[ 5], v[10], v[15],  8,  9 ); \
+   BLAKE2B_G( R, v[ 1], v[ 6], v[11], v[12], 10, 11 ); \
+   BLAKE2B_G( R, v[ 2], v[ 7], v[ 8], v[13], 12, 13 ); \
+   BLAKE2B_G( R, v[ 3], v[ 4], v[ 9], v[14], 14, 15 ); \
+}
+
+#endif
 
 // Initialization Vector.
 
-static const uint64_t blake2b_iv[8] = {
+static const uint64_t blake2b_iv[8] __attribute__ ((aligned (32))) =
+{
 	0x6A09E667F3BCC908, 0xBB67AE8584CAA73B,
 	0x3C6EF372FE94F82B, 0xA54FF53A5F1D36F1,
 	0x510E527FADE682D1, 0x9B05688C2B3E6C1F,
 	0x1F83D9ABFB41BD6B, 0x5BE0CD19137E2179
 };
 
+static const uint8_t sigma[12][16] __attribute__ ((aligned (32))) =
+{
+      { 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 },
+      { 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 }
+};
+
 // Compression function. "last" flag indicates last block.
 
 static void blake2b_compress( sph_blake2b_ctx *ctx, int last )
 {
-	const uint8_t sigma[12][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 },
-		{ 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 }
-	};
-	int i;
-	uint64_t v[16], m[16];
+	uint64_t v[16] __attribute__ ((aligned (32)));
+   uint64_t m[16] __attribute__ ((aligned (32)));
+   int i;
 
 	for (i = 0; i < 8; i++) {           // init work variables
 		v[i] = ctx->h[i];
@@ -103,20 +247,11 @@ static void blake2b_compress( sph_blake2b_ctx *ctx, int last )
 	v[13] ^= ctx->t[1];                 // high 64 bits
 	if (last)                           // last block flag set ?
 		v[14] = ~v[14];
-
 	for (i = 0; i < 16; i++)            // get little-endian words
 		m[i] = B2B_GET64(&ctx->b[8 * i]);
 
-	for (i = 0; i < 12; i++) {          // twelve rounds
-		B2B_G( 0, 4,  8, 12, m[sigma[i][ 0]], m[sigma[i][ 1]]);
-		B2B_G( 1, 5,  9, 13, m[sigma[i][ 2]], m[sigma[i][ 3]]);
-		B2B_G( 2, 6, 10, 14, m[sigma[i][ 4]], m[sigma[i][ 5]]);
-		B2B_G( 3, 7, 11, 15, m[sigma[i][ 6]], m[sigma[i][ 7]]);
-		B2B_G( 0, 5, 10, 15, m[sigma[i][ 8]], m[sigma[i][ 9]]);
-		B2B_G( 1, 6, 11, 12, m[sigma[i][10]], m[sigma[i][11]]);
-		B2B_G( 2, 7,  8, 13, m[sigma[i][12]], m[sigma[i][13]]);
-		B2B_G( 3, 4,  9, 14, m[sigma[i][14]], m[sigma[i][15]]);
-	}
+	for (i = 0; i < 12; i++)
+      BLAKE2B_ROUND( i );   
 
 	for( i = 0; i < 8; ++i )
 		ctx->h[i] ^= v[i] ^ v[i + 8];
@@ -184,7 +319,8 @@ void sph_blake2b_final( sph_blake2b_ctx *ctx, void *out )
 
 	while (ctx->c < 128)                // fill up with zeros
 		ctx->b[ctx->c++] = 0;
-	blake2b_compress(ctx, 1);           // final block flag = 1
+
+   blake2b_compress(ctx, 1);           // final block flag = 1
 
 	// little endian convert and store
 	for (i = 0; i < ctx->outlen; i++) {

algo/blake/sph_blake2b.h

@@ -18,7 +18,7 @@
 #endif
 
 // state context
-ALIGN(64) typedef struct {
+typedef ALIGN(64) struct {
 	uint8_t b[128]; // input buffer
 	uint64_t h[8];  // chained state
 	uint64_t t[2];  // total number of bytes

algo/blake/sse2/blake.c

@@ -1,476 +0,0 @@
-/* $Id: blake.c 252 2011-06-07 17:55:14Z tp $ */
-/*
- * BLAKE implementation.
- *
- * ==========================(LICENSE BEGIN)============================
- *
- * Copyright (c) 2007-2010  Projet RNRT SAPHIR
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
- * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- * ===========================(LICENSE END)=============================
- *
- * @author   Thomas Pornin <thomas.pornin@cryptolog.com>
- */
-#include <stddef.h>
-#include <string.h>
-#include <limits.h>
-
-#include "../sph_blake.h"
-
-#ifdef __cplusplus
-extern "C"{
-#endif
-
-#ifdef _MSC_VER
-#pragma warning (disable: 4146)
-#endif
-
-static const sph_u64 blkIV512[8] = {
-	SPH_C64(0x6A09E667F3BCC908), SPH_C64(0xBB67AE8584CAA73B),
-	SPH_C64(0x3C6EF372FE94F82B), SPH_C64(0xA54FF53A5F1D36F1),
-	SPH_C64(0x510E527FADE682D1), SPH_C64(0x9B05688C2B3E6C1F),
-	SPH_C64(0x1F83D9ABFB41BD6B), SPH_C64(0x5BE0CD19137E2179)
-};
-
-#define Z00   0
-#define Z01   1
-#define Z02   2
-#define Z03   3
-#define Z04   4
-#define Z05   5
-#define Z06   6
-#define Z07   7
-#define Z08   8
-#define Z09   9
-#define Z0A   A
-#define Z0B   B
-#define Z0C   C
-#define Z0D   D
-#define Z0E   E
-#define Z0F   F
-
-#define Z10   E
-#define Z11   A
-#define Z12   4
-#define Z13   8
-#define Z14   9
-#define Z15   F
-#define Z16   D
-#define Z17   6
-#define Z18   1
-#define Z19   C
-#define Z1A   0
-#define Z1B   2
-#define Z1C   B
-#define Z1D   7
-#define Z1E   5
-#define Z1F   3
-
-#define Z20   B
-#define Z21   8
-#define Z22   C
-#define Z23   0
-#define Z24   5
-#define Z25   2
-#define Z26   F
-#define Z27   D
-#define Z28   A
-#define Z29   E
-#define Z2A   3
-#define Z2B   6
-#define Z2C   7
-#define Z2D   1
-#define Z2E   9
-#define Z2F   4
-
-#define Z30   7
-#define Z31   9
-#define Z32   3
-#define Z33   1
-#define Z34   D
-#define Z35   C
-#define Z36   B
-#define Z37   E
-#define Z38   2
-#define Z39   6
-#define Z3A   5
-#define Z3B   A
-#define Z3C   4
-#define Z3D   0
-#define Z3E   F
-#define Z3F   8
-
-#define Z40   9
-#define Z41   0
-#define Z42   5
-#define Z43   7
-#define Z44   2
-#define Z45   4
-#define Z46   A
-#define Z47   F
-#define Z48   E
-#define Z49   1
-#define Z4A   B
-#define Z4B   C
-#define Z4C   6
-#define Z4D   8
-#define Z4E   3
-#define Z4F   D
-
-#define Z50   2
-#define Z51   C
-#define Z52   6
-#define Z53   A
-#define Z54   0
-#define Z55   B
-#define Z56   8
-#define Z57   3
-#define Z58   4
-#define Z59   D
-#define Z5A   7
-#define Z5B   5
-#define Z5C   F
-#define Z5D   E
-#define Z5E   1
-#define Z5F   9
-
-#define Z60   C
-#define Z61   5
-#define Z62   1
-#define Z63   F
-#define Z64   E
-#define Z65   D
-#define Z66   4
-#define Z67   A
-#define Z68   0
-#define Z69   7
-#define Z6A   6
-#define Z6B   3
-#define Z6C   9
-#define Z6D   2
-#define Z6E   8
-#define Z6F   B
-
-#define Z70   D
-#define Z71   B
-#define Z72   7
-#define Z73   E
-#define Z74   C
-#define Z75   1
-#define Z76   3
-#define Z77   9
-#define Z78   5
-#define Z79   0
-#define Z7A   F
-#define Z7B   4
-#define Z7C   8
-#define Z7D   6
-#define Z7E   2
-#define Z7F   A
-
-#define Z80   6
-#define Z81   F
-#define Z82   E
-#define Z83   9
-#define Z84   B
-#define Z85   3
-#define Z86   0
-#define Z87   8
-#define Z88   C
-#define Z89   2
-#define Z8A   D
-#define Z8B   7
-#define Z8C   1
-#define Z8D   4
-#define Z8E   A
-#define Z8F   5
-
-#define Z90   A
-#define Z91   2
-#define Z92   8
-#define Z93   4
-#define Z94   7
-#define Z95   6
-#define Z96   1
-#define Z97   5
-#define Z98   F
-#define Z99   B
-#define Z9A   9
-#define Z9B   E
-#define Z9C   3
-#define Z9D   C
-#define Z9E   D
-#define Z9F   0
-
-#define Mx(r, i)    Mx_(Z ## r ## i)
-#define Mx_(n)      Mx__(n)
-#define Mx__(n)     M ## n
-
-#define CSx(r, i)   CSx_(Z ## r ## i)
-#define CSx_(n)     CSx__(n)
-#define CSx__(n)    CS ## n
-
-#define CS0   SPH_C32(0x243F6A88)
-#define CS1   SPH_C32(0x85A308D3)
-#define CS2   SPH_C32(0x13198A2E)
-#define CS3   SPH_C32(0x03707344)
-#define CS4   SPH_C32(0xA4093822)
-#define CS5   SPH_C32(0x299F31D0)
-#define CS6   SPH_C32(0x082EFA98)
-#define CS7   SPH_C32(0xEC4E6C89)
-#define CS8   SPH_C32(0x452821E6)
-#define CS9   SPH_C32(0x38D01377)
-#define CSA   SPH_C32(0xBE5466CF)
-#define CSB   SPH_C32(0x34E90C6C)
-#define CSC   SPH_C32(0xC0AC29B7)
-#define CSD   SPH_C32(0xC97C50DD)
-#define CSE   SPH_C32(0x3F84D5B5)
-#define CSF   SPH_C32(0xB5470917)
-
-
-
-#define CBx(r, i)   CBx_(Z ## r ## i)
-#define CBx_(n)     CBx__(n)
-#define CBx__(n)    CB ## n
-
-#define CB0   SPH_C64(0x243F6A8885A308D3)
-#define CB1   SPH_C64(0x13198A2E03707344)
-#define CB2   SPH_C64(0xA4093822299F31D0)
-#define CB3   SPH_C64(0x082EFA98EC4E6C89)
-#define CB4   SPH_C64(0x452821E638D01377)
-#define CB5   SPH_C64(0xBE5466CF34E90C6C)
-#define CB6   SPH_C64(0xC0AC29B7C97C50DD)
-#define CB7   SPH_C64(0x3F84D5B5B5470917)
-#define CB8   SPH_C64(0x9216D5D98979FB1B)
-#define CB9   SPH_C64(0xD1310BA698DFB5AC)
-#define CBA   SPH_C64(0x2FFD72DBD01ADFB7)
-#define CBB   SPH_C64(0xB8E1AFED6A267E96)
-#define CBC   SPH_C64(0xBA7C9045F12C7F99)
-#define CBD   SPH_C64(0x24A19947B3916CF7)
-#define CBE   SPH_C64(0x0801F2E2858EFC16)
-#define CBF   SPH_C64(0x636920D871574E69)
-
-
-#define GS(m0, m1, c0, c1, a, b, c, d)   do { \
-		a = SPH_T32(a + b + (m0 ^ c1)); \
-		d = SPH_ROTR32(d ^ a, 16); \
-		c = SPH_T32(c + d); \
-		b = SPH_ROTR32(b ^ c, 12); \
-		a = SPH_T32(a + b + (m1 ^ c0)); \
-		d = SPH_ROTR32(d ^ a, 8); \
-		c = SPH_T32(c + d); \
-		b = SPH_ROTR32(b ^ c, 7); \
-	} while (0)
-
-#define ROUND_S(r)   do { \
-		GS(Mx(r, 0), Mx(r, 1), CSx(r, 0), CSx(r, 1), V0, V4, V8, VC); \
-		GS(Mx(r, 2), Mx(r, 3), CSx(r, 2), CSx(r, 3), V1, V5, V9, VD); \
-		GS(Mx(r, 4), Mx(r, 5), CSx(r, 4), CSx(r, 5), V2, V6, VA, VE); \
-		GS(Mx(r, 6), Mx(r, 7), CSx(r, 6), CSx(r, 7), V3, V7, VB, VF); \
-		GS(Mx(r, 8), Mx(r, 9), CSx(r, 8), CSx(r, 9), V0, V5, VA, VF); \
-		GS(Mx(r, A), Mx(r, B), CSx(r, A), CSx(r, B), V1, V6, VB, VC); \
-		GS(Mx(r, C), Mx(r, D), CSx(r, C), CSx(r, D), V2, V7, V8, VD); \
-		GS(Mx(r, E), Mx(r, F), CSx(r, E), CSx(r, F), V3, V4, V9, VE); \
-	} while (0)
-
-
-
-#define GB(m0, m1, c0, c1, a, b, c, d)   do { \
-		a = SPH_T64(a + b + (m0 ^ c1)); \
-		d = SPH_ROTR64(d ^ a, 32); \
-		c = SPH_T64(c + d); \
-		b = SPH_ROTR64(b ^ c, 25); \
-		a = SPH_T64(a + b + (m1 ^ c0)); \
-		d = SPH_ROTR64(d ^ a, 16); \
-		c = SPH_T64(c + d); \
-		b = SPH_ROTR64(b ^ c, 11); \
-	} while (0)
-
-#define ROUND_B(r)   do { \
-		GB(Mx(r, 0), Mx(r, 1), CBx(r, 0), CBx(r, 1), V0, V4, V8, VC); \
-		GB(Mx(r, 2), Mx(r, 3), CBx(r, 2), CBx(r, 3), V1, V5, V9, VD); \
-		GB(Mx(r, 4), Mx(r, 5), CBx(r, 4), CBx(r, 5), V2, V6, VA, VE); \
-		GB(Mx(r, 6), Mx(r, 7), CBx(r, 6), CBx(r, 7), V3, V7, VB, VF); \
-		GB(Mx(r, 8), Mx(r, 9), CBx(r, 8), CBx(r, 9), V0, V5, VA, VF); \
-		GB(Mx(r, A), Mx(r, B), CBx(r, A), CBx(r, B), V1, V6, VB, VC); \
-		GB(Mx(r, C), Mx(r, D), CBx(r, C), CBx(r, D), V2, V7, V8, VD); \
-		GB(Mx(r, E), Mx(r, F), CBx(r, E), CBx(r, F), V3, V4, V9, VE); \
-	} while (0)
-
-
-#define COMPRESS64   do { \
-                int b=0; \
-		sph_u64 M0, M1, M2, M3, M4, M5, M6, M7; \
-		sph_u64 M8, M9, MA, MB, MC, MD, ME, MF; \
-		sph_u64 V0, V1, V2, V3, V4, V5, V6, V7; \
-		sph_u64 V8, V9, VA, VB, VC, VD, VE, VF; \
-		V0 = blkH0, \
-		V1 = blkH1, \
-		V2 = blkH2, \
-		V3 = blkH3, \
-		V4 = blkH4, \
-		V5 = blkH5, \
-		V6 = blkH6, \
-		V7 = blkH7; \
-		V8 = blkS0 ^ CB0, \
-		V9 = blkS1 ^ CB1, \
-		VA = blkS2 ^ CB2, \
-		VB = blkS3 ^ CB3, \
-		VC = hashctA ^ CB4, \
-		VD = hashctA ^ CB5, \
-		VE = hashctB ^ CB6, \
-		VF = hashctB ^ CB7; \
-		M0 = sph_dec64be_aligned(buf +   0), \
-		M1 = sph_dec64be_aligned(buf +   8), \
-		M2 = sph_dec64be_aligned(buf +  16), \
-		M3 = sph_dec64be_aligned(buf +  24), \
-		M4 = sph_dec64be_aligned(buf +  32), \
-		M5 = sph_dec64be_aligned(buf +  40), \
-		M6 = sph_dec64be_aligned(buf +  48), \
-		M7 = sph_dec64be_aligned(buf +  56), \
-		M8 = sph_dec64be_aligned(buf +  64), \
-		M9 = sph_dec64be_aligned(buf +  72), \
-		MA = sph_dec64be_aligned(buf +  80), \
-		MB = sph_dec64be_aligned(buf +  88), \
-		MC = sph_dec64be_aligned(buf +  96), \
-		MD = sph_dec64be_aligned(buf + 104), \
-		ME = sph_dec64be_aligned(buf + 112), \
-		MF = sph_dec64be_aligned(buf + 120); \
-                /* loop once and a half */ \
-                /* save some space */ \
-                for (;;) { \
-		    ROUND_B(0); \
-		    ROUND_B(1); \
-		    ROUND_B(2); \
-		    ROUND_B(3); \
-		    ROUND_B(4); \
-		    ROUND_B(5); \
-                    if (b)  break; \
-                    b = 1; \
-		    ROUND_B(6); \
-		    ROUND_B(7); \
-		    ROUND_B(8); \
-		    ROUND_B(9); \
-                }; \
-		blkH0 ^= blkS0 ^ V0 ^ V8, \
-		blkH1 ^= blkS1 ^ V1 ^ V9, \
-		blkH2 ^= blkS2 ^ V2 ^ VA, \
-		blkH3 ^= blkS3 ^ V3 ^ VB, \
-		blkH4 ^= blkS0 ^ V4 ^ VC, \
-		blkH5 ^= blkS1 ^ V5 ^ VD, \
-		blkH6 ^= blkS2 ^ V6 ^ VE, \
-		blkH7 ^= blkS3 ^ V7 ^ VF; \
-	} while (0)
-/*
-*/
-#define DECL_BLK \
-	sph_u64 blkH0; \
-	sph_u64 blkH1; \
-	sph_u64 blkH2; \
-	sph_u64 blkH3; \
-	sph_u64 blkH4; \
-	sph_u64 blkH5; \
-	sph_u64 blkH6; \
-	sph_u64 blkH7; \
-	sph_u64 blkS0; \
-	sph_u64 blkS1; \
-	sph_u64 blkS2; \
-	sph_u64 blkS3; \
-
-/* load initial constants */
-#define BLK_I \
-do { \
-    blkH0 = SPH_C64(0x6A09E667F3BCC908); \
-    blkH1 = SPH_C64(0xBB67AE8584CAA73B); \
-    blkH2 = SPH_C64(0x3C6EF372FE94F82B); \
-    blkH3 = SPH_C64(0xA54FF53A5F1D36F1); \
-    blkH4 = SPH_C64(0x510E527FADE682D1); \
-    blkH5 = SPH_C64(0x9B05688C2B3E6C1F); \
-    blkH6 = SPH_C64(0x1F83D9ABFB41BD6B); \
-    blkH7 = SPH_C64(0x5BE0CD19137E2179); \
-    blkS0 = 0; \
-    blkS1 = 0; \
-    blkS2 = 0; \
-    blkS3 = 0; \
-    hashctB = SPH_T64(0- 1); \
-} while (0)
-
-/* copy in 80 for initial hash */
-#define BLK_W \
-do { \
-    memcpy(hashbuf, input, 80); \
-    hashctA = SPH_C64(0xFFFFFFFFFFFFFC00) + 80*8; \
-    hashptr = 80; \
-} while (0)
-
-/* copy in 64 for looped hash */
-#define BLK_U \
-do { \
-    memcpy(hashbuf, hash , 64); \
-    hashctA = SPH_C64(0xFFFFFFFFFFFFFC00) + 64*8; \
-    hashptr = 64; \
-} while (0)
-
-/* blake compress function */
-/* hash = blake512(loaded) */
-#define BLK_C \
-do { \
-    \
-    union { \
-        unsigned char buf[128]; \
-        sph_u64 dummy; \
-    } u; \
-    size_t ptr; \
-    unsigned bit_len; \
- \
-    ptr = hashptr; \
-    bit_len = ((unsigned)ptr << 3) + 0; \
-    u.buf[ptr] = ((0 & -(0x80)) | (0x80)) & 0xFF; \
-    memset(u.buf + ptr + 1, 0, 111 - ptr); \
-    u.buf[111] |= 1; \
-    sph_enc64be_aligned(u.buf + 112, 0); \
-    sph_enc64be_aligned(u.buf + 120, bit_len); \
-    do { \
-    const void *data = u.buf + ptr; \
-    unsigned char *buf; \
-    buf = hashbuf; \
-    size_t clen; \
-    clen = (sizeof(char)*128) - hashptr; \
-    memcpy(buf + hashptr, data, clen); \
-    hashctA = SPH_T64(hashctA + 1024); \
-    hashctB = SPH_T64(hashctB + 1); \
-    COMPRESS64; \
-    } while (0); \
-    /* end blake64(sc, u.buf + ptr, 128 - ptr); */ \
-    sph_enc64be((unsigned char*)(hash) + (0 << 3), blkH0), \
-    sph_enc64be((unsigned char*)(hash) + (1 << 3), blkH1); \
-    sph_enc64be((unsigned char*)(hash) + (2 << 3), blkH2), \
-    sph_enc64be((unsigned char*)(hash) + (3 << 3), blkH3); \
-    sph_enc64be((unsigned char*)(hash) + (4 << 3), blkH4), \
-    sph_enc64be((unsigned char*)(hash) + (5 << 3), blkH5); \
-    sph_enc64be((unsigned char*)(hash) + (6 << 3), blkH6), \
-    sph_enc64be((unsigned char*)(hash) + (7 << 3), blkH7); \
-} while (0) 
-
-
-#ifdef __cplusplus
-}
-#endif

algo/blake/sse2/blake/sse41/api.h

@@ -1,2 +0,0 @@
-#define CRYPTO_BYTES 64
-

algo/blake/sse2/blake/sse41/architectures

@@ -1,2 +0,0 @@
-amd64
-x86

algo/blake/sse2/blake/sse41/config.h

@@ -1,8 +0,0 @@
-#ifndef __BLAKE512_CONFIG_H__
-#define __BLAKE512_CONFIG_H__
-
-#define AVOID_BRANCHING 1
-//#define HAVE_XOP 1
-
-#endif
-

algo/blake/sse2/blake/sse41/hash.c

@@ -1,287 +0,0 @@
-
-#include "hash.h"
-/*
-#ifndef NOT_SUPERCOP
-
-#include "crypto_hash.h"
-#include "crypto_uint64.h"
-#include "crypto_uint32.h"
-#include "crypto_uint8.h"
-
-typedef crypto_uint64 u64;
-typedef crypto_uint32 u32;
-typedef crypto_uint8 u8; 
-
-#else
-
-typedef unsigned long long u64; 
-typedef unsigned int u32; 
-typedef unsigned char u8; 
-
-#endif
-*/
-#define U8TO32(p) \
-  (((u32)((p)[0]) << 24) | ((u32)((p)[1]) << 16) | \
-   ((u32)((p)[2]) <<  8) | ((u32)((p)[3])      ))
-#define U8TO64(p) \
-  (((u64)U8TO32(p) << 32) | (u64)U8TO32((p) + 4))
-#define U32TO8(p, v) \
-    (p)[0] = (u8)((v) >> 24); (p)[1] = (u8)((v) >> 16); \
-    (p)[2] = (u8)((v) >>  8); (p)[3] = (u8)((v)      ); 
-#define U64TO8(p, v) \
-    U32TO8((p),     (u32)((v) >> 32));	\
-    U32TO8((p) + 4, (u32)((v)      )); 
-/*
-typedef struct  
-{ 
-	__m128i h[4];
-  u64 s[4], t[2];
-  u32 buflen, nullt;
-  u8 buf[128];
-} state __attribute__ ((aligned (64)));
-*/
-static const u8 padding[129] =
-{ 
-	0x80,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
-};
-
-static inline int blake512_compress( hashState_blake * state, const u8 * datablock ) 
-{
-
-  __m128i row1l,row1h;
-  __m128i row2l,row2h;
-  __m128i row3l,row3h;
-  __m128i row4l,row4h;
-
-  const __m128i r16 = _mm_setr_epi8(2,3,4,5,6,7,0,1,10,11,12,13,14,15,8,9);
-  const __m128i u8to64 = _mm_set_epi8(8, 9, 10, 11, 12, 13, 14, 15, 0, 1, 2, 3, 4, 5, 6, 7);
-
-  __m128i m0, m1, m2, m3, m4, m5, m6, m7;
-  __m128i t0, t1, t2, t3, t4, t5, t6, t7;
-  __m128i b0, b1, b2, b3;
-
-  m0 = _mm_loadu_si128((__m128i*)(datablock +   0));
-  m1 = _mm_loadu_si128((__m128i*)(datablock +  16));
-  m2 = _mm_loadu_si128((__m128i*)(datablock +  32));
-  m3 = _mm_loadu_si128((__m128i*)(datablock +  48));
-  m4 = _mm_loadu_si128((__m128i*)(datablock +  64));
-  m5 = _mm_loadu_si128((__m128i*)(datablock +  80));
-  m6 = _mm_loadu_si128((__m128i*)(datablock +  96));
-  m7 = _mm_loadu_si128((__m128i*)(datablock + 112));
-
-  m0 = BSWAP64(m0);
-  m1 = BSWAP64(m1);
-  m2 = BSWAP64(m2);
-  m3 = BSWAP64(m3);
-  m4 = BSWAP64(m4);
-  m5 = BSWAP64(m5);
-  m6 = BSWAP64(m6);
-  m7 = BSWAP64(m7);
-
-  row1l = state->h[0];
-  row1h = state->h[1];
-  row2l = state->h[2];
-  row2h = state->h[3];
-  row3l = _mm_set_epi64x(0x13198A2E03707344ULL, 0x243F6A8885A308D3ULL);
-  row3h = _mm_set_epi64x(0x082EFA98EC4E6C89ULL, 0xA4093822299F31D0ULL);
-
-  row4l = _mm_set_epi64x(0xBE5466CF34E90C6CULL, 0x452821E638D01377ULL);
-  row4h = _mm_set_epi64x(0x3F84D5B5B5470917ULL, 0xC0AC29B7C97C50DDULL);
-
-#ifdef AVOID_BRANCHING
-  do
-  {
-    const __m128i mask = _mm_cmpeq_epi32(_mm_setzero_si128(), _mm_set1_epi32(state->nullt));
-    const __m128i xor1 = _mm_and_si128(_mm_set1_epi64x(state->t[0]), mask);
-    const __m128i xor2 = _mm_and_si128(_mm_set1_epi64x(state->t[1]), mask);
-    row4l = _mm_xor_si128(row4l, xor1);
-    row4h = _mm_xor_si128(row4h, xor2);
-  } while(0);
-#else
-  if(!state->nullt)
-  {
-  	row4l = _mm_xor_si128(row4l, _mm_set1_epi64x(state->t[0]));
-  	row4h = _mm_xor_si128(row4h, _mm_set1_epi64x(state->t[1]));
-  }
-#endif
-
-  ROUND( 0);
-  ROUND( 1);
-  ROUND( 2);
-  ROUND( 3);
-  ROUND( 4);
-  ROUND( 5);
-  ROUND( 6);
-  ROUND( 7);
-  ROUND( 8);
-  ROUND( 9);
-  ROUND(10);
-  ROUND(11);
-  ROUND(12);
-  ROUND(13);
-  ROUND(14);
-  ROUND(15);
-
-  row1l = _mm_xor_si128(row3l,row1l);
-  row1h = _mm_xor_si128(row3h,row1h);
-
-  state->h[0] = _mm_xor_si128(row1l, state->h[0]);
-  state->h[1] = _mm_xor_si128(row1h, state->h[1]);
-
-  row2l = _mm_xor_si128(row4l,row2l);
-  row2h = _mm_xor_si128(row4h,row2h);
-
-  state->h[2] = _mm_xor_si128(row2l, state->h[2]);
-  state->h[3] = _mm_xor_si128(row2h, state->h[3]);
-  
-  return 0;
-}
-
-static inline void blake512_init( hashState_blake * S, u64 databitlen )
-{
-  memset(S, 0, sizeof(hashState_blake));
-  S->h[0] = _mm_set_epi64x(0xBB67AE8584CAA73BULL, 0x6A09E667F3BCC908ULL);
-  S->h[1] = _mm_set_epi64x(0xA54FF53A5F1D36F1ULL, 0x3C6EF372FE94F82BULL);
-  S->h[2] = _mm_set_epi64x(0x9B05688C2B3E6C1FULL, 0x510E527FADE682D1ULL);
-  S->h[3] = _mm_set_epi64x(0x5BE0CD19137E2179ULL, 0x1F83D9ABFB41BD6BULL);
-  S->buflen = databitlen;
-}
-
-
-static void blake512_update( hashState_blake * S, const u8 * data, u64 datalen ) 
-{
-
-
-  int left = (S->buflen >> 3); 
-  int fill = 128 - left;
-
-  if( left && ( ((datalen >> 3) & 0x7F) >= fill ) ) {
-    memcpy( (void *) (S->buf + left), (void *) data, fill );
-    S->t[0] += 1024;
-    blake512_compress( S, S->buf );
-    data += fill;
-    datalen  -= (fill << 3);       
-    left = 0;
-  }
-
-  while( datalen >= 1024 ) {  
-    S->t[0] += 1024;
-    blake512_compress( S, data );
-    data += 128;
-    datalen  -= 1024;
-  }
-
-  if( datalen > 0 ) {
-    memcpy( (void *) (S->buf + left), (void *) data, ( datalen>>3 ) & 0x7F );
-    S->buflen = (left<<3) + datalen;
-  }
-  else S->buflen=0;
-}
-
-static inline void blake512_final( hashState_blake * S, u8 * digest ) 
-{
-
-  u8 msglen[16], zo=0x01,oo=0x81;
-  u64 lo=S->t[0] + S->buflen, hi = S->t[1];
-  if ( lo < S->buflen ) hi++;
-  U64TO8(  msglen + 0, hi );
-  U64TO8(  msglen + 8, lo );
-
-  if ( S->buflen == 888 ) /* one padding byte */
-  { 
-    S->t[0] -= 8; 
-    blake512_update( S, &oo, 8 );
-  }
-  else 
-  {
-    if ( S->buflen < 888 ) /* enough space to fill the block */
-    { 
-      if ( S->buflen == 0 ) S->nullt=1;
-      S->t[0] -= 888 - S->buflen;
-      blake512_update( S, padding, 888 - S->buflen );
-    }
-    else /* NOT enough space, need 2 compressions */ 
-    { 
-      S->t[0] -= 1024 - S->buflen; 
-      blake512_update( S, padding, 1024 - S->buflen );
-      S->t[0] -= 888;
-      blake512_update( S, padding+1, 888 );
-      S->nullt = 1;
-    }
-    blake512_update( S, &zo, 8 );
-    S->t[0] -= 8;
-  }
-  S->t[0] -= 128;
-  blake512_update( S, msglen, 128 );    
-
-  do
-  {
-    const __m128i u8to64 = _mm_set_epi8(8, 9, 10, 11, 12, 13, 14, 15, 0, 1, 2, 3, 4, 5, 6, 7);
-    _mm_storeu_si128((__m128i*)(digest +  0), BSWAP64(S->h[0]));
-    _mm_storeu_si128((__m128i*)(digest + 16), BSWAP64(S->h[1]));
-    _mm_storeu_si128((__m128i*)(digest + 32), BSWAP64(S->h[2]));
-    _mm_storeu_si128((__m128i*)(digest + 48), BSWAP64(S->h[3]));
-  } while(0);
-}
-
-/*
-int crypto_hash( unsigned char *out, const unsigned char *in, unsigned long long inlen ) 
-{
-
-  hashState_blake S;
-  blake512_init( &S );
-  blake512_update( &S, in, inlen*8 );
-  blake512_final( &S, out );
-  return 0;
-}
-*/
-/*
-#ifdef NOT_SUPERCOP
-
-int main() 
-{
-
-  int i, v;
-  u8 data[144], digest[64];
-  u8 test1[]= {0x97, 0x96, 0x15, 0x87, 0xF6, 0xD9, 0x70, 0xFA, 0xBA, 0x6D, 0x24, 0x78, 0x04, 0x5D, 0xE6, 0xD1, 
-	       0xFA, 0xBD, 0x09, 0xB6, 0x1A, 0xE5, 0x09, 0x32, 0x05, 0x4D, 0x52, 0xBC, 0x29, 0xD3, 0x1B, 0xE4, 
-	       0xFF, 0x91, 0x02, 0xB9, 0xF6, 0x9E, 0x2B, 0xBD, 0xB8, 0x3B, 0xE1, 0x3D, 0x4B, 0x9C, 0x06, 0x09, 
-	       0x1E, 0x5F, 0xA0, 0xB4, 0x8B, 0xD0, 0x81, 0xB6, 0x34, 0x05, 0x8B, 0xE0, 0xEC, 0x49, 0xBE, 0xB3};
-  u8 test2[]= {0x31, 0x37, 0x17, 0xD6, 0x08, 0xE9, 0xCF, 0x75, 0x8D, 0xCB, 0x1E, 0xB0, 0xF0, 0xC3, 0xCF, 0x9F, 
-	       0xC1, 0x50, 0xB2, 0xD5, 0x00, 0xFB, 0x33, 0xF5, 0x1C, 0x52, 0xAF, 0xC9, 0x9D, 0x35, 0x8A, 0x2F, 
-	       0x13, 0x74, 0xB8, 0xA3, 0x8B, 0xBA, 0x79, 0x74, 0xE7, 0xF6, 0xEF, 0x79, 0xCA, 0xB1, 0x6F, 0x22, 
-	       0xCE, 0x1E, 0x64, 0x9D, 0x6E, 0x01, 0xAD, 0x95, 0x89, 0xC2, 0x13, 0x04, 0x5D, 0x54, 0x5D, 0xDE};
-
-  for(i=0; i<144; ++i) data[i]=0;  
-
-  crypto_hash( digest, data, 1 );    
-  v=0;
-  for(i=0; i<64; ++i) {
-    printf("%02X", digest[i]);
-    if ( digest[i] != test1[i]) v=1;
-  }
-  if (v) printf("\nerror\n");
-  else  printf("\nok\n");
-
-  for(i=0; i<144; ++i) data[i]=0;  
-
-  crypto_hash( digest, data, 144 );    
-  v=0;
-  for(i=0; i<64; ++i) {
-    printf("%02X", digest[i]);
-    if ( digest[i] != test2[i]) v=1;
-  }
-  if (v) printf("\nerror\n");
-  else printf("\nok\n");
-
-  return 0;
-}
-
-#endif
-
-*/
-
-

algo/blake/sse2/blake/sse41/hash.h

@@ -1,74 +0,0 @@
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <x86intrin.h>
-
-#include "config.h"
-#include "rounds.h"
-/*
-#ifndef NOT_SUPERCOP
-
-#include "crypto_hash.h"
-#include "crypto_uint64.h"
-#include "crypto_uint32.h"
-#include "crypto_uint8.h"
-
-typedef crypto_uint64 u64;
-typedef crypto_uint32 u32;
-typedef crypto_uint8 u8; 
-
-#else
-*/
-typedef unsigned long long u64; 
-typedef unsigned int u32; 
-typedef unsigned char u8; 
-
-typedef struct  
-{ 
-	__m128i h[4];
-  u64 s[4], t[2];
-  u32 buflen, nullt;
-  u8 buf[128];
-} hashState_blake __attribute__ ((aligned (64)));
-/*
-#endif
-
-#define U8TO32(p) \
-  (((u32)((p)[0]) << 24) | ((u32)((p)[1]) << 16) | \
-   ((u32)((p)[2]) <<  8) | ((u32)((p)[3])      ))
-#define U8TO64(p) \
-  (((u64)U8TO32(p) << 32) | (u64)U8TO32((p) + 4))
-#define U32TO8(p, v) \
-    (p)[0] = (u8)((v) >> 24); (p)[1] = (u8)((v) >> 16); \
-    (p)[2] = (u8)((v) >>  8); (p)[3] = (u8)((v)      ); 
-#define U64TO8(p, v) \
-    U32TO8((p),     (u32)((v) >> 32));	\
-    U32TO8((p) + 4, (u32)((v)      )); 
-*/
-
-/*
-static const u8 padding[129] =
-{ 
-	0x80,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
-};
-
-*/
-static inline void blake512_init( hashState_blake * S, u64 datalen );
-
-
-static void blake512_update( hashState_blake * S, const u8 * data, u64 datalen ) ;
-
-static inline void blake512_final( hashState_blake * S, u8 * digest ) ;
-
-
-int crypto_hash( unsigned char *out, const unsigned char *in, unsigned long long inlen ) ;
-
-
-
-
-
-