903da53c06
Adds `prefractal`, an experimental module that lets a FROST t-of-n group
occupy ONE participant slot of an ordinary MuSig2 (BIP 327) session. Each
member computes
s_i = k1_i + b_frost*b_musig*k2_i + e*a*lambda_i*g*gacc*d_i
and the group publishes one ordinary MuSig2 public nonce and one ordinary
MuSig2 partial signature, so cosigners need no support for it and cannot tell
a group is involved.
Four public functions, all sessionless (every call takes its session
parameters explicitly, so there are no new opaque types, magics or *_SIZE
constants to keep synchronised):
secp256k1_prefractal_nonce_agg group wire nonce + unscaled aggnonce
secp256k1_prefractal_sign one member's partial signature
secp256k1_prefractal_partial_sig_verify identifiable abort
secp256k1_prefractal_partial_sig_agg sum -> musig partial signature
Three deliberate deviations from BIP 445, all documented in the public header:
1. b_frost does not commit to the message. The target protocols publish the
group's wire nonce before the message exists, so a message-committing
coefficient could not be computed in round one and rebuilt later. The outer
b_musig does commit to the message and multiplies this one, so the product
still binds it. Same trade the iceberg module makes, for the same reason.
The preimage is BIP 445's with the message dropped and the group key
carried in full rather than x-only, since it is used as a full point
downstream.
2. There is NO g_frost factor. Stock FROST normalises its threshold key to
even Y (g_times_gacc_parity = gacc_parity ^ pk_odd, frost/session_impl.h
:664) because it produces a BIP 340 x-only signature. Here the threshold
key is an inner participant of the outer key aggregation and is used as a
full point, so all key-side parity normalisation happens once, at the
aggregate level, off the OUTER keyagg cache. Note this is NOT implied by
the tweak cache being the identity: with an identity cache g_frost is still
-1 for every odd-Y group key, i.e. about half of them. Importing frost's
key-side parity here would yield a signer that works for even-Y groups and
fails for odd-Y ones.
3. The FROST tweak cache must be the identity (tacc == 0, gacc_parity == 0).
Checked in sign and partial_sig_verify, not only in partial_sig_agg, so the
key a member signs under is tied to the cache that was validated; sign and
verify additionally require thresh_pk to equal the cache's own key so the
two arguments cannot disagree.
The verification equation lives in one helper used both by sign's BIP 445
self-check and by partial_sig_verify, so the two cannot drift apart.
Build wiring. Three files order their module blocks differently and the
constraints point in opposite directions:
- src/secp256k1.c: the include goes AFTER frost and musig, because the
module calls their static internals.
- src/CMakeLists.txt: the block goes BEFORE both, because its set() calls
are only observed by blocks that run later.
- configure.ac: the block likewise goes before the musig block, NOT at
iceberg's position further down. configure.ac orders musig and frost ahead
of iceberg, and iceberg's late enable_module_musig=yes is harmless only
because musig defaults to yes. frost defaults to no, so a late
force-enable would leave -DENABLE_MODULE_FROST=1 unemitted while
AM_CONDITIONAL still observed the mutation - a library whose secp256k1.c
never included frost, built alongside frost's own sources.
frost is also the first default-OFF module anything depends on, which breaks
the dependency-guard idiom used everywhere else in both build systems: the
existing "DEFINED X AND NOT X" (CMake) and "x$X = xno" (autotools) tests read
as "the user disabled it explicitly" only for default-ON modules, and are true
by default for a default-OFF one. Since neither build system can distinguish
an explicit disable from the default once both are in the cache, enabling
prefractal simply implies frost; the guard is kept for musig, where it still
means what it says. The CMake block additionally lifts both dependencies into
the parent scope so the top-level configuration summary reports what was
actually built rather than printing "frost OFF" while compiling frost in.
Verified on both build systems:
cmake -B build -DSECP256K1_ENABLE_MODULE_PREFRACTAL=ON -DSECP256K1_BUILD_TESTS=ON
-> musig/frost/prefractal all ON, tests pass, 4 prefractal symbols exported
cmake -B build -DSECP256K1_BUILD_TESTS=ON
-> prefractal OFF, default build unchanged, tests pass
./configure --enable-experimental --enable-module-prefractal && make && make check
-> frost=yes forced on, -DENABLE_MODULE_FROST=1 emitted, 3/3 pass
./configure --enable-module-prefractal
-> correctly refused: "Prefractal module is experimental"
tests_impl.h is a placeholder here so the module links; the real suite lands
next.
781 lines
33 KiB
Plaintext
781 lines
33 KiB
Plaintext
AC_PREREQ([2.60])
|
|
|
|
# The package (a.k.a. release) version is based on semantic versioning 2.0.0 of
|
|
# the API. All changes in experimental modules are treated as
|
|
# backwards-compatible and therefore at most increase the minor version.
|
|
define(_PKG_VERSION_MAJOR, 0)
|
|
define(_PKG_VERSION_MINOR, 1)
|
|
define(_PKG_VERSION_PATCH, 0)
|
|
define(_PKG_VERSION_IS_RELEASE, false)
|
|
|
|
# The library version is based on libtool versioning of the ABI. The set of
|
|
# rules for updating the version can be found here:
|
|
# https://www.gnu.org/software/libtool/manual/html_node/Updating-version-info.html
|
|
# All changes in experimental modules are treated as if they don't affect the
|
|
# interface and therefore only increase the revision.
|
|
define(_LIB_VERSION_CURRENT, 0)
|
|
define(_LIB_VERSION_REVISION, 0)
|
|
define(_LIB_VERSION_AGE, 0)
|
|
|
|
AC_INIT([libsecp256k1],m4_join([.], _PKG_VERSION_MAJOR, _PKG_VERSION_MINOR, _PKG_VERSION_PATCH)m4_if(_PKG_VERSION_IS_RELEASE, [true], [], [-dev]),[https://github.com/bitcoin-core/secp256k1/issues],[libsecp256k1],[https://github.com/bitcoin-core/secp256k1])
|
|
|
|
AC_CONFIG_AUX_DIR([autotools-aux])
|
|
AC_CONFIG_MACRO_DIR([autotools-aux/m4])
|
|
AC_CANONICAL_HOST
|
|
|
|
# Require Automake 1.11.2 for AM_PROG_AR
|
|
AM_INIT_AUTOMAKE([1.11.2 foreign subdir-objects])
|
|
|
|
# Make the compilation flags quiet unless V=1 is used.
|
|
m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])])
|
|
|
|
if test "${CFLAGS+set}" = "set"; then
|
|
CFLAGS_overridden=yes
|
|
else
|
|
CFLAGS_overridden=no
|
|
fi
|
|
AC_PROG_CC
|
|
AM_PROG_AS
|
|
AM_PROG_AR
|
|
|
|
# Clear some cache variables as a workaround for a bug that appears due to a bad
|
|
# interaction between AM_PROG_AR and LT_INIT when combining MSVC's archiver lib.exe.
|
|
# https://debbugs.gnu.org/cgi/bugreport.cgi?bug=54421
|
|
AS_UNSET(ac_cv_prog_AR)
|
|
AS_UNSET(ac_cv_prog_ac_ct_AR)
|
|
LT_INIT([win32-dll])
|
|
|
|
build_windows=no
|
|
|
|
case $host_os in
|
|
*darwin*)
|
|
if test x$cross_compiling != xyes; then
|
|
AC_CHECK_PROG([BREW], brew, brew)
|
|
if test x$BREW = xbrew; then
|
|
# These Homebrew packages may be keg-only, meaning that they won't be found
|
|
# in expected paths because they may conflict with system files. Ask
|
|
# Homebrew where each one is located, then adjust paths accordingly.
|
|
if $BREW list --versions valgrind >/dev/null; then
|
|
valgrind_prefix=$($BREW --prefix valgrind 2>/dev/null)
|
|
VALGRIND_CPPFLAGS="-I$valgrind_prefix/include"
|
|
fi
|
|
else
|
|
AC_CHECK_PROG([PORT], port, port)
|
|
# If homebrew isn't installed and macports is, add the macports default paths
|
|
# as a last resort.
|
|
if test x$PORT = xport; then
|
|
CPPFLAGS="$CPPFLAGS -isystem /opt/local/include"
|
|
LDFLAGS="$LDFLAGS -L/opt/local/lib"
|
|
fi
|
|
fi
|
|
fi
|
|
;;
|
|
cygwin*|mingw*)
|
|
build_windows=yes
|
|
;;
|
|
esac
|
|
|
|
# Try if some desirable compiler flags are supported and append them to SECP_CFLAGS.
|
|
#
|
|
# These are our own flags, so we append them to our own SECP_CFLAGS variable (instead of CFLAGS) as
|
|
# recommended in the automake manual (Section "Flag Variables Ordering"). CFLAGS belongs to the user
|
|
# and we are not supposed to touch it. In the Makefile, we will need to ensure that SECP_CFLAGS
|
|
# is prepended to CFLAGS when invoking the compiler so that the user always has the last word (flag).
|
|
#
|
|
# Another advantage of not touching CFLAGS is that the contents of CFLAGS will be picked up by
|
|
# libtool for compiling helper executables. For example, when compiling for Windows, libtool will
|
|
# generate entire wrapper executables (instead of simple wrapper scripts as on Unix) to ensure
|
|
# proper operation of uninstalled programs linked by libtool against the uninstalled shared library.
|
|
# These executables are compiled from C source file for which our flags may not be appropriate,
|
|
# e.g., -std=c89 flag has lead to undesirable warnings in the past.
|
|
#
|
|
# TODO We should analogously not touch CPPFLAGS and LDFLAGS but currently there are no issues.
|
|
AC_DEFUN([SECP_TRY_APPEND_DEFAULT_CFLAGS], [
|
|
# GCC and compatible (incl. clang)
|
|
if test "x$GCC" = "xyes"; then
|
|
# Try to append -Werror to CFLAGS temporarily. Otherwise checks for some unsupported
|
|
# flags will succeed.
|
|
# Note that failure to append -Werror does not necessarily mean that -Werror is not
|
|
# supported. The compiler may already be warning about something unrelated, for example
|
|
# about some path issue. If that is the case, -Werror cannot be used because all
|
|
# of those warnings would be turned into errors.
|
|
SECP_TRY_APPEND_DEFAULT_CFLAGS_saved_CFLAGS="$CFLAGS"
|
|
SECP_TRY_APPEND_CFLAGS([-Werror], CFLAGS)
|
|
|
|
SECP_TRY_APPEND_CFLAGS([-std=c89 -pedantic -Wno-long-long -Wnested-externs -Wshadow -Wstrict-prototypes -Wundef], $1) # GCC >= 3.0, -Wlong-long is implied by -pedantic.
|
|
SECP_TRY_APPEND_CFLAGS([-Wno-overlength-strings], $1) # GCC >= 4.2, -Woverlength-strings is implied by -pedantic.
|
|
SECP_TRY_APPEND_CFLAGS([-Wall], $1) # GCC >= 2.95 and probably many other compilers
|
|
SECP_TRY_APPEND_CFLAGS([-Wno-unused-function], $1) # GCC >= 3.0, -Wunused-function is implied by -Wall.
|
|
SECP_TRY_APPEND_CFLAGS([-Wextra], $1) # GCC >= 3.4, this is the newer name of -W, which we don't use because older GCCs will warn about unused functions.
|
|
SECP_TRY_APPEND_CFLAGS([-Wcast-align], $1) # GCC >= 2.95
|
|
SECP_TRY_APPEND_CFLAGS([-Wcast-align=strict], $1) # GCC >= 8.0
|
|
SECP_TRY_APPEND_CFLAGS([-Wconditional-uninitialized], $1) # Clang >= 3.0 only
|
|
SECP_TRY_APPEND_CFLAGS([-Wreserved-identifier], $1) # Clang >= 13.0 only
|
|
SECP_TRY_APPEND_CFLAGS([-Wtrailing-whitespace=any], $1) # GCC >= 15.0
|
|
SECP_TRY_APPEND_CFLAGS([-Wleading-whitespace=spaces], $1) # GCC >= 15.0
|
|
|
|
CFLAGS="$SECP_TRY_APPEND_DEFAULT_CFLAGS_saved_CFLAGS"
|
|
fi
|
|
|
|
# MSVC
|
|
# Assume MSVC if we're building for Windows but not with GCC or compatible;
|
|
# libtool makes the same assumption internally.
|
|
# Note that "/opt" and "-opt" are equivalent for MSVC; we use "-opt" because "/opt" looks like a path.
|
|
if test x"$GCC" != x"yes" && test x"$build_windows" = x"yes"; then
|
|
SECP_TRY_APPEND_CFLAGS([-W3], $1) # Production quality warning level.
|
|
SECP_TRY_APPEND_CFLAGS([-wd4146], $1) # Disable warning C4146 "unary minus operator applied to unsigned type, result still unsigned".
|
|
SECP_TRY_APPEND_CFLAGS([-wd4244], $1) # Disable warning C4244 "'conversion' conversion from 'type1' to 'type2', possible loss of data".
|
|
SECP_TRY_APPEND_CFLAGS([-wd4267], $1) # Disable warning C4267 "'var' : conversion from 'size_t' to 'type', possible loss of data".
|
|
# Eliminate deprecation warnings for the older, less secure functions.
|
|
CPPFLAGS="-D_CRT_SECURE_NO_WARNINGS $CPPFLAGS"
|
|
fi
|
|
])
|
|
SECP_TRY_APPEND_DEFAULT_CFLAGS(SECP_CFLAGS)
|
|
|
|
###
|
|
### Define config arguments
|
|
###
|
|
|
|
# In dev mode, we enable all binaries and modules by default but individual options can still be overridden explicitly.
|
|
# Check for dev mode first because SECP_SET_DEFAULT needs enable_dev_mode set.
|
|
AC_ARG_ENABLE(dev_mode, [], [],
|
|
[enable_dev_mode=no])
|
|
|
|
AC_ARG_ENABLE(benchmark,
|
|
AS_HELP_STRING([--enable-benchmark],[compile benchmark [default=yes]]), [],
|
|
[SECP_SET_DEFAULT([enable_benchmark], [yes], [yes])])
|
|
|
|
AC_ARG_ENABLE(coverage,
|
|
AS_HELP_STRING([--enable-coverage],[enable coverage analysis support [default=no]]), [],
|
|
[SECP_SET_DEFAULT([enable_coverage], [no], [no])])
|
|
|
|
AC_ARG_ENABLE(tests,
|
|
AS_HELP_STRING([--enable-tests],[compile tests [default=yes]]), [],
|
|
[SECP_SET_DEFAULT([enable_tests], [yes], [yes])])
|
|
|
|
AC_ARG_ENABLE(ctime_tests,
|
|
AS_HELP_STRING([--enable-ctime-tests],[compile constant-time tests [default=yes if valgrind enabled]]), [],
|
|
[SECP_SET_DEFAULT([enable_ctime_tests], [auto], [auto])])
|
|
|
|
AC_ARG_ENABLE(experimental,
|
|
AS_HELP_STRING([--enable-experimental],[allow experimental configure options [default=no]]), [],
|
|
[SECP_SET_DEFAULT([enable_experimental], [no], [yes])])
|
|
|
|
AC_ARG_ENABLE(exhaustive_tests,
|
|
AS_HELP_STRING([--enable-exhaustive-tests],[compile exhaustive tests [default=yes]]), [],
|
|
[SECP_SET_DEFAULT([enable_exhaustive_tests], [yes], [yes])])
|
|
|
|
AC_ARG_ENABLE(examples,
|
|
AS_HELP_STRING([--enable-examples],[compile the examples [default=no]]), [],
|
|
[SECP_SET_DEFAULT([enable_examples], [no], [yes])])
|
|
|
|
AC_ARG_ENABLE(module_ecdh,
|
|
AS_HELP_STRING([--enable-module-ecdh],[enable ECDH module [default=yes]]), [],
|
|
[SECP_SET_DEFAULT([enable_module_ecdh], [yes], [yes])])
|
|
|
|
AC_ARG_ENABLE(module_recovery,
|
|
AS_HELP_STRING([--enable-module-recovery],[enable ECDSA pubkey recovery module [default=no]]), [],
|
|
[SECP_SET_DEFAULT([enable_module_recovery], [no], [yes])])
|
|
|
|
AC_ARG_ENABLE(module_extrakeys,
|
|
AS_HELP_STRING([--enable-module-extrakeys],[enable extrakeys module [default=yes]]), [],
|
|
[SECP_SET_DEFAULT([enable_module_extrakeys], [yes], [yes])])
|
|
|
|
AC_ARG_ENABLE(module_schnorrsig,
|
|
AS_HELP_STRING([--enable-module-schnorrsig],[enable schnorrsig module [default=yes]]), [],
|
|
[SECP_SET_DEFAULT([enable_module_schnorrsig], [yes], [yes])])
|
|
|
|
AC_ARG_ENABLE(module_musig,
|
|
AS_HELP_STRING([--enable-module-musig],[enable MuSig2 module [default=yes]]), [],
|
|
[SECP_SET_DEFAULT([enable_module_musig], [yes], [yes])])
|
|
|
|
AC_ARG_ENABLE(module_schnorrsig_halfagg,
|
|
AS_HELP_STRING([--enable-module-schnorrsig-halfagg],[enable schnorrsig half-aggregation module (experimental) [default=no]]), [],
|
|
[SECP_SET_DEFAULT([enable_module_schnorrsig_halfagg], [no], [yes])])
|
|
|
|
AC_ARG_ENABLE(module_ellswift,
|
|
AS_HELP_STRING([--enable-module-ellswift],[enable ElligatorSwift module [default=yes]]), [],
|
|
[SECP_SET_DEFAULT([enable_module_ellswift], [yes], [yes])])
|
|
|
|
AC_ARG_ENABLE(module_generator,
|
|
AS_HELP_STRING([--enable-module-generator],[enable NUMS generator module [default=no]]),
|
|
[],
|
|
[SECP_SET_DEFAULT([enable_module_generator], [no], [yes])])
|
|
|
|
AC_ARG_ENABLE(module_rangeproof,
|
|
AS_HELP_STRING([--enable-module-rangeproof],[enable Pedersen / zero-knowledge range proofs module [default=no]]),
|
|
[],
|
|
[SECP_SET_DEFAULT([enable_module_rangeproof], [no], [yes])])
|
|
|
|
AC_ARG_ENABLE(module_surjectionproof,
|
|
AS_HELP_STRING([--enable-module-surjectionproof],[enable surjection proof module [default=no]]),
|
|
[],
|
|
[SECP_SET_DEFAULT([enable_module_surjectionproof], [no], [yes])])
|
|
AC_ARG_ENABLE(reduced_surjection_proof_size,
|
|
AS_HELP_STRING([--enable-reduced-surjection-proof-size],[use reduced surjection proof size (disabling parsing and verification) [default=no]]),
|
|
[],
|
|
[SECP_SET_DEFAULT([enable_reduced_surjection_proof_size], [no], [no])])
|
|
|
|
AC_ARG_ENABLE(module_whitelist,
|
|
AS_HELP_STRING([--enable-module-whitelist],[enable key whitelisting module [default=no]]),
|
|
[],
|
|
[SECP_SET_DEFAULT([enable_module_whitelist], [no], [yes])])
|
|
|
|
AC_ARG_ENABLE(module_ecdsa_s2c,
|
|
AS_HELP_STRING([--enable-module-ecdsa-s2c],[enable ECDSA sign-to-contract module [default=no]]),
|
|
[],
|
|
[SECP_SET_DEFAULT([enable_module_ecdsa_s2c], [no], [yes])])
|
|
|
|
AC_ARG_ENABLE(module_bppp,
|
|
AS_HELP_STRING([--enable-module-bppp],[enable Bulletproofs++ module (experimental)]),
|
|
[],
|
|
[SECP_SET_DEFAULT([enable_module_bppp], [no], [yes])])
|
|
|
|
AC_ARG_ENABLE(module_ecdsa-adaptor,
|
|
AS_HELP_STRING([--enable-module-ecdsa-adaptor],[enable ECDSA adaptor module [default=no]]),
|
|
[],
|
|
[SECP_SET_DEFAULT([enable_module_ecdsa_adaptor], [no], [yes])])
|
|
|
|
AC_ARG_ENABLE(external_default_callbacks,
|
|
AS_HELP_STRING([--enable-external-default-callbacks],[enable external default callback functions [default=no]]), [],
|
|
[SECP_SET_DEFAULT([enable_external_default_callbacks], [no], [no])])
|
|
|
|
AC_ARG_ENABLE(module_frost,
|
|
AS_HELP_STRING([--enable-module-frost],[enable FROST module (experimental)]),
|
|
[],
|
|
[SECP_SET_DEFAULT([enable_module_frost], [no], [yes])])
|
|
|
|
AC_ARG_ENABLE(module_chilldkg,
|
|
AS_HELP_STRING([--enable-module-chilldkg],[enable ChillDKG module (experimental)]),
|
|
[],
|
|
[SECP_SET_DEFAULT([enable_module_chilldkg], [no], [yes])])
|
|
|
|
AC_ARG_ENABLE(module_iceberg,
|
|
AS_HELP_STRING([--enable-module-iceberg],[enable Iceberg threshold-MuSig module (experimental)]),
|
|
[],
|
|
[SECP_SET_DEFAULT([enable_module_iceberg], [no], [yes])])
|
|
|
|
AC_ARG_ENABLE(module_prefractal,
|
|
AS_HELP_STRING([--enable-module-prefractal],[enable Prefractal nested FROST+MuSig2 module (experimental)]),
|
|
[],
|
|
[SECP_SET_DEFAULT([enable_module_prefractal], [no], [yes])])
|
|
|
|
# Test-only override of the (autodetected by the C code) "widemul" setting.
|
|
# Legal values are:
|
|
# * int64 (for [u]int64_t),
|
|
# * int128 (for [unsigned] __int128),
|
|
# * int128_struct (for int128 implemented as a structure),
|
|
# * and auto (the default).
|
|
AC_ARG_WITH([test-override-wide-multiply], [] ,[set_widemul=$withval], [set_widemul=auto])
|
|
|
|
AC_ARG_WITH([asm], [AS_HELP_STRING([--with-asm=x86_64|arm32|no|auto],
|
|
[assembly to use (experimental: arm32) [default=auto]])],[req_asm=$withval], [req_asm=auto])
|
|
|
|
AC_ARG_WITH([ecmult-window], [AS_HELP_STRING([--with-ecmult-window=SIZE],
|
|
[window size for ecmult precomputation for verification, specified as integer in range [2..24].]
|
|
[Larger values result in possibly better performance at the cost of an exponentially larger precomputed table.]
|
|
[The table will store 2^(SIZE-1) * 64 bytes of data but can be larger in memory due to platform-specific padding and alignment.]
|
|
[A window size larger than 15 will require you delete the prebuilt precomputed_ecmult.c file so that it can be rebuilt.]
|
|
[For very large window sizes, use "make -j 1" to reduce memory use during compilation.]
|
|
[The default value is a reasonable setting for desktop machines (currently 15). [default=15]]
|
|
)],
|
|
[set_ecmult_window=$withval], [set_ecmult_window=15])
|
|
|
|
AC_ARG_WITH([ecmult-gen-kb], [AS_HELP_STRING([--with-ecmult-gen-kb=2|22|86],
|
|
[The size of the precomputed table for signing in multiples of 1024 bytes (on typical platforms).]
|
|
[Larger values result in possibly better signing/keygeneration performance at the cost of a larger table.]
|
|
[The default value is a reasonable setting for desktop machines (currently 86). [default=86]]
|
|
)],
|
|
[set_ecmult_gen_kb=$withval], [set_ecmult_gen_kb=86])
|
|
|
|
AC_ARG_WITH([valgrind], [AS_HELP_STRING([--with-valgrind=yes|no|auto],
|
|
[Build with extra checks for running inside Valgrind [default=auto]]
|
|
)],
|
|
[req_valgrind=$withval], [req_valgrind=auto])
|
|
|
|
###
|
|
### Handle config options (except for modules)
|
|
###
|
|
|
|
if test x"$req_valgrind" = x"no"; then
|
|
enable_valgrind=no
|
|
else
|
|
SECP_VALGRIND_CHECK
|
|
if test x"$has_valgrind" != x"yes"; then
|
|
if test x"$req_valgrind" = x"yes"; then
|
|
AC_MSG_ERROR([Valgrind support explicitly requested but valgrind/memcheck.h header not available])
|
|
fi
|
|
enable_valgrind=no
|
|
else
|
|
enable_valgrind=yes
|
|
fi
|
|
fi
|
|
|
|
if test x"$enable_ctime_tests" = x"auto"; then
|
|
enable_ctime_tests=$enable_valgrind
|
|
fi
|
|
|
|
print_msan_notice=no
|
|
if test x"$enable_ctime_tests" = x"yes"; then
|
|
SECP_MSAN_CHECK
|
|
# MSan on Clang >=16 reports uninitialized memory in function parameters and return values, even if
|
|
# the uninitialized variable is never actually "used". This is called "eager" checking, and it's
|
|
# sounds like good idea for normal use of MSan. However, it yields many false positives in the
|
|
# ctime_tests because many return values depend on secret (i.e., "uninitialized") values, and
|
|
# we're only interested in detecting branches (which count as "uses") on secret data.
|
|
if test x"$msan_enabled" = x"yes"; then
|
|
SECP_TRY_APPEND_CFLAGS([-fno-sanitize-memory-param-retval], SECP_CFLAGS)
|
|
print_msan_notice=yes
|
|
fi
|
|
fi
|
|
|
|
if test x"$enable_coverage" = x"yes"; then
|
|
SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES -DCOVERAGE=1"
|
|
SECP_CFLAGS="-O0 --coverage $SECP_CFLAGS"
|
|
# If coverage is enabled, and the user has not overridden CFLAGS,
|
|
# override Autoconf's value "-g -O2" with "-g". Otherwise we'd end up
|
|
# with "-O0 --coverage -g -O2".
|
|
if test "$CFLAGS_overridden" = "no"; then
|
|
CFLAGS="-g"
|
|
fi
|
|
LDFLAGS="--coverage $LDFLAGS"
|
|
else
|
|
# Most likely the CFLAGS already contain -O2 because that is autoconf's default.
|
|
# We still add it here because passing it twice is not an issue, and handling
|
|
# this case would just add unnecessary complexity (see #896).
|
|
SECP_CFLAGS="-O2 $SECP_CFLAGS"
|
|
fi
|
|
|
|
AC_MSG_CHECKING([for __builtin_popcount])
|
|
AC_LINK_IFELSE([AC_LANG_SOURCE([[void myfunc() {__builtin_popcount(0);}]])],
|
|
[ AC_MSG_RESULT([yes]); SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES -DHAVE_BUILTIN_POPCOUNT=1"],
|
|
[ AC_MSG_RESULT([no])
|
|
])
|
|
|
|
AC_MSG_CHECKING([for __builtin_clzll])
|
|
AC_LINK_IFELSE([AC_LANG_SOURCE([[void myfunc() { __builtin_clzll(1);}]])],
|
|
[ AC_MSG_RESULT([yes]); SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES -DHAVE_BUILTIN_CLZLL=1"],
|
|
[ AC_MSG_RESULT([no])
|
|
])
|
|
|
|
if test x"$req_asm" = x"auto"; then
|
|
SECP_X86_64_ASM_CHECK
|
|
if test x"$has_x86_64_asm" = x"yes"; then
|
|
set_asm=x86_64
|
|
fi
|
|
if test x"$set_asm" = x; then
|
|
set_asm=no
|
|
fi
|
|
else
|
|
set_asm=$req_asm
|
|
case $set_asm in
|
|
x86_64)
|
|
SECP_X86_64_ASM_CHECK
|
|
if test x"$has_x86_64_asm" != x"yes"; then
|
|
AC_MSG_ERROR([x86_64 assembly requested but not available])
|
|
fi
|
|
;;
|
|
arm32)
|
|
SECP_ARM32_ASM_CHECK
|
|
if test x"$has_arm32_asm" != x"yes"; then
|
|
AC_MSG_ERROR([ARM32 assembly requested but not available])
|
|
fi
|
|
;;
|
|
no)
|
|
;;
|
|
*)
|
|
AC_MSG_ERROR([invalid assembly selection])
|
|
;;
|
|
esac
|
|
fi
|
|
|
|
# Select assembly
|
|
enable_external_asm=no
|
|
|
|
case $set_asm in
|
|
x86_64)
|
|
SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES -DUSE_ASM_X86_64=1"
|
|
;;
|
|
arm32)
|
|
enable_external_asm=yes
|
|
;;
|
|
no)
|
|
;;
|
|
*)
|
|
AC_MSG_ERROR([invalid assembly selection])
|
|
;;
|
|
esac
|
|
|
|
if test x"$enable_external_asm" = x"yes"; then
|
|
SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES -DUSE_EXTERNAL_ASM=1"
|
|
fi
|
|
|
|
|
|
# Select wide multiplication implementation
|
|
case $set_widemul in
|
|
int128_struct)
|
|
SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES -DUSE_FORCE_WIDEMUL_INT128_STRUCT=1"
|
|
;;
|
|
int128)
|
|
SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES -DUSE_FORCE_WIDEMUL_INT128=1"
|
|
;;
|
|
int64)
|
|
SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES -DUSE_FORCE_WIDEMUL_INT64=1"
|
|
;;
|
|
auto)
|
|
;;
|
|
*)
|
|
AC_MSG_ERROR([invalid wide multiplication implementation])
|
|
;;
|
|
esac
|
|
|
|
error_window_size=['window size for ecmult precomputation not an integer in range [2..24]']
|
|
case $set_ecmult_window in
|
|
''|*[[!0-9]]*)
|
|
# no valid integer
|
|
AC_MSG_ERROR($error_window_size)
|
|
;;
|
|
*)
|
|
if test "$set_ecmult_window" -lt 2 -o "$set_ecmult_window" -gt 24 ; then
|
|
# not in range
|
|
AC_MSG_ERROR($error_window_size)
|
|
fi
|
|
SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES -DECMULT_WINDOW_SIZE=$set_ecmult_window"
|
|
;;
|
|
esac
|
|
|
|
case $set_ecmult_gen_kb in
|
|
2)
|
|
SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES -DCOMB_BLOCKS=2 -DCOMB_TEETH=5"
|
|
;;
|
|
22)
|
|
SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES -DCOMB_BLOCKS=11 -DCOMB_TEETH=6"
|
|
;;
|
|
86)
|
|
SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES -DCOMB_BLOCKS=43 -DCOMB_TEETH=6"
|
|
;;
|
|
*)
|
|
AC_MSG_ERROR(['ecmult gen table size not 2, 22 or 86'])
|
|
;;
|
|
esac
|
|
|
|
if test x"$enable_valgrind" = x"yes"; then
|
|
SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES $VALGRIND_CPPFLAGS -DVALGRIND"
|
|
fi
|
|
|
|
# Add -Werror and similar flags passed from the outside (for testing, e.g., in CI).
|
|
# We don't want to set the user variable CFLAGS in CI because this would disable
|
|
# autoconf's logic for setting default CFLAGS, which we would like to test in CI.
|
|
SECP_CFLAGS="$SECP_CFLAGS $WERROR_CFLAGS"
|
|
|
|
###
|
|
### Handle module options
|
|
###
|
|
|
|
# Processing must be done in a reverse topological sorting of the dependency graph
|
|
# (dependent module first).
|
|
if test x"$enable_module_schnorrsig_halfagg" = x"yes"; then
|
|
if test x"$enable_module_schnorrsig" = x"no"; then
|
|
AC_MSG_ERROR([Module dependency error: You have disabled the schnorrsig module explicitly, but it is required by the schnorrsig_halfagg module.])
|
|
fi
|
|
SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES -DENABLE_MODULE_SCHNORRSIG_HALFAGG=1"
|
|
enable_module_schnorrsig=yes
|
|
fi
|
|
|
|
if test x"$enable_module_bppp" = x"yes"; then
|
|
if test x"$enable_module_generator" = x"no"; then
|
|
AC_MSG_ERROR([Module dependency error: You have disabled the generator module explicitly, but it is required by the bppp module.])
|
|
fi
|
|
SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES -DENABLE_MODULE_BPPP=1"
|
|
enable_module_generator=yes
|
|
fi
|
|
|
|
if test x"$enable_module_ecdsa_s2c" = x"yes"; then
|
|
SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES -DENABLE_MODULE_ECDSA_S2C=1"
|
|
fi
|
|
|
|
if test x"$enable_module_ecdsa_adaptor" = x"yes"; then
|
|
SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES -DENABLE_MODULE_ECDSA_ADAPTOR=1"
|
|
fi
|
|
|
|
if test x"$enable_module_whitelist" = x"yes"; then
|
|
if test x"$enable_module_rangeproof" = x"no"; then
|
|
AC_MSG_ERROR([Module dependency error: You have disabled the rangeproof module explicitly, but it is required by the whitelist module.])
|
|
fi
|
|
SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES -DENABLE_MODULE_WHITELIST=1"
|
|
enable_module_rangeproof=yes
|
|
fi
|
|
|
|
if test x"$enable_module_surjectionproof" = x"yes"; then
|
|
if test x"$enable_module_rangeproof" = x"no"; then
|
|
AC_MSG_ERROR([Module dependency error: You have disabled the rangeproof module explicitly, but it is required by the surjectionproof module.])
|
|
fi
|
|
SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES -DENABLE_MODULE_SURJECTIONPROOF=1"
|
|
enable_module_rangeproof=yes
|
|
fi
|
|
|
|
if test x"$enable_module_rangeproof" = x"yes"; then
|
|
if test x"$enable_module_generator" = x"no"; then
|
|
AC_MSG_ERROR([Module dependency error: You have disabled the generator module explicitly, but it is required by the rangeproof module.])
|
|
fi
|
|
SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES -DENABLE_MODULE_RANGEPROOF=1"
|
|
enable_module_generator=yes
|
|
fi
|
|
|
|
if test x"$enable_module_generator" = x"yes"; then
|
|
SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES -DENABLE_MODULE_GENERATOR=1"
|
|
fi
|
|
|
|
if test x"$enable_module_ellswift" = x"yes"; then
|
|
SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES -DENABLE_MODULE_ELLSWIFT=1"
|
|
fi
|
|
|
|
# This block must stay ahead of the musig and frost blocks below. The
|
|
# enable_module_* assignments here are only observed by blocks that run after
|
|
# them, and frost defaults to "no": placing this at the iceberg block's
|
|
# position (further down) would leave -DENABLE_MODULE_FROST=1 unemitted while
|
|
# AM_CONDITIONAL still saw the mutation, which builds frost's sources into a
|
|
# library whose secp256k1.c never included them.
|
|
if test x"$enable_module_prefractal" = x"yes"; then
|
|
# musig defaults to yes, so "no" here really does mean the user disabled it.
|
|
if test x"$enable_module_musig" = x"no"; then
|
|
AC_MSG_ERROR([Module dependency error: You have disabled the musig module explicitly, but it is required by the prefractal module.])
|
|
fi
|
|
# frost defaults to no, so the same test would reject every prefractal build.
|
|
# SECP_SET_DEFAULT only runs in AC_ARG_ENABLE's action-if-not-given branch,
|
|
# so telling an explicit --disable-module-frost from the default would mean
|
|
# changing frost's own declaration; enabling prefractal simply implies frost
|
|
# instead. The CMake block does the same, for the same reason.
|
|
enable_module_frost=yes
|
|
enable_module_musig=yes
|
|
SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES -DENABLE_MODULE_PREFRACTAL=1"
|
|
fi
|
|
|
|
if test x"$enable_module_musig" = x"yes"; then
|
|
if test x"$enable_module_schnorrsig" = x"no"; then
|
|
AC_MSG_ERROR([Module dependency error: You have disabled the schnorrsig module explicitly, but it is required by the musig module.])
|
|
fi
|
|
enable_module_schnorrsig=yes
|
|
SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES -DENABLE_MODULE_MUSIG=1"
|
|
fi
|
|
|
|
if test x"$enable_module_schnorrsig" = x"yes"; then
|
|
if test x"$enable_module_extrakeys" = x"no"; then
|
|
AC_MSG_ERROR([Module dependency error: You have disabled the extrakeys module explicitly, but it is required by the schnorrsig module.])
|
|
fi
|
|
enable_module_extrakeys=yes
|
|
SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES -DENABLE_MODULE_SCHNORRSIG=1"
|
|
fi
|
|
|
|
if test x"$enable_module_extrakeys" = x"yes"; then
|
|
SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES -DENABLE_MODULE_EXTRAKEYS=1"
|
|
fi
|
|
|
|
if test x"$enable_module_recovery" = x"yes"; then
|
|
SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES -DENABLE_MODULE_RECOVERY=1"
|
|
fi
|
|
|
|
if test x"$enable_module_ecdh" = x"yes"; then
|
|
SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES -DENABLE_MODULE_ECDH=1"
|
|
fi
|
|
|
|
if test x"$enable_module_frost" = x"yes"; then
|
|
if test x"$enable_module_schnorrsig" = x"no"; then
|
|
AC_MSG_ERROR([Module dependency error: You have disabled the schnorrsig module explicitly, but it is required by the frost module.])
|
|
fi
|
|
SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES -DENABLE_MODULE_FROST=1"
|
|
enable_module_schnorrsig=yes
|
|
fi
|
|
|
|
if test x"$enable_module_chilldkg" = x"yes"; then
|
|
if test x"$enable_module_schnorrsig" = x"no"; then
|
|
AC_MSG_ERROR([Module dependency error: You have disabled the schnorrsig module explicitly, but it is required by the chilldkg module.])
|
|
fi
|
|
if test x"$enable_module_ecdh" = x"no"; then
|
|
AC_MSG_ERROR([Module dependency error: You have disabled the ecdh module explicitly, but it is required by the chilldkg module.])
|
|
fi
|
|
SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES -DENABLE_MODULE_CHILLDKG=1"
|
|
enable_module_schnorrsig=yes
|
|
enable_module_ecdh=yes
|
|
fi
|
|
|
|
if test x"$enable_module_iceberg" = x"yes"; then
|
|
if test x"$enable_module_musig" = x"no"; then
|
|
AC_MSG_ERROR([Module dependency error: You have disabled the musig module explicitly, but it is required by the iceberg module.])
|
|
fi
|
|
enable_module_musig=yes
|
|
SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES -DENABLE_MODULE_ICEBERG=1"
|
|
fi
|
|
|
|
if test x"$enable_external_default_callbacks" = x"yes"; then
|
|
SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES -DUSE_EXTERNAL_DEFAULT_CALLBACKS=1"
|
|
fi
|
|
|
|
if test x"$enable_reduced_surjection_proof_size" = x"yes"; then
|
|
SECP_CONFIG_DEFINES="$SECP_CONFIG_DEFINES -DUSE_REDUCED_SURJECTION_PROOF_SIZE=1"
|
|
fi
|
|
|
|
###
|
|
### Check for --enable-experimental if necessary
|
|
###
|
|
|
|
if test x"$enable_experimental" = x"no"; then
|
|
# The order of the following tests matters. If the user enables a dependent
|
|
# module (which automatically enables the module dependencies) we want to
|
|
# print an error for the dependent module, not the module dependency. Hence,
|
|
# we first test dependent modules.
|
|
if test x"$enable_module_schnorrsig_halfagg" = x"yes"; then
|
|
AC_MSG_ERROR([Schnorrsig Half-Aggregation module is experimental. Use --enable-experimental to allow.])
|
|
fi
|
|
if test x"$enable_module_bppp" = x"yes"; then
|
|
AC_MSG_ERROR([Bulletproofs++ module is experimental. Use --enable-experimental to allow.])
|
|
fi
|
|
if test x"$enable_module_ecdsa_adaptor" = x"yes"; then
|
|
AC_MSG_ERROR([ecdsa adaptor signatures module is experimental. Use --enable-experimental to allow.])
|
|
fi
|
|
if test x"$enable_module_ecdsa_s2c" = x"yes"; then
|
|
AC_MSG_ERROR([ECDSA sign-to-contract module module is experimental. Use --enable-experimental to allow.])
|
|
fi
|
|
if test x"$enable_module_whitelist" = x"yes"; then
|
|
AC_MSG_ERROR([Key whitelisting module is experimental. Use --enable-experimental to allow.])
|
|
fi
|
|
if test x"$enable_module_surjectionproof" = x"yes"; then
|
|
AC_MSG_ERROR([Surjection proof module is experimental. Use --enable-experimental to allow.])
|
|
fi
|
|
if test x"$enable_module_rangeproof" = x"yes"; then
|
|
AC_MSG_ERROR([Range proof module is experimental. Use --enable-experimental to allow.])
|
|
fi
|
|
if test x"$enable_module_generator" = x"yes"; then
|
|
AC_MSG_ERROR([NUMS generator module is experimental. Use --enable-experimental to allow.])
|
|
fi
|
|
if test x"$set_asm" = x"arm32"; then
|
|
AC_MSG_ERROR([ARM32 assembly is experimental. Use --enable-experimental to allow.])
|
|
fi
|
|
if test x"$enable_module_prefractal" = x"yes"; then
|
|
AC_MSG_ERROR([Prefractal module is experimental. Use --enable-experimental to allow.])
|
|
fi
|
|
if test x"$enable_module_frost" = x"yes"; then
|
|
AC_MSG_ERROR([FROST module is experimental. Use --enable-experimental to allow.])
|
|
fi
|
|
if test x"$enable_module_chilldkg" = x"yes"; then
|
|
AC_MSG_ERROR([ChillDKG module is experimental. Use --enable-experimental to allow.])
|
|
fi
|
|
if test x"$enable_module_iceberg" = x"yes"; then
|
|
AC_MSG_ERROR([Iceberg module is experimental. Use --enable-experimental to allow.])
|
|
fi
|
|
fi
|
|
|
|
# Check for concurrency support (tests only)
|
|
if test "x$enable_tests" != x"no"; then
|
|
AC_CHECK_HEADERS([sys/types.h sys/wait.h unistd.h])
|
|
AS_IF([test "x$ac_cv_header_sys_types_h" = xyes && test "x$ac_cv_header_sys_wait_h" = xyes &&
|
|
test "x$ac_cv_header_unistd_h" = xyes], [TEST_DEFINES="-DSUPPORTS_CONCURRENCY=1"], TEST_DEFINES="")
|
|
AC_SUBST(TEST_DEFINES)
|
|
fi
|
|
|
|
###
|
|
### Generate output
|
|
###
|
|
|
|
AC_CONFIG_FILES([Makefile libsecp256k1.pc])
|
|
AC_SUBST(SECP_CFLAGS)
|
|
AC_SUBST(SECP_CONFIG_DEFINES)
|
|
AM_CONDITIONAL([ENABLE_COVERAGE], [test x"$enable_coverage" = x"yes"])
|
|
AM_CONDITIONAL([USE_TESTS], [test x"$enable_tests" != x"no"])
|
|
AM_CONDITIONAL([USE_CTIME_TESTS], [test x"$enable_ctime_tests" = x"yes"])
|
|
AM_CONDITIONAL([USE_EXHAUSTIVE_TESTS], [test x"$enable_exhaustive_tests" != x"no"])
|
|
AM_CONDITIONAL([USE_EXAMPLES], [test x"$enable_examples" != x"no"])
|
|
AM_CONDITIONAL([USE_BENCHMARK], [test x"$enable_benchmark" = x"yes"])
|
|
AM_CONDITIONAL([ENABLE_MODULE_ECDH], [test x"$enable_module_ecdh" = x"yes"])
|
|
AM_CONDITIONAL([ENABLE_MODULE_RECOVERY], [test x"$enable_module_recovery" = x"yes"])
|
|
AM_CONDITIONAL([ENABLE_MODULE_EXTRAKEYS], [test x"$enable_module_extrakeys" = x"yes"])
|
|
AM_CONDITIONAL([ENABLE_MODULE_SCHNORRSIG], [test x"$enable_module_schnorrsig" = x"yes"])
|
|
AM_CONDITIONAL([ENABLE_MODULE_MUSIG], [test x"$enable_module_musig" = x"yes"])
|
|
AM_CONDITIONAL([ENABLE_MODULE_ELLSWIFT], [test x"$enable_module_ellswift" = x"yes"])
|
|
AM_CONDITIONAL([ENABLE_MODULE_GENERATOR], [test x"$enable_module_generator" = x"yes"])
|
|
AM_CONDITIONAL([ENABLE_MODULE_RANGEPROOF], [test x"$enable_module_rangeproof" = x"yes"])
|
|
AM_CONDITIONAL([ENABLE_MODULE_SURJECTIONPROOF], [test x"$enable_module_surjectionproof" = x"yes"])
|
|
AM_CONDITIONAL([ENABLE_MODULE_WHITELIST], [test x"$enable_module_whitelist" = x"yes"])
|
|
AM_CONDITIONAL([ENABLE_MODULE_ECDSA_S2C], [test x"$enable_module_ecdsa_s2c" = x"yes"])
|
|
AM_CONDITIONAL([ENABLE_MODULE_ECDSA_ADAPTOR], [test x"$enable_module_ecdsa_adaptor" = x"yes"])
|
|
AM_CONDITIONAL([ENABLE_MODULE_BPPP], [test x"$enable_module_bppp" = x"yes"])
|
|
AM_CONDITIONAL([ENABLE_MODULE_SCHNORRSIG_HALFAGG], [test x"$enable_module_schnorrsig_halfagg" = x"yes"])
|
|
AM_CONDITIONAL([ENABLE_MODULE_FROST], [test x"$enable_module_frost" = x"yes"])
|
|
AM_CONDITIONAL([ENABLE_MODULE_CHILLDKG], [test x"$enable_module_chilldkg" = x"yes"])
|
|
AM_CONDITIONAL([ENABLE_MODULE_ICEBERG], [test x"$enable_module_iceberg" = x"yes"])
|
|
AM_CONDITIONAL([ENABLE_MODULE_PREFRACTAL], [test x"$enable_module_prefractal" = x"yes"])
|
|
AM_CONDITIONAL([USE_REDUCED_SURJECTION_PROOF_SIZE], [test x"$use_reduced_surjection_proof_size" = x"yes"])
|
|
AM_CONDITIONAL([USE_EXTERNAL_ASM], [test x"$enable_external_asm" = x"yes"])
|
|
AM_CONDITIONAL([USE_ASM_ARM], [test x"$set_asm" = x"arm32"])
|
|
AM_CONDITIONAL([BUILD_WINDOWS], [test "$build_windows" = "yes"])
|
|
AC_SUBST(LIB_VERSION_CURRENT, _LIB_VERSION_CURRENT)
|
|
AC_SUBST(LIB_VERSION_REVISION, _LIB_VERSION_REVISION)
|
|
AC_SUBST(LIB_VERSION_AGE, _LIB_VERSION_AGE)
|
|
|
|
AC_OUTPUT
|
|
|
|
# The order in which all modules are listed here should be considered the
|
|
# canonical order. This order (or, when appropriate, its reserve) should be used
|
|
# everywhere we list or process modules, i.e., here and in other build system
|
|
# files and docs.
|
|
echo
|
|
echo "Build Options:"
|
|
echo " with external callbacks = $enable_external_default_callbacks"
|
|
echo " with benchmarks = $enable_benchmark"
|
|
echo " with tests = $enable_tests"
|
|
echo " with exhaustive tests = $enable_exhaustive_tests"
|
|
echo " with ctime tests = $enable_ctime_tests"
|
|
echo " with coverage = $enable_coverage"
|
|
echo " with examples = $enable_examples"
|
|
echo " module ecdh = $enable_module_ecdh"
|
|
echo " module recovery = $enable_module_recovery"
|
|
echo " module extrakeys = $enable_module_extrakeys"
|
|
echo " module schnorrsig = $enable_module_schnorrsig"
|
|
echo " module musig = $enable_module_musig"
|
|
echo " module ellswift = $enable_module_ellswift"
|
|
# libsecp256k1-zkp modules, in the order they were added to the libsecp256k1-zkp
|
|
echo " module generator = $enable_module_generator"
|
|
echo " module rangeproof = $enable_module_rangeproof"
|
|
echo " module surjectionproof = $enable_module_surjectionproof"
|
|
if test x"$enable_module_surjectionproof" = x"yes" && test x"$enable_reduced_surjection_proof_size" = x"yes"; then
|
|
echo " reduced proof size = $enable_reduced_surjection_proof_size"
|
|
fi
|
|
echo " module whitelist = $enable_module_whitelist"
|
|
echo " module ecdsa-s2c = $enable_module_ecdsa_s2c"
|
|
echo " module ecdsa-adaptor = $enable_module_ecdsa_adaptor"
|
|
echo " module bppp = $enable_module_bppp"
|
|
echo " module schnorrsig-halfagg = $enable_module_schnorrsig_halfagg"
|
|
echo " module frost = $enable_module_frost"
|
|
echo " module chilldkg = $enable_module_chilldkg"
|
|
echo " module iceberg = $enable_module_iceberg"
|
|
echo " module prefractal = $enable_module_prefractal"
|
|
echo
|
|
echo " asm = $set_asm"
|
|
echo " ecmult window size = $set_ecmult_window"
|
|
echo " ecmult gen table size = $set_ecmult_gen_kb KiB"
|
|
# Hide test-only options unless they're used.
|
|
if test x"$set_widemul" != xauto; then
|
|
echo " wide multiplication = $set_widemul"
|
|
fi
|
|
echo
|
|
echo " valgrind = $enable_valgrind"
|
|
echo " CC = $CC"
|
|
echo " CPPFLAGS = $CPPFLAGS"
|
|
echo " SECP_CFLAGS = $SECP_CFLAGS"
|
|
echo " CFLAGS = $CFLAGS"
|
|
echo " LDFLAGS = $LDFLAGS"
|
|
|
|
if test x"$print_msan_notice" = x"yes"; then
|
|
echo
|
|
echo "Note:"
|
|
echo " MemorySanitizer detected, tried to add -fno-sanitize-memory-param-retval to SECP_CFLAGS"
|
|
echo " to avoid false positives in ctime_tests. Pass --disable-ctime-tests to avoid this."
|
|
fi
|
|
|
|
if test x"$enable_experimental" = x"yes"; then
|
|
echo
|
|
echo "WARNING: Experimental build"
|
|
echo " Experimental features do not have stable APIs or properties, and may not be safe for"
|
|
echo " production use."
|
|
fi
|