cmake
    https://askubuntu.com/questions/829310/how-to-upgrade-cmake-in-ubuntu

apt-get install opencl-headers
sudo apt-get install ocl-icd-libopencl1

sudo ln -s /usr/lib/x86_64-linux-gnu/libOpenCL.so.1 /usr/lib/libOpenCL.so

1. https://gist.github.com/zhanwenchen/e520767a409325d9961072f666815bb8

2. There is a mistake in the tutorial

   sudo nano /etc/environment Be sure you have at the end of the file :/usr/local/cuda/bin (it is important to have : at the beginning something exists before)

0. git submodule update --init

1. make

2. copy the argon2-gpu-test and data folder to Node-WebDollar /dist_bundle/GPU/

ns_per_hash=$(./argon2-gpu-bench
-t $type -v $version
$precompute_flag
-m $mode -d $device -k $kernel
-b $batch_size -s $samples
-T $t_cost -M $m_cost -L $lanes
-o ns-per-hash --output-mode mean) ret=$?

./argon2-gpu-bench -t d -v 1.3 -m cuda -d 0 -k by-segment -b 50 -s 5 -T 2 -M 256 -L 2 -o ns-per-hash --output-mode mean

./argon2 Satoshi_is_Finney -d -t 2 -m 8 -p 2 -e -l 32

./argon2-gpu-test -m opencl -d 0

A proof-of-concept GPU password cracker for Argon2 hashes.

Argon2 is a password hashing function created by Alex Biryukov, Daniel Dinu, and Dmitry Khovratovich. It was designed to be resistant against brute-force attacks using specialized hardware, such as GPUs, ASICs, or FPGAs. In July 2015, it was announced as the winner of the Password Hashing Competition.

The main goal of this project is to provide an efficient GPU implementation of Argon2 that can be used to estimate the speed and efficiency of Argon2 GPU cracking, in order to support or refute claims of its GPU cracking resistance.

Currently, the project implements two backends -- one that uses the NVIDIA's CUDA framework and another one that uses the OpenCL API.

Argon2-gpu supports all Argon2 variants (Argon2i, Argon2d, and Argon2id) and versions (1.3 and 1.0).

The CUDA implementation can reach about 40-60 GiB/s (divide by time cost * memory cost * 1024 B to get hashes per second) on an NVIDIA Tesla K20X. For comparison, a fast Intel Xeon processor can only reach about 10 GiB/s.

This project uses the CMake build system.

First, if you haven't cloned the repository using git clone --recursive, you need to run:

git submodule update --init

Then, to prepare build:

cmake -DCMAKE_BUILD_TYPE=Release .

Finally, just run make to build the code. Note that to use the OpenCL backend, you need to have the data subdirectory in the working directory (if you have the binaries in a different directory, just create a symlink using ln -s <path_to_repo>/data data).

To build without CUDA support, just add -DNO_CUDA=TRUE to the CMake command line. In this case the CUDA backend will always report 0 devices.

If CMake fails to find a usable CUDA installation, the project will be automatically built without CUDA support.

The CUDA implementation has three variants, which are currently implemented in separate branches:

• master -- uses only shared memory operations; is somewhat slower than the other two
• warp-shuffle -- uses warp shuffle instructions; doesn't use shared memory at all
• warp-shuffle-shared -- like warp-shuffle, but uses less regsters (compensated by using shared memory); this one is about as fast as warp-shuffle, but can be a little slower or faster in some edge cases

In addition, Argon2i and Argon2id implementations support a special 'precompute' mode, which makes them as fast as Argon2d, but uses a bit more memory (depending on time cost and memory cost). This mode is also supported by the OpenCL backend and can be enabled/disabled at runtime.