diff options
| author | Calvin Morrison <calvin@pobox.com> | 2025-09-03 21:15:36 -0400 |
|---|---|---|
| committer | Calvin Morrison <calvin@pobox.com> | 2025-09-03 21:15:36 -0400 |
| commit | 49fa5aa2a127bdf8924d02bf77e5086b39c7a447 (patch) | |
| tree | 61d86a7705dacc9fddccc29fa79d075d83ab8059 /server/_build/default/lib/bcrypt | |
Diffstat (limited to 'server/_build/default/lib/bcrypt')
42 files changed, 3110 insertions, 0 deletions
diff --git a/server/_build/default/lib/bcrypt/LICENSE b/server/_build/default/lib/bcrypt/LICENSE new file mode 100644 index 0000000..f479304 --- /dev/null +++ b/server/_build/default/lib/bcrypt/LICENSE @@ -0,0 +1,116 @@ +The Erlang code is subject to this license: + +%% Copyright (c) 2011 Hunter Morris <hunter.morris@smarkets.com> + +%% Permission to use, copy, modify, and distribute this software for any +%% purpose with or without fee is hereby granted, provided that the above +%% copyright notice and this permission notice appear in all copies. + +%% THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +%% WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +%% MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +%% ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +%% WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +%% ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +%% OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + +The underlying blowfish code is derived from OpenBSD libc and is +subject to the following license: + +/* + * Blowfish block cipher for OpenBSD + * Copyright 1997 Niels Provos <provos@physnet.uni-hamburg.de> + * All rights reserved. + * + * Implementation advice by David Mazieres <dm@lcs.mit.edu>. + * + * 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. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by Niels Provos. + * 4. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 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. + */ + +The underlying bcrypt (hashing) code is derived from OpenBSD libc and is +subject to the following license: + +/* + * Copyright 1997 Niels Provos <provos@physnet.uni-hamburg.de> + * 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. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by Niels Provos. + * 4. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 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. + */ + +The asynchronous queue code (c_src/async_queue.c and +c_src/async_queue.h) is from the esnappy project, copyright 2011 +Konstantin V. Sorokin. It is subject to the following license: + +Copyright (c) 2011 Konstantin V. Sorokin +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. +3. Neither the name of the copyright holder nor the names of contributors + may be used to endorse or promote products derived from this software + without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTOR(S) ``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 CONTRIBUTOR(S) 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. diff --git a/server/_build/default/lib/bcrypt/README.md b/server/_build/default/lib/bcrypt/README.md new file mode 100644 index 0000000..8b6c481 --- /dev/null +++ b/server/_build/default/lib/bcrypt/README.md @@ -0,0 +1,186 @@ +bcrypt +====== + + +[](https://hex.pm/packages/bcrypt) + +erlang-bcrypt is a wrapper around the OpenBSD Blowfish password hashing +algorithm, as described in +[A Future-Adaptable Password Scheme](http://www.openbsd.org/papers/bcrypt-paper.ps) +by Niels Provos and David Mazieres. + +This bcrypt repository at erlangpack is in active maintainance and used +as the basis of the Hex package. + + +OTP Compatibility +----------------- + +erlang-bcrypt is compatible with OTP 21.3 to 23. + +Use version 1.0.3 on OTP versions before 21.3 + +In version 1.1.0 support for OTP 21.2 and earlier is removed +due to the removal of erl_interface in OTP 23. + + +Rebar.config +------------ + +erlang-bcrypt is on Hex: + + ```erlang + {deps, [ + {bcrypt, "1.1.3"} + ]}. + ``` + +To use the master branch: + + ```erlang + {deps, [ + {bcrypt, {git, ".*", {git, "https://github.com/erlangpack/bcrypt.git", {branch, "master"}}} + ]}. + ``` + + +Basic build instructions +------------------------ + +1. Build it (project uses rebar3, a Makefile is included): + + ```shell + make + ``` + +2. Run it (simple way, starting sasl, crypto and bcrypt): + + ```shell + $ ./rebar3 shell + ===> Verifying dependencies... + ===> Compiling bcrypt + make: Nothing to be done for `all'. + Erlang/OTP 23 [erts-11.0] [source] [64-bit] [smp:12:12] [ds:12:12:10] [async-threads:1] [hipe] + + Eshell V11.0 (abort with ^G) + 1> application:ensure_all_started(bcrypt). + {ok,[bcrypt]} + 2> + ``` + +Basic usage instructions +------------------------ + +Hash a password using a salt with the default number of rounds: + +```erlang +1> {ok, Salt} = bcrypt:gen_salt(). +{ok,"$2a$12$sSS8Eg.ovVzaHzi1nUHYK."} +2> {ok, Hash} = bcrypt:hashpw("foo", Salt). +{ok,"$2a$12$sSS8Eg.ovVzaHzi1nUHYK.HbUIOdlQI0iS22Q5rd5z.JVVYH6sfm6"} +``` + +Verify the password: + +```erlang +3> {ok, Hash} =:= bcrypt:hashpw("foo", Hash). +true +4> {ok, Hash} =:= bcrypt:hashpw("bar", Hash). +false +``` + +Configuration +------------- + +The bcrypt application is configured by changing values in the +application's environment: + +`default_log_rounds` + Sets the default number of rounds which define the complexity of the + hash function. Defaults to `12`. + +`mechanism` + Specifies whether to use the NIF implementation (`'nif'`) or a + pool of port programs (`'port'`). Defaults to `'nif'`. + + `Note: the NIF implementation no longer blocks the Erlang VM scheduler threads` + +`pool_size` + Specifies the size of the port program pool. Defaults to `4`. + +`nif_pool_size` + Specifies the size of the nif program pool. Defaults to `4`. + +`nif_pool_max_overflow` + Specifies the max workers to overflow of the nif program pool. Defaults to `10`. + +Run tests +--------- + +To run the eunit and proper tests use: + +```shell +make tests +``` + +To test all exported function of a module use: + +```shell +$ ./rebar3 as test shell +===> Verifying dependencies... +===> Compiling bcrypt +make: Nothing to be done for all. +Erlang/OTP 23 [erts-11.0] [source] [64-bit] [smp:12:12] [ds:12:12:10] [async-threads:1] [hipe] + +Eshell V11.0 (abort with ^G) +1> application:ensure_all_started(bcrypt). +{ok,[bcrypt]} +2>proper:check_specs(bcrypt). +Testing bcrypt:gen_salt/0 +.................................................................................................... +OK: Passed 100 test(s). + +Testing bcrypt:hashpw/2 +.................................................................................................... +OK: Passed 100 test(s). + +Testing bcrypt:gen_salt/1 +.................................................................................................... +OK: Passed 100 test(s). + +Testing bcrypt:mechanism/0 +.................................................................................................... +OK: Passed 100 test(s). + +[] +4> +``` + +## Documentation generation + +### Edoc + +#### Generate public API +``` +rebar3 edoc +``` + +#### Generate private API +``` +rebar3 as edoc_private edoc +``` + +### ExDoc + +``` +rebar3 ex_doc --output edoc +``` + + +Both the _port_ and the _NIF_ version of bcrypt are tested. +All tests should pass. + +Original authors +---------------- + +Hunter Morris & [Mrinal Wadhwa](https://github.com/mrinalwadhwa). diff --git a/server/_build/default/lib/bcrypt/c_src/Makefile b/server/_build/default/lib/bcrypt/c_src/Makefile new file mode 100644 index 0000000..0e4a634 --- /dev/null +++ b/server/_build/default/lib/bcrypt/c_src/Makefile @@ -0,0 +1,89 @@ +# Based on c_src.mk from erlang.mk by Loic Hoguin <essen@ninenines.eu> + +CURDIR := . +BASEDIR := .. + +PROJECT ?= $(notdir $(BASEDIR)) +PROJECT := $(strip $(PROJECT)) + +ERTS_INCLUDE_DIR ?= $(shell erl -noshell -eval "io:format(\"~s/erts-~s/include/\", [code:root_dir(), erlang:system_info(version)]), halt().") +ERL_INTERFACE_INCLUDE_DIR ?= $(shell erl -noshell -eval "io:format(\"~s\", [code:lib_dir(erl_interface, include)]), halt().") +ERL_INTERFACE_LIB_DIR ?= $(shell erl -noshell -eval "io:format(\"~s\", [code:lib_dir(erl_interface, lib)]), halt().") + +C_SRC_DIR = $(CURDIR) +C_SRC_NIF = $(CURDIR)/../priv/bcrypt_nif.so +C_SRC_PORT = $(CURDIR)/../priv/bcrypt + +# DRV_LDFLAGS = -shared $(ERL_LDFLAGS) -lpthread +DRV_CFLAGS = -Ic_src -Wall -O3 -fPIC $(ERL_CFLAGS) + +# System type and C compiler/flags. + +UNAME_SYS := $(shell uname -s) +ifeq ($(UNAME_SYS), Darwin) + CC ?= cc + CFLAGS ?= -O3 -std=c99 -Wall -Wmissing-prototypes + LDFLAGS += -flat_namespace -undefined suppress + DRV_LDFLAGS = -flat_namespace -undefined suppress $(ERL_LDFLAGS) +else ifeq ($(UNAME_SYS), Linux) + CC ?= gcc + CFLAGS ?= -O3 -std=c99 -finline-functions -Wall -Wmissing-prototypes -D_DEFAULT_SOURCE + DRV_LDFLAGS = $(ERL_LDFLAGS) +else # FreeBSD + CC ?= cc + CFLAGS ?= -O3 -std=c99 -finline-functions -Wall -Wmissing-prototypes + DRV_LDFLAGS = $(ERL_LDFLAGS) +endif + +# {"DRV_LDFLAGS","-shared $ERL_LDFLAGS -lpthread"}, +# {"darwin", "DRV_LDFLAGS", "-bundle -flat_namespace -undefined suppress $ERL_LDFLAGS -lpthread"}, +# {"solaris", "ERL_LDFLAGS", "-lxnet -lssp -lnsl $ERL_LDFLAGS"}, +# {"DRV_CFLAGS","-Ic_src -Wall -O3 -fPIC $ERL_CFLAGS"}, +# {"CFLAGS", "$CFLAGS -Ic_src -Wall -O3"}, +# {"LDFLAGS", "$LDFLAGS -lpthread"} + +CFLAGS += -fPIC -I $(ERTS_INCLUDE_DIR) -I $(ERL_INTERFACE_INCLUDE_DIR) + +LDLIBS += -L $(ERL_INTERFACE_LIB_DIR) -lei -lpthread + +# Verbosity. + +c_verbose_0 = @echo " C " $(?F); +c_verbose = $(c_verbose_$(V)) + +cpp_verbose_0 = @echo " CPP " $(?F); +cpp_verbose = $(cpp_verbose_$(V)) + +link_verbose_0 = @echo " LD " $(@F); +link_verbose = $(link_verbose_$(V)) + +SOURCES := $(shell find $(C_SRC_DIR) -type f \( -name "*.c" -o -name "*.C" -o -name "*.cc" -o -name "*.cpp" \)) +OBJECTS = $(addsuffix .o, $(basename $(SOURCES))) + +COMPILE_C = $(c_verbose) $(CC) $(CFLAGS) $(CPPFLAGS) -c +COMPILE_CPP = $(cpp_verbose) $(CXX) $(CXXFLAGS) $(CPPFLAGS) -c + +all: $(C_SRC_NIF) $(C_SRC_PORT) + +$(C_SRC_PORT): $(OBJECTS) + @mkdir -p $(BASEDIR)/priv/ + $(CC) $(CFLAGS) bcrypt_port.o bcrypt.o blowfish.o $(DRV_LDFLAGS) $(LDLIBS) -o ../priv/bcrypt + +$(C_SRC_NIF): $(OBJECTS) + @mkdir -p $(BASEDIR)/priv/ + $(link_verbose) $(CC) $(OBJECTS) $(LDFLAGS) -shared $(LDLIBS) -o $(C_SRC_NIF) + +%.o: %.c + $(COMPILE_C) $(OUTPUT_OPTION) $< + +%.o: %.cc + $(COMPILE_CPP) $(OUTPUT_OPTION) $< + +%.o: %.C + $(COMPILE_CPP) $(OUTPUT_OPTION) $< + +%.o: %.cpp + $(COMPILE_CPP) $(OUTPUT_OPTION) $< + +clean: + @rm -f $(C_SRC_OUTPUT) $(OBJECTS) diff --git a/server/_build/default/lib/bcrypt/c_src/async_queue.c b/server/_build/default/lib/bcrypt/c_src/async_queue.c new file mode 100644 index 0000000..fbe30aa --- /dev/null +++ b/server/_build/default/lib/bcrypt/c_src/async_queue.c @@ -0,0 +1,141 @@ +/* + From https://github.com/thekvs/esnappy: + Copyright (c) 2011 Konstantin V. Sorokin + 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. + 3. Neither the name of the copyright holder nor the names of contributors + may be used to endorse or promote products derived from this software + without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTOR(S) ``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 CONTRIBUTOR(S) 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. +*/ +// vim: shiftwidth=4 expandtab +#include "async_queue.h" + +async_queue_t* +async_queue_create(char* mutex_name, char* condvar_name) +{ + async_queue_t *aq; + + aq = ALLOC(sizeof(*aq)); + + if (!aq) { + errx(1, "enif_alloc() failed"); + } + + aq->q = ALLOC(sizeof(*(aq->q))); + + if (!(aq->q)) { + errx(1, "enif_alloc() failed"); + } + + TAILQ_INIT(aq->q); + + aq->waiting_threads = aq->len = 0; + + aq->mutex = enif_mutex_create(mutex_name); + + if (!aq->mutex) { + errx(1, "enif_mutex_create() failed"); + } + + aq->cond = enif_cond_create(condvar_name); + + if (!aq->cond) { + errx(1, "enif_cond_create() failed"); + } + + return aq; +} + +int +async_queue_length(async_queue_t *aq) +{ + int length; + + MUTEX_LOCK(aq->mutex); + length = aq->len - aq->waiting_threads; + MUTEX_UNLOCK(aq->mutex); + + return length; +} + +void * +async_queue_pop(async_queue_t *aq) +{ + struct async_queue_entry *en; + void *d; + + MUTEX_LOCK(aq->mutex); + + d = NULL; + aq->waiting_threads++; + while (TAILQ_EMPTY(aq->q)) { + enif_cond_wait(aq->cond, aq->mutex); + } + aq->waiting_threads--; + + en = TAILQ_FIRST(aq->q); + TAILQ_REMOVE(aq->q, en, entries); + d = en->data; + aq->len--; + enif_free(en); + + MUTEX_UNLOCK(aq->mutex); + + return d; +} + +void +async_queue_push(async_queue_t *aq, void *data) +{ + struct async_queue_entry *en; + + MUTEX_LOCK(aq->mutex); + + en = ALLOC(sizeof(*en)); + en->data = data; + TAILQ_INSERT_TAIL(aq->q, en, entries); + aq->len++; + + COND_SIGNAL(aq->cond); + MUTEX_UNLOCK(aq->mutex); +} + +void +async_queue_destroy(async_queue_t *aq) +{ + struct async_queue_entry *en; + + while (!TAILQ_EMPTY(aq->q)) { + en = TAILQ_FIRST(aq->q); + TAILQ_REMOVE(aq->q, en, entries); + enif_free(en); + } + + COND_DESTROY(aq->cond); + MUTEX_DESTROY(aq->mutex); + + enif_free(aq->q); + enif_free(aq); +} + diff --git a/server/_build/default/lib/bcrypt/c_src/async_queue.h b/server/_build/default/lib/bcrypt/c_src/async_queue.h new file mode 100644 index 0000000..c7804ea --- /dev/null +++ b/server/_build/default/lib/bcrypt/c_src/async_queue.h @@ -0,0 +1,83 @@ +/* + From https://github.com/thekvs/esnappy: + Copyright (c) 2011 Konstantin V. Sorokin + 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. + 3. Neither the name of the copyright holder nor the names of contributors + may be used to endorse or promote products derived from this software + without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTOR(S) ``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 CONTRIBUTOR(S) 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. +*/ +// vim: shiftwidth=4 expandtab +#ifndef __ASYNC_QUEUE_H_INCLUDED__ +#define __ASYNC_QUEUE_H_INCLUDED__ + +#include <sys/queue.h> +#include <sys/types.h> +#include <sys/time.h> +#include <stdio.h> +#include <unistd.h> +#include <stdlib.h> +#include <string.h> +#include <errno.h> +#include <err.h> + +#include <erl_nif.h> + +#ifdef __cplusplus +extern "C" { +#endif + +TAILQ_HEAD(queue, async_queue_entry); + +struct async_queue_entry { + TAILQ_ENTRY(async_queue_entry) entries; + void *data; +}; + +typedef struct __async_queue { + struct queue *q; + ErlNifMutex *mutex; + ErlNifCond *cond; + int waiting_threads; + int len; +} async_queue_t; + +async_queue_t* async_queue_create(char* mutex_name, char* condvar_name); +int async_queue_length(async_queue_t *aq); +void* async_queue_pop(async_queue_t *aq); +void async_queue_push(async_queue_t *aq, void *data); +void async_queue_destroy(async_queue_t *aq); + +#define ALLOC(size) enif_alloc(size) +#define MUTEX_LOCK(mutex) enif_mutex_lock(mutex) +#define MUTEX_UNLOCK(mutex) enif_mutex_unlock(mutex) +#define MUTEX_DESTROY(mutex) enif_mutex_destroy(mutex) +#define COND_SIGNAL(condvar) enif_cond_signal(condvar) +#define COND_DESTROY(condvar) enif_cond_destroy(condvar) + +#ifdef __cplusplus +} // extern "C" +#endif + +#endif diff --git a/server/_build/default/lib/bcrypt/c_src/async_queue.o b/server/_build/default/lib/bcrypt/c_src/async_queue.o Binary files differnew file mode 100644 index 0000000..f23a2f2 --- /dev/null +++ b/server/_build/default/lib/bcrypt/c_src/async_queue.o diff --git a/server/_build/default/lib/bcrypt/c_src/bcrypt.c b/server/_build/default/lib/bcrypt/c_src/bcrypt.c new file mode 100644 index 0000000..9875123 --- /dev/null +++ b/server/_build/default/lib/bcrypt/c_src/bcrypt.c @@ -0,0 +1,281 @@ +/* $OpenBSD: bcrypt.c,v 1.24 2008/04/02 19:54:05 millert Exp $ */ + +/* + * Copyright 1997 Niels Provos <provos@physnet.uni-hamburg.de> + * 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. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by Niels Provos. + * 4. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 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 password hashing algorithm was designed by David Mazieres + * <dm@lcs.mit.edu> and works as follows: + * + * 1. state := InitState () + * 2. state := ExpandKey (state, salt, password) 3. + * REPEAT rounds: + * state := ExpandKey (state, 0, salt) + * state := ExpandKey(state, 0, password) + * 4. ctext := "OrpheanBeholderScryDoubt" + * 5. REPEAT 64: + * ctext := Encrypt_ECB (state, ctext); + * 6. RETURN Concatenate (salt, ctext); + * + */ + +#include <stdio.h> +#include <stdlib.h> +#include <sys/types.h> +#include <string.h> +#include <pwd.h> + +#include "erl_blf.h" + +/* This implementation is adaptable to current computing power. + * You can have up to 2^31 rounds which should be enough for some + * time to come. + */ + +#define BCRYPT_VERSION '2' +#define BCRYPT_MAXSALT 16 /* Precomputation is just so nice */ +#define BCRYPT_BLOCKS 6 /* Ciphertext blocks */ +#define BCRYPT_MINROUNDS 16 /* we have log2(rounds) in salt */ + +int ts_bcrypt(char *, const char *, const char *); +void encode_salt(char *, u_int8_t *, u_int16_t, u_int8_t); + +static void encode_base64(u_int8_t *, u_int8_t *, u_int16_t); +static void decode_base64(u_int8_t *, u_int16_t, u_int8_t *); + +#define ERROR -1 + +const static u_int8_t Base64Code[] = +"./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"; + +const static u_int8_t index_64[128] = { + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 0, 1, 54, 55, + 56, 57, 58, 59, 60, 61, 62, 63, 255, 255, + 255, 255, 255, 255, 255, 2, 3, 4, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, + 255, 255, 255, 255, 255, 255, 28, 29, 30, + 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, + 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, + 51, 52, 53, 255, 255, 255, 255, 255 +}; +#define CHAR64(c) ( (c) > 127 ? 255 : index_64[(c)]) + +static void +decode_base64(u_int8_t *buffer, u_int16_t len, u_int8_t *data) +{ + u_int8_t *bp = buffer; + u_int8_t *p = data; + u_int8_t c1, c2, c3, c4; + while (bp < buffer + len) { + c1 = CHAR64(*p); + c2 = CHAR64(*(p + 1)); + + /* Invalid data */ + if (c1 == 255 || c2 == 255) + break; + + *bp++ = (c1 << 2) | ((c2 & 0x30) >> 4); + if (bp >= buffer + len) + break; + + c3 = CHAR64(*(p + 2)); + if (c3 == 255) + break; + + *bp++ = ((c2 & 0x0f) << 4) | ((c3 & 0x3c) >> 2); + if (bp >= buffer + len) + break; + + c4 = CHAR64(*(p + 3)); + if (c4 == 255) + break; + *bp++ = ((c3 & 0x03) << 6) | c4; + + p += 4; + } +} + +void +encode_salt(char *salt, u_int8_t *csalt, u_int16_t clen, u_int8_t logr) +{ + salt[0] = '$'; + salt[1] = BCRYPT_VERSION; + salt[2] = 'a'; + salt[3] = '$'; + + snprintf(salt + 4, 4, "%2.2u$", logr); + + encode_base64((u_int8_t *) salt + 7, csalt, clen); +} + +/* We handle $Vers$log2(NumRounds)$salt+passwd$ + i.e. $2$04$iwouldntknowwhattosayetKdJ6iFtacBqJdKe6aW7ou */ + +int +ts_bcrypt(char * encrypted, const char *key, const char *salt) +{ + blf_ctx state; + u_int32_t rounds, i, k; + u_int16_t j; + u_int8_t key_len, salt_len, logr, minor; + u_int8_t ciphertext[4 * BCRYPT_BLOCKS] = "OrpheanBeholderScryDoubt"; + u_int8_t csalt[BCRYPT_MAXSALT]; + u_int32_t cdata[BCRYPT_BLOCKS]; + int n; + + /* Discard "$" identifier */ + salt++; + + if (*salt > BCRYPT_VERSION) { + /* How do I handle errors ? Return ':' */ + return ERROR; + } + + /* Check for minor versions */ + if (salt[1] != '$') { + switch (salt[1]) { + case 'a': + /* 'ab' should not yield the same as 'abab' */ + minor = salt[1]; + salt++; + break; + default: + return ERROR; + } + } else + minor = 0; + + /* Discard version + "$" identifier */ + salt += 2; + + if (salt[2] != '$') + /* Out of sync with passwd entry */ + return ERROR; + + /* Computer power doesn't increase linear, 2^x should be fine */ + n = atoi(salt); + if (n > 31 || n < 0) + return ERROR; + logr = (u_int8_t)n; + if ((rounds = (u_int32_t) 1 << logr) < BCRYPT_MINROUNDS) + return ERROR; + + /* Discard num rounds + "$" identifier */ + salt += 3; + + if (strlen(salt) * 3 / 4 < BCRYPT_MAXSALT) + return ERROR; + + /* We dont want the base64 salt but the raw data */ + decode_base64(csalt, BCRYPT_MAXSALT, (u_int8_t *) salt); + salt_len = BCRYPT_MAXSALT; + key_len = strlen(key) + (minor >= 'a' ? 1 : 0); + + /* Setting up S-Boxes and Subkeys */ + Blowfish_initstate(&state); + Blowfish_expandstate(&state, csalt, salt_len, + (u_int8_t *) key, key_len); + for (k = 0; k < rounds; k++) { + Blowfish_expand0state(&state, (u_int8_t *) key, key_len); + Blowfish_expand0state(&state, csalt, salt_len); + } + + /* This can be precomputed later */ + j = 0; + for (i = 0; i < BCRYPT_BLOCKS; i++) + cdata[i] = Blowfish_stream2word(ciphertext, 4 * BCRYPT_BLOCKS, &j); + + /* Now do the encryption */ + for (k = 0; k < 64; k++) + blf_enc(&state, cdata, BCRYPT_BLOCKS / 2); + + for (i = 0; i < BCRYPT_BLOCKS; i++) { + ciphertext[4 * i + 3] = cdata[i] & 0xff; + cdata[i] = cdata[i] >> 8; + ciphertext[4 * i + 2] = cdata[i] & 0xff; + cdata[i] = cdata[i] >> 8; + ciphertext[4 * i + 1] = cdata[i] & 0xff; + cdata[i] = cdata[i] >> 8; + ciphertext[4 * i + 0] = cdata[i] & 0xff; + } + + + i = 0; + encrypted[i++] = '$'; + encrypted[i++] = BCRYPT_VERSION; + if (minor) + encrypted[i++] = minor; + encrypted[i++] = '$'; + + snprintf(encrypted + i, 4, "%2.2u$", logr); + + encode_base64((u_int8_t *) encrypted + i + 3, csalt, BCRYPT_MAXSALT); + encode_base64((u_int8_t *) encrypted + strlen(encrypted), ciphertext, + 4 * BCRYPT_BLOCKS - 1); + memset(&state, 0, sizeof(state)); + memset(ciphertext, 0, sizeof(ciphertext)); + memset(csalt, 0, sizeof(csalt)); + memset(cdata, 0, sizeof(cdata)); + return 0; +} + +static void +encode_base64(u_int8_t *buffer, u_int8_t *data, u_int16_t len) +{ + u_int8_t *bp = buffer; + u_int8_t *p = data; + u_int8_t c1, c2; + while (p < data + len) { + c1 = *p++; + *bp++ = Base64Code[(c1 >> 2)]; + c1 = (c1 & 0x03) << 4; + if (p >= data + len) { + *bp++ = Base64Code[c1]; + break; + } + c2 = *p++; + c1 |= (c2 >> 4) & 0x0f; + *bp++ = Base64Code[c1]; + c1 = (c2 & 0x0f) << 2; + if (p >= data + len) { + *bp++ = Base64Code[c1]; + break; + } + c2 = *p++; + c1 |= (c2 >> 6) & 0x03; + *bp++ = Base64Code[c1]; + *bp++ = Base64Code[c2 & 0x3f]; + } + *bp = '\0'; +} diff --git a/server/_build/default/lib/bcrypt/c_src/bcrypt.o b/server/_build/default/lib/bcrypt/c_src/bcrypt.o Binary files differnew file mode 100644 index 0000000..15974d8 --- /dev/null +++ b/server/_build/default/lib/bcrypt/c_src/bcrypt.o diff --git a/server/_build/default/lib/bcrypt/c_src/bcrypt_nif.c b/server/_build/default/lib/bcrypt/c_src/bcrypt_nif.c new file mode 100644 index 0000000..fd3492a --- /dev/null +++ b/server/_build/default/lib/bcrypt/c_src/bcrypt_nif.c @@ -0,0 +1,244 @@ +/* + * Copyright (c) 2011-2012 Hunter Morris <hunter.morris@smarkets.com> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include <assert.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> + +#include "erl_nif.h" +#include "erl_blf.h" +#include "bcrypt_nif.h" + +static void free_task(task_t* task) +{ + if (task->env != NULL) + enif_free_env(task->env); + enif_free(task); +} + +static task_t* alloc_task(task_type_t type) +{ + task_t* task = (task_t*)enif_alloc(sizeof(task_t)); + if (task == NULL) + return NULL; + (void)memset(task, 0, sizeof(task_t)); + task->type = type; + return task; +} + +static task_t* alloc_init_task(task_type_t type, ERL_NIF_TERM ref, ErlNifPid pid, int num_orig_terms, const ERL_NIF_TERM orig_terms[]) +{ + task_t* task = alloc_task(type); + task->pid = pid; + task->env = enif_alloc_env(); + if (task->env == NULL) { + free_task(task); + return NULL; + } + + if (type == HASH) { + assert(num_orig_terms == 2); + if (!enif_inspect_iolist_as_binary( + task->env, enif_make_copy(task->env, orig_terms[0]), + &task->data.hash.salt)) { + free_task(task); + return NULL; + } + if (!enif_inspect_iolist_as_binary( + task->env, enif_make_copy(task->env, orig_terms[1]), + &task->data.hash.password)) { + free_task(task); + return NULL; + } + } + + task->ref = enif_make_copy(task->env, ref); + return task; +} + +static ERL_NIF_TERM hashpw(task_t* task) +{ + char password[1024] = { 0 }; + char salt[1024] = { 0 }; + char encrypted[1024] = { 0 }; + + size_t password_sz = 1024; + if (password_sz > task->data.hash.password.size) + password_sz = task->data.hash.password.size; + (void)memcpy(&password, task->data.hash.password.data, password_sz); + + size_t salt_sz = 1024; + if (salt_sz > task->data.hash.salt.size) + salt_sz = task->data.hash.salt.size; + (void)memcpy(&salt, task->data.hash.salt.data, salt_sz); + + if (ts_bcrypt(encrypted, password, salt)) { + return enif_make_tuple3( + task->env, + enif_make_atom(task->env, "error"), + task->ref, + enif_make_string(task->env, "bcrypt failed", ERL_NIF_LATIN1)); + } + + return enif_make_tuple3( + task->env, + enif_make_atom(task->env, "ok"), + task->ref, + enif_make_string(task->env, encrypted, ERL_NIF_LATIN1)); +} + +static void* async_worker(void* arg) +{ + ctx_t* ctx; + task_t* task; + + ERL_NIF_TERM result; + + ctx = (ctx_t*)arg; + + while (1) { + task = (task_t*)async_queue_pop(ctx->queue); + + if (task->type == SHUTDOWN) { + free_task(task); + break; + } else if (task->type == HASH) { + result = hashpw(task); + } else { + errx(1, "Unexpected task type: %i", task->type); + } + + enif_send(NULL, &task->pid, task->env, result); + free_task(task); + } + + return NULL; +} + +static ERL_NIF_TERM bcrypt_encode_salt(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) +{ + ErlNifBinary csalt, bin; + unsigned long log_rounds; + ERL_NIF_TERM ret; + + if (!enif_inspect_binary(env, argv[0], &csalt) || 16 != csalt.size) { + return enif_make_badarg(env); + } + + if (!enif_get_ulong(env, argv[1], &log_rounds)) { + enif_release_binary(&csalt); + return enif_make_badarg(env); + } + + if (!enif_alloc_binary(64, &bin)) { + enif_release_binary(&csalt); + return enif_make_badarg(env); + } + + encode_salt((char *)bin.data, (u_int8_t*)csalt.data, csalt.size, log_rounds); + enif_release_binary(&csalt); + + ret = enif_make_string(env, (char *)bin.data, ERL_NIF_LATIN1); + enif_release_binary(&bin); + return ret; +} + +static ERL_NIF_TERM bcrypt_hashpw(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) +{ + ctx_t *ctx; + task_t *task; + ErlNifPid pid; + + if (argc != 5) + return enif_make_badarg(env); + + bcrypt_privdata_t *priv = (bcrypt_privdata_t*)enif_priv_data(env); + + if (!enif_get_resource(env, argv[0], priv->bcrypt_rt, (void**)(&ctx))) + return enif_make_badarg(env); + + if (!enif_is_ref(env, argv[1])) + return enif_make_badarg(env); + + if (!enif_get_local_pid(env, argv[2], &pid)) + return enif_make_badarg(env); + + ERL_NIF_TERM orig_terms[] = { argv[4], argv[3] }; + task = alloc_init_task(HASH, argv[1], pid, 2, orig_terms); + + if (!task) + return enif_make_badarg(env); + + async_queue_push(ctx->queue, task); + + return enif_make_atom(env, "ok"); +} + +static ERL_NIF_TERM bcrypt_create_ctx(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) +{ + ERL_NIF_TERM ret; + bcrypt_privdata_t *priv = (bcrypt_privdata_t*)enif_priv_data(env); + ctx_t* ctx = (ctx_t*)enif_alloc_resource(priv->bcrypt_rt, sizeof(ctx_t)); + if (ctx == NULL) + return enif_make_badarg(env); + ctx->queue = async_queue_create("bcrypt_queue_mutex", "bcrypt_queue_condvar"); + ctx->topts = enif_thread_opts_create("bcrypt_thread_opts"); + if (enif_thread_create("bcrypt_worker", &ctx->tid, async_worker, ctx, ctx->topts) != 0) { + enif_release_resource(ctx); + return enif_make_badarg(env); + } + ret = enif_make_resource(env, ctx); + enif_release_resource(ctx); + return ret; +} + +static ErlNifFunc bcrypt_nif_funcs[] = +{ + {"encode_salt", 2, bcrypt_encode_salt}, + {"hashpw", 5, bcrypt_hashpw}, + {"create_ctx", 0, bcrypt_create_ctx}, +}; + +static void bcrypt_rt_dtor(ErlNifEnv* env, void* obj) +{ + ctx_t *ctx = (ctx_t*)obj; + task_t *task = alloc_task(SHUTDOWN); + void *result = NULL; + + async_queue_push(ctx->queue, task); + enif_thread_join(ctx->tid, &result); + async_queue_destroy(ctx->queue); + enif_thread_opts_destroy(ctx->topts); +} + +static int on_load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info) +{ + const char *mod = "bcrypt_nif"; + const char *name = "nif_resource"; + + ErlNifResourceFlags flags = (ErlNifResourceFlags)(ERL_NIF_RT_CREATE | ERL_NIF_RT_TAKEOVER); + + bcrypt_privdata_t *priv = (bcrypt_privdata_t*)enif_alloc(sizeof(bcrypt_privdata_t)); + priv->bcrypt_rt = enif_open_resource_type(env, mod, name, bcrypt_rt_dtor, flags, NULL); + if (priv->bcrypt_rt == NULL) + return -1; + *priv_data = priv; + return 0; +} + +ERL_NIF_INIT(bcrypt_nif, bcrypt_nif_funcs, &on_load, NULL, NULL, NULL) diff --git a/server/_build/default/lib/bcrypt/c_src/bcrypt_nif.h b/server/_build/default/lib/bcrypt/c_src/bcrypt_nif.h new file mode 100644 index 0000000..9c1cd69 --- /dev/null +++ b/server/_build/default/lib/bcrypt/c_src/bcrypt_nif.h @@ -0,0 +1,40 @@ +#ifndef ERLANG_BCRYPT_BCRYPT_NIF_H +#define ERLANG_BCRYPT_BCRYPT_NIF_H + +#include "async_queue.h" + +typedef unsigned char byte; + +int ts_bcrypt(char *, const char *, const char *); +void encode_salt(char *, u_int8_t *, u_int16_t, u_int8_t); + +typedef struct { + ErlNifResourceType *bcrypt_rt; +} bcrypt_privdata_t; + +typedef struct { + async_queue_t *queue; + ErlNifThreadOpts *topts; + ErlNifTid tid; +} ctx_t; + +typedef enum { + UNKNOWN, + SHUTDOWN, + HASH +} task_type_t; + +typedef struct { + task_type_t type; + ErlNifEnv *env; + ErlNifPid pid; + ERL_NIF_TERM ref; + union { + struct { + ErlNifBinary salt; + ErlNifBinary password; + } hash; + } data; +} task_t; + +#endif // ERLANG_BCRYPT_BCRYPT_NIF_H diff --git a/server/_build/default/lib/bcrypt/c_src/bcrypt_nif.o b/server/_build/default/lib/bcrypt/c_src/bcrypt_nif.o Binary files differnew file mode 100644 index 0000000..64cab20 --- /dev/null +++ b/server/_build/default/lib/bcrypt/c_src/bcrypt_nif.o diff --git a/server/_build/default/lib/bcrypt/c_src/bcrypt_port.c b/server/_build/default/lib/bcrypt/c_src/bcrypt_port.c new file mode 100644 index 0000000..7cafb2b --- /dev/null +++ b/server/_build/default/lib/bcrypt/c_src/bcrypt_port.c @@ -0,0 +1,266 @@ +/* + * Copyright (c) 2011 Hunter Morris <hunter.morris@smarkets.com> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> + +#include "erl_blf.h" +#include "ei.h" + +#define dec_int16(s) ((((unsigned char*)(s))[0] << 8) | \ + (((unsigned char*)(s))[1])) + +#define BUFSIZE (1 << 16) +#define CMD_SALT 0 +#define CMD_HASHPW 1 + +#define DATASIZE 1024 + +extern int ts_bcrypt(char *, const char *, const char *); +extern void encode_salt(char *, u_int8_t *, u_int16_t, u_int8_t); + + +static void +fail(int place) { + fprintf(stderr, "Something went wrong %d\n", place); + exit(1); +} + +/* These methods came from the Erlang port command tutorial: + * http://www.erlang.org/doc/tutorial/c_port.html#4.2 + */ +static int +read_buf(int fd, char *buf, int len) +{ + int i, got = 0; + do { + if ((i = read(fd, buf+got, len-got)) <= 0) { + if (i == 0) return got; + if (errno != EINTR) + fail(-1); + i = 0; + } + got += i; + } while (got < len); + return (len); +} + +static int +read_cmd(char *buf) +{ + int len; + if (read_buf(0, buf, 2) != 2) + return 0; + len = dec_int16(buf); + if (read_buf(0, buf, len) != len) + return 0; + return 1; +} + +static void +write_buf(int fd, const char *buf, int len) +{ + int i; + int done = 0; + + do { + if ((i = write(fd, buf+done, len-done)) < 0) { + if (errno != EINTR) + fail(-2); + i = 0; + } + done += i; + } while (done < len); +} + +static void +write_cmd(const char *buf, int len) +{ + unsigned char li; + + li = (len >> 8) & 0xff; + write_buf(1, (char *) &li, 1); + li = len & 0xff; + write_buf(1, (char *) &li, 1); + write_buf(1, buf, len); +} + +static void +process_reply(int cmd, const char *result) +{ + ei_x_buff res_buf; + + if (ei_x_new_with_version(&res_buf) != 0) + fail(-10); + if (ei_x_encode_tuple_header(&res_buf, 2) != 0) + fail(-11); + if (ei_x_encode_long(&res_buf, (long) cmd) != 0) + fail(-12); + if (ei_x_encode_binary(&res_buf, result, (long) strlen( (const char *) result)) != 0) + fail(-13); + + write_cmd(res_buf.buff, res_buf.index); + + if (ei_x_free(&res_buf) != 0) + fail(-14); +} + +static void +process_error_reply(int cmd, const char *error) +{ + ei_x_buff res_buf; + + if (ei_x_new_with_version(&res_buf) != 0) + fail(-20); + if (ei_x_encode_tuple_header(&res_buf, 2) != 0) + fail(-21); + if (ei_x_encode_long(&res_buf, (long) cmd) != 0) + fail(-22); + if (ei_x_encode_atom(&res_buf, error) != 0) + fail(-23); + + write_cmd(res_buf.buff, res_buf.index); + + if (ei_x_free(&res_buf) != 0) + fail(-24); +} + +static void +process_encode_salt( + int salt_size, + char *salt, + long rounds) +{ + char encoded_salt[64]; + + if (16 != salt_size) { + process_error_reply(CMD_SALT, "invalid_salt_length"); + } else if (rounds < 4 || rounds > 31) { + process_error_reply(CMD_SALT, "invalid_rounds"); + } else { + memset(encoded_salt, 0, 64); + encode_salt(encoded_salt, (u_int8_t *) salt, (u_int16_t) salt_size, (u_int8_t) rounds); + process_reply(CMD_SALT, encoded_salt); + } +} + +static void +process_hashpw( + int password_size, + char *password, + int salt_size, + char *salt) +{ + char encrypted[DATASIZE+1]; + + memset(encrypted, 0, DATASIZE+1); + if (ts_bcrypt(encrypted, password, salt)) { + process_error_reply(CMD_HASHPW, "invalid_salt"); + } else { + process_reply(CMD_HASHPW, encrypted); + } +} + +static void +process_command(char *buf) +{ + int index = 0; + int version = 0; + int arity = 0; + int type; + long cmd; + long len; + long rounds; + int data_size; + char data[DATASIZE+1]; + int salt_size; + char salt[DATASIZE+1]; + + memset(data, 0, DATASIZE+1); + memset(salt, 0, DATASIZE+1); + + if (ei_decode_version(buf, &index, &version) != 0) + fail(1); + + // Three tuple: {Cmd, Port, Data} + if (ei_decode_tuple_header(buf, &index, &arity) != 0) + fail(2); + if (arity != 2) + fail(3); + if (ei_decode_long(buf, &index, &cmd) != 0) + fail(4); + + // All commands have a two tuple for Data + if (ei_decode_tuple_header(buf, &index, &arity) != 0) + fail(6); + if (arity != 2) + fail(7); + + // First arg is always a binary + if (ei_get_type(buf, &index, &type, &data_size) != 0) + fail(8); + if (type != ERL_BINARY_EXT) + fail(9); + if (data_size < 0 || data_size > DATASIZE) + fail(10); + if (ei_decode_binary(buf, &index, data, &len) != 0) + fail(11); + + switch (cmd) { + case CMD_HASHPW: + // Two tuple: {Pass, Salt} + if (ei_get_type(buf, &index, &type, &salt_size) != 0) + fail(12); + if (type != ERL_BINARY_EXT) + fail(13); + if (salt_size < 0 || salt_size > DATASIZE) + fail(14); + if (ei_decode_binary(buf, &index, salt, &len) != 0) + fail(15); + + process_hashpw(data_size, data, salt_size, salt); + break; + case CMD_SALT: + // Two tuple: {Csalt, LogRounds} + if (ei_decode_long(buf, &index, &rounds) != 0) + fail(16); + + process_encode_salt(data_size, data, rounds); + break; + default: + fail(17); + } +} + +static void +loop(void) +{ + char buf[BUFSIZE]; + + while (read_cmd(buf) == 1) { + process_command(buf); + } +} + +int +main(int argc, char *argv[]) +{ + ei_init(); + loop(); + return 0; +} diff --git a/server/_build/default/lib/bcrypt/c_src/bcrypt_port.o b/server/_build/default/lib/bcrypt/c_src/bcrypt_port.o Binary files differnew file mode 100644 index 0000000..9abcc81 --- /dev/null +++ b/server/_build/default/lib/bcrypt/c_src/bcrypt_port.o diff --git a/server/_build/default/lib/bcrypt/c_src/blowfish.c b/server/_build/default/lib/bcrypt/c_src/blowfish.c new file mode 100644 index 0000000..f78055c --- /dev/null +++ b/server/_build/default/lib/bcrypt/c_src/blowfish.c @@ -0,0 +1,686 @@ +/* $OpenBSD: blowfish.c,v 1.18 2004/11/02 17:23:26 hshoexer Exp $ */ +/* + * Blowfish block cipher for OpenBSD + * Copyright 1997 Niels Provos <provos@physnet.uni-hamburg.de> + * All rights reserved. + * + * Implementation advice by David Mazieres <dm@lcs.mit.edu>. + * + * 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. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by Niels Provos. + * 4. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 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 code is derived from section 14.3 and the given source + * in section V of Applied Cryptography, second edition. + * Blowfish is an unpatented fast block cipher designed by + * Bruce Schneier. + */ + +#if 0 +#include <stdio.h> /* used for debugging */ +#include <string.h> +#endif + +#include <sys/types.h> + +#include "erl_blf.h" + +#undef inline +#ifdef __GNUC__ +#define inline __inline +#else /* !__GNUC__ */ +#define inline +#endif /* !__GNUC__ */ + +/* Function for Feistel Networks */ + +#define F(s, x) ((((s)[ (((x)>>24)&0xFF)] \ + + (s)[0x100 + (((x)>>16)&0xFF)]) \ + ^ (s)[0x200 + (((x)>> 8)&0xFF)]) \ + + (s)[0x300 + ( (x) &0xFF)]) + +#define BLFRND(s,p,i,j,n) (i ^= F(s,j) ^ (p)[n]) + +void +Blowfish_encipher(blf_ctx *c, u_int32_t *xl, u_int32_t *xr) +{ + u_int32_t Xl; + u_int32_t Xr; + u_int32_t *s = c->S[0]; + u_int32_t *p = c->P; + + Xl = *xl; + Xr = *xr; + + Xl ^= p[0]; + BLFRND(s, p, Xr, Xl, 1); BLFRND(s, p, Xl, Xr, 2); + BLFRND(s, p, Xr, Xl, 3); BLFRND(s, p, Xl, Xr, 4); + BLFRND(s, p, Xr, Xl, 5); BLFRND(s, p, Xl, Xr, 6); + BLFRND(s, p, Xr, Xl, 7); BLFRND(s, p, Xl, Xr, 8); + BLFRND(s, p, Xr, Xl, 9); BLFRND(s, p, Xl, Xr, 10); + BLFRND(s, p, Xr, Xl, 11); BLFRND(s, p, Xl, Xr, 12); + BLFRND(s, p, Xr, Xl, 13); BLFRND(s, p, Xl, Xr, 14); + BLFRND(s, p, Xr, Xl, 15); BLFRND(s, p, Xl, Xr, 16); + + *xl = Xr ^ p[17]; + *xr = Xl; +} + +void +Blowfish_decipher(blf_ctx *c, u_int32_t *xl, u_int32_t *xr) +{ + u_int32_t Xl; + u_int32_t Xr; + u_int32_t *s = c->S[0]; + u_int32_t *p = c->P; + + Xl = *xl; + Xr = *xr; + + Xl ^= p[17]; + BLFRND(s, p, Xr, Xl, 16); BLFRND(s, p, Xl, Xr, 15); + BLFRND(s, p, Xr, Xl, 14); BLFRND(s, p, Xl, Xr, 13); + BLFRND(s, p, Xr, Xl, 12); BLFRND(s, p, Xl, Xr, 11); + BLFRND(s, p, Xr, Xl, 10); BLFRND(s, p, Xl, Xr, 9); + BLFRND(s, p, Xr, Xl, 8); BLFRND(s, p, Xl, Xr, 7); + BLFRND(s, p, Xr, Xl, 6); BLFRND(s, p, Xl, Xr, 5); + BLFRND(s, p, Xr, Xl, 4); BLFRND(s, p, Xl, Xr, 3); + BLFRND(s, p, Xr, Xl, 2); BLFRND(s, p, Xl, Xr, 1); + + *xl = Xr ^ p[0]; + *xr = Xl; +} + +void +Blowfish_initstate(blf_ctx *c) +{ + /* P-box and S-box tables initialized with digits of Pi */ + + static const blf_ctx initstate = + { { + { + 0xd1310ba6, 0x98dfb5ac, 0x2ffd72db, 0xd01adfb7, + 0xb8e1afed, 0x6a267e96, 0xba7c9045, 0xf12c7f99, + 0x24a19947, 0xb3916cf7, 0x0801f2e2, 0x858efc16, + 0x636920d8, 0x71574e69, 0xa458fea3, 0xf4933d7e, + 0x0d95748f, 0x728eb658, 0x718bcd58, 0x82154aee, + 0x7b54a41d, 0xc25a59b5, 0x9c30d539, 0x2af26013, + 0xc5d1b023, 0x286085f0, 0xca417918, 0xb8db38ef, + 0x8e79dcb0, 0x603a180e, 0x6c9e0e8b, 0xb01e8a3e, + 0xd71577c1, 0xbd314b27, 0x78af2fda, 0x55605c60, + 0xe65525f3, 0xaa55ab94, 0x57489862, 0x63e81440, + 0x55ca396a, 0x2aab10b6, 0xb4cc5c34, 0x1141e8ce, + 0xa15486af, 0x7c72e993, 0xb3ee1411, 0x636fbc2a, + 0x2ba9c55d, 0x741831f6, 0xce5c3e16, 0x9b87931e, + 0xafd6ba33, 0x6c24cf5c, 0x7a325381, 0x28958677, + 0x3b8f4898, 0x6b4bb9af, 0xc4bfe81b, 0x66282193, + 0x61d809cc, 0xfb21a991, 0x487cac60, 0x5dec8032, + 0xef845d5d, 0xe98575b1, 0xdc262302, 0xeb651b88, + 0x23893e81, 0xd396acc5, 0x0f6d6ff3, 0x83f44239, + 0x2e0b4482, 0xa4842004, 0x69c8f04a, 0x9e1f9b5e, + 0x21c66842, 0xf6e96c9a, 0x670c9c61, 0xabd388f0, + 0x6a51a0d2, 0xd8542f68, 0x960fa728, 0xab5133a3, + 0x6eef0b6c, 0x137a3be4, 0xba3bf050, 0x7efb2a98, + 0xa1f1651d, 0x39af0176, 0x66ca593e, 0x82430e88, + 0x8cee8619, 0x456f9fb4, 0x7d84a5c3, 0x3b8b5ebe, + 0xe06f75d8, 0x85c12073, 0x401a449f, 0x56c16aa6, + 0x4ed3aa62, 0x363f7706, 0x1bfedf72, 0x429b023d, + 0x37d0d724, 0xd00a1248, 0xdb0fead3, 0x49f1c09b, + 0x075372c9, 0x80991b7b, 0x25d479d8, 0xf6e8def7, + 0xe3fe501a, 0xb6794c3b, 0x976ce0bd, 0x04c006ba, + 0xc1a94fb6, 0x409f60c4, 0x5e5c9ec2, 0x196a2463, + 0x68fb6faf, 0x3e6c53b5, 0x1339b2eb, 0x3b52ec6f, + 0x6dfc511f, 0x9b30952c, 0xcc814544, 0xaf5ebd09, + 0xbee3d004, 0xde334afd, 0x660f2807, 0x192e4bb3, + 0xc0cba857, 0x45c8740f, 0xd20b5f39, 0xb9d3fbdb, + 0x5579c0bd, 0x1a60320a, 0xd6a100c6, 0x402c7279, + 0x679f25fe, 0xfb1fa3cc, 0x8ea5e9f8, 0xdb3222f8, + 0x3c7516df, 0xfd616b15, 0x2f501ec8, 0xad0552ab, + 0x323db5fa, 0xfd238760, 0x53317b48, 0x3e00df82, + 0x9e5c57bb, 0xca6f8ca0, 0x1a87562e, 0xdf1769db, + 0xd542a8f6, 0x287effc3, 0xac6732c6, 0x8c4f5573, + 0x695b27b0, 0xbbca58c8, 0xe1ffa35d, 0xb8f011a0, + 0x10fa3d98, 0xfd2183b8, 0x4afcb56c, 0x2dd1d35b, + 0x9a53e479, 0xb6f84565, 0xd28e49bc, 0x4bfb9790, + 0xe1ddf2da, 0xa4cb7e33, 0x62fb1341, 0xcee4c6e8, + 0xef20cada, 0x36774c01, 0xd07e9efe, 0x2bf11fb4, + 0x95dbda4d, 0xae909198, 0xeaad8e71, 0x6b93d5a0, + 0xd08ed1d0, 0xafc725e0, 0x8e3c5b2f, 0x8e7594b7, + 0x8ff6e2fb, 0xf2122b64, 0x8888b812, 0x900df01c, + 0x4fad5ea0, 0x688fc31c, 0xd1cff191, 0xb3a8c1ad, + 0x2f2f2218, 0xbe0e1777, 0xea752dfe, 0x8b021fa1, + 0xe5a0cc0f, 0xb56f74e8, 0x18acf3d6, 0xce89e299, + 0xb4a84fe0, 0xfd13e0b7, 0x7cc43b81, 0xd2ada8d9, + 0x165fa266, 0x80957705, 0x93cc7314, 0x211a1477, + 0xe6ad2065, 0x77b5fa86, 0xc75442f5, 0xfb9d35cf, + 0xebcdaf0c, 0x7b3e89a0, 0xd6411bd3, 0xae1e7e49, + 0x00250e2d, 0x2071b35e, 0x226800bb, 0x57b8e0af, + 0x2464369b, 0xf009b91e, 0x5563911d, 0x59dfa6aa, + 0x78c14389, 0xd95a537f, 0x207d5ba2, 0x02e5b9c5, + 0x83260376, 0x6295cfa9, 0x11c81968, 0x4e734a41, + 0xb3472dca, 0x7b14a94a, 0x1b510052, 0x9a532915, + 0xd60f573f, 0xbc9bc6e4, 0x2b60a476, 0x81e67400, + 0x08ba6fb5, 0x571be91f, 0xf296ec6b, 0x2a0dd915, + 0xb6636521, 0xe7b9f9b6, 0xff34052e, 0xc5855664, + 0x53b02d5d, 0xa99f8fa1, 0x08ba4799, 0x6e85076a}, + { + 0x4b7a70e9, 0xb5b32944, 0xdb75092e, 0xc4192623, + 0xad6ea6b0, 0x49a7df7d, 0x9cee60b8, 0x8fedb266, + 0xecaa8c71, 0x699a17ff, 0x5664526c, 0xc2b19ee1, + 0x193602a5, 0x75094c29, 0xa0591340, 0xe4183a3e, + 0x3f54989a, 0x5b429d65, 0x6b8fe4d6, 0x99f73fd6, + 0xa1d29c07, 0xefe830f5, 0x4d2d38e6, 0xf0255dc1, + 0x4cdd2086, 0x8470eb26, 0x6382e9c6, 0x021ecc5e, + 0x09686b3f, 0x3ebaefc9, 0x3c971814, 0x6b6a70a1, + 0x687f3584, 0x52a0e286, 0xb79c5305, 0xaa500737, + 0x3e07841c, 0x7fdeae5c, 0x8e7d44ec, 0x5716f2b8, + 0xb03ada37, 0xf0500c0d, 0xf01c1f04, 0x0200b3ff, + 0xae0cf51a, 0x3cb574b2, 0x25837a58, 0xdc0921bd, + 0xd19113f9, 0x7ca92ff6, 0x94324773, 0x22f54701, + 0x3ae5e581, 0x37c2dadc, 0xc8b57634, 0x9af3dda7, + 0xa9446146, 0x0fd0030e, 0xecc8c73e, 0xa4751e41, + 0xe238cd99, 0x3bea0e2f, 0x3280bba1, 0x183eb331, + 0x4e548b38, 0x4f6db908, 0x6f420d03, 0xf60a04bf, + 0x2cb81290, 0x24977c79, 0x5679b072, 0xbcaf89af, + 0xde9a771f, 0xd9930810, 0xb38bae12, 0xdccf3f2e, + 0x5512721f, 0x2e6b7124, 0x501adde6, 0x9f84cd87, + 0x7a584718, 0x7408da17, 0xbc9f9abc, 0xe94b7d8c, + 0xec7aec3a, 0xdb851dfa, 0x63094366, 0xc464c3d2, + 0xef1c1847, 0x3215d908, 0xdd433b37, 0x24c2ba16, + 0x12a14d43, 0x2a65c451, 0x50940002, 0x133ae4dd, + 0x71dff89e, 0x10314e55, 0x81ac77d6, 0x5f11199b, + 0x043556f1, 0xd7a3c76b, 0x3c11183b, 0x5924a509, + 0xf28fe6ed, 0x97f1fbfa, 0x9ebabf2c, 0x1e153c6e, + 0x86e34570, 0xeae96fb1, 0x860e5e0a, 0x5a3e2ab3, + 0x771fe71c, 0x4e3d06fa, 0x2965dcb9, 0x99e71d0f, + 0x803e89d6, 0x5266c825, 0x2e4cc978, 0x9c10b36a, + 0xc6150eba, 0x94e2ea78, 0xa5fc3c53, 0x1e0a2df4, + 0xf2f74ea7, 0x361d2b3d, 0x1939260f, 0x19c27960, + 0x5223a708, 0xf71312b6, 0xebadfe6e, 0xeac31f66, + 0xe3bc4595, 0xa67bc883, 0xb17f37d1, 0x018cff28, + 0xc332ddef, 0xbe6c5aa5, 0x65582185, 0x68ab9802, + 0xeecea50f, 0xdb2f953b, 0x2aef7dad, 0x5b6e2f84, + 0x1521b628, 0x29076170, 0xecdd4775, 0x619f1510, + 0x13cca830, 0xeb61bd96, 0x0334fe1e, 0xaa0363cf, + 0xb5735c90, 0x4c70a239, 0xd59e9e0b, 0xcbaade14, + 0xeecc86bc, 0x60622ca7, 0x9cab5cab, 0xb2f3846e, + 0x648b1eaf, 0x19bdf0ca, 0xa02369b9, 0x655abb50, + 0x40685a32, 0x3c2ab4b3, 0x319ee9d5, 0xc021b8f7, + 0x9b540b19, 0x875fa099, 0x95f7997e, 0x623d7da8, + 0xf837889a, 0x97e32d77, 0x11ed935f, 0x16681281, + 0x0e358829, 0xc7e61fd6, 0x96dedfa1, 0x7858ba99, + 0x57f584a5, 0x1b227263, 0x9b83c3ff, 0x1ac24696, + 0xcdb30aeb, 0x532e3054, 0x8fd948e4, 0x6dbc3128, + 0x58ebf2ef, 0x34c6ffea, 0xfe28ed61, 0xee7c3c73, + 0x5d4a14d9, 0xe864b7e3, 0x42105d14, 0x203e13e0, + 0x45eee2b6, 0xa3aaabea, 0xdb6c4f15, 0xfacb4fd0, + 0xc742f442, 0xef6abbb5, 0x654f3b1d, 0x41cd2105, + 0xd81e799e, 0x86854dc7, 0xe44b476a, 0x3d816250, + 0xcf62a1f2, 0x5b8d2646, 0xfc8883a0, 0xc1c7b6a3, + 0x7f1524c3, 0x69cb7492, 0x47848a0b, 0x5692b285, + 0x095bbf00, 0xad19489d, 0x1462b174, 0x23820e00, + 0x58428d2a, 0x0c55f5ea, 0x1dadf43e, 0x233f7061, + 0x3372f092, 0x8d937e41, 0xd65fecf1, 0x6c223bdb, + 0x7cde3759, 0xcbee7460, 0x4085f2a7, 0xce77326e, + 0xa6078084, 0x19f8509e, 0xe8efd855, 0x61d99735, + 0xa969a7aa, 0xc50c06c2, 0x5a04abfc, 0x800bcadc, + 0x9e447a2e, 0xc3453484, 0xfdd56705, 0x0e1e9ec9, + 0xdb73dbd3, 0x105588cd, 0x675fda79, 0xe3674340, + 0xc5c43465, 0x713e38d8, 0x3d28f89e, 0xf16dff20, + 0x153e21e7, 0x8fb03d4a, 0xe6e39f2b, 0xdb83adf7}, + { + 0xe93d5a68, 0x948140f7, 0xf64c261c, 0x94692934, + 0x411520f7, 0x7602d4f7, 0xbcf46b2e, 0xd4a20068, + 0xd4082471, 0x3320f46a, 0x43b7d4b7, 0x500061af, + 0x1e39f62e, 0x97244546, 0x14214f74, 0xbf8b8840, + 0x4d95fc1d, 0x96b591af, 0x70f4ddd3, 0x66a02f45, + 0xbfbc09ec, 0x03bd9785, 0x7fac6dd0, 0x31cb8504, + 0x96eb27b3, 0x55fd3941, 0xda2547e6, 0xabca0a9a, + 0x28507825, 0x530429f4, 0x0a2c86da, 0xe9b66dfb, + 0x68dc1462, 0xd7486900, 0x680ec0a4, 0x27a18dee, + 0x4f3ffea2, 0xe887ad8c, 0xb58ce006, 0x7af4d6b6, + 0xaace1e7c, 0xd3375fec, 0xce78a399, 0x406b2a42, + 0x20fe9e35, 0xd9f385b9, 0xee39d7ab, 0x3b124e8b, + 0x1dc9faf7, 0x4b6d1856, 0x26a36631, 0xeae397b2, + 0x3a6efa74, 0xdd5b4332, 0x6841e7f7, 0xca7820fb, + 0xfb0af54e, 0xd8feb397, 0x454056ac, 0xba489527, + 0x55533a3a, 0x20838d87, 0xfe6ba9b7, 0xd096954b, + 0x55a867bc, 0xa1159a58, 0xcca92963, 0x99e1db33, + 0xa62a4a56, 0x3f3125f9, 0x5ef47e1c, 0x9029317c, + 0xfdf8e802, 0x04272f70, 0x80bb155c, 0x05282ce3, + 0x95c11548, 0xe4c66d22, 0x48c1133f, 0xc70f86dc, + 0x07f9c9ee, 0x41041f0f, 0x404779a4, 0x5d886e17, + 0x325f51eb, 0xd59bc0d1, 0xf2bcc18f, 0x41113564, + 0x257b7834, 0x602a9c60, 0xdff8e8a3, 0x1f636c1b, + 0x0e12b4c2, 0x02e1329e, 0xaf664fd1, 0xcad18115, + 0x6b2395e0, 0x333e92e1, 0x3b240b62, 0xeebeb922, + 0x85b2a20e, 0xe6ba0d99, 0xde720c8c, 0x2da2f728, + 0xd0127845, 0x95b794fd, 0x647d0862, 0xe7ccf5f0, + 0x5449a36f, 0x877d48fa, 0xc39dfd27, 0xf33e8d1e, + 0x0a476341, 0x992eff74, 0x3a6f6eab, 0xf4f8fd37, + 0xa812dc60, 0xa1ebddf8, 0x991be14c, 0xdb6e6b0d, + 0xc67b5510, 0x6d672c37, 0x2765d43b, 0xdcd0e804, + 0xf1290dc7, 0xcc00ffa3, 0xb5390f92, 0x690fed0b, + 0x667b9ffb, 0xcedb7d9c, 0xa091cf0b, 0xd9155ea3, + 0xbb132f88, 0x515bad24, 0x7b9479bf, 0x763bd6eb, + 0x37392eb3, 0xcc115979, 0x8026e297, 0xf42e312d, + 0x6842ada7, 0xc66a2b3b, 0x12754ccc, 0x782ef11c, + 0x6a124237, 0xb79251e7, 0x06a1bbe6, 0x4bfb6350, + 0x1a6b1018, 0x11caedfa, 0x3d25bdd8, 0xe2e1c3c9, + 0x44421659, 0x0a121386, 0xd90cec6e, 0xd5abea2a, + 0x64af674e, 0xda86a85f, 0xbebfe988, 0x64e4c3fe, + 0x9dbc8057, 0xf0f7c086, 0x60787bf8, 0x6003604d, + 0xd1fd8346, 0xf6381fb0, 0x7745ae04, 0xd736fccc, + 0x83426b33, 0xf01eab71, 0xb0804187, 0x3c005e5f, + 0x77a057be, 0xbde8ae24, 0x55464299, 0xbf582e61, + 0x4e58f48f, 0xf2ddfda2, 0xf474ef38, 0x8789bdc2, + 0x5366f9c3, 0xc8b38e74, 0xb475f255, 0x46fcd9b9, + 0x7aeb2661, 0x8b1ddf84, 0x846a0e79, 0x915f95e2, + 0x466e598e, 0x20b45770, 0x8cd55591, 0xc902de4c, + 0xb90bace1, 0xbb8205d0, 0x11a86248, 0x7574a99e, + 0xb77f19b6, 0xe0a9dc09, 0x662d09a1, 0xc4324633, + 0xe85a1f02, 0x09f0be8c, 0x4a99a025, 0x1d6efe10, + 0x1ab93d1d, 0x0ba5a4df, 0xa186f20f, 0x2868f169, + 0xdcb7da83, 0x573906fe, 0xa1e2ce9b, 0x4fcd7f52, + 0x50115e01, 0xa70683fa, 0xa002b5c4, 0x0de6d027, + 0x9af88c27, 0x773f8641, 0xc3604c06, 0x61a806b5, + 0xf0177a28, 0xc0f586e0, 0x006058aa, 0x30dc7d62, + 0x11e69ed7, 0x2338ea63, 0x53c2dd94, 0xc2c21634, + 0xbbcbee56, 0x90bcb6de, 0xebfc7da1, 0xce591d76, + 0x6f05e409, 0x4b7c0188, 0x39720a3d, 0x7c927c24, + 0x86e3725f, 0x724d9db9, 0x1ac15bb4, 0xd39eb8fc, + 0xed545578, 0x08fca5b5, 0xd83d7cd3, 0x4dad0fc4, + 0x1e50ef5e, 0xb161e6f8, 0xa28514d9, 0x6c51133c, + 0x6fd5c7e7, 0x56e14ec4, 0x362abfce, 0xddc6c837, + 0xd79a3234, 0x92638212, 0x670efa8e, 0x406000e0}, + { + 0x3a39ce37, 0xd3faf5cf, 0xabc27737, 0x5ac52d1b, + 0x5cb0679e, 0x4fa33742, 0xd3822740, 0x99bc9bbe, + 0xd5118e9d, 0xbf0f7315, 0xd62d1c7e, 0xc700c47b, + 0xb78c1b6b, 0x21a19045, 0xb26eb1be, 0x6a366eb4, + 0x5748ab2f, 0xbc946e79, 0xc6a376d2, 0x6549c2c8, + 0x530ff8ee, 0x468dde7d, 0xd5730a1d, 0x4cd04dc6, + 0x2939bbdb, 0xa9ba4650, 0xac9526e8, 0xbe5ee304, + 0xa1fad5f0, 0x6a2d519a, 0x63ef8ce2, 0x9a86ee22, + 0xc089c2b8, 0x43242ef6, 0xa51e03aa, 0x9cf2d0a4, + 0x83c061ba, 0x9be96a4d, 0x8fe51550, 0xba645bd6, + 0x2826a2f9, 0xa73a3ae1, 0x4ba99586, 0xef5562e9, + 0xc72fefd3, 0xf752f7da, 0x3f046f69, 0x77fa0a59, + 0x80e4a915, 0x87b08601, 0x9b09e6ad, 0x3b3ee593, + 0xe990fd5a, 0x9e34d797, 0x2cf0b7d9, 0x022b8b51, + 0x96d5ac3a, 0x017da67d, 0xd1cf3ed6, 0x7c7d2d28, + 0x1f9f25cf, 0xadf2b89b, 0x5ad6b472, 0x5a88f54c, + 0xe029ac71, 0xe019a5e6, 0x47b0acfd, 0xed93fa9b, + 0xe8d3c48d, 0x283b57cc, 0xf8d56629, 0x79132e28, + 0x785f0191, 0xed756055, 0xf7960e44, 0xe3d35e8c, + 0x15056dd4, 0x88f46dba, 0x03a16125, 0x0564f0bd, + 0xc3eb9e15, 0x3c9057a2, 0x97271aec, 0xa93a072a, + 0x1b3f6d9b, 0x1e6321f5, 0xf59c66fb, 0x26dcf319, + 0x7533d928, 0xb155fdf5, 0x03563482, 0x8aba3cbb, + 0x28517711, 0xc20ad9f8, 0xabcc5167, 0xccad925f, + 0x4de81751, 0x3830dc8e, 0x379d5862, 0x9320f991, + 0xea7a90c2, 0xfb3e7bce, 0x5121ce64, 0x774fbe32, + 0xa8b6e37e, 0xc3293d46, 0x48de5369, 0x6413e680, + 0xa2ae0810, 0xdd6db224, 0x69852dfd, 0x09072166, + 0xb39a460a, 0x6445c0dd, 0x586cdecf, 0x1c20c8ae, + 0x5bbef7dd, 0x1b588d40, 0xccd2017f, 0x6bb4e3bb, + 0xdda26a7e, 0x3a59ff45, 0x3e350a44, 0xbcb4cdd5, + 0x72eacea8, 0xfa6484bb, 0x8d6612ae, 0xbf3c6f47, + 0xd29be463, 0x542f5d9e, 0xaec2771b, 0xf64e6370, + 0x740e0d8d, 0xe75b1357, 0xf8721671, 0xaf537d5d, + 0x4040cb08, 0x4eb4e2cc, 0x34d2466a, 0x0115af84, + 0xe1b00428, 0x95983a1d, 0x06b89fb4, 0xce6ea048, + 0x6f3f3b82, 0x3520ab82, 0x011a1d4b, 0x277227f8, + 0x611560b1, 0xe7933fdc, 0xbb3a792b, 0x344525bd, + 0xa08839e1, 0x51ce794b, 0x2f32c9b7, 0xa01fbac9, + 0xe01cc87e, 0xbcc7d1f6, 0xcf0111c3, 0xa1e8aac7, + 0x1a908749, 0xd44fbd9a, 0xd0dadecb, 0xd50ada38, + 0x0339c32a, 0xc6913667, 0x8df9317c, 0xe0b12b4f, + 0xf79e59b7, 0x43f5bb3a, 0xf2d519ff, 0x27d9459c, + 0xbf97222c, 0x15e6fc2a, 0x0f91fc71, 0x9b941525, + 0xfae59361, 0xceb69ceb, 0xc2a86459, 0x12baa8d1, + 0xb6c1075e, 0xe3056a0c, 0x10d25065, 0xcb03a442, + 0xe0ec6e0e, 0x1698db3b, 0x4c98a0be, 0x3278e964, + 0x9f1f9532, 0xe0d392df, 0xd3a0342b, 0x8971f21e, + 0x1b0a7441, 0x4ba3348c, 0xc5be7120, 0xc37632d8, + 0xdf359f8d, 0x9b992f2e, 0xe60b6f47, 0x0fe3f11d, + 0xe54cda54, 0x1edad891, 0xce6279cf, 0xcd3e7e6f, + 0x1618b166, 0xfd2c1d05, 0x848fd2c5, 0xf6fb2299, + 0xf523f357, 0xa6327623, 0x93a83531, 0x56cccd02, + 0xacf08162, 0x5a75ebb5, 0x6e163697, 0x88d273cc, + 0xde966292, 0x81b949d0, 0x4c50901b, 0x71c65614, + 0xe6c6c7bd, 0x327a140a, 0x45e1d006, 0xc3f27b9a, + 0xc9aa53fd, 0x62a80f00, 0xbb25bfe2, 0x35bdd2f6, + 0x71126905, 0xb2040222, 0xb6cbcf7c, 0xcd769c2b, + 0x53113ec0, 0x1640e3d3, 0x38abbd60, 0x2547adf0, + 0xba38209c, 0xf746ce76, 0x77afa1c5, 0x20756060, + 0x85cbfe4e, 0x8ae88dd8, 0x7aaaf9b0, 0x4cf9aa7e, + 0x1948c25c, 0x02fb8a8c, 0x01c36ae4, 0xd6ebe1f9, + 0x90d4f869, 0xa65cdea0, 0x3f09252d, 0xc208e69f, + 0xb74e6132, 0xce77e25b, 0x578fdfe3, 0x3ac372e6} + }, + { + 0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344, + 0xa4093822, 0x299f31d0, 0x082efa98, 0xec4e6c89, + 0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c, + 0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917, + 0x9216d5d9, 0x8979fb1b + } }; + + *c = initstate; +} + +u_int32_t +Blowfish_stream2word(const u_int8_t *data, u_int16_t databytes, + u_int16_t *current) +{ + u_int8_t i; + u_int16_t j; + u_int32_t temp; + + temp = 0x00000000; + j = *current; + + for (i = 0; i < 4; i++, j++) { + if (j >= databytes) + j = 0; + temp = (temp << 8) | data[j]; + } + + *current = j; + return temp; +} + +void +Blowfish_expand0state(blf_ctx *c, const u_int8_t *key, u_int16_t keybytes) +{ + u_int16_t i; + u_int16_t j; + u_int16_t k; + u_int32_t temp; + u_int32_t datal; + u_int32_t datar; + + j = 0; + for (i = 0; i < BLF_N + 2; i++) { + /* Extract 4 int8 to 1 int32 from keystream */ + temp = Blowfish_stream2word(key, keybytes, &j); + c->P[i] = c->P[i] ^ temp; + } + + j = 0; + datal = 0x00000000; + datar = 0x00000000; + for (i = 0; i < BLF_N + 2; i += 2) { + Blowfish_encipher(c, &datal, &datar); + + c->P[i] = datal; + c->P[i + 1] = datar; + } + + for (i = 0; i < 4; i++) { + for (k = 0; k < 256; k += 2) { + Blowfish_encipher(c, &datal, &datar); + + c->S[i][k] = datal; + c->S[i][k + 1] = datar; + } + } +} + + +void +Blowfish_expandstate(blf_ctx *c, const u_int8_t *data, u_int16_t databytes, + const u_int8_t *key, u_int16_t keybytes) +{ + u_int16_t i; + u_int16_t j; + u_int16_t k; + u_int32_t temp; + u_int32_t datal; + u_int32_t datar; + + j = 0; + for (i = 0; i < BLF_N + 2; i++) { + /* Extract 4 int8 to 1 int32 from keystream */ + temp = Blowfish_stream2word(key, keybytes, &j); + c->P[i] = c->P[i] ^ temp; + } + + j = 0; + datal = 0x00000000; + datar = 0x00000000; + for (i = 0; i < BLF_N + 2; i += 2) { + datal ^= Blowfish_stream2word(data, databytes, &j); + datar ^= Blowfish_stream2word(data, databytes, &j); + Blowfish_encipher(c, &datal, &datar); + + c->P[i] = datal; + c->P[i + 1] = datar; + } + + for (i = 0; i < 4; i++) { + for (k = 0; k < 256; k += 2) { + datal ^= Blowfish_stream2word(data, databytes, &j); + datar ^= Blowfish_stream2word(data, databytes, &j); + Blowfish_encipher(c, &datal, &datar); + + c->S[i][k] = datal; + c->S[i][k + 1] = datar; + } + } + +} + +void +blf_key(blf_ctx *c, const u_int8_t *k, u_int16_t len) +{ + /* Initialize S-boxes and subkeys with Pi */ + Blowfish_initstate(c); + + /* Transform S-boxes and subkeys with key */ + Blowfish_expand0state(c, k, len); +} + +void +blf_enc(blf_ctx *c, u_int32_t *data, u_int16_t blocks) +{ + u_int32_t *d; + u_int16_t i; + + d = data; + for (i = 0; i < blocks; i++) { + Blowfish_encipher(c, d, d + 1); + d += 2; + } +} + +void +blf_dec(blf_ctx *c, u_int32_t *data, u_int16_t blocks) +{ + u_int32_t *d; + u_int16_t i; + + d = data; + for (i = 0; i < blocks; i++) { + Blowfish_decipher(c, d, d + 1); + d += 2; + } +} + +void +blf_ecb_encrypt(blf_ctx *c, u_int8_t *data, u_int32_t len) +{ + u_int32_t l, r; + u_int32_t i; + + for (i = 0; i < len; i += 8) { + l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3]; + r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7]; + Blowfish_encipher(c, &l, &r); + data[0] = l >> 24 & 0xff; + data[1] = l >> 16 & 0xff; + data[2] = l >> 8 & 0xff; + data[3] = l & 0xff; + data[4] = r >> 24 & 0xff; + data[5] = r >> 16 & 0xff; + data[6] = r >> 8 & 0xff; + data[7] = r & 0xff; + data += 8; + } +} + +void +blf_ecb_decrypt(blf_ctx *c, u_int8_t *data, u_int32_t len) +{ + u_int32_t l, r; + u_int32_t i; + + for (i = 0; i < len; i += 8) { + l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3]; + r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7]; + Blowfish_decipher(c, &l, &r); + data[0] = l >> 24 & 0xff; + data[1] = l >> 16 & 0xff; + data[2] = l >> 8 & 0xff; + data[3] = l & 0xff; + data[4] = r >> 24 & 0xff; + data[5] = r >> 16 & 0xff; + data[6] = r >> 8 & 0xff; + data[7] = r & 0xff; + data += 8; + } +} + +void +blf_cbc_encrypt(blf_ctx *c, u_int8_t *iv, u_int8_t *data, u_int32_t len) +{ + u_int32_t l, r; + u_int32_t i, j; + + for (i = 0; i < len; i += 8) { + for (j = 0; j < 8; j++) + data[j] ^= iv[j]; + l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3]; + r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7]; + Blowfish_encipher(c, &l, &r); + data[0] = l >> 24 & 0xff; + data[1] = l >> 16 & 0xff; + data[2] = l >> 8 & 0xff; + data[3] = l & 0xff; + data[4] = r >> 24 & 0xff; + data[5] = r >> 16 & 0xff; + data[6] = r >> 8 & 0xff; + data[7] = r & 0xff; + iv = data; + data += 8; + } +} + +void +blf_cbc_decrypt(blf_ctx *c, u_int8_t *iva, u_int8_t *data, u_int32_t len) +{ + u_int32_t l, r; + u_int8_t *iv; + u_int32_t i, j; + + iv = data + len - 16; + data = data + len - 8; + for (i = len - 8; i >= 8; i -= 8) { + l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3]; + r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7]; + Blowfish_decipher(c, &l, &r); + data[0] = l >> 24 & 0xff; + data[1] = l >> 16 & 0xff; + data[2] = l >> 8 & 0xff; + data[3] = l & 0xff; + data[4] = r >> 24 & 0xff; + data[5] = r >> 16 & 0xff; + data[6] = r >> 8 & 0xff; + data[7] = r & 0xff; + for (j = 0; j < 8; j++) + data[j] ^= iv[j]; + iv -= 8; + data -= 8; + } + l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3]; + r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7]; + Blowfish_decipher(c, &l, &r); + data[0] = l >> 24 & 0xff; + data[1] = l >> 16 & 0xff; + data[2] = l >> 8 & 0xff; + data[3] = l & 0xff; + data[4] = r >> 24 & 0xff; + data[5] = r >> 16 & 0xff; + data[6] = r >> 8 & 0xff; + data[7] = r & 0xff; + for (j = 0; j < 8; j++) + data[j] ^= iva[j]; +} + +#if 0 +void +report(u_int32_t data[], u_int16_t len) +{ + u_int16_t i; + for (i = 0; i < len; i += 2) + printf("Block %0hd: %08lx %08lx.\n", + i / 2, data[i], data[i + 1]); +} +void +main(void) +{ + + blf_ctx c; + char key[] = "AAAAA"; + char key2[] = "abcdefghijklmnopqrstuvwxyz"; + + u_int32_t data[10]; + u_int32_t data2[] = + {0x424c4f57l, 0x46495348l}; + + u_int16_t i; + + /* First test */ + for (i = 0; i < 10; i++) + data[i] = i; + + blf_key(&c, (u_int8_t *) key, 5); + blf_enc(&c, data, 5); + blf_dec(&c, data, 1); + blf_dec(&c, data + 2, 4); + printf("Should read as 0 - 9.\n"); + report(data, 10); + + /* Second test */ + blf_key(&c, (u_int8_t *) key2, strlen(key2)); + blf_enc(&c, data2, 1); + printf("\nShould read as: 0x324ed0fe 0xf413a203.\n"); + report(data2, 2); + blf_dec(&c, data2, 1); + report(data2, 2); +} +#endif diff --git a/server/_build/default/lib/bcrypt/c_src/blowfish.o b/server/_build/default/lib/bcrypt/c_src/blowfish.o Binary files differnew file mode 100644 index 0000000..6a9aba6 --- /dev/null +++ b/server/_build/default/lib/bcrypt/c_src/blowfish.o diff --git a/server/_build/default/lib/bcrypt/c_src/erl_blf.h b/server/_build/default/lib/bcrypt/c_src/erl_blf.h new file mode 100644 index 0000000..b03a3a0 --- /dev/null +++ b/server/_build/default/lib/bcrypt/c_src/erl_blf.h @@ -0,0 +1,94 @@ +/* $OpenBSD: blf.h,v 1.7 2007/03/14 17:59:41 grunk Exp $ */ +/* + * Blowfish - a fast block cipher designed by Bruce Schneier + * + * Copyright 1997 Niels Provos <provos@physnet.uni-hamburg.de> + * 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. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by Niels Provos. + * 4. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 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. + */ + +#ifndef _ERL_BLF_H_ +#define _ERL_BLF_H_ + +/* Solaris compatibility */ +#ifdef __sun +#define u_int8_t uint8_t +#define u_int16_t uint16_t +#define u_int32_t uint32_t +#define u_int64_t uint64_t +#endif + +#include <sys/types.h> + +/* Schneier specifies a maximum key length of 56 bytes. + * This ensures that every key bit affects every cipher + * bit. However, the subkeys can hold up to 72 bytes. + * Warning: For normal blowfish encryption only 56 bytes + * of the key affect all cipherbits. + */ + +#define BLF_N 16 /* Number of Subkeys */ +#define BLF_MAXKEYLEN ((BLF_N-2)*4) /* 448 bits */ +#define BLF_MAXUTILIZED ((BLF_N+2)*4) /* 576 bits */ + +#define _PASSWORD_LEN 128 /* max length, not counting NUL */ + +/* Blowfish context */ +typedef struct BlowfishContext { + u_int32_t S[4][256]; /* S-Boxes */ + u_int32_t P[BLF_N + 2]; /* Subkeys */ +} blf_ctx; + +/* Raw access to customized Blowfish + * blf_key is just: + * Blowfish_initstate( state ) + * Blowfish_expand0state( state, key, keylen ) + */ + +void Blowfish_encipher(blf_ctx *, u_int32_t *, u_int32_t *); +void Blowfish_decipher(blf_ctx *, u_int32_t *, u_int32_t *); +void Blowfish_initstate(blf_ctx *); +void Blowfish_expand0state(blf_ctx *, const u_int8_t *, u_int16_t); +void Blowfish_expandstate +(blf_ctx *, const u_int8_t *, u_int16_t, const u_int8_t *, u_int16_t); + +/* Standard Blowfish */ + +void blf_key(blf_ctx *, const u_int8_t *, u_int16_t); +void blf_enc(blf_ctx *, u_int32_t *, u_int16_t); +void blf_dec(blf_ctx *, u_int32_t *, u_int16_t); + +void blf_ecb_encrypt(blf_ctx *, u_int8_t *, u_int32_t); +void blf_ecb_decrypt(blf_ctx *, u_int8_t *, u_int32_t); + +void blf_cbc_encrypt(blf_ctx *, u_int8_t *, u_int8_t *, u_int32_t); +void blf_cbc_decrypt(blf_ctx *, u_int8_t *, u_int8_t *, u_int32_t); + +/* Converts u_int8_t to u_int32_t */ +u_int32_t Blowfish_stream2word(const u_int8_t *, u_int16_t , u_int16_t *); + +#endif diff --git a/server/_build/default/lib/bcrypt/ebin/bcrypt.app b/server/_build/default/lib/bcrypt/ebin/bcrypt.app new file mode 100644 index 0000000..48bb861 --- /dev/null +++ b/server/_build/default/lib/bcrypt/ebin/bcrypt.app @@ -0,0 +1,18 @@ +{application,bcrypt, + [{description,"An Erlang wrapper (NIF or port program) for the OpenBSD password scheme, bcrypt."}, + {vsn,"1.2.0"}, + {registered,[bcrypt_sup,bcrypt_port_sup,bcrypt_pool]}, + {mod,{bcrypt_app,[]}}, + {applications,[kernel,stdlib,crypto,poolboy]}, + {env,[{default_log_rounds,12}, + {mechanism,nif}, + {pool_size,4}, + {nif_pool_size,4}, + {nif_pool_max_overflow,10}]}, + {exclude_files,["priv/bcrypt"]}, + {maintainers,["Hunter Morris","Mrinal Wadhwa","ErlangPack"]}, + {licenses,["MIT"]}, + {links,[{"Github","https://github.com/erlangpack/bcrypt"}]}, + {modules,[bcrypt,bcrypt_app,bcrypt_nif,bcrypt_nif_pool_sup, + bcrypt_nif_worker,bcrypt_pool,bcrypt_port, + bcrypt_port_sup,bcrypt_sup]}]}. diff --git a/server/_build/default/lib/bcrypt/ebin/bcrypt.beam b/server/_build/default/lib/bcrypt/ebin/bcrypt.beam Binary files differnew file mode 100644 index 0000000..9331a98 --- /dev/null +++ b/server/_build/default/lib/bcrypt/ebin/bcrypt.beam diff --git a/server/_build/default/lib/bcrypt/ebin/bcrypt_app.beam b/server/_build/default/lib/bcrypt/ebin/bcrypt_app.beam Binary files differnew file mode 100644 index 0000000..4fcd74f --- /dev/null +++ b/server/_build/default/lib/bcrypt/ebin/bcrypt_app.beam diff --git a/server/_build/default/lib/bcrypt/ebin/bcrypt_nif.beam b/server/_build/default/lib/bcrypt/ebin/bcrypt_nif.beam Binary files differnew file mode 100644 index 0000000..86b1bf3 --- /dev/null +++ b/server/_build/default/lib/bcrypt/ebin/bcrypt_nif.beam diff --git a/server/_build/default/lib/bcrypt/ebin/bcrypt_nif_pool_sup.beam b/server/_build/default/lib/bcrypt/ebin/bcrypt_nif_pool_sup.beam Binary files differnew file mode 100644 index 0000000..f66ce73 --- /dev/null +++ b/server/_build/default/lib/bcrypt/ebin/bcrypt_nif_pool_sup.beam diff --git a/server/_build/default/lib/bcrypt/ebin/bcrypt_nif_worker.beam b/server/_build/default/lib/bcrypt/ebin/bcrypt_nif_worker.beam Binary files differnew file mode 100644 index 0000000..0b120f8 --- /dev/null +++ b/server/_build/default/lib/bcrypt/ebin/bcrypt_nif_worker.beam diff --git a/server/_build/default/lib/bcrypt/ebin/bcrypt_pool.beam b/server/_build/default/lib/bcrypt/ebin/bcrypt_pool.beam Binary files differnew file mode 100644 index 0000000..7637e75 --- /dev/null +++ b/server/_build/default/lib/bcrypt/ebin/bcrypt_pool.beam diff --git a/server/_build/default/lib/bcrypt/ebin/bcrypt_port.beam b/server/_build/default/lib/bcrypt/ebin/bcrypt_port.beam Binary files differnew file mode 100644 index 0000000..5509406 --- /dev/null +++ b/server/_build/default/lib/bcrypt/ebin/bcrypt_port.beam diff --git a/server/_build/default/lib/bcrypt/ebin/bcrypt_port_sup.beam b/server/_build/default/lib/bcrypt/ebin/bcrypt_port_sup.beam Binary files differnew file mode 100644 index 0000000..b262153 --- /dev/null +++ b/server/_build/default/lib/bcrypt/ebin/bcrypt_port_sup.beam diff --git a/server/_build/default/lib/bcrypt/ebin/bcrypt_sup.beam b/server/_build/default/lib/bcrypt/ebin/bcrypt_sup.beam Binary files differnew file mode 100644 index 0000000..b4b1b7d --- /dev/null +++ b/server/_build/default/lib/bcrypt/ebin/bcrypt_sup.beam diff --git a/server/_build/default/lib/bcrypt/hex_metadata.config b/server/_build/default/lib/bcrypt/hex_metadata.config new file mode 100644 index 0000000..50d2c35 --- /dev/null +++ b/server/_build/default/lib/bcrypt/hex_metadata.config @@ -0,0 +1,24 @@ +{<<"app">>,<<"bcrypt">>}. +{<<"build_tools">>,[<<"rebar3">>]}. +{<<"description">>, + <<"An Erlang wrapper (NIF or port program) for the OpenBSD password scheme, bcrypt.">>}. +{<<"files">>, + [<<"LICENSE">>,<<"README.md">>,<<"c_src">>,<<"c_src/Makefile">>, + <<"c_src/async_queue.c">>,<<"c_src/async_queue.h">>,<<"c_src/bcrypt.c">>, + <<"c_src/bcrypt_nif.c">>,<<"c_src/bcrypt_nif.h">>,<<"c_src/bcrypt_port.c">>, + <<"c_src/blowfish.c">>,<<"c_src/erl_blf.h">>,<<"priv">>, + <<"priv/.gitignore">>,<<"rebar.config">>,<<"rebar.lock">>,<<"src">>, + <<"src/bcrypt.app.src">>,<<"src/bcrypt.erl">>,<<"src/bcrypt_app.erl">>, + <<"src/bcrypt_nif.erl">>,<<"src/bcrypt_nif_pool_sup.erl">>, + <<"src/bcrypt_nif_worker.erl">>,<<"src/bcrypt_pool.erl">>, + <<"src/bcrypt_port.erl">>,<<"src/bcrypt_port_sup.erl">>, + <<"src/bcrypt_sup.erl">>]}. +{<<"licenses">>,[<<"MIT">>]}. +{<<"links">>,[{<<"Github">>,<<"https://github.com/erlangpack/bcrypt">>}]}. +{<<"name">>,<<"bcrypt">>}. +{<<"requirements">>, + [{<<"poolboy">>, + [{<<"app">>,<<"poolboy">>}, + {<<"optional">>,false}, + {<<"requirement">>,<<"1.5.2">>}]}]}. +{<<"version">>,<<"1.2.0">>}. diff --git a/server/_build/default/lib/bcrypt/priv/.gitignore b/server/_build/default/lib/bcrypt/priv/.gitignore new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/server/_build/default/lib/bcrypt/priv/.gitignore diff --git a/server/_build/default/lib/bcrypt/priv/bcrypt b/server/_build/default/lib/bcrypt/priv/bcrypt Binary files differnew file mode 100755 index 0000000..0c3f3a4 --- /dev/null +++ b/server/_build/default/lib/bcrypt/priv/bcrypt diff --git a/server/_build/default/lib/bcrypt/priv/bcrypt_nif.so b/server/_build/default/lib/bcrypt/priv/bcrypt_nif.so Binary files differnew file mode 100755 index 0000000..131b212 --- /dev/null +++ b/server/_build/default/lib/bcrypt/priv/bcrypt_nif.so diff --git a/server/_build/default/lib/bcrypt/rebar.config b/server/_build/default/lib/bcrypt/rebar.config new file mode 100644 index 0000000..6d00b4f --- /dev/null +++ b/server/_build/default/lib/bcrypt/rebar.config @@ -0,0 +1,62 @@ +%% -*- mode: erlang;erlang-indent-level: 2;indent-tabs-mode: nil -*- + +{require_min_otp_vsn, "21.3"}. + +{erl_opts, + [debug_info]}. + +{pre_hooks, + [{"(linux|darwin|solaris)", compile, "make -C c_src"}, + {"(freebsd|openbsd)", compile, "gmake -C c_src"}]}. + +{post_hooks, + [{"(linux|darwin|solaris)", clean, "make -C c_src clean"}, + {"(freebsd|openbsd)", clean, "gmake -C c_src clean"}]}. +{deps, [ + {poolboy, "1.5.2"} +]}. + +{profiles, [ + {test, [ + {xref_checks, [ + undefined_function_calls, + locals_not_used, + deprecated_function_calls + ]}, + + {xref_ignores, [ + ]}, + + {dialyzer, [ + {warnings, [ + no_return + ]} + ]}, + {plugins, [ + rebar3_proper + ]}, + {deps, [{proper,"1.4.0"}]} + ]}, + {edoc_private, [ + {edoc_opts, [ + {private, true} + ]} + ]} +]}. + +{project_plugins, [rebar3_hex, rebar3_ex_doc]}. + +{hex, [ + {doc, #{provider => ex_doc}} +]}. + +{ex_doc, [ + {extras, [ + {"README.md", #{title => "Overview"}}, + {"LICENSE", #{title => "License"}} + ]}, + {main, "README.md"}, + {source_url, "https://github.com/erlangpack/bcrypt"}, + {assets, "assets"}, + {api_reference, true} +]}. diff --git a/server/_build/default/lib/bcrypt/rebar.lock b/server/_build/default/lib/bcrypt/rebar.lock new file mode 100644 index 0000000..1ab8da9 --- /dev/null +++ b/server/_build/default/lib/bcrypt/rebar.lock @@ -0,0 +1,8 @@ +{"1.2.0", +[{<<"poolboy">>,{pkg,<<"poolboy">>,<<"1.5.2">>},0}]}. +[ +{pkg_hash,[ + {<<"poolboy">>, <<"392B007A1693A64540CEAD79830443ABF5762F5D30CF50BC95CB2C1AAAFA006B">>}]}, +{pkg_hash_ext,[ + {<<"poolboy">>, <<"DAD79704CE5440F3D5A3681C8590B9DC25D1A561E8F5A9C995281012860901E3">>}]} +]. diff --git a/server/_build/default/lib/bcrypt/src/bcrypt.app.src b/server/_build/default/lib/bcrypt/src/bcrypt.app.src new file mode 100644 index 0000000..d834377 --- /dev/null +++ b/server/_build/default/lib/bcrypt/src/bcrypt.app.src @@ -0,0 +1,15 @@ +{application,bcrypt, + [{description,"An Erlang wrapper (NIF or port program) for the OpenBSD password scheme, bcrypt."}, + {vsn,"1.2.0"}, + {registered,[bcrypt_sup,bcrypt_port_sup,bcrypt_pool]}, + {mod,{bcrypt_app,[]}}, + {applications,[kernel,stdlib,crypto,poolboy]}, + {env,[{default_log_rounds,12}, + {mechanism,nif}, + {pool_size,4}, + {nif_pool_size,4}, + {nif_pool_max_overflow,10}]}, + {exclude_files,["priv/bcrypt"]}, + {maintainers,["Hunter Morris","Mrinal Wadhwa","ErlangPack"]}, + {licenses,["MIT"]}, + {links,[{"Github","https://github.com/erlangpack/bcrypt"}]}]}. diff --git a/server/_build/default/lib/bcrypt/src/bcrypt.erl b/server/_build/default/lib/bcrypt/src/bcrypt.erl new file mode 100644 index 0000000..f1997c2 --- /dev/null +++ b/server/_build/default/lib/bcrypt/src/bcrypt.erl @@ -0,0 +1,91 @@ +%% Copyright (c) 2011 Hunter Morris +%% Distributed under the MIT license; see LICENSE for details. +%% @doc The OpenBSD Blowfish password hashing algorithm wrapper module. +-module(bcrypt). +-author('Hunter Morris <hunter.morris@smarkets.com>'). + +%% API +-export([start/0, stop/0]). +-export([mechanism/0]). +-export([gen_salt/0, gen_salt/1, hashpw/2]). + +-type mechanism() :: nif | port. +-type rounds() :: 4..31. +-type pwerr() :: invalid_salt | invalid_salt_length | invalid_rounds. + +-export_type([ mechanism/0, rounds/0, pwerr/0 ]). + +%% @doc Starts `Application' `bcrypt'. +%% <b>See also:</b> +%% [http://erlang.org/doc/man/application.html#start-1 application:start/1]. + +start() -> application:start(bcrypt). + +%% @doc Stops `Application' `bcrypt'. +%% <b>See also:</b> +%% [http://erlang.org/doc/man/application.html#stop-1 application:stop/1]. + +stop() -> application:stop(bcrypt). + +%% @doc Get environment setting of hash generation. + +-spec mechanism() -> mechanism(). +mechanism() -> + {ok, M} = application:get_env(bcrypt, mechanism), + M. + +%% @doc Returns a random string data. + +-spec gen_salt() -> Result when + Result :: {ok, Salt}, + Salt :: [byte()]. +gen_salt() -> + do_gen_salt(mechanism()). + +%% @doc Generate a random string data. + +-spec gen_salt( Rounds ) -> Result when + Rounds :: rounds(), + Result :: {ok, Salt}, + Salt :: [byte()]. +gen_salt(Rounds) when is_integer(Rounds), Rounds < 32, Rounds > 3 -> + do_gen_salt(mechanism(), Rounds). + +%% @doc Make hash string based on `Password' and `Salt'. + +-spec hashpw( Password, Salt ) -> Result when + Password :: [byte()] | binary(), + Salt :: [byte()] | binary(), + Result :: {ok, Hash} | {error, ErrorDescription}, + Hash :: [byte()], + ErrorDescription :: pwerr(). +hashpw(Password, Salt) -> + do_hashpw(mechanism(), Password, Salt). + +%% @private + +-spec do_gen_salt(nif | port) -> Result when + Result :: {ok, Salt}, + Salt :: [byte()]. +do_gen_salt(nif) -> bcrypt_nif_worker:gen_salt(); +do_gen_salt(port) -> bcrypt_pool:gen_salt(). + +%% @private + +-spec do_gen_salt(nif | port, Rounds) -> Result when + Rounds :: rounds(), + Result :: {ok, Salt}, + Salt :: [byte()]. +do_gen_salt(nif, Rounds) -> bcrypt_nif_worker:gen_salt(Rounds); +do_gen_salt(port, Rounds) -> bcrypt_pool:gen_salt(Rounds). + +%% @private + +-spec do_hashpw(nif | port, Password, Salt) -> Result when + Password :: [byte()] | binary(), + Salt :: [byte()], + Result :: {ok, Hash} | {error, ErrorDescription}, + Hash :: [byte()], + ErrorDescription :: pwerr(). +do_hashpw(nif, Password, Salt) -> bcrypt_nif_worker:hashpw(Password, Salt); +do_hashpw(port, Password, Salt) -> bcrypt_pool:hashpw(Password, Salt). diff --git a/server/_build/default/lib/bcrypt/src/bcrypt_app.erl b/server/_build/default/lib/bcrypt/src/bcrypt_app.erl new file mode 100644 index 0000000..d83db7d --- /dev/null +++ b/server/_build/default/lib/bcrypt/src/bcrypt_app.erl @@ -0,0 +1,27 @@ +%% @copyright 2011 Hunter Morris +%% @doc Implementation of `application' behaviour. +%% @private +%% @end +%% Distributed under the MIT license; see LICENSE for details. +-module(bcrypt_app). +-author('Hunter Morris <hunter.morris@smarkets.com>'). + +-behaviour(application). + +-export([start/2, stop/1]). + +-spec start(StartType, StartArgs) -> Result when + StartType :: normal, + StartArgs :: term(), + Result :: {ok, pid()} | {error, Reason}, + Reason :: term(). +start(normal, _Args) -> + case bcrypt_sup:start_link() of + {ok, Pid} -> {ok, Pid}; + {error, _} = Error -> Error + end. + +-spec stop(State) -> Result when + State :: term(), + Result :: ok. +stop(_State) -> ok. diff --git a/server/_build/default/lib/bcrypt/src/bcrypt_nif.erl b/server/_build/default/lib/bcrypt/src/bcrypt_nif.erl new file mode 100644 index 0000000..348d8df --- /dev/null +++ b/server/_build/default/lib/bcrypt/src/bcrypt_nif.erl @@ -0,0 +1,99 @@ +%% @author Hunter Morris <hunter.morris@smarkets.com> +%% @copyright 2011 Hunter Morris +%% +%% @doc Bcrypt Erlang wrapper. <div>The wrapper around the OpenBSD Blowfish password hashing algorithm, as +%% described in: [http://www.openbsd.org/papers/bcrypt-paper.ps "A Future-Adaptable Password Scheme"] +%% by Niels Provos and David Mazieres.</div> +%% @end +%% +%% Permission to use, copy, modify, and distribute this software for any +%% purpose with or without fee is hereby granted, provided that the above +%% copyright notice and this permission notice appear in all copies. + +%% THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +%% WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +%% MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +%% ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +%% WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +%% ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +%% OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +-module(bcrypt_nif). +-author('Hunter Morris <hunter.morris@smarkets.com>'). + +%% API +-export([init/0]). +-export([gen_salt/1, hashpw/5, create_ctx/0]). + +-on_load(init/0). + +%%-------------------------------------------------------------------- +%% @doc Load the bcrypt NIFs +%% @private +%% @end +%%-------------------------------------------------------------------- + +-spec init() -> Result when + Result :: ok | Error, + Error :: {error, {Reason, ErrorText}}, + Reason :: load_failed | bad_lib | load | reload | upgrade | old_code, + ErrorText :: string(). +init() -> + Dir = case code:priv_dir(bcrypt) of + {error, bad_name} -> + case code:which(bcrypt) of + Filename when is_list(Filename) -> + filename:join( + [filename:dirname(Filename), "../priv"]); + _ -> + "../priv" + end; + Priv -> Priv + end, + erlang:load_nif(filename:join(Dir, "bcrypt_nif"), 0). + +%%-------------------------------------------------------------------- +%% @doc Generate a random text salt for use with hashpw/3. LogRounds +%% defines the complexity of the hashing, increasing the cost as +%% 2^log_rounds. +%% @end +%%-------------------------------------------------------------------- + +-spec gen_salt(LogRounds) -> Result when + LogRounds :: integer(), + Result :: [byte()]. +gen_salt(LogRounds) + when is_integer(LogRounds), LogRounds < 32, LogRounds > 3 -> + R = crypto:strong_rand_bytes(16), + encode_salt(R, LogRounds). + +encode_salt(_R, _LogRounds) -> + nif_stub_error(?LINE). + +%%-------------------------------------------------------------------- +%% @doc Create a context which hashes passwords in a separate thread. +%% @end +%%-------------------------------------------------------------------- + +-spec create_ctx() -> Context when + Context :: term(). +create_ctx() -> + nif_stub_error(?LINE). + +%%-------------------------------------------------------------------- +%% @doc Hash the specified password and the salt using the OpenBSD +%% Blowfish password hashing algorithm. Returns the hashed password. +%% @end +%%-------------------------------------------------------------------- + +-spec hashpw(Ctx, Ref, Pid, Password, Salt) -> Result when + Ctx :: term(), + Ref :: reference(), + Pid :: pid(), + Password :: [byte()], + Salt :: [byte()], + Result :: ok. +hashpw(_Ctx, _Ref, _Pid, _Password, _Salt) -> + nif_stub_error(?LINE). + +nif_stub_error(Line) -> + erlang:nif_error({nif_not_loaded, module, ?MODULE, line, Line}). diff --git a/server/_build/default/lib/bcrypt/src/bcrypt_nif_pool_sup.erl b/server/_build/default/lib/bcrypt/src/bcrypt_nif_pool_sup.erl new file mode 100644 index 0000000..dbd5868 --- /dev/null +++ b/server/_build/default/lib/bcrypt/src/bcrypt_nif_pool_sup.erl @@ -0,0 +1,50 @@ +%% @copyright 2011 Hunter Morris +%% @doc Implementation of `supervisor' behaviour. +%% @private +%% @end +%% Distributed under the MIT license; see LICENSE for details. +-module(bcrypt_nif_pool_sup). + +-behaviour(supervisor). + +-export([start_link/0, start_child/0, init/1]). + +%% @doc Creates a supervisor process as part of a supervision tree. + + +-spec start_link() -> Result when + Result :: {ok, pid()} | ignore | {error, StartlinkError}, + StartlinkError :: {already_started, pid()} | {shutdown, term()} | term(). +start_link() -> supervisor:start_link({local, ?MODULE}, ?MODULE, []). + +%% @doc Dynamically adds a child specification to supervisor, +%% which starts the corresponding child process. + +-spec start_child() -> Result when + Info :: term(), + Child :: undefined | pid(), + Result :: {ok, Child} | {ok, Child, Info} | {error, StartChildError}, + StartChildError :: already_present | {already_started, Child} | term(). +start_child() -> supervisor:start_child(?MODULE, []). + +-spec init(Args) -> Result when + Args :: list(), + Result :: {ok,{SupFlags, ChildSpec}} | ignore, + SupFlags :: {one_for_one, 10, 10}, + ChildSpec :: [supervisor:child_spec()]. +init([]) -> + {ok, PoolSize} = application:get_env(bcrypt, nif_pool_size), + {ok, MaxOverFlow} = application:get_env(bcrypt, nif_pool_max_overflow), + + PoolArgs = [ + {name, {local, bcrypt_nif_pool}}, + {size, PoolSize}, + {max_overflow, MaxOverFlow}, + {worker_module, bcrypt_nif_worker} + ], + + PoolSpecs = [ + poolboy:child_spec(bcrypt_nif_pool, PoolArgs, []) + ], + + {ok, {{one_for_one, 10, 10}, PoolSpecs}}.
\ No newline at end of file diff --git a/server/_build/default/lib/bcrypt/src/bcrypt_nif_worker.erl b/server/_build/default/lib/bcrypt/src/bcrypt_nif_worker.erl new file mode 100644 index 0000000..70b8eed --- /dev/null +++ b/server/_build/default/lib/bcrypt/src/bcrypt_nif_worker.erl @@ -0,0 +1,144 @@ +%% @copyright 2011 Hunter Morris. +%% @doc Implementation of `gen_server' behaviour. +%% @end +%% Distributed under the MIT license; see LICENSE for details. +-module(bcrypt_nif_worker). +-author('Hunter Morris <huntermorris@gmail.com>'). + +-behaviour(gen_server). + +-export([start_link/1]). +-export([gen_salt/0, gen_salt/1]). +-export([hashpw/2]). + +%% gen_server +-export([init/1, code_change/3, terminate/2, + handle_call/3, handle_cast/2, handle_info/2]). + +-record(state, { + default_log_rounds :: integer(), + context :: term() + }). + +-type state() :: #state{default_log_rounds :: integer(), context :: term()}. + +%% @doc Creates a `gen_server' process as part of a supervision tree. + +-spec start_link(Args) -> Result when + Args :: term(), + Result :: {ok,Pid} | ignore | {error,Error}, + Pid :: pid(), + Error :: {already_started,Pid} | term(). +start_link(Args) -> gen_server:start_link(?MODULE, Args, []). + +%% @doc Returns bcrypt salt. + +-spec gen_salt() -> Result when + Result :: [byte()]. +gen_salt() -> + poolboy:transaction(bcrypt_nif_pool, fun(Worker) -> + gen_server:call(Worker, gen_salt, infinity) + end). + +%% @doc Returns bcrypt salt. + +-spec gen_salt(Rounds) -> Result when + Rounds :: bcrypt:rounds(), + Result :: [byte()]. +gen_salt(Rounds) -> + poolboy:transaction(bcrypt_nif_pool, fun(Worker) -> + gen_server:call(Worker, {gen_salt, Rounds}, infinity) + end). + +%% @doc Make hash string based on `Password' and `Salt'. + +-spec hashpw( Password, Salt ) -> Result when + Password :: [byte()] | binary(), + Salt :: [byte()] | binary(), + Result :: {ok, Hash} | {error, ErrorDescription}, + Hash :: [byte()], + ErrorDescription :: bcrypt:pwerr(). +hashpw(Password, Salt) -> + poolboy:transaction(bcrypt_nif_pool, fun(Worker) -> + gen_server:call(Worker, {hashpw, Password, Salt}, infinity) + end). + +%% @private + +-spec init(Args) -> Result when + Args :: list(), + Result :: {ok, state()}. +init([]) -> + process_flag(trap_exit, true), + {ok, Default} = application:get_env(bcrypt, default_log_rounds), + Ctx = bcrypt_nif:create_ctx(), + {ok, #state{default_log_rounds = Default, context = Ctx}}. + +%% @private + +terminate(shutdown, _) -> ok. + +%% @private + +-spec handle_call(Request, From, State) -> Result when + Request :: gen_salt, + From :: {pid(), atom()}, + State :: state(), + Result :: {reply, Reply, State}, + Reply :: {ok, Salt}, + Salt :: integer(); +(Request, From, State) -> Result when + Request :: {gen_salt, Rounds}, + From :: {pid(), atom()}, + State :: state(), + Rounds :: bcrypt:rounds(), + Result :: {reply, Reply, State}, + Reply :: {ok, Salt}, + Salt :: integer(); +(Request, From, State) -> Result when + Request :: {hashpw, Password, Salt}, + From :: {pid(), atom()}, + State :: state(), + Password :: [byte()], + Salt :: integer(), + Result :: {reply, Reply, State} | {reply, Reply, State}, + Reply :: {ok, ResultInfo} | {error, ResultInfo}, + ResultInfo :: term(). + +handle_call(gen_salt, _From, #state{default_log_rounds = R} = State) -> + Salt = bcrypt_nif:gen_salt(R), + {reply, {ok, Salt}, State}; +handle_call({gen_salt, R}, _From, State) -> + Salt = bcrypt_nif:gen_salt(R), + {reply, {ok, Salt}, State}; +handle_call({hashpw, Password, Salt}, _From, #state{context=Ctx}=State) -> + Ref = make_ref(), + ok = bcrypt_nif:hashpw(Ctx, Ref, self(), to_list(Password), to_list(Salt)), + receive + {ok, Ref, Result} -> + {reply, {ok, Result}, State}; + {error, Ref, Result} -> + {reply, {error, Result}, State} + end; +handle_call(Msg, _, _) -> exit({unknown_call, Msg}). + +%% @private + +handle_cast(Msg, _) -> exit({unknown_cast, Msg}). + +%% @private + +handle_info(Msg, _) -> exit({unknown_info, Msg}). + +%% @private + +code_change(_OldVsn, State, _Extra) -> {ok, State}. + +-spec to_list(List) -> Result when + List :: [byte()], + Result :: [byte()]; +(Binary) -> Result when + Binary :: binary(), + Result :: [byte()]. +to_list(L) when is_list(L) -> L; +to_list(B) when is_binary(B) -> binary_to_list(B). diff --git a/server/_build/default/lib/bcrypt/src/bcrypt_pool.erl b/server/_build/default/lib/bcrypt/src/bcrypt_pool.erl new file mode 100644 index 0000000..7b6ea91 --- /dev/null +++ b/server/_build/default/lib/bcrypt/src/bcrypt_pool.erl @@ -0,0 +1,140 @@ +%% @copyright 2011 Hunter Morris +%% @doc Implementation of `gen_server' behaviour. +%% @end +%% Distributed under the MIT license; see LICENSE for details. +-module(bcrypt_pool). +-author('Hunter Morris <huntermorris@gmail.com>'). + +-behaviour(gen_server). + +-export([start_link/0, available/1]). +-export([gen_salt/0, gen_salt/1]). +-export([hashpw/2]). + +%% gen_server +-export([init/1, code_change/3, terminate/2, + handle_call/3, handle_cast/2, handle_info/2]). + +-record(state, { + size = 0, + busy = 0, + requests = queue:new(), + ports = queue:new() + }). + +-record(req, {mon :: reference(), from :: {pid(), atom()}}). + +-type state() :: #state{size :: 0, busy :: 0, requests :: queue:queue(), ports :: queue:queue()}. + +%% @doc Creates a `gen_server' process as part of a supervision tree. + +-spec start_link() -> Result when + Result :: {ok,Pid} | ignore | {error,Error}, + Pid :: pid(), + Error :: {already_started,Pid} | term(). +start_link() -> gen_server:start_link({local, ?MODULE}, ?MODULE, [], []). + +%% @doc Asynchronosly check if `Pid' in `#state:requests' queue or not. + +-spec available(Pid) -> Result when + Pid :: pid(), + Result :: ok. +available(Pid) -> gen_server:cast(?MODULE, {available, Pid}). + +%% @doc Generate a random text salt. + +-spec gen_salt() -> Result when + Result :: {ok, Salt}, + Salt :: [byte()]. +gen_salt() -> do_call(fun bcrypt_port:gen_salt/1, []). + +%% @doc Generate a random text salt. Rounds defines the complexity of +%% the hashing, increasing the cost as 2^log_rounds. + +-spec gen_salt(Rounds) -> Result when + Rounds :: bcrypt:rounds(), + Result :: {ok, Salt}, + Salt :: [byte()]. +gen_salt(Rounds) -> do_call(fun bcrypt_port:gen_salt/2, [Rounds]). + +%% @doc Hash the specified password and the salt. + +hashpw(Password, Salt) -> do_call(fun bcrypt_port:hashpw/3, [Password, Salt]). + +%% @private + +-spec init([]) -> Result when + Result :: {ok, state()}. +init([]) -> + {ok, Size} = application:get_env(bcrypt, pool_size), + {ok, #state{size = Size}}. + +%% @private + +terminate(shutdown, _) -> ok. + +%% @private + +-spec handle_call(Request, From, State) -> Result when + Request :: request, + From :: {RPid, atom()}, + RPid :: pid(), + State :: state(), + Result :: {noreply, state()} | {reply, {ok, pid()}, state()}. +handle_call(request, {RPid, _} = From, #state{ports = P} = State) -> + case queue:out(P) of + {empty, P} -> + #state{size = Size, busy = B, requests = R} = State, + B1 = + if Size > B -> + {ok, _} = bcrypt_port_sup:start_child(), + B + 1; + true -> + B + end, + RRef = erlang:monitor(process, RPid), + R1 = queue:in(#req{mon = RRef, from = From}, R), + {noreply, State#state{requests = R1, + busy = B1}}; + {{value, PPid}, P1} -> + #state{busy = B} = State, + {reply, {ok, PPid}, State#state{busy = B + 1, ports = P1}} + end; +handle_call(Msg, _, _) -> exit({unknown_call, Msg}). + +%% @private + +-spec handle_cast({available, Pid}, state()) -> Result when + Pid :: pid(), + Result :: {noreply, state()}. +handle_cast( + {available, Pid}, + #state{requests = R, ports = P, busy = B} = S) -> + case queue:out(R) of + {empty, R} -> + {noreply, S#state{ports = queue:in(Pid, P), busy = B - 1}}; + {{value, #req{mon = Mon, from = F}}, R1} -> + true = erlang:demonitor(Mon, [flush]), + gen_server:reply(F, {ok, Pid}), + {noreply, S#state{requests = R1}} + end; +handle_cast(Msg, _) -> exit({unknown_cast, Msg}). + +%% @private + +handle_info({'DOWN', Ref, process, _Pid, _Reason}, #state{requests = R} = State) -> + R1 = queue:from_list(lists:keydelete(Ref, #req.mon, queue:to_list(R))), + {noreply, State#state{requests = R1}}; + +%% @private + +handle_info(Msg, _) -> exit({unknown_info, Msg}). + +%% @private + +code_change(_OldVsn, State, _Extra) -> {ok, State}. + +do_call(F, Args0) -> + {ok, Pid} = gen_server:call(?MODULE, request, infinity), + Args = [Pid|Args0], + apply(F, Args). diff --git a/server/_build/default/lib/bcrypt/src/bcrypt_port.erl b/server/_build/default/lib/bcrypt/src/bcrypt_port.erl new file mode 100644 index 0000000..6365de6 --- /dev/null +++ b/server/_build/default/lib/bcrypt/src/bcrypt_port.erl @@ -0,0 +1,157 @@ +%% @copyright 2011 Hunter Morris +%% @doc Implementation of `gen_server' behaviour. +%% @end +%% Distributed under the MIT license; see LICENSE for details. +-module(bcrypt_port). +-author('Hunter Morris <hunter.morris@smarkets.com>'). + +-behaviour(gen_server). + +%% API +-export([start_link/0, stop/0]). +-export([gen_salt/1, gen_salt/2]). +-export([hashpw/3]). + +%% gen_server callbacks +-export([init/1, handle_call/3, handle_cast/2, handle_info/2, terminate/2, + code_change/3]). + +-record(state, { + port :: port(), + default_log_rounds :: non_neg_integer(), + cmd_from :: {pid(), term()} | undefined + }). + +-type state() :: #state{port :: port(), + default_log_rounds :: non_neg_integer(), + cmd_from :: {pid(), term()} | undefined}. + +-define(CMD_SALT, 0). +-define(CMD_HASH, 1). +-define(BCRYPT_ERROR(F, D), error_logger:error_msg(F, D)). +-define(BCRYPT_WARNING(F, D), error_logger:warning_msg(F, D)). + +-spec start_link() -> Result when + Result :: {ok,Pid} | ignore | {error,Error}, + Pid :: pid(), + Error :: {already_started,Pid} | term(), + Pid :: pid(). +start_link() -> + Dir = case code:priv_dir(bcrypt) of + {error, bad_name} -> + case code:which(bcrypt) of + Filename when is_list(Filename) -> + filename:join( + [filename:dirname(Filename), "../priv"]); + _ -> + "../priv" + end; + Priv -> Priv + end, + Port = filename:join(Dir, "bcrypt"), + gen_server:start_link(?MODULE, [Port], []). + +-spec stop() -> Result when + Result :: {stop, normal, ok, state()}. +stop() -> gen_server:call(?MODULE, stop). + +-spec gen_salt(Pid) -> Result when + Pid :: pid(), + Result :: {ok, Salt}, + Salt :: [byte()]. +gen_salt(Pid) -> + R = crypto:strong_rand_bytes(16), + gen_server:call(Pid, {encode_salt, R}, infinity). + +-spec gen_salt(Pid, LogRounds) -> Result when + Pid :: pid(), + LogRounds :: bcrypt:rounds(), + Result :: {ok, Salt}, + Salt :: [byte()]. +gen_salt(Pid, LogRounds) -> + R = crypto:strong_rand_bytes(16), + gen_server:call(Pid, {encode_salt, R, LogRounds}, infinity). + +-spec hashpw(Pid, Password, Salt) -> Result when + Pid :: pid(), + Password :: [byte()], + Salt :: [byte()], + Result :: [byte()]. +hashpw(Pid, Password, Salt) -> + gen_server:call(Pid, {hashpw, Password, Salt}, infinity). + +%%==================================================================== +%% gen_server callbacks +%%==================================================================== +%% @private + +init([Filename]) -> + case file:read_file_info(Filename) of + {ok, _Info} -> + Port = open_port( + {spawn, Filename}, [{packet, 2}, binary, exit_status]), + ok = bcrypt_pool:available(self()), + {ok, Rounds} = application:get_env(bcrypt, default_log_rounds), + {ok, #state{port = Port, default_log_rounds = Rounds}}; + {error, Reason} -> + ?BCRYPT_ERROR("Can't open file ~p: ~p", [Filename, Reason]), + {stop, error_opening_bcrypt_file} + end. + +%% @private + +terminate(_Reason, #state{port=Port}) -> + catch port_close(Port), + ok. + +%% @private + +handle_call({encode_salt, R}, From, #state{default_log_rounds = LogRounds} = State) -> + handle_call({encode_salt, R, LogRounds}, From, State); +handle_call({encode_salt, R, LogRounds}, From, #state{ cmd_from = undefined } = State) -> + Port = State#state.port, + Data = term_to_binary({?CMD_SALT, {iolist_to_binary(R), LogRounds}}), + erlang:port_command(Port, Data), + {noreply, State#state{ cmd_from = From }}; +handle_call({encode_salt, _R, _Rounds}, From, #state{ cmd_from = CmdFrom } = State) -> + ?BCRYPT_ERROR("bcrypt: Salt request from ~p whilst busy for ~p", [ From, CmdFrom ]), + {reply, {error, {busy, From}}, State}; +handle_call({hashpw, Password, Salt}, From, #state{ cmd_from = undefined } = State) -> + Port = State#state.port, + Data = term_to_binary({?CMD_HASH, {iolist_to_binary(Password), iolist_to_binary(Salt)}}), + erlang:port_command(Port, Data), + {noreply, State#state{ cmd_from = From }}; +handle_call({hashpw, _Password, _Salt}, From, #state{ cmd_from = CmdFrom } = State) -> + ?BCRYPT_ERROR("bcrypt: Hash request from ~p whilst busy for ~p", [ From, CmdFrom ]), + {reply, {error, {busy, From}}, State}; +handle_call(stop, _From, State) -> + {stop, normal, ok, State}; +handle_call(Msg, _, State) -> + {stop, {unknown_call, Msg}, State}. + +handle_cast(Msg, State) -> + {stop, {unknown_cast, Msg}, State}. + +code_change(_OldVsn, State, _Extra) -> + {ok, State}. + +handle_info({Port, {data, Data}}, #state{ port = Port, cmd_from = From } = State) -> + Reply = + case binary_to_term(Data) of + {_, Error} when is_atom(Error) -> + {error, Error}; + {?CMD_SALT, Result} when is_binary(Result) -> + {ok, binary_to_list(Result)}; + {?CMD_HASH, Result} when is_binary(Result) -> + {ok, binary_to_list(Result)} + end, + gen_server:reply(From, Reply), + ok = bcrypt_pool:available(self()), + {noreply, State#state{ cmd_from = undefined }}; +handle_info({Port, {exit_status, Status}}, #state{port=Port}=State) -> + %% Rely on whomever is supervising this process to restart. + ?BCRYPT_WARNING("Port died: ~p", [Status]), + {stop, port_died, State}; +handle_info(Msg, _) -> + exit({unknown_info, Msg}). + diff --git a/server/_build/default/lib/bcrypt/src/bcrypt_port_sup.erl b/server/_build/default/lib/bcrypt/src/bcrypt_port_sup.erl new file mode 100644 index 0000000..89fe33d --- /dev/null +++ b/server/_build/default/lib/bcrypt/src/bcrypt_port_sup.erl @@ -0,0 +1,21 @@ +%% @copyright 2011 Hunter Morris +%% @doc Implementation of `supervisor' behaviour. +%% @private +%% @end +%% Distributed under the MIT license; see LICENSE for details. +-module(bcrypt_port_sup). +-author('Hunter Morris <huntermorris@gmail.com>'). + +-behaviour(supervisor). + +-export([start_link/0, start_child/0, init/1]). + +start_link() -> supervisor:start_link({local, ?MODULE}, ?MODULE, []). + +start_child() -> supervisor:start_child(?MODULE, []). + +init([]) -> + {ok, {{simple_one_for_one, 1, 1}, + [{undefined, + {bcrypt_port, start_link, []}, + transient, brutal_kill, worker, [bcrypt_port]}]}}. diff --git a/server/_build/default/lib/bcrypt/src/bcrypt_sup.erl b/server/_build/default/lib/bcrypt/src/bcrypt_sup.erl new file mode 100644 index 0000000..502a6a3 --- /dev/null +++ b/server/_build/default/lib/bcrypt/src/bcrypt_sup.erl @@ -0,0 +1,28 @@ +%% @copyright 2011 Hunter Morris +%% @doc Implementation of `supervisor' behaviour. +%% @private +%% @end +%% Distributed under the MIT license; see LICENSE for details. +-module(bcrypt_sup). +-author('Hunter Morris <huntermorris@gmail.com>'). + +-behaviour(supervisor). + +-export([start_link/0, init/1]). + +start_link() -> supervisor:start_link({local, ?MODULE}, ?MODULE, []). + +init([]) -> + PortChildren + = [{bcrypt_port_sup, {bcrypt_port_sup, start_link, []}, permanent, + 16#ffffffff, supervisor, [bcrypt_port_sup]}, + {bcrypt_pool, {bcrypt_pool, start_link, []}, permanent, + 16#ffffffff, worker, [bcrypt_pool]}], + NifChildren + = [{bcrypt_nif_pool_sup, {bcrypt_nif_pool_sup, start_link, []}, permanent, + 16#ffffffff, supervisor, [bcrypt_nif_pool_sup]}], + case application:get_env(bcrypt, mechanism) of + undefined -> {stop, no_mechanism_defined}; + {ok, nif} -> {ok, {{one_for_all, 15, 60}, NifChildren}}; + {ok, port} -> {ok, {{one_for_all, 15, 60}, PortChildren}} + end. |