argon2 2.2.0 → 2.3.1

data/ext/phc-winner-argon2/Makefile

@@ -1,255 +0,0 @@
-#
-# 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 : https://creativecommons.org/publicdomain/zero/1.0
-# - Apache 2.0        : https://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.
-#
-
-RUN = argon2
-BENCH = bench
-GENKAT = genkat
-ARGON2_VERSION ?= ZERO
-
-# installation parameters for staging area and final installation path
-# Note; if Linux and not Debian/Ubuntu version also add lib override to make command-line
-#       for RedHat/Fedora, add: LIBRARY_REL=lib64
-DESTDIR ?=
-PREFIX ?= /usr
-
-# Increment on an ABI breaking change
-ABI_VERSION = 1
-
-DIST = phc-winner-argon2
-
-SRC = src/argon2.c src/core.c src/blake2/blake2b.c src/thread.c src/encoding.c
-SRC_RUN = src/run.c
-SRC_BENCH = src/bench.c
-SRC_GENKAT = src/genkat.c
-OBJ = $(SRC:.c=.o)
-
-CFLAGS += -std=c89 -O3 -Wall -g -Iinclude -Isrc
-
-ifeq ($(NO_THREADS), 1)
-CFLAGS += -DARGON2_NO_THREADS
-else
-CFLAGS += -pthread
-endif
-
-CI_CFLAGS := $(CFLAGS) -Werror=declaration-after-statement -D_FORTIFY_SOURCE=2 \
-				-Wextra -Wno-type-limits -Werror -coverage -DTEST_LARGE_RAM
-
-OPTTARGET ?= native
-OPTTEST := $(shell $(CC) -Iinclude -Isrc -march=$(OPTTARGET) src/opt.c -c \
-			-o /dev/null 2>/dev/null; echo $$?)
-# Detect compatible platform
-ifneq ($(OPTTEST), 0)
-$(info Building without optimizations)
-	SRC += src/ref.c
-else
-$(info Building with optimizations for $(OPTTARGET))
-	CFLAGS += -march=$(OPTTARGET)
-	SRC += src/opt.c
-endif
-
-BUILD_PATH := $(shell pwd)
-KERNEL_NAME := $(shell uname -s)
-MACHINE_NAME := $(shell uname -m)
-
-LIB_NAME = argon2
-PC_NAME = lib$(LIB_NAME).pc
-PC_SRC = $(PC_NAME).in
-
-ifeq ($(KERNEL_NAME), Linux)
-	LIB_EXT := so.$(ABI_VERSION)
-	LIB_CFLAGS := -shared -fPIC -fvisibility=hidden -DA2_VISCTL=1
-	SO_LDFLAGS := -Wl,-soname,lib$(LIB_NAME).$(LIB_EXT)
-	LINKED_LIB_EXT := so
-	PC_EXTRA_LIBS ?= -lrt -ldl
-endif
-ifeq ($(KERNEL_NAME), $(filter $(KERNEL_NAME),DragonFly FreeBSD NetBSD OpenBSD))
-	LIB_EXT := so
-	LIB_CFLAGS := -shared -fPIC
-	PC_EXTRA_LIBS ?=
-endif
-ifeq ($(KERNEL_NAME), Darwin)
-	LIB_EXT := $(ABI_VERSION).dylib
-	LIB_CFLAGS = -dynamiclib -install_name $(PREFIX)/$(LIBRARY_REL)/lib$(LIB_NAME).$(LIB_EXT)
-	LINKED_LIB_EXT := dylib
-	PC_EXTRA_LIBS ?=
-endif
-ifeq ($(findstring CYGWIN, $(KERNEL_NAME)), CYGWIN)
-	LIB_EXT := dll
-	LIB_CFLAGS := -shared -Wl,--out-implib,lib$(LIB_NAME).$(LIB_EXT).a
-	PC_EXTRA_LIBS ?=
-endif
-ifeq ($(findstring MINGW, $(KERNEL_NAME)), MINGW)
-	LIB_EXT := dll
-	LIB_CFLAGS := -shared -Wl,--out-implib,lib$(LIB_NAME).$(LIB_EXT).a
-	PC_EXTRA_LIBS ?=
-endif
-ifeq ($(findstring MSYS, $(KERNEL_NAME)), MSYS)
-	LIB_EXT := dll
-	LIB_CFLAGS := -shared -Wl,--out-implib,lib$(LIB_NAME).$(LIB_EXT).a
-	PC_EXTRA_LIBS ?=
-endif
-ifeq ($(KERNEL_NAME), SunOS)
-	CC := gcc
-	CFLAGS += -D_REENTRANT
-	LIB_EXT := so
-	LIB_CFLAGS := -shared -fPIC
-	PC_EXTRA_LIBS ?=
-endif
-
-ifeq ($(KERNEL_NAME), Linux)
-ifeq ($(CC), clang)
-	CI_CFLAGS += -fsanitize=address -fsanitize=undefined
-endif
-endif
-
-LIB_SH := lib$(LIB_NAME).$(LIB_EXT)
-LIB_ST := lib$(LIB_NAME).a
-
-ifdef LINKED_LIB_EXT
-LINKED_LIB_SH := lib$(LIB_NAME).$(LINKED_LIB_EXT)
-endif
-
-# Some systems don't provide an unprefixed ar when cross-compiling.
-AR=ar
-
-LIBRARIES = $(LIB_SH) $(LIB_ST)
-HEADERS = include/argon2.h
-
-INSTALL = install
-
-# relative paths for different OS
-ifeq ($(KERNEL_NAME), $(filter $(KERNEL_NAME),DragonFly FreeBSD))
-
-# default for FreeBSD
-BINARY_REL ?= bin
-INCLUDE_REL ?= include
-LIBRARY_REL ?= lib
-PKGCONFIG_REL ?= libdata
-
-else ifeq ($(KERNEL_NAME)-$(MACHINE_NAME), Linux-x86_64)
-
-# default for Debian/Ubuntu x86_64
-BINARY_REL ?= bin
-INCLUDE_REL ?= include
-LIBRARY_REL ?= lib/x86_64-linux-gnu
-PKGCONFIG_REL ?= $(LIBRARY_REL)
-
-else
-
-# NetBSD, ... and Linux64/Linux32 variants that use plain lib directory
-BINARY_REL ?= bin
-INCLUDE_REL ?= include
-LIBRARY_REL ?= lib
-PKGCONFIG_REL ?= $(LIBRARY_REL)
-
-endif
-
-# absolute paths to staging area
-INST_INCLUDE = $(DESTDIR)$(PREFIX)/$(INCLUDE_REL)
-INST_LIBRARY = $(DESTDIR)$(PREFIX)/$(LIBRARY_REL)
-INST_BINARY = $(DESTDIR)$(PREFIX)/$(BINARY_REL)
-INST_PKGCONFIG = $(DESTDIR)$(PREFIX)/$(PKGCONFIG_REL)/pkgconfig
-
-# main target
-.PHONY: all
-all: $(RUN) libs
-
-.PHONY: libs
-libs: $(LIBRARIES) $(PC_NAME)
-
-$(RUN):	        $(SRC) $(SRC_RUN)
-		$(CC) $(CFLAGS) $(LDFLAGS) $^ -o $@
-
-$(BENCH):       $(SRC) $(SRC_BENCH)
-		$(CC) $(CFLAGS) $^ -o $@
-
-$(GENKAT):      $(SRC) $(SRC_GENKAT)
-		$(CC) $(CFLAGS) $^ -o $@ -DGENKAT
-
-$(LIB_SH): 	$(SRC)
-		$(CC) $(CFLAGS) $(LIB_CFLAGS) $(LDFLAGS) $(SO_LDFLAGS) $^ -o $@
-
-$(LIB_ST): 	$(OBJ)
-		$(AR) rcs $@ $^
-
-.PHONY: clean
-clean:
-		rm -f '$(RUN)' '$(BENCH)' '$(GENKAT)'
-		rm -f '$(LIB_SH)' '$(LIB_ST)' kat-argon2* '$(PC_NAME)'
-		rm -f testcase
-		rm -rf *.dSYM
-		cd src/ && rm -f *.o
-		cd src/blake2/ && rm -f *.o
-		cd kats/ &&  rm -f kat-* diff* run_* make_*
-
-
-# all substitutions to pc template
-SED_COMMANDS  = /^\#\#.*$$/d;
-SED_COMMANDS += s\#@PREFIX@\#$(PREFIX)\#g;
-SED_COMMANDS += s\#@EXTRA_LIBS@\#$(PC_EXTRA_LIBS)\#g;
-SED_COMMANDS += s\#@UPSTREAM_VER@\#$(ARGON2_VERSION)\#g;
-SED_COMMANDS += s\#@HOST_MULTIARCH@\#$(LIBRARY_REL)\#g;
-SED_COMMANDS += s\#@INCLUDE@\#$(INCLUDE_REL)\#g;
-
-# substitute PREFIX and PC_EXTRA_LIBS into pkgconfig pc file
-$(PC_NAME): $(PC_SRC)
-		sed '$(SED_COMMANDS)' < '$(PC_SRC)' > '$@'
-
-
-.PHONY: dist
-dist:
-		cd ..; \
-		tar -c --exclude='.??*' -z -f $(DIST)-`date "+%Y%m%d"`.tgz $(DIST)/*
-
-.PHONY: test
-test:           $(SRC) src/test.c
-		$(CC) $(CFLAGS)  -Wextra -Wno-type-limits $^ -o testcase
-		@sh kats/test.sh
-		./testcase
-
-.PHONY: testci
-testci:         $(SRC) src/test.c
-		$(CC) $(CI_CFLAGS) $^ -o testcase
-		@sh kats/test.sh
-		./testcase
-
-
-.PHONY: format
-format:
-		clang-format -style="{BasedOnStyle: llvm, IndentWidth: 4}" \
-			-i include/*.h src/*.c src/*.h src/blake2/*.c src/blake2/*.h
-
-.PHONY: install
-install: $(RUN) libs
-	$(INSTALL) -d $(INST_INCLUDE)
-	$(INSTALL) -m 0644 $(HEADERS) $(INST_INCLUDE)
-	$(INSTALL) -d $(INST_LIBRARY)
-	$(INSTALL) -m 0644 $(LIBRARIES) $(INST_LIBRARY)
-ifdef LINKED_LIB_SH
-	cd $(INST_LIBRARY) && ln -sf $(notdir $(LIB_SH) $(LINKED_LIB_SH))
-endif
-	$(INSTALL) -d $(INST_BINARY)
-	$(INSTALL) $(RUN) $(INST_BINARY)
-	$(INSTALL) -d $(INST_PKGCONFIG)
-	$(INSTALL) -m 0644 $(PC_NAME) $(INST_PKGCONFIG)
-
-.PHONY: uninstall
-uninstall:
-	cd $(INST_INCLUDE) && rm -f $(notdir $(HEADERS))
-	cd $(INST_LIBRARY) && rm -f $(notdir $(LIBRARIES) $(LINKED_LIB_SH))
-	cd $(INST_BINARY) && rm -f $(notdir $(RUN))
-	cd $(INST_PKG_CONFIG) && rm -f $(notdir $(PC_NAME))

data/ext/phc-winner-argon2/Package.swift

@@ -1,46 +0,0 @@
-// swift-tools-version:5.3
-
-import PackageDescription
-
-let package = Package(
-    name: "argon2",
-    products: [
-        .library(
-            name: "argon2",
-            targets: ["argon2"]),
-    ],
-    targets: [
-        .target(
-            name: "argon2",
-            path: ".",
-            exclude: [
-                "kats",
-                "vs2015",
-                "latex",
-                "libargon2.pc.in",
-                "export.sh",
-                "appveyor.yml",
-                "Argon2.sln",
-                "argon2-specs.pdf",
-                "CHANGELOG.md",
-                "LICENSE",
-                "Makefile",
-                "man",
-                "README.md",
-                "src/bench.c",
-                "src/genkat.c",
-                "src/opt.c",
-                "src/run.c",
-                "src/test.c",
-            ],
-            sources: [
-                "src/blake2/blake2b.c",
-                "src/argon2.c",
-                "src/core.c",
-                "src/encoding.c",
-                "src/ref.c",
-                "src/thread.c"
-            ]
-        )
-    ]
-)

data/ext/phc-winner-argon2/README.md

@@ -1,303 +0,0 @@
-# Argon2
-
-[![Build Status](https://travis-ci.org/P-H-C/phc-winner-argon2.svg?branch=master)](https://travis-ci.org/P-H-C/phc-winner-argon2)
-[![Build status](https://ci.appveyor.com/api/projects/status/8nfwuwq55sgfkele?svg=true)](https://ci.appveyor.com/project/P-H-C/phc-winner-argon2)
-[![codecov.io](https://codecov.io/github/P-H-C/phc-winner-argon2/coverage.svg?branch=master)](https://codecov.io/github/P-H-C/phc-winner-argon2?branch=master)
-
-This is the reference C implementation of Argon2, the password-hashing
-function that won the [Password Hashing Competition
-(PHC)](https://password-hashing.net).
-
-Argon2 is a password-hashing function that summarizes the state of the
-art in the design of memory-hard functions and can be used to hash
-passwords for credential storage, key derivation, or other applications.
-
-It has a simple design aimed at the highest memory filling rate and
-effective use of multiple computing units, while still providing defense
-against tradeoff attacks (by exploiting the cache and memory organization
-of the recent processors).
-
-Argon2 has three variants: Argon2i, Argon2d, and Argon2id. Argon2d is faster
-and uses data-depending memory access, which makes it highly resistant
-against GPU cracking attacks and suitable for applications with no threats
-from side-channel timing attacks (eg. cryptocurrencies). Argon2i instead
-uses data-independent memory access, which is preferred for password
-hashing and password-based key derivation, but it is slower as it makes
-more passes over the memory to protect from tradeoff attacks. Argon2id is a
-hybrid of Argon2i and Argon2d, using a combination of data-depending and
-data-independent memory accesses, which gives some of Argon2i's resistance to
-side-channel cache timing attacks and much of Argon2d's resistance to GPU
-cracking attacks.
-
-Argon2i, Argon2d, and Argon2id are parametrized by:
-
-* A **time** cost, which defines the amount of computation realized and
-  therefore the execution time, given in number of iterations
-* A **memory** cost, which defines the memory usage, given in kibibytes
-* A **parallelism** degree, which defines the number of parallel threads
-
-The [Argon2 document](argon2-specs.pdf) gives detailed specs and design
-rationale.
-
-Please report bugs as issues on this repository.
-
-## Usage
-
-`make` builds the executable `argon2`, the static library `libargon2.a`,
-and the shared library `libargon2.so` (or on macOS, the dynamic library
-`libargon2.dylib` -- make sure to specify the installation prefix when
-you compile: `make PREFIX=/usr`). Make sure to run `make test` to verify
-that your build produces valid results. `sudo make install PREFIX=/usr`
-installs it to your system.
-
-### Command-line utility
-
-`argon2` is a command-line utility to test specific Argon2 instances
-on your system. To show usage instructions, run
-`./argon2 -h` as
-```
-Usage:  ./argon2 [-h] salt [-i|-d|-id] [-t iterations] [-m memory] [-p parallelism] [-l hash length] [-e|-r] [-v (10|13)]
-        Password is read from stdin
-Parameters:
-        salt            The salt to use, at least 8 characters
-        -i              Use Argon2i (this is the default)
-        -d              Use Argon2d instead of Argon2i
-        -id             Use Argon2id instead of Argon2i
-        -t N            Sets the number of iterations to N (default = 3)
-        -m N            Sets the memory usage of 2^N KiB (default 12)
-        -p N            Sets parallelism to N threads (default 1)
-        -l N            Sets hash output length to N bytes (default 32)
-        -e              Output only encoded hash
-        -r              Output only the raw bytes of the hash
-        -v (10|13)      Argon2 version (defaults to the most recent version, currently 13)
-        -h              Print argon2 usage
-```
-For example, to hash "password" using "somesalt" as a salt and doing 2
-iterations, consuming 64 MiB, using four parallel threads and an output hash
-of 24 bytes
-```
-$ echo -n "password" | ./argon2 somesalt -t 2 -m 16 -p 4 -l 24
-Type:           Argon2i
-Iterations:     2
-Memory:         65536 KiB
-Parallelism:    4
-Hash:           45d7ac72e76f242b20b77b9bf9bf9d5915894e669a24e6c6
-Encoded:        $argon2i$v=19$m=65536,t=2,p=4$c29tZXNhbHQ$RdescudvJCsgt3ub+b+dWRWJTmaaJObG
-0.188 seconds
-Verification ok
-```
-
-### Library
-
-`libargon2` provides an API to both low-level and high-level functions
-for using Argon2.
-
-The example program below hashes the string "password" with Argon2i
-using the high-level API and then using the low-level API. While the
-high-level API takes the three cost parameters (time, memory, and
-parallelism), the password input buffer, the salt input buffer, and the
-output buffers, the low-level API takes in these and additional parameters
-, as defined in [`include/argon2.h`](include/argon2.h).
-
-There are many additional parameters, but we will highlight three of them here.
-
-1. The `secret` parameter, which is used for [keyed hashing](
-   https://en.wikipedia.org/wiki/Hash-based_message_authentication_code).
-   This allows a secret key to be input at hashing time (from some external
-   location) and be folded into the value of the hash. This means that even if
-   your salts and hashes are compromized, an attacker cannot brute-force to find
-   the password without the key.
-
-2. The `ad` parameter, which is used to fold any additional data into the hash
-   value. Functionally, this behaves almost exactly like the `secret` or `salt`
-   parameters; the `ad` parameter is folding into the value of the hash.
-   However, this parameter is used for different data. The `salt` should be a
-   random string stored alongside your password. The `secret` should be a random
-   key only usable at hashing time. The `ad` is for any other data.
-
-3. The `flags` parameter, which determines which memory should be securely
-   erased. This is useful if you want to securly delete the `pwd` or `secret`
-   fields right after they are used. To do this set `flags` to either
-   `ARGON2_FLAG_CLEAR_PASSWORD` or `ARGON2_FLAG_CLEAR_SECRET`. To change how
-   internal memory is cleared, change the global flag
-   `FLAG_clear_internal_memory` (defaults to clearing internal memory).
-
-Here the time cost `t_cost` is set to 2 iterations, the
-memory cost `m_cost` is set to 2<sup>16</sup> kibibytes (64 mebibytes),
-and parallelism is set to 1 (single-thread).
-
-Compile for example as `gcc test.c libargon2.a -Isrc -o test`, if the program
-below is named `test.c` and placed in the project's root directory.
-
-```c
-#include "argon2.h"
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-
-#define HASHLEN 32
-#define SALTLEN 16
-#define PWD "password"
-
-int main(void)
-{
-    uint8_t hash1[HASHLEN];
-    uint8_t hash2[HASHLEN];
-
-    uint8_t salt[SALTLEN];
-    memset( salt, 0x00, SALTLEN );
-
-    uint8_t *pwd = (uint8_t *)strdup(PWD);
-    uint32_t pwdlen = strlen((char *)pwd);
-
-    uint32_t t_cost = 2;            // 2-pass computation
-    uint32_t m_cost = (1<<16);      // 64 mebibytes memory usage
-    uint32_t parallelism = 1;       // number of threads and lanes
-
-    // high-level API
-    argon2i_hash_raw(t_cost, m_cost, parallelism, pwd, pwdlen, salt, SALTLEN, hash1, HASHLEN);
-
-    // low-level API
-    argon2_context context = {
-        hash2,  /* output array, at least HASHLEN in size */
-        HASHLEN, /* digest length */
-        pwd, /* password array */
-        pwdlen, /* password length */
-        salt,  /* salt array */
-        SALTLEN, /* salt length */
-        NULL, 0, /* optional secret data */
-        NULL, 0, /* optional associated data */
-        t_cost, m_cost, parallelism, parallelism,
-        ARGON2_VERSION_13, /* algorithm version */
-        NULL, NULL, /* custom memory allocation / deallocation functions */
-        /* by default only internal memory is cleared (pwd is not wiped) */
-        ARGON2_DEFAULT_FLAGS
-    };
-
-    int rc = argon2i_ctx( &context );
-    if(ARGON2_OK != rc) {
-        printf("Error: %s\n", argon2_error_message(rc));
-        exit(1);
-    }
-    free(pwd);
-
-    for( int i=0; i<HASHLEN; ++i ) printf( "%02x", hash1[i] ); printf( "\n" );
-    if (memcmp(hash1, hash2, HASHLEN)) {
-        for( int i=0; i<HASHLEN; ++i ) {
-            printf( "%02x", hash2[i] );
-        }
-        printf("\nfail\n");
-    }
-    else printf("ok\n");
-    return 0;
-}
-```
-
-To use Argon2d instead of Argon2i call `argon2d_hash_raw` instead of
-`argon2i_hash_raw` using the high-level API, and `argon2d` instead of
-`argon2i` using the low-level API. Similarly for Argon2id, call `argon2id_hash_raw`
-and `argon2id`.
-
-To produce the crypt-like encoding rather than the raw hash, call
-`argon2i_hash_encoded` for Argon2i, `argon2d_hash_encoded` for Argon2d, and
-`argon2id_hash_encoded` for Argon2id
-
-See [`include/argon2.h`](include/argon2.h) for API details.
-
-*Note: in this example the salt is set to the all-`0x00` string for the
-sake of simplicity, but in your application you should use a random salt.*
-
-
-### Benchmarks
-
-`make bench` creates the executable `bench`, which measures the execution
-time of various Argon2 instances:
-
-```
-$ ./bench
-Argon2d 1 iterations  1 MiB 1 threads:  5.91 cpb 5.91 Mcycles
-Argon2i 1 iterations  1 MiB 1 threads:  4.64 cpb 4.64 Mcycles
-0.0041 seconds
-
-Argon2d 1 iterations  1 MiB 2 threads:  2.76 cpb 2.76 Mcycles
-Argon2i 1 iterations  1 MiB 2 threads:  2.87 cpb 2.87 Mcycles
-0.0038 seconds
-
-Argon2d 1 iterations  1 MiB 4 threads:  3.25 cpb 3.25 Mcycles
-Argon2i 1 iterations  1 MiB 4 threads:  3.57 cpb 3.57 Mcycles
-0.0048 seconds
-
-(...)
-
-Argon2d 1 iterations  4096 MiB 2 threads:  2.15 cpb 8788.08 Mcycles
-Argon2i 1 iterations  4096 MiB 2 threads:  2.15 cpb 8821.59 Mcycles
-13.0112 seconds
-
-Argon2d 1 iterations  4096 MiB 4 threads:  1.79 cpb 7343.72 Mcycles
-Argon2i 1 iterations  4096 MiB 4 threads:  2.72 cpb 11124.86 Mcycles
-19.3974 seconds
-
-(...)
-```
-
-## Bindings
-
-Bindings are available for the following languages (make sure to read
-their documentation):
-
-* [Android (Java/Kotlin)](https://github.com/lambdapioneer/argon2kt) by [@lambdapioneer](https://github.com/lambdapioneer)
-* [Dart](https://github.com/tmthecoder/dargon2) by [@tmthecoder](https://github.com/tmthecoder)
-* [Elixir](https://github.com/riverrun/argon2_elixir) by [@riverrun](https://github.com/riverrun)
-* [Erlang](https://github.com/ergenius/eargon2) by [@ergenius](https://github.com/ergenius)
-* [Go](https://github.com/tvdburgt/go-argon2) by [@tvdburgt](https://github.com/tvdburgt)
-* [Haskell](https://hackage.haskell.org/package/argon2) by [@hvr](https://github.com/hvr)
-* [JavaScript (native)](https://github.com/ranisalt/node-argon2), by [@ranisalt](https://github.com/ranisalt)
-* [JavaScript (native)](https://github.com/jdconley/argon2themax), by [@jdconley](https://github.com/jdconley)
-* [JavaScript (ffi)](https://github.com/cjlarose/argon2-ffi), by [@cjlarose](https://github.com/cjlarose)
-* [JavaScript (browser)](https://github.com/antelle/argon2-browser), by [@antelle](https://github.com/antelle)
-* [JVM](https://github.com/phxql/argon2-jvm) by [@phXql](https://github.com/phxql)
-* [JVM (with keyed hashing)](https://github.com/kosprov/jargon2-api) by [@kosprov](https://github.com/kosprov)
-* [Lua (native)](https://github.com/thibaultCha/lua-argon2) by [@thibaultCha](https://github.com/thibaultCha)
-* [Lua (ffi)](https://github.com/thibaultCha/lua-argon2-ffi) by [@thibaultCha](https://github.com/thibaultCha)
-* [OCaml](https://github.com/Khady/ocaml-argon2) by [@Khady](https://github.com/Khady)
-* [Python (native)](https://pypi.python.org/pypi/argon2), by [@flamewow](https://github.com/flamewow)
-* [Python (ffi)](https://pypi.python.org/pypi/argon2_cffi), by [@hynek](https://github.com/hynek)
-* [Python (ffi, with keyed hashing)](https://github.com/thusoy/porridge), by [@thusoy](https://github.com/thusoy)
-* [Python (ffi, with keyed hashing)](https://github.com/ultrahorizon/pyargon2), by [@ultrahorizon](https://github.com/ultrahorizon)
-* [R](https://cran.r-project.org/package=argon2) by [@wrathematics](https://github.com/wrathematics)
-* [Ruby](https://github.com/technion/ruby-argon2) by [@technion](https://github.com/technion)
-* [Rust](https://github.com/quininer/argon2-rs) by [@quininer](https://github.com/quininer)
-* [Rust](https://docs.rs/argonautica/) by [@bcmyers](https://github.com/bcmyers/)
-* [C#/.NET CoreCLR](https://github.com/kmaragon/Konscious.Security.Cryptography) by [@kmaragon](https://github.com/kmaragon)
-* [Perl](https://github.com/Leont/crypt-argon2) by [@leont](https://github.com/Leont)
-* [mruby](https://github.com/Asmod4n/mruby-argon2) by [@Asmod4n](https://github.com/Asmod4n)
-* [Swift](https://github.com/ImKcat/CatCrypto) by [@ImKcat](https://github.com/ImKcat)
-* [Swift](https://github.com/tmthecoder/Argon2Swift) by [@tmthecoder](https://github.com/tmthecoder)
-
-
-## Test suite
-
-There are two sets of test suites. One is a low level test for the hash
-function, the other tests the higher level API. Both of these are built and
-executed by running:
-
-`make test`
-
-## Intellectual property
-
-Except for the components listed below, the Argon2 code in this
-repository is copyright (c) 2015 Daniel Dinu, Dmitry Khovratovich (main
-authors), Jean-Philippe Aumasson and Samuel Neves, and dual licensed under the
-[CC0 License](https://creativecommons.org/about/cc0) and the
-[Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0). For more info
-see the LICENSE file.
-
-The string encoding routines in [`src/encoding.c`](src/encoding.c) are
-copyright (c) 2015 Thomas Pornin, and under
-[CC0 License](https://creativecommons.org/about/cc0).
-
-The BLAKE2 code in [`src/blake2/`](src/blake2) is copyright (c) Samuel
-Neves, 2013-2015, and under
-[CC0 License](https://creativecommons.org/about/cc0).
-
-All licenses are therefore GPL-compatible.

data/ext/phc-winner-argon2/appveyor.yml

@@ -1,25 +0,0 @@
-os: Visual Studio 2015
-
-environment:
-  matrix:
-    - platform: x86
-      configuration: Debug
-    - platform: x86
-      configuration: Release
-    - platform: x64
-      configuration: Debug
-    - platform: x64
-      configuration: Release
-
-matrix:
-  fast_finish: false
-
-build:
-  parallel: true
-  project: Argon2.sln
-  verbosity: minimal
-
-test_script:
-  - ps: kats\test.ps1
-  - ps: if ("Release" -eq $env:configuration) { vs2015\build\Argon2OptTestCI.exe }
-  - ps: if ("Release" -eq $env:configuration) { vs2015\build\Argon2RefTestCI.exe }

data/ext/phc-winner-argon2/export.sh

@@ -1,7 +0,0 @@
-#!/bin/sh
-
-FILE=`date "+%Y%m%d"`
-BRANCH=master
-
-git archive --format zip --output $FILE.zip $BRANCH
-git archive --format tar.gz --output $FILE.tar.gz $BRANCH