Auto merge of #4740 - str4d:remove-openssl, r=daira
Remove OpenSSL Includes changes cherry-picked from the following upstream PRs: - bitcoin/bitcoin#7095 - bitcoin/bitcoin#11024 - bitcoin/bitcoin#17165 - Only the commit removing SSL lib detection (we have long since removed the rest). - bitcoin/bitcoin#17265 - We had already migrated away from OpenSSL for randomness. - bitcoin/bitcoin#17515 - Only the second commit. Closes #145.
This commit is contained in:
commit
b5fa52b701
5
COPYING
5
COPYING
|
@ -29,11 +29,6 @@ source code is not considered a derived work of these Autoconf macros or of the
|
|||
dependencies. For further details see 'contrib/debian/copyright'.
|
||||
|
||||
|
||||
This product includes software developed by the OpenSSL Project for use in the
|
||||
OpenSSL Toolkit (https://www.openssl.org/). This product includes cryptographic
|
||||
software written by Eric Young (eay@cryptsoft.com).
|
||||
|
||||
|
||||
Although almost all of the Zcash code is licensed under "permissive" open source
|
||||
licenses, users and distributors should note that when built using the default
|
||||
build options, Zcash depends on Oracle Berkeley DB 6.2.x, which is licensed
|
||||
|
|
17
configure.ac
17
configure.ac
|
@ -429,12 +429,7 @@ case $host in
|
|||
dnl It's safe to add these paths even if the functionality is disabled by
|
||||
dnl the user (--without-wallet for example).
|
||||
|
||||
openssl_prefix=`$BREW --prefix openssl 2>/dev/null`
|
||||
bdb_prefix=`$BREW --prefix berkeley-db4 2>/dev/null`
|
||||
if test x$openssl_prefix != x; then
|
||||
PKG_CONFIG_PATH="$openssl_prefix/lib/pkgconfig:$PKG_CONFIG_PATH"
|
||||
export PKG_CONFIG_PATH
|
||||
fi
|
||||
if test x$bdb_prefix != x; then
|
||||
CPPFLAGS="$CPPFLAGS -I$bdb_prefix/include"
|
||||
LIBS="$LIBS -L$bdb_prefix/lib"
|
||||
|
@ -756,8 +751,6 @@ if test x$use_pkgconfig = xyes; then
|
|||
m4_ifdef(
|
||||
[PKG_CHECK_MODULES],
|
||||
[
|
||||
PKG_CHECK_MODULES([SSL], [libssl],, [AC_MSG_ERROR(openssl not found.)])
|
||||
PKG_CHECK_MODULES([CRYPTO], [libcrypto],,[AC_MSG_ERROR(libcrypto not found.)])
|
||||
if test x$build_bitcoin_utils$build_bitcoind$bitcoin_enable_qt$use_tests != xnononono; then
|
||||
PKG_CHECK_MODULES([EVENT], [libevent],, [AC_MSG_ERROR(libevent not found.)])
|
||||
if test x$TARGET_OS != xwindows; then
|
||||
|
@ -777,14 +770,6 @@ if test x$use_pkgconfig = xyes; then
|
|||
]
|
||||
)
|
||||
else
|
||||
# BUG: Fix this:
|
||||
echo 'BUG: configure does not yet check for the following dependencies if pkg-config is not on the system: libcrypto++'
|
||||
|
||||
AC_CHECK_HEADER([openssl/crypto.h],,AC_MSG_ERROR(libcrypto headers missing))
|
||||
AC_CHECK_LIB([crypto], [main],CRYPTO_LIBS=-lcrypto, AC_MSG_ERROR(libcrypto missing))
|
||||
|
||||
AC_CHECK_HEADER([openssl/ssl.h],, AC_MSG_ERROR(libssl headers missing),)
|
||||
AC_CHECK_LIB([ssl], [main],SSL_LIBS=-lssl, AC_MSG_ERROR(libssl missing))
|
||||
|
||||
if test x$build_bitcoin_utils$build_bitcoind$bitcoin_enable_qt$use_tests != xnononono; then
|
||||
AC_CHECK_HEADER([event2/event.h],, AC_MSG_ERROR(libevent headers missing),)
|
||||
|
@ -962,8 +947,6 @@ AC_SUBST(LIBTOOL_APP_LDFLAGS)
|
|||
AC_SUBST(BOOST_LIBS)
|
||||
AC_SUBST(TESTDEFS)
|
||||
AC_SUBST(LEVELDB_TARGET_FLAGS)
|
||||
AC_SUBST(CRYPTO_LIBS)
|
||||
AC_SUBST(SSL_LIBS)
|
||||
AC_SUBST(EVENT_LIBS)
|
||||
AC_SUBST(EVENT_PTHREADS_LIBS)
|
||||
AC_SUBST(ZMQ_LIBS)
|
||||
|
|
|
@ -97,10 +97,6 @@ Copyright: 1990, 2016 Oracle and/or its affiliates;
|
|||
2000-2005 INRIA, France Telecom
|
||||
License: BDB
|
||||
|
||||
Files: depends/sources/openssl-*.tar.gz
|
||||
Copyright: 1998-2016 The OpenSSL Project and 1995-1998 Eric Young
|
||||
License: OpenSSL+SSLeay
|
||||
|
||||
Files: depends/sources/zeromq-*.tar.gz
|
||||
Copyright:
|
||||
1994, 1995, 1996, 1999, 2000, 2001, 2002, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
|
||||
|
@ -935,128 +931,6 @@ License: BDB
|
|||
* THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
License: OpenSSL+SSLeay
|
||||
The OpenSSL toolkit stays under a dual license, i.e. both the conditions of
|
||||
the OpenSSL License and the original SSLeay license apply to the toolkit.
|
||||
See below for the actual license texts.
|
||||
.
|
||||
OpenSSL License
|
||||
---------------
|
||||
.
|
||||
/* ====================================================================
|
||||
* Copyright (c) 1998-2016 The OpenSSL Project. 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 acknowledgment:
|
||||
* "This product includes software developed by the OpenSSL Project
|
||||
* for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
|
||||
*
|
||||
* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
|
||||
* endorse or promote products derived from this software without
|
||||
* prior written permission. For written permission, please contact
|
||||
* openssl-core@openssl.org.
|
||||
*
|
||||
* 5. Products derived from this software may not be called "OpenSSL"
|
||||
* nor may "OpenSSL" appear in their names without prior written
|
||||
* permission of the OpenSSL Project.
|
||||
*
|
||||
* 6. Redistributions of any form whatsoever must retain the following
|
||||
* acknowledgment:
|
||||
* "This product includes software developed by the OpenSSL Project
|
||||
* for use in the OpenSSL Toolkit (http://www.openssl.org/)"
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
|
||||
* EXPRESSED 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 OpenSSL PROJECT OR
|
||||
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
||||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
|
||||
* OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
* ====================================================================
|
||||
*
|
||||
* This product includes cryptographic software written by Eric Young
|
||||
* (eay@cryptsoft.com). This product includes software written by Tim
|
||||
* Hudson (tjh@cryptsoft.com).
|
||||
*
|
||||
*/
|
||||
.
|
||||
Original SSLeay License
|
||||
-----------------------
|
||||
.
|
||||
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
|
||||
* All rights reserved.
|
||||
*
|
||||
* This package is an SSL implementation written
|
||||
* by Eric Young (eay@cryptsoft.com).
|
||||
* The implementation was written so as to conform with Netscapes SSL.
|
||||
*
|
||||
* This library is free for commercial and non-commercial use as long as
|
||||
* the following conditions are aheared to. The following conditions
|
||||
* apply to all code found in this distribution, be it the RC4, RSA,
|
||||
* lhash, DES, etc., code; not just the SSL code. The SSL documentation
|
||||
* included with this distribution is covered by the same copyright terms
|
||||
* except that the holder is Tim Hudson (tjh@cryptsoft.com).
|
||||
*
|
||||
* Copyright remains Eric Young's, and as such any Copyright notices in
|
||||
* the code are not to be removed.
|
||||
* If this package is used in a product, Eric Young should be given attribution
|
||||
* as the author of the parts of the library used.
|
||||
* This can be in the form of a textual message at program startup or
|
||||
* in documentation (online or textual) provided with the package.
|
||||
*
|
||||
* 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 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 cryptographic software written by
|
||||
* Eric Young (eay@cryptsoft.com)"
|
||||
* The word 'cryptographic' can be left out if the rouines from the library
|
||||
* being used are not cryptographic related :-).
|
||||
* 4. If you include any Windows specific code (or a derivative thereof) from
|
||||
* the apps directory (application code) you must include an acknowledgement:
|
||||
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
|
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
|
||||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
||||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*
|
||||
* The licence and distribution terms for any publically available version or
|
||||
* derivative of this code cannot be changed. i.e. this code cannot simply be
|
||||
* copied and put under another distribution licence
|
||||
* [including the GNU Public Licence.]
|
||||
*/
|
||||
|
||||
License: BSD-3clause
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
|
|
@ -65,10 +65,6 @@ This is experimental software.
|
|||
|
||||
Distributed under the MIT software license, see the accompanying file COPYING
|
||||
or <https://www.opensource.org/licenses/mit-license.php>.
|
||||
|
||||
This product includes software developed by the OpenSSL Project for use in the
|
||||
OpenSSL Toolkit <https://www.openssl.org/> and cryptographic software written
|
||||
by Eric Young.
|
||||
```
|
||||
|
||||
### Persist data to the host
|
||||
|
|
|
@ -1,116 +0,0 @@
|
|||
package=openssl
|
||||
$(package)_version=1.1.1a
|
||||
$(package)_download_path=https://www.openssl.org/source/old/1.1.1
|
||||
$(package)_file_name=$(package)-$($(package)_version).tar.gz
|
||||
$(package)_sha256_hash=fc20130f8b7cbd2fb918b2f14e2f429e109c31ddd0fb38fc5d71d9ffed3f9f41
|
||||
|
||||
define $(package)_set_vars
|
||||
$(package)_config_env=AR="$($(package)_ar)" RANLIB="$($(package)_ranlib)" CC="$($(package)_cc)"
|
||||
$(package)_config_opts=--prefix=$(host_prefix) --openssldir=$(host_prefix)/etc/openssl
|
||||
$(package)_config_opts+=no-afalgeng
|
||||
$(package)_config_opts+=no-asm
|
||||
$(package)_config_opts+=no-async
|
||||
$(package)_config_opts+=no-bf
|
||||
$(package)_config_opts+=no-blake2
|
||||
$(package)_config_opts+=no-camellia
|
||||
$(package)_config_opts+=no-capieng
|
||||
$(package)_config_opts+=no-cast
|
||||
$(package)_config_opts+=no-chacha
|
||||
$(package)_config_opts+=no-cmac
|
||||
$(package)_config_opts+=no-cms
|
||||
$(package)_config_opts+=no-comp
|
||||
$(package)_config_opts+=no-crypto-mdebug
|
||||
$(package)_config_opts+=no-crypto-mdebug-backtrace
|
||||
$(package)_config_opts+=no-ct
|
||||
$(package)_config_opts+=no-des
|
||||
$(package)_config_opts+=no-dgram
|
||||
$(package)_config_opts+=no-dsa
|
||||
$(package)_config_opts+=no-dso
|
||||
$(package)_config_opts+=no-dtls
|
||||
$(package)_config_opts+=no-dtls1
|
||||
$(package)_config_opts+=no-dtls1-method
|
||||
$(package)_config_opts+=no-dynamic-engine
|
||||
$(package)_config_opts+=no-ec2m
|
||||
$(package)_config_opts+=no-ec_nistp_64_gcc_128
|
||||
$(package)_config_opts+=no-egd
|
||||
$(package)_config_opts+=no-engine
|
||||
$(package)_config_opts+=no-err
|
||||
$(package)_config_opts+=no-gost
|
||||
$(package)_config_opts+=no-heartbeats
|
||||
$(package)_config_opts+=no-idea
|
||||
$(package)_config_opts+=no-md2
|
||||
$(package)_config_opts+=no-md4
|
||||
$(package)_config_opts+=no-mdc2
|
||||
$(package)_config_opts+=no-multiblock
|
||||
$(package)_config_opts+=no-nextprotoneg
|
||||
$(package)_config_opts+=no-ocb
|
||||
$(package)_config_opts+=no-ocsp
|
||||
$(package)_config_opts+=no-poly1305
|
||||
$(package)_config_opts+=no-posix-io
|
||||
$(package)_config_opts+=no-psk
|
||||
$(package)_config_opts+=no-rc2
|
||||
$(package)_config_opts+=no-rc4
|
||||
$(package)_config_opts+=no-rc5
|
||||
$(package)_config_opts+=no-rdrand
|
||||
$(package)_config_opts+=no-rfc3779
|
||||
$(package)_config_opts+=no-rmd160
|
||||
$(package)_config_opts+=no-scrypt
|
||||
$(package)_config_opts+=no-sctp
|
||||
$(package)_config_opts+=no-seed
|
||||
$(package)_config_opts+=no-shared
|
||||
$(package)_config_opts+=no-sock
|
||||
$(package)_config_opts+=no-srp
|
||||
$(package)_config_opts+=no-srtp
|
||||
$(package)_config_opts+=no-ssl
|
||||
$(package)_config_opts+=no-ssl3
|
||||
$(package)_config_opts+=no-ssl3-method
|
||||
$(package)_config_opts+=no-ssl-trace
|
||||
$(package)_config_opts+=no-stdio
|
||||
$(package)_config_opts+=no-tls
|
||||
$(package)_config_opts+=no-tls1
|
||||
$(package)_config_opts+=no-tls1-method
|
||||
$(package)_config_opts+=no-ts
|
||||
$(package)_config_opts+=no-ui
|
||||
$(package)_config_opts+=no-unit-test
|
||||
$(package)_config_opts+=no-weak-ssl-ciphers
|
||||
$(package)_config_opts+=no-whirlpool
|
||||
$(package)_config_opts+=no-zlib
|
||||
$(package)_config_opts+=no-zlib-dynamic
|
||||
$(package)_config_opts+=$($(package)_cflags) $($(package)_cppflags)
|
||||
$(package)_config_opts+=-DPURIFY
|
||||
$(package)_config_opts_linux=-fPIC -Wa,--noexecstack
|
||||
$(package)_config_opts_freebsd=-fPIC -Wa,--noexecstack
|
||||
$(package)_config_opts_x86_64_linux=linux-x86_64
|
||||
$(package)_config_opts_i686_linux=linux-generic32
|
||||
$(package)_config_opts_arm_linux=linux-generic32
|
||||
$(package)_config_opts_aarch64_linux=linux-generic64
|
||||
$(package)_config_opts_mipsel_linux=linux-generic32
|
||||
$(package)_config_opts_mips_linux=linux-generic32
|
||||
$(package)_config_opts_powerpc_linux=linux-generic32
|
||||
$(package)_config_opts_x86_64_darwin=darwin64-x86_64-cc
|
||||
$(package)_config_opts_x86_64_freebsd=BSD-x86_64
|
||||
$(package)_config_opts_i686_freebsd=BSD-generic32
|
||||
$(package)_config_opts_x86_64_mingw32=mingw64
|
||||
$(package)_config_opts_i686_mingw32=mingw
|
||||
endef
|
||||
|
||||
define $(package)_preprocess_cmds
|
||||
sed -i.old 's/built on: $$$$date/built on: date not available/' util/mkbuildinf.pl && \
|
||||
sed -i.old "s|\"engines\", \"apps\", \"test\"|\"engines\"|" Configure
|
||||
endef
|
||||
|
||||
define $(package)_config_cmds
|
||||
./Configure $($(package)_config_opts)
|
||||
endef
|
||||
|
||||
define $(package)_build_cmds
|
||||
$(MAKE) -j1 build_libs libcrypto.pc libssl.pc openssl.pc
|
||||
endef
|
||||
|
||||
define $(package)_stage_cmds
|
||||
$(MAKE) DESTDIR=$($(package)_staging_dir) -j1 install_sw
|
||||
endef
|
||||
|
||||
define $(package)_postprocess_cmds
|
||||
rm -rf share bin etc
|
||||
endef
|
|
@ -1,5 +1,5 @@
|
|||
zcash_packages := libsodium utfcpp
|
||||
packages := boost openssl libevent zeromq $(zcash_packages) googletest
|
||||
packages := boost libevent zeromq $(zcash_packages) googletest
|
||||
native_packages := native_ccache native_rust
|
||||
|
||||
wallet_packages=bdb
|
||||
|
|
|
@ -84,7 +84,3 @@ This is experimental software.
|
|||
|
||||
Distributed under the MIT software license, see the accompanying file COPYING
|
||||
or <https://www.opensource.org/licenses/mit-license.php>.
|
||||
|
||||
This product includes software developed by the OpenSSL Project for use in the
|
||||
OpenSSL Toolkit <https://www.openssl.org/> and cryptographic software written
|
||||
by Eric Young.
|
||||
|
|
|
@ -98,7 +98,3 @@ This is experimental software.
|
|||
|
||||
Distributed under the MIT software license, see the accompanying file COPYING
|
||||
or <https://www.opensource.org/licenses/mit-license.php>.
|
||||
|
||||
This product includes software developed by the OpenSSL Project for use in the
|
||||
OpenSSL Toolkit <https://www.openssl.org/> and cryptographic software written
|
||||
by Eric Young.
|
||||
|
|
|
@ -518,7 +518,3 @@ This is experimental software.
|
|||
|
||||
Distributed under the MIT software license, see the accompanying file COPYING
|
||||
or <https://www.opensource.org/licenses/mit-license.php>.
|
||||
|
||||
This product includes software developed by the OpenSSL Project for use in the
|
||||
OpenSSL Toolkit <https://www.openssl.org/> and cryptographic software written
|
||||
by Eric Young.
|
||||
|
|
|
@ -8,4 +8,3 @@ Description: Library for the Zcash consensus protocol.
|
|||
Version: @PACKAGE_VERSION@
|
||||
Libs: -L${libdir} -lzcashconsensus
|
||||
Cflags: -I${includedir}
|
||||
Requires.private: libcrypto
|
||||
|
|
|
@ -36,13 +36,6 @@ native_ccache 3.7.7 2021-01-20
|
|||
native_ccache 3.7.8 2021-01-20
|
||||
native_ccache 3.7.9 2021-01-20
|
||||
native_ccache 3.7.10 2021-01-20
|
||||
openssl 1.1.1.b 2021-01-20
|
||||
openssl 1.1.1.c 2021-01-20
|
||||
openssl 1.1.1.d 2021-01-20
|
||||
openssl 1.1.1.e 2021-01-20
|
||||
openssl 1.1.1.f 2021-01-20
|
||||
openssl 1.1.1.g 2021-01-20
|
||||
proton 0.31.0 2021-01-20
|
||||
native_rust 1.45.0 2021-01-20
|
||||
native_rust 1.45.1 2021-01-20
|
||||
native_rust 1.45.2 2021-01-20
|
||||
|
|
|
@ -69,10 +69,6 @@ def get_dependency_list():
|
|||
GithubTagReleaseLister("ccache", "ccache", "^v?(\d+)\.(\d+)(?:\.(\d+))?$",
|
||||
{ "v3.5.1": (3, 5, 1), "v3.6": (3, 6)}),
|
||||
DependsVersionGetter("native_ccache")),
|
||||
Dependency("openssl",
|
||||
GithubTagReleaseLister("openssl", "openssl", "^OpenSSL_(\d+)_(\d+)_(\d+)([a-z]+)?$",
|
||||
{ "OpenSSL_1_1_1b": (1, 1, 1, 'b'), "OpenSSL_1_1_1-pre9": None }),
|
||||
DependsVersionGetter("openssl")),
|
||||
Dependency("native_rust",
|
||||
GithubTagReleaseLister("rust-lang", "rust", "^(\d+)\.(\d+)(?:\.(\d+))?$",
|
||||
{ "1.33.0": (1, 33, 0), "0.9": (0, 9) }),
|
||||
|
|
|
@ -12,7 +12,7 @@ AM_CPPFLAGS = $(DEBUG_CPPFLAGS) $(HARDENED_CPPFLAGS)
|
|||
EXTRA_LIBRARIES =
|
||||
|
||||
BITCOIN_CONFIG_INCLUDES=-I$(builddir)/config
|
||||
BITCOIN_INCLUDES=-I$(builddir) -I$(builddir)/obj $(BDB_CPPFLAGS) $(BOOST_CPPFLAGS) $(LEVELDB_CPPFLAGS) $(CRYPTO_CFLAGS) $(SSL_CFLAGS)
|
||||
BITCOIN_INCLUDES=-I$(builddir) -I$(builddir)/obj $(BDB_CPPFLAGS) $(BOOST_CPPFLAGS) $(LEVELDB_CPPFLAGS)
|
||||
|
||||
BITCOIN_CONFIG_INCLUDES += -I$(srcdir)/rust/include
|
||||
BITCOIN_INCLUDES += -I$(srcdir)/rust/include
|
||||
|
@ -468,8 +468,6 @@ zcashd_LDADD = \
|
|||
zcashd_LDADD += \
|
||||
$(BOOST_LIBS) \
|
||||
$(BDB_LIBS) \
|
||||
$(SSL_LIBS) \
|
||||
$(CRYPTO_LIBS) \
|
||||
$(EVENT_PTHREADS_LIBS) \
|
||||
$(EVENT_LIBS) \
|
||||
$(ZMQ_LIBS) \
|
||||
|
@ -491,8 +489,6 @@ zcash_cli_LDADD = \
|
|||
$(LIBUNIVALUE) \
|
||||
$(LIBBITCOIN_UTIL) \
|
||||
$(BOOST_LIBS) \
|
||||
$(SSL_LIBS) \
|
||||
$(CRYPTO_LIBS) \
|
||||
$(EVENT_LIBS) \
|
||||
$(LIBZCASH) \
|
||||
$(LIBRUSTZCASH) \
|
||||
|
@ -521,7 +517,7 @@ zcash_tx_LDADD = \
|
|||
$(LIBBITCOIN_CRYPTO) \
|
||||
$(LIBZCASH_LIBS)
|
||||
|
||||
zcash_tx_LDADD += $(BOOST_LIBS) $(CRYPTO_LIBS)
|
||||
zcash_tx_LDADD += $(BOOST_LIBS)
|
||||
#
|
||||
|
||||
# zcash protocol primitives #
|
||||
|
|
|
@ -46,7 +46,7 @@ if ENABLE_WALLET
|
|||
bench_bench_bitcoin_LDADD += $(LIBBITCOIN_WALLET)
|
||||
endif
|
||||
|
||||
bench_bench_bitcoin_LDADD += $(BOOST_LIBS) $(BDB_LIBS) $(SSL_LIBS) $(CRYPTO_LIBS) $(MINIUPNPC_LIBS) $(EVENT_PTHREADS_LIBS) $(EVENT_LIBS) $(LIBZCASH_LIBS)
|
||||
bench_bench_bitcoin_LDADD += $(BOOST_LIBS) $(BDB_LIBS) $(EVENT_PTHREADS_LIBS) $(EVENT_LIBS) $(LIBZCASH_LIBS)
|
||||
bench_bench_bitcoin_LDFLAGS = $(RELDFLAGS) $(AM_LDFLAGS) $(LIBTOOL_APP_LDFLAGS)
|
||||
|
||||
CLEAN_BITCOIN_BENCH = bench/*.gcda bench/*.gcno
|
||||
|
|
|
@ -84,8 +84,6 @@ zcash_gtest_LDADD += \
|
|||
$(BOOST_LIBS) \
|
||||
$(BOOST_UNIT_TEST_FRAMEWORK_LIB) \
|
||||
$(BDB_LIBS) \
|
||||
$(SSL_LIBS) \
|
||||
$(CRYPTO_LIBS) \
|
||||
$(EVENT_PTHREADS_LIBS) \
|
||||
$(EVENT_LIBS) \
|
||||
$(ZMQ_LIBS) \
|
||||
|
|
|
@ -50,7 +50,7 @@ GENERATED_TEST_FILES = $(JSON_TEST_FILES:.json=.json.h) $(RAW_TEST_FILES:.raw=.r
|
|||
|
||||
BITCOIN_TESTS =\
|
||||
test/arith_uint256_tests.cpp \
|
||||
test/bignum.h \
|
||||
test/scriptnum10.h \
|
||||
test/addrman_tests.cpp \
|
||||
test/alert_tests.cpp \
|
||||
test/allocator_tests.cpp \
|
||||
|
@ -130,7 +130,7 @@ test_test_bitcoin_LDADD += $(LIBBITCOIN_SERVER) $(LIBBITCOIN_CLI) $(LIBBITCOIN_C
|
|||
$(LIBLEVELDB) $(LIBLEVELDB_SSE42) $(LIBMEMENV) $(BOOST_LIBS) $(BOOST_UNIT_TEST_FRAMEWORK_LIB) $(LIBSECP256K1) $(EVENT_LIBS) $(EVENT_PTHREADS_LIBS)
|
||||
test_test_bitcoin_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
|
||||
|
||||
test_test_bitcoin_LDADD += $(LIBZCASH_CONSENSUS) $(BDB_LIBS) $(SSL_LIBS) $(CRYPTO_LIBS) $(LIBZCASH) $(LIBRUSTZCASH) $(LIBZCASH_LIBS)
|
||||
test_test_bitcoin_LDADD += $(LIBZCASH_CONSENSUS) $(BDB_LIBS) $(LIBZCASH) $(LIBRUSTZCASH) $(LIBZCASH_LIBS)
|
||||
test_test_bitcoin_LDFLAGS = $(RELDFLAGS) $(AM_LDFLAGS) $(LIBTOOL_APP_LDFLAGS) -static
|
||||
|
||||
if ENABLE_ZMQ
|
||||
|
|
|
@ -59,7 +59,6 @@
|
|||
#include <boost/bind.hpp>
|
||||
#include <boost/interprocess/sync/file_lock.hpp>
|
||||
#include <boost/thread.hpp>
|
||||
#include <openssl/crypto.h>
|
||||
|
||||
#if ENABLE_ZMQ
|
||||
#include "zmq/zmqnotificationinterface.h"
|
||||
|
@ -1165,7 +1164,6 @@ bool AppInit2(boost::thread_group& threadGroup, CScheduler& scheduler)
|
|||
// if (GetBoolArg("-shrinkdebugfile", !fDebug))
|
||||
// ShrinkDebugFile();
|
||||
|
||||
LogPrintf("Using OpenSSL version %s\n", SSLeay_version(SSLEAY_VERSION));
|
||||
#ifdef ENABLE_WALLET
|
||||
LogPrintf("Using BerkeleyDB version %s\n", DbEnv::version(0, 0, 0));
|
||||
#endif
|
||||
|
|
|
@ -95,14 +95,14 @@ public:
|
|||
//! Check whether the public key corresponding to this private key is (to be) compressed.
|
||||
bool IsCompressed() const { return fCompressed; }
|
||||
|
||||
//! Initialize from a CPrivKey (serialized OpenSSL private key data).
|
||||
//! Initialize from a CPrivKey (serialized OpenSSL-format private key data).
|
||||
bool SetPrivKey(const CPrivKey& vchPrivKey, bool fCompressed);
|
||||
|
||||
//! Generate a new private key using a cryptographic PRNG.
|
||||
void MakeNewKey(bool fCompressed);
|
||||
|
||||
/**
|
||||
* Convert the private key to a CPrivKey (serialized OpenSSL private key data).
|
||||
* Convert the private key to a CPrivKey (serialized OpenSSL-format private key data).
|
||||
* This is expensive.
|
||||
*/
|
||||
CPrivKey GetPrivKey() const;
|
||||
|
|
|
@ -228,12 +228,12 @@ public:
|
|||
m_value = set_vch(vch);
|
||||
}
|
||||
|
||||
inline bool operator==(const int64_t& rhs) const { return m_value == rhs; }
|
||||
inline bool operator!=(const int64_t& rhs) const { return m_value != rhs; }
|
||||
inline bool operator<=(const int64_t& rhs) const { return m_value <= rhs; }
|
||||
inline bool operator< (const int64_t& rhs) const { return m_value < rhs; }
|
||||
inline bool operator>=(const int64_t& rhs) const { return m_value >= rhs; }
|
||||
inline bool operator> (const int64_t& rhs) const { return m_value > rhs; }
|
||||
inline bool operator==(const int64_t& rhs) const { return m_value == rhs; }
|
||||
inline bool operator!=(const int64_t& rhs) const { return m_value != rhs; }
|
||||
inline bool operator<=(const int64_t& rhs) const { return m_value <= rhs; }
|
||||
inline bool operator< (const int64_t& rhs) const { return m_value < rhs; }
|
||||
inline bool operator>=(const int64_t& rhs) const { return m_value >= rhs; }
|
||||
inline bool operator> (const int64_t& rhs) const { return m_value > rhs; }
|
||||
|
||||
inline bool operator==(const CScriptNum& rhs) const { return operator==(rhs.m_value); }
|
||||
inline bool operator!=(const CScriptNum& rhs) const { return operator!=(rhs.m_value); }
|
||||
|
@ -242,8 +242,20 @@ public:
|
|||
inline bool operator>=(const CScriptNum& rhs) const { return operator>=(rhs.m_value); }
|
||||
inline bool operator> (const CScriptNum& rhs) const { return operator> (rhs.m_value); }
|
||||
|
||||
inline CScriptNum operator+( const int64_t& rhs) const { return CScriptNum(m_value + rhs);}
|
||||
inline CScriptNum operator-( const int64_t& rhs) const { return CScriptNum(m_value - rhs);}
|
||||
inline CScriptNum operator+( const int64_t& rhs) const
|
||||
{
|
||||
assert(rhs == 0 || (rhs > 0 && m_value <= std::numeric_limits<int64_t>::max() - rhs) ||
|
||||
(rhs < 0 && m_value >= std::numeric_limits<int64_t>::min() - rhs));
|
||||
return CScriptNum(m_value + rhs);
|
||||
}
|
||||
|
||||
inline CScriptNum operator-( const int64_t& rhs) const
|
||||
{
|
||||
assert(rhs == 0 || (rhs > 0 && m_value >= std::numeric_limits<int64_t>::min() + rhs) ||
|
||||
(rhs < 0 && m_value <= std::numeric_limits<int64_t>::max() + rhs));
|
||||
return CScriptNum(m_value - rhs);
|
||||
}
|
||||
|
||||
inline CScriptNum operator+( const CScriptNum& rhs) const { return operator+(rhs.m_value); }
|
||||
inline CScriptNum operator-( const CScriptNum& rhs) const { return operator-(rhs.m_value); }
|
||||
|
||||
|
@ -256,7 +268,7 @@ public:
|
|||
return CScriptNum(-m_value);
|
||||
}
|
||||
|
||||
inline CScriptNum& operator=( const int64_t& rhs)
|
||||
inline CScriptNum& operator=( const int64_t& rhs)
|
||||
{
|
||||
m_value = rhs;
|
||||
return *this;
|
||||
|
|
|
@ -1,193 +0,0 @@
|
|||
// Copyright (c) 2009-2010 Satoshi Nakamoto
|
||||
// Copyright (c) 2009-2013 The Bitcoin Core developers
|
||||
// Distributed under the MIT software license, see the accompanying
|
||||
// file COPYING or https://www.opensource.org/licenses/mit-license.php .
|
||||
|
||||
#ifndef BITCOIN_TEST_BIGNUM_H
|
||||
#define BITCOIN_TEST_BIGNUM_H
|
||||
|
||||
#include <algorithm>
|
||||
#include <cassert>
|
||||
#include <limits>
|
||||
#include <stdexcept>
|
||||
#include <stdint.h>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#include <openssl/bn.h>
|
||||
|
||||
class bignum_error : public std::runtime_error
|
||||
{
|
||||
public:
|
||||
explicit bignum_error(const std::string& str) : std::runtime_error(str) {}
|
||||
};
|
||||
|
||||
|
||||
/** C++ wrapper for BIGNUM (OpenSSL bignum) */
|
||||
class CBigNum
|
||||
{
|
||||
BIGNUM* bn;
|
||||
public:
|
||||
CBigNum()
|
||||
{
|
||||
bn = BN_new();
|
||||
assert(bn);
|
||||
}
|
||||
|
||||
CBigNum(const CBigNum& b)
|
||||
{
|
||||
bn = BN_new();
|
||||
assert(bn);
|
||||
if (!BN_copy(bn, b.bn))
|
||||
{
|
||||
BN_clear_free(bn);
|
||||
throw bignum_error("CBigNum::CBigNum(const CBigNum&): BN_copy failed");
|
||||
}
|
||||
}
|
||||
|
||||
CBigNum& operator=(const CBigNum& b)
|
||||
{
|
||||
if (!BN_copy(bn, b.bn))
|
||||
throw bignum_error("CBigNum::operator=: BN_copy failed");
|
||||
return (*this);
|
||||
}
|
||||
|
||||
~CBigNum()
|
||||
{
|
||||
BN_clear_free(bn);
|
||||
}
|
||||
|
||||
CBigNum(long long n) { bn = BN_new(); assert(bn); setint64(n); }
|
||||
|
||||
explicit CBigNum(const std::vector<unsigned char>& vch)
|
||||
{
|
||||
bn = BN_new();
|
||||
assert(bn);
|
||||
setvch(vch);
|
||||
}
|
||||
|
||||
int getint() const
|
||||
{
|
||||
BN_ULONG n = BN_get_word(bn);
|
||||
if (!BN_is_negative(bn))
|
||||
return (n > (BN_ULONG)std::numeric_limits<int>::max() ? std::numeric_limits<int>::max() : n);
|
||||
else
|
||||
return (n > (BN_ULONG)std::numeric_limits<int>::max() ? std::numeric_limits<int>::min() : -(int)n);
|
||||
}
|
||||
|
||||
void setint64(int64_t sn)
|
||||
{
|
||||
unsigned char pch[sizeof(sn) + 6];
|
||||
unsigned char* p = pch + 4;
|
||||
bool fNegative;
|
||||
uint64_t n;
|
||||
|
||||
if (sn < (int64_t)0)
|
||||
{
|
||||
// Since the minimum signed integer cannot be represented as positive so long as its type is signed,
|
||||
// and it's not well-defined what happens if you make it unsigned before negating it,
|
||||
// we instead increment the negative integer by 1, convert it, then increment the (now positive) unsigned integer by 1 to compensate
|
||||
n = -(sn + 1);
|
||||
++n;
|
||||
fNegative = true;
|
||||
} else {
|
||||
n = sn;
|
||||
fNegative = false;
|
||||
}
|
||||
|
||||
bool fLeadingZeroes = true;
|
||||
for (int i = 0; i < 8; i++)
|
||||
{
|
||||
unsigned char c = (n >> 56) & 0xff;
|
||||
n <<= 8;
|
||||
if (fLeadingZeroes)
|
||||
{
|
||||
if (c == 0)
|
||||
continue;
|
||||
if (c & 0x80)
|
||||
*p++ = (fNegative ? 0x80 : 0);
|
||||
else if (fNegative)
|
||||
c |= 0x80;
|
||||
fLeadingZeroes = false;
|
||||
}
|
||||
*p++ = c;
|
||||
}
|
||||
unsigned int nSize = p - (pch + 4);
|
||||
pch[0] = (nSize >> 24) & 0xff;
|
||||
pch[1] = (nSize >> 16) & 0xff;
|
||||
pch[2] = (nSize >> 8) & 0xff;
|
||||
pch[3] = (nSize) & 0xff;
|
||||
BN_mpi2bn(pch, p - pch, bn);
|
||||
}
|
||||
|
||||
void setvch(const std::vector<unsigned char>& vch)
|
||||
{
|
||||
std::vector<unsigned char> vch2(vch.size() + 4);
|
||||
unsigned int nSize = vch.size();
|
||||
// BIGNUM's byte stream format expects 4 bytes of
|
||||
// big endian size data info at the front
|
||||
vch2[0] = (nSize >> 24) & 0xff;
|
||||
vch2[1] = (nSize >> 16) & 0xff;
|
||||
vch2[2] = (nSize >> 8) & 0xff;
|
||||
vch2[3] = (nSize >> 0) & 0xff;
|
||||
// swap data to big endian
|
||||
reverse_copy(vch.begin(), vch.end(), vch2.begin() + 4);
|
||||
BN_mpi2bn(&vch2[0], vch2.size(), bn);
|
||||
}
|
||||
|
||||
std::vector<unsigned char> getvch() const
|
||||
{
|
||||
unsigned int nSize = BN_bn2mpi(bn, NULL);
|
||||
if (nSize <= 4)
|
||||
return std::vector<unsigned char>();
|
||||
std::vector<unsigned char> vch(nSize);
|
||||
BN_bn2mpi(bn, &vch[0]);
|
||||
vch.erase(vch.begin(), vch.begin() + 4);
|
||||
reverse(vch.begin(), vch.end());
|
||||
return vch;
|
||||
}
|
||||
|
||||
friend inline const CBigNum operator+(const CBigNum& a, const CBigNum& b);
|
||||
friend inline const CBigNum operator-(const CBigNum& a, const CBigNum& b);
|
||||
friend inline const CBigNum operator-(const CBigNum& a);
|
||||
friend inline bool operator==(const CBigNum& a, const CBigNum& b);
|
||||
friend inline bool operator!=(const CBigNum& a, const CBigNum& b);
|
||||
friend inline bool operator<=(const CBigNum& a, const CBigNum& b);
|
||||
friend inline bool operator>=(const CBigNum& a, const CBigNum& b);
|
||||
friend inline bool operator<(const CBigNum& a, const CBigNum& b);
|
||||
friend inline bool operator>(const CBigNum& a, const CBigNum& b);
|
||||
};
|
||||
|
||||
|
||||
|
||||
inline const CBigNum operator+(const CBigNum& a, const CBigNum& b)
|
||||
{
|
||||
CBigNum r;
|
||||
if (!BN_add(r.bn, a.bn, b.bn))
|
||||
throw bignum_error("CBigNum::operator+: BN_add failed");
|
||||
return r;
|
||||
}
|
||||
|
||||
inline const CBigNum operator-(const CBigNum& a, const CBigNum& b)
|
||||
{
|
||||
CBigNum r;
|
||||
if (!BN_sub(r.bn, a.bn, b.bn))
|
||||
throw bignum_error("CBigNum::operator-: BN_sub failed");
|
||||
return r;
|
||||
}
|
||||
|
||||
inline const CBigNum operator-(const CBigNum& a)
|
||||
{
|
||||
CBigNum r(a);
|
||||
BN_set_negative(r.bn, !BN_is_negative(r.bn));
|
||||
return r;
|
||||
}
|
||||
|
||||
inline bool operator==(const CBigNum& a, const CBigNum& b) { return (BN_cmp(a.bn, b.bn) == 0); }
|
||||
inline bool operator!=(const CBigNum& a, const CBigNum& b) { return (BN_cmp(a.bn, b.bn) != 0); }
|
||||
inline bool operator<=(const CBigNum& a, const CBigNum& b) { return (BN_cmp(a.bn, b.bn) <= 0); }
|
||||
inline bool operator>=(const CBigNum& a, const CBigNum& b) { return (BN_cmp(a.bn, b.bn) >= 0); }
|
||||
inline bool operator<(const CBigNum& a, const CBigNum& b) { return (BN_cmp(a.bn, b.bn) < 0); }
|
||||
inline bool operator>(const CBigNum& a, const CBigNum& b) { return (BN_cmp(a.bn, b.bn) > 0); }
|
||||
|
||||
#endif // BITCOIN_TEST_BIGNUM_H
|
|
@ -17,8 +17,6 @@
|
|||
|
||||
#include <boost/assign/list_of.hpp>
|
||||
#include <boost/test/unit_test.hpp>
|
||||
#include <openssl/aes.h>
|
||||
#include <openssl/evp.h>
|
||||
|
||||
BOOST_FIXTURE_TEST_SUITE(crypto_tests, BasicTestingSetup)
|
||||
|
||||
|
|
|
@ -14,7 +14,7 @@ BOOST_AUTO_TEST_CASE(basic_sanity)
|
|||
{
|
||||
BOOST_CHECK_MESSAGE(glibc_sanity_test() == true, "libc sanity test");
|
||||
BOOST_CHECK_MESSAGE(glibcxx_sanity_test() == true, "stdlib sanity test");
|
||||
BOOST_CHECK_MESSAGE(ECC_InitSanityCheck() == true, "openssl ECC test");
|
||||
BOOST_CHECK_MESSAGE(ECC_InitSanityCheck() == true, "ECC sanity test");
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_SUITE_END()
|
||||
|
|
|
@ -0,0 +1,209 @@
|
|||
// Copyright (c) 2009-2010 Satoshi Nakamoto
|
||||
// Copyright (c) 2009-2013 The Bitcoin Core developers
|
||||
// Distributed under the MIT software license, see the accompanying
|
||||
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
|
||||
#ifndef BITCOIN_TEST_SCRIPTNUM10_H
|
||||
#define BITCOIN_TEST_SCRIPTNUM10_H
|
||||
|
||||
#include <algorithm>
|
||||
#include <limits>
|
||||
#include <stdexcept>
|
||||
#include <stdint.h>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include "assert.h"
|
||||
|
||||
class scriptnum10_error : public std::runtime_error
|
||||
{
|
||||
public:
|
||||
explicit scriptnum10_error(const std::string& str) : std::runtime_error(str) {}
|
||||
};
|
||||
|
||||
class CScriptNum10
|
||||
{
|
||||
/**
|
||||
* The ScriptNum implementation from Bitcoin Core 0.10.0, for cross-comparison.
|
||||
*/
|
||||
public:
|
||||
|
||||
explicit CScriptNum10(const int64_t& n)
|
||||
{
|
||||
m_value = n;
|
||||
}
|
||||
|
||||
static const size_t nDefaultMaxNumSize = 4;
|
||||
|
||||
explicit CScriptNum10(const std::vector<unsigned char>& vch, bool fRequireMinimal,
|
||||
const size_t nMaxNumSize = nDefaultMaxNumSize)
|
||||
{
|
||||
if (vch.size() > nMaxNumSize) {
|
||||
throw scriptnum10_error("script number overflow");
|
||||
}
|
||||
if (fRequireMinimal && vch.size() > 0) {
|
||||
// Check that the number is encoded with the minimum possible
|
||||
// number of bytes.
|
||||
//
|
||||
// If the most-significant-byte - excluding the sign bit - is zero
|
||||
// then we're not minimal. Note how this test also rejects the
|
||||
// negative-zero encoding, 0x80.
|
||||
if ((vch.back() & 0x7f) == 0) {
|
||||
// One exception: if there's more than one byte and the most
|
||||
// significant bit of the second-most-significant-byte is set
|
||||
// it would conflict with the sign bit. An example of this case
|
||||
// is +-255, which encode to 0xff00 and 0xff80 respectively.
|
||||
// (big-endian).
|
||||
if (vch.size() <= 1 || (vch[vch.size() - 2] & 0x80) == 0) {
|
||||
throw scriptnum10_error("non-minimally encoded script number");
|
||||
}
|
||||
}
|
||||
}
|
||||
m_value = set_vch(vch);
|
||||
}
|
||||
|
||||
inline bool operator==(const int64_t& rhs) const { return m_value == rhs; }
|
||||
inline bool operator!=(const int64_t& rhs) const { return m_value != rhs; }
|
||||
inline bool operator<=(const int64_t& rhs) const { return m_value <= rhs; }
|
||||
inline bool operator< (const int64_t& rhs) const { return m_value < rhs; }
|
||||
inline bool operator>=(const int64_t& rhs) const { return m_value >= rhs; }
|
||||
inline bool operator> (const int64_t& rhs) const { return m_value > rhs; }
|
||||
|
||||
inline bool operator==(const CScriptNum10& rhs) const { return operator==(rhs.m_value); }
|
||||
inline bool operator!=(const CScriptNum10& rhs) const { return operator!=(rhs.m_value); }
|
||||
inline bool operator<=(const CScriptNum10& rhs) const { return operator<=(rhs.m_value); }
|
||||
inline bool operator< (const CScriptNum10& rhs) const { return operator< (rhs.m_value); }
|
||||
inline bool operator>=(const CScriptNum10& rhs) const { return operator>=(rhs.m_value); }
|
||||
inline bool operator> (const CScriptNum10& rhs) const { return operator> (rhs.m_value); }
|
||||
|
||||
inline CScriptNum10 operator+( const int64_t& rhs) const
|
||||
{
|
||||
assert(rhs == 0 || (rhs > 0 && m_value <= std::numeric_limits<int64_t>::max() - rhs) ||
|
||||
(rhs < 0 && m_value >= std::numeric_limits<int64_t>::min() - rhs));
|
||||
return CScriptNum10(m_value + rhs);
|
||||
}
|
||||
|
||||
inline CScriptNum10 operator-( const int64_t& rhs) const
|
||||
{
|
||||
assert(rhs == 0 || (rhs > 0 && m_value >= std::numeric_limits<int64_t>::min() + rhs) ||
|
||||
(rhs < 0 && m_value <= std::numeric_limits<int64_t>::max() + rhs));
|
||||
return CScriptNum10(m_value - rhs);
|
||||
}
|
||||
|
||||
inline CScriptNum10 operator+( const CScriptNum10& rhs) const { return operator+(rhs.m_value); }
|
||||
inline CScriptNum10 operator-( const CScriptNum10& rhs) const { return operator-(rhs.m_value); }
|
||||
|
||||
inline CScriptNum10& operator+=( const CScriptNum10& rhs) { return operator+=(rhs.m_value); }
|
||||
inline CScriptNum10& operator-=( const CScriptNum10& rhs) { return operator-=(rhs.m_value); }
|
||||
|
||||
inline CScriptNum10 operator-() const
|
||||
{
|
||||
assert(m_value != std::numeric_limits<int64_t>::min());
|
||||
return CScriptNum10(-m_value);
|
||||
}
|
||||
|
||||
inline CScriptNum10& operator=( const int64_t& rhs)
|
||||
{
|
||||
m_value = rhs;
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline CScriptNum10& operator+=( const int64_t& rhs)
|
||||
{
|
||||
assert(rhs == 0 || (rhs > 0 && m_value <= std::numeric_limits<int64_t>::max() - rhs) ||
|
||||
(rhs < 0 && m_value >= std::numeric_limits<int64_t>::min() - rhs));
|
||||
m_value += rhs;
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline CScriptNum10& operator-=( const int64_t& rhs)
|
||||
{
|
||||
assert(rhs == 0 || (rhs > 0 && m_value >= std::numeric_limits<int64_t>::min() + rhs) ||
|
||||
(rhs < 0 && m_value <= std::numeric_limits<int64_t>::max() + rhs));
|
||||
m_value -= rhs;
|
||||
return *this;
|
||||
}
|
||||
|
||||
int getint() const
|
||||
{
|
||||
if (m_value > std::numeric_limits<int>::max())
|
||||
return std::numeric_limits<int>::max();
|
||||
else if (m_value < std::numeric_limits<int>::min())
|
||||
return std::numeric_limits<int>::min();
|
||||
return m_value;
|
||||
}
|
||||
|
||||
std::vector<unsigned char> getvch() const
|
||||
{
|
||||
return serialize(m_value);
|
||||
}
|
||||
|
||||
static std::vector<unsigned char> serialize(const int64_t& value)
|
||||
{
|
||||
if(value == 0)
|
||||
return std::vector<unsigned char>();
|
||||
|
||||
// This could result in undefined behaviour in Bitcoin 0.10.0 and
|
||||
// Zcash prior to https://github.com/zcash/zcash/pull/4454 .
|
||||
// Since we only use this implementation for tests, we just assert
|
||||
// that the tests are not triggering this case (which is tested
|
||||
// separately for the real implementation).
|
||||
assert(value != INT64_MIN);
|
||||
|
||||
std::vector<unsigned char> result;
|
||||
const bool neg = value < 0;
|
||||
uint64_t absvalue = neg ? -value : value;
|
||||
|
||||
while(absvalue)
|
||||
{
|
||||
result.push_back(absvalue & 0xff);
|
||||
absvalue >>= 8;
|
||||
}
|
||||
|
||||
// - If the most significant byte is >= 0x80 and the value is positive, push a
|
||||
// new zero-byte to make the significant byte < 0x80 again.
|
||||
|
||||
// - If the most significant byte is >= 0x80 and the value is negative, push a
|
||||
// new 0x80 byte that will be popped off when converting to an integral.
|
||||
|
||||
// - If the most significant byte is < 0x80 and the value is negative, add
|
||||
// 0x80 to it, since it will be subtracted and interpreted as a negative when
|
||||
// converting to an integral.
|
||||
|
||||
if (result.back() & 0x80)
|
||||
result.push_back(neg ? 0x80 : 0);
|
||||
else if (neg)
|
||||
result.back() |= 0x80;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
private:
|
||||
static int64_t set_vch(const std::vector<unsigned char>& vch)
|
||||
{
|
||||
if (vch.empty())
|
||||
return 0;
|
||||
|
||||
// This could result in undefined behaviour in Bitcoin 0.10.0 and
|
||||
// Zcash prior to https://github.com/zcash/zcash/pull/4454 .
|
||||
// Since we only use this implementation for tests, we just assert
|
||||
// that the tests are not triggering this case (which is tested
|
||||
// separately for the real implementation).
|
||||
assert(vch.size() <= 8);
|
||||
|
||||
int64_t result = 0;
|
||||
for (size_t i = 0; i != vch.size(); ++i)
|
||||
result |= static_cast<int64_t>(vch[i]) << 8*i;
|
||||
|
||||
// If the input vector's most significant byte is 0x80, remove it from
|
||||
// the result's msb and return a negative.
|
||||
if (vch.back() & 0x80)
|
||||
return -((int64_t)(result & ~(0x80ULL << (8 * (vch.size() - 1)))));
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
int64_t m_value;
|
||||
};
|
||||
|
||||
|
||||
#endif // BITCOIN_TEST_BIGNUM_H
|
|
@ -2,7 +2,7 @@
|
|||
// Distributed under the MIT software license, see the accompanying
|
||||
// file COPYING or https://www.opensource.org/licenses/mit-license.php .
|
||||
|
||||
#include "bignum.h"
|
||||
#include "scriptnum10.h"
|
||||
#include "script/script.h"
|
||||
#include "test/test_bitcoin.h"
|
||||
|
||||
|
@ -13,55 +13,70 @@
|
|||
BOOST_FIXTURE_TEST_SUITE(scriptnum_tests, BasicTestingSetup)
|
||||
|
||||
static const int64_t values[] = \
|
||||
{ 0, 1, CHAR_MIN, CHAR_MAX, UCHAR_MAX, SHRT_MIN, USHRT_MAX, INT_MIN, INT_MAX, UINT_MAX, LONG_MIN, LONG_MAX };
|
||||
{ 0, 1, CHAR_MIN, CHAR_MAX, UCHAR_MAX, SHRT_MIN, USHRT_MAX, INT_MIN, INT_MAX, UINT_MAX, INT64_MIN, INT64_MAX };
|
||||
static const int64_t offsets[] = { 1, 0x79, 0x80, 0x81, 0xFF, 0x7FFF, 0x8000, 0xFFFF, 0x10000};
|
||||
|
||||
static bool verify(const CBigNum& bignum, const CScriptNum& scriptnum)
|
||||
|
||||
static bool addition_in_range(int64_t a, int64_t b) {
|
||||
// intentionally excludes cases where the result would be INT64_MIN
|
||||
return b > 0 ? (a <= INT64_MAX - b) : (a > INT64_MIN - b);
|
||||
}
|
||||
|
||||
static bool subtraction_in_range(int64_t a, int64_t b) {
|
||||
// intentionally excludes cases where the result would be INT64_MIN
|
||||
return b >= 0 ? (a > INT64_MIN + b) : (a <= INT64_MAX + b);
|
||||
}
|
||||
|
||||
static bool value_in_range(int64_t a) {
|
||||
return a != INT64_MIN;
|
||||
}
|
||||
|
||||
static bool verify(const CScriptNum10& bignum, const CScriptNum& scriptnum)
|
||||
{
|
||||
return bignum.getvch() == scriptnum.getvch() && bignum.getint() == scriptnum.getint();
|
||||
}
|
||||
|
||||
static void CheckCreateVch(const int64_t& num)
|
||||
static void CheckCreateVch(int64_t num)
|
||||
{
|
||||
CBigNum bignum(num);
|
||||
CScriptNum10 bignum(num);
|
||||
CScriptNum scriptnum(num);
|
||||
BOOST_CHECK(verify(bignum, scriptnum));
|
||||
|
||||
CBigNum bignum2(bignum.getvch());
|
||||
CScriptNum scriptnum2(scriptnum.getvch(), false);
|
||||
CScriptNum10 bignum2(bignum.getvch(), false);
|
||||
std::vector<unsigned char> scriptnum_vch = scriptnum.getvch();
|
||||
// The 9-byte case is exercised by the 'intmin' test.
|
||||
BOOST_CHECK(scriptnum_vch.size() <= 8);
|
||||
CScriptNum scriptnum2(scriptnum_vch, false);
|
||||
BOOST_CHECK(verify(bignum2, scriptnum2));
|
||||
|
||||
CBigNum bignum3(scriptnum2.getvch());
|
||||
CScriptNum10 bignum3(scriptnum2.getvch(), false);
|
||||
CScriptNum scriptnum3(bignum2.getvch(), false);
|
||||
BOOST_CHECK(verify(bignum3, scriptnum3));
|
||||
}
|
||||
|
||||
static void CheckCreateInt(const int64_t& num)
|
||||
static void CheckCreateInt(int64_t num)
|
||||
{
|
||||
CBigNum bignum(num);
|
||||
CScriptNum10 bignum(num);
|
||||
CScriptNum scriptnum(num);
|
||||
BOOST_CHECK(verify(bignum, scriptnum));
|
||||
BOOST_CHECK(verify(bignum.getint(), CScriptNum(scriptnum.getint())));
|
||||
BOOST_CHECK(verify(scriptnum.getint(), CScriptNum(bignum.getint())));
|
||||
BOOST_CHECK(verify(CBigNum(scriptnum.getint()).getint(), CScriptNum(CScriptNum(bignum.getint()).getint())));
|
||||
BOOST_CHECK(verify(CScriptNum10(bignum.getint()), CScriptNum(scriptnum.getint())));
|
||||
BOOST_CHECK(verify(CScriptNum10(scriptnum.getint()), CScriptNum(bignum.getint())));
|
||||
BOOST_CHECK(verify(CScriptNum10(CScriptNum10(scriptnum.getint()).getint()), CScriptNum(CScriptNum(bignum.getint()).getint())));
|
||||
}
|
||||
|
||||
|
||||
static void CheckAdd(const int64_t& num1, const int64_t& num2)
|
||||
static void CheckAdd(int64_t num1, int64_t num2)
|
||||
{
|
||||
const CBigNum bignum1(num1);
|
||||
const CBigNum bignum2(num2);
|
||||
const CScriptNum10 bignum1(num1);
|
||||
const CScriptNum10 bignum2(num2);
|
||||
const CScriptNum scriptnum1(num1);
|
||||
const CScriptNum scriptnum2(num2);
|
||||
CBigNum bignum3(num1);
|
||||
CBigNum bignum4(num1);
|
||||
CScriptNum10 bignum3(num1);
|
||||
CScriptNum10 bignum4(num1);
|
||||
CScriptNum scriptnum3(num1);
|
||||
CScriptNum scriptnum4(num1);
|
||||
|
||||
// int64_t overflow is undefined.
|
||||
bool invalid = (((num2 > 0) && (num1 > (std::numeric_limits<int64_t>::max() - num2))) ||
|
||||
((num2 < 0) && (num1 < (std::numeric_limits<int64_t>::min() - num2))));
|
||||
if (!invalid)
|
||||
if (addition_in_range(num1, num2))
|
||||
{
|
||||
BOOST_CHECK(verify(bignum1 + bignum2, scriptnum1 + scriptnum2));
|
||||
BOOST_CHECK(verify(bignum1 + bignum2, scriptnum1 + num2));
|
||||
|
@ -69,91 +84,84 @@ static void CheckAdd(const int64_t& num1, const int64_t& num2)
|
|||
}
|
||||
}
|
||||
|
||||
static void CheckNegate(const int64_t& num)
|
||||
static void CheckNegate(int64_t num)
|
||||
{
|
||||
const CBigNum bignum(num);
|
||||
const CScriptNum10 bignum(num);
|
||||
const CScriptNum scriptnum(num);
|
||||
|
||||
// -INT64_MIN is undefined
|
||||
if (num != std::numeric_limits<int64_t>::min())
|
||||
BOOST_CHECK(verify(-bignum, -scriptnum));
|
||||
BOOST_CHECK(verify(-bignum, -scriptnum));
|
||||
}
|
||||
|
||||
static void CheckSubtract(const int64_t& num1, const int64_t& num2)
|
||||
static void CheckSubtract(int64_t num1, int64_t num2)
|
||||
{
|
||||
const CBigNum bignum1(num1);
|
||||
const CBigNum bignum2(num2);
|
||||
const CScriptNum10 bignum1(num1);
|
||||
const CScriptNum10 bignum2(num2);
|
||||
const CScriptNum scriptnum1(num1);
|
||||
const CScriptNum scriptnum2(num2);
|
||||
bool invalid = false;
|
||||
|
||||
// int64_t overflow is undefined.
|
||||
invalid = ((num2 > 0 && num1 < std::numeric_limits<int64_t>::min() + num2) ||
|
||||
(num2 < 0 && num1 > std::numeric_limits<int64_t>::max() + num2));
|
||||
if (!invalid)
|
||||
if (subtraction_in_range(num1, num2))
|
||||
{
|
||||
BOOST_CHECK(verify(bignum1 - bignum2, scriptnum1 - scriptnum2));
|
||||
BOOST_CHECK(verify(bignum1 - bignum2, scriptnum1 - num2));
|
||||
}
|
||||
|
||||
invalid = ((num1 > 0 && num2 < std::numeric_limits<int64_t>::min() + num1) ||
|
||||
(num1 < 0 && num2 > std::numeric_limits<int64_t>::max() + num1));
|
||||
if (!invalid)
|
||||
if (subtraction_in_range(num2, num1))
|
||||
{
|
||||
BOOST_CHECK(verify(bignum2 - bignum1, scriptnum2 - scriptnum1));
|
||||
BOOST_CHECK(verify(bignum2 - bignum1, scriptnum2 - num1));
|
||||
}
|
||||
}
|
||||
|
||||
static void CheckCompare(const int64_t& num1, const int64_t& num2)
|
||||
static void CheckCompare(int64_t num1, int64_t num2)
|
||||
{
|
||||
const CBigNum bignum1(num1);
|
||||
const CBigNum bignum2(num2);
|
||||
const CScriptNum10 bignum1(num1);
|
||||
const CScriptNum10 bignum2(num2);
|
||||
const CScriptNum scriptnum1(num1);
|
||||
const CScriptNum scriptnum2(num2);
|
||||
|
||||
BOOST_CHECK((bignum1 == bignum1) == (scriptnum1 == scriptnum1));
|
||||
BOOST_CHECK((bignum1 != bignum1) == (scriptnum1 != scriptnum1));
|
||||
BOOST_CHECK((bignum1 < bignum1) == (scriptnum1 < scriptnum1));
|
||||
BOOST_CHECK((bignum1 > bignum1) == (scriptnum1 > scriptnum1));
|
||||
BOOST_CHECK((bignum1 >= bignum1) == (scriptnum1 >= scriptnum1));
|
||||
BOOST_CHECK((bignum1 <= bignum1) == (scriptnum1 <= scriptnum1));
|
||||
BOOST_CHECK((bignum1 != bignum1) == (scriptnum1 != scriptnum1));
|
||||
BOOST_CHECK((bignum1 < bignum1) == (scriptnum1 < scriptnum1));
|
||||
BOOST_CHECK((bignum1 > bignum1) == (scriptnum1 > scriptnum1));
|
||||
BOOST_CHECK((bignum1 >= bignum1) == (scriptnum1 >= scriptnum1));
|
||||
BOOST_CHECK((bignum1 <= bignum1) == (scriptnum1 <= scriptnum1));
|
||||
|
||||
BOOST_CHECK((bignum1 == bignum1) == (scriptnum1 == num1));
|
||||
BOOST_CHECK((bignum1 != bignum1) == (scriptnum1 != num1));
|
||||
BOOST_CHECK((bignum1 < bignum1) == (scriptnum1 < num1));
|
||||
BOOST_CHECK((bignum1 > bignum1) == (scriptnum1 > num1));
|
||||
BOOST_CHECK((bignum1 >= bignum1) == (scriptnum1 >= num1));
|
||||
BOOST_CHECK((bignum1 <= bignum1) == (scriptnum1 <= num1));
|
||||
BOOST_CHECK((bignum1 != bignum1) == (scriptnum1 != num1));
|
||||
BOOST_CHECK((bignum1 < bignum1) == (scriptnum1 < num1));
|
||||
BOOST_CHECK((bignum1 > bignum1) == (scriptnum1 > num1));
|
||||
BOOST_CHECK((bignum1 >= bignum1) == (scriptnum1 >= num1));
|
||||
BOOST_CHECK((bignum1 <= bignum1) == (scriptnum1 <= num1));
|
||||
|
||||
BOOST_CHECK((bignum1 == bignum2) == (scriptnum1 == scriptnum2));
|
||||
BOOST_CHECK((bignum1 != bignum2) == (scriptnum1 != scriptnum2));
|
||||
BOOST_CHECK((bignum1 < bignum2) == (scriptnum1 < scriptnum2));
|
||||
BOOST_CHECK((bignum1 > bignum2) == (scriptnum1 > scriptnum2));
|
||||
BOOST_CHECK((bignum1 >= bignum2) == (scriptnum1 >= scriptnum2));
|
||||
BOOST_CHECK((bignum1 <= bignum2) == (scriptnum1 <= scriptnum2));
|
||||
BOOST_CHECK((bignum1 == bignum2) == (scriptnum1 == scriptnum2));
|
||||
BOOST_CHECK((bignum1 != bignum2) == (scriptnum1 != scriptnum2));
|
||||
BOOST_CHECK((bignum1 < bignum2) == (scriptnum1 < scriptnum2));
|
||||
BOOST_CHECK((bignum1 > bignum2) == (scriptnum1 > scriptnum2));
|
||||
BOOST_CHECK((bignum1 >= bignum2) == (scriptnum1 >= scriptnum2));
|
||||
BOOST_CHECK((bignum1 <= bignum2) == (scriptnum1 <= scriptnum2));
|
||||
|
||||
BOOST_CHECK((bignum1 == bignum2) == (scriptnum1 == num2));
|
||||
BOOST_CHECK((bignum1 != bignum2) == (scriptnum1 != num2));
|
||||
BOOST_CHECK((bignum1 < bignum2) == (scriptnum1 < num2));
|
||||
BOOST_CHECK((bignum1 > bignum2) == (scriptnum1 > num2));
|
||||
BOOST_CHECK((bignum1 >= bignum2) == (scriptnum1 >= num2));
|
||||
BOOST_CHECK((bignum1 <= bignum2) == (scriptnum1 <= num2));
|
||||
BOOST_CHECK((bignum1 == bignum2) == (scriptnum1 == num2));
|
||||
BOOST_CHECK((bignum1 != bignum2) == (scriptnum1 != num2));
|
||||
BOOST_CHECK((bignum1 < bignum2) == (scriptnum1 < num2));
|
||||
BOOST_CHECK((bignum1 > bignum2) == (scriptnum1 > num2));
|
||||
BOOST_CHECK((bignum1 >= bignum2) == (scriptnum1 >= num2));
|
||||
BOOST_CHECK((bignum1 <= bignum2) == (scriptnum1 <= num2));
|
||||
}
|
||||
|
||||
static void RunCreate(const int64_t& num)
|
||||
static void RunCreate(int64_t num)
|
||||
{
|
||||
CheckCreateInt(num);
|
||||
CScriptNum scriptnum(num);
|
||||
if (scriptnum.getvch().size() <= CScriptNum::nDefaultMaxNumSize)
|
||||
CheckCreateVch(num);
|
||||
else
|
||||
{
|
||||
BOOST_CHECK_THROW (CheckCreateVch(num), scriptnum_error);
|
||||
CheckCreateVch(num);
|
||||
} else {
|
||||
BOOST_CHECK_THROW(CheckCreateVch(num), scriptnum10_error);
|
||||
}
|
||||
}
|
||||
|
||||
static void RunOperators(const int64_t& num1, const int64_t& num2)
|
||||
static void RunOperators(int64_t num1, int64_t num2)
|
||||
{
|
||||
CheckAdd(num1, num2);
|
||||
CheckSubtract(num1, num2);
|
||||
|
@ -163,35 +171,56 @@ static void RunOperators(const int64_t& num1, const int64_t& num2)
|
|||
|
||||
BOOST_AUTO_TEST_CASE(creation)
|
||||
{
|
||||
for(size_t i = 0; i < sizeof(values) / sizeof(values[0]); ++i)
|
||||
for (size_t i = 0; i < sizeof(values) / sizeof(values[0]); ++i)
|
||||
{
|
||||
for(size_t j = 0; j < sizeof(offsets) / sizeof(offsets[0]); ++j)
|
||||
for (size_t j = 0; j < sizeof(offsets) / sizeof(offsets[0]); ++j)
|
||||
{
|
||||
RunCreate(values[i]);
|
||||
RunCreate(values[i] + offsets[j]);
|
||||
RunCreate(values[i] - offsets[j]);
|
||||
if (value_in_range(values[i])) {
|
||||
RunCreate(values[i]);
|
||||
}
|
||||
if (addition_in_range(values[i], offsets[j])) {
|
||||
RunCreate(values[i] + offsets[j]);
|
||||
}
|
||||
if (subtraction_in_range(values[i], offsets[j])) {
|
||||
RunCreate(values[i] - offsets[j]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(operators)
|
||||
{
|
||||
for(size_t i = 0; i < sizeof(values) / sizeof(values[0]); ++i)
|
||||
for (size_t i = 0; i < sizeof(values) / sizeof(values[0]); ++i)
|
||||
{
|
||||
for(size_t j = 0; j < sizeof(offsets) / sizeof(offsets[0]); ++j)
|
||||
for (size_t j = 0; j < sizeof(values) / sizeof(values[0]); ++j)
|
||||
{
|
||||
RunOperators(values[i], values[i]);
|
||||
RunOperators(values[i], -values[i]);
|
||||
RunOperators(values[i], values[j]);
|
||||
RunOperators(values[i], -values[j]);
|
||||
RunOperators(values[i] + values[j], values[j]);
|
||||
RunOperators(values[i] + values[j], -values[j]);
|
||||
RunOperators(values[i] - values[j], values[j]);
|
||||
RunOperators(values[i] - values[j], -values[j]);
|
||||
RunOperators(values[i] + values[j], values[i] + values[j]);
|
||||
RunOperators(values[i] + values[j], values[i] - values[j]);
|
||||
RunOperators(values[i] - values[j], values[i] + values[j]);
|
||||
RunOperators(values[i] - values[j], values[i] - values[j]);
|
||||
if (value_in_range(values[i]))
|
||||
{
|
||||
RunOperators(values[i], values[i]);
|
||||
RunOperators(values[i], -values[i]);
|
||||
}
|
||||
if (value_in_range(values[i]) && value_in_range(values[j]))
|
||||
{
|
||||
RunOperators(values[i], values[j]);
|
||||
RunOperators(values[i], -values[j]);
|
||||
}
|
||||
if (addition_in_range(values[i], values[j]) && value_in_range(values[j]))
|
||||
{
|
||||
RunOperators(values[i] + values[j], values[j]);
|
||||
RunOperators(values[i] + values[j], -values[j]);
|
||||
RunOperators(values[i] + values[j], values[i] + values[j]);
|
||||
}
|
||||
if (subtraction_in_range(values[i], values[j]) && value_in_range(values[j]))
|
||||
{
|
||||
RunOperators(values[i] - values[j], values[j]);
|
||||
RunOperators(values[i] - values[j], -values[j]);
|
||||
RunOperators(values[i] - values[j], values[i] - values[j]);
|
||||
}
|
||||
if (addition_in_range(values[i], values[j]) && subtraction_in_range(values[i], values[j]))
|
||||
{
|
||||
RunOperators(values[i] + values[j], values[i] - values[j]);
|
||||
RunOperators(values[i] - values[j], values[i] + values[j]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
47
src/util.cpp
47
src/util.cpp
|
@ -83,8 +83,6 @@
|
|||
#include <boost/program_options/detail/config_file.hpp>
|
||||
#include <boost/program_options/parsers.hpp>
|
||||
#include <boost/thread.hpp>
|
||||
#include <openssl/crypto.h>
|
||||
#include <openssl/conf.h>
|
||||
|
||||
// Work around clang compilation problem in Boost 1.46:
|
||||
// /usr/include/boost/program_options/detail/config_file.hpp:163:17: error: call to function 'to_internal' that is neither visible in the template definition nor found by argument-dependent lookup
|
||||
|
@ -118,47 +116,6 @@ bool fLogIPs = DEFAULT_LOGIPS;
|
|||
std::atomic<bool> fReopenDebugLog(false);
|
||||
CTranslationInterface translationInterface;
|
||||
|
||||
/** Init OpenSSL library multithreading support */
|
||||
static CCriticalSection** ppmutexOpenSSL;
|
||||
void locking_callback(int mode, int i, const char* file, int line) NO_THREAD_SAFETY_ANALYSIS
|
||||
{
|
||||
if (mode & CRYPTO_LOCK) {
|
||||
ENTER_CRITICAL_SECTION(*ppmutexOpenSSL[i]);
|
||||
} else {
|
||||
LEAVE_CRITICAL_SECTION(*ppmutexOpenSSL[i]);
|
||||
}
|
||||
}
|
||||
|
||||
// Init
|
||||
static class CInit
|
||||
{
|
||||
public:
|
||||
CInit()
|
||||
{
|
||||
// Init OpenSSL library multithreading support
|
||||
ppmutexOpenSSL = (CCriticalSection**)OPENSSL_malloc(CRYPTO_num_locks() * sizeof(CCriticalSection*));
|
||||
for (int i = 0; i < CRYPTO_num_locks(); i++)
|
||||
ppmutexOpenSSL[i] = new CCriticalSection();
|
||||
CRYPTO_set_locking_callback(locking_callback);
|
||||
|
||||
// OpenSSL can optionally load a config file which lists optional loadable modules and engines.
|
||||
// We don't use them so we don't require the config. However some of our libs may call functions
|
||||
// which attempt to load the config file, possibly resulting in an exit() or crash if it is missing
|
||||
// or corrupt. Explicitly tell OpenSSL not to try to load the file. The result for our libs will be
|
||||
// that the config appears to have been loaded and there are no modules/engines available.
|
||||
OPENSSL_no_config();
|
||||
}
|
||||
~CInit()
|
||||
{
|
||||
// Shutdown OpenSSL library multithreading support
|
||||
CRYPTO_set_locking_callback(NULL);
|
||||
for (int i = 0; i < CRYPTO_num_locks(); i++)
|
||||
delete ppmutexOpenSSL[i];
|
||||
OPENSSL_free(ppmutexOpenSSL);
|
||||
}
|
||||
}
|
||||
instance_of_cinit;
|
||||
|
||||
/**
|
||||
* LogPrintf() has been broken a couple of times now
|
||||
* by well-meaning people adding mutexes in the most straightforward way.
|
||||
|
@ -893,9 +850,7 @@ std::string LicenseInfo()
|
|||
"\n" +
|
||||
FormatParagraph(_("This is experimental software.")) + "\n" +
|
||||
"\n" +
|
||||
FormatParagraph(_("Distributed under the MIT software license, see the accompanying file COPYING or <https://www.opensource.org/licenses/mit-license.php>.")) + "\n" +
|
||||
"\n" +
|
||||
FormatParagraph(_("This product includes software developed by the OpenSSL Project for use in the OpenSSL Toolkit <https://www.openssl.org/> and cryptographic software written by Eric Young.")) +
|
||||
FormatParagraph(_("Distributed under the MIT software license, see the accompanying file COPYING or <https://www.opensource.org/licenses/mit-license.php>.")) +
|
||||
"\n";
|
||||
}
|
||||
|
||||
|
|
|
@ -10,76 +10,9 @@
|
|||
#include <vector>
|
||||
|
||||
#include <boost/test/unit_test.hpp>
|
||||
#include <openssl/aes.h>
|
||||
#include <openssl/evp.h>
|
||||
|
||||
BOOST_FIXTURE_TEST_SUITE(wallet_crypto, BasicTestingSetup)
|
||||
|
||||
bool OldSetKeyFromPassphrase(const SecureString& strKeyData, const std::vector<unsigned char>& chSalt, const unsigned int nRounds, const unsigned int nDerivationMethod, unsigned char* chKey, unsigned char* chIV)
|
||||
{
|
||||
if (nRounds < 1 || chSalt.size() != WALLET_CRYPTO_SALT_SIZE)
|
||||
return false;
|
||||
|
||||
int i = 0;
|
||||
if (nDerivationMethod == 0)
|
||||
i = EVP_BytesToKey(EVP_aes_256_cbc(), EVP_sha512(), &chSalt[0],
|
||||
(unsigned char *)&strKeyData[0], strKeyData.size(), nRounds, chKey, chIV);
|
||||
|
||||
if (i != (int)WALLET_CRYPTO_KEY_SIZE)
|
||||
{
|
||||
memory_cleanse(chKey, sizeof(chKey));
|
||||
memory_cleanse(chIV, sizeof(chIV));
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool OldEncrypt(const CKeyingMaterial& vchPlaintext, std::vector<unsigned char> &vchCiphertext, const unsigned char chKey[32], const unsigned char chIV[16])
|
||||
{
|
||||
// max ciphertext len for a n bytes of plaintext is
|
||||
// n + AES_BLOCK_SIZE - 1 bytes
|
||||
int nLen = vchPlaintext.size();
|
||||
int nCLen = nLen + AES_BLOCK_SIZE, nFLen = 0;
|
||||
vchCiphertext = std::vector<unsigned char> (nCLen);
|
||||
|
||||
bool fOk = true;
|
||||
|
||||
EVP_CIPHER_CTX* ctx = EVP_CIPHER_CTX_new();
|
||||
assert(ctx);
|
||||
if (fOk) fOk = EVP_EncryptInit_ex(ctx, EVP_aes_256_cbc(), NULL, chKey, chIV) != 0;
|
||||
if (fOk) fOk = EVP_EncryptUpdate(ctx, &vchCiphertext[0], &nCLen, &vchPlaintext[0], nLen) != 0;
|
||||
if (fOk) fOk = EVP_EncryptFinal_ex(ctx, (&vchCiphertext[0]) + nCLen, &nFLen) != 0;
|
||||
EVP_CIPHER_CTX_free(ctx);
|
||||
|
||||
if (!fOk) return false;
|
||||
|
||||
vchCiphertext.resize(nCLen + nFLen);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool OldDecrypt(const std::vector<unsigned char>& vchCiphertext, CKeyingMaterial& vchPlaintext, const unsigned char chKey[32], const unsigned char chIV[16])
|
||||
{
|
||||
// plaintext will always be equal to or lesser than length of ciphertext
|
||||
int nLen = vchCiphertext.size();
|
||||
int nPLen = nLen, nFLen = 0;
|
||||
|
||||
vchPlaintext = CKeyingMaterial(nPLen);
|
||||
|
||||
bool fOk = true;
|
||||
|
||||
EVP_CIPHER_CTX* ctx = EVP_CIPHER_CTX_new();
|
||||
assert(ctx);
|
||||
if (fOk) fOk = EVP_DecryptInit_ex(ctx, EVP_aes_256_cbc(), NULL, chKey, chIV) != 0;
|
||||
if (fOk) fOk = EVP_DecryptUpdate(ctx, &vchPlaintext[0], &nPLen, &vchCiphertext[0], nLen) != 0;
|
||||
if (fOk) fOk = EVP_DecryptFinal_ex(ctx, (&vchPlaintext[0]) + nPLen, &nFLen) != 0;
|
||||
EVP_CIPHER_CTX_free(ctx);
|
||||
|
||||
if (!fOk) return false;
|
||||
|
||||
vchPlaintext.resize(nPLen + nFLen);
|
||||
return true;
|
||||
}
|
||||
|
||||
class TestCrypter
|
||||
{
|
||||
public:
|
||||
|
@ -87,25 +20,15 @@ static void TestPassphraseSingle(const std::vector<unsigned char>& vchSalt, cons
|
|||
const std::vector<unsigned char>& correctKey = std::vector<unsigned char>(),
|
||||
const std::vector<unsigned char>& correctIV=std::vector<unsigned char>())
|
||||
{
|
||||
unsigned char chKey[WALLET_CRYPTO_KEY_SIZE];
|
||||
unsigned char chIV[WALLET_CRYPTO_IV_SIZE];
|
||||
|
||||
CCrypter crypt;
|
||||
crypt.SetKeyFromPassphrase(passphrase, vchSalt, rounds, 0);
|
||||
|
||||
OldSetKeyFromPassphrase(passphrase, vchSalt, rounds, 0, chKey, chIV);
|
||||
|
||||
BOOST_CHECK_MESSAGE(memcmp(chKey, crypt.vchKey.data(), crypt.vchKey.size()) == 0, \
|
||||
HexStr(chKey, chKey+sizeof(chKey)) + std::string(" != ") + HexStr(crypt.vchKey));
|
||||
BOOST_CHECK_MESSAGE(memcmp(chIV, crypt.vchIV.data(), crypt.vchIV.size()) == 0, \
|
||||
HexStr(chIV, chIV+sizeof(chIV)) + std::string(" != ") + HexStr(crypt.vchIV));
|
||||
|
||||
if(!correctKey.empty())
|
||||
BOOST_CHECK_MESSAGE(memcmp(chKey, &correctKey[0], sizeof(chKey)) == 0, \
|
||||
HexStr(chKey, chKey+sizeof(chKey)) + std::string(" != ") + HexStr(correctKey.begin(), correctKey.end()));
|
||||
BOOST_CHECK_MESSAGE(memcmp(crypt.vchKey.data(), correctKey.data(), crypt.vchKey.size()) == 0, \
|
||||
HexStr(crypt.vchKey.begin(), crypt.vchKey.end()) + std::string(" != ") + HexStr(correctKey.begin(), correctKey.end()));
|
||||
if(!correctIV.empty())
|
||||
BOOST_CHECK_MESSAGE(memcmp(chIV, &correctIV[0], sizeof(chIV)) == 0,
|
||||
HexStr(chIV, chIV+sizeof(chIV)) + std::string(" != ") + HexStr(correctIV.begin(), correctIV.end()));
|
||||
BOOST_CHECK_MESSAGE(memcmp(crypt.vchIV.data(), correctIV.data(), crypt.vchIV.size()) == 0,
|
||||
HexStr(crypt.vchIV.begin(), crypt.vchIV.end()) + std::string(" != ") + HexStr(correctIV.begin(), correctIV.end()));
|
||||
}
|
||||
|
||||
static void TestPassphrase(const std::vector<unsigned char>& vchSalt, const SecureString& passphrase, uint32_t rounds,
|
||||
|
@ -117,50 +40,26 @@ static void TestPassphrase(const std::vector<unsigned char>& vchSalt, const Secu
|
|||
TestPassphraseSingle(vchSalt, SecureString(i, passphrase.end()), rounds);
|
||||
}
|
||||
|
||||
|
||||
static void TestDecrypt(const CCrypter& crypt, const std::vector<unsigned char>& vchCiphertext, \
|
||||
const std::vector<unsigned char>& vchPlaintext = std::vector<unsigned char>())
|
||||
{
|
||||
CKeyingMaterial vchDecrypted1;
|
||||
CKeyingMaterial vchDecrypted2;
|
||||
int result1, result2;
|
||||
result1 = crypt.Decrypt(vchCiphertext, vchDecrypted1);
|
||||
result2 = OldDecrypt(vchCiphertext, vchDecrypted2, crypt.vchKey.data(), crypt.vchIV.data());
|
||||
BOOST_CHECK(result1 == result2);
|
||||
|
||||
// These two should be equal. However, OpenSSL 1.0.1j introduced a change
|
||||
// that would zero all padding except for the last byte for failed decrypts.
|
||||
// This behavior was reverted for 1.0.1k.
|
||||
if (vchDecrypted1 != vchDecrypted2 && vchDecrypted1.size() >= AES_BLOCK_SIZE && SSLeay() == 0x100010afL)
|
||||
{
|
||||
for(CKeyingMaterial::iterator it = vchDecrypted1.end() - AES_BLOCK_SIZE; it != vchDecrypted1.end() - 1; it++)
|
||||
*it = 0;
|
||||
}
|
||||
|
||||
BOOST_CHECK_MESSAGE(vchDecrypted1 == vchDecrypted2, HexStr(vchDecrypted1.begin(), vchDecrypted1.end()) + " != " + HexStr(vchDecrypted2.begin(), vchDecrypted2.end()));
|
||||
|
||||
CKeyingMaterial vchDecrypted;
|
||||
crypt.Decrypt(vchCiphertext, vchDecrypted);
|
||||
if (vchPlaintext.size())
|
||||
BOOST_CHECK(CKeyingMaterial(vchPlaintext.begin(), vchPlaintext.end()) == vchDecrypted2);
|
||||
BOOST_CHECK(CKeyingMaterial(vchPlaintext.begin(), vchPlaintext.end()) == vchDecrypted);
|
||||
}
|
||||
|
||||
static void TestEncryptSingle(const CCrypter& crypt, const CKeyingMaterial& vchPlaintext,
|
||||
const std::vector<unsigned char>& vchCiphertextCorrect = std::vector<unsigned char>())
|
||||
{
|
||||
std::vector<unsigned char> vchCiphertext1;
|
||||
std::vector<unsigned char> vchCiphertext2;
|
||||
int result1 = crypt.Encrypt(vchPlaintext, vchCiphertext1);
|
||||
|
||||
int result2 = OldEncrypt(vchPlaintext, vchCiphertext2, crypt.vchKey.data(), crypt.vchIV.data());
|
||||
BOOST_CHECK(result1 == result2);
|
||||
BOOST_CHECK(vchCiphertext1 == vchCiphertext2);
|
||||
std::vector<unsigned char> vchCiphertext;
|
||||
crypt.Encrypt(vchPlaintext, vchCiphertext);
|
||||
|
||||
if (!vchCiphertextCorrect.empty())
|
||||
BOOST_CHECK(vchCiphertext2 == vchCiphertextCorrect);
|
||||
BOOST_CHECK(vchCiphertext == vchCiphertextCorrect);
|
||||
|
||||
const std::vector<unsigned char> vchPlaintext2(vchPlaintext.begin(), vchPlaintext.end());
|
||||
|
||||
if(vchCiphertext1 == vchCiphertext2)
|
||||
TestDecrypt(crypt, vchCiphertext1, vchPlaintext2);
|
||||
TestDecrypt(crypt, vchCiphertext, vchPlaintext2);
|
||||
}
|
||||
|
||||
static void TestEncrypt(const CCrypter& crypt, const std::vector<unsigned char>& vchPlaintextIn, \
|
||||
|
|
Loading…
Reference in New Issue